@dtmd/temper 0.0.6 → 0.0.8

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

@@ -12,8 +12,9 @@ import type { SectionContainsRow } from "./SectionContainsRow.js";
  * and, per predicate, its own argument: the node-set/edge-scope predicates
  * carry
  * their bounds/target, and the node-scope predicates that need more than
- * `field`/`severity` (`min_len`/`max_len`/`max_lines`'s bound, `allowed_chars`'s
- * charset, `forbidden_keys`'s keys, `deny`'s values) carry theirs too — so a kind's
+ * `field`/`severity` (`min_len`/`max_len`/`extent`'s bound, `extent`'s unit,
+ * `allowed_chars`'s charset, `forbidden_keys`'s keys, `deny`'s values, `type`'s declared
+ * kind) carry theirs too — so a kind's
  * own floor clause round-trips losslessly, not identity+severity alone.
  * `unique`'s field rides the shared `field`
  * column (the same slot `required`/`min_len`/… target); the rest carry their own
@@ -24,6 +25,18 @@ import type { SectionContainsRow } from "./SectionContainsRow.js";
  * [`crate::contract::Predicate`] already makes for its own `Range` bounds.
  */
 export type ClauseRow = {
+    /**
+     * The clause's **address** — the deterministic, human-legible label
+     * [`crate::contract::clause_label`] derives from the row's identity columns, and
+     * the row's identity in the lock: every finding this clause produces prints it as
+     * the diagnostic `rule` id, `explain` narrates it, and the dial names a clause by
+     * it.
+     *
+     * `None` on a payload row and `Some` on a lock row: emit is the one writer
+     * ([`emit`]), stamping every row as it composes the lock, so the seam has no label
+     * to author and no way to author a wrong one.
+     */
+    label?: string;
     /**
      * The kind whose contract carries the clause. `None` when this row is nested
      * inside a [`RequirementRow`]'s own [`clauses`](RequirementRow::clauses) — a
@@ -67,10 +80,51 @@ export type ClauseRow = {
      */
     degree?: DegreeBoundRow;
     /**
-     * The `min_len`/`max_len`/`max_lines` clause's scalar bound, when the predicate
+     * The `mention-reachable` clause's **target-side gate field**, when the predicate
+     * is `mention-reachable`. The one predicate taking two field arguments: its
+     * source-side scope field rides the shared [`field`](ClauseRow::field) column, and
+     * this column carries the other end — the field read off the *mentioned* member,
+     * which `field` alone cannot express.
+     */
+    gate?: string;
+    /**
+     * The `type` clause's declared source kinds, when the predicate is `type` — the
+     * lattice names (`string`/`integer`/`number`/`boolean`/`null`/`list`/`map`) that
+     * [`crate::extract::ValueType::from_name`] decodes. Carried as names rather than
+     * as [`crate::extract::ValueType`]s: the lattice is a feature-side type, and the
+     * row family decodes its arguments at the boundary.
+     *
+     * A **set**, since a `type` clause declares one: the column is an array of names
+     * in lattice order, and a one-element array is the single-kind clause. A lock
+     * written by an older engine spells that case as a bare string, which
+     * [`ClauseRow::from_table`] reads as the one-element set it means; the next `emit`
+     * rewrites the file whole in the array form, which is the upgrade — a committed
+     * lock is re-emitted from its source, never patched in place.
+     */
+    value_type?: Array<string>;
+    /**
+     * The `shape` clause's declared shape, when the predicate is `shape` — the closed
+     * set's own spelling (`hyphen-placement`/`no-xml-tags`) that
+     * [`crate::contract::Shape::from_name`] decodes. Carried as a name rather than as a
+     * [`crate::contract::Shape`], the trade `value_type` already makes: the row family
+     * carries its arguments as names and decodes them at the boundary.
+     *
+     * One name, never a set — a clause names exactly one shape — so this is a plain
+     * string column, and no read-side skew tolerance answers it.
+     */
+    shape?: string;
+    /**
+     * The `min_len`/`max_len`/`extent` clause's scalar bound, when the predicate
      * is one of those three.
      */
     bound?: BoundRow;
+    /**
+     * The `extent` clause's declared unit (`lines`/`characters`), when the predicate is
+     * `extent` — the closed set [`crate::contract::ExtentUnit::from_name`] decodes, an
+     * unknown value refused at load. Carried as a name, the trade the whole row family
+     * makes for its closed-vocabulary arguments.
+     */
+    unit?: string;
     /**
      * The `allowed_chars` clause's declared character class, when the predicate is
      * `allowed_chars`.
@@ -94,4 +148,20 @@ export type ClauseRow = {
      * predicate is `section_contains`.
      */
     section?: SectionContainsRow;
+    /**
+     * The `require_sections` clause's required heading list, when the predicate is
+     * `require_sections`.
+     */
+    sections?: Array<string>;
+    /**
+     * The `when` clause's guard predicate key (`enum` or `type`), when the predicate
+     * is `when`. The guard predicate's own arguments (field, values, etc.) ride the
+     * shared columns as if it were a bare guard row.
+     */
+    guard_predicate?: string;
+    /**
+     * The `when` clause's nested body rows, when the predicate is `when` — the
+     * clauses evaluated where the guard holds.
+     */
+    body?: Array<ClauseRow>;
 };

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

@@ -0,0 +1,21 @@
+/**
+ * A kind's declared **collection address** row — the manifest a registration member
+ * surfaces in and the key path it keys at, the presence-coupled pair
+ * [`KindFactRow::collection_address`] carries. Absent from a [`KindFactRow`] means the
+ * kind owns its own file locus.
+ */
+export type CollectionAddressRow = {
+    /**
+     * The host manifest the registration surfaces in (`settings.json`, `.mcp.json`).
+     */
+    manifest: string;
+    /**
+     * The manifest key path the registration keys at (`hooks.<Event>`, `mcpServers.*`), a
+     * closed vocabulary the engine's kind lift rejects an unknown value from.
+     */
+    key_path: string;
+    /**
+     * The entry's declared shape — whether it's an object, scalar, or group-array.
+     */
+    entry_shape: string | null;
+};

package/dist/src/generated/CollectionAddressRow.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/Declarations.d.ts

@@ -4,8 +4,10 @@ import type { IncludeRow } from "./IncludeRow.js";
 import type { KindFactRow } from "./KindFactRow.js";
 import type { MentionRow } from "./MentionRow.js";
 import type { NestedMemberRow } from "./NestedMemberRow.js";
+import type { RegistrationRow } from "./RegistrationRow.js";
 import type { RequirementRow } from "./RequirementRow.js";
 import type { SatisfiesRow } from "./SatisfiesRow.js";
+import type { SettingsRow } from "./SettingsRow.js";
 /**
  * The lock's **declaration-row family** — the composed program's erased declarations,
  * beside the
@@ -69,4 +71,19 @@ export type Declarations = {
      * (0018, "the projection is not the database").
      */
     nested_members: Array<NestedMemberRow>;
+    /**
+     * The fields-only registration members the SDK erased for the manifest write face —
+     * seam-inbound carrying their folded fields, so `emit` routes each host manifest whole
+     * through the canonical write face. The lock's `registration` family records only each
+     * member's identity and collection address; the fields live in the projected manifest
+     * artifact, never a second copy read back (0018), so a lock round-trip reads them
+     * fieldless.
+     */
+    registrations: Array<RegistrationRow>;
+    /**
+     * The harness-level settings residue — seam-inbound opaque `settings.json` keys with
+     * no member home, folded into their manifest's residue at emit. Like `includes`, never
+     * written into this declaration table, so a lock round-trip reads none.
+     */
+    settings: Array<SettingsRow>;
 };

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

@@ -10,9 +10,9 @@ import type { EmbeddedMemberCollectionEntry } from "./EmbeddedMemberCollectionEn
  * addressed structurally (member + kind + key + child path) so drift, `impact`, and
  * citations survive rewording ([`EmbeddedMember::addressed_leaves`]).
  *
- * Floor leaves carry no mentions — interpolation stays deferred until a floor
- * mention syntax is separately ratified — so a
- * leaf is a plain [`String`], not a mention-bearing span.
+ * Floor leaves carry no mentions: an edge is declared at a position, never matched as
+ * a pattern within prose, so no floor mention syntax can exist and a leaf is
+ * permanently a plain [`String`], never a mention-bearing span.
  */
 export type EmbeddedMember = {
     /**

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

@@ -4,8 +4,8 @@ import type { ValueType } from "./ValueType.js";
  * [`ValueType`] alongside its comparison text), a list field (e.g. a YAML sequence
  * like `allowed-tools`), or a map field. Scalar predicates (`min_len`, `enum`,
  * `deny`, `allowed_chars`) read the scalar text; presence predicates
- * (`required`, `forbidden_keys`) need only the key; the `type` primitive
- * (forthcoming) reads [`FeatureValue::kind`].
+ * (`required`, `forbidden_keys`) need only the key; the `type` primitive reads
+ * [`FeatureValue::kind`].
  */
 export type FeatureValue = {
     "Scalar": {

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

@@ -1,5 +1,4 @@
 import type { EmbeddedMember } from "./EmbeddedMember.js";
-import type { FeatureValue } from "./FeatureValue.js";
 import type { FencedBlock } from "./FencedBlock.js";
 import type { Section } from "./Section.js";
 /**
@@ -15,14 +14,46 @@ export type Features = {
      * Frontmatter fields by name — the typed fields *and* the `extra` keys, so
      * a clause resolves `name`/`description`/`version` or any unknown key
      * (e.g. for `forbidden_keys`) through one generic lookup.
+     *
+     * Each value is retained **as parsed**, never flattened: a clause addresses a field
+     * by a path that may step into an object or grain over an array's elements
+     * ([`Features::locate`]), so the nesting has to survive extraction. Projection to
+     * the [`FeatureValue`] the predicates read happens at the read edge
+     * ([`json_to_feature`]), on the node the path located rather than on the top-level
+     * value alone.
+     *
+     * A retained value is arbitrary parsed JSON, and the binding says exactly that: the
+     * TS face narrows before it reads, because typing the value is the *contract*'s job
+     * and no consumer of this map knows the kind yet.
      */
     fields: {
-        [key in string]: FeatureValue;
+        [key in string]: unknown;
     };
     /**
-     * The artifact body's line count (for `max_lines`).
+     * The artifact body's line count — the `line_count` primitive's feature, populated
+     * only when a kind composes it.
      */
     body_lines: number;
+    /**
+     * The member's **rendered extent** in lines — the projection's line count, measured
+     * intrinsically off every unit rather than gated behind a composed primitive, since
+     * `extent` is node-scope and must decide over any kind's members. Distinct from
+     * [`body_lines`](Features::body_lines): that reads only where `line_count` is
+     * composed; this carries the projected body's size.
+     *
+     * `None` where nothing rendered a projection to measure — an embedded member read off
+     * a layout host's source, never a format's output. A file member always carries
+     * `Some` (its committed body is the projection), so an `extent` clause over it stays
+     * decidable; a `None` member's `extent` is undecidable rather than a zero read as a
+     * pass.
+     */
+    rendered_lines: number | null;
+    /**
+     * The member's **rendered extent** in characters — the projection's character count,
+     * the second unit an `extent` clause measures in. `None` on the same terms as
+     * [`rendered_lines`](Features::rendered_lines).
+     */
+    rendered_chars: number | null;
     /**
      * The ATX headings (`#`..`######`) in the body, in document order, with the
      * `#` run and any closing `#` run trimmed (for `require_sections`). A `#`
@@ -79,4 +110,22 @@ export type Features = {
      * decidable feature.
      */
     satisfies: Array<string>;
+    /**
+     * Each edge this member *carries*, paired with whether the format that renders the
+     * member placed it — the feature a `format-places-edges` clause decides over. The
+     * carried set is the lock's `assembly` `edge` facts for this member's kind, narrowed
+     * to the fields its own row fills; the placed set is its
+     * [`NestedMemberRow::placed_edges`](crate::drift::NestedMemberRow::placed_edges),
+     * which `emit` captured while rendering. It arrives as a declaration row because
+     * the engine never sees the `render` hook and never reads a projection back.
+     *
+     * The two ways a member offers nothing to indict stay apart, because an empty map
+     * standing for both is what would leave the clause undecidable: `None` is no format
+     * at all (a layout host's document is source, so no rendering happened, and a kind
+     * declaring no edge places nothing either way), `Some` over an empty map is a format
+     * that ran with no carried edge to place. Both hold; neither is a fabricated pass.
+     */
+    edge_placements: {
+        [key in string]: boolean;
+    } | null;
 };

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

@@ -1,4 +1,6 @@
+import type { CollectionAddressRow } from "./CollectionAddressRow.js";
 import type { LayoutRow } from "./LayoutRow.js";
+import type { TemplateRow } from "./TemplateRow.js";
 /**
  * One kind's declaration row — its identity and declared runtime facts.
  * The optional facts are omitted from the lock when the kind declares none, so the row
@@ -14,13 +16,29 @@ export type KindFactRow = {
      */
     provider?: string;
     /**
-     * The `governs` locus root directory.
+     * The `governs` locus root directory. Absent together with
+     * [`governs_glob`](KindFactRow::governs_glob) for a **nested file** kind: its members'
+     * paths compose from their host's unit and the host template's pattern, so it governs
+     * no glob of its own and two kinds still never share one.
      */
-    governs_root: string;
+    governs_root?: string;
     /**
-     * The `governs` locus filename glob.
+     * The `governs` locus filename glob, absent for a nested file kind (see
+     * [`governs_root`](KindFactRow::governs_root)).
      */
-    governs_glob: string;
+    governs_glob?: string;
+    /**
+     * The file locus's declared **commitment class** label — `local` for a per-machine,
+     * uncommitted locus: the kind is declared and reviewed, its members' documents are
+     * not. Absent for the committed class every
+     * shipped kind takes, so an ordinary row stays byte-identical — the same tolerant
+     * round-trip the rest of the optional facts take.
+     *
+     * A local member's rows never enter the lock, so this column is the *whole* of a
+     * local kind's residue here: the row declares the kind, and the documents it governs
+     * derive at read time under it.
+     */
+    commitment?: string;
     /**
      * The declared projection format label, when declared.
      */
@@ -36,16 +54,29 @@ export type KindFactRow = {
      */
     registration?: Array<string>;
     /**
-     * The host kind's declared nesting templates — the embedded child kind names it
-     * folds embedded members of. Empty for
+     * The kind's declared nesting templates — one [`TemplateRow`] per inner layer of
+     * nested members it hosts. Empty for
      * a kind that nests nothing, the tolerant round-trip a lockless/template-less
      * kind takes.
      */
-    templates?: Array<string>;
+    templates?: Array<TemplateRow>;
     /**
      * The declared content: absent for a `file`-content kind (the default the whole
      * built-in set takes, so those rows stay byte-identical), a [`LayoutRow`] for a
      * kind whose body is a declared layout over its heading tree.
      */
     content?: LayoutRow;
+    /**
+     * The **fields-only** body-shape marker — `fields` for a no-body-slot kind (a hook,
+     * an MCP server); absent for a body-bearing kind, whose body is `file` or a `content`
+     * layout. The tolerant `#[serde(default)]` round-trip the rest of the optional facts
+     * take, so a body-bearing kind's row stays byte-identical.
+     */
+    shape?: 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
+     * file-locus kind, so an ordinary row stays byte-identical.
+     */
+    collection_address?: CollectionAddressRow;
 };

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

@@ -1,9 +1,11 @@
 /**
  * One authored `n` mention edge's declaration row — the citing member's own
  * `kind:name` address and the address its mention names (another member's
- * `kind:name`, or a bare requirement name), already resolved at emit. Recorded
- * unconditionally: a dangling mention never reaches the lock (`emit` refuses
- * first), so this row carries no resolution state of its own.
+ * `kind:name`, or a bare requirement name). Recorded unconditionally, carrying no
+ * resolution state of its own: `emit` refuses a mention naming no declared kind
+ * before a byte is written, while a mention naming a declared kind with no composed
+ * member defers — its row rides the lock for `check` to resolve against the
+ * discovered corpus.
  */
 export type MentionRow = {
     /**

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

@@ -36,4 +36,36 @@ export type NestedMemberRow = {
     collections: {
         [key in string]: Array<CollectionEntryWire>;
     };
+    /**
+     * The declared edge fields this value's **format placed** — which of them the
+     * format selected while `emit` rendered the value, sorted. The engine never sees
+     * a format and never reads a rendering back, so an edge's placement reaches it
+     * here or not at all; the declared set it is measured against is the `assembly`
+     * family's `edge` facts for [`kind`](Self::kind).
+     *
+     * `None` and `Some(vec![])` are distinct, and the distinction is the whole point:
+     * `Some(vec![])` is a format that placed no edge (a `format-places-edges` finding
+     * per declared edge), while `None` is a value **no format rendered** — a member
+     * embedded in a layout document is read off its host's declared layout, so it has
+     * no format to omit anything and the clause has nothing to decide. Absent from a
+     * row whose value no format rendered, so an ordinary row stays byte-identical.
+     */
+    placed_edges?: Array<string>;
+    /**
+     * The value's **rendered extent** in lines — the line count of the block `emit`
+     * projected for this member, captured off the same render, so an `extent` clause bound
+     * to the embedded kind budgets real data instead of a hardcoded zero.
+     *
+     * `None` is a member **no format rendered** — one embedded in a layout document, read
+     * off its host's declared layout rather than projected — which has no rendered span to
+     * measure, so its `extent` stays undecidable. Absent from such a row, so an ordinary
+     * row stays byte-identical (the [`placed_edges`](Self::placed_edges) precedent).
+     */
+    rendered_lines?: number;
+    /**
+     * The value's **rendered extent** in characters — the second unit an `extent` clause
+     * measures in, captured off the same render. `None` on the same terms as
+     * [`rendered_lines`](Self::rendered_lines).
+     */
+    rendered_chars?: number;
 };

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

@@ -13,6 +13,12 @@ export type PayloadMember = {
      * Identity within the kind.
      */
     name: string;
+    /**
+     * The `kind:name` address of the host member this member's unit composes under —
+     * carried by a **nested file** child, whose path is its host's unit joined with the
+     * host template's pattern; absent at every other locus.
+     */
+    host?: string;
     /**
      * The kind's typed fields, flat and ordered — the projected frontmatter. The
      * value is arbitrary JSON, so the seam type is `unknown`, never a serde_json

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

@@ -0,0 +1,35 @@
+/**
+ * One fields-only registration member the SDK erased for the manifest write face — a
+ * hook, an MCP server — carried across the seam so `emit` routes its host manifest whole
+ * through the canonical write face ([`crate::json_manifest::write_manifest`]) rather than
+ * the unrepresented in-place splice. `kind`/`key` are the member's identity; `manifest`/
+ * `key_path` name the collection address it surfaces at; `fields` are its folded typed
+ * fields — the entry value the write face places under `key`.
+ *
+ * **Seam-inbound with `fields`.** The lock's `registration` declaration family records
+ * only the identity and address: the fields live in the projected manifest artifact, never
+ * a second copy the engine reads back (0018, "the projection is not the database"), so a
+ * row read back off the lock carries an empty `fields`.
+ */
+export type RegistrationRow = {
+    /**
+     * The registration kind's bare name — `hook`, `mcp-server` — joining `declarations.kinds`.
+     */
+    kind: string;
+    /**
+     * The member's key among its collection's entries — a hook's event, a server's name.
+     */
+    key: string;
+    /**
+     * The host manifest the registration surfaces in (`settings.json`, `.mcp.json`).
+     */
+    manifest: string;
+    /**
+     * The manifest key-path label the registration keys at (`hooks.<Event>`, `mcpServers.*`).
+     */
+    key_path: string;
+    /**
+     * The member's folded typed fields — seam-inbound only, dropped from the lock row.
+     */
+    fields: Array<[string, unknown]>;
+};

package/dist/src/generated/RegistrationRow.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/RequirementRow.d.ts

@@ -1,4 +1,5 @@
 import type { ClauseRow } from "./ClauseRow.js";
+import type { Verifier } from "./Verifier.js";
 /**
  * One named requirement's declaration row,
  * carrying the scalar facets plus the requirement's own **clause rows** — the
@@ -29,9 +30,10 @@ export type RequirementRow = {
      */
     clauses: Array<ClauseRow>;
     /**
-     * The external verifier for the behavioral remainder, when declared.
+     * The typed verifier for the behavioral remainder, when declared — a
+     * species-tagged [`Verifier`], resolved at admissibility, never run.
      */
-    verified_by?: string;
+    verifier?: Verifier;
     /**
      * The authored intent the requirement exists to carry, when declared —
      * carried verbatim, never interpreted.

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

@@ -4,7 +4,8 @@
  */
 export type SatisfiesRow = {
     /**
-     * The filling member's id.
+     * The filling member's own `kind:name` address — the same qualified label a
+     * [`MentionRow`] carries, so a same-named member of another kind never collides.
      */
     member: string;
     /**

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

@@ -0,0 +1,25 @@
+/**
+ * One harness-level settings-residue key the SDK erased for the manifest write face — an
+ * opaque top-level key of the manifest it names (Claude Code's `settings.json`) with no
+ * typed member kind of its own yet. Carried across the seam so `emit` folds it into that
+ * manifest's opaque residue beside the collection segments its registration members build.
+ *
+ * **Seam-inbound with `value`.** Like a composed-prose include, this row is consumed at
+ * emit and never written into the lock's declaration table: the value lives in the
+ * projected manifest artifact, never a second copy the engine reads back (0018), so a lock
+ * round-trip carries none.
+ */
+export type SettingsRow = {
+    /**
+     * The host manifest the residue key surfaces in (`settings.json`).
+     */
+    manifest: string;
+    /**
+     * The residue key — an opaque top-level manifest key with no member home.
+     */
+    key: string;
+    /**
+     * The key's opaque JSON value, placed verbatim into the manifest's residue.
+     */
+    value: unknown;
+};

package/dist/src/generated/SettingsRow.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/Shape.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The closed set of value forms a [`Predicate::Shape`] clause may name.
+ *
+ * A member exists only where an external document states the rule and this engine
+ * implements it, so the set is closed by construction and an author extends it with
+ * nothing: the enum *is* the vocabulary, and [`from_name`](Shape::from_name) rejects
+ * anything outside it at load. That closure is the whole safety property — it is what
+ * separates a shape from an open lint, which no clause may become.
+ *
+ * Each member's mechanics are one regex plus a polarity: [`pattern`](Shape::pattern) is
+ * the expression, [`match_holds`](Shape::match_holds) says whether matching it means the
+ * shape holds or is violated. One definition serves both the gate and the emitted
+ * schema, so the two channels cannot decide the same shape differently.
+ */
+export type Shape = "hyphen-placement" | "no-xml-tags" | "leading-dot-slash";

package/dist/src/generated/Shape.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/TemplateRow.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A kind's declared **nesting template** row — one inner layer of nested members the
+ * kind hosts: the child kind, plus the `path` pattern (relative to the parent's unit)
+ * when that layer's children are files (`model/representation.md`, "kind"). The child
+ * kind alone means an embedded layer: the children live in the host's own body, so no
+ * path addresses them.
+ *
+ * A declared template is the kind's own nesting *fact*, never a resolution rule: a
+ * host's actual embedded members are resolved off [`Declarations::nested_members`] by
+ * address, and nothing discovers a file child off its `path` pattern.
+ */
+export type TemplateRow = {
+    /**
+     * The child kind this layer templates — the `member.<kind>` an embedded child's
+     * fence info string carries, or the kind a file child's unit is read as.
+     */
+    kind: string;
+    /**
+     * The path pattern a file child's unit sits at, relative to the parent's unit
+     * (a skill's `*.md`). Absent for an embedded layer, whose children have no unit of
+     * their own.
+     */
+    path?: string;
+};

package/dist/src/generated/TemplateRow.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/ValueType.d.ts

@@ -3,7 +3,16 @@
  * field schema ranges over. Taken from the *parsed*
  * YAML/JSON value, not its stringified form: a sound `type` check needs the
  * extractor to preserve the source kind rather than collapse every scalar to a
- * bare string (the slice-1 shortcut this entry corrects). The five scalar kinds
+ * bare string. The five scalar kinds
  * answer [`FeatureValue::as_scalar`]; the two container kinds do not.
+ *
+ * The binding renames to lowercase so the TS spelling is the one
+ * [`ValueType::from_name`] decodes — the lattice has one name across the seam,
+ * and a `type` clause's declared kind crosses the lock in that spelling.
+ *
+ * `Ord` is the declaration order above, and it is what gives a declared *set* of
+ * kinds one canonical spelling: a `type` clause holds its kinds in a `BTreeSet`, so
+ * the order an author wrote them in never reaches the lock, the diagnostic, or the
+ * emitted schema.
  */
-export type ValueType = "String" | "Integer" | "Number" | "Boolean" | "Null" | "List" | "Map";
+export type ValueType = "string" | "integer" | "number" | "boolean" | "null" | "list" | "map";

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

@@ -0,0 +1,20 @@
+/**
+ * A requirement's **typed verifier** — the declared delegate that judges the
+ * behavioral remainder, resolved at admissibility and never run. Two species this
+ * slice; a probe stays a documented pattern until a consumer types its transcript
+ * surface. One shared shape: [`crate::drift::RequirementRow`] carries it on the
+ * wire and [`crate::roster`] resolves over it.
+ */
+export type Verifier = {
+    "species": "script";
+    /**
+     * The test/CI path, relative to the harness root.
+     */
+    path: string;
+} | {
+    "species": "telemetry";
+    /**
+     * The harness lifecycle event names this verifier reads the tap for.
+     */
+    events: Array<string>;
+};

package/dist/src/generated/Verifier.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/index.d.ts

@@ -2,6 +2,7 @@ export type { AssemblyFactRow } from "./AssemblyFactRow.js";
 export type { BoundRow } from "./BoundRow.js";
 export type { CharsetRow } from "./CharsetRow.js";
 export type { ClauseRow } from "./ClauseRow.js";
+export type { CollectionAddressRow } from "./CollectionAddressRow.js";
 export type { CollectionEntryRow } from "./CollectionEntryRow.js";
 export type { CollectionEntryWire } from "./CollectionEntryWire.js";
 export type { CountBoundRow } from "./CountBoundRow.js";
@@ -22,8 +23,13 @@ export type { NestedMemberRow } from "./NestedMemberRow.js";
 export type { Payload } from "./Payload.js";
 export type { PayloadMember } from "./PayloadMember.js";
 export type { RangeBoundRow } from "./RangeBoundRow.js";
+export type { RegistrationRow } from "./RegistrationRow.js";
 export type { RequirementRow } from "./RequirementRow.js";
 export type { SatisfiesRow } from "./SatisfiesRow.js";
 export type { Section } from "./Section.js";
 export type { SectionContainsRow } from "./SectionContainsRow.js";
+export type { SettingsRow } from "./SettingsRow.js";
+export type { Shape } from "./Shape.js";
+export type { TemplateRow } from "./TemplateRow.js";
 export type { ValueType } from "./ValueType.js";
+export type { Verifier } from "./Verifier.js";