@dtmd/temper 0.0.3 → 0.0.6

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/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,29 @@
+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 { 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 { RequirementRow } from "./RequirementRow.js";
+export type { SatisfiesRow } from "./SatisfiesRow.js";
+export type { Section } from "./Section.js";
+export type { SectionContainsRow } from "./SectionContainsRow.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 { Clause, Predicate, Requirement, Severity } from "./contract.js";
-export { allowedChars, clause, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, requireSections, requirement, type, } 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 type { Charset, Clause, Predicate, Requirement, Severity } from "./contract.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 { EdgeField, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, 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, 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, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, requireSections, requirement, type, } 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,34 @@
 /**
- * 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,
+ * 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. `tsc` is the keystroke wall;
+ * every type erases at the seam, and what a kind leaves behind is those six 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).
+ * reference is the imported value.
  */
-import type { Prose } from "./prose.js";
+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 +49,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 +57,36 @@ 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[];
+}
+/** 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 +98,38 @@ 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;
 }
 /**
- * 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 +149,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;

package/dist/src/kind.js

@@ -1,12 +1,10 @@
 /**
- * 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,
+ * 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. `tsc` is the keystroke wall;
+ * every type erases at the seam, and what a kind leaves behind is those six 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).
+ * reference is the imported value.
  */
 /** The framework keys of a member init — everything else is a typed field (flat). */
 const FRAMEWORK_KEYS = new Set(["name", "prose", "satisfies", "requires", "needs"]);
@@ -28,11 +26,13 @@ function orderedFields(facts, init) {
     return [...head, ...typed];
 }
 /**
- * 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 function kind(facts) {
+export function kind(facts, options = {}) {
     const construct = (init) => ({
         kind: facts.name,
         facts,
@@ -43,21 +43,21 @@ export function kind(facts) {
         requires: init.requires ?? {},
         needs: init.needs ?? [],
     });
-    return Object.assign(construct, { facts, key: facts.name });
+    return Object.assign(construct, { facts, key: facts.name, render: options.render });
 }
 /**
- * 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 function genre(facts) {
-    return kind({
-        name: facts.name,
-        provider: facts.provider,
-        locus: { kind: "genre", withinHosts: facts.withinHosts },
-        unitShape: "file",
-        registration: { via: "always" },
-        edgeFields: facts.edgeFields,
-    });
+export function embeddedMemberValue(init) {
+    const [kindName, render] = typeof init.kind === "string" ? [init.kind, undefined] : [init.kind.key, init.kind.render];
+    return {
+        kind: kindName,
+        key: init.key,
+        leaves: init.leaves,
+        collections: init.collections ?? {},
+        ...(render !== undefined ? { render } : {}),
+    };
 }

package/dist/src/needs.d.ts

@@ -1,31 +1,31 @@
 /**
- * Needs — the capabilities a member's behavior uses, declared as typed values
- * (`specs/architecture/20-surface.md`, "The member"; "Emit — total"). Emit derives
+ * Needs — the capabilities a member's behavior uses, declared as typed values.
+ * Emit derives
  * the settings permission list from their union, so a permission is never authored
  * twice: `permissions.allow` is the union of the members' declared `needs`, and a
- * permission with no member is visible as exactly that (the derived-list Decision).
+ * permission with no member is visible as exactly that.
  */
 /** A declared capability — its `permission` is the entry it derives in the union. */
 export interface Capability {
     /**
      * The permission-list entry this capability derives. The union of every
      * member's needs is the settings `permissions.allow` — the fold hooks and MCP
-     * members ride into once those kinds land (`20-surface.md`, "Emit — total").
+   * members ride into once those kinds land.
      */
     readonly permission: string;
 }
 /**
  * A shell-command capability. Its derived permission is the Claude Code allow
  * entry `Bash(<command>)` (code.claude.com/docs/en/settings, retrieved
- * 2026-07-04) — the port scene's `bash("git diff")` (`20-surface.md`).
+ * 2026-07-04) — e.g. `bash("git diff")`.
  */
 export declare function bash(command: string): Capability;
 /** Any capability whose permission entry the author states verbatim. */
 export declare function capability(permission: string): Capability;
 /**
  * The derived permission list — the union of every capability's entry, deduped
- * and sorted so the derived artifact is byte-stable across runs (law 5). The
- * permission is derived here, never authored (`20-surface.md`, the derived-list
- * Decision).
+ * and sorted so the derived artifact is byte-stable across runs.
+ * The
+ * permission is derived here, never authored.
  */
 export declare function permissionUnion(needs: readonly Capability[]): string[];

package/dist/src/needs.js

@@ -1,14 +1,14 @@
 /**
- * Needs — the capabilities a member's behavior uses, declared as typed values
- * (`specs/architecture/20-surface.md`, "The member"; "Emit — total"). Emit derives
+ * Needs — the capabilities a member's behavior uses, declared as typed values.
+ * Emit derives
  * the settings permission list from their union, so a permission is never authored
  * twice: `permissions.allow` is the union of the members' declared `needs`, and a
- * permission with no member is visible as exactly that (the derived-list Decision).
+ * permission with no member is visible as exactly that.
  */
 /**
  * A shell-command capability. Its derived permission is the Claude Code allow
  * entry `Bash(<command>)` (code.claude.com/docs/en/settings, retrieved
- * 2026-07-04) — the port scene's `bash("git diff")` (`20-surface.md`).
+ * 2026-07-04) — e.g. `bash("git diff")`.
  */
 export function bash(command) {
     return { permission: `Bash(${command})` };
@@ -19,9 +19,9 @@ export function capability(permission) {
 }
 /**
  * The derived permission list — the union of every capability's entry, deduped
- * and sorted so the derived artifact is byte-stable across runs (law 5). The
- * permission is derived here, never authored (`20-surface.md`, the derived-list
- * Decision).
+ * and sorted so the derived artifact is byte-stable across runs.
+ * The
+ * permission is derived here, never authored.
  */
 export function permissionUnion(needs) {
     return [...new Set(needs.map((need) => need.permission))].sort();