@dtmd/temper 0.0.6 → 0.0.8

package/dist/src/declarations.js

@@ -9,7 +9,7 @@
  * in lockstep.
  */
 import { fileURLToPath } from "node:url";
-import { resolveLeaf } from "./prose.js";
+import { isTextSpan, resolveLeaf } from "./prose.js";
 /**
  * Compile one `Clause` into its lock row: the shared `key`/`field`/`severity`/
  * `guidance`/`cite` columns — the clause's four channels surviving erasure
@@ -17,7 +17,7 @@ import { resolveLeaf } from "./prose.js";
  * predicate carries them, the `count`/`target`/`degree` argument columns a
  * requirement's own set-/edge-scope demand needs, and the
  * `bound`/`charset`/`keys`/`values` argument columns a kind's own node-scope
- * floor clause needs (`min_len`/`max_len`/`max_lines`'s bound,
+ * floor clause needs (`min_len`/`max_len`/`extent`'s bound, `extent`'s unit,
  * `allowed_chars`'s charset, `forbidden_keys`'s keys, `deny`'s values) — so
  * the lock encodes the floor losslessly, not identity+severity alone. `kind`
  * is supplied only for a kind's own `expect` clause; a requirement's nested
@@ -25,6 +25,37 @@ import { resolveLeaf } from "./prose.js";
  */
 function clauseRow(clause, kind) {
     const { predicate } = clause;
+    // For a `when` clause, extract the guard predicate's key and arguments,
+    // then convert the body to nested rows.
+    if (predicate.key === "when") {
+        const guardPredicate = clause.when_guard;
+        if (!guardPredicate) {
+            throw new Error("when clause missing guard predicate");
+        }
+        // Build a row for the guard predicate's arguments, then copy those fields
+        // into this row alongside the guard_predicate and body.
+        const guardRow = clauseRow({ predicate: guardPredicate, severity: clause.severity }, undefined);
+        return {
+            kind,
+            predicate: "when",
+            severity: clause.severity,
+            guidance: clause.guidance,
+            cite: clause.cite,
+            field: guardRow.field,
+            guard_predicate: guardRow.predicate,
+            value_type: guardRow.value_type,
+            shape: guardRow.shape,
+            bound: guardRow.bound,
+            unit: guardRow.unit,
+            charset: guardRow.charset,
+            keys: guardRow.keys,
+            values: guardRow.values,
+            range: guardRow.range,
+            section: guardRow.section,
+            sections: guardRow.sections,
+            body: clause.when_body ? clause.when_body.map((c) => clauseRow(c, undefined)) : undefined,
+        };
+    }
     return {
         kind,
         predicate: predicate.key,
@@ -42,10 +73,14 @@ function clauseRow(clause, kind) {
                 outgoing: edgeBoundArgs(predicate.args, "outgoing"),
             }
             : undefined,
+        gate: predicate.key === "mention-reachable" ? predicate.gate : undefined,
+        value_type: predicate.key === "type" && predicate.value_type ? [...predicate.value_type] : undefined,
+        shape: predicate.key === "shape" ? predicate.shape : undefined,
         bound: nodeScopeBoundArgs(predicate),
-        // The generated rows carry mutable columns; the predicate's `charset`/`keys`/
-        // `values` are read-only, so copy each into a fresh array/object — the same
-        // bytes, a shape the row will accept.
+        unit: predicate.key === "extent" ? predicate.unit : undefined,
+        // The generated rows carry mutable columns; the predicate's `value_type`/
+        // `charset`/`keys`/`values` are read-only, so copy each into a fresh
+        // array/object — the same bytes, a shape the row will accept.
         charset: predicate.key === "allowed_chars" && predicate.charset !== undefined
             ? {
                 ranges: predicate.charset.ranges ? [...predicate.charset.ranges] : undefined,
@@ -62,13 +97,16 @@ function clauseRow(clause, kind) {
         section: predicate.key === "section_contains" && predicate.section !== undefined
             ? { heading: predicate.section.heading, marker: predicate.section.marker }
             : undefined,
+        sections: predicate.key === "require_sections" && predicate.sections
+            ? [...predicate.sections]
+            : undefined,
     };
 }
-/** `min_len`/`max_len`/`max_lines`'s scalar bound off their shared `min`/`max`
+/** `min_len`/`max_len`/`extent`'s scalar bound off their shared `min`/`max`
  * args keys — `undefined` for every other predicate, and for these three when
  * neither endpoint is present. */
 function nodeScopeBoundArgs(predicate) {
-    if (predicate.key !== "min_len" && predicate.key !== "max_len" && predicate.key !== "max_lines") {
+    if (predicate.key !== "min_len" && predicate.key !== "max_len" && predicate.key !== "extent") {
         return undefined;
     }
     const min = predicate.args?.min;
@@ -83,10 +121,10 @@ function edgeBoundArgs(args, direction) {
     return min === undefined && max === undefined ? undefined : { min, max };
 }
 /**
- * The lock label for a kind's declared unit shape: `file`/`directory` verbatim,
- * or `named-field(<identityField>)` for the third mode — the same `<name>(<field>)`
- * call syntax [`registrationLabel`] uses, so the id source round-trips through the
- * row rather than degrading to a bare, unreconstructable `"named-field"`.
+ * The lock label for a kind's declared unit shape: `file`/`directory`/`starred-segment`
+ * verbatim, or `named-field(<identityField>)` for the field-sourced mode — the same
+ * `<name>(<field>)` call syntax [`registrationLabel`] uses, so the id source round-trips
+ * through the row rather than degrading to a bare, unreconstructable `"named-field"`.
  */
 function unitShapeLabel(facts) {
     if (facts.unitShape !== "named-field")
@@ -108,6 +146,10 @@ function registrationLabel(registration) {
             return `event(${registration.field})`;
         case "connection":
             return "connection";
+        case "enablement":
+            return "enablement";
+        case "registry":
+            return "registry";
     }
 }
 /** The lock labels for a kind's declared registration **set**, in declaration order —
@@ -120,16 +162,28 @@ export function compareStrings(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
 /**
- * A host kind's declared nesting templates — the embedded kinds among `allKinds`
- * whose `withinHosts` names it, name-sorted. `undefined` when the host nests nothing, so the row omits the column
- * rather than carrying an empty array.
+ * A host kind's nesting templates, from its two declaration loci. The kind's own
+ * declared templates carry each layer — child kind, plus a file layer's path pattern.
+ * An adopting corpus that admits its own embedded kinds over the host overrides the
+ * *embedded* grain only: an admission names a host and a child kind but no path, so it
+ * can only speak for the pathless (embedded) layer. The path-carrying file layers the
+ * host declares are the host's own facts and stand, joined with the admitted rows —
+ * else composing a body over a host wipes its declared file layer and the engine, finding
+ * no file template, refuses the host's nested file children.
+ *
+ * `undefined` when nothing is declared or admitted, so the row omits the column rather
+ * than carrying an empty array.
  */
-function templatesFor(hostName, allKinds) {
-    const names = allKinds
-        .filter((facts) => facts.locus.kind === "embedded" && facts.locus.withinHosts.includes(hostName))
-        .map((facts) => facts.name)
-        .sort(compareStrings);
-    return names.length > 0 ? names : undefined;
+function templatesFor(facts, admissions) {
+    const declared = (facts.templates ?? []).map((template) => ({
+        kind: template.kind.key,
+        path: template.path,
+    }));
+    const admitted = [...(admissions.get(facts.name) ?? [])].sort(compareStrings);
+    if (admitted.length === 0)
+        return declared.length > 0 ? declared : undefined;
+    const fileLayers = declared.filter((template) => template.path !== undefined);
+    return [...fileLayers, ...admitted.map((kind) => ({ kind }))];
 }
 /**
  * Lower a kind's declared {@link Layout} into its `content` row — one flat
@@ -153,42 +207,100 @@ function contentRow(content) {
     return { regions };
 }
 /**
- * One kind's fact row — the `at` locus supplies `governs_root`/`governs_glob`,
- * `templates` names the embedded kinds (among `allKinds`) declared within it, and
- * `content` lowers a declared layout (absent for a `file`-content kind).
+ * Lower a kind's declared {@link CollectionAddress} into its `collection_address` row —
+ * `keyPath` spelled as the wire's snake_case `key_path`, and `entryShape` passed through
+ * as a string wire format (`object`, `scalar(field)`, or `group-array(member_key;lifted_fields)`).
+ * `undefined` for a file-locus kind, so its row omits the column and stays byte-identical.
+ */
+function collectionAddressRow(facts) {
+    if (facts.collectionAddress === undefined)
+        return undefined;
+    return {
+        manifest: facts.collectionAddress.manifest,
+        key_path: facts.collectionAddress.keyPath,
+        entry_shape: facts.collectionAddress.entryShape,
+    };
+}
+/**
+ * One kind's fact row — an `at` locus supplies `governs_root`/`governs_glob` and a
+ * nested-file kind neither (its path composes from its host's unit and the host
+ * template's pattern, so it governs no glob). A file locus's `commitment` class rides
+ * the same spelling, absent for the committed default. `templates` names the embedded kinds the
+ * corpus admits over it, and `content` lowers a declared layout (absent for a
+ * `file`-content kind). A registration kind extends the row with its `shape` marker and
+ * `collection_address`.
  */
-function kindFactRow(facts, allKinds) {
-    if (facts.locus.kind !== "at") {
-        // An embedded kind inherits its world residue through its host; it carries no
-        // `at` locus, so it takes no kind-fact row. Callers filter these out before this point.
+function kindFactRow(facts, admissions) {
+    if (facts.locus.kind === "embedded") {
+        // An embedded kind inherits its world residue through its host; it owns no unit at
+        // all, so it takes no kind-fact row. Callers filter these out before this point.
         throw new Error(`kind \`${facts.name}\` is embedded — it carries no locus-bearing kind fact.`);
     }
+    const governs = facts.locus.kind === "at" ? facts.locus : undefined;
     return {
         name: facts.name,
         provider: facts.provider,
-        governs_root: facts.locus.root,
-        governs_glob: facts.locus.glob,
+        governs_root: governs?.root,
+        governs_glob: governs?.glob,
+        commitment: governs?.commitment,
         format: facts.format,
         unit_shape: unitShapeLabel(facts),
         registration: registrationLabels(facts.registration),
-        templates: templatesFor(facts.name, allKinds),
+        templates: templatesFor(facts, admissions),
         content: contentRow(facts.content),
+        shape: facts.shape,
+        collection_address: collectionAddressRow(facts),
     };
 }
-/** Every kind in play, at any locus — member kinds ∪ expect kinds ∪ their embedded children. */
+/**
+ * Every kind in play, at any locus — member kinds ∪ expect kinds ∪ their embedded
+ * children — name-sorted, so every family derived from it inherits one stable order.
+ *
+ * The embedded children close transitively over both channels a host names one through:
+ * `admit` (the adopting corpus's declaration) and a path-less `templates` entry (the
+ * embedded layer). An embedded kind reaches the lock through its host's `templates`
+ * column rather than a row of its own, so those channels are the only way one is in play
+ * at all — and its declared edge fields are still owed their assembly facts.
+ *
+ * Only *embedded* children are drawn in. A path-carrying template is the nested-file
+ * layer, whose child owns a unit and reaches the lock through `expect` like any other
+ * unit kind; pulling one in here would forge it a kind-fact row it never declared.
+ */
 function kindsInPlay(harness) {
     const byName = new Map();
+    const pending = [];
+    const admit = (facts) => {
+        if (byName.has(facts.name))
+            return;
+        byName.set(facts.name, facts);
+        pending.push(facts);
+    };
     for (const member of harness.members)
-        byName.set(member.facts.name, member.facts);
+        admit(member.facts);
     for (const binding of harness.expect)
-        byName.set(binding.kind.facts.name, binding.kind.facts);
-    return [...byName.values()];
+        admit(binding.kind.facts);
+    for (const { admits } of harness.admit)
+        for (const child of admits)
+            admit(child.facts);
+    for (let facts = pending.pop(); facts !== undefined; facts = pending.pop()) {
+        for (const template of facts.templates ?? []) {
+            if (template.kind.facts.locus.kind === "embedded")
+                admit(template.kind.facts);
+        }
+    }
+    return [...byName.values()].sort((a, b) => compareStrings(a.name, b.name));
 }
-/** The distinct locus-bearing (`at`) kinds in play, name-sorted. */
+/** The distinct discoverable (`at`) kinds in play. */
 function atLocusKindsInPlay(allKinds) {
-    return allKinds
-        .filter((facts) => facts.locus.kind === "at")
-        .sort((a, b) => compareStrings(a.name, b.name));
+    return allKinds.filter((facts) => facts.locus.kind === "at");
+}
+/**
+ * The distinct unit-owning kinds in play — every locus but `embedded`. The kinds that
+ * take a fact row: a nested-file kind owns a file the engine must place, and places it
+ * off its row, though it governs no glob to be discovered at.
+ */
+function unitKindsInPlay(allKinds) {
+    return allKinds.filter((facts) => facts.locus.kind !== "embedded");
 }
 /** The requirement rows — assembly `require` and every member's `requires`, one namespace. */
 function requirementRows(harness) {
@@ -214,34 +326,56 @@ function requirementRows(harness) {
         .sort(([a], [b]) => compareStrings(a, b))
         .map(([name, requirement]) => ({
         name,
-        kind: requirement.kind?.key,
+        kind: typeof requirement.kind === "string" ? requirement.kind : requirement.kind?.key,
         required: requirement.required ?? false,
         clauses: (requirement.clauses ?? []).map((clause) => clauseRow(clause)),
-        verified_by: requirement.verifiedBy,
+        verifier: verifierRow(requirement.verifier),
         prose: requirement.prose,
     }));
 }
 /**
- * The assembly-scope facts, in a stable order: the root member's declared
- * `mode` (always present"The root
- * member": harness-wide declarations are root-member fields), then one edge
- * row per kind edge field.
+ * Lower a typed verifier to its species-tagged wire row — `species` plus the
+ * variant's own payload. The generated row carries a mutable `events` column, so
+ * the telemetry species copies its read-only names into a fresh array (the same
+ * read-only→mutable copy `charset`/`keys`/`values` make above).
+ */
+function verifierRow(verifier) {
+    if (verifier === undefined)
+        return undefined;
+    return verifier.species === "script"
+        ? { species: "script", path: verifier.path }
+        : { species: "telemetry", events: [...verifier.events] };
+}
+/**
+ * The assembly-scope facts, in a stable order: the root member's declared `mode`, then
+ * one edge row per kind edge field.
+ *
+ * `kinds` is every kind in play at *any* locus, not just the unit-owning ones that take
+ * a kind-fact row: an edge is a declared relationship at any grain, so an embedded
+ * kind's edge fields are owed their rows even though the kind itself reaches the lock
+ * through its host's `templates` column alone.
  */
 function assemblyFactRows(harness, kinds) {
     const facts = [{ fact: "mode", value: harness.mode }];
     for (const kind of kinds) {
         for (const edge of kind.edgeFields ?? []) {
-            facts.push({ fact: "edge", from: kind.name, field: edge.field, to: edge.to });
+            facts.push({ fact: "edge", from: kind.name, field: edge.field, to: [...edge.to] });
         }
     }
     return facts;
 }
-/** The `satisfies` rows — every member's fill claims, member-then-requirement sorted. */
+/**
+ * The `satisfies` rows — every member's fill claims, member-then-requirement sorted.
+ * The `member` is the filler's own `kind:name` address, the same identity
+ * `mentionRows` writes, so the read side joins on a kind-qualified label a same-named
+ * member of another kind can never collide with.
+ */
 function satisfiesRows(harness) {
     const rows = [];
     for (const member of harness.members) {
+        const address = `${member.kind}:${member.name}`;
         for (const requirement of member.satisfies) {
-            rows.push({ member: member.name, requirement });
+            rows.push({ member: address, requirement });
         }
     }
     return rows.sort((a, b) => compareStrings(a.member, b.member) || compareStrings(a.requirement, b.requirement));
@@ -249,25 +383,33 @@ function satisfiesRows(harness) {
 /**
  * The `mention` rows — every member's authored `n` targets, member-then-target
  * sorted. `text`-kind prose contributes one row per mention, keyed to the
- * member's own `kind:name` address; `blocks()`-kind prose additionally
- * contributes one row per mention inside a `Text`-authored leaf, keyed to that
- * leaf's own `<member>/<kind>/<key>/<child-path>` address
- * ([`embeddedLeafMentionRows`]) — a `file()` body names none. Recorded off the
- * raw authored address, unconditionally — resolution is `emit`'s own refusal
+ * member's own `kind:name` address. A `blocks()` composed body keys each child
+ * to what it is: a prose span's mentions are host-level, keyed to the member's
+ * own `kind:name` address like a `text` body; an embedded value's `Text`-leaf
+ * mentions are keyed to that leaf's own `<member>/<kind>/<key>/<child-path>`
+ * address ([`embeddedLeafMentionRows`]). A `file()` body names none. Recorded off
+ * the raw authored address, unconditionally — resolution is `emit`'s own refusal
  * (`emit.ts`), not this row's concern.
  */
 function mentionRows(harness) {
     const rows = [];
     for (const member of harness.members) {
+        const address = `${member.kind}:${member.name}`;
         if (member.prose?.kind === "text") {
-            const address = `${member.kind}:${member.name}`;
             for (const mention of member.prose.mentions) {
                 rows.push({ member: address, target: mention.target.address });
             }
         }
         if (member.prose?.kind === "blocks") {
             for (const value of member.prose.values) {
-                rows.push(...embeddedLeafMentionRows(member.name, value));
+                if (isTextSpan(value)) {
+                    for (const mention of value.mentions) {
+                        rows.push({ member: address, target: mention.target.address });
+                    }
+                }
+                else {
+                    rows.push(...embeddedLeafMentionRows(member.name, value));
+                }
             }
         }
     }
@@ -311,97 +453,263 @@ function embeddedLeafMentionRows(hostName, value) {
  * path resolved against the stating module ({@link fileURLToPath} over the include's own
  * `moduleUrl`), never the workspace — the engine reads, splices, and fingerprints it.
  * Member order stays authored (never target-sorted): the body's include slots ride the
- * same order, so the engine pairs the k-th slot with the k-th row. Only member-level
- * `text` prose carries includes (a `file()`/`blocks()` body names none; an embedded leaf
- * is refused at {@link resolveLeaf}).
+ * same order, so the engine pairs the k-th slot with the k-th row. Includes ride a `text`
+ * body and a composed body's prose spans alike, in authored order across the interleave; an
+ * embedded leaf carries none (refused at {@link resolveLeaf}) and a `file()` body names none.
  */
 function includeRows(harness) {
     const rows = [];
+    const push = (address, include) => {
+        rows.push({ member: address, source_path: fileURLToPath(new URL(include.path, include.moduleUrl)) });
+    };
     for (const member of harness.members) {
-        if (member.prose?.kind !== "text")
-            continue;
         const address = `${member.kind}:${member.name}`;
-        for (const include of member.prose.includes) {
-            rows.push({ member: address, source_path: fileURLToPath(new URL(include.path, include.moduleUrl)) });
+        if (member.prose?.kind === "text") {
+            for (const include of member.prose.includes)
+                push(address, include);
+        }
+        else if (member.prose?.kind === "blocks") {
+            for (const value of member.prose.values) {
+                if (!isTextSpan(value))
+                    continue;
+                for (const include of value.includes)
+                    push(address, include);
+            }
         }
     }
     return rows;
 }
+/**
+ * One composed embedded value's key in an {@link EdgePlacements} table — its host's
+ * `kind:name` address plus the value's own kind and key, the same triple the
+ * `nested_member` row it feeds is identified by.
+ */
+export function placementKey(host, kind, key) {
+    return `${host}${kind}${key}`;
+}
 /**
  * One host member's declared embedded-member value as its declaration row —
  * each `Text`-authored leaf resolved to its final stored string
- * ([`NestedMemberRow`]), mention-resolution-checked against `mentionable` the
- * identical way `emit.ts`'s `renderMemberToml` checks the same leaf on its way
- * into the rendered fence.
+ * ([`NestedMemberRow`]), mention-resolution-checked against `scope` the identical
+ * way `emit.ts`'s `renderMemberToml` checks the same leaf on its way into the
+ * rendered fence — plus the `placed_edges` record `emit` observed while rendering the
+ * same value, which is the only way an edge's placement reaches the engine.
  */
-function nestedMemberRow(host, value, mentionable) {
+function nestedMemberRow(host, value, scope, placements, extents) {
     const context = (childPath) => `member.${value.kind} ${value.key}: leaf \`${childPath}\``;
     const leaves = {};
     for (const [field, leaf] of Object.entries(value.leaves)) {
-        leaves[field] = resolveLeaf(leaf, mentionable, context(field));
+        leaves[field] = resolveLeaf(leaf, scope, context(field));
     }
     const collections = {};
     for (const [collection, entries] of Object.entries(value.collections)) {
         collections[collection] = entries.map((entry) => {
             const entryLeaves = {};
             for (const [field, leaf] of Object.entries(entry.leaves)) {
-                entryLeaves[field] = resolveLeaf(leaf, mentionable, context(`${collection}.${entry.key}.${field}`));
+                entryLeaves[field] = resolveLeaf(leaf, scope, context(`${collection}.${entry.key}.${field}`));
             }
             return { key: entry.key, leaves: entryLeaves };
         });
     }
-    return { host, kind: value.kind, key: value.key, leaves, collections };
+    const key = placementKey(host, value.kind, value.key);
+    const placed = placements?.get(key);
+    const extent = extents?.get(key);
+    return {
+        host,
+        kind: value.kind,
+        key: value.key,
+        leaves,
+        collections,
+        // Omitted, never `undefined`-valued: an absent column is the wire's own spelling of
+        // "no format placement was observed here", so a value with no edge to place keeps
+        // the row it has always written. The generated row carries a mutable column and the
+        // placement record is read-only, so the copy is a fresh array.
+        ...(placed === undefined ? {} : { placed_edges: [...placed] }),
+        // The rendered span, on the same omitted-not-null discipline: a value no render
+        // observed (compiled without `emit`'s measurement) keeps the row it has always
+        // written, and its `extent` reads as undecidable rather than a captured zero.
+        ...(extent === undefined ? {} : { rendered_lines: extent.lines, rendered_chars: extent.chars }),
+    };
 }
 /**
- * Every in-play embedded kind's declared host kinds, keyed by kind name — the map
- * {@link nestedMemberRows} checks a `blocks()` value's kind against. An embedded kind
- * reaches this map through `kindsInPlay` (a member of it, or an `expect` binding), and
- * its `withinHosts` is the set of host kinds it templates within; a value whose kind is
- * absent here, or whose hosts miss the hosting member's kind, is untemplated nesting.
+ * The corpus's `admit` declarations, indexed by host kind name — the one source both
+ * {@link templatesFor} and {@link nestedMemberRows} read. Admission carries kind values,
+ * so an admitted kind is imported and thereby in play; repeated hosts union.
+ *
+ * # Throws
+ * If an admission names a non-embedded kind: a body composes embedded members, and a
+ * file-locus kind owns a file instead — admitting one declares a nesting no locus backs.
  */
-function embeddedHostsByKind(harness) {
+function admissionsByHost(harness) {
     const map = new Map();
-    for (const facts of kindsInPlay(harness)) {
-        if (facts.locus.kind === "embedded") {
-            map.set(facts.name, new Set(facts.locus.withinHosts));
+    for (const { host, admits } of harness.admit) {
+        const admitted = map.get(host.key) ?? new Set();
+        for (const child of admits) {
+            if (child.facts.locus.kind !== "embedded") {
+                throw new Error(`host kind \`${host.key}\` admits \`${child.key}\`, which is not an embedded kind — ` +
+                    `a composed body admits embedded members only ` +
+                    `(specs/model/representation.md, "nesting").`);
+            }
+            admitted.add(child.key);
         }
+        map.set(host.key, admitted);
     }
     return map;
 }
 /**
  * The `nested_member` rows — every host member's `blocks()`-declared embedded-member
- * values, host-then-kind-then-key sorted. Only `blocks`-kind prose carries them (a
- * `file()`/`text` body names none); the fence rendering itself is unchanged
+ * values, host-then-kind-then-key sorted. Only a composed body's embedded values carry
+ * them (a `file()`/`text` body — and a composed body's prose spans — name none); the
+ * fence rendering itself is unchanged
  * (`emit.ts`'s `resolveBody`) — this row is a second *read* of the same authored
  * value, never a second copy the engine reads back (0018).
  *
- * Refuses an untemplated nesting before a byte is written: a value's kind must be an
- * in-play embedded kind whose `withinHosts` names the hosting member's kind. `templates`
- * derives solely from `withinHosts` ({@link templatesFor}), so a value the host never
- * templates would reach the lock as a `nested_member` row no `templates` column admits,
- * to be unmodeled without a word — nesting is the host template's own declaration, so an
- * unadmitted nested member is an unresolved input, not output to write over.
+ * Refuses an unadmitted nesting before a byte is written: the corpus must admit the
+ * value's kind over the hosting member's kind. `templates` derives from that same
+ * admission ({@link templatesFor}), so an unadmitted value would reach the lock as a
+ * `nested_member` row no `templates` column admits, to be unmodeled without a word —
+ * admission is the adopting corpus's own declaration, so an unadmitted nested member is
+ * an unresolved input, not output to write over.
  */
-function nestedMemberRows(harness, mentionable) {
-    const hostsByKind = embeddedHostsByKind(harness);
+function nestedMemberRows(harness, admissions, scope, placements, extents) {
     const rows = [];
     for (const member of harness.members) {
         if (member.prose?.kind !== "blocks")
             continue;
         const host = `${member.kind}:${member.name}`;
         for (const value of member.prose.values) {
-            const hosts = hostsByKind.get(value.kind);
-            if (hosts === undefined || !hosts.has(member.kind)) {
+            if (isTextSpan(value))
+                continue;
+            if (!admissions.get(member.kind)?.has(value.kind)) {
                 throw new Error(`member \`${member.name}\`: embedded value \`${value.key}\` is of kind ` +
                     `\`${value.kind}\`, which does not nest within host kind \`${member.kind}\` — a ` +
-                    `\`blocks()\` value's kind must be an in-play embedded kind whose \`withinHosts\` ` +
-                    `names the host (specs/model/representation.md, "nesting").`);
+                    `\`blocks()\` value's kind must be one the harness \`admit\`s over the host kind ` +
+                    `(specs/model/representation.md, "nesting").`);
             }
-            rows.push(nestedMemberRow(host, value, mentionable));
+            rows.push(nestedMemberRow(host, value, scope, placements, extents));
         }
     }
     return rows.sort((a, b) => compareStrings(a.host, b.host) || compareStrings(a.kind, b.kind) || compareStrings(a.key, b.key));
 }
+/**
+ * The `registration` rows — every fields-only registration member (a hook, an MCP server)
+ * erased for the manifest write face, kind-then-key sorted so double emit is byte-stable.
+ * Each carries its identity (`kind`/`key`), its collection address (`manifest`/`keyPath`,
+ * the wire's snake_case `key_path`), and its folded typed fields — the entry value the
+ * engine's write face places under `key`. The one source `emit.ts`'s public
+ * {@link RegistrationFact} view also maps from, so the seam and the `EmitResult` sibling
+ * cannot disagree on what a manifest carries.
+ *
+ * # Throws
+ * If a fields-only member declares no collection address — it surfaces in no host manifest.
+ */
+export function registrationRows(harness) {
+    return harness.members
+        .filter((member) => member.facts.shape === "fields")
+        .map((member) => {
+        const address = member.facts.collectionAddress;
+        if (address === undefined) {
+            throw new Error(`member \`${member.name}\`: a fields-only registration kind declares no ` +
+                `collection address — it surfaces in no host manifest (specs/model/pipeline.md, "The SDK").`);
+        }
+        return {
+            kind: member.kind,
+            key: member.name,
+            manifest: address.manifest,
+            key_path: address.keyPath,
+            // The generated row carries a mutable field list; the member's is read-only, so
+            // copy each pair into a fresh tuple — the same values, a shape the row accepts.
+            fields: member.fields.map(([name, value]) => [name, value]),
+        };
+    })
+        .sort((a, b) => compareStrings(a.kind, b.kind) || compareStrings(a.key, b.key));
+}
+/** The tap invocation the synthesized telemetry hooks run — the sibling verb of the
+ * session-start reporter, appending one event record to the per-machine log
+ * (`src/tap.rs`). Every synthesized hook's `command` field carries it verbatim. */
+const TAP_COMMAND = "temper tap";
+/**
+ * The `settings.json` lifecycle event and matcher one documented telemetry event-name
+ * projects its tap hook at. The event-name is the author-facing token a telemetry
+ * verifier names (`contract.ts`'s `telemetry`, the `roster.rs` admissibility set); the
+ * `event` is the `hooks.<Event>` key the tap registers under, and the `matcher` scopes
+ * the fire to the telemetry-relevant subset — each an external fact
+ * (code.claude.com/docs/en/hooks, retrieved 2026-07-17):
+ *
+ * - `InstructionsLoaded` fires on a rule/memory load; its matcher filters the load
+ *   reason, and `path_glob_match` is the lazy per-path load the coverage tap reads.
+ * - `Skill` is a skill invocation, surfaced under `PostToolUse` with the tool-name
+ *   matcher `Skill` — the tap's own read of a skill call.
+ * - `UserPromptExpansion` fires on a command expansion; its matcher filters the command
+ *   name, `.*` capturing every one.
+ * - `PostToolUse` fires after any tool call; its matcher filters the tool name, `.*`
+ *   capturing every one.
+ */
+const TELEMETRY_EVENT_HOOKS = {
+    InstructionsLoaded: { event: "InstructionsLoaded", matcher: "path_glob_match" },
+    Skill: { event: "PostToolUse", matcher: "Skill" },
+    UserPromptExpansion: { event: "UserPromptExpansion", matcher: ".*" },
+    PostToolUse: { event: "PostToolUse", matcher: ".*" },
+};
+/**
+ * The synthesized tap-hook `registration` rows — one deduped `hooks.<Event>`
+ * registration per (lifecycle event, matcher) any telemetry verifier names. Scans the
+ * same requirement sources {@link requirementRows} reads (assembly `require` ∪ each
+ * member's `requires`), keeps the telemetry-species verifiers ({@link Verifier}), and
+ * unions the lifecycle events they name into one dumb registration apiece: the tap
+ * records every fire and read time joins raw events to members, so however many
+ * verifiers name an event it takes exactly one hook — the derived-aggregate precedent
+ * the permission union sets ({@link permissionUnion}). Each row runs {@link TAP_COMMAND}
+ * under the event's documented matcher ({@link TELEMETRY_EVENT_HOOKS}); an event-name
+ * outside that table is the roster's inadmissibility finding, never a row.
+ */
+export function tapHookRows(harness) {
+    const deduped = new Map();
+    const collect = (requirement) => {
+        if (requirement.verifier?.species !== "telemetry")
+            return;
+        for (const name of requirement.verifier.events) {
+            const mapping = TELEMETRY_EVENT_HOOKS[name];
+            if (mapping !== undefined)
+                deduped.set(`${mapping.event}${mapping.matcher}`, mapping);
+        }
+    };
+    for (const requirement of Object.values(harness.require))
+        collect(requirement);
+    for (const member of harness.members) {
+        for (const requirement of Object.values(member.requires))
+            collect(requirement);
+    }
+    return [...deduped.values()]
+        .sort((a, b) => compareStrings(a.event, b.event) || compareStrings(a.matcher, b.matcher))
+        .map(({ event, matcher }) => ({
+        kind: "hook",
+        key: event,
+        manifest: SETTINGS_MANIFEST,
+        key_path: "hooks.<Event>",
+        fields: [
+            ["type", "command"],
+            ["command", TAP_COMMAND],
+            ["matcher", matcher],
+        ],
+    }));
+}
+/**
+ * The manifest Claude Code's harness-level settings reside in — the file the assembly's
+ * residual settings keys fold into as opaque residue, the same manifest the `hook` kind's
+ * registrations surface inside (code.claude.com/docs/en/settings, retrieved 2026-07-10).
+ */
+const SETTINGS_MANIFEST = "settings.json";
+/**
+ * The `settings` rows — the assembly's harness-level residual settings keys, each folded
+ * into the settings.json manifest's opaque residue at emit. Key-sorted so double emit is
+ * byte-stable. Seam-inbound: the value lives in the projected manifest, never the lock.
+ */
+export function settingsRows(harness) {
+    return Object.entries(harness.settings)
+        .map(([key, value]) => ({ manifest: SETTINGS_MANIFEST, key, value }))
+        .sort((a, b) => compareStrings(a.key, b.key));
+}
 /** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
 export function declaredRequirements(harness) {
     const set = new Set();
@@ -415,20 +723,56 @@ export function declaredRequirements(harness) {
 }
 /**
  * Every address a mention may name — declared requirement names ∪ each member's
- * `kind:name`. Shared by `emit.ts` (a member-level `Text` body's mentions) and
- * this module (an embedded member's `Text` leaves) — the one resolution-check
- * set, so a leaf mention and a member mention are held to the identical bar.
+ * `kind:name` ∪ each `blocks()`-declared embedded member's host-scoped
+ * `<host-kind>:<host-name>/<kind>/<key>` address. Shared by `emit.ts` (a
+ * member-level `Text` body's mentions) and this module (an embedded member's
+ * `Text` leaves) — the one resolution-check set, so a leaf mention and a member
+ * mention are held to the identical bar. The embedded address is host-scoped,
+ * never a flat `<kind>:<key>` — flat would force corpus-wide key uniqueness on
+ * embedded kinds.
  */
 export function declaredAddresses(harness) {
     const set = declaredRequirements(harness);
-    for (const member of harness.members)
+    for (const member of harness.members) {
         set.add(`${member.kind}:${member.name}`);
+        if (member.prose?.kind !== "blocks")
+            continue;
+        for (const value of member.prose.values) {
+            if (isTextSpan(value))
+                continue;
+            set.add(`${member.kind}:${member.name}/${value.kind}/${value.key}`);
+        }
+    }
     return set;
 }
-/** Compile a harness into its seven declaration families — the erased program. */
-export function compileDeclarations(harness) {
+/**
+ * Every discoverable (`at`-locus) kind the program declares — the deferral signal a
+ * dangling mention is measured against (`prose.ts`'s `defersToGate`): a mention naming
+ * one of these whose member is not a composed value defers to `check`, while a mention
+ * naming no declared kind refuses at emit. Member kinds ∪ `expect` kinds; an embedded
+ * kind is excluded — its members are composed within a host, never discovered, so a
+ * flat `kind:name` mention of one has no discovery locus to defer to.
+ */
+export function declaredAtLocusKinds(harness) {
+    return new Set(atLocusKindsInPlay(kindsInPlay(harness)).map((facts) => facts.name));
+}
+/** The full {@link MentionScope} the program resolves a mention against — its addresses and its deferral kinds. */
+export function mentionScope(harness) {
+    return { mentionable: declaredAddresses(harness), deferrableKinds: declaredAtLocusKinds(harness) };
+}
+/**
+ * Compile a harness into its seven declaration families — the erased program.
+ *
+ * `placements` and `extents` are `emit`'s record of what each embedded value's format
+ * rendered (`emit.ts`'s `edgePlacements`) and the span it spanned (`renderedExtents`); this
+ * pass compiles declarations and never renders, so it observes neither itself. Omitted,
+ * every `nested_member` row omits its `placed_edges`/`rendered_lines`/`rendered_chars`
+ * columns — honest (nothing observed a render) but undecidable for a `format-places-edges`
+ * or `extent` clause, so a whole compile goes through `emit`, never this alone.
+ */
+export function compileDeclarations(harness, placements, extents) {
     const allKinds = kindsInPlay(harness);
-    const kinds = atLocusKindsInPlay(allKinds);
+    const admissions = admissionsByHost(harness);
     const clauses = [];
     for (const binding of [...harness.expect].sort((a, b) => compareStrings(a.kind.key, b.kind.key))) {
         for (const clause of binding.clauses) {
@@ -436,14 +780,16 @@ export function compileDeclarations(harness) {
         }
     }
     return {
-        kinds: kinds.map((facts) => kindFactRow(facts, allKinds)),
+        kinds: unitKindsInPlay(allKinds).map((facts) => kindFactRow(facts, admissions)),
         clauses,
         requirements: requirementRows(harness),
-        assembly: assemblyFactRows(harness, kinds),
+        assembly: assemblyFactRows(harness, allKinds),
         satisfies: satisfiesRows(harness),
         mentions: mentionRows(harness),
         includes: includeRows(harness),
-        nested_members: nestedMemberRows(harness, declaredAddresses(harness)),
+        nested_members: nestedMemberRows(harness, admissions, mentionScope(harness), placements, extents),
+        registrations: [...registrationRows(harness), ...tapHookRows(harness)],
+        settings: settingsRows(harness),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */