@prestack/thread-ui 0.1.1 → 0.1.3

package/dist/ui/attach.ts

@@ -1,5 +1,6 @@
 import type { Attaching } from '@prestack/thread/core/attach'
-import { named } from '@prestack/thread/core/scope'
+import { SHAPED } from '@prestack/thread/core/init'
+import { NAMED, named } from '@prestack/thread/core/scope'
 import type { Threaded } from '@prestack/thread/core/thread'
 
 import { ANIMATIONS } from './animations.ts'
@@ -53,19 +54,19 @@ const SHIPPED: readonly { readonly into: string; readonly list: string; readonly
     into: 'ui.ts',
     list: 'GENERATORS',
     id: 'i18n-generator',
-    source: "  {\n    id: 'i18n-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/i18n.js',\n    describes: 'The generator of an app\\'s wording — it reads the languages the app declares and every message key its interface names, and writes one file per language holding a line for each. It cannot invent a sentence, so a key it has just found arrives holding nothing; run with `--check`, the mode the gate runs it in, it writes nothing and refuses a language file that is not what the declarations produce, and refuses any key left unanswered. It also writes the module the app imports, which states the keys the interface uses as a type, so a language missing one is a compiler error before it is a gate error.',\n    version: 1,\n    by: 'thread i18n',\n    runs: 'thread i18n --check',\n    derives: [\n      {\n        id: 'wording',\n        at: 'app/_generated/wording.ts',\n        describes: 'Every language this app is in, as one module the layout hands to the provider, with the keys the interface names stated as a type so a language missing one is a compiler error.',\n        version: 1,\n        by: 'thread i18n',\n        runs: 'thread i18n --check',\n      },\n    ],\n  },",
+    source: "  {\n    id: 'i18n-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/i18n.js',\n    describes: 'The generator of an app\\'s wording — it reads the languages the app declares and every message key its interface names, and writes one file per language holding a line for each. It cannot invent a sentence, so a key it has just found arrives holding nothing; run with `--check`, the mode the gate runs it in, it writes nothing and refuses a language file that is not what the declarations produce, and refuses any key left unanswered. It also writes the module the app imports, which states the keys the interface uses as a type, so a language missing one is a compiler error before it is a gate error.',\n    version: 1,\n    by: 'thread i18n',\n    runs: 'thread i18n --check',\n    derives: [\n      {\n        id: 'wording',\n        at: 'app/_generated/wording.ts',\n        describes: 'Every language this app is in, as one module the layout hands to the provider, with the keys the interface names stated as a type so a language missing one is a compiler error. That type is written as an assignment rather than a satisfies clause, because satisfies would also refuse the extra keys a filled wording always carries.',\n        version: 1,\n        by: 'thread i18n',\n        runs: 'thread i18n --check',\n      },\n    ],\n  },",
   },
   {
     into: 'ui.ts',
     list: 'GENERATORS',
     id: 'routes-generator',
-    source: "  {\n    id: 'routes-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/routes.js',\n    describes: 'The generator of the routes, the map, the pages a browser reaches, and the root layout. Nobody types a route. The first page an app declares answers `/`, every other page answers its own name, and a sheet, popover, overlay or toast has no route, so the page under each route follows from the screens sheet. It reads every `navigateTo` the screens and their compositions hold and writes the map: from which screen, through which button, to which screen. A button is the only thing that makes a link. A press that names a sheet, popover, overlay or toast is a link like any other, and the client half opens that screen where somebody already is. A name no screen has, a destination not written out as a name, and a route typed into a screen are each refused by name. The layout imports what the other generators produce. Run with `--check`, the mode the gate runs it in, it writes nothing and refuses a hand edit to any of these files, exactly as the stylesheet is refused.',\n    version: 1,\n    by: 'thread routes',\n    runs: 'thread routes --check',\n    derives: [\n      {\n        id: 'layout',\n        at: 'app/layout.tsx',\n        describes: 'The root layout — it imports what the other generators produce and hands the wording to the provider, so the one file every page passes through is a consequence of the declarations rather than something somebody keeps in step with them.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'door',\n        at: 'app/_generated/door.tsx',\n        describes: 'This app\\'s own client half. It is written when the app has operations a page can reach, or screens a press can move between. The provider takes something to run an operation with and something to move between screens with, and the layout cannot hand either over: the layout is a server component and the provider is a client one, and a function does not cross that line — \"Functions cannot be passed directly to Client Components\", measured 2026-09-01 as a page that returned 500 on every request while the gate was green. So both are made on the side that uses them. This file imports what the operations half derived and the map, and hands them over itself. The layout renders this and passes only the actor, which is data and crosses the way data does.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'bundler',\n        at: 'next.config.js',\n        describes: 'Where the bundler resolves from, derived from where the packages actually are. Only written when they live outside this app, which is when a bundler cannot see them and every import fails at run time while the compiler is content.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'map',\n        at: 'app/_generated/map.ts',\n        describes: 'Every screen this app has, where each one lives, and every way from one to another: from which screen, through which button, to which screen. It is read off every `navigateTo` the screens and their compositions hold, so a button is the only thing that makes a link. The client half moves through it: a press that names a page goes to the address held here, and a press that names a sheet, popover, overlay or toast opens it where somebody already is. A screen no button reaches is printed by `thread routes` rather than found by somebody looking for it.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n    ],\n  },",
+    source: "  {\n    id: 'routes-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/routes.js',\n    describes: 'The generator of the routes, the map, the pages a browser reaches, and the root layout. Nobody types a route. The first page an app declares answers `/`, every other page answers its own name, and a sheet, popover, overlay or toast has no route, so the page under each route follows from the screens sheet. It reads every `navigateTo` the screens and their compositions hold and writes the map: from which screen, through which button, to which screen. A button is the only thing that makes a link. A press that names a sheet, popover, overlay or toast is a link like any other, and the client half opens that screen where somebody already is. A name no screen has, a destination not written out as a name, and a route typed into a screen are each refused by name. The layout imports what the other generators produce. Run with `--check`, the mode the gate runs it in, it writes nothing and refuses a hand edit to any of these files, exactly as the stylesheet is refused.',\n    version: 1,\n    by: 'thread routes',\n    runs: 'thread routes --check',\n    derives: [\n      {\n        id: 'layout',\n        at: 'app/layout.tsx',\n        describes: 'The root layout — it imports what the other generators produce and hands the wording to the provider, so the one file every page passes through is a consequence of the declarations rather than something somebody keeps in step with them.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'door',\n        at: 'app/_generated/door.tsx',\n        describes: 'This app\\'s own client half. It is written when the app has operations a page can reach, or screens a press can move between. The provider takes something to run an operation with and something to move between screens with, and the layout cannot hand either over: the layout is a server component and the provider is a client one, and a function does not cross that line — \"Functions cannot be passed directly to Client Components\", measured 2026-09-01 as a page that returned 500 on every request while the gate was green. So both are made on the side that uses them. This file imports what the operations half derived and the map, and hands them over itself. The layout renders this and passes only the actor, which is data and crosses the way data does.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'bundler',\n        at: 'next.config.js',\n        describes: 'What Next reads to serve this app. It is written whenever the manifest runs Next, whether or not this app declares a screen, because it states three things a served app needs and one of them is that Next may not write files of its own into a tree where every file is declared. It also refuses to compile anything until the gate has passed, and names where the bundler resolves from when the packages live outside this app — which is when a bundler cannot see them and every import fails at run time while the compiler is content. It opens the disk itself rather than through the disk this framework declares, because Next reads this file before any TypeScript in this tree has been loaded — a file that gates the build cannot import the thing it is gating.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n      {\n        id: 'map',\n        at: 'app/_generated/map.ts',\n        describes: 'Every screen this app has, where each one lives, and every way from one to another: from which screen, through which button, to which screen. It is read off every `navigateTo` the screens and their compositions hold, so a button is the only thing that makes a link. The client half moves through it: a press that names a page goes to the address held here, and a press that names a sheet, popover, overlay or toast opens it where somebody already is. A screen no button reaches is printed by `thread routes` rather than found by somebody looking for it.',\n        version: 1,\n        by: 'thread routes',\n        runs: 'thread routes --check',\n      },\n    ],\n  },",
   },
   {
     into: 'ui.ts',
     list: 'GENERATORS',
     id: 'dev-generator',
-    source: "  {\n    id: 'dev-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/dev.js',\n    describes: 'The command that runs the app, and the only one here that puts a pixel on a screen — until it existed the framework could build an interface nothing in it could start, because a gate answers whether declarations agree with files and cannot answer whether a button is where somebody says it is not. It is two halves in one word. First it settles this tree: every generator the declarations name is run until the checks stop complaining, which is what `thread create` and `thread run trial` already did and what starting the app was alone in not doing — an app had `thread gate` in front of `next dev`, and a gate refuses a stale file rather than writing it. Then it runs the entry the manifest declares, which is where the gate hook fires and Next is reached. Neither half is written down here: the generators are read off the rows, and `next dev` appears nowhere, so a package attached tomorrow is run by this without this changing and an app served by something else needs no edit. `--ship` swaps the entry for the build. Alone among the generators it carries no `runs:`, because a server stays up until it is stopped and a gate step that never returns is a gate that hangs.',\n    version: 1,\n    by: 'thread dev',\n  },",
+    source: "  {\n    id: 'dev-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/dev.js',\n    describes: 'The command that runs the app, and the only one here that puts a pixel on a screen — until it existed the framework could build an interface nothing in it could start, because a gate answers whether declarations agree with files and cannot answer whether a button is where somebody says it is not. It is two halves in one word. First it settles this tree: every generator the declarations name is run until the checks stop complaining, which is what `thread create` and `thread run trial` already did and what starting the app was alone in not doing — an app had `thread gate` in front of `next dev`, and a gate refuses a stale file rather than writing it. Then it runs the gate, and then starts Next itself, because Next is what this package installs to serve an app and the manifest carries no script for it. The generators are read off the rows, and `next dev` is the one thing written down here: this package serves an app with Next and nothing else. `--ship` swaps the entry for the build. Alone among the generators it carries no `runs:`, because a server stays up until it is stopped and a gate step that never returns is a gate that hangs.',\n    version: 1,\n    by: 'thread dev',\n  },",
   },
   {
     into: 'ui.ts',
@@ -89,7 +90,7 @@ const SHIPPED: readonly { readonly into: string; readonly list: string; readonly
     into: 'ui.ts',
     list: 'GENERATORS',
     id: 'icons-generator',
-    source: "  {\n    id: 'icons-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/icons.js',\n    describes: 'The generator of the icon module — it reads which library the icon rows name and which meanings they declare, and writes the one module that imports exactly those symbols and installs them. A meaning is what an element asks for, so changing the library row redraws every icon in the app and rewrites nothing else. Run with `--check`, the mode the gate runs it in, it writes nothing and refuses a generated file that does not match the rows.',\n    version: 1,\n    by: 'thread icons',\n    runs: 'thread icons --check',\n    derives: [\n      {\n        id: 'symbols',\n        at: 'app/_generated/icons.ts',\n        describes: 'The one module importing exactly the symbols the icon rows name, from the one library they name.',\n        version: 1,\n        by: 'thread icons',\n        runs: 'thread icons --check',\n      },\n    ],\n  },",
+    source: "  {\n    id: 'icons-generator',\n    at: 'node_modules/@prestack/thread-ui/dist/ui/generators/icons.js',\n    describes: 'The generator of the icon module — it reads which library the icon rows name and which meanings they declare, and writes the one module that imports exactly those symbols and installs them. A meaning is what an element asks for, so changing the library row redraws every icon in the app and rewrites nothing else. Run with `--check`, the mode the gate runs it in, it writes nothing and refuses a generated file that does not match the rows.',\n    version: 1,\n    by: 'thread icons',\n    runs: 'thread icons --check',\n    derives: [\n      {\n        id: 'symbols',\n        at: 'app/_generated/icons.ts',\n        describes: 'The one module importing exactly the symbols the icon rows name, from the one library they name. The layout renders it rather than merely importing it, because a bare import of a client module from a server layout is a reference that never runs — the install never happens and every icon on the page refuses.',\n        version: 1,\n        by: 'thread icons',\n        runs: 'thread icons --check',\n      },\n    ],\n  },",
   },
   {
     into: 'ui.ts',
@@ -272,11 +273,12 @@ interface Node {
   readonly describes: string
   readonly files?: string
   readonly declares?: readonly Row[]
+  readonly derives?: readonly Row[]
   readonly holds?: readonly Row[]
 }
 
 function inside(node: Node): readonly Row[] {
-  return [...(node.holds ?? []), ...(node.declares ?? [])]
+  return [...(node.holds ?? []), ...(node.declares ?? []), ...(node.derives ?? [])]
 }
 
 function quoted(value: string): string {
@@ -397,16 +399,10 @@ const ARRANGES: Readonly<Record<string, readonly string[]>> = {
   element: ['tag', 'raises', 'carries', 'always', 'places', 'works', 'measures', 'reads', 'gives', 'keeps', 'animates', 'shows', 'called', 'wires', 'dresses'],
 }
 
-const TEACHING: Readonly<Record<string, string>> = {
-  composition: `export { TEACHES, catalogue } from '${named('ui')}/compositions'`,
-  screen: `export { TEACHES, screening as catalogue } from '${named('ui')}/compositions'`,
-}
-
 function source(node: Node, file: string, rows: readonly Row[]): string {
   const extra = stated(rows, ARRANGES[node.id] ?? []).map((key) => SHAPES[key] ?? '')
-  const taught = TEACHING[node.id]
 
-  const authors = node.declares !== undefined || rows.some((one) => one.at !== undefined && one.at !== node.at)
+  const authors = node.declares !== undefined || node.derives !== undefined || rows.some((one) => one.at !== undefined && one.at !== node.at)
   const values = node.holds !== undefined || rows.some((one) => one.at === undefined || one.at === node.at)
 
   const own = node.id
@@ -440,7 +436,7 @@ ${[...(node.files === undefined ? [] : ['  readonly files?: string']), ...lists]
 
   const wants = shape.includes('Condition')
 
-  return `import type { Threaded } from '../core/thread.ts'${wants ? `\nimport type { Condition } from '../core/condition.ts'` : ''}
+  return `import type { Threaded } from '${SHAPED}'${wants ? `\nimport type { Condition } from '${NAMED}/core/condition'` : ''}
 ${shape}
 export const ${node.id.toUpperCase()}: ${bespoke ? own : 'Threaded'} = {
   id: ${quoted(node.id)},
@@ -449,7 +445,7 @@ export const ${node.id.toUpperCase()}: ${bespoke ? own : 'Threaded'} = {
   version: 1,
 ${held.join('\n')}
 }
-${taught === undefined ? '' : `\n${taught}\n`}`
+`
 }
 
 const LISTS: readonly { readonly node: Node; readonly file: string; readonly rows?: readonly Row[] }[] = [
@@ -503,7 +499,7 @@ function sectioned(one: { readonly node: Node; readonly file: string; readonly r
   })
 }
 
-const UI_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const UI_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const UI: Threaded = {
 ${SEEDED.declares.split('\n').slice(1, -1).map((line) => line.slice(4)).join('\n')}
@@ -513,58 +509,6 @@ ${SEEDED.declares.split('\n').slice(1, -1).map((line) => line.slice(4)).join('\n
 export const GENERATORS: readonly Threaded[] = []
 `
 
-const RETIRED = [
-  {
-    into: 'tokens.ts',
-    list: 'holds',
-    id: 'font',
-    why: 'a font is not a token — the fonts sheet holds faces, sizes and appearance directly, so there is no variable of this kind for a style guide to give a value to',
-  },
-  ...(['sm', 'md', 'lg'] as const).map((one) => ({
-    into: 'styleguides.ts',
-    list: 'holds',
-    id: `icon-${one}`,
-    why: 'the style guide holds no icon size — `icons.ts` does, and it is the one place a symbol is measured. These rows and a constant inside the package were both claiming to decide it, and the constant was what anything actually drew at, so changing the row moved the CSS variable and left every icon the size it already was',
-  })),
-  ...(['link', 'glyph', 'avatar', 'skeleton', 'spinner'] as const).map((one) => ({
-    into: 'variants.ts',
-    list: 'declares',
-    id: one,
-    why: `a variant sharing a word with the element that wears it — \`${one}\` was coined twice, once as the element and once as the look, with two different meanings. The framework's own rule refuses that, and an app made entirely by these commands failed its own descent on five words this package had shipped. Renamed to \`${one}-\` plus what distinguishes it`,
-  })),
-
-  ...(['icon', 'icon-ghost', 'icon-border', 'label-icon', 'elevated'] as const).map((one) => ({
-    into: 'variants.ts',
-    list: 'declares',
-    id: `button-${one}`,
-    why: 'a variant may not decide what a button CONTAINS — a symbol, a word or both is the composition\'s to arrange, and four variants existed only to answer it. `button-ghost`, `button-fill` and the rest each serve every shape of content. `button-elevated` is withdrawn as simply poor',
-  })),
-  ...(['filled', 'outlined', 'plain'] as const).map((one) => ({
-    into: 'materials.ts',
-    list: 'declares',
-    id: one,
-    why: 'not a material — a background, an ink and a border width are three style guide rows, and wrapping them in a material only added a second place to look. A material is for what composes into one appearance worth naming: glass, a real relief, a glaze. The variants that wore these now name the rows directly',
-  })),
-  ...(['primary', 'secondary'] as const).map((one) => ({
-    into: 'variants.ts',
-    list: 'declares',
-    id: `button-${one}`,
-    why: 'a second name for something the button family already carries — `button-primary` is `button-fill` and `button-secondary` is `button-border`. Two names for one look is the defect this framework refuses everywhere else, and it was shipping it in the one place an app looks first',
-  })),
-  ...(['sans', 'serif', 'mono', 'display'] as const).map((one) => ({
-    into: 'styleguides.ts',
-    list: 'holds',
-    id: `font-${one}`,
-    why: 'the style guide holds no font — a font is not a token value, and the fonts sheet is the source for faces',
-  })),
-  ...(['display', 'heading', 'body', 'label'] as const).map((one) => ({
-    into: 'variants.ts',
-    list: 'declares',
-    id: one,
-    why: 'a type role, not a variant — it set a face, a size and a weight, all of which the fonts sheet now decides',
-  })),
-]
-
 export const ATTACH: Attaching = {
   attaches: SEEDED.attaches,
   id: SEEDED.id,
@@ -595,7 +539,6 @@ export const ATTACH: Attaching = {
     ...LISTS.flatMap((one) => sectioned(one)),
     ...SHIPPED,
   ],
-  retires: RETIRED,
   declares: SEEDED.declares,
   writes: [
     { file: 'ui.ts', source: UI_SOURCE },

package/dist/ui/charts.d.ts

@@ -12,9 +12,6 @@ export declare const str: (row: Row, key: string) => string;
 export declare function useRamp(count: number): readonly string[];
 export declare function placed(element: string, place: string): string;
 export declare function measured(held: Readonly<Record<string, string | number>>): Record<string, string | number>;
-export declare function EmptyFrame({ className }: {
-    className?: string;
-}): React.ReactElement;
 export interface SeriesProps extends ChartBase {
     readonly value: string;
     readonly at: string;

package/dist/ui/charts.js

@@ -1,8 +1,7 @@
 'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { seriesRamp } from "./series.js";
-import { classOfElement } from "./variant.js";
-import { useUi } from "./wrappers.js";
+import { seriesRamp } from './series.js';
+import { classOfElement } from './variant.js';
+import { useUi } from './wrappers.js';
 export const num = (row, key) => {
     const v = row[key];
     return typeof v === 'number' ? v : Number(v ?? 0);
@@ -21,9 +20,6 @@ export function measured(held) {
         out[`--${name}`] = value;
     return out;
 }
-export function EmptyFrame({ className }) {
-    return _jsx("div", { className: className, "data-empty": "true" });
-}
 export function polyline(values, width, height) {
     if (values.length === 0)
         return '';

package/dist/ui/charts.tsx

@@ -41,10 +41,6 @@ export function measured(held: Readonly<Record<string, string | number>>): Recor
   return out
 }
 
-export function EmptyFrame({ className }: { className?: string }): React.ReactElement {
-  return <div className={className} data-empty="true" />
-}
-
 export interface SeriesProps extends ChartBase {
   readonly value: string
   readonly at: string

package/dist/ui/checked.d.ts

@@ -11,7 +11,7 @@ export type VariantsFor<E extends string> = Shipped extends infer One ? One exte
 } ? E extends One['wears'][number] ? Camel<One['id']> : never : never : never;
 type Pascal<S extends string> = S extends `${infer Head}-${infer Rest}` ? `${Capitalize<Head>}${Pascal<Rest>}` : Capitalize<S>;
 type Camel<S extends string> = S extends `${infer Head}-${infer Rest}` ? `${Head}${Pascal<Rest>}` : S;
-export type ArrangementElement = (typeof ELEMENTS)['declares'][number] extends infer One ? One extends {
+export type ArrangementElement = (typeof ELEMENTS)['derives'][number] extends infer One ? One extends {
     readonly arranges: true;
     readonly id: infer Id extends string;
 } ? Pascal<Id> : never : never;

package/dist/ui/checked.ts

@@ -21,7 +21,7 @@ type Pascal<S extends string> = S extends `${infer Head}-${infer Rest}`
 
 type Camel<S extends string> = S extends `${infer Head}-${infer Rest}` ? `${Head}${Pascal<Rest>}` : S
 
-export type ArrangementElement = (typeof ELEMENTS)['declares'][number] extends infer One
+export type ArrangementElement = (typeof ELEMENTS)['derives'][number] extends infer One
   ? One extends { readonly arranges: true; readonly id: infer Id extends string }
     ? Pascal<Id>
     : never

package/dist/ui/collector.js

@@ -23,7 +23,7 @@ export function createCollector(options) {
         const body = JSON.stringify({ events: batch });
         if (options.beacon !== undefined && options.beacon(options.endpoint, body))
             return;
-        const doFetch = options.fetch ?? globalThis.fetch;
+        const doFetch = options.fetch;
         if (doFetch === undefined) {
             dropped += batch.length;
             return;

package/dist/ui/collector.ts

@@ -82,7 +82,7 @@ export function createCollector(options: CollectorOptions): Collector {
 
     if (options.beacon !== undefined && options.beacon(options.endpoint, body)) return
 
-    const doFetch = options.fetch ?? globalThis.fetch
+    const doFetch = options.fetch
     if (doFetch === undefined) {
       dropped += batch.length
       return

package/dist/ui/compositions.d.ts

@@ -1,14 +1,20 @@
 import type { Threaded } from '@prestack/thread/core/thread';
 import type { Tree } from '@prestack/thread/core/tree';
-export declare const TEACHES: readonly string[];
 export declare const REACHES: RegExp;
 export declare const declares: readonly Threaded[];
 export declare const COMPOSITIONS: Threaded & {
     readonly files: string;
 };
+export declare const PASCAL: (id: string) => string;
 export declare function nameOf(at: string): string;
-export declare const catalogue: () => Promise<readonly string[]>;
-export declare const screening: () => Promise<readonly string[]>;
+export type Listed = {
+    readonly id: string;
+    readonly at?: string;
+    readonly describes?: string;
+    readonly wears?: readonly string[];
+    readonly arranges?: boolean;
+};
+export declare function sheetOf(tree: Tree, file: string, ...named: readonly string[]): readonly Listed[];
 export declare function composed(body: string, rows: readonly {
     readonly id: string;
     readonly at?: string;

package/dist/ui/compositions.js

@@ -1,97 +1,11 @@
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "@prestack/thread/core/files";
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from '@prestack/thread/integrations/disk';
 import { basename, dirname, join, relative } from 'node:path';
 import { argv, stdout } from 'node:process';
-import { TYPED, wrapped } from "@prestack/thread/core/answers";
-import { exit, invoked } from "@prestack/thread/core/invoked";
-import { valuesIn } from "@prestack/thread/core/rows";
-import { named as packageOf } from "@prestack/thread/core/scope";
-import { findTree, inTree } from "@prestack/thread/core/tree";
-import { compiled } from "./generators/react.js";
-export const TEACHES = [
-    '  what the body may reach, and how a premium state is written:',
-    '',
-    '    `useUi()` is the door. It carries `actor` — who is asking, with the roles read from',
-    '    the row that declared itself the caller — and `translate`, `clock` and `dispatch`. Name',
-    '    it in the body and the import is written for you.',
-    '',
-    '    A premium look is not decided at the call site. A grant already says who may run an',
-    '    operation, in words your own entity declares, and a signal that names that operation',
-    '    holds for exactly the callers the grant refuses. The rule is written once, on the',
-    '    grant, and every screen follows it:',
-    '',
-    '      <FeatureBox.paywalled>',
-    '        <Text k=\'feature.title\' />',
-    '      </FeatureBox.paywalled>',
-    '',
-    '    Read it in three parts, and each is its own command:',
-    '',
-    '      `locked` is a signal the ELEMENT declares it raises — `thread create element` with',
-    '      `raises: locked`. A signal this app declares cannot be raised on an element that',
-    '      never said it raises one, so `Box` will not take it. Nothing passes it here: it is',
-    '      set for you wherever the gate refuses the operation the signal names.',
-    '      `.paywalled` is a variant worn as the TAG, never passed as a prop, and it is what',
-    '      carries the look — `thread create variant` with a `state: locked` and what it sets.',
-    '      Declare that state on a MATERIAL instead and every variant made of it locks the same',
-    '      way, which is how one overlay dresses a whole app from one row.',
-    '      The rule itself is `thread grant`, and the words in it are options on the value your',
-    '      entity names as saying what a caller may do — `thread create entity`.',
-    '',
-    '    THE MEMBER IS THE VARIANT\'S WHOLE ID, CAMELCASED — never the part after the element',
-    '    name. A variant `button-fill` is worn `<Button.buttonFill>`, and `<Button.fill>` is not',
-    '    a thing. `.paywalled` above reads short only because that variant is itself named',
-    '    `paywalled`; most carry the element in their id and wear all of it.',
-    '',
-    '  how a control reaches an operation:',
-    '',
-    '    Wiring is imperative. There is no `run=`, `operation=` or `dispatch=` prop on any',
-    '    element, and the compiler is what will tell you so. A control calls dispatch in its own',
-    '    handler:',
-    '',
-    '      <Button.buttonFill label=\'common.save\'',
-    '        onPress={() => useUi().dispatch?.(\'wf_save\')} />',
-    '',
-    '    `dispatch` is optional on the hook, so `?.` is required — without it the compiler says',
-    '    "Cannot invoke an object which is possibly \'undefined\'". The name is the operation\'s own',
-    '    id from `thread create operation`, and one this app never declared is refused before it',
-    '    runs. An operation whose `to:` named nobody is refused however the button looks — and',
-    '    `to:` takes roles off an entity, which is a noun that arrives with `thread attach',
-    `    ${packageOf('data')}\`.`,
-    '',
-    '    Nothing here decides access. The gate still refuses the operation behind the lock',
-    '    whatever the screen shows, so a screen that got this wrong shows the wrong thing and',
-    '    still cannot do the wrong thing.',
-    '',
-    '  how a press moves to another screen:',
-    '',
-    '    Name the screen. `navigateTo` takes the screen\'s export name — its id in PascalCase, so',
-    '    `order-detail` is reached as `navigateTo="OrderDetail"`:',
-    '',
-    '      <Button.buttonNormal label=\'home.orders\' navigateTo="Orders" />',
-    '',
-    '    That is the whole of it. `thread routes` reads every `navigateTo` the screens and their',
-    '    compositions hold and writes the map — from which screen, through which button, to which',
-    '    screen — and the pages. A page is reached by its route, and a sheet, popover, overlay or',
-    '    toast opens where somebody already is, so the press is written the same way for both.',
-    '    A name no screen has and a destination not written out as a name are each refused there.',
-    '    Never an `href` and never',
-    '    a router: a move the map cannot see is a screen the map reads as unreachable.',
-    '',
-    '  how a screen shows data:',
-    '',
-    '    A screen NAMES the reads it binds, and never fetches. `views` takes the ids of declared',
-    '    views, the framework runs each one, and `useView` hands back what came out:',
-    '',
-    '      export const Orders = screen(\'orders\', { as: \'page\', views: [\'vw_orders\'] }, () => (',
-    '        <Each rows={useView<readonly Row[]>(\'vw_orders\') ?? []} by="id">',
-    '          {(row) => <Text k="orders.line" with={{ name: row.name }} />}',
-    '        </Each>',
-    '      ))',
-    '',
-    '    `useView` comes through the same door as `useUi`, and it refuses a name the screen did not',
-    '    bind. `thread routes` refuses a view this app declares no operation for, and writes what each',
-    '    screen shows into the map. A fetch of your own, or a hook you wrote, is how a screen ends up',
-    '    showing something nothing declared, and there is no second way in.',
-];
+import { exit, invoked } from '@prestack/thread/core/invoked';
+import { valuesIn } from '@prestack/thread/core/rows';
+import { named as packageOf } from '@prestack/thread/core/scope';
+import { findTree, inTree } from '@prestack/thread/core/tree';
+import { compiled } from './generators/react.js';
 export const REACHES = /\buseUi\s*\(/;
 const here = 'thread/ui/compositions.ts';
 const said = [
@@ -118,7 +32,7 @@ export const COMPOSITIONS = {
     cites: said,
     declares,
 };
-const PASCAL = (id) => id
+export const PASCAL = (id) => id
     .split('-')
     .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
     .join('');
@@ -126,81 +40,18 @@ export function nameOf(at) {
     const file = at.split('\\').join('/').split('/').at(-1) ?? at;
     return PASCAL(file.replace(/^cmp_/, '').replace(/\.[^.]+$/, ''));
 }
-function sheetOf(tree, file, ...named) {
+export function sheetOf(tree, file, ...named) {
     const at = inTree(tree, file);
     if (!existsSync(at))
         return [];
     const held = valuesIn(readFileSync(at));
     for (const one of named) {
-        const found = held[one]?.declares;
+        const found = held[one]?.derives ?? held[one]?.declares;
         if (found !== undefined)
             return found;
     }
     return [];
 }
-const camelOf = (id) => id.replace(/-([a-z0-9])/g, (_, one) => one.toUpperCase());
-const sentence = (one, pad) => String(one.describes ?? '').trim() === '' ? [] : wrapped(String(one.describes), pad);
-function listed(tree, making) {
-    const elements = sheetOf(tree, `elements.${'ts'}`, 'ELEMENT', 'ELEMENTS');
-    const variants = sheetOf(tree, `variants.${'ts'}`, 'VARIANT', 'VARIANTS');
-    const compositions = sheetOf(tree, `compositions.${'ts'}`, 'COMPOSITION', 'COMPOSITIONS');
-    const screens = making === 'screen' ? sheetOf(tree, `screens.${'ts'}`, 'SCREEN', 'SCREENS') : [];
-    const worn = new Map();
-    for (const one of variants) {
-        for (const each of one.wears ?? []) {
-            const key = PASCAL(each);
-            const already = worn.get(key) ?? [];
-            if (!already.includes(one.id))
-                worn.set(key, [...already, one.id]);
-        }
-    }
-    const writes = (one) => {
-        const name = PASCAL(one.id);
-        const members = (worn.get(name) ?? []).sort().map((each) => `<${name}.${camelOf(each)}>`);
-        if (members.length === 0)
-            return `<${name}>`;
-        return one.arranges === true ? `<${name}>, or ${members.join(' ')}` : members.join(' ');
-    };
-    const section = (title, rows, write) => rows.length === 0
-        ? [`  ${title}: none yet.`, '']
-        : [
-            `  ${title} (${String(rows.length)}):`,
-            ...rows.flatMap((one) => [`    ${write(one)}`, ...sentence(one, '      ')]),
-            '',
-        ];
-    return [
-        '',
-        ...(making === 'screen'
-            ? section('SCREENS that exist, and the name a press reaches each one by', screens, (one) => `${one.id} — navigateTo="${PASCAL(one.id)}"`)
-            : []),
-        ...section('COMPOSITIONS you can place', compositions, (one) => `<${typeof one.at === 'string' && one.at !== '' ? nameOf(one.at) : PASCAL(one.id)}>`),
-        ...section('ELEMENTS, written as the tags they can actually be typed as', elements, writes),
-        ...(variants.length === 0
-            ? ['  VARIANTS: none yet.', '']
-            : [
-                `  VARIANTS (${String(variants.length)}), under the elements that accept them:`,
-                ...[...worn.keys()].sort().map((name) => `    ${name} — ${(worn.get(name) ?? []).sort().map(camelOf).join(', ')}`),
-                ...(() => {
-                    const nobody = variants.filter((one) => (one.wears ?? []).length === 0).map((one) => one.id);
-                    return nobody.length === 0
-                        ? []
-                        : [`    worn by nothing, so writable nowhere: ${nobody.sort().join(', ')}`];
-                })(),
-                '',
-            ]),
-        '  Materials, style guide values, fonts and animations are chosen inside a VARIANT, never inside',
-        `  a body — \`${TYPED} create variant\` prints every one of them at the moment one is needed.`,
-        '',
-        `  Every element and the tags it is written as: \`${TYPED} create element\`. Every variant and`,
-        `  the tag it is worn as: \`${TYPED} create variant\`. Then open the one nearest to what you are`,
-        `  about to build with \`${TYPED} read <id>\` — it already answers how a body is arranged, how a`,
-        '  variant is worn and how a control reaches an operation, and a file cannot be wrong in the way',
-        '  a remembered example can.',
-        '',
-    ];
-}
-export const catalogue = async () => listed(findTree(), 'composition');
-export const screening = async () => listed(findTree(), 'screen');
 const TAG = /<([A-Z][A-Za-z0-9]*)/g;
 export function composed(body, rows, from, except) {
     const named = new Map();