Non-error diagnostics (for example `markdown.inert_executable` for a would-be
execution node outside any function body) are now printed to stderr before
execution and included in `--json` run output, instead of being silently
hidden on a successful run.
Findings from the conformance corpus workstream, all fixed at the source:
- value/wire: enable serde_json's float_roundtrip so typed wire floats keep
their exact digits across foreign/plugin boundaries (Python pi*9 now stays
28.274333882308138).
- host: default interpreter stack budget lowered to 128 frames so deeply
recursive documents hit a structured resource.exhausted instead of exhausting
the native debug-build Rust stack; --stack remains available.
- frontend/map: calling an external HTTP(S) link is reported as ref.unresolved
(consistent with other unresolvable call targets) instead of math.unsupported.
- frontend/analyze: invalid front matter emits a single frontmatter.invalid
diagnostic (the YAML error is not repeated by the imports pass).
- spec/mapping: clarify that would-be execution nodes outside any function body
are inert with a markdown.inert_executable warning (no "return outside a
function" hard-error claim).
- tests: add the conformance corpus and harness (150 AST goldens, 36 semantic
goldens, 48 hard-error + 6 warning + 10 runtime-error negatives, CLI/module/
plugin integration tests, prose-invariance properties) and update the
three reported observations to the fixed behaviour.
Blueprint section 4.2: reference edges are static, never execution.
- For every loaded document, resolve same-document anchors, relative file
links and target anchors (analysing referenced files statically without
executing them); unresolved targets produce `ref.unresolved` errors with
source spans.
- External HTTP(S) links are treated as external references, not errors.
- `inspect --refs` continues to print the resolved edge graph as JSON.
Blueprint section 10 / P6: exports of an explicitly trusted plugin are callable
from a `.mq.md` file through a bound namespace.
- host: StdHost::load_plugin requires an explicit trust decision and a granted
plugin capability, loads the native artifact through the ABI v1 loader with
no capability handler (all plugin host-capability requests denied), and
dispatches HostOp::PluginInvoke through the typed wire request/response.
In-process native code is documented as sharing the host address space; no
isolated worker transport exists in this build.
- runtime: a qualified call whose base is not a local value, import alias or
builtin namespace is routed to the plugin namespace; plugin calls take named
arguments only and plugin values become Marqdo values (Unit when absent).
- cli: run/call gain `--plugin <path>`, `--trust-native-plugin` and reuse
`--allow-plugin <package>`; missing trust/grant/loaded namespace surface as
structured errors.
- frontend: member-call bases are namespaces (builtin/import/plugin), never
inferred parameters, so `solver.add(...)` does not invent a parameter.
- `marqdo add <name> --path <dir>` / `--git URL --rev SHA` and
`marqdo remove <name>` edit marqdo.yaml only after validating the dependency
source (path-relative, git pinned by exact rev, no duplicate entry).
Removing a dependency also drops its stale lock entry; locking stays an
explicit step so no version changes happen silently.
- Manifest serialization omits empty dependency/plugin maps and empty
capability requests, keeping generated manifests readable and stable.
`inspect --ast` and AST goldens now show `{"kind":"heading","level":2,...}`
instead of a nested `{"kind":{"kind":"heading",...}}` object, matching
spec/markdown-profile.md section 5 and the shape new contributors expect.
- calls: validate_program runs after a whole project is loaded and checks
qualified calls through explicit import aliases against the imported module's
signatures (missing function, missing/unknown arguments), plus qualified
builtin calls such as math.eval; local calls stay checked by
validate_module so diagnostics are not duplicated.
- infer: `math.eval(...)` / `foreign.call(...)` callee namespaces are builtin
namespaces, not free variable reads, so they no longer become inferred
parameters or unknown-variable errors. Explicit signatures behave likewise.
Blueprint section 8, minimum viable P3:
- marqdo.yaml parsing/validation: project identity, dependency sources (path or
git with mandatory exact rev), plugin requirements, capability requests;
absolute dependency paths, ambiguous sources and unpinned git are errors.
- marqdo.lock: lock_version, sorted packages, canonical YAML with no
timestamps or machine paths so repeated locking is byte-identical.
- discover_root walks up to the nearest marqdo.yaml.
- Manifest::template for `marqdo init`.
Blueprint section 10: a first-class plugin ABI independent of the legacy
MARQDO_ABI_VERSION=2, with a C ABI that is explicitly not a sandbox.
- include/marqdo_plugin_abi_v1.h: frozen stable-layout C contract with
documented buffer ownership/lifetimes, size limits, NULL/zero-length
semantics, single-threaded invocation, no hot-unload policy, version
negotiation and target-triple requirements.
- marqdo-plugin-abi (host side): repr(C) mirrors with compile-time layout
assertions, major/minor negotiation (wrong major fails, minor clamps),
plugin.yaml parsing/validation, target selection and sha256 artifact
verification, wire_version 1 typed JSON request/response envelopes,
structured PluginError, and a libloading-based loader with host alloc/free,
export registration and runtime ABI re-negotiation.
- marqdo-plugin-sdk (plugin side): mq_plugin_entry! macro, panic containment,
safe byte-buffer wrappers, capability/logging context and JSON helpers; it
depends only on the shared ABI crate.
- examples/plugin-demo: dependency-free C plugin (solver.add), manifest,
build.sh that refreshes the artifact hash, README explaining that install,
inspect and load are three different trust decisions.
- Tests: C plugin cross-compiled with cc and loaded, plus wrong ABI major,
missing symbol/artifact, hash mismatch and malformed manifest cases.
Marqdo-math: limited, documented LaTeX-subset kernel (blueprint section 5).
- Exact BigRational arithmetic, structured Float only for irrational results;
Int result when exact; bounds on exponents, source size, AST nodes and result
bits so hostile input cannot hang or exhaust memory.
- Supports numbers, Unicode identifiers, \pi/\e, + - * / ^, \frac, \sqrt,
\cdot/\times, braces, parentheses, one '=' equation, and linear solving for a
target variable (F=ma solved for F/m/a).
- Unsupported constructs are structured errors; the kernel never claims any
mathematical proof.
Marqdo-foreign: explicit kernels (blueprint section 6).
- run/call/detect only; reading a document never spawns a process.
- Direct exec of python3/python/node with a temp program file, clear env,
private cwd, JSON request envelope on stdin, captured bounded stdout/stderr,
wall-clock timeout with kill, typed wire decoding for call, structured
ForeignError for spawn/protocol/timeout/oversized output.
- Process isolation only: crate docs state this is not a strict OS sandbox.
Implements the single side-effect boundary from blueprint sections 7.3 and 9:
- Capabilities: console/math, project-relative fs globs, net hosts, process,
foreign, plugins; pure/project defaults deny external I/O and grants are
explicit, checked at execution time (never at parse time).
- Budget: evaluation fuel, call-stack depth, program output bytes and a
wall-clock deadline, all reported as resource.exhausted.
- EffectTrace: op/module/span/duration/result entries with no secret data.
- StdHost: canonical Host implementation dispatching print, fs read/write and
the math/foreign kernels; all errors are structured RuntimeErrors, including
a permission.denied path with a grant hint.
- ProjectFs: project-rooted, rejects absolute paths, `..` traversal and symlink
escapes outside the root; bounded UTF-8 reads and safe writes.
- Math adapter: parse/eval/substitute through marqdo-math with exact rational
binding conversion and explicit unsupported-operation errors.
- Foreign adapter: capability-gated one-shot run/call through marqdo-foreign,
typed wire input, structured result map, timeout/output limits mapped to
budget errors.
Blueprint section 9: advertise a security guarantee only when it can be
enforced.
- SandboxMode pure/project/strict with stable names.
- PlatformCapabilities detection reports strict isolation as unavailable in
this build with an explicit reason; worker processes are reported false.
- enforce() refuses strict mode when OS-level isolation is not implemented,
instead of pretending a cooperative in-process check is a sandbox.
- Pure/project modes remain available.
- value: add ErrorCategory::RefAmbiguous (code ref.ambiguous) for the S-07 rule
that a reference matching several resources must never silently pick the
first one; re-export float/integer conversion helpers at the crate root.
- ir/builtins: math/foreign calls accept positional arguments followed by named
ones (matching the documented examples) instead of being named-only; arity
and unknown-name validation still apply.
- tests updated for the new builtin call shape.
Implement the P0/P1 frontend from spec/mapping.md, spec/evaluation.md:
- units: heading scope index (level-1 namespace, level-2 function, level>=3
section), range computation, duplicate/empty-name diagnostics, GitHub anchor
table kept separate from canonical ids, and warnings for would-be execution
nodes outside function bodies.
- map: AST-to-IR mapping where role comes from node kind + position. Strong is
an execution statement, Emph a return, ordered list a branch, bullet list a
loop sequence, block quote a call; invalid shapes are hard
markdown.invalid_construct errors, never prose fallback. Payload parsing
errors are mapped from payload-relative to file-relative spans.
- payload: strict text/code payload concatenation with exact span mapping
(including code-span delimiter handling) used to rewrite expression spans
onto the source file.
- signature: optional `(name: Type = const)` paragraph declaration; defaults
must be compile-time constants; duplicates and malformed declarations are
errors.
- infer: definite-assignment data-flow parameter inference (must/may/ambiguous
states, loop first-iteration handling, branch joins) per blueprint S-04.
- calls: static call validation of arity/named arguments/builtin signatures
after all signatures are known; inferred signatures accept named args only.
- resources: inert Formula/Code resources with owning units and SHA-256
content hashes.
- analyze: pipeline (parse -> units -> frontmatter imports -> map -> signature/
inference -> module -> call checks) that never executes anything.
Tests include factorial recursion, loop counter, prose-invariance (IR equal
modulo spans), and hard-error cases.
- md code nodes now carry `ticks` (delimiter length) so executable payload
offsets inside code spans map back to exact source bytes instead of pointing
at backticks; this keeps diagnostics precise for mixed text/code payloads.
- value: add the markdown.inert_executable warning code and a small clippy fix,
without changing the wire format.
- spec: document the code-span tick metadata, declare strikethrough lazy, and
make the inert-execution warning explicit for nodes outside any function.
- workspace dependencies: add unicode-ident (grammar) and glob (capability
path patterns) for the frontend/host layers.
Tests: 15 markdown + 10 value + 2 span tests pass; fmt/clippy clean.
Add the independent program IR from blueprint sections 7.1 and 11:
- ModuleId, FunctionId and UnitId canonical identities; UnitInfo/UnitKind for
heading scopes (root, namespace, function, section).
- Function with explicit or inferred signature metadata, params and defaults;
assignments, expression statements, link-form calls, branches, loops and
returns, all carrying source spans.
- CallTarget distinguishes same-module, import-alias-qualified and
link-resolved calls.
- ImportDecl from explicit front-matter imports; Resource records inert
Formula/Code artifacts with SHA-256 content hashes and owning units.
- Module anchors, resolved import edges and Program lookup helpers used by the
runtime and CLI.
- Builtin registry (names, aliases, arity, named-only/effect flags) shared by
static validation and runtime dispatch; adding a builtin is a spec change.
Prose is absent from the IR by construction, so narrative edits cannot change
the executable projection.
Implement the independent expression parser frozen in spec/expression.ebnf:
- Unicode XID identifiers (Chinese names supported), reserved keywords
true/false/None/and/or/not.
- Arbitrary-precision Int literals, binary64 Float literals (digits required on
both sides, overflow rejected), double-quoted Text with \u{...} escapes.
- List and record literals, calls with positional-then-named arguments and
trailing commas, member access, indexing, chained postfix operators.
- Precedence exactly as specified: right-associative ** with unary minus
binding outside, multiplicative/additive, single non-associative comparison,
short-circuit and/or.
- Assignment only as `identifier = expression` at statement start; no comments,
no second Markdown parser, max nesting depth 128 with structured errors.
- parse_expression/parse_statement/parse_arguments never panic; ParseError has
stable code expr.parse, payload-relative byte spans and Display/Error.
50 unit tests + 2 doctests, cargo fmt/clippy clean.
P0 baseline: one Markdown parser, one frozen option set, no silent upgrades.
- profile: CommonMark 0.31.2 core + GFM tables/strikethrough/task lists +
dollar math + YAML front matter at byte 0, with every other extension
disabled and asserted by tests. comrak is pinned to exactly 1.0.0.
- ast::MdNode: owned, serializable node tree carrying kind, byte Span and
literal payloads. Nodes outside the profile are preserved as MdKind::Other
instead of being dropped; task list items keep their checkbox state.
- frontmatter: extracts the YAML body from the parser node, parses it once,
and exposes only the explicit `import` alias mapping; invalid YAML is
reported, never guessed.
- text: strict executable payload extraction (Text/Code only, everything else
is a hard error) and inert plain-text extraction for heading names.
- UTF-8 BOM is tolerated; all spans are re-based onto the original file.
No semantic mapping or execution exists in this crate by design.
Implements the shared data contract from blueprint sections 3.4, 7.2 and 10.3:
- Value: Unit/None/Bool/Int(BigInt)/Float/Text/List/Map/Table/Formula/Code/
FunctionRef/PluginHandle; Unit and None stay distinct and there is no
implicit string/number coercion.
- Diagnostic with stable machine-readable codes (markdown.invalid_construct,
expr.parse, symbol.unknown, permission.denied, ...) and span/related/hints.
- RuntimeError with category codes and call frames; renders to a Diagnostic.
- Versioned, type-tagged JSON wire format (wire_version = 1) that keeps
arbitrary-precision integers as decimal strings, tags NaN/Infinity, enforces
depth/size limits on untrusted input and never trusts JSON numbers for Int.
- Byte spans and line/column mapping live in the new marqdo-span crate.
Create the Marqdo CLI Rust workspace with the module boundaries from the
development blueprint (section 11):
- marqdo-span: byte spans and line/column mapping shared by every layer
- marqdo-value, marqdo-expression, marqdo-markdown, marqdo-ir
- marqdo-frontend, marqdo-runtime, marqdo-host, marqdo-sandbox
- marqdo-math, marqdo-foreign, marqdo-package
- marqdo-plugin-abi, marqdo-plugin-sdk
- marqdo-cli (binary `marqdo`)
Pin the Markdown parser exactly (comrak =1.0.0, no default features) so the
frozen profile can never drift silently. Dependencies are centralized in
workspace.dependencies; no crate is allowed to add its own version of a shared
dependency.