@dtmd/temper 0.0.4 → 0.0.7

package/dist/src/kind.js

@@ -1,23 +1,25 @@
 /**
- * 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).
+ * 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.
  */
 /** The framework keys of a member init — everything else is a typed field (flat). */
 const FRAMEWORK_KEYS = new Set(["name", "prose", "satisfies", "requires", "needs"]);
 /**
- * Build the ordered projected-frontmatter fields for a member: nothing for a
- * frontmatterless kind (memory declares no `format`), else the identity field
- * (when the kind writes its name into frontmatter) followed by the typed fields
- * in the author's declared order.
+ * Build the ordered projected fields for a member: nothing for a frontmatterless
+ * body-bearing kind (memory declares no `format` and is not fields-only), else the
+ * identity field (when the kind writes its name into frontmatter) followed by the
+ * typed fields in the author's declared order. A fields-only registration kind (a
+ * hook, an MCP server) carries its typed fields though it declares no `format` —
+ * the fields are the whole member, folded into a manifest entry, never a header.
  */
 function orderedFields(facts, init) {
-    if (facts.format === undefined)
+    if (facts.format === undefined && facts.shape !== "fields")
         return [];
     const typed = [];
     for (const [key, value] of Object.entries(init)) {
@@ -28,11 +30,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 +47,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();

package/dist/src/prose.d.ts

@@ -1,13 +1,15 @@
 /**
- * Prose — three constructors, one field type (`specs/architecture/20-surface.md`,
- * "Prose — three constructors, one field type"). A member's words are data the
+ * Prose — three constructors, one field type. A member's words are data the
  * member declares: `file()` for a document that keeps its medium, `` text`…` ``
- * for short inline prose, `blocks()` for fully composed genre values. Whatever
+ * for short inline prose, `blocks()` for fully composed embedded-member values. Whatever
  * the constructor, the words land byte-identical to their authored text (law 5).
- * Interpolations in `` text`…` `` are **mentions** — declared one-way edges,
- * authored per word, resolution-checked at emit, never mined (law 8).
+ * Interpolations in `` text`…` `` are references, two intents apart: a **mention**
+ * (a {@link Mentionable}) is a declared one-way edge that moves no content, and an
+ * **include** (an {@link Include}) pulls the target file's bytes into the host's emitted
+ * projection. Both are authored per word and resolution-checked at emit, never mined
+ * (law 8).
  */
-import type { GenreValue } from "./genres.js";
+import type { EmbeddedMemberValue } from "./kind.js";
 /** A declared value a mention may name — the target of the one-way citation edge. */
 export interface Mentionable {
     /** The mention's rendered form and graph edge target (`kind:name` or a leaf address). */
@@ -21,14 +23,32 @@ export interface Mention {
     readonly target: Mentionable;
 }
 /**
- * `file(path)` — the document keeps its medium: markdown in a markdown file,
- * full tooling, forever legal (posture 1, `15-kinds.md`). Resolved and read in
- * byte-for-byte at emit.
+ * An include the author interpolates into `` text`…` `` — it moves content, not a
+ * citation: at emit the engine pulls the target file's bytes into the host's projection
+ * at this slot and fingerprints the dependency. The path resolves against the stating
+ * module ({@link moduleUrl}), never the workspace — the same anchor {@link file} takes.
+ */
+export interface Include {
+    readonly kind: "include";
+    /** Path to the include target, resolved against {@link moduleUrl}. */
+    readonly path: string;
+    /** The declaring module's own `import.meta.url` — what {@link path} resolves against. */
+    readonly moduleUrl: string;
+}
+/** A `` text`…` `` interpolation — a mention (moves no content) or an include (moves content). */
+export type Reference = Mentionable | Include;
+/**
+ * `file(moduleUrl, path)` — the document keeps its medium: markdown in a
+ * markdown file, full tooling, forever legal (posture 1, `15-kinds.md`).
+ * Resolved and read in byte-for-byte at emit, relative to the declaring
+ * module, never the process cwd.
  */
 export interface File {
     readonly kind: "file";
-    /** Module-relative path to the authored document. */
+    /** Path to the authored document, resolved against {@link moduleUrl}. */
     readonly path: string;
+    /** The declaring module's own `import.meta.url` — what {@link path} resolves against. */
+    readonly moduleUrl: string;
 }
 /**
  * `` text`…` `` — short prose inline, dedented, byte-deterministic; the
@@ -37,38 +57,54 @@ export interface File {
  */
 export interface Text {
     readonly kind: "text";
-    /** The dedented authored text with one {@link MENTION_SLOT} per mention, in order. */
+    /**
+     * The dedented authored text with one {@link MENTION_SLOT} per mention and one
+     * {@link INCLUDE_SLOT} per include, each in authored order.
+     */
     readonly template: string;
     readonly mentions: readonly Mention[];
+    /** The includes riding beside the text, in authored order — one per {@link INCLUDE_SLOT}. */
+    readonly includes: readonly Include[];
 }
 /**
- * `blocks(…)` — fully composed genre values (posture 3): typed collections whose
- * emitted document is pure render, byte-identical to the same values authored as
- * fences (posture 2). The shared fence format is `(genre-fence-format)`, deferred
- * until its first consumer lands (`15-kinds.md`), so a `blocks()` body composes
- * now and renders when the pilot does — emit refuses to project one until then,
- * never guessing a format.
+ * `blocks(…)` — fully composed embedded-member values (posture 3): typed
+ * collections rendered to `member.<kind> <key>` TOML fences, byte-identical to
+ * the same values authored as fences directly (posture 2) and read back by the
+ * engine's fold (`src/extract.rs` `parse_embedded_info`/`parse_embedded_member`).
  */
 export interface Blocks {
     readonly kind: "blocks";
-    readonly values: readonly GenreValue[];
+    readonly values: readonly EmbeddedMemberValue[];
 }
 /** A member's prose — one of the three constructors, one field type. */
 export type Prose = File | Text | Blocks;
-/** Declare a document whose medium is preserved — read in whole at emit (posture 1). */
-export declare function file(path: string): File;
 /**
- * The inline dedenting prose constructor. Interpolate only {@link Mentionable}
- * values — each interpolation is a mention, opt-in per word; plain prose with
- * zero mentions is fully legal forever (the opt-in Decision, `20-surface.md`).
+ * Declare a document whose medium is preserved — read in whole at emit
+ * (posture 1). `moduleUrl` is the declaring module's own `import.meta.url`,
+ * so `path` resolves relative to that module, never the process cwd:
+ * `file(import.meta.url, "./long.md")`.
+ */
+export declare function file(moduleUrl: string, path: string): File;
+/**
+ * The inline dedenting prose constructor. Interpolate {@link Reference} values — a
+ * {@link Mentionable} is a mention (moves no content), an {@link Include} pulls the
+ * target's bytes in; either is opt-in per word, and plain prose with zero references is
+ * fully legal forever (the opt-in Decision, `20-surface.md`).
  *
  * # Throws
- * If an authored chunk contains {@link MENTION_SLOT} — the marker must be the
- * tool's alone, so a stray NUL is a loud authoring error, not a silent mis-split.
+ * If an authored chunk carries {@link MENTION_SLOT} or {@link INCLUDE_SLOT} — the markers
+ * are the tool's alone, so a stray one is a loud authoring error, not a silent mis-split.
  */
-export declare function text(strings: TemplateStringsArray, ...targets: Mentionable[]): Text;
-/** Compose fully-typed genre values into a member's body (posture 3). */
-export declare function blocks(...values: GenreValue[]): Blocks;
+export declare function text(strings: TemplateStringsArray, ...targets: Reference[]): Text;
+/**
+ * Declare an include target — its bytes are pulled into the host's projection at emit,
+ * a dependency the lock fingerprints. `moduleUrl` is the declaring module's own
+ * `import.meta.url`, so `path` resolves relative to that module, never the process cwd:
+ * `include(import.meta.url, "./fragment.md")`.
+ */
+export declare function include(moduleUrl: string, path: string): Include;
+/** Compose fully-typed embedded-member values into a member's body (posture 3). */
+export declare function blocks(...values: EmbeddedMemberValue[]): Blocks;
 /**
  * Render an inline body to its final text — the display rule applied: each
  * mention slot becomes its target's display form, the surrounding words
@@ -76,3 +112,14 @@ export declare function blocks(...values: GenreValue[]): Blocks;
  * construction, so the walk consumes every slot.
  */
 export declare function renderText(prose: Text): string;
+/**
+ * Resolve a leaf's authored value to its stored/rendered string: a bare string
+ * is unchanged; a `Text` leaf is mention-resolution-checked against
+ * `mentionable` (loud on a dangling address) and rendered by {@link renderText}
+ * — the same rule a member-level `Text` body resolves by. `context` prefixes
+ * the dangling-mention error so it names the leaf, not just the mention.
+ *
+ * # Throws
+ * If a mention names no declared value.
+ */
+export declare function resolveLeaf(value: string | Text, mentionable: ReadonlySet<string>, context: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "description": "The temper authoring face — the six-noun model as typed modules: harness(), kind<T>(), clause values, needs, and file()/text/blocks(). Emit compiles to the declaration rows the engine reads, a byte-faithful projection, and the lock.",
   "license": "(MIT OR Apache-2.0)",
   "repository": {
@@ -32,6 +32,7 @@
   },
   "files": [
     "dist/src",
+    "bin",
     "README.md"
   ],
   "publishConfig": {
@@ -46,5 +47,12 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"
+  },
+  "bin": {
+    "temper": "bin/temper.js"
+  },
+  "optionalDependencies": {
+    "@dtmd/temper-linux-x64": "0.0.7",
+    "@dtmd/temper-win32-x64": "0.0.7"
   }
 }

package/dist/src/genres.d.ts

@@ -1,38 +0,0 @@
-/**
- * Genre values — prose that declares its own anatomy (`specs/architecture/15-kinds.md`,
- * "A genre is a kind at the block locus"; ratified `specs/intent/00-intent.md`, the
- * genre Decision). A genre value's meaning-carrying fields are prose leaves —
- * authored strings, law-5 protected one by one — plus keyed sibling collections.
- * This constructor carries the **shape only**: any predicate over a genre value
- * is a clause some module ships, never here (`15-kinds.md`, the genre Decision).
- * There is no prescribed genre ontology — a corpus that argues differently
- * declares its own genres with the same machinery (`15-kinds.md`, "a genre is
- * a full kind, and genre checks are data, never engine").
- *
- * `genreValue()` is the posture-3 spelling — a fully composed value passed to
- * `blocks()` (`20-surface.md`). The byte-identical posture-2 fence render awaits
- * `(genre-fence-format)`, deferred until its first consumer lands.
- */
-/**
- * A genre value serialized whole: leaves are authored strings keyed by field
- * name; sibling collections are keyed at every level (`rejected."baked-projection"`),
- * never positional — leaf addresses are structural and keyed (`20-surface.md`,
- * the leaf-address Decision).
- */
-export interface GenreValue {
-    /** The genre name — a project's own, never a built-in prescribed ontology. */
-    readonly genre: 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. */
-    readonly leaves: Readonly<Record<string, string>>;
-    /** Keyed sibling collections: collection → entry key → field → authored string. */
-    readonly collections: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, string>>>>>>;
-}
-/** A project's own genre — the same machinery, an author-declared shape. */
-export declare function genreValue(init: {
-    genre: string;
-    key: string;
-    leaves: Readonly<Record<string, string>>;
-    collections?: GenreValue["collections"];
-}): GenreValue;

package/dist/src/genres.js

@@ -1,24 +0,0 @@
-/**
- * Genre values — prose that declares its own anatomy (`specs/architecture/15-kinds.md`,
- * "A genre is a kind at the block locus"; ratified `specs/intent/00-intent.md`, the
- * genre Decision). A genre value's meaning-carrying fields are prose leaves —
- * authored strings, law-5 protected one by one — plus keyed sibling collections.
- * This constructor carries the **shape only**: any predicate over a genre value
- * is a clause some module ships, never here (`15-kinds.md`, the genre Decision).
- * There is no prescribed genre ontology — a corpus that argues differently
- * declares its own genres with the same machinery (`15-kinds.md`, "a genre is
- * a full kind, and genre checks are data, never engine").
- *
- * `genreValue()` is the posture-3 spelling — a fully composed value passed to
- * `blocks()` (`20-surface.md`). The byte-identical posture-2 fence render awaits
- * `(genre-fence-format)`, deferred until its first consumer lands.
- */
-/** A project's own genre — the same machinery, an author-declared shape. */
-export function genreValue(init) {
-    return {
-        genre: init.genre,
-        key: init.key,
-        leaves: init.leaves,
-        collections: init.collections ?? {},
-    };
-}