@dtmd/temper 0.0.17 → 0.0.19

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,9 +585,12 @@ 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
@@ -562,14 +601,48 @@ function settingsResidue(harness) {
  * `emit` on every harness with two hooks on one event (0.0.16).
  */
 function memberTable(harness) {
-    const table = uniqueMap(harness.members
-        .filter((member) => !isRegistration(member))
-        .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(`${member.kind}:${member.name}`, member);
+        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) {
     return [...harness.members]
@@ -578,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

@@ -38,10 +38,11 @@ export type ClauseRow = {
      */
     label?: string;
     /**
-     * The kind whose contract carries the clause. `None` when this row is nested
-     * inside a [`RequirementRow`]'s own [`clauses`](RequirementRow::clauses) — a
-     * requirement's set-scope demand names no kind of its own; it ranges over
-     * whatever kind the requirement's own row already carries.
+     * The kind whose contract carries the clause. `None` has two homes, distinguished
+     * by nesting rather than by a second column: inside a [`RequirementRow`]'s own
+     * [`clauses`](RequirementRow::clauses) it is the requirement's set-scope demand,
+     * ranging over whatever kind the requirement's own row already carries; at the top
+     * level it is the **root member's** clause, ranging over the whole governed forest.
      */
     kind?: string;
     /**
@@ -49,7 +50,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;
     /**
@@ -71,14 +79,28 @@ export type ClauseRow = {
      */
     count?: CountBoundRow;
     /**
-     * The `membership` clause's target requirement name, when the predicate is
-     * `membership`.
+     * The **requirement name** whose satisfiers a clause reads its second selection
+     * from — two owners, one naming scheme: `membership`'s allowed-set source and
+     * `reached-from`'s closure roots. Both ask the same question of the same column
+     * ("which requirement's satisfiers?"), so a second column would be the residue
+     * class ([`crate::contract::predicate_from_row`] decodes either from here).
      */
     target?: string;
     /**
      * The `degree` clause's in/out edge-count bound, when the predicate is `degree`.
      */
     degree?: DegreeBoundRow;
+    /**
+     * The **field set** a by-incidence clause filters its selection to — `degree`'s
+     * bound and `reached-from`'s via set (`specs/decisions/0056-…`). Shared rather
+     * than nested inside [`DegreeBoundRow`] because the filter is the *clause's*, not
+     * either direction's, and the two consumers name one concept: a lock spelling it
+     * twice would be the residue class.
+     *
+     * Absent ⇒ unfiltered, so no committed lock row moves when a clause declares no
+     * filter.
+     */
+    fields?: Array<string>;
     /**
      * The `mention-reachable` clause's **target-side gate field**, when the predicate
      * is `mention-reachable`. The one predicate taking two field arguments: its

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

@@ -1,6 +1,7 @@
 import type { AssemblyFactRow } from "./AssemblyFactRow.js";
 import type { ClauseRow } from "./ClauseRow.js";
 import type { IncludeRow } from "./IncludeRow.js";
+import type { InputRow } from "./InputRow.js";
 import type { KindFactRow } from "./KindFactRow.js";
 import type { MentionRow } from "./MentionRow.js";
 import type { NestedMemberRow } from "./NestedMemberRow.js";
@@ -65,6 +66,13 @@ export type Declarations = {
      * declaration table, so a lock round-trip reads it empty).
      */
     includes: Array<IncludeRow>;
+    /**
+     * The members' declared inputs — the files their claims rest on. Seam-inbound
+     * like `includes`: `emit` resolves and fingerprints each as an `input` source
+     * dependency without moving a byte into any projection, so a lock round-trip reads
+     * this family empty.
+     */
+    inputs: Array<InputRow>;
     /**
      * The host members' declared embedded-member facts — captured as declaration
      * rows rather than a second copy the engine reads back off the rendered fence

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

@@ -0,0 +1,21 @@
+/**
+ * One **declared input** the SDK declares — a file the member's claims rest on, and the
+ * member that rests on it. Its own type, not a reuse of [`IncludeRow`]: an include's
+ * path pairs positionally with a body slot, an input's moves nothing, and two concepts
+ * sharing two columns are still two concepts.
+ *
+ * A seam-inbound row only, the same posture an include takes: `emit` resolves it against
+ * disk ([`resolve_source_dependency`]) and lowers it to a fingerprinted `input` source
+ * dependency — this row itself never reaches the lock. Nothing is spliced and no byte
+ * moves, so the target is never decoded and a binary input is legal.
+ */
+export type InputRow = {
+    /**
+     * The declaring member's own `kind:name` address.
+     */
+    member: string;
+    /**
+     * The input's SDK-resolved absolute path.
+     */
+    source_path: string;
+};

package/dist/src/generated/InputRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

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

@@ -73,6 +73,18 @@ export type KindFactRow = {
      * take, so a body-bearing kind's row stays byte-identical.
      */
     shape?: string;
+    /**
+     * The kind's **leaf set** — the leaf names a member of it carries, derived at emit
+     * from the member value type the SDK knows, never authored twice (decision 0053).
+     * Empty for a kind whose declaration carries none, the same tolerant round-trip
+     * [`registration`](KindFactRow::registration) takes, so a committed lock written
+     * before the column existed re-reads byte-identically.
+     *
+     * The declaration a read verb renders where the surface holds no member yet: the
+     * type is the declaration, so a present set outranks the union of what members
+     * carry today.
+     */
+    leaves?: Array<string>;
     /**
      * The declared **collection address** — for a registration member surfacing inside a
      * host manifest, which manifest and which key path it keys at. Absent for a

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

@@ -15,6 +15,7 @@ export type { FeatureValue } from "./FeatureValue.js";
 export type { Features } from "./Features.js";
 export type { FencedBlock } from "./FencedBlock.js";
 export type { IncludeRow } from "./IncludeRow.js";
+export type { InputRow } from "./InputRow.js";
 export type { KindFactRow } from "./KindFactRow.js";
 export type { LayoutRegionRow } from "./LayoutRegionRow.js";
 export type { LayoutRow } from "./LayoutRow.js";

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * temper's authoring face — the six-noun core as a typed module library.
  * A harness author imports plain nouns — `harness()`, the generic `kind`
- * constructor, the clause and requirement constructors, `needs`, and the three
+ * constructor, the clause and requirement constructors, `needs`, and the four
  * prose constructors — and composes members as typed values. `emit` compiles the
  * whole into the declaration rows and the projected members' erased payload —
  * the JSON pipe printed to stdout; the engine is the sole compiler of every
@@ -13,16 +13,17 @@
  * the `./claude-code` subpath, never here.
  */
 export type { Blocks, File, Include, Mention, Mentionable, Prose, Reference, Text } from "./prose.js";
-export { blocks, file, include, mentionOf, renderText, text } from "./prose.js";
+export { blocks, file, include, mentionOf, renderText, span, text } from "./prose.js";
 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 { allowedChars, clause, closedKeys, count, degree, deny, enumOf, extent, forbiddenKeys, formatPlacesEdges, fresh, globValid, locusDeclared, maxLen, membership, mentionReachable, minLen, mustDefine, nameMatchesDir, optional, range, reachable, reachedFrom, required, requireSections, requirement, script, sectionContains, shape, telemetry, type, unique, uniqueName, when, } from "./contract.js";
+export type { CollectionAddress, EdgeField, EdgeTargetFacts, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, Input, KindDefinition, KindFacts, KindOptions, KindRelocation, Layout, LayoutRegion, LeafSet, Locus, Member, MemberInit, Registration, Residue, ResolvedEmbeddedMemberCollectionEntry, ResolvedEmbeddedMemberValue, Shape, Template, UnitShape, } from "./kind.js";
+export { embeddedMemberValue, kind, relocate } from "./kind.js";
+export { input } 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 { harness, rootDefaultContract } from "./assembly.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

@@ -1,7 +1,7 @@
 /**
  * temper's authoring face — the six-noun core as a typed module library.
  * A harness author imports plain nouns — `harness()`, the generic `kind`
- * constructor, the clause and requirement constructors, `needs`, and the three
+ * constructor, the clause and requirement constructors, `needs`, and the four
  * prose constructors — and composes members as typed values. `emit` compiles the
  * whole into the declaration rows and the projected members' erased payload —
  * the JSON pipe printed to stdout; the engine is the sole compiler of every
@@ -12,10 +12,14 @@
  * The first-party Claude Code provider face — the built-in kinds — lives at
  * the `./claude-code` subpath, never here.
  */
-export { blocks, file, include, mentionOf, renderText, text } from "./prose.js";
+export { blocks, file, include, mentionOf, renderText, span, 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 { harness } from "./assembly.js";
+export { allowedChars, clause, closedKeys, count, degree, deny, enumOf, extent, forbiddenKeys, formatPlacesEdges, fresh, globValid, locusDeclared, maxLen, membership, mentionReachable, minLen, mustDefine, nameMatchesDir, optional, range, reachable, reachedFrom, required, requireSections, requirement, script, sectionContains, shape, telemetry, type, unique, uniqueName, when, } from "./contract.js";
+export { embeddedMemberValue, kind, relocate } from "./kind.js";
+// Inputs — the files a member's claims rest on, fingerprinted by the lock and moved
+// nowhere. A member-grain declaration, not a word in a body, so it rides here rather
+// than on the prose line.
+export { input } from "./kind.js";
+export { harness, rootDefaultContract } from "./assembly.js";
 export { emit } from "./emit.js";
 export { dial, dialDefaultContract } from "./dial.js";