@nodegx/export 0.0.0-stage → 0.2.5

package/dist/emit/animateLib.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `src/lib/animate.ts` — the animation pair's frame engine, emitted into the app (EXP-011 §49).
+ *
+ * The same shape as {@link ./timerLib.ts}: constant text, shipped only where a component calls into
+ * it, a fifth module rather than a section of `timer.ts` because an app with a countdown should
+ * not ship a tween engine. `states.ts` ({@link ./statesLib.ts}) imports this one.
+ *
+ * It is a transcription of four things the interpreter runs:
+ *
+ * - `noodl-runtime/src/timerscheduler.ts` — one timer with repeat count 1: `start()` queues it, it
+ *   **joins at the end of the next frame** with `_start = frameTime + delay` (a zero delay plays
+ *   `onStart` + `onRunning(0)` in that frame), each later frame at or after `_start` computes
+ *   `t = (now − _start) / duration` (`1` when the duration is 0), calls `onRunning(min(t, 1))`, and
+ *   at `t ≥ 1` calls `onFinish`. `stop()` fires nothing; `start()` on a running timer stops it first.
+ * - `noodl-viewer-react/src/easecurves.ts` — start/end baked into every curve, so callers pass the
+ *   endpoints. The four names the picker offers, with `easeIn`/`easeOut`/`easeInOut` aliased onto
+ *   the cubic variants exactly as that file does.
+ * - `bezier-easing` 1.1.1 — the solver behind a States transition's `curve: [x1, y1, x2, y2]`,
+ *   transcribed with its constants (four Newton iterations, the eleven-sample table, the
+ *   subdivision fallback) so the two worlds put the same value on the same frame.
+ * - `noodl-viewer-react/src/nodes/std-library/animate-to-value.ts` — the first target is adopted
+ *   outright, a target equal to the current end is ignored, anything else tweens from wherever the
+ *   value is; booleans are 1/0 and a NaN is ignored; `At Target Value` fires on finish only.
+ *
+ * ⚠️ **One liberty, recorded.** The frame clock is `requestAnimationFrame`'s timestamp here and the
+ * viewer's frame callback there; both are monotonic milliseconds advanced by the host once per
+ * frame, and nothing an author can wire observes which.
+ */
+/** Where the module lands in the exported app. */
+export declare const ANIMATE_LIB_PATH = "src/lib/animate.ts";
+/** The exported helpers a component imports. Sorted — the import list is sorted too. */
+export declare const ANIMATE_HELPERS: readonly ["useAnimatedValue"];
+/** The easing names the node's enum offers — `easecurves.ts`'s aliases, in the picker's order. */
+export declare const ANIMATE_EASE_NAMES: readonly ["easeOut", "easeIn", "linear", "easeInOut"];
+export type AnimateEaseName = (typeof ANIMATE_EASE_NAMES)[number];
+/**
+ * The module's source.
+ *
+ * ⚠️ A plain string rather than a template literal, for `dateLib.ts`'s stated reason: the emitted
+ * body needs no interpolation, and keeping it out of an interpolation context means a future edit
+ * cannot accidentally interpolate the generator's own scope into the exported app.
+ */
+export declare function animateLibSource(): string;

package/dist/emit/component.d.ts

@@ -0,0 +1,144 @@
+/**
+ * The visual-node generator (EXP-002 step 4): one component file + one CSS module per component,
+ * from a ComponentPlan. The target shapes are hand-written in EXP-002-TARGET-OUTPUT.md §1–§2 and
+ * the golden tests hold this emitter to them:
+ *
+ * - Component Inputs → a typed optional-props interface; wires from it become JSX interpolations
+ *   (one input feeding two sinks is two interpolations, not a variable).
+ * - One CSS-module class per visual node (style.ts owns the split); identical style sets merge
+ *   and naming.ts owns every name.
+ * - A For Each whose effective mapping is the static identity `map({...})` literal becomes
+ *   `items.map()` with per-prop spreading and `key={item.id}`.
+ * - A DbCollection2 consumed by a repeater becomes plain `useState` + `useEffect` over a typed
+ *   api stub — no library, no magic.
+ * - `RouterNavigate` resolves at generation time to `navigate('/url')` on the wired element.
+ * - Unwired inputs stay native and uncontrolled; a control earns state only when a wire demands
+ *   it. Exporting the app's behaviour includes exporting its gaps.
+ */
+import { CatalogIndex } from '../catalog';
+import { ComponentPlan, ProjectPlan } from '../analyze/plan';
+import { ExportIR, NodeIR } from '../ir/types';
+import { KitBinding } from './kits';
+import { MediaHelper } from './mediaLib';
+/**
+ * The old Look-preset markers (P100-UPG001-VARIANT). No runtime, viewer or exporter reads them (UPG-001 §3.4), so a
+ * node that still carries one has lost nothing, and the report must not say it was dropped. The editor's own list is
+ * `PRESET_MARKERS` in `noodl-editor/…/models/Looks/looks.ts`. This package may not import the editor (HLS-001 AC2),
+ * so `tests/p100-upg001-variant.test.ts` holds the two copies equal.
+ */
+export declare const PRESET_MARKERS: readonly ["_variant", "_size"];
+/**
+ * EXP-015. The element an author asked a node to render as, validated, with the sentence to report
+ * when the answer is "not that one".
+ *
+ * The port is real, shipped and documented as mattering — `Text.tsx` renders `props.as || 'div'`
+ * and `Group.tsx` destructures `const { as = 'div' }` — and until this function existed the
+ * exporter never read it. One landing-page template set it 61 times and the export lost all 61,
+ * shipping a site with no heading of any level and no landmark of any kind.
+ *
+ * 🔴 **Validated against the catalog's own enum for this node type, never a list written here.**
+ * `Text` offers `div h1…h6 p span`; `Group` offers `div section article aside nav header footer
+ * main span`; the two lists differ and both are the editor's own dropdown. A hand-written mirror
+ * drifts the moment somebody adds `<figure>` to one of them — `a-second-copy-of-a-palette-drifts-
+ * silently` — so the catalog artifact is the authority and this function only reads it.
+ *
+ * Three ways to be told no — in this order, each reported rather than silently ignored, because a
+ * silently ignored authored value is the defect this exists to fix:
+ *
+ * 1. **The value is a void element**, which cannot take children. Checked FIRST and without
+ *    consulting the catalog, so that it is a real outer gate rather than dead code behind the enum
+ *    test: neither shipped enum contains one today, and the whole point of the guard is the day one
+ *    does. Its absence is `<img className={…}>Sign up</img>` in somebody's repo.
+ * 2. **The catalog does not describe an `as` port on this type at all.** Only `Text` and `Group`
+ *    carry one, so this is a parameter written by hand or by a tool onto a node whose port set has
+ *    no such port — the export has no authority to invent an element for it.
+ * 3. **The value is outside the port's enum.** The editor cannot produce one; a hand-authored
+ *    project or a future catalog change can.
+ */
+export declare function authoredTag(node: NodeIR, fallback: string, catalog: CatalogIndex): {
+    tag: string;
+    refusal?: {
+        nodeId: string;
+        reason: string;
+    };
+};
+export interface EmittedComponent {
+    /** { "src/pages/Landing.tsx": …, "src/pages/Landing.module.css": … } */
+    files: Record<string, string>;
+    notes: string[];
+    /**
+     * `src/lib/date.ts` helpers this component imports (EXP-011 Tier 1.3), or an empty set.
+     *
+     * 🔴 Reported from **here** rather than derived from the plan, and the difference is the
+     * dead-module trap one construct over: `resolveExpr` runs speculatively, so a plan-side flag
+     * would be set by a date read a later pass then dropped, and the app would ship a `lib/date.ts`
+     * no line imports. This set is filled by the same walkers that write the import line, so the
+     * module exists exactly when something names it.
+     */
+    dateHelpers: Set<string>;
+    /** The same, for `src/lib/util.ts` (EXP-011 Tier 2.7) — same rationale, same filling walkers. */
+    utilHelpers: Set<string>;
+    /** EXP-011 §37 — which of `src/lib/id.ts`'s helpers this component calls. */
+    idHelpers: Set<string>;
+    /** `src/lib/timer.ts` verbs this component calls (EXP-011 §39). */
+    timerHelpers: Set<string>;
+    /** EXP-011 §86. Whether this component runs a Function whose signals have chains (`src/lib/functionRun.ts`). */
+    functionRunLib: boolean;
+    /** EXP-020. `src/lib/noodl.ts`, earned by a printed Function that reads a backend member of the Noodl API. */
+    noodlLib: boolean;
+    /** EXP-020 slice 2: `src/lib/componentScope.ts`, the `Component` a Function's body reads. */
+    componentScopeLib: boolean;
+    /** EXP-011 §49. Whether this component imports `src/lib/animate.ts` / `src/lib/states.ts`. */
+    animateLib: boolean;
+    statesLib: boolean;
+    /** EXP-011 §52. Whether this component imports `src/lib/script.ts`. */
+    scriptLib: boolean;
+    /** P109 ISL-005. Whether this component imports the script-file registry (`src/lib/projectScriptFiles.ts`). */
+    projectScripts: boolean;
+    /** EXP-011 §53. `src/lib/runTasks.ts` is owed when any component keeps a Run Tasks node. */
+    runTasksLib: boolean;
+    /** EXP-011 §54. `src/lib/errors.ts` is owed when this component keeps a boundary or raises on the channel. */
+    errorsLib: boolean;
+    /** EXP-011 §56. `src/lib/filterRecords.ts` is owed when this component prints a Filter Records read. */
+    recordFilterLib: boolean;
+    /** EXP-011 §58. `src/lib/streaming.ts` is owed when this component keeps a streaming node. */
+    streamingLib: boolean;
+    /** EXP-011 §64. `src/lib/sse.ts` is owed when this component keeps a Server-Sent Events node. */
+    sseLib: boolean;
+    /** EXP-011 §65. `src/lib/websocket.ts` is owed when this component keeps a WebSocket node. */
+    websocketLib: boolean;
+    /** EXP-011 §66. `src/lib/realtime.ts` is owed when this component keeps a Subscribe To Changes node. */
+    realtimeLib: boolean;
+    /** GAM-013. `src/lib/repeat.ts` is owed when this component keeps a Repeat node. */
+    repeatLib: boolean;
+    /** EXP-011 §77. `src/lib/actions.ts` is owed when this component keeps an Action Dispatcher or an Action Handler. */
+    actionsLib: boolean;
+    /** EXP-011 §78. `src/lib/history.ts` is owed when this component keeps a State History, an Undo / Redo, a State Snapshot or an Optimistic Update. */
+    historyLib: boolean;
+    /** EXP-011 §79. `src/lib/signIn.ts` is owed when this component keeps a Sign In With. */
+    signInLib: boolean;
+    /** EXP-011 §59. `src/lib/crypto.ts` verbs this component calls; `src/lib/screen.ts` is owed when a viewport hook prints. */
+    cryptoHelpers: Set<string>;
+    screenLib: boolean;
+    /** EXP-011 §60. `src/lib/componentObject.ts` is owed when a record hook, a parent hook or a provider printed. */
+    componentObjectLib: boolean;
+    /** EXP-011 §63. Whether this component imports `src/lib/drag.ts`. */
+    dragLib: boolean;
+    /** EXP-011 §61. `src/lib/pageStack.ts` is owed when this component renders a stack, pushes, pops, or is pushed. */
+    pageStackLib: boolean;
+    /** HLT-014 — a popup slot rendered, so `src/lib/popupDialog.ts` is owed. */
+    popupDialogLib: boolean;
+    /**
+     * EXP-014 §14.5. Which of `src/lib/media.ts`'s helpers this component prints a WIRED src / srcSet /
+     * poster through. Filled by `contentAttrs` at the point the attribute is printed — the same
+     * dead-module rule as `dateHelpers`: the module ships exactly when a line names it.
+     */
+    mediaHelpers: Set<MediaHelper>;
+}
+export declare function emitComponent(plan: ComponentPlan, project: ProjectPlan, ir: ExportIR, catalog: CatalogIndex, 
+/**
+ * EXP-010. Node type → the generated wrapper the pages render it through. Empty when the project
+ * has no kit nodes; a type that is *missing* from a non-empty map is a node whose kit failed to
+ * load, and it emits a named marker rather than nothing.
+ */
+kitBindings?: Map<string, KitBinding>): EmittedComponent | null;

package/dist/emit/dateLib.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `src/lib/date.ts` — the date family's arithmetic, emitted into the app (EXP-011 Tier 1.3).
+ *
+ * Unlike `src/api/http.ts`, which is generated per node from a configuration, this module is the
+ * **same text in every project**: the five pure date nodes are one function each, and what varies
+ * between two projects using them is only the arguments at the call site. So it is a constant
+ * here rather than a builder, and it ships only where something calls into it.
+ *
+ * It is a transcription of two runtime files, and the transcription is the whole job:
+ *
+ * - `noodl-runtime/src/nodes/std-library/date/datemath.ts` — `toDate`, `addToDate`,
+ *   `differenceBetween`, `truncateTo`, `isoWeek`. The clamping rule and the whole-calendar-step
+ *   rule live there and are reproduced exactly, comments included, because both are answers the
+ *   author has already seen in the interpreter.
+ * - `noodl-runtime/src/nodes/std-library/datetostring.ts` — `_format` and `fieldsInZone`.
+ *
+ * 🔴 **`Date To String` reads its input through `toDate`, like the other four, since P107-D14.**
+ * It predates `datemath.ts` and used to read a millisecond **number** unconverted, so `getDate()`
+ * threw and the catch blanked it, while the Timezone branch rendered it. ISL-032 (`844f8569b`,
+ * ruled "One rule, like the other date nodes") moved the runtime to `toDate`. This module kept the
+ * old read for eight days, unseen, because the spec that grades it had been given a `require` stub
+ * that blanked the runtime's side too (P18-S102-DATEHARNESS).
+ *
+ * ⚠️ **These functions are pure; the nodes are not.** A node holds its last answer, and when its
+ * Date input goes from a value to *unset* the interpreter abstains (`_recompute` returns early on
+ * `inputSupplied === false`) and keeps the previous answer, where this returns `undefined`. The
+ * divergence is one transition wide, it only exists for a wired input that can deliver empty, and
+ * the planner reports it where the wire can actually do that. Note that the interpreter is
+ * already inconsistent with itself here: an *invalid* date clears the answer, an *absent* one
+ * does not — and the pure form matches the invalid-date branch.
+ */
+/** Where the module lands in the exported app. */
+export declare const DATE_LIB_PATH = "src/lib/date.ts";
+/** The exported helpers, one per translated date node. Sorted — the import list is sorted too. */
+export declare const DATE_HELPERS: readonly ["dateAdd", "dateCompare", "dateDifference", "datePart", "dateToString"];
+export type DateHelper = (typeof DATE_HELPERS)[number];
+/**
+ * The module's source.
+ *
+ * ⚠️ Written as a plain string rather than a template literal: the emitted body contains `${`
+ * nowhere by design (the runtime's one template literal is a `throw` this transcription does not
+ * reproduce — see `addToDate` below), and keeping it out of an interpolation context means a
+ * future edit cannot accidentally interpolate the generator's own scope into the exported app.
+ */
+export declare function dateLibSource(): string;

package/dist/emit/emitApp.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Whole-app emission: the scaffold, then the visual generator's component/page files replacing
+ * the scaffold's placeholders, then the app-state modules (stores/events — step 5) and the
+ * typed api stubs the pages consume. The dependency list stays computed from the output
+ * (TARGET-OUTPUT §3): @nodegx/core joins package.json exactly when a generated file imports it.
+ */
+import { Catalog } from '../catalog';
+import { ExportIR } from '../ir/types';
+import { EmittedCopy } from './kits';
+import { ExportReportData } from './report';
+export interface EmittedApp {
+    /** Path → content, sorted by path (D-rules). */
+    files: Record<string, string>;
+    /**
+     * Files that travel byte-for-byte rather than being generated (EXP-010 AC5) — every
+     * `noodl_modules` file, sorted by destination.
+     *
+     * 🔴 **A separate channel because `files` is `Record<string, string>` and a font is not a
+     * string.** `noodl_modules/inter/` ships four `.ttf` files and `lucide-icons/` a `.woff2`;
+     * reading one into a UTF-8 string to put it in `files` would corrupt it silently, and the
+     * failure would render as blank glyphs rather than as an error. Emission stays pure — this is a
+     * list of paths, not a filesystem operation — and the caller that writes `files` to disk copies
+     * these alongside.
+     */
+    copies: EmittedCopy[];
+    /** EXP-004's feed: everything analysis or emission dropped or deferred, per component. */
+    notes: string[];
+    /**
+     * The same facts, grouped by the scope the pushing code already knew (EXP-004).
+     *
+     * 🔴 **Built beside `notes`, never derived from it.** `notes` is a flat list of sentences and
+     * three dozen suites assert on its wording; recovering "which component is this about" by
+     * reading those sentences back would make every reword a re-grouping. Both channels are filled
+     * at the same push site, where `plan` is in hand and scope is a fact rather than a guess.
+     */
+    report: ExportReportData;
+}
+export declare function emitApp(ir: ExportIR, catalog: Catalog): EmittedApp;

package/dist/emit/idLib.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `src/lib/id.ts` — the two id generators, emitted into the app (EXP-011 Tier 2.7).
+ *
+ * The same shape as {@link ./dateLib.ts} and {@link ./utilLib.ts}: constant text, shipped only
+ * where something calls into it. A **separate** module rather than a section of `util.ts`, on
+ * that file's own stated rule — a project that formats a string should not ship a CSPRNG.
+ *
+ * It is a transcription of three runtime files, and the two nodes it serves are **not** two
+ * spellings of one thing. `uuid.ts`'s own header says so, and the export has to keep them apart:
+ *
+ * | | `Unique Id` | `UUID` |
+ * |---|---|---|
+ * | shape | 10 chars, alphanumeric | 36 chars, RFC 4122 v4 |
+ * | source | `Math.random()` (`model.ts` `_randomString`) | `crypto.randomUUID` / `crypto.getRandomValues` |
+ * | can it fail | **no** — and the node has no Failure port | **yes**, and it has `failure` and `Error` |
+ *
+ * - `noodl-runtime/src/model.ts` — `Model.guid()` is `_randomString(10)`, and the character set
+ *   and the `(1 + Math.random()) * 0x10000` index are transcribed rather than modernised. An
+ *   `id.length === 10` assertion would pass on a rewrite that drew from a different alphabet, and
+ *   these ids end up in urls and as React keys in apps that already shipped.
+ * - `noodl-runtime/src/nodes/std-library/crypto/encoding.ts` — `randomUuid`, its `randomBytes`
+ *   dependency and `bytesToHex`. 🔴 **The `getRandomValues` throw is transcribed verbatim,
+ *   message included**, because it is the *only* thing `UUID`'s Failure arm can ever report and
+ *   the emitted app's Error output prints it.
+ * - `noodl-runtime/src/nodes/std-library/crypto/uuid.ts` — the node's own `try`/`catch`, which is
+ *   what {@link tryRandomUuid} and `initialUuid` are. The node never lets the throw escape.
+ *
+ * ⚠️ **`randomBytes`'s 65536-byte chunk loop is deliberately not transcribed.** It exists so a
+ * large request does not exceed `getRandomValues`'s per-call quota; this call asks for **16**
+ * bytes, one loop iteration, and reproducing the loop would be transcribing a constraint that
+ * cannot bind here. Everything the loop *decides* for 16 bytes is what the single call does.
+ *
+ * 🔴 **`tryRandomUuid` returns a discriminated union rather than `{ uuid?, error? }`.** The
+ * emitted action branches on it and then reads `.uuid` in the success arm; an optional-property
+ * pair does not narrow, so that read would be `string | undefined` and every sink downstream
+ * would have to guard a value that is always present. The union is what makes the emitted app
+ * typecheck without a `!`.
+ */
+/** Where the module lands in the exported app. */
+export declare const ID_LIB_PATH = "src/lib/id.ts";
+/**
+ * The exported helpers. Sorted — the import list is sorted too.
+ *
+ * `randomUuid` is deliberately **not** exported from the emitted module: it throws, and the two
+ * nodes that use it both catch. Exporting it would offer the exported app a door the interpreter
+ * does not have.
+ */
+export declare const ID_HELPERS: readonly ["initialUuid", "randomId", "tryRandomUuid"];
+export type IdHelper = (typeof ID_HELPERS)[number];
+/**
+ * Which of the two generators a node calls, and what each earns.
+ *
+ * 🔴 Must agree with `ID_NODES` in `plan.ts`, which reads this table rather than restating it.
+ * The `boot` helper seeds the state row and the `call` helper is what the `New` action invokes;
+ * they differ for `UUID` because `initialize` swallows the failure and `_generate` reports it.
+ */
+export declare const ID_HELPERS_BY_FN: Record<'randomId' | 'randomUuid', {
+    boot: IdHelper;
+    call: IdHelper;
+}>;
+/**
+ * The module's source.
+ *
+ * ⚠️ A plain string array rather than a template literal, for `dateLib.ts`'s stated reason: the
+ * emitted body needs no interpolation, and keeping it out of an interpolation context means a
+ * future edit cannot accidentally interpolate the generator's own scope into the exported app.
+ */
+export declare function idLibSource(): string;

package/dist/emit/kits.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Custom node kits in the exported app — EXP-010's emit half, Route B.
+ *
+ * ## What this emits, and the honest cost
+ *
+ * Route B ships the kit's own `index.js` verbatim and runs it behind a small shim implementing the
+ * four things a kit node's code reaches for: `props`, `_internal`, `flagOutputDirty` and
+ * `sendSignalOnOutput`. That is **correct by construction** — the exported app runs the same code
+ * the editor and the deploy run, so a kit node cannot render differently in the three places — and
+ * it is the only route that works for every existing kit on the day it lands.
+ *
+ * 🔴 **It also puts a slice of the Noodl node model into an export that has spent thirty sessions
+ * keeping one out** (`EXP-002-TARGET-OUTPUT.md`'s headline: zero `@nodegx/core` imports). That
+ * cost is real, it is confined to `src/kits/runtime.tsx`, and it is stated in the emitted file
+ * itself rather than left for a reader to discover. Route A — a generated wrapper per node kind
+ * with no shim at all — is the phase's exit criterion and needs a kit-format convention phase 69
+ * owns (EXP-010 §6). This is the floor it will be diffed against.
+ *
+ * ## What a developer reads
+ *
+ * The call site is ordinary React: `<CashflowPill day={12} onDropped={…} />`. The generated
+ * wrapper per node type is a dozen typed lines. Only `runtime.tsx` knows what a Noodl node is.
+ *
+ * ## The file layout, and why it splits
+ *
+ * - `src/kits/runtime.tsx` — the shim, the registry, and `window.React` / `window.Noodl`.
+ * - `src/kits/modules/<dir>/<main>` — each kit's script, byte-identical, **bundled** so it is
+ *   subject to the app's own build rather than served loose.
+ * - `public/noodl_modules/<dir>/…` — everything else in every module folder, **verbatim**, because
+ *   a stylesheet's `url()` references are invisible to the manifest and only survive a copy that
+ *   changes nothing (AC5).
+ *
+ * A kit's script is the one file that goes to `src/` rather than `public/`: it has to be a module
+ * the bundle imports so its evaluation order relative to the globals is guaranteed. Every other
+ * file has exactly one home.
+ */
+import { ExportIR, KitNodeIR, KitPortIR } from '../ir/types';
+/** A file to copy byte-for-byte, rather than generate. Both paths are relative to their root. */
+export interface EmittedCopy {
+    /** Project-relative source, e.g. `noodl_modules/inter/Inter-Bold.ttf`. */
+    from: string;
+    /** Output-relative destination, e.g. `public/noodl_modules/inter/Inter-Bold.ttf`. */
+    to: string;
+}
+/** One custom node type as the emitted app sees it. */
+export interface KitBinding {
+    /** The graph's node type — `nodegx.cashflow.Pill`. */
+    type: string;
+    /** The React symbol the pages import — `Pill`, or `CashflowPill` when `Pill` collides. */
+    symbol: string;
+    /** `src/kits/CashflowKit` — the module pages import `symbol` from. */
+    modulePath: string;
+    def: KitNodeIR;
+    /** Input port name → the wrapper's prop name. Identity unless the name is not an identifier. */
+    propOf: Map<string, string>;
+    /** Signal output port name → the wrapper's callback prop (`dropped` → `onDropped`). */
+    signalPropOf: Map<string, string>;
+    /** Value output port name → the wrapper's callback prop (`liveDay` → `onLiveDayChanged`). */
+    valuePropOf: Map<string, string>;
+}
+export interface EmittedKits {
+    files: Record<string, string>;
+    copies: EmittedCopy[];
+    /** Node type → how to render it. Empty when the project has no usable kit node. */
+    bindings: Map<string, KitBinding>;
+    notes: string[];
+}
+/**
+ * The kit bridge for a project.
+ *
+ * ⚠️ **Every module contributes copies; only kits that loaded contribute code.** A kit that threw
+ * still has its folder shipped and its failure named — deleting the folder because the export
+ * could not read it would take an author's own work out of their repo on the strength of this
+ * pipeline's opinion.
+ */
+export declare function emitKits(ir: ExportIR, usedTypes: Set<string>): EmittedKits;
+/**
+ * A kit port's declared type as TypeScript.
+ *
+ * ⚠️ **`unknown` where the kit says nothing**, never `any`: a port with no declared type is one
+ * the exported app's typecheck genuinely cannot help with, and `any` would quietly claim it can.
+ * A units-typed port is `number | string` because the runtime turns `24` into `"24px"` before the
+ * component sees it, and the graph may equally set `var(--space-4)`.
+ */
+export declare function tsTypeOf(port: KitPortIR): string;

package/dist/emit/mediaLib.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `src/lib/media.ts` — a media URL port as the browser must be handed it, emitted into the app
+ * (EXP-014 §14.5, the `<img src>` residual).
+ *
+ * A transcription of two runtime functions, kept as two functions so each can be cited:
+ *
+ * - `absoluteUrl` is `noodl-runtime/src/utils.ts` `getAbsoluteUrl`: a LOCAL path takes the base
+ *   URL in front; a root-absolute path, a `scheme://` URL and a `data:` URI pass through, and so
+ *   does an empty string. The runtime's base is `Noodl.baseUrl || '/'`; the exported app is served
+ *   from its root, so the base is `/` here. `String(value)` first, as there — a Cloud File is an
+ *   object with a custom `toString()`, and the cast is what makes one usable as a source.
+ * - `mediaSrc` is `noodl-viewer-react/src/nodes/visual/media-source.ts` `resolveMediaSource`, the
+ *   gate the Image and Video nodes put in FRONT of `getAbsoluteUrl`: `null`, `undefined` and `''`
+ *   answer `undefined`, which React renders as no attribute at all. `src=""` resolves to the
+ *   document and refetches the page; `/undefined` requests a file called undefined — both are
+ *   measured in that file's own table, and clearing the attribute is the only spelling that
+ *   produces no request.
+ *
+ * 🔴 **Why this module exists at all.** The emitted app routes with a `BrowserRouter`, so the
+ * DOCUMENT sits at the route's depth and a relative `src` resolves against it. The parameter holds
+ * a project-relative path (`noodl_modules/starter-imagery/portrait.svg`) and the asset travels
+ * through the `copies` channel to `public/<same path>`, served from the site root. On a one-segment
+ * route (`/business`) the relative form resolves to `/noodl_modules/…` and works; on `/gallery/team`
+ * it resolves to `/gallery/noodl_modules/…` and 404s. The viewer never sees this because its Image
+ * node runs every source through `getAbsoluteUrl` at the port; the export printed the parameter
+ * verbatim, and every route the shipped templates emit is one segment deep, which is why three
+ * drives read zero broken images. `cssUrl` in `style.ts` closes the same gap for a CSS `url()`,
+ * for a different reason (a stylesheet resolves against ITSELF).
+ *
+ * ⚠️ **Recorded divergence: `srcset` is resolved candidate by candidate here, and the viewer sets
+ * it verbatim** (`image.ts`, an `inputProps` entry with `propPath: 'dom'` and no setter). Under the
+ * viewer's default hash routing the document is always `/`, so verbatim works there; under path
+ * routing the viewer carries the same latent 404 in `srcset` that this closes for `src`. The
+ * export's router is a path router with no hash mode, so verbatim here would be a picture that
+ * breaks one route-depth away — the residual this module was written to close. The viewer-side
+ * gap is registered in EXP-014, owner NONE, not reproduced.
+ *
+ * ⚠️ The icon node is the one caller that takes `absoluteUrl` DIRECTLY: the runtime's
+ * `iconImageSource` setter (`node-shared-port-definitions.ts`) calls `getAbsoluteUrl` with no
+ * empty gate in front, so an empty icon source stays `src=""` there and stays `src=""` here. That is
+ * the runtime's own unrepaired edge (NDA-012 fixed Image and Video only) — transcribed, not fixed.
+ */
+/** Where the module lands in the exported app. */
+export declare const MEDIA_LIB_PATH = "src/lib/media.ts";
+/** The helpers the module exports; a wired attribute names the one it prints through. */
+export type MediaHelper = 'mediaSrc' | 'mediaSrcSet';
+/**
+ * The DOM attributes that carry a media URL, and the helper each resolves through. Keyed by the
+ * ATTRIBUTE because that is the DOM's meaning, the same key `ATTR_SINK` in `component.ts` uses —
+ * `src` on an `<img>` and on a `<video>` are the same channel.
+ */
+export declare const MEDIA_ATTRS: Record<string, {
+    helper: MediaHelper;
+    resolve: (value: unknown) => string | undefined;
+}>;
+/** `getAbsoluteUrl`, with the base the exported app is served from. */
+export declare function absoluteUrl(value: unknown): string;
+/** `resolveMediaSource`: an empty port clears the attribute; anything else is made absolute. */
+export declare function mediaSrc(value: unknown): string | undefined;
+/**
+ * A `srcset` with every candidate URL resolved and every descriptor kept. The tokeniser is the
+ * HTML parser's own: a candidate URL is a run of non-whitespace with trailing commas stripped (a
+ * comma INSIDE a `data:` URI survives, as it does in the browser), and its descriptors run to the
+ * next comma. A candidate that resolves to nothing is dropped; a list with none left clears.
+ */
+export declare function mediaSrcSet(value: unknown): string | undefined;
+/**
+ * The module's source — the three functions above, as the app receives them.
+ *
+ * 🔴 A second copy of the rule, and it is graded against the first: `tests/the-picture-path.test.ts`
+ * transpiles this text and runs it beside the package's own functions over one table, so the two
+ * cannot drift apart without a row going red. A plain string array rather than a template literal,
+ * for `dateLib.ts`'s stated reason.
+ */
+export declare function mediaLibSource(): string;

package/dist/emit/naming.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Class and symbol naming (EXP-002 step 4, rules from EXP-002-TARGET-OUTPUT.md §1–§2):
+ *
+ * - Class names come from the author's node ids, camelCased. Editor dedup suffixes (`card-3`,
+ *   `body-2`) are stripped when no other class in the component claims the base name — v2 ids
+ *   are author-chosen and semantic, so this is authoring intent carrying through.
+ * - Nodes with byte-identical style declaration sets merge into one class. The merged name is
+ *   the ids' longest common camelCase-word suffix when one exists (`nameLabel`/`emailLabel`… →
+ *   `label`); failing that their longest common word prefix (`fieldName`/`fieldEmail`… →
+ *   `field`, the target's own example); failing both, the alphabetically first id. Determinism
+ *   needs a stated tiebreak, so it is stated here.
+ * - Machine-generated ids (UUIDs) carry no intent: those nodes name from their authored label,
+ *   or fall back to their style role.
+ * - Collisions resolve first-wins in tree order with numeric suffixes (D5).
+ */
+/**
+ * Whether a bindable-looking identifier is in fact reserved (EXP-011 §45). The state allocator
+ * asks it: a checkbox labelled "Private" minted `const [private, setPrivate]`, which is a syntax
+ * error in a strict module — the fixture's own typecheck found it, and the sanitiser above had
+ * the list all along.
+ */
+export declare const isReservedWord: (name: string) => boolean;
+/**
+ * One port name → the identifier it prints as, before per-component collision resolution.
+ * A name that is already a bindable identifier is returned untouched — the emitted interface is
+ * the author's vocabulary wherever it legally can be.
+ */
+export declare function propIdentifier(name: string): string;
+/**
+ * Port name → emitted prop identifier, for every declared input prop of one component.
+ *
+ * Two passes, and the order is the point: a port that is *already* an identifier keeps its name,
+ * so a sanitised sibling yields to it rather than stealing it. The generated callback props
+ * (`onXChanged`, `onClose`) share the destructuring, so they reserve first.
+ */
+export declare function propIdentifiers(plan: {
+    props: ReadonlyArray<{
+        name: string;
+    }>;
+    outputProps: ReadonlyArray<{
+        prop: string;
+    }>;
+    liftedOutputProps: ReadonlyArray<{
+        prop: string;
+    }>;
+    closesPopup?: boolean;
+}): Map<string, string>;
+export interface ClassCandidate {
+    /** Node ids sharing one merged class, in tree (pre-order) encounter order. */
+    nodeIds: string[];
+    /** Fallback when every id is machine-generated: authored label of the first node, if any. */
+    label?: string;
+    /** Style role of the first node — the last-resort name (`page`, `text`, `group`). */
+    role: string;
+}
+/**
+ * Assigns one class name per candidate group, in the given order (first-wins for collisions).
+ * Returns names parallel to the input array.
+ */
+export declare function assignClassNames(groups: ClassCandidate[]): string[];
+/**
+ * Splits one identical-style group into merge subgroups. Byte-identical declarations alone are
+ * not intent: `sectionHead` can collide with the field wrappers by accident. Ids merge only when
+ * they share naming vocabulary — a common first camel word (`fieldName`/`fieldEmail` → `field`)
+ * or a common last one (`nameLabel`/`emailLabel` → `label`). The partition (by-first vs by-last)
+ * that yields fewer classes wins; ties prefer the suffix. Ids sharing neither keep their own
+ * class — duplicate CSS is honest, a stolen name is not. Machine-generated ids never merge.
+ */
+export declare function partitionMergeGroup(nodeIds: string[]): string[][];
+/** `card-3` → `card`: the editor's id-collision counter, not authoring intent. */
+export declare function stripDedupSuffix(id: string): string;
+export declare function camelCase(text: string): string;
+export declare function pascalCase(text: string): string;
+export declare function lowerFirst(text: string): string;
+/** UUID-shaped ids carry no authoring intent. */
+export declare function isMachineId(id: string): boolean;