Owned Dynamic benchmark values

The closed zerglang.benchmark-exec/4 request invokes checked Core-1 interpreted Algorithm messages with complete Dynamic parameter and result signatures. It uses the existing public owned runtime, not a host-side oracle or source rewriting. Only the interpreter and reflect effect/capability subset are admitted. Other signatures/tiers remain explicit gaps; stable activation is unchanged.

Required request fields are schema, operation: "dynamic", source_path, edition: "core-1", the cumulative preview, a fully qualified public root selector, executor: "algorithm-interpreter", arguments, and authority. arguments contains 0–32 lowercase-hex canonical ZLD2 frames; the checked signature must have exactly that arity. Each frame/result, including its header, is limited to 16,384 bytes. Existing total request and process-output bounds remain 65,536 bytes. Results never silently truncate.

authority is exactly none or reflect. The host issues a live reflect capability only for an explicit reflect request. A source effect never creates authority. Missing authority for an actual lookup remains a language failure. Arguments remain host-owned; the runtime clones them and returns an owned result. Arguments, results, frames and capabilities are released on all exit paths.

Optional source_files uses the complete package-closure rules, including path/module correspondence, exact root selection, all-source checking, confinement and aggregate limits. Imported calls execute the checked root artifact and preserve transitive effects and ownership. Revisions 1–3 retain valid request behavior, including revision 1’s fixed record-lookup seam and bare-name aliases. Revision 4 requires an exact fully qualified selector, not a bare alias.

Linked private late-lookup intrinsics retain their behavior after the package linker wraps their names. The evaluator unwraps complete length-prefixed module/type/selector records before matching the reserved intrinsic; it does not treat a name suffix as authority. Lookup still checks the caller’s declared effect and the separately supplied live capability. Compiled internal callees may receive and return opaque Dynamic values. The public root remains interpreted; this transfer support does not imply Dynamic native/JIT support and does not change earlier source or artifact encodings. The dynamic-linkage mutation gate and generated one-to-four-hop package calls cover lookup, missing authority and argument selection.

The separately versioned explicit source matching extension adds closed-tag matching in compiled/interpreted callees, including scoped Bool and Int64 bindings, through ZLM2 2.21 / ZLA2 1.13. Request revision 4 is unchanged. Matching runs through the checked owned runtime, preserves authority boundaries, and shares an instruction budget across calls. It does not enable native tiers.

The result envelope remains zerglang.benchmark-result/1. A successful result has exactly kind: "dynamic-zld2" and hex. Wrong request identity/authority is ZL-BENCH-REQUEST; wrong arity is ZL-BENCH-ARGUMENTS; malformed/oversized frames are ZL-BENCH-DYNAMIC-VALUE. Invalid JSON remains ZL-BENCH-JSON. Checked source diagnostics are preserved. Runtime failures without a source diagnostic use ZL-BENCH-DYNAMIC and retain the numeric Dynamic error in the message.

Typed runner mapping

New case inputs contain exactly two record fields: arguments, a record whose names exactly match execution.input_order, and authority, text none or reflect. Transmission follows that explicit argument order. The legacy record_key/record_value/lookup_key shape still selects revision 1.

Benchmark value	Dynamic tag
Empty variant with case null	null
Bool	bool
Integer in Int64 range	i64
Float with exact binary64 bits	f64
Text	text
Sequence	list
Record	record

Unit, Bytes, other variants, binary32 and out-of-range integers do not implicitly convert. Null is not Unit. Text permits valid UTF-8 and embedded NUL; record names must be NUL-free, unique and sorted by UTF-8 bytes in transport. Binary64 bits, including negative zero and NaN payloads, are preserved without floating- point arithmetic. Recursive depth is at most 128, matching native ZLD2.

The independent Python codec checks the existing ZLD2 2.0 header, exact payload length, SHA-256 digest, closed tags, boolean bits, scalar widths, UTF-8, child counts, record order, nesting and absence of trailing bytes. No Dynamic wire revision is introduced. Scoring compares canonical typed values: text "7" cannot equal integer 7, including inside aggregates. Malformed output is an infrastructure error; valid wrong values or extra result fields fail behavior. Property oracles retain the existing isolated complete-response boundary.

Acceptance uses benchmark.dynamic_arguments, benchmark.dynamic_codec, and tests/properties/test_dynamic_transport.py: independent wire vectors, real owned calls, imported roots, public/held-out inputs, tag-sensitive scoring, capability/profile failures, bounds and recursive cross-runtime/permutation properties. This does not promote any fixture or alter ZL256/ZL512 allocation, publication policy. Matching grammar and its new checked-artifact minor are covered separately by benchmark.dynamic_match and its property/mutation gates.