@dtmd/temper 0.0.4 → 0.0.7

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

@@ -0,0 +1,40 @@
+import type { ClauseRow } from "./ClauseRow.js";
+/**
+ * One named requirement's declaration row,
+ * carrying the scalar facets plus the requirement's own **clause rows** — the
+ * set-scope demands
+ * the roster/graph checks range over. No facet columns: a demand's severity,
+ * argument, and — for `unique`/`membership` — targeted field ride the nested
+ * [`ClauseRow`], the identical row shape a kind's own floor clauses use.
+ *
+ * Not `Eq`: its nested [`ClauseRow`]s may carry `f64` `range` bounds.
+ */
+export type RequirementRow = {
+    /**
+     * The requirement's name.
+     */
+    name: string;
+    /**
+     * The kind that may fill it, when typed by one.
+     */
+    kind?: string;
+    /**
+     * Whether an unfilled requirement blocks the gate.
+     */
+    required: boolean;
+    /**
+     * The requirement's set-/edge-scope demands, in declaration order — a
+     * `count`/`unique`/`membership`/`degree` [`ClauseRow`] per clause, each
+     * carrying its own severity. Empty ⇒ no set-scope demand.
+     */
+    clauses: Array<ClauseRow>;
+    /**
+     * The external verifier for the behavioral remainder, when declared.
+     */
+    verified_by?: string;
+    /**
+     * The authored intent the requirement exists to carry, when declared —
+     * carried verbatim, never interpreted.
+     */
+    prose?: string;
+};

package/dist/src/generated/RequirementRow.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * One member→requirement fill edge's declaration row — the `satisfies` join the
+ * roster/coverage tiers need, carried on the lock rather than re-imported.
+ */
+export type SatisfiesRow = {
+    /**
+     * The filling member's id.
+     */
+    member: string;
+    /**
+     * The requirement key the member opts into filling.
+     */
+    requirement: string;
+};

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

@@ -0,0 +1,21 @@
+/**
+ * One ATX **section** of a markdown body: a heading paired with the body span
+ * beneath it, up to the next heading of the same or a shallower level. The
+ * feature a `section_contains` clause decides over — its [`heading`](Section::heading) is
+ * matched by the clause's declared prefix, its [`body`](Section::body) searched
+ * for the declared marker. Surface-decidable like every other feature: a heading
+ * inside a fenced code block opens no section (the same exclusion
+ * [`body_headings`] makes), so a section is never a guess.
+ */
+export type Section = {
+    /**
+     * The heading text, with its `#` markers stripped exactly as
+     * [`body_headings`] strips them.
+     */
+    heading: string;
+    /**
+     * The body span beneath the heading — the intervening lines rejoined with
+     * `\n`, the text a `section_contains` marker check searches.
+     */
+    body: string;
+};

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

@@ -0,0 +1,14 @@
+/**
+ * A `section_contains` clause row's arguments — the heading-text prefix selecting the
+ * governed sections and the marker every governed section's body must carry.
+ */
+export type SectionContainsRow = {
+    /**
+     * The heading-text prefix that selects the sections the clause governs.
+     */
+    heading: string;
+    /**
+     * The marker text every governed section's body must contain.
+     */
+    marker: string;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * A field's parsed source kind — the closed scalar/container lattice a kind's
+ * 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
+ * answer [`FeatureValue::as_scalar`]; the two container kinds do not.
+ */
+export type ValueType = "String" | "Integer" | "Number" | "Boolean" | "Null" | "List" | "Map";

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

@@ -0,0 +1,32 @@
+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";
+export type { Declarations } from "./Declarations.js";
+export type { DegreeBoundRow } from "./DegreeBoundRow.js";
+export type { EdgeBoundRow } from "./EdgeBoundRow.js";
+export type { EmbeddedMember } from "./EmbeddedMember.js";
+export type { EmbeddedMemberCollectionEntry } from "./EmbeddedMemberCollectionEntry.js";
+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 { KindFactRow } from "./KindFactRow.js";
+export type { LayoutRegionRow } from "./LayoutRegionRow.js";
+export type { LayoutRow } from "./LayoutRow.js";
+export type { MentionRow } from "./MentionRow.js";
+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 { ValueType } from "./ValueType.js";

package/dist/src/generated/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/index.d.ts

@@ -1,32 +1,28 @@
 /**
- * temper's authoring face — the six-noun core as a typed module library
- * (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`).
- * A harness author imports plain nouns — `harness()`, the generic `kind`/`genre`
- * constructors, the clause and requirement constructors, `needs`, and the three
+ * 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
  * 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
- * projection and the whole lock (`20-surface.md`, "The seam — one
- * implementation"). Every type erases at the seam, and Turing-completeness
+ * projection and the whole lock.
+ * Every type erases at the seam, and Turing-completeness
  * stays quarantined at authoring time.
  *
  * The first-party Claude Code provider face — the built-in `skill`/`rule`/
- * `memory` kinds — lives at the `./claude-code` subpath, never here
- * (`specs/architecture/50-distribution.md`, "Decision: one SDK package").
+ * `memory` kinds — lives at the `./claude-code` subpath, never here.
  */
-export type { Blocks, File, Mention, Mentionable, Prose, Text } from "./prose.js";
-export { blocks, file, renderText, text } from "./prose.js";
-export type { GenreValue } from "./genres.js";
-export { genreValue } from "./genres.js";
+export type { Blocks, File, Include, Mention, Mentionable, Prose, Reference, Text } from "./prose.js";
+export { blocks, file, include, renderText, text } from "./prose.js";
 export type { Capability } from "./needs.js";
 export { bash, capability, permissionUnion } from "./needs.js";
 export type { Charset, Clause, Predicate, Requirement, Severity } from "./contract.js";
-export { allowedChars, clause, count, degree, deny, forbiddenKeys, maxLen, maxLines, membership, minLen, nameMatchesDir, required, requireSections, requirement, type, unique, } from "./contract.js";
-export type { EdgeField, Format, KindDefinition, KindFacts, Locus, Member, MemberInit, Registration, UnitShape, } from "./kind.js";
-export { genre, kind } from "./kind.js";
-export type { ExpectBinding, Harness } from "./assembly.js";
+export { allowedChars, clause, count, degree, deny, enumOf, forbiddenKeys, maxLen, maxLines, membership, minLen, mustDefine, nameMatchesDir, optional, range, required, requireSections, requirement, sectionContains, type, unique, uniqueName, } from "./contract.js";
+export type { CollectionAddress, EdgeField, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, Shape, UnitShape, } from "./kind.js";
+export { embeddedMemberValue, kind } from "./kind.js";
+export type { EnforcementMode, ExpectBinding, Harness } from "./assembly.js";
 export { harness } from "./assembly.js";
 export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./declarations.js";
-export { SEAM_VERSION, compileDeclarations, declarationsToJson } from "./declarations.js";
-export type { EmitOptions, EmitResult, PayloadMember, ResolveOptions } from "./emit.js";
+export { SEAM_VERSION, compileDeclarations } from "./declarations.js";
+export type { EmitResult, PayloadMember, RegistrationFact, ResolveOptions } from "./emit.js";
 export { emit } from "./emit.js";

package/dist/src/index.js

@@ -1,24 +1,21 @@
 /**
- * temper's authoring face — the six-noun core as a typed module library
- * (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`).
- * A harness author imports plain nouns — `harness()`, the generic `kind`/`genre`
- * constructors, the clause and requirement constructors, `needs`, and the three
+ * 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
  * 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
- * projection and the whole lock (`20-surface.md`, "The seam — one
- * implementation"). Every type erases at the seam, and Turing-completeness
+ * projection and the whole lock.
+ * Every type erases at the seam, and Turing-completeness
  * stays quarantined at authoring time.
  *
  * The first-party Claude Code provider face — the built-in `skill`/`rule`/
- * `memory` kinds — lives at the `./claude-code` subpath, never here
- * (`specs/architecture/50-distribution.md`, "Decision: one SDK package").
+ * `memory` kinds — lives at the `./claude-code` subpath, never here.
  */
-export { blocks, file, renderText, text } from "./prose.js";
-export { genreValue } from "./genres.js";
+export { blocks, file, include, renderText, text } from "./prose.js";
 export { bash, capability, permissionUnion } from "./needs.js";
-export { allowedChars, clause, count, degree, deny, forbiddenKeys, maxLen, maxLines, membership, minLen, nameMatchesDir, required, requireSections, requirement, type, unique, } from "./contract.js";
-export { genre, kind } from "./kind.js";
+export { allowedChars, clause, count, degree, deny, enumOf, forbiddenKeys, maxLen, maxLines, membership, minLen, mustDefine, nameMatchesDir, optional, range, required, requireSections, requirement, sectionContains, type, unique, uniqueName, } from "./contract.js";
+export { embeddedMemberValue, kind } from "./kind.js";
 export { harness } from "./assembly.js";
-export { SEAM_VERSION, compileDeclarations, declarationsToJson } from "./declarations.js";
+export { SEAM_VERSION, compileDeclarations } from "./declarations.js";
 export { emit } from "./emit.js";

package/dist/src/kind.d.ts

@@ -1,27 +1,36 @@
 /**
- * Kinds — the engine room (`specs/architecture/15-kinds.md`, "A kind is a
- * constructor plus five facts"). A kind is a plain typed surface — an interface
- * `T` and a constructor `kind<T>()` — plus five facts of runtime residue: label,
- * locus, layout, registration, and edge fields. `tsc` is the keystroke wall; every
- * type erases at the seam, and what a kind leaves behind is those five facts,
- * riding the lock as rows. Identity travels by import, never by string — a `kind`
- * reference is the imported value (`15-kinds.md`, the built-ins-are-a-module
- * Decision).
- */
-import type { Prose } from "./prose.js";
+ * Kinds — the engine room. A kind is a plain typed surface — an interface
+ * `T` and a constructor `kind<T>()` — plus six facts of runtime residue: label,
+ * locus, layout, registration, edge fields, and content. A registration kind (a hook,
+ * an MCP server) extends the content fact with a fields-only `shape` and a
+ * `collectionAddress` naming the host manifest it surfaces in. `tsc` is the keystroke
+ * wall; every type erases at the seam, and what a kind leaves behind rides the lock as
+ * rows. Identity travels by import, never by string — a `kind` reference is the imported
+ * value.
+ */
+import type { Prose, Text } from "./prose.js";
 import type { Capability } from "./needs.js";
 import type { Requirement } from "./contract.js";
 /** The shape of the on-disk artifact a member projects to (fact 3, layout). */
 export type Format = "yaml-frontmatter";
-/** Whether a member is a lone file (identity from the stem) or a directory with an entry file. */
-export type UnitShape = "file" | "directory";
 /**
- * A kind's **registration** — the declared edge between a member and the world
- * (fact 4, `15-kinds.md`, "Registration"). Reachability is graph reachability
- * from the world node over these edges.
+ * Whether a member is a lone file (identity from the stem), a directory with an
+ * entry file (identity from the directory name), or a lone file whose identity is
+ * read from a declared frontmatter field (`identityField`) instead of derived from
+ * the path (an agent's `name`).
+ */
+export type UnitShape = "file" | "directory" | "named-field";
+/**
+ * One **channel** a kind's registration declares — a documented way a member
+ * reaches the world (fact 4, `builtins.md`, "The shipped kinds": "user
+ * invocation and description trigger are channels, not rivals"). Reachability
+ * is graph reachability from the world node, OR'd across a member's declared
+ * channel set — live on any one channel is live.
  */
 export type Registration = {
     readonly via: "always";
+} | {
+    readonly via: "user-invoked";
 } | {
     readonly via: "description-trigger";
     readonly field: string;
@@ -42,7 +51,7 @@ export interface EdgeField {
 }
 /**
  * A kind's **locus** (fact 2): members live at path globs (`at`) or as typed
- * fenced blocks inside host documents (`genre`). An `at` locus is split root +
+ * fenced blocks inside host documents (`embedded`). An `at` locus is split root +
  * glob so the kind fact row carries `governs_root`/`governs_glob` directly.
  */
 export type Locus = {
@@ -50,10 +59,53 @@ export type Locus = {
     readonly root: string;
     readonly glob: string;
 } | {
-    readonly kind: "genre";
+    readonly kind: "embedded";
     readonly withinHosts: readonly string[];
 };
-/** The five facts of a kind's runtime residue (`15-kinds.md`). */
+/**
+ * One region of a kind's **layout** — one of the three corpus primitives over the
+ * body's heading tree. `prose` is a verbatim span, or an `import` reference resolving to
+ * a file's contents; `field` is a heading whose span fills a named field `slot`;
+ * `collection` is a heading whose child headings are each one member of `memberKind`,
+ * identity the slugged child heading unless an explicit `key` overrides it.
+ */
+export type LayoutRegion = {
+    readonly region: "prose";
+    readonly import?: string;
+} | {
+    readonly region: "field";
+    readonly slot: string;
+} | {
+    readonly region: "collection";
+    readonly memberKind: string;
+    readonly key?: string;
+};
+/**
+ * A declared **layout** — the ordered regions a `layout`-content kind's body is read as.
+ * Declaring one on a kind's `content` makes the kind `layout`-content; leaving `content`
+ * absent leaves it `file`-content (one verbatim prose body, the default).
+ */
+export interface Layout {
+    readonly regions: readonly LayoutRegion[];
+}
+/**
+ * A kind's **body shape** marker — `"fields"` for a fields-only kind: no body slot at
+ * all, the member its typed fields and edges and nothing more (a hook, an MCP server).
+ * Absent leaves the kind body-bearing, its body `file` (the default) or a declared
+ * {@link Layout}.
+ */
+export type Shape = "fields";
+/**
+ * A registration member's **collection address** — where inside a host manifest its
+ * registration surfaces: which `manifest` (`settings.json`, `.mcp.json`) and which
+ * `keyPath` (`hooks.<Event>`, `mcpServers.*`) it keys at. Carried by a fields-only
+ * registration kind; absent for a kind that owns its own file locus.
+ */
+export interface CollectionAddress {
+    readonly manifest: string;
+    readonly keyPath: "hooks.<Event>" | "mcpServers.*";
+}
+/** The six facts of a kind's runtime residue. */
 export interface KindFacts {
     /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
     readonly name: string;
@@ -65,31 +117,44 @@ export interface KindFacts {
     readonly format?: Format;
     /** Fact 3b, layout — the on-disk unit shape. */
     readonly unitShape: UnitShape;
-    /** Fact 4, registration — the world edge. */
-    readonly registration: Registration;
+    /** Fact 4, registration — the declared channel set naming every documented way
+     * 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 (a skill's `name`), or
-     * absent when identity is the file stem (a rule). A layout detail: it shapes
-     * the projected frontmatter, never the model.
-     */
+      * 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).
+    */
     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;
 }
 /**
- * One authored member — a typed value in the library (`20-surface.md`, "The
- * member"). Kind identity travels by import (`facts`), never by string; the
+ * One authored member — a typed value in the library. Kind identity travels by
+ * import (`facts`), never by string; the
  * typed fields are flat at the top level, carried as an ordered pair list so the
  * projected frontmatter key order is the author's.
  */
 export interface Member {
     /** The kind's name — its declaration-row and lock identity. */
     readonly kind: string;
-    /** The kind's five facts — carried for projection and the declaration rows. */
+    /** The kind's six facts — carried for projection and the declaration rows. */
     readonly facts: KindFacts;
     /** Identity within the kind. */
     readonly name: string;
-    /** The member's words (`20-surface.md`, "Prose"). */
+    /** The member's words. */
     readonly prose?: Prose;
     /** The kind's typed fields, flat and ordered — the projected frontmatter. */
     readonly fields: ReadonlyArray<readonly [string, unknown]>;
@@ -109,30 +174,112 @@ export type MemberInit<T> = {
     readonly needs?: readonly Capability[];
 } & T;
 /**
- * A kind — a callable constructor carrying its five facts. Calling it builds a
+ * A kind — a callable constructor carrying its six facts. Calling it builds a
  * member; `key` (its name) keys `expect` and a `kind` reference in a requirement.
- * The value *is* the identity (`15-kinds.md`, "identity travels by import").
+ * The value *is* the identity — it travels by import, never by string.
  */
 export interface KindDefinition<T> {
     (init: MemberInit<T>): Member;
     readonly facts: KindFacts;
     readonly key: string;
+    /**
+     * An embedded kind's own composed view of one of its values (`representation.md`,
+     * "kind": an embedded-locus format is writer-only, so the hook is unconstrained).
+     * Every leaf the hook receives is already resolved to its final stored string
+     * (`emit.ts`'s `resolveMemberLeaves`) — a hook author never handles a raw `Text`
+     * template. Erased at the emit seam — the engine only ever sees the resulting
+     * string, never the function. Absent, `blocks()` renders the kind's values with
+     * the default `[collection.entry]` TOML view.
+     */
+    readonly render?: (value: ResolvedEmbeddedMemberValue) => string;
+}
+/** The options `kind()` takes beyond its six facts — today, only the embedded `render` hook. */
+export interface KindOptions {
+    readonly render?: (value: ResolvedEmbeddedMemberValue) => string;
 }
 /**
- * Define a kind (`15-kinds.md`). Returns a constructor over the kind's typed
+ * Define a kind. Returns a constructor over the kind's typed
  * fields `T`; every type erases at the seam, so what the returned member carries
- * into emit is the five facts plus flat field data.
+ * into emit is the six facts plus flat field data. `options.render`, when given,
+ * rides alongside `facts`/`key` on the returned constructor — never on the member
+ * it builds, since it is erased before a member reaches emit.
  */
-export declare function kind<T extends object>(facts: KindFacts): KindDefinition<T>;
+export declare function kind<T extends object>(facts: KindFacts, options?: KindOptions): 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
+ * index; the entry's `key` is what a leaf address carries.
+ */
+export interface EmbeddedMemberCollectionEntry {
+    /** The entry's key among its collection's siblings. */
+    readonly key: string;
+    /**
+     * The entry's own leaf fields: field name → authored string, or a `Text`
+     * template whose mentions resolve the way a member-level `Text` body does.
+     */
+    readonly leaves: Readonly<Record<string, string | Text>>;
+}
+/**
+ * An **embedded member's** composed value (posture 3, passed to `blocks()`):
+ * leaves are authored strings keyed by field name; sibling collections are keyed
+ * by collection name, each an authored-order list of entries — leaf addresses
+ * are structural and keyed. Its
+ * facts are declaration rows, captured the same emit pass that renders it —
+ * never mined back from the `member.<kind> <key>` fence `blocks()` renders
+ * (`pipeline.md`, "Emit"). There is no prescribed child-kind ontology — a
+ * corpus that wants one declares its own child kind with the same machinery.
+ */
+export interface EmbeddedMemberValue {
+    /** The child kind this value instantiates — the fence info string's `member.<kind>`. */
+    readonly kind: string;
+    /** The value's key — the identity a leaf address carries (`surface-authority`). */
+    readonly key: string;
+    /**
+     * Prose leaves: authored strings, law-5 protected one by one, or a `Text`
+     * template carrying its own mentions — a leaf mention lifts into the host's
+     * mention rows and resolves the way a member-level `Text` body does.
+     */
+    readonly leaves: Readonly<Record<string, string | Text>>;
+    /** Sibling collections: collection name → its entries, in authored order. */
+    readonly collections: Readonly<Record<string, readonly EmbeddedMemberCollectionEntry[]>>;
+    /** The originating kind's `render` hook, when declared — resolved once at construction. */
+    readonly render?: (value: ResolvedEmbeddedMemberValue) => string;
+}
+/**
+ * One resolved sibling-collection entry: its own key plus its leaf fields,
+ * already resolved to plain strings — no `Text` template remains.
+ */
+export interface ResolvedEmbeddedMemberCollectionEntry {
+    /** The entry's key among its collection's siblings. */
+    readonly key: string;
+    /** The entry's own leaf fields, already resolved to their final strings. */
+    readonly leaves: Readonly<Record<string, string>>;
+}
+/**
+ * An {@link EmbeddedMemberValue} after every leaf (top-level and each
+ * collection entry's) resolves to its final stored string
+ * (`emit.ts`'s `resolveMemberLeaves`) — the shape a kind's own `render` hook
+ * receives, so a hook author never handles a raw `Text` leaf.
+ */
+export interface ResolvedEmbeddedMemberValue {
+    /** The child kind this value instantiates. */
+    readonly kind: string;
+    /** The value's key. */
+    readonly key: string;
+    /** Prose leaves, already resolved to their final strings. */
+    readonly leaves: Readonly<Record<string, string>>;
+    /** Sibling collections, each entry's leaves already resolved. */
+    readonly collections: Readonly<Record<string, readonly ResolvedEmbeddedMemberCollectionEntry[]>>;
+}
 /**
- * Define a **genre** — a kind whose locus is `genre(within hosts)`: its members
- * live as typed fenced blocks inside host documents instead of at their own
- * paths (`15-kinds.md`, "A genre is a kind at the block locus"). Registration
- * inherits through the host, so a genre carries no world edge of its own.
+ * 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 (when
+ * declared) through to emit, with no other change to the composed value's shape.
  */
-export declare function genre<T extends object>(facts: {
-    name: string;
-    provider?: string;
-    withinHosts: readonly string[];
-    edgeFields?: readonly EdgeField[];
-}): KindDefinition<T>;
+export declare function embeddedMemberValue(init: {
+    kind: string | KindDefinition<any>;
+    key: string;
+    leaves: Readonly<Record<string, string | Text>>;
+    collections?: EmbeddedMemberValue["collections"];
+}): EmbeddedMemberValue;