@dtmd/temper 0.0.4 → 0.0.7

package/dist/src/declarations.js

@@ -1,20 +1,21 @@
 /**
- * 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 { 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
- * (`10-contracts.md`, "The clause — the atom of a contract") — plus, when the
+ * — plus, when the
  * predicate carries them, the `count`/`target`/`degree` argument columns a
- * requirement's own set-/edge-scope demand needs (`10-contracts.md`, "Judged
- * at the node-set scope" / "Judged at the edge scope"), and the
+ * 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
@@ -42,9 +43,25 @@ function clauseRow(clause, kind) {
             }
             : undefined,
         bound: nodeScopeBoundArgs(predicate),
-        charset: predicate.key === "allowed_chars" ? predicate.charset : undefined,
-        keys: predicate.key === "forbidden_keys" ? predicate.keys : undefined,
-        values: predicate.key === "deny" ? predicate.values : undefined,
+        // 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`
@@ -65,11 +82,24 @@ function edgeBoundArgs(args, direction) {
     const max = args?.[`${direction}_max`];
     return min === undefined && max === undefined ? undefined : { min, max };
 }
-/** The lock label for a kind's declared registration. */
+/**
+ * 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":
@@ -80,13 +110,69 @@ function registrationLabel(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 };
+}
+/**
+ * Lower a kind's declared {@link CollectionAddress} into its `collection_address` row —
+ * `keyPath` spelled as the wire's snake_case `key_path`. `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 };
+}
+/**
+ * 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). A registration
+ * kind extends the row with its `shape` marker and `collection_address`.
+ */
+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,
@@ -94,20 +180,28 @@ function kindFactRow(facts) {
         governs_root: facts.locus.root,
         governs_glob: facts.locus.glob,
         format: facts.format,
-        unit_shape: facts.unitShape,
-        registration: registrationLabel(facts.registration),
+        unit_shape: unitShapeLabel(facts),
+        registration: registrationLabels(facts.registration),
+        templates: templatesFor(facts.name, allKinds),
+        content: contentRow(facts.content),
+        shape: facts.shape,
+        collection_address: collectionAddressRow(facts),
     };
 }
-/** 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) {
@@ -116,7 +210,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.`);
         }
@@ -130,23 +224,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), 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(kinds) {
-    const facts = [{ fact: "authority", value: "shared" }];
+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 });
@@ -162,34 +257,267 @@ 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));
+}
+/**
+ * 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 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();
+    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(clauseRow(clause, binding.kind.key));
         }
     }
     return {
-        kinds: kinds.map(kindFactRow),
+        kinds: kinds.map((facts) => kindFactRow(facts, allKinds)),
         clauses,
         requirements: requirementRows(harness),
-        assembly: assemblyFactRows(kinds),
+        assembly: assemblyFactRows(harness, kinds),
         satisfies: satisfiesRows(harness),
+        mentions: mentionRows(harness),
+        includes: includeRows(harness),
+        nested_members: nestedMemberRows(harness, declaredAddresses(harness)),
+        registrations: registrationRows(harness),
+        settings: settingsRows(harness),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
 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";
 }

package/dist/src/emit.d.ts

@@ -1,48 +1,63 @@
 /**
- * Emit — the compile from the six-noun face to the seam's JSON pipe
- * (`specs/architecture/20-surface.md`, "Emit — total, byte-reproducible, refusing";
- * "The seam — one implementation"). The SDK implements **no semantics**: emit
+ * Emit — the compile from the six-noun face to the seam's JSON pipe.
+ * The SDK implements **no semantics**: emit
  * produces plain data — the declaration rows the engine reads and, per projected
  * member, its ordered typed fields and resolved prose body. The engine is the
  * sole compiler of every projection and the whole lock; the SDK writes neither.
  * Emit is total (members are the only source), refuses before it produces a byte
  * on a broken source, and is byte-reproducible — double-emit verified at every
- * run (law 5).
+ * run.
  */
 import type { Harness } from "./assembly.js";
 import type { Declarations } from "./declarations.js";
-/** How a `file()` asset's module-relative path resolves at emit. */
+import type { PayloadMember } from "./generated/index.js";
+export type { PayloadMember } from "./generated/index.js";
+/** What a mention may resolve against at emit. */
 export interface ResolveOptions {
-    /** Base dir a `file()` module-relative path resolves against (default: cwd). */
-    readonly baseDir?: string;
     /** The addresses a mention may name — resolution-checked; a mention cannot dangle. */
     readonly mentionable?: ReadonlySet<string>;
 }
-/** One projected member's erased payload — the engine derives its locus from the kind's own declaration row. */
-export interface PayloadMember {
-    /** The kind's bare name — joins the payload's `declarations.kinds` family. */
+/**
+ * One fields-only registration member erased for the manifest write face: its key
+ * (a hook's lifecycle event, an MCP server's name), the collection address it keys
+ * at, and its folded typed fields — the same declaration-row shape the engine write
+ * face reads back off a manifest (`json_manifest.rs`'s `RegistrationMember`). Carried
+ * from the composing program, never mined from a projection.
+ */
+export interface RegistrationFact {
+    /** The erased registration kind — `hook`, `mcp-server` — joining `declarations.kinds`. */
     readonly kind: string;
-    /** Identity within the kind. */
-    readonly name: string;
-    /** The kind's typed fields, flat and ordered — the projected frontmatter. */
+    /** The member's key among its collection's entries — a hook's event, a server's name. */
+    readonly key: string;
+    /** The manifest collection address the registration surfaces at. */
+    readonly collectionAddress: {
+        readonly manifest: string;
+        readonly keyPath: string;
+    };
+    /** The member's folded typed fields, in the author's declared order. */
     readonly fields: ReadonlyArray<readonly [string, unknown]>;
-    /** The resolved prose body, byte-faithful. */
-    readonly body: string;
-    /** The resolved `file()` asset's absolute path; absent for `text`/`blocks` prose. */
-    readonly source_path?: string;
 }
-/** Emit-time inputs beyond the harness — where a `file()` asset's module-relative path resolves against. */
-export interface EmitOptions {
-    /** Base dir a `file()` asset's module-relative path resolves against (default: cwd). */
-    readonly baseDir?: string;
+/**
+ * One harness-level settings-residue key erased for the manifest write face: the manifest
+ * it surfaces in, its opaque key, and its value — the entry `emit` folds into the manifest's
+ * residue beside its registration members' collection segments. Carried from the composing
+ * program, never mined from a projection.
+ */
+export interface SettingsResidue {
+    /** The host manifest the residue key surfaces in (`settings.json`). */
+    readonly manifest: string;
+    /** The opaque top-level manifest key with no member home. */
+    readonly key: string;
+    /** The key's opaque value, placed verbatim into the manifest's residue. */
+    readonly value: unknown;
 }
 /**
- * A full emit's compiled outputs — the whole seam the engine reads
- * (`20-surface.md`, "The seam"). A pure function of the harness, so [`emit`]
+ * A full emit's compiled outputs — the whole seam the engine reads.
+ * A pure function of the harness, so [`emit`]
  * double-verifies it.
  */
 export interface EmitResult {
-    /** The declaration rows — the erased program the lock's five families carry. */
+    /** The declaration rows — the erased program the lock's seven families carry. */
     readonly declarations: Declarations;
     /** The projected members — the engine's sole input for every projection. */
     readonly members: readonly PayloadMember[];
@@ -53,17 +68,30 @@ export interface EmitResult {
     readonly seam: string;
     /**
      * The derived permission list — the union of every member's `needs`, deduped and
-     * sorted (`20-surface.md`, "The permission list is derived, never authored").
+   * sorted.
      * Folds into the settings artifact once hook/MCP members land; carried here as
      * data until then.
      */
     readonly permissions: readonly string[];
+    /**
+     * The fields-only registration members erased for the manifest write face — each
+     * a name, its collection address, and its folded fields. Folds into the manifest
+     * artifacts once the engine write face lands; carried here as data until then, the
+     * way `permissions` is.
+     */
+    readonly registrations: readonly RegistrationFact[];
+    /**
+     * The harness-level settings residue erased for the manifest write face — each an opaque
+     * settings.json key and its value. Folds into the settings.json manifest's residue at
+     * emit, the way `registrations` builds its collection segments; carried here as data too.
+     */
+    readonly settings: readonly SettingsResidue[];
 }
 /**
  * Compile the whole face in one deterministic pass: the declaration rows (its
- * rollup and its five families) and every projected member's erased payload.
+ * rollup and its seven families) and every projected member's erased payload.
  * Prose resolves once (`file()` assets read in, mentions resolution-checked
  * against the harness's declared values). Double-emit verified — nondeterministic
- * authoring is a loud failure, never a silent churn (law 5).
+ * authoring is a loud failure, never a silent churn.
  */
-export declare function emit(harness: Harness, options?: EmitOptions): EmitResult;
+export declare function emit(harness: Harness): EmitResult;