@dtmd/temper 0.0.3 → 0.0.6

package/dist/src/declarations.d.ts

@@ -1,68 +1,35 @@
 /**
- * Declaration rows — the composed program's erased declarations
- * (`specs/architecture/20-surface.md`, "The seam — one implementation"; "The lock
- * and drift"). Every type erases at the seam: kinds, clauses, requirements, and
- * assembly facts compile to plain rows the engine reads. The **row shape** matches
- * the Rust lock's `[declaration]` families (`src/drift.rs` `Declarations`) — the
- * byte-parity lockstep two writers keep until single-writer lands
- * (`SDK-RECUT-CORPUS-FACE`). The same rows ride the internal versioned JSON pipe
- * ({@link declarationsToJson}) — not a designed IR, versioned in lockstep.
+ * Declaration rows — the composed program's erased declarations.
+ * Every type erases at the seam: kinds, clauses, requirements, and
+ * assembly facts compile to plain rows the engine reads. The **row shapes are the
+ * generated `ts-rs` bindings** (`./generated/`, derived from `src/drift.rs`), so a
+ * Rust-side row rename is a compile error here, never a silent shape drift. This
+ * module authors the builders that fill them; the same rows ride the internal
+ * versioned JSON pipe ({@link encodeSeam}) — not a designed IR, versioned
+ * in lockstep.
  */
 import type { Harness } from "./assembly.js";
-/** One kind's declaration row — its identity and declared runtime facts. */
-export interface KindFactRow {
-    readonly name: string;
-    readonly provider?: string;
-    readonly governs_root: string;
-    readonly governs_glob: string;
-    readonly format?: string;
-    readonly unit_shape?: string;
-    readonly activation?: string;
-}
-/** One clause of a kind's effective contract, reduced to the lock's columns. */
-export interface ClauseRow {
-    readonly kind: string;
-    readonly predicate: string;
-    readonly field?: string;
-    readonly severity: string;
-}
-/** One named requirement's declaration row, reduced to the scalar facets the lock records. */
-export interface RequirementRow {
-    readonly name: string;
-    readonly kind?: string;
-    readonly package?: string;
-    readonly required: boolean;
-    readonly verified_by?: string;
-}
-/** One assembly-scope fact — authority, reachability, or an edge. */
-export interface AssemblyFactRow {
-    readonly fact: string;
-    readonly value?: string;
-    readonly from?: string;
-    readonly field?: string;
-    readonly to?: string;
-}
-/** One member→requirement fill edge — a resolved `satisfies` key. */
-export interface SatisfiesRow {
-    readonly member: string;
-    readonly requirement: string;
-}
-/** The five declaration families — the whole erased program the lock and pipe carry. */
-export interface Declarations {
-    readonly kinds: readonly KindFactRow[];
-    readonly clauses: readonly ClauseRow[];
-    readonly requirements: readonly RequirementRow[];
-    readonly assembly: readonly AssemblyFactRow[];
-    readonly satisfies: readonly SatisfiesRow[];
-}
-/** Compile a harness into its five declaration families — the erased program. */
+import type { Declarations, Payload } from "./generated/index.js";
+export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./generated/index.js";
+/** The stable-sort ordering every declaration row family shares. */
+export declare function compareStrings(a: string, b: string): number;
+/** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
+export declare function declaredRequirements(harness: Harness): Set<string>;
+/**
+ * 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.
+ */
+export declare function declaredAddresses(harness: Harness): Set<string>;
+/** Compile a harness into its seven declaration families — the erased program. */
 export declare function compileDeclarations(harness: Harness): Declarations;
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
-export declare const SEAM_VERSION = 1;
+export declare const SEAM_VERSION = 2;
 /**
- * Serialize the declaration rows to the internal versioned JSON pipe
- * (`20-surface.md`, "The seam"). Not a designed IR — a stable public interchange
- * is admitted only when its consumer lands. Deterministic: insertion-ordered keys
- * and a trailing newline, so a re-emit is byte-identical (law 5).
+ * Serialize the seam payload to the internal versioned JSON pipe — `encodeSeam`
+ * stamps `version`, so the caller supplies the rest of the {@link Payload}.
+ * Deterministic: insertion-ordered keys and a trailing newline, so a re-emit is
+ * byte-identical.
  */
-export declare function declarationsToJson(declarations: Declarations): string;
+export declare function encodeSeam(payload: Omit<Payload, "version">): string;

package/dist/src/declarations.js

@@ -1,18 +1,105 @@
 /**
- * Declaration rows — the composed program's erased declarations
- * (`specs/architecture/20-surface.md`, "The seam — one implementation"; "The lock
- * and drift"). Every type erases at the seam: kinds, clauses, requirements, and
- * assembly facts compile to plain rows the engine reads. The **row shape** matches
- * the Rust lock's `[declaration]` families (`src/drift.rs` `Declarations`) — the
- * byte-parity lockstep two writers keep until single-writer lands
- * (`SDK-RECUT-CORPUS-FACE`). The same rows ride the internal versioned JSON pipe
- * ({@link declarationsToJson}) — not a designed IR, versioned in lockstep.
+ * Declaration rows — the composed program's erased declarations.
+ * Every type erases at the seam: kinds, clauses, requirements, and
+ * assembly facts compile to plain rows the engine reads. The **row shapes are the
+ * generated `ts-rs` bindings** (`./generated/`, derived from `src/drift.rs`), so a
+ * Rust-side row rename is a compile error here, never a silent shape drift. This
+ * module authors the builders that fill them; the same rows ride the internal
+ * versioned JSON pipe ({@link encodeSeam}) — not a designed IR, versioned
+ * in lockstep.
  */
-/** The lock label for a kind's declared registration — the activation spelling. */
-function activationLabel(registration) {
+import { fileURLToPath } from "node:url";
+import { 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
+ * — plus, when the
+ * 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,
+ * `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
+ * clause carries none.
+ */
+function clauseRow(clause, kind) {
+    const { predicate } = clause;
+    return {
+        kind,
+        predicate: predicate.key,
+        field: predicate.field,
+        severity: clause.severity,
+        guidance: clause.guidance,
+        cite: clause.cite,
+        count: predicate.key === "count"
+            ? { min: predicate.args?.min ?? 0, max: predicate.args?.max ?? Number.MAX_SAFE_INTEGER }
+            : undefined,
+        target: predicate.key === "membership" ? predicate.target : undefined,
+        degree: predicate.key === "degree"
+            ? {
+                incoming: edgeBoundArgs(predicate.args, "incoming"),
+                outgoing: edgeBoundArgs(predicate.args, "outgoing"),
+            }
+            : 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.
+        charset: predicate.key === "allowed_chars" && predicate.charset !== undefined
+            ? {
+                ranges: predicate.charset.ranges ? [...predicate.charset.ranges] : undefined,
+                chars: predicate.charset.chars,
+            }
+            : undefined,
+        keys: predicate.key === "forbidden_keys" && predicate.keys ? [...predicate.keys] : undefined,
+        values: (predicate.key === "deny" || predicate.key === "enum") && predicate.values
+            ? [...predicate.values]
+            : undefined,
+        range: predicate.key === "range" && predicate.range !== undefined
+            ? { min: predicate.range.min, max: predicate.range.max }
+            : undefined,
+        section: predicate.key === "section_contains" && predicate.section !== undefined
+            ? { heading: predicate.section.heading, marker: predicate.section.marker }
+            : undefined,
+    };
+}
+/** `min_len`/`max_len`/`max_lines`'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") {
+        return undefined;
+    }
+    const min = predicate.args?.min;
+    const max = predicate.args?.max;
+    return min === undefined && max === undefined ? undefined : { min, max };
+}
+/** One `degree` direction's `{min, max}` off its flat `<dir>_min`/`<dir>_max` args
+ * keys — `undefined` when neither is present (that direction is unconstrained). */
+function edgeBoundArgs(args, direction) {
+    const min = args?.[`${direction}_min`];
+    const max = args?.[`${direction}_max`];
+    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"`.
+ */
+function unitShapeLabel(facts) {
+    if (facts.unitShape !== "named-field")
+        return facts.unitShape;
+    return `named-field(${facts.identityField})`;
+}
+/** The lock label for one declared registration channel. */
+function registrationLabel(registration) {
     switch (registration.via) {
         case "always":
             return "always";
+        case "user-invoked":
+            return "user-invoked";
         case "description-trigger":
             return `description-trigger(${registration.field})`;
         case "paths-match":
@@ -23,13 +110,58 @@ function activationLabel(registration) {
             return "connection";
     }
 }
-/** One kind's fact row — the `at` locus supplies `governs_root`/`governs_glob`. */
-function kindFactRow(facts) {
+/** The lock labels for a kind's declared registration **set**, in declaration order —
+ * `undefined` for an empty set, the same omit-the-column tolerance `templatesFor` takes. */
+function registrationLabels(registration) {
+    return registration.length > 0 ? registration.map(registrationLabel) : undefined;
+}
+/** The stable-sort ordering every declaration row family shares. */
+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.
+ */
+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;
+}
+/**
+ * Lower a kind's declared {@link Layout} into its `content` row — one flat
+ * discriminator-plus-columns [`LayoutRegionRow`] per region, `memberKind` spelled as the
+ * wire's snake_case `member_kind`. `undefined` for a `file`-content kind (no declared
+ * content), so its row omits the column and stays byte-identical.
+ */
+function contentRow(content) {
+    if (content === undefined)
+        return undefined;
+    const regions = content.regions.map((region) => {
+        switch (region.region) {
+            case "prose":
+                return { region: "prose", import: region.import };
+            case "field":
+                return { region: "field", slot: region.slot };
+            case "collection":
+                return { region: "collection", member_kind: region.memberKind, key: region.key };
+        }
+    });
+    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).
+ */
+function kindFactRow(facts, allKinds) {
     if (facts.locus.kind !== "at") {
-        // A genre inherits its world residue through its host; it carries no `at`
-        // locus, so it takes no kind-fact row (`15-kinds.md`). Callers filter these
-        // out before this point.
-        throw new Error(`kind \`${facts.name}\` is a genre — it carries no locus-bearing kind fact.`);
+        // 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.
+        throw new Error(`kind \`${facts.name}\` is embedded — it carries no locus-bearing kind fact.`);
     }
     return {
         name: facts.name,
@@ -37,20 +169,26 @@ function kindFactRow(facts) {
         governs_root: facts.locus.root,
         governs_glob: facts.locus.glob,
         format: facts.format,
-        unit_shape: facts.unitShape,
-        activation: activationLabel(facts.registration),
+        unit_shape: unitShapeLabel(facts),
+        registration: registrationLabels(facts.registration),
+        templates: templatesFor(facts.name, allKinds),
+        content: contentRow(facts.content),
     };
 }
-/** The distinct locus-bearing kinds in play — member kinds ∪ expect kinds, name-sorted. */
+/** Every kind in play, at any locus — member kinds ∪ expect kinds ∪ their embedded children. */
 function kindsInPlay(harness) {
     const byName = new Map();
     for (const member of harness.members)
         byName.set(member.facts.name, member.facts);
     for (const binding of harness.expect)
         byName.set(binding.kind.facts.name, binding.kind.facts);
-    return [...byName.values()]
+    return [...byName.values()];
+}
+/** The distinct locus-bearing (`at`) kinds in play, name-sorted. */
+function atLocusKindsInPlay(allKinds) {
+    return allKinds
         .filter((facts) => facts.locus.kind === "at")
-        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        .sort((a, b) => compareStrings(a.name, b.name));
 }
 /** The requirement rows — assembly `require` and every member's `requires`, one namespace. */
 function requirementRows(harness) {
@@ -59,7 +197,7 @@ function requirementRows(harness) {
         const existing = merged.get(name);
         if (existing !== undefined && existing !== requirement) {
             // One namespace, one fill mechanism; a cross-publisher name collision is an
-            // admissibility finding, never a shadowing rule (`10-contracts.md`).
+            // admissibility finding, never a shadowing rule.
             throw new Error(`requirement \`${name}\` is published twice (${source} collides with an earlier ` +
                 `publisher) — a name collision across publishers is an admissibility finding.`);
         }
@@ -73,25 +211,24 @@ function requirementRows(harness) {
         }
     }
     return [...merged.entries()]
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .sort(([a], [b]) => compareStrings(a, b))
         .map(([name, requirement]) => ({
         name,
         kind: requirement.kind?.key,
         required: requirement.required ?? false,
+        clauses: (requirement.clauses ?? []).map((clause) => clauseRow(clause)),
         verified_by: requirement.verifiedBy,
+        prose: requirement.prose,
     }));
 }
 /**
- * The assembly-scope facts, in a stable order: authority (always declared — the
- * `shared` default anchors every harness until a surface-authority posture is
- * authored), reachability when the dial is set, then one edge row per kind edge
- * field (`40-composition.md`; `45-governance.md`).
+ * 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.
  */
 function assemblyFactRows(harness, kinds) {
-    const facts = [{ fact: "authority", value: "shared" }];
-    if (harness.reachability !== undefined) {
-        facts.push({ fact: "reachability", value: harness.reachability });
-    }
+    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 });
@@ -107,39 +244,216 @@ function satisfiesRows(harness) {
             rows.push({ member: member.name, requirement });
         }
     }
-    return rows.sort((a, b) => (a.member < b.member ? -1 : a.member > b.member ? 1 : 0) ||
-        (a.requirement < b.requirement ? -1 : a.requirement > b.requirement ? 1 : 0));
+    return rows.sort((a, b) => compareStrings(a.member, b.member) || compareStrings(a.requirement, b.requirement));
+}
+/**
+ * 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
+ * (`emit.ts`), not this row's concern.
+ */
+function mentionRows(harness) {
+    const rows = [];
+    for (const member of harness.members) {
+        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));
+            }
+        }
+    }
+    return rows.sort((a, b) => compareStrings(a.member, b.member) || compareStrings(a.target, b.target));
+}
+/**
+ * The mention rows one `blocks()`-declared embedded-member value's `Text` leaves
+ * contribute — top-level leaves addressed by their bare field name, a
+ * collection entry's leaves addressed `<collection>.<entry>.<field>` (one layer
+ * deep, matching the row's own shape) — each row keyed to the leaf's own
+ * structural address, the `<member>/<kind>/<key>/<child-path>` grammar
+ * `src/read.rs`'s `parse_leaf_address` resolves. A bare-string leaf names no
+ * mention.
+ */
+function embeddedLeafMentionRows(hostName, value) {
+    const rows = [];
+    const addressed = (childPath) => `${hostName}/${value.kind}/${value.key}/${childPath}`;
+    for (const [field, leaf] of Object.entries(value.leaves)) {
+        if (typeof leaf === "string")
+            continue;
+        for (const mention of leaf.mentions) {
+            rows.push({ member: addressed(field), target: mention.target.address });
+        }
+    }
+    for (const [collection, entries] of Object.entries(value.collections)) {
+        for (const entry of entries) {
+            for (const [field, leaf] of Object.entries(entry.leaves)) {
+                if (typeof leaf === "string")
+                    continue;
+                for (const mention of leaf.mentions) {
+                    rows.push({ member: addressed(`${collection}.${entry.key}.${field}`), target: mention.target.address });
+                }
+            }
+        }
+    }
+    return rows;
+}
+/**
+ * The `include` rows — every member's `text`-body includes, in member-then-authored
+ * order. Each carries the host member's `kind:name` address and the include target's
+ * 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}).
+ */
+function includeRows(harness) {
+    const rows = [];
+    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)) });
+        }
+    }
+    return rows;
+}
+/**
+ * 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.
+ */
+function nestedMemberRow(host, value, mentionable) {
+    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));
+    }
+    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}`));
+            }
+            return { key: entry.key, leaves: entryLeaves };
+        });
+    }
+    return { host, kind: value.kind, key: value.key, leaves, collections };
+}
+/**
+ * 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.
+ */
+function embeddedHostsByKind(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));
+        }
+    }
+    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
+ * (`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.
+ */
+function nestedMemberRows(harness, mentionable) {
+    const hostsByKind = embeddedHostsByKind(harness);
+    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)) {
+                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").`);
+            }
+            rows.push(nestedMemberRow(host, value, mentionable));
+        }
+    }
+    return rows.sort((a, b) => compareStrings(a.host, b.host) || compareStrings(a.kind, b.kind) || 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();
+    for (const name of Object.keys(harness.require))
+        set.add(name);
+    for (const member of harness.members) {
+        for (const name of Object.keys(member.requires))
+            set.add(name);
+    }
+    return set;
+}
+/**
+ * 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.
+ */
+export function declaredAddresses(harness) {
+    const set = declaredRequirements(harness);
+    for (const member of harness.members)
+        set.add(`${member.kind}:${member.name}`);
+    return set;
 }
-/** Compile a harness into its five declaration families — the erased program. */
+/** Compile a harness into its seven declaration families — the erased program. */
 export function compileDeclarations(harness) {
-    const kinds = kindsInPlay(harness);
+    const allKinds = kindsInPlay(harness);
+    const kinds = atLocusKindsInPlay(allKinds);
     const clauses = [];
-    for (const binding of [...harness.expect].sort((a, b) => (a.kind.key < b.kind.key ? -1 : a.kind.key > b.kind.key ? 1 : 0))) {
+    for (const binding of [...harness.expect].sort((a, b) => compareStrings(a.kind.key, b.kind.key))) {
         for (const clause of binding.clauses) {
-            clauses.push({
-                kind: binding.kind.key,
-                predicate: clause.predicate.key,
-                field: clause.predicate.field,
-                severity: clause.severity,
-            });
+            clauses.push(clauseRow(clause, binding.kind.key));
         }
     }
     return {
-        kinds: kinds.map(kindFactRow),
+        kinds: kinds.map((facts) => kindFactRow(facts, allKinds)),
         clauses,
         requirements: requirementRows(harness),
         assembly: assemblyFactRows(harness, kinds),
         satisfies: satisfiesRows(harness),
+        mentions: mentionRows(harness),
+        includes: includeRows(harness),
+        nested_members: nestedMemberRows(harness, declaredAddresses(harness)),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
-export const SEAM_VERSION = 1;
+export const SEAM_VERSION = 2;
 /**
- * Serialize the declaration rows to the internal versioned JSON pipe
- * (`20-surface.md`, "The seam"). Not a designed IR — a stable public interchange
- * is admitted only when its consumer lands. Deterministic: insertion-ordered keys
- * and a trailing newline, so a re-emit is byte-identical (law 5).
+ * Serialize the seam payload to the internal versioned JSON pipe — `encodeSeam`
+ * stamps `version`, so the caller supplies the rest of the {@link Payload}.
+ * Deterministic: insertion-ordered keys and a trailing newline, so a re-emit is
+ * byte-identical.
  */
-export function declarationsToJson(declarations) {
-    return JSON.stringify({ version: SEAM_VERSION, ...declarations }, null, 2) + "\n";
+export function encodeSeam(payload) {
+    return JSON.stringify({ version: SEAM_VERSION, ...payload }, null, 2) + "\n";
 }