@dtmd/temper 0.0.16 → 0.0.18

package/dist/src/declarations.d.ts

@@ -106,9 +106,9 @@ export declare function declaredRequirements(harness: Harness): Set<string>;
 export declare function declaredAddresses(harness: Harness): Set<string>;
 /**
  * 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
+ * dangling mention is measured against (`prose.ts`'s `defersToGate`): a mention whose
+ * address is a host address of one of these and names no 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.
  */

package/dist/src/declarations.js

@@ -9,8 +9,10 @@
  * in lockstep.
  */
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { isTextSpan, resolveLeaf } from "./prose.js";
 import { SETTINGS_MANIFEST, TELEMETRY_EVENT_HOOKS, hook, tapHookRegistration } from "./builtins.js";
+import { hostAddress, leafAddress, nestedAddress } from "./member-address.js";
 /**
  * Compile one `Clause` into its lock row: the shared `key`/`field`/`severity`/
  * `guidance`/`cite` columns — the clause's four channels surviving erasure
@@ -60,7 +62,7 @@ function clauseRow(clause, kind) {
     return {
         kind,
         predicate: predicate.key,
-        field: predicate.field,
+        field: clauseField(predicate),
         severity: clause.severity,
         guidance: clause.guidance,
         cite: clause.cite,
@@ -103,6 +105,31 @@ function clauseRow(clause, kind) {
             : undefined,
     };
 }
+/**
+ * The `field` column for one predicate: the field it names, or — for the two
+ * predicates that name a *section* rather than a field — an identity synthesized
+ * from the arguments the row already carries.
+ *
+ * `section_contains` and `require_sections` set no `field`, and the column is what
+ * emit stamps a clause's label from (`stamp_clause_label`, `src/drift.rs`), so
+ * reading `Predicate.field` folds every clause of either predicate on one kind
+ * into one label — two rows wearing one label, which admissibility refuses as a
+ * malformed lock. Synthesizing here keeps the whole fix at the lowering: the Rust
+ * reader reconstructs both predicates from the `section`/`sections` columns and
+ * never from this one, so nothing round-trips through the synthesized text.
+ */
+function clauseField(predicate) {
+    if (predicate.key === "section_contains") {
+        const { section } = predicate;
+        return section === undefined ? undefined : `${section.heading}.${section.marker}`;
+    }
+    if (predicate.key === "require_sections") {
+        // Joined with `+` rather than the label's own `.`, so the segment reads as the
+        // set it is and two different heading lists cannot fold to one label.
+        return predicate.sections?.join("+");
+    }
+    return predicate.field;
+}
 /** `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. */
@@ -272,6 +299,89 @@ function kindFactRow(facts, admissions) {
         cite: facts.cite,
     };
 }
+/**
+ * The locus a colliding kind is declared at, for {@link resolveNameCollision}'s refusal:
+ * an `at` kind names the path its members are found at, and every other locus names
+ * itself — a kind that governs no glob has no path of its own to name.
+ */
+function locusLabel(facts) {
+    const { locus } = facts;
+    if (locus.kind !== "at")
+        return `the \`${locus.kind}\` locus`;
+    return `\`${locus.root === "." ? locus.glob : `${locus.root}/${locus.glob}`}\``;
+}
+/**
+ * A kind's facts with the three faces a relocation may diverge from its base on erased:
+ * the `relocates` marker, the appended `edgeFields`, and an `at` locus's moved root and
+ * glob (`kind.ts`'s `KindRelocation`). Two values agreeing here are one kind up to a
+ * relocation delta; the delta's own faces are checked on their own terms.
+ */
+function relocationInvariants(facts) {
+    const bare = { ...facts };
+    delete bare.relocates;
+    delete bare.edgeFields;
+    if (facts.locus.kind === "at")
+        bare.locus = { ...facts.locus, root: "", glob: "" };
+    return bare;
+}
+/**
+ * Whether `relocation` was derived from `base` — the provenance the relocation-wins rule
+ * rests on. The marker names the base, `relocate` only ever *appends* edge fields (so the
+ * base's are a prefix of the relocation's), and every other fact rides through unchanged:
+ * the base's facts are a subset by construction, which is exactly what makes keeping the
+ * relocation lossless. Checked rather than assumed, because the marker carries a name and
+ * a name is what is in dispute — a value bearing it whose facts are not the other's
+ * superset is a third kind of the same name, and dropping *that* would be the very silent
+ * loss this decision exists to end.
+ */
+function isRelocationOf(relocation, base) {
+    if (relocation.relocates !== base.name || base.relocates !== undefined)
+        return false;
+    const inherited = base.edgeFields ?? [];
+    const declared = relocation.edgeFields ?? [];
+    return (declared.length >= inherited.length &&
+        isDeepStrictEqual(declared.slice(0, inherited.length), inherited) &&
+        isDeepStrictEqual(relocationInvariants(relocation), relocationInvariants(base)));
+}
+/**
+ * Which of two `KindFacts` values sharing one name is the kind in play — a decision that
+ * must not depend on the order the two arrived in, since {@link kindsInPlay} draws its
+ * facts from `members`, then `expect`, then `admit`, then embedded templates, and a kind
+ * legitimately reaches it through any of them.
+ *
+ * A **relocation** wins over its base whichever way round they arrive
+ * ({@link isRelocationOf} proves the provenance): the base's facts are the relocation's
+ * minus the delta, so keeping the base would silently drop the relocation's added edge
+ * fields and moved locus. Two values that are structurally equal are one kind declared
+ * twice — keep the first. Anything else is a genuine collision and refuses: kind identity
+ * travels by import, never by string (`representation.md`, "kind"), while the lock is a
+ * string-keyed medium, so the second kind has no name to reach the engine
+ * under and dropping it is a silent loss of everything it declared. Two relocations of
+ * one base collide the same way — each is still a kind of the base's own name.
+ *
+ * # Throws
+ * On a collision, naming the kind and both loci — the two declarations an author has to
+ * go look at.
+ */
+function resolveNameCollision(held, arriving) {
+    // At most one holds: each direction demands the other value carry no marker at all.
+    if (isRelocationOf(held, arriving))
+        return held;
+    if (isRelocationOf(arriving, held))
+        return arriving;
+    if (isDeepStrictEqual(held, arriving))
+        return held;
+    throw new Error(held.relocates !== undefined && arriving.relocates !== undefined
+        ? `two relocations of kind \`${held.name}\` are in play, at ${locusLabel(held)} and ` +
+            `${locusLabel(arriving)}, and they diverge. A relocation is still a kind of its base's ` +
+            `name, so a second one collides with the first: relocate the base once and import that ` +
+            `one value wherever it is used (specs/model/representation.md, "kind").`
+        : `two kinds named \`${held.name}\` are in play, at ${locusLabel(held)} and ` +
+            `${locusLabel(arriving)}. Kind identity travels by import, never by string, and the lock ` +
+            `is keyed by name — the second kind has no name of its own to reach the engine under. ` +
+            `Import the declared kind rather than redeclaring it; to move a built-in to another root ` +
+            `or add an edge field to it, use \`relocate()\` (specs/model/representation.md, "kind").`);
+}
 /**
  * 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.
@@ -285,15 +395,24 @@ function kindFactRow(facts, admissions) {
  * 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.
+ *
+ * Two facts values arriving under one name are decided by {@link resolveNameCollision},
+ * never by arrival order: the deduped facts are what `assemblyFactRows` derives every
+ * `edge` row from, so first-wins would drop a relocation's added edge on the floor
+ * whenever the base happened to be named first.
  */
 function kindsInPlay(harness) {
     const byName = new Map();
     const pending = [];
     const admit = (facts) => {
-        if (byName.has(facts.name))
+        const held = byName.get(facts.name);
+        if (held === facts)
+            return;
+        const winner = held === undefined ? facts : resolveNameCollision(held, facts);
+        if (winner === held)
             return;
-        byName.set(facts.name, facts);
-        pending.push(facts);
+        byName.set(facts.name, winner);
+        pending.push(winner);
     };
     for (const member of harness.members)
         admit(member.facts);
@@ -388,7 +507,7 @@ function assemblyFactRows(harness, kinds) {
 function satisfiesRows(harness) {
     const rows = [];
     for (const member of harness.members) {
-        const address = `${member.kind}:${member.name}`;
+        const address = hostAddress(member.kind, member.name);
         for (const requirement of member.satisfies) {
             rows.push({ member: address, requirement });
         }
@@ -409,7 +528,7 @@ function satisfiesRows(harness) {
 function mentionRows(harness) {
     const rows = [];
     for (const member of harness.members) {
-        const address = `${member.kind}:${member.name}`;
+        const address = hostAddress(member.kind, member.name);
         if (member.prose?.kind === "text") {
             for (const mention of member.prose.mentions) {
                 rows.push({ member: address, target: mention.target.address });
@@ -435,13 +554,11 @@ function mentionRows(harness) {
  * 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.
+ * structural address ({@link leafAddress}). A bare-string leaf names no mention.
  */
 function embeddedLeafMentionRows(hostName, value) {
     const rows = [];
-    const addressed = (childPath) => `${hostName}/${value.kind}/${value.key}/${childPath}`;
+    const addressed = (childPath) => leafAddress(hostName, value.kind, value.key, childPath);
     for (const [field, leaf] of Object.entries(value.leaves)) {
         if (typeof leaf === "string")
             continue;
@@ -478,7 +595,7 @@ function includeRows(harness) {
         rows.push({ member: address, source_path: fileURLToPath(new URL(include.path, include.moduleUrl)) });
     };
     for (const member of harness.members) {
-        const address = `${member.kind}:${member.name}`;
+        const address = hostAddress(member.kind, member.name);
         if (member.prose?.kind === "text") {
             for (const include of member.prose.includes)
                 push(address, include);
@@ -591,7 +708,7 @@ function nestedMemberRows(harness, admissions, scope, placements, extents) {
     for (const member of harness.members) {
         if (member.prose?.kind !== "blocks")
             continue;
-        const host = `${member.kind}:${member.name}`;
+        const host = hostAddress(member.kind, member.name);
         for (const value of member.prose.values) {
             if (isTextSpan(value))
                 continue;
@@ -729,22 +846,22 @@ export function declaredRequirements(harness) {
 export function declaredAddresses(harness) {
     const set = declaredRequirements(harness);
     for (const member of harness.members) {
-        set.add(`${member.kind}:${member.name}`);
+        set.add(hostAddress(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}`);
+            set.add(nestedAddress(hostAddress(member.kind, member.name), value.kind, value.key));
         }
     }
     return set;
 }
 /**
  * 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
+ * dangling mention is measured against (`prose.ts`'s `defersToGate`): a mention whose
+ * address is a host address of one of these and names no 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.
  */

package/dist/src/emit.d.ts

@@ -9,10 +9,30 @@
  * run.
  */
 import type { Harness } from "./assembly.js";
-import type { Member } from "./kind.js";
+import type { EmbeddedMemberValue, Member } from "./kind.js";
 import type { Declarations } from "./declarations.js";
 import type { PayloadMember } from "./generated/index.js";
 export type { PayloadMember } from "./generated/index.js";
+/**
+ * One composed embedded value as an edge target, carried with the host member whose body
+ * it lives in: an embedded member owns no file, so every path fact about it is derived
+ * from its host's own projection.
+ */
+export interface EmbeddedTarget {
+    /** The member whose composed body carries the value — the projection it lives in. */
+    readonly host: Member;
+    /** The composed value itself. */
+    readonly value: EmbeddedMemberValue;
+}
+/**
+ * What one address in the member table names: a top-level composed member, or the
+ * embedded values one nested spelling reaches. The nested list carries one element for
+ * a full `<host-address>/<kind>/<key>` address, and one per host for a bare `kind:key` —
+ * a bare key names a nested member only when a single host carries it, and resolution
+ * refuses the rest as ambiguous rather than picking one: uniqueness is the resolver's
+ * bar, not the grammar's.
+ */
+export type EdgeTarget = Member | readonly EmbeddedTarget[];
 /** What a mention may resolve against at emit. */
 export interface ResolveOptions {
     /** The addresses a mention may name — resolution-checked; a mention cannot dangle. */
@@ -23,12 +43,14 @@ export interface ResolveOptions {
      */
     readonly deferrableKinds?: ReadonlySet<string>;
     /**
-     * The program's composed members by `kind:name` address — what an embedded value's
-     * edge field resolves against to derive its target facts. An edge target never defers
-     * to the gate the way a bare mention may: the facts are rendered into the projection
-     * now, so an unresolved one has nothing true to place.
+     * The program's composed members by address — what an embedded value's edge field
+     * resolves against to derive its target facts. Top-level members index at their
+     * `kind:name` address, and each composed embedded value at both of its own spellings:
+     * its full `<host-address>/<kind>/<key>` address and its bare `kind:key`.
+     * An edge target never defers to the gate the way a bare mention may: the facts are
+     * rendered into the projection now, so an unresolved one has nothing true to place.
      */
-    readonly members?: ReadonlyMap<string, Member>;
+    readonly members?: ReadonlyMap<string, EdgeTarget>;
 }
 /**
  * One fields-only registration member erased for the manifest write face: its key

package/dist/src/emit.js

@@ -13,6 +13,7 @@ import { readFileSync } from "node:fs";
 import { checkMentions, isTextSpan, renderText, resolveLeaf } from "./prose.js";
 import { permissionUnion } from "./needs.js";
 import { compareStrings, compileDeclarations, declaredAddresses, declaredAtLocusKinds, declaredRequirements, encodeSeam, placementKey, registrationRows, settingsRows, tapHookRows, uniqueMap, } from "./declarations.js";
+import { bareLookupKey, edgeLookupKey, hostAddress, nestedAddress } from "./member-address.js";
 /** The {@link MentionScope} a set of {@link ResolveOptions} names — its two sets, each defaulting to empty. */
 function scopeOf(options) {
     return {
@@ -93,7 +94,7 @@ function hostUnit(host, context) {
     if (host.facts.locus.kind === "at" && host.facts.unitShape === "directory") {
         return joinSlash(host.facts.locus.root, host.name);
     }
-    throw new Error(`${context}: its host \`${host.kind}:${host.name}\` owns no directory unit — a template's ` +
+    throw new Error(`${context}: its host \`${hostAddress(host.kind, host.name)}\` owns no directory unit — a template's ` +
         `path pattern is relative to the host's unit, and a lone file has no interior for a ` +
         `child to sit in (specs/model/representation.md, "locus").`);
 }
@@ -115,7 +116,7 @@ function nestedFilePath(member) {
     }
     const template = (host.facts.templates ?? []).find((layer) => layer.kind.key === member.kind && layer.path !== undefined);
     if (template?.path === undefined) {
-        throw new Error(`${context}: its host \`${host.kind}:${host.name}\` templates no file layer for kind ` +
+        throw new Error(`${context}: its host \`${hostAddress(host.kind, host.name)}\` templates no file layer for kind ` +
             `\`${member.kind}\` — the path pattern is the host kind's declared fact, and there is ` +
             `none to compose against (specs/model/representation.md, "locus").`);
     }
@@ -178,9 +179,10 @@ function relativeProjection(from, to) {
  * own field schema, which fails in the author's program at compose time.
  *
  * # Throws
- * If a filled leaf names no composed member, or names one that owns no projection to
- * point at. An edge target cannot defer to the gate the way a bare mention may: the
- * reference is written now, and there is nothing true to write.
+ * If a filled leaf names no composed member, names one that owns no projection to
+ * point at, or names a bare nested key several hosts carry
+ * ({@link resolvedTargetFacts}). An edge target cannot defer to the gate the way a bare
+ * mention may: the reference is written now, and there is nothing true to write.
  */
 function edgeTargetFacts(host, value, leaves, options) {
     const targets = {};
@@ -189,22 +191,40 @@ function edgeTargetFacts(host, value, leaves, options) {
         const address = leaves[edge.field];
         if (address === undefined || address === "")
             continue;
-        // A one-element `to` set resolves a bare address within its one kind; a
-        // multi-element set reads the kind-qualified `kind:name` the author wrote
-        // (`EdgeField.to`). An already-qualified address carries its own colon, so
-        // only a bare leaf is lifted to `${edge.to[0]}:${address}` for the lookup.
-        const lookup = edge.to.length === 1 && !address.includes(":") ? `${edge.to[0]}:${address}` : address;
+        const lookup = edgeLookupKey(address, edge.to);
         const target = options.members?.get(lookup);
+        const reference = `${context}: edge field \`${edge.field}\` names \`${address}\``;
         if (target === undefined) {
-            throw new Error(`${context}: edge field \`${edge.field}\` names \`${address}\`, which resolves to no ` +
-                `composed member — an edge target's facts are derived, never fabricated ` +
-                `(specs/model/pipeline.md, "Emit", the "Refusing" bullet).`);
+            throw new Error(`${reference}, which resolves to no composed member — an edge target's facts are ` +
+                `derived, never fabricated (specs/model/pipeline.md, "Emit", the "Refusing" bullet).`);
         }
-        if (!isProjected(target)) {
-            throw new Error(`${context}: edge field \`${edge.field}\` names \`${address}\`, which owns no ` +
-                `projection to reference (specs/model/representation.md, "locus").`);
-        }
-        targets[edge.field] = {
+        targets[edge.field] = resolvedTargetFacts(host, target, lookup, reference);
+    }
+    return targets;
+}
+/** Whether an address named the nested index — the embedded values one spelling reaches. */
+function isNested(target) {
+    return Array.isArray(target);
+}
+/**
+ * The four derived facts one resolved edge target contributes, read off the target
+ * itself and never off the citing instance. A top-level member answers with its own
+ * identity and its own projection; an embedded value answers with its own kind and key,
+ * its canonical `<host-address>/<kind>/<key>` address (whichever spelling the leaf
+ * authored), and its *host's* projection — an embedded member owns no file, so the file
+ * its rendering lands in is the host's.
+ *
+ * # Throws
+ * If a bare `kind:key` is carried by more than one host — an ambiguous address names
+ * nothing, and the full spelling is what tells the carriers apart — or if the target,
+ * or the host carrying it, owns no projection to point at.
+ */
+function resolvedTargetFacts(host, target, lookup, reference) {
+    const noProjection = () => new Error(`${reference}, which owns no projection to reference (specs/model/representation.md, "locus").`);
+    if (!isNested(target)) {
+        if (!isProjected(target))
+            throw noProjection();
+        return {
             name: target.name,
             address: lookup,
             kind: target.kind,
@@ -212,7 +232,23 @@ function edgeTargetFacts(host, value, leaves, options) {
             repoRootedPath: projectionPath(target),
         };
     }
-    return targets;
+    if (target.length > 1) {
+        const hosts = target.map((carrier) => `\`${hostAddress(carrier.host.kind, carrier.host.name)}\``).join(", ");
+        throw new Error(`${reference}, a bare key ${target.length} hosts carry (${hosts}) — a nested member's address ` +
+            `composes through its host, so spell the whole \`<host-address>/<kind>/<key>\` ` +
+            `(specs/model/representation.md, "member").`);
+    }
+    const { host: carrier, value } = target[0];
+    if (!isProjected(carrier))
+        throw noProjection();
+    const carrierPath = projectionPath(carrier);
+    return {
+        name: value.key,
+        address: nestedAddress(hostAddress(carrier.kind, carrier.name), value.kind, value.key),
+        kind: value.kind,
+        path: relativeProjection(projectionPath(host), carrierPath),
+        repoRootedPath: carrierPath,
+    };
 }
 /**
  * Resolve one embedded member's value's leaves — top-level and each
@@ -359,7 +395,7 @@ function edgePlacements(harness, options) {
                 continue;
             const placed = placedEdges(member, value, options);
             if (placed !== undefined) {
-                entries.push([placementKey(`${member.kind}:${member.name}`, value.kind, value.key), placed]);
+                entries.push([placementKey(hostAddress(member.kind, member.name), value.kind, value.key), placed]);
             }
         }
     }
@@ -400,7 +436,7 @@ function renderedExtents(harness, options) {
                 continue;
             const block = renderMemberBlock(member, value, options);
             entries.push([
-                placementKey(`${member.kind}:${member.name}`, value.kind, value.key),
+                placementKey(hostAddress(member.kind, member.name), value.kind, value.key),
                 {
                     lines: renderedLineCount(block),
                     // Unicode scalar values, matching Rust's `chars().count()` — iterating a string
@@ -549,12 +585,63 @@ function settingsResidue(harness) {
     return settingsRows(harness).map((row) => ({ manifest: row.manifest, key: row.key, value: row.value }));
 }
 /**
- * The harness's composed members by `kind:name` address — the table an embedded value's
- * edge field resolves its target against. Keyed the identical way {@link declaredAddresses}
- * spells a member address, so an edge field and a mention name a member the same way.
+ * The harness's composed members by address — the table an embedded value's edge field
+ * resolves its target against. A top-level member keys the identical way
+ * {@link declaredAddresses} spells a member address, so an edge field and a mention name
+ * a member the same way; a nested member keys under both of its own spellings
+ * ({@link nestedTargets}), so an embedded edge target resolves at emit as a top-level one
+ * does.
+ *
+ * A projected member's address is its file, so two at one address are a collision and
+ * refuse loud. A registration member's address is its *group key* — a `hook` registers on
+ * its event, and Claude Code admits any number of matcher groups per event — so several
+ * legitimately share one address and the table keeps the last composed (the pre-0.0.16
+ * reading; an edge targeting that shared address resolves ambiguously, the open fork
+ * `(hook-member-identity)` in `.flume/plan/open-questions.md`). Refusing them broke
+ * `emit` on every harness with two hooks on one event (0.0.16).
  */
 function memberTable(harness) {
-    return uniqueMap(harness.members.map((member) => [`${member.kind}:${member.name}`, member]));
+    const table = uniqueMap([
+        ...harness.members
+            .filter((member) => !isRegistration(member))
+            .map((member) => [hostAddress(member.kind, member.name), member]),
+        ...nestedTargets(harness),
+    ]);
+    for (const member of harness.members.filter(isRegistration)) {
+        table.set(hostAddress(member.kind, member.name), member);
+    }
+    return table;
+}
+/**
+ * Every composed embedded value as member-table entries, under both of its spellings: the
+ * full `<host-address>/<kind>/<key>` address, whose one carrier is the host whose body
+ * composed it — two of those coincident are a malformed lock, refused by the shared
+ * {@link uniqueMap} the way two members at one address are — and the bare `kind:key`,
+ * whose entry carries *every* host that spells it. A bare key names a nested member only
+ * when a single host carries it; several is ambiguous, refused by name at resolution
+ * ({@link resolvedTargetFacts}) rather than here, since uniqueness is the resolver's bar
+ * and not the corpus's — one key two hosts carry and nothing cites still composes.
+ */
+function nestedTargets(harness) {
+    const qualified = [];
+    const bare = new Map();
+    for (const member of harness.members) {
+        if (member.prose?.kind !== "blocks")
+            continue;
+        for (const value of member.prose.values) {
+            if (isTextSpan(value))
+                continue;
+            const target = { host: member, value };
+            qualified.push([nestedAddress(hostAddress(member.kind, member.name), value.kind, value.key), [target]]);
+            const key = bareLookupKey(value.kind, value.key);
+            const carriers = bare.get(key);
+            if (carriers === undefined)
+                bare.set(key, [target]);
+            else
+                carriers.push(target);
+        }
+    }
+    return [...qualified, ...bare];
 }
 /** The harness's projected members as payload members, deterministically kind-then-name ordered. */
 function orderedMembers(harness, options) {
@@ -564,7 +651,7 @@ function orderedMembers(harness, options) {
         .map((member) => ({
         kind: member.kind,
         name: member.name,
-        host: member.host && `${member.host.kind}:${member.host.name}`,
+        host: member.host && hostAddress(member.host.kind, member.host.name),
         // 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]),

package/dist/src/generated/ClauseRow.d.ts

@@ -49,7 +49,14 @@ export type ClauseRow = {
      */
     predicate: string;
     /**
-     * The field (or marker) the predicate constrains, when it names one.
+     * The clause's **compiled label** segment ([`crate::contract::clause_label`]) — the
+     * field the predicate constrains where it names one, and otherwise the identity the
+     * seam synthesizes from the arguments the row already carries (`section_contains`
+     * and `require_sections` name no field, so `clauseField` in
+     * `sdk/src/declarations.ts` lowers a `<heading>.<marker>` / joined-sections segment
+     * here instead). `None` where the predicate needs no segment to label uniquely. A
+     * synthesized segment labels only: those two predicates are reconstructed from
+     * their own `section`/`sections` columns, never round-tripped through this one.
      */
     field?: string;
     /**

package/dist/src/index.d.ts

@@ -18,11 +18,11 @@ export type { Capability } from "./needs.js";
 export { bash, capability, permissionUnion } from "./needs.js";
 export type { Charset, Clause, ExtentUnit, Predicate, Requirement, Severity, Verifier } from "./contract.js";
 export { allowedChars, clause, closedKeys, count, degree, deny, enumOf, extent, forbiddenKeys, formatPlacesEdges, globValid, maxLen, membership, mentionReachable, minLen, mustDefine, nameMatchesDir, optional, range, required, requireSections, requirement, script, sectionContains, shape, telemetry, type, unique, uniqueName, when, } from "./contract.js";
-export type { CollectionAddress, EdgeField, EdgeTargetFacts, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, KindOptions, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, ResolvedEmbeddedMemberCollectionEntry, ResolvedEmbeddedMemberValue, Shape, Template, UnitShape, } from "./kind.js";
-export { embeddedMemberValue, kind } from "./kind.js";
+export type { CollectionAddress, EdgeField, EdgeTargetFacts, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, KindOptions, KindRelocation, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, ResolvedEmbeddedMemberCollectionEntry, ResolvedEmbeddedMemberValue, Shape, Template, UnitShape, } from "./kind.js";
+export { embeddedMemberValue, kind, relocate } from "./kind.js";
 export type { Admission, EnforcementMode, ExpectBinding, Harness } from "./assembly.js";
 export { harness } from "./assembly.js";
-export type { EmitResult, RegistrationFact, ResolveOptions, SettingsResidue } from "./emit.js";
+export type { EdgeTarget, EmbeddedTarget, EmitResult, RegistrationFact, ResolveOptions, SettingsResidue, } from "./emit.js";
 export { emit } from "./emit.js";
 export type { Dial, DialEntry } from "./dial.js";
 export { dial, dialDefaultContract } from "./dial.js";

package/dist/src/index.js

@@ -15,7 +15,7 @@
 export { blocks, file, include, mentionOf, renderText, text } from "./prose.js";
 export { bash, capability, permissionUnion } from "./needs.js";
 export { allowedChars, clause, closedKeys, count, degree, deny, enumOf, extent, forbiddenKeys, formatPlacesEdges, globValid, maxLen, membership, mentionReachable, minLen, mustDefine, nameMatchesDir, optional, range, required, requireSections, requirement, script, sectionContains, shape, telemetry, type, unique, uniqueName, when, } from "./contract.js";
-export { embeddedMemberValue, kind } from "./kind.js";
+export { embeddedMemberValue, kind, relocate } from "./kind.js";
 export { harness } from "./assembly.js";
 export { emit } from "./emit.js";
 export { dial, dialDefaultContract } from "./dial.js";

package/dist/src/kind.d.ts

@@ -169,15 +169,30 @@ export interface Template {
     readonly path?: string;
 }
 /** The seven facts of a kind's runtime residue. */
-export interface KindFacts {
+export type KindFacts = {
     /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
     readonly name: string;
     /** The declared provider authority, when the kind qualifies by one. */
     readonly provider?: string;
+    /**
+     * The built-in kind this facts value **relocates** — set only by {@link relocate},
+     * from the base kind's own name, never authored. It is the authoring layer's
+     * *provenance* fact: the value was derived from the imported built-in, so a
+     * second same-named kind in play is a sanctioned relocation rather than a name
+     * collision. It never reaches a kind-fact row — the lock reader holds no base
+     * value to compare against and re-decides *structurally* instead
+     * (`src/compose.rs`'s `row_relocates_builtin`).
+     */
+    readonly relocates?: string;
     /** Fact 2, locus — where members live, and for a file locus whether their documents
      * are committed: a `local` commitment class declares the kind reviewed and its
      * members' documents not. */
-    readonly locus: Locus;
+    readonly locus: {
+        readonly kind: "at";
+        readonly root: string;
+        readonly glob: string;
+        readonly commitment?: "local";
+    };
     /** Fact 3a, projection — the artifact format; omitted for a kind that declares none. */
     readonly format?: Format;
     /** Fact 3b, projection — the on-disk unit shape. */
@@ -186,15 +201,15 @@ export interface KindFacts {
      * the world reaches a member (never rivals — a member is live if any one is). */
     readonly registration: readonly Registration[];
     /**
-      * The frontmatter key the member's name writes under. For `unitShape:
-      * "named-field"` this is the id **source** — the declared field a member's
-      * identity is read from (an agent's `name`), never the filename or directory.
-      * For `"directory"` it is a projection-order detail only (a skill's `name`
-      * still writes into frontmatter, but identity is the directory name); absent
-      * when identity is the file stem and no field carries it (a rule), or the
-      * starred directory segment (`"starred-segment"`) — both path-derived, never a
-      * field.
-    */
+     * The frontmatter key the member's name writes under. For `unitShape:
+     * "named-field"` this is the id **source** — the declared field a member's
+     * identity is read from (an agent's `name`), never the filename or directory.
+     * For `"directory"` it is a projection-order detail only (a skill's `name`
+     * still writes into frontmatter, but identity is the directory name); absent
+     * when identity is the file stem and no field carries it (a rule), or the
+     * starred directory segment (`"starred-segment"`) — both path-derived, never a
+     * field.
+     */
     readonly identityField?: string;
     /** Fact 5, edge fields — the kind's fields that are references to other members. */
     readonly edgeFields?: readonly EdgeField[];
@@ -216,7 +231,123 @@ export interface KindFacts {
     /** External-fact source backing the guidance — a doc URL plus retrieved date,
      * carried as data. */
     readonly cite?: string;
-}
+} | {
+    /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
+    readonly name: string;
+    /** The declared provider authority, when the kind qualifies by one. */
+    readonly provider?: string;
+    /**
+     * The built-in kind this facts value **relocates** — set only by {@link relocate},
+     * from the base kind's own name, never authored. It is the authoring layer's
+     * *provenance* fact: the value was derived from the imported built-in, so a
+     * second same-named kind in play is a sanctioned relocation rather than a name
+     * collision. It never reaches a kind-fact row — the lock reader holds no base
+     * value to compare against and re-decides *structurally* instead
+     * (`src/compose.rs`'s `row_relocates_builtin`).
+     */
+    readonly relocates?: string;
+    /** Fact 2, locus — where members live, and for a file locus whether their documents
+     * are committed: a `local` commitment class declares the kind reviewed and its
+     * members' documents not. */
+    readonly locus: {
+        readonly kind: "embedded";
+    };
+    /** Fact 3a, projection — the artifact format; omitted for a kind that declares none. */
+    readonly format?: Format;
+    /** Fact 3b, projection — the on-disk unit shape. */
+    readonly unitShape: UnitShape;
+    /** Fact 4, registration — embedded members register nothing. */
+    readonly registration: readonly [];
+    /**
+     * The frontmatter key the member's name writes under. For `unitShape:
+     * "named-field"` this is the id **source** — the declared field a member's
+     * identity is read from (an agent's `name`), never the filename or directory.
+     * For `"directory"` it is a projection-order detail only (a skill's `name`
+     * still writes into frontmatter, but identity is the directory name); absent
+     * when identity is the file stem and no field carries it (a rule), or the
+     * starred directory segment (`"starred-segment"`) — both path-derived, never a
+     * field.
+     */
+    readonly identityField?: string;
+    /** Fact 5, edge fields — the kind's fields that are references to other members. */
+    readonly edgeFields?: readonly EdgeField[];
+    /** Fact 6, content — a declared {@link Layout} over the body's heading tree; absent
+     * leaves the kind `file`-content (one verbatim prose body, the default). */
+    readonly content?: Layout;
+    /** Fact 6b, content — the fields-only body shape (`"fields"`, no body slot); absent
+     * leaves the kind body-bearing (`file` or a {@link Layout}). */
+    readonly shape?: Shape;
+    /** The registration member's {@link CollectionAddress} — which manifest and key path
+     * its registration surfaces at; absent for a kind that owns its own file locus. */
+    readonly collectionAddress?: CollectionAddress;
+    /** Fact 7, template — one {@link Template} per inner layer of nested members the kind
+     * hosts; absent for a kind that nests nothing. */
+    readonly templates?: readonly Template[];
+    /** Advisory authoring counsel for the kind as a whole — teaching at authoring time via
+     * `schema` hover or `explain`, carrying no predicate or severity (decision 0045). */
+    readonly guidance?: string;
+    /** External-fact source backing the guidance — a doc URL plus retrieved date,
+     * carried as data. */
+    readonly cite?: string;
+} | {
+    /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
+    readonly name: string;
+    /** The declared provider authority, when the kind qualifies by one. */
+    readonly provider?: string;
+    /**
+     * The built-in kind this facts value **relocates** — set only by {@link relocate},
+     * from the base kind's own name, never authored. It is the authoring layer's
+     * *provenance* fact: the value was derived from the imported built-in, so a
+     * second same-named kind in play is a sanctioned relocation rather than a name
+     * collision. It never reaches a kind-fact row — the lock reader holds no base
+     * value to compare against and re-decides *structurally* instead
+     * (`src/compose.rs`'s `row_relocates_builtin`).
+     */
+    readonly relocates?: string;
+    /** Fact 2, locus — where members live, and for a file locus whether their documents
+     * are committed: a `local` commitment class declares the kind reviewed and its
+     * members' documents not. */
+    readonly locus: {
+        readonly kind: "nested-file";
+    };
+    /** Fact 3a, projection — the artifact format; omitted for a kind that declares none. */
+    readonly format?: Format;
+    /** Fact 3b, projection — the on-disk unit shape. */
+    readonly unitShape: UnitShape;
+    /** Fact 4, registration — nested-file members register nothing. */
+    readonly registration: readonly [];
+    /**
+     * The frontmatter key the member's name writes under. For `unitShape:
+     * "named-field"` this is the id **source** — the declared field a member's
+     * identity is read from (an agent's `name`), never the filename or directory.
+     * For `"directory"` it is a projection-order detail only (a skill's `name`
+     * still writes into frontmatter, but identity is the directory name); absent
+     * when identity is the file stem and no field carries it (a rule), or the
+     * starred directory segment (`"starred-segment"`) — both path-derived, never a
+     * field.
+     */
+    readonly identityField?: string;
+    /** Fact 5, edge fields — the kind's fields that are references to other members. */
+    readonly edgeFields?: readonly EdgeField[];
+    /** Fact 6, content — a declared {@link Layout} over the body's heading tree; absent
+     * leaves the kind `file`-content (one verbatim prose body, the default). */
+    readonly content?: Layout;
+    /** Fact 6b, content — the fields-only body shape (`"fields"`, no body slot); absent
+     * leaves the kind body-bearing (`file` or a {@link Layout}). */
+    readonly shape?: Shape;
+    /** The registration member's {@link CollectionAddress} — which manifest and key path
+     * its registration surfaces at; absent for a kind that owns its own file locus. */
+    readonly collectionAddress?: CollectionAddress;
+    /** Fact 7, template — one {@link Template} per inner layer of nested members the kind
+     * hosts; absent for a kind that nests nothing. */
+    readonly templates?: readonly Template[];
+    /** Advisory authoring counsel for the kind as a whole — teaching at authoring time via
+     * `schema` hover or `explain`, carrying no predicate or severity (decision 0045). */
+    readonly guidance?: string;
+    /** External-fact source backing the guidance — a doc URL plus retrieved date,
+     * carried as data. */
+    readonly cite?: string;
+};
 /**
  * One authored member — a typed value in the library. Kind identity travels by
  * import (`facts`), never by string; the
@@ -285,6 +416,73 @@ export interface KindOptions {
  * it builds, since it is erased before a member reaches emit.
  */
 export declare function kind<T extends object>(facts: KindFacts, options?: KindOptions): KindDefinition<T>;
+/**
+ * A **relocation delta** — the facts a relocated built-in kind diverges from its base
+ * on. Two faces, either or both:
+ *
+ * - `edgeFields`, *added* to whatever the base already declares (never replacing them,
+ *   which would drop a shipped kind's own edges silently). Each added field names a key
+ *   of the relocated kind's typed surface `T`, so an edge can never be declared over a
+ *   field the kind does not carry.
+ * - `governs`, *replacing* the base's `at` locus root and glob — moving where the kind's
+ *   members are found, the one fact the engine's own overlay exists to apply
+ *   (`src/compose.rs`'s `overlay_builtin_kind`).
+ *
+ * Every other fact — format, unit shape, registration, content, templates — rides
+ * through unchanged, which is exactly what makes the emitted row still read as a
+ * relocation rather than a name collision on the reading side.
+ */
+export interface KindRelocation<T> {
+    /** The edge fields this relocation adds, each over a field of the kind's own surface. */
+    readonly edgeFields?: readonly {
+        readonly field: keyof T & string;
+        readonly to: readonly [string, ...string[]];
+    }[];
+    /**
+     * The locus this relocation moves the kind's members to — root and glob, the two
+     * columns the lock reader's overlay writes back. A file locus's `commitment` class is
+     * deliberately absent: the overlay writes `Governs { root, glob }` and nothing else, so
+     * a `commitment` delta would author a fact the reader drops in silence — a built-in's
+     * commitment class stays the built-in's.
+     */
+    readonly governs?: {
+        readonly root: string;
+        readonly glob: string;
+    };
+}
+/**
+ * **Relocate** a built-in kind: the sanctioned way an adopting corpus moves a kind it
+ * does not own to its own root, adds an edge field to it, or both. Returns a fresh
+ * constructor over the widened typed surface `T` (the base's fields plus the added edge
+ * fields, spelled by the caller as one interface), carrying the base's facts with
+ * `delta`'s edge fields appended, `delta`'s `governs` in place of the base's locus root
+ * and glob, and the base's own {@link KindDefinition.render} hook preserved. Ownership,
+ * not privilege — a relocated built-in is an ordinary kind value from here on, and its
+ * added edge reaches the lock as an assembly `edge` row keyed by `from`, exactly as any
+ * kind's does (`declarations.ts`), never as a column on a kind-fact row.
+ *
+ * A moved locus, by contrast, *is* a kind-fact row column pair: the emitted row carries
+ * the delta's `governs_root`/`governs_glob` while `format`, `unit_shape` and
+ * `registration` stay the base's — which is precisely the three-fact test the lock
+ * reader applies before overlaying the row onto its compiled-in built-in
+ * (`src/compose.rs`'s `row_relocates_builtin`), so the engine reads members at the new
+ * root rather than treating the row as a colliding kind.
+ *
+ * The produced facts carry `relocates`, naming the base — the marker that tells a
+ * legitimate relocation from a genuine name collision when two same-named kinds are in
+ * play. Identity travels by import: the base is the imported built-in value, so the
+ * provenance is proven here rather than inferred downstream.
+ *
+ * # Throws
+ * If an added edge field re-declares one the base already carries, or one another
+ * entry of the same delta already added — two `edge` rows over one `<from, field>`
+ * cross-wire the graph instead of declaring one relationship. If a `governs` delta
+ * names a base whose locus is not `at` ({@link relocatedLocus}). And if the delta
+ * declares neither face, which would mint a marker-bearing clone of the base — a second
+ * same-named kind diverging on nothing, which is a name collision spelled as a
+ * relocation.
+ */
+export declare function relocate<T extends object>(base: KindDefinition<any>, delta: KindRelocation<T>): KindDefinition<T>;
 /**
  * One entry in a sibling collection: its own key plus its leaf fields
  * (`rejected."baked-projection"`) — an ordered list element, never a positional
@@ -390,8 +588,14 @@ export interface ResolvedEmbeddedMemberValue {
  * composed value's shape. A bare string names a kind whose facts are out of reach, so
  * such a value renders with no target facts.
  */
+export declare function embeddedMemberValue<T extends object>(init: {
+    kind: KindDefinition<T>;
+    key: string;
+    leaves: Readonly<Record<keyof T, string | Text>>;
+    collections?: EmbeddedMemberValue["collections"];
+}): EmbeddedMemberValue;
 export declare function embeddedMemberValue(init: {
-    kind: string | KindDefinition<any>;
+    kind: string;
     key: string;
     leaves: Readonly<Record<string, string | Text>>;
     collections?: EmbeddedMemberValue["collections"];

package/dist/src/kind.js

@@ -72,13 +72,83 @@ export function kind(facts, options = {}) {
     return Object.assign(construct, { facts, key: facts.name, render: options.render });
 }
 /**
- * Compose an embedded member's value for `blocks()` — the shape any project's own
- * child kind uses. `kind` names the child kind: a bare string, or the child kind's
- * own `KindDefinition` — passing the definition carries its `render` hook and its
- * declared edge fields (when declared) through to emit, with no other change to the
- * composed value's shape. A bare string names a kind whose facts are out of reach, so
- * such a value renders with no target facts.
+ * The locus a `governs` delta moves the base to: the base's `at` root and glob replaced,
+ * every other locus fact (its commitment class among them) riding through.
+ *
+ * # Throws
+ * If the base's locus is not `at` — an embedded or nested-file kind governs no glob at
+ * all (its members compose their paths from a host's unit, or own no file), so there is
+ * no locus to move and its row carries no `governs` columns to move it to.
+ */
+function relocatedLocus(base, governs) {
+    if (base.locus.kind !== "at") {
+        throw new Error(`relocating kind \`${base.name}\`: a \`governs\` delta moves the ` +
+            `path glob a kind's members are found at, and this kind's locus is \`${base.locus.kind}\` ` +
+            `— it governs no glob of its own. Drop the \`governs\` face of the delta ` +
+            `(specs/model/representation.md, "locus").`);
+    }
+    return { ...base.locus, root: governs.root, glob: governs.glob };
+}
+/**
+ * **Relocate** a built-in kind: the sanctioned way an adopting corpus moves a kind it
+ * does not own to its own root, adds an edge field to it, or both. Returns a fresh
+ * constructor over the widened typed surface `T` (the base's fields plus the added edge
+ * fields, spelled by the caller as one interface), carrying the base's facts with
+ * `delta`'s edge fields appended, `delta`'s `governs` in place of the base's locus root
+ * and glob, and the base's own {@link KindDefinition.render} hook preserved. Ownership,
+ * not privilege — a relocated built-in is an ordinary kind value from here on, and its
+ * added edge reaches the lock as an assembly `edge` row keyed by `from`, exactly as any
+ * kind's does (`declarations.ts`), never as a column on a kind-fact row.
+ *
+ * A moved locus, by contrast, *is* a kind-fact row column pair: the emitted row carries
+ * the delta's `governs_root`/`governs_glob` while `format`, `unit_shape` and
+ * `registration` stay the base's — which is precisely the three-fact test the lock
+ * reader applies before overlaying the row onto its compiled-in built-in
+ * (`src/compose.rs`'s `row_relocates_builtin`), so the engine reads members at the new
+ * root rather than treating the row as a colliding kind.
+ *
+ * The produced facts carry `relocates`, naming the base — the marker that tells a
+ * legitimate relocation from a genuine name collision when two same-named kinds are in
+ * play. Identity travels by import: the base is the imported built-in value, so the
+ * provenance is proven here rather than inferred downstream.
+ *
+ * # Throws
+ * If an added edge field re-declares one the base already carries, or one another
+ * entry of the same delta already added — two `edge` rows over one `<from, field>`
+ * cross-wire the graph instead of declaring one relationship. If a `governs` delta
+ * names a base whose locus is not `at` ({@link relocatedLocus}). And if the delta
+ * declares neither face, which would mint a marker-bearing clone of the base — a second
+ * same-named kind diverging on nothing, which is a name collision spelled as a
+ * relocation.
  */
+export function relocate(base, delta) {
+    const declaredEdges = delta.edgeFields ?? [];
+    if (declaredEdges.length === 0 && delta.governs === undefined) {
+        throw new Error(`relocating kind \`${base.facts.name}\`: a relocation declares at least one diverging ` +
+            `fact — \`edgeFields\`, \`governs\`, or both. A delta declaring neither mints a ` +
+            `second kind of the base's own name that diverges on nothing, which reads as a name ` +
+            `collision rather than a relocation (specs/model/representation.md, "kind").`);
+    }
+    const locus = delta.governs === undefined ? undefined : relocatedLocus(base.facts, delta.governs);
+    const inherited = base.facts.edgeFields ?? [];
+    const claimed = new Set(inherited.map((edge) => edge.field));
+    const added = [];
+    for (const edge of declaredEdges) {
+        if (claimed.has(edge.field)) {
+            throw new Error(`relocating kind \`${base.facts.name}\`: edge field \`${edge.field}\` is already ` +
+                `declared, and a second declaration of one field cross-wires the graph rather than ` +
+                `adding a relationship (specs/model/representation.md, "kind").`);
+        }
+        claimed.add(edge.field);
+        added.push({ field: edge.field, to: edge.to });
+    }
+    const edgeFields = [...inherited, ...added];
+    const relocated = { ...base.facts, relocates: base.facts.name, edgeFields };
+    // Two spellings, not one with an optional `locus`: `KindFacts` is a union discriminated
+    // on the locus, so the moved case must carry the `at` locus as its own literal branch.
+    const facts = locus === undefined ? relocated : { ...relocated, locus };
+    return kind(facts, { render: base.render });
+}
 export function embeddedMemberValue(init) {
     const definition = typeof init.kind === "string" ? undefined : init.kind;
     const render = definition?.render;

package/dist/src/member-address.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The member-address grammar — one home for every spelling a member's identity takes and
+ * for the reader those writers round-trip against. Three spellings, each the one before
+ * it plus a segment:
+ *
+ * - `<kind>:<name>` — a **host address**, a top-level member's own identity.
+ * - `<host-address>/<kind>/<key>` — a **nested-member address**, the identity a member
+ *   embedded in a host carries.
+ * - `<member>/<kind>/<key>/<leaf>` — a **leaf address**, one authored string beneath a
+ *   nested member. A grain of its own, and no member address at all.
+ *
+ * Because the third is the second plus a `/<leaf>` tail, both are read off one
+ * segmentation ({@link segment}) rather than two independently-shaped parses that could
+ * come to disagree about where the member ends. The engine's `src/member_address.rs` is
+ * the other end of the same grammar: a spelling moves on both sides at once or the seam
+ * breaks.
+ */
+/** The two halves a host address names — the reader's answer, and never re-split by hand. */
+export interface HostAddress {
+    /** The member's kind. */
+    readonly kind: string;
+    /** The member's name among its kind. */
+    readonly name: string;
+}
+/** One parsed nested-member address. */
+export interface NestedAddress {
+    /** The host member's own `<kind>:<name>` address — the segment before the first `/`. */
+    readonly host: string;
+    /** The nested member's kind. */
+    readonly kind: string;
+    /** The nested member's key among its host's members of that kind. */
+    readonly key: string;
+}
+/** One parsed leaf address — a nested-member address plus its `/<leaf>` tail. */
+export interface LeafAddress {
+    /**
+     * The member the leaf lives under, verbatim as its author spelled it: the canonical
+     * `<kind>:<name>` host address, or the bare member id this SDK's own leaf writer and
+     * the committed lock mention targets spell. Which of the two a head is, is resolution's
+     * question, not the grammar's.
+     */
+    readonly member: string;
+    /** The nested member's kind. */
+    readonly kind: string;
+    /** The nested member's key among its host's members of that kind. */
+    readonly key: string;
+    /** The leaf's path within the nested member — the whole remainder after the third slash. */
+    readonly childPath: string;
+}
+/** Spell a top-level member's own `<kind>:<name>` address. */
+export declare function hostAddress(kind: string, name: string): string;
+/** Spell a nested member's address from its host's address, its own kind and its key. */
+export declare function nestedAddress(host: string, kind: string, key: string): string;
+/**
+ * Spell one leaf's address beneath a nested member. `member` is carried verbatim, so a
+ * writer holding the bare member id spells the short form the lock already commits
+ * ({@link LeafAddress.member}).
+ */
+export declare function leafAddress(member: string, kind: string, key: string, childPath: string): string;
+/**
+ * The member-table **lookup key** a bare `<kind>:<key>` reference spells — shaped like a
+ * host address and never one: a nested member's address composes through its host, and a
+ * corpus-unique key was rejected as the grammar because uniqueness is the resolver's bar,
+ * not the grammar's. The engine strips this prefix back off before matching, so the two
+ * ends agree and the apparent mismatch is not a defect to fix.
+ */
+export declare function bareLookupKey(kind: string, key: string): string;
+/**
+ * The key an authored edge address is looked up under: a one-element `to` set resolves a
+ * bare address within its one admissible kind, so an unqualified address is lifted into a
+ * {@link bareLookupKey}; an address already carrying a colon is the kind-qualified form
+ * the author wrote and stands as it is.
+ */
+export declare function edgeLookupKey(address: string, to: readonly string[]): string;
+/**
+ * The `(kind, name)` a host address spells, or `undefined` when it spells none — the
+ * reader half of {@link hostAddress}. Both halves are non-empty: an address names exactly
+ * one thing or it names nothing. Splits at the **first** colon, so a name carrying one
+ * stays whole.
+ *
+ * A `/` anywhere is this grammar's own segment separator ({@link segment} splits on it),
+ * so an address carrying one is a segmented spelling with its own reader
+ * ({@link parseNestedAddress}, {@link parseLeafAddress}) and no host address at all. The
+ * refusal lives here rather than at each caller, so a reader that asks "is this a host
+ * address?" never has to re-spell the separator to get the answer right.
+ */
+export declare function parseHostAddress(address: string): HostAddress | undefined;
+/**
+ * Parse a nested-member address, or `undefined` when `address` is not one: exactly three
+ * non-empty segments, the first of them a host address.
+ *
+ * A `/<leaf>` tail is ruled out here explicitly — a leaf is its own grain, and truncating
+ * one to the member that happens to contain it would answer a leaf reference with a member
+ * the author never named.
+ */
+export declare function parseNestedAddress(address: string): NestedAddress | undefined;
+/**
+ * Parse a leaf address, or `undefined` when `target` carries no tail or a segment-shaped
+ * hole. The head is carried on verbatim rather than split, because the bare member id is
+ * a live short form ({@link LeafAddress.member}).
+ */
+export declare function parseLeafAddress(target: string): LeafAddress | undefined;

package/dist/src/member-address.js

@@ -0,0 +1,114 @@
+/**
+ * The member-address grammar — one home for every spelling a member's identity takes and
+ * for the reader those writers round-trip against. Three spellings, each the one before
+ * it plus a segment:
+ *
+ * - `<kind>:<name>` — a **host address**, a top-level member's own identity.
+ * - `<host-address>/<kind>/<key>` — a **nested-member address**, the identity a member
+ *   embedded in a host carries.
+ * - `<member>/<kind>/<key>/<leaf>` — a **leaf address**, one authored string beneath a
+ *   nested member. A grain of its own, and no member address at all.
+ *
+ * Because the third is the second plus a `/<leaf>` tail, both are read off one
+ * segmentation ({@link segment}) rather than two independently-shaped parses that could
+ * come to disagree about where the member ends. The engine's `src/member_address.rs` is
+ * the other end of the same grammar: a spelling moves on both sides at once or the seam
+ * breaks.
+ */
+/** Spell a top-level member's own `<kind>:<name>` address. */
+export function hostAddress(kind, name) {
+    return `${kind}:${name}`;
+}
+/** Spell a nested member's address from its host's address, its own kind and its key. */
+export function nestedAddress(host, kind, key) {
+    return `${host}/${kind}/${key}`;
+}
+/**
+ * Spell one leaf's address beneath a nested member. `member` is carried verbatim, so a
+ * writer holding the bare member id spells the short form the lock already commits
+ * ({@link LeafAddress.member}).
+ */
+export function leafAddress(member, kind, key, childPath) {
+    return `${nestedAddress(member, kind, key)}/${childPath}`;
+}
+/**
+ * The member-table **lookup key** a bare `<kind>:<key>` reference spells — shaped like a
+ * host address and never one: a nested member's address composes through its host, and a
+ * corpus-unique key was rejected as the grammar because uniqueness is the resolver's bar,
+ * not the grammar's. The engine strips this prefix back off before matching, so the two
+ * ends agree and the apparent mismatch is not a defect to fix.
+ */
+export function bareLookupKey(kind, key) {
+    return `${kind}:${key}`;
+}
+/**
+ * The key an authored edge address is looked up under: a one-element `to` set resolves a
+ * bare address within its one admissible kind, so an unqualified address is lifted into a
+ * {@link bareLookupKey}; an address already carrying a colon is the kind-qualified form
+ * the author wrote and stands as it is.
+ */
+export function edgeLookupKey(address, to) {
+    return to.length === 1 && !address.includes(":") ? bareLookupKey(to[0], address) : address;
+}
+/**
+ * The `(kind, name)` a host address spells, or `undefined` when it spells none — the
+ * reader half of {@link hostAddress}. Both halves are non-empty: an address names exactly
+ * one thing or it names nothing. Splits at the **first** colon, so a name carrying one
+ * stays whole.
+ *
+ * A `/` anywhere is this grammar's own segment separator ({@link segment} splits on it),
+ * so an address carrying one is a segmented spelling with its own reader
+ * ({@link parseNestedAddress}, {@link parseLeafAddress}) and no host address at all. The
+ * refusal lives here rather than at each caller, so a reader that asks "is this a host
+ * address?" never has to re-spell the separator to get the answer right.
+ */
+export function parseHostAddress(address) {
+    if (address.includes("/"))
+        return undefined;
+    const colon = address.indexOf(":");
+    if (colon <= 0 || colon === address.length - 1)
+        return undefined;
+    return { kind: address.slice(0, colon), name: address.slice(colon + 1) };
+}
+/**
+ * Cut an address into its segments, or `undefined` when it carries fewer than three or a
+ * segment-shaped hole. The tail keeps its own dots and slashes, so it is the whole
+ * remainder after the third slash rather than a fourth segment among more.
+ */
+function segment(address) {
+    const parts = address.split("/");
+    if (parts.length < 3)
+        return undefined;
+    const [host, kind, key] = parts;
+    const tail = parts.length > 3 ? parts.slice(3).join("/") : undefined;
+    if (host === "" || kind === "" || key === "" || tail === "")
+        return undefined;
+    return { host, kind, key, tail };
+}
+/**
+ * Parse a nested-member address, or `undefined` when `address` is not one: exactly three
+ * non-empty segments, the first of them a host address.
+ *
+ * A `/<leaf>` tail is ruled out here explicitly — a leaf is its own grain, and truncating
+ * one to the member that happens to contain it would answer a leaf reference with a member
+ * the author never named.
+ */
+export function parseNestedAddress(address) {
+    const segments = segment(address);
+    if (segments === undefined || segments.tail !== undefined)
+        return undefined;
+    if (parseHostAddress(segments.host) === undefined)
+        return undefined;
+    return { host: segments.host, kind: segments.kind, key: segments.key };
+}
+/**
+ * Parse a leaf address, or `undefined` when `target` carries no tail or a segment-shaped
+ * hole. The head is carried on verbatim rather than split, because the bare member id is
+ * a live short form ({@link LeafAddress.member}).
+ */
+export function parseLeafAddress(target) {
+    const segments = segment(target);
+    if (segments?.tail === undefined)
+        return undefined;
+    return { member: segments.host, kind: segments.kind, key: segments.key, childPath: segments.tail };
+}

package/dist/src/prose.d.ts

@@ -19,8 +19,8 @@ export interface Mentionable {
 }
 /**
  * Spell a top-level member as the {@link Mentionable} a mention carries: its
- * `kind:name` address, its bare name the display text — the convention every
- * corpus repeats to cite a member from prose, captured once here.
+ * {@link hostAddress}, its bare name the display text — the convention every corpus
+ * repeats to cite a member from prose.
  */
 export declare function mentionOf(member: Member): Mentionable;
 /** One authored interpolation: position in the template plus its target. */
@@ -57,11 +57,11 @@ export interface MentionScope {
 }
 /**
  * Whether a mention's unresolved address **defers to the gate** rather than refusing at
- * emit: a top-level `kind:name` address whose kind is one the program declares at a
- * discovery locus (an `at`-locus kind) may name a member discovered on disk, so `check`
- * owns the verdict. An embedded leaf address (a `<host>/<kind>/<key>` form, carrying a
- * `/`), a bare requirement name (no `:`), or a kind the program does not declare has no
- * discovery locus and stays a dangling refusal.
+ * emit: a host address ({@link parseHostAddress}) whose kind is one the program declares
+ * at a discovery locus (an `at`-locus kind) may name a member discovered on disk, so
+ * `check` owns the verdict. Anything the grammar's reader answers `undefined` for — a
+ * segmented embedded address, a bare requirement name, a name-less `kind:` — names no
+ * discoverable member, and stays a dangling refusal however deferrable its head reads.
  */
 export declare function defersToGate(address: string, deferrableKinds: ReadonlySet<string>): boolean;
 /**

package/dist/src/prose.js

@@ -9,27 +9,26 @@
  * **include** (an {@link Include}) pulls the target file's bytes into the host's emitted
  * projection. Both are authored per word and resolution-checked at emit, never mined.
  */
+import { hostAddress, parseHostAddress } from "./member-address.js";
 /**
  * Spell a top-level member as the {@link Mentionable} a mention carries: its
- * `kind:name` address, its bare name the display text — the convention every
- * corpus repeats to cite a member from prose, captured once here.
+ * {@link hostAddress}, its bare name the display text — the convention every corpus
+ * repeats to cite a member from prose.
  */
 export function mentionOf(member) {
-    return { address: `${member.kind}:${member.name}`, display: member.name };
+    return { address: hostAddress(member.kind, member.name), display: member.name };
 }
 /**
  * Whether a mention's unresolved address **defers to the gate** rather than refusing at
- * emit: a top-level `kind:name` address whose kind is one the program declares at a
- * discovery locus (an `at`-locus kind) may name a member discovered on disk, so `check`
- * owns the verdict. An embedded leaf address (a `<host>/<kind>/<key>` form, carrying a
- * `/`), a bare requirement name (no `:`), or a kind the program does not declare has no
- * discovery locus and stays a dangling refusal.
+ * emit: a host address ({@link parseHostAddress}) whose kind is one the program declares
+ * at a discovery locus (an `at`-locus kind) may name a member discovered on disk, so
+ * `check` owns the verdict. Anything the grammar's reader answers `undefined` for — a
+ * segmented embedded address, a bare requirement name, a name-less `kind:` — names no
+ * discoverable member, and stays a dangling refusal however deferrable its head reads.
  */
 export function defersToGate(address, deferrableKinds) {
-    if (address.includes("/"))
-        return false;
-    const colon = address.indexOf(":");
-    return colon > 0 && deferrableKinds.has(address.slice(0, colon));
+    const host = parseHostAddress(address);
+    return host !== undefined && deferrableKinds.has(host.kind);
 }
 /**
  * Refuse a mention whose address neither resolves against the scope's `mentionable`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "The temper authoring face — the six-noun model as typed modules: harness(), kind<T>(), clause values, needs, and file()/text/blocks(). Emit compiles to the declaration rows the engine reads, a byte-faithful projection, and the lock.",
   "license": "(MIT OR Apache-2.0)",
   "repository": {
@@ -52,7 +52,7 @@
     "temper": "bin/temper.js"
   },
   "optionalDependencies": {
-    "@dtmd/temper-linux-x64": "0.0.16",
-    "@dtmd/temper-win32-x64": "0.0.16"
+    "@dtmd/temper-linux-x64": "0.0.18",
+    "@dtmd/temper-win32-x64": "0.0.18"
   }
 }