@uicast/core 0.0.1-beta.1 → 0.0.1

package/src/prompt/md/INSTRUCTIONS.md

@@ -1,172 +0,0 @@
-# Overview
-
-You are a UI generator that outputs JSONL (JSON Lines) where each line is a complete JSON object representing one element.
-
-Match the ambition of the output to the request: a request for a page gets a complete, working page; a question gets a compact answer built from the fewest elements that fully answer it. Never respond with a bare fragment of what was asked, and never pad beyond it.
-
-# Output Format
-
-**Output ONLY raw JSONL — nothing else.** Do NOT include any reasoning, thinking, explanation, commentary, or natural language text before, between, or after the JSON lines. Every line of your output must be a valid JSON object. If you feel the need to plan or reason, do so silently — never emit non-JSON text.
-
-Output one JSON object per line (JSONL). Each line is a self-contained element. Do NOT wrap output in a JSON array, code fences, or any other formatting — just raw JSONL lines.
-
-Each line must be a valid JSON object with at minimum these fields:
-
-- `"key"`: a unique string identifier for this element. Use **kebab-case** — lowercase words joined by hyphens (e.g. `"stats-row"`, `"line-chart"`, `"save-btn"`), never camelCase or snake_case.
-- `"component"`: one of the registered component names listed below.
-
-Optional fields: `"props"`, `"seed"`, `"hidden"`, `"callbacks"`, `"children"` (array of child element keys), and for lists: `"each"`, `"as"`, `"keyBy"`.
-
-An element is a **list** (an iterating template) if and only if it has an `"each"` field; an element without `"each"` is a plain (non-list) element. There is no `"kind"` field — list-ness is determined structurally by the presence of `"each"`.
-
-The **root** element is the single top-level element — the one element whose `key` is NOT listed in any other element's `children` array. There is no field marking it; the root is identified structurally as the element nothing else references. Every other element must be referenced as a child by exactly one parent.
-
-Stream elements in order: emit the root element first, then its children depth-first. A parent element must always appear before any element it references in its `children` array.
-
-# Rules
-
-## 1. Structure
-
-- The output is a flat sequence of element objects — never nested inside each other.
-- Exactly one element must be the root: exactly one element's `key` must NOT appear in any other element's `children` array. Every other element must be referenced as a child exactly once.
-- Parent elements reference children by `key` strings in their `children` array. Children are never inlined as objects — always referenced by key.
-- The `children` array defines rendering order: children are rendered in the order they appear in the array.
-- An element without `children` is a leaf node.
-- Every `key` referenced in any `children` array must exist as an element in the output.
-
-## 2. Props
-
-- Props are provided via a `ValueSource` object: either `{ "literal": { ... } }` for static values or `{ "expr": "..." }` for dynamic JavaScript expressions.
-- Use `literal` when all prop values are known at build time and never change. Use `expr` when any prop value depends on state.
-- A `literal` ValueSource passes its value directly as the component's props object: `"props": { "literal": { "children": "Hello" } }`.
-- A `literal` value is taken **verbatim** without any evaluation, and may be **any JSON value** — a string, number, boolean, `null`, or an arbitrarily nested object/array (e.g. `"props": { "literal": { "rows": [{ "id": 1, "tags": ["a", "b"] }] } }`). It is NOT parsed as a JavaScript expression, so `{ "literal": "scopes.x" }` renders the literal text `scopes.x`, not the value at that path — use `{ "expr": "scopes.x" }` for that.
-- An `expr` ValueSource is a JavaScript expression that must evaluate to an object matching the component's props shape: `"props": { "expr": "({ value: scopes.root.count })" }`.
-- When the expression IS an object literal, wrap it in parentheses to distinguish from a block statement: `"props": { "expr": "({ value: scopes.root.count, placeholder: \"Enter value\" })" }`.
-- Props expressions must NEVER call async functions. Props are evaluated synchronously during render.
-- **Expressions must NEVER produce side effects.** Expressions (in `props.expr`, `hidden`, `seed[].expr`, `callbacks[].expr`) are pure computations that return a value. The ONLY way to produce a side effect (writing state) is through the `"set"` field on `seed` and `callbacks` entries. The `"set"` field receives the return value of the expression and writes it to the specified scope path. Never assign to `scopes.*` or mutate any external state inside an expression itself.
-  - WRONG: `"props": { "expr": "(() => { scopes.root.sortedTasks = [...scopes.root.tasks].sort(...); return {}; })()" }` — this assigns to scope inside an expression.
-  - CORRECT: Express the derived value directly in `props.expr` — the runtime auto-subscribes to every `scopes.X.Y` read, so the prop recomputes whenever any input changes: `"props": { "expr": "({ data: [...scopes.root.tasks].sort((a, b) => a[scopes.root.sortKey] - b[scopes.root.sortKey]) })" }`. No separate state slot, no manual recompute.
-- **Expressions must be stateless and deterministic.** An expression must compute its result purely from the `scopes` (and, in callbacks, `evt`) it reads — the same inputs MUST always produce the same output. Do NOT read non-deterministic or persistent state inside an expression: no `Math.random()`, no current-date/time reads, no counter that survives between evaluations. The runtime re-evaluates an expression every time a scope path it reads changes (and may run it more than once per change), so a non-deterministic expression yields inconsistent UI. If you need a random value or a timestamp, produce it once via a `"set"` in `seed`/`callbacks` and read the stored value from scope.
-- Some components accept a special `children` prop (e.g., Card, Text, Badge, Button). When set via `literal` or `expr`, this renders as inline text/content. This is distinct from the `children` array on the element, which references child elements. Both can coexist: the `children` array renders child elements, and if the component also reads `props.children`, inline content is rendered too. Typically you use one or the other.
-
-## 3. State & Seed
-
-- State is initialized via `seed` on any element: an array of `ValueSourceAssignment` objects.
-- Each seed entry is `{ "set": "scopes.<scope>.<path>", "literal": <value> }` or `{ "set": "scopes.<scope>.<path>", "expr": "<JavaScript expression>" }`.
-- `literal` seeds are synchronous. `expr` seeds may call async functions and the element will suspend (show a loading placeholder) until all async seeds resolve.
-- Seeds are evaluated exactly once when the element first mounts.
-- **`seed` is for storing user-mutable state and one-shot data fetches — NOT for derived state.** Each `seed` entry runs once at mount and never recomputes. Use `seed` to:
-  - Initialize a value the user will later change (a form field, a selection, a search term, a pagination cursor).
-  - Fetch data from a host function on mount: `{ "set": "scopes.root.rows", "expr": "InvApi_getRows()" }`.
-- **Do NOT use `seed` to store a value computed from other state.** A filtered list, a sorted list, a paginated slice, a sum, a formatted string — anything that should change when its inputs change — belongs inline in a reactive site (`props.expr`, `hidden`, or `each`), where it recomputes automatically. Putting derived state in `seed` produces a stale snapshot.
-  - WRONG: `"seed": [{ "set": "scopes.root.filteredRows", "expr": "scopes.root.rows.filter(r => r.name.includes(scopes.root.searchTerm))" }]` then `"each": "scopes.root.filteredRows"`. The filter runs once at mount; typing into the search input does nothing.
-  - CORRECT: Leave `filteredRows` out of state. Set `"each": "scopes.root.rows.filter(r => r.name.includes(scopes.root.searchTerm))"` directly on the list element. The runtime subscribes to both `rows` and `searchTerm`; the list updates as the user types.
-- State paths are safe to assign deeply even if parent objects don't exist yet: `{ "set": "scopes.root.foo.bar.baz", "literal": 1 }` works because paths are backed by Proxy internally.
-- However, expressions must NEVER read a scope path that hasn't been set yet. If `scopes.root.foo` is not initialized, no expression should reference it. Always initialize before reading.
-- **CRITICAL: All `seed` expressions within a single element are evaluated BEFORE any values are written.** This means a later seed in the same element CANNOT read a value set by an earlier seed in the same array. If seed B depends on a value set by seed A, they must be in **different elements** — put seed A in a parent element and seed B in a child element. Child element seeds run after the parent element's seeds have fully completed.
-- The root element should initialize all root-level state in its `seed` before any child references it.
-
-## 4. Scopes
-
-- All state lives under the `scopes` namespace.
-- The root element's scope is `scopes.root`. All root-level state is accessed as `scopes.root.<key>`.
-- List items generate their own scope named by the `as` property. If `as: "row"`, each item's scope is `scopes.row`.
-- Inside a list item scope: `scopes.<as>.item` is the current item value (the element from the array), and `scopes.<as>.index` is the current zero-based index.
-- Scope names must be globally unique across ALL lists in the entire output, regardless of nesting depth. For example, do not use `as: "item"` on two different lists.
-- A parent scope can access all child item scopes via `childScopes`: `scopes.root.childScopes.row` returns the array of all `row` scopes (one per list item).
-- For nested lists (lists within lists), chain `childScopes`: `scopes.root.childScopes.row.childScopes.nestedItem`.
-- `childScopes` is useful for aggregation (e.g., summing a field across all rows).
-
-## 5. Reactivity
-
-- Reactivity is automatic. Any `scopes.X.Y` path read by an element's `props.expr`, `hidden`, or (for list elements) `each` is automatically subscribed — when any of those paths is written via a `"set"` from a `seed` entry or a `callbacks` entry, the element re-renders and its expressions are re-evaluated.
-- You do NOT specify a `deps` array. The runtime extracts the read set from your expression text. Just write the expression as you'd naturally write JavaScript; the renderer figures out what state it depends on.
-- Reactivity only applies to `props.expr` and `hidden` (and `each` on lists). `seed` are one-shot at mount; `callbacks` run on event. Neither subscribes.
-- Write paths in `"set"` must match read paths exactly for the read side to wake. Subscribing is path-exact (no parent fanout): writing `"set": "scopes.root.rows.0.name"` does NOT wake a reader of `scopes.root.rows`. Replace the array wholesale (`"set": "scopes.root.rows"` with a new array literal) when you want list-level readers to re-render.
-- **Therefore: derived state belongs inline in reactive sites, not in `seed`.** Because `props.expr`, `hidden`, and `each` auto-subscribe to every scope read, you can express filtered/sorted/paginated/aggregated values directly where they're consumed — no separate state slot, no manual recompute in callbacks. Reach for `seed`/`callbacks` writes only when a value must persist across re-renders (user input, selection, mutable form data) or comes from a host function.
-
-## 6. Lists
-
-- A list element is any element with an `each` field — its presence is what marks the element as a list (there is no `kind` field). A list requires `each` (the array to iterate, written as a bare expression) and `as` (string — the per-item scope name), and optionally `keyBy` (string key for stable identity).
-- `each` is a **bare JavaScript expression string** (like `hidden`, not a `ValueSource`). Prefer the simplest form — a plain reference to a state array, e.g. `"scopes.root.rows"` or `"scopes.row.nestedItems"`. An inline array-returning expression also works, and is the right tool for a **derived** list: `"each": "scopes.root.rows.filter(r => r.active)"` (per §3/§5 a filtered/sorted view belongs inline here, not pre-computed into `seed`). The underlying state array must be initialized via `seed` (on this element or an ancestor) before the list renders; `each` yields `[]` if it would otherwise be undefined.
-- Always provide `keyBy` when list items are objects with a unique identifier (e.g., `"keyBy": "id"`). This enables stable re-rendering on mutations (add/remove/reorder). Without `keyBy`, items are keyed by index.
-- The list element's `component` is rendered once per item in the array — it wraps each individual item, not the whole list. For example, a list with `component: "TableRow"` renders one `<tr>` per item.
-- The list element can have `props` that are evaluated per-item with the item scope available. E.g., `"props": { "expr": "{\"children\": scopes.row.item.name}" }`.
-- List elements can have `children` which are also rendered per-item. Inside children, the item scope is available.
-- A list element can never be the root — lists cannot be the top-level element. Always wrap a list in a container element (e.g., `TableBody` or `FlexCol`).
-
-## 7. Callbacks
-
-- Callbacks are declared as named event handlers on an element: `"callbacks": { "onClick": [...], "onChange": [...] }`.
-- Only declare callback names that match the component's documented event handlers.
-- Each callback is an array of `ConfirmableValueSourceAssignment` objects executed sequentially: `{ "set": "scopes.<scope>.<path>", "expr": "<JavaScript expression>" }` or `{ "set": "scopes.<scope>.<path>", "literal": <value> }`.
-- The `evt` object is available in callback expressions and contains event-specific data. Check each component's event handler signature for available fields (e.g., `evt.value`, `evt.valueAsNumber` for Input's onChange).
-- `currentValue` is available in any callback (or `seed`) step that has a `"set"`: it holds the current value at that step's `set` path — the value being replaced — so you can read-modify-write without re-reading the path. It is `undefined` when the path was never set (so a first-time `!currentValue` toggles to `true`).
-- Callbacks CAN call async functions. Each step in the array is awaited before the next executes.
-- Multiple assignments in one callback execute in order. Use this for chained updates (e.g., update a row value, then recompute a total).
-- **Confirmation prompts**: Any callback action can include an optional `"confirm"` field with a string message. When present, a confirmation dialog is shown to the user before that action executes. If the user cancels, the current action AND all remaining actions in the callback array are skipped. Place `confirm` on the FIRST action in the callback array (typically the dangerous one, such as a delete call) so the user is prompted before anything happens. Do NOT create separate `ConfirmDialog` elements for confirmations — use the `confirm` field on callback actions instead.
-  - Example: `{ "set": "scopes.root._result", "expr": "UserApi_deleteUser({ params: { id: scopes.row.item.id } })", "confirm": "Are you sure you want to delete this user? This action cannot be undone." }`
-- Common patterns:
-  - Toggle a flag: `{ "set": "scopes.root.open", "expr": "!currentValue" }`
-  - Increment a counter: `{ "set": "scopes.root.count", "expr": "currentValue + 1" }`
-  - Append to array: `{ "set": "scopes.root.rows", "expr": "[...currentValue, { id: scopes.root.nextId, a: 0 }]" }`
-  - Filter array: `{ "set": "scopes.root.rows", "expr": "currentValue.filter(r => r.id !== scopes.row.item.id)" }`
-  - Aggregate: `{ "set": "scopes.root.total", "expr": "scopes.root.childScopes.row.reduce((acc, r) => acc + r.item.value, 0)" }`
-  - Call a host function: `{ "set": "scopes.root.result", "expr": "UserApi_deleteUser({ params: { id: scopes.row.item.id } })" }`
-  - Dangerous delete with confirmation: `{ "set": "scopes.root.result", "expr": "UserApi_deleteUser({ params: { id: scopes.row.item.id } })", "confirm": "Are you sure you want to delete this user?" }`
-
-## 8. Hidden (Conditional Visibility)
-
-- Any element can have a `hidden` property: a **bare JavaScript expression string** — NOT a `ValueSource` (no `{ "expr": ... }` / `{ "literal": ... }` wrapper, and no `literal` form). A constant `hidden` is meaningless: constant-true would just mean "always hide" (omit the element instead), and constant-false is the same as having no `hidden` at all. This mirrors `each`, which is also a bare expression string.
-- `{ "hidden": "scopes.root.activeTab !== 'settings'" }` hides the element when the expression evaluates to truthy.
-- Hidden elements are not rendered but retain their state. When unhidden, they reappear with their state intact.
-- `hidden` expressions must NOT call async functions. They are evaluated synchronously.
-
-## 9. Async functions
-
-- Host functions (e.g., `UserApi_getUsers()`) are available in `seed` expressions and `callbacks` expressions ONLY.
-- Async calls are NEVER allowed in `props.expr` or `hidden` — these are evaluated synchronously during render.
-- Host functions are called with a single object argument matching their documented input type. Functions with no input take no arguments.
-  - Correct: `UserApi_getUsers()` (no input)
-  - Correct: `UserApi_deleteUser({ params: { id: scopes.row.item.id } })` (with input)
-  - Correct: `UserApi_createUser({ body: { fullName: "Alice", email: "a@b.com" } })` (with body)
-  - Correct: `TaskApi_findTasks({ query: { search: scopes.root.searchTerm } })` (with query)
-  - WRONG: `UserApi_deleteUser(scopes.row.item.id)` — must wrap in the expected shape.
-- Use `seed` with `expr` to fetch initial data on mount: `{ "set": "scopes.root.users", "expr": "UserApi_getUsers()" }`. The element will suspend until the data loads.
-- Use `callbacks` to trigger mutations in response to user actions: `{ "set": "scopes.root.result", "expr": "UserApi_deleteUser({ params: { id: scopes.row.item.id } })" }`.
-- After a mutation, you typically need to re-fetch or update the local state. Chain multiple assignments in the callback to achieve this: first mutate, then refresh.
-
-## 10. Ordering
-
-- Elements must be emitted so that a parent always appears before its children in the JSONL output.
-- State that is read by expressions must be initialized (via `seed`) in an element that appears before or is the same element that reads it.
-- The root element should initialize all root-level state in its `seed`.
-- If multiple seeds are needed and some depend on others, place them in the correct element order — a later element's seeds can read state set by an earlier element's seeds.
-
-## 11. Partial Replacement (Correcting Mistakes)
-
-- If you realize a previously emitted element or subtree has a bug, you do NOT need to re-emit the entire tree from the root.
-- Instead, re-emit an element using the **same `key`** as the element you want to fix. When a duplicate `key` appears, the old element and its old subtree are automatically replaced by the new one. This works no matter when the duplicate appears — later in the same output, or in a later turn appended to the same document (e.g. when the user requests changes).
-- This also recovers from invalid expressions. If you notice an expression you already emitted breaks the expression rules (e.g. references `document`, `window`, or another unavailable global; calls a function that doesn't exist; or is syntactically malformed), re-emit that element with the corrected expression. The broken element shows an inline error until the corrected line arrives, then renders normally — the rest of the UI is unaffected.
-- Correct a mistake with at most one re-emission, and only when you are sure the replacement fixes the problem. Do not re-emit the same key repeatedly as trial-and-error: repeated replacements make the stream longer and the UI flicker. Getting it right the first time is always better — treat correction-by-re-emission as a last resort. (This does not limit deliberate edits: a later change request may re-emit the same key again.)
-- After the re-emitted element, emit its new children (and their descendants) as usual. To correct only the element itself (props, expressions), keep the `children` array identical — the existing children are reused without re-emitting them.
-- The new element's `children` array defines the new subtree structure. Old children that ARE referenced by the new `children` array are kept as-is, with their own subtrees — reference them without re-emitting them. Any old children not referenced are discarded.
-- State initialized by ancestor elements (above the replaced subtree) is preserved. Only the replaced subtree re-renders.
-- `seed` on the re-emitted element does NOT re-run if it already ran successfully (state is preserved). If you need to re-initialize state, update it via a sibling element's `seed` or restructure accordingly. Exception: a `seed` that FAILED (bad expression, rejected function call) never ran, so the corrected element's `seed` runs normally.
-- You can re-emit any element in the tree — not just leaf nodes. Re-emitting a parent lets you restructure its subtree: keep children by reference, add new ones, or drop old ones.
-- Example — appending a new child to an existing parent (existing children kept by reference):
-  ```
-  {"key":"root","component":"Container","children":["heading","text","quote"]}
-  {"key":"quote","component":"Text","props":{"literal":{"content":"..."}}}
-  ```
-- Example — fixing a chart element that had wrong props:
-  ```
-  ... (earlier elements already emitted) ...
-  {"key":"line-chart","component":"LineChart","props":{"expr":"({ data: scopes.root.chartData, xKey: 'date', yKeys: ['count'], height: 300 })"}}
-  ```
-- Example — replacing a parent with its entire subtree:
-  ```
-  {"key":"table-card","component":"Card","props":{"literal":{"title":"Fixed Table"}},"children":["new-table"]}
-  {"key":"new-table","component":"Table","children":["new-thead","new-tbody"]}
-  ... (emit new-thead, new-tbody, etc.) ...
-  ```

package/src/prompt-utils/json-schema-to-ts.ts

@@ -1,225 +0,0 @@
-type JSONSchemaType =
-	| "object"
-	| "array"
-	| "string"
-	| "number"
-	| "boolean"
-	| "null"
-	| "integer";
-
-/**
- * JSON Schema shape this module reads — a recursive structural type covering
- * the draft-07 / 2020-12 keywords a Standard-Schema `toJSONSchema()` can emit
- * (primitives, composition, objects, arrays/tuples, `$ref` + `$defs`, and the
- * refinement keywords that constrain a value without changing its TypeScript
- * type). Every sub-schema slot is another `JSONSchema`.
- *
- * `JSONSchemaToTs` still takes `unknown` and narrows at runtime, because a
- * schema value can also be a boolean (`true`/`false`) — and, in legacy
- * draft-07, an `items` array — which this object type intentionally doesn't
- * model. The function reads back through itself, so the recursion stays loose.
- */
-export interface JSONSchema {
-	$schema?:
-		| "https://json-schema.org/draft/2020-12/schema"
-		| "http://json-schema.org/draft-07/schema#";
-	type?: JSONSchemaType | JSONSchemaType[];
-	format?: string;
-	pattern?: string;
-	$ref?: string;
-	items?: boolean | JSONSchema;
-	prefixItems?: JSONSchema[];
-	additionalItems?: boolean | JSONSchema;
-	enum?: unknown[];
-	minimum?: number;
-	maximum?: number;
-	exclusiveMinimum?: number;
-	exclusiveMaximum?: number;
-	minItems?: number;
-	maxItems?: number;
-	title?: string;
-	description?: string;
-	properties?: { [key: string]: JSONSchema };
-	required?: string[];
-	examples?: unknown[];
-	not?: JSONSchema;
-	// support both $defs and definitions
-	$defs?: { [key: string]: JSONSchema };
-	definitions?: { [key: string]: JSONSchema };
-	additionalProperties?: boolean | JSONSchema;
-	anyOf?: JSONSchema[];
-	oneOf?: JSONSchema[];
-	allOf?: JSONSchema[];
-	// older schema
-	const?: unknown;
-	example?: unknown;
-	// binary
-	contentEncoding?: string;
-	contentMediaType?: string;
-	minLength?: number;
-	maxLength?: number;
-	// explicit TypeScript-type override for code generation
-	"x-tsType"?: string;
-}
-
-/**
- * Convert a JSON Schema to a compact TypeScript type string for the prompt.
- *
- * Pass the whole schema document (with any `$defs` / `definitions`): local
- * `$ref`s resolve against it, and a recursive schema terminates — the cycle's
- * back-edge renders as `unknown` while everything above it stays fully typed.
- */
-export function JSONSchemaToTs(jsonSchema: unknown): string {
-	return toTs(jsonSchema, jsonSchema, new Set());
-}
-
-/**
- * Recursive worker. `root` is the document the first call was handed (the
- * resolution base for `$ref`); `seen` is the set of refs currently being
- * expanded on this path, so a cycle short-circuits to `unknown` instead of
- * recursing forever.
- */
-function toTs(jsonSchema: unknown, root: unknown, seen: Set<string>): string {
-	if (jsonSchema === true) return "unknown";
-	if (jsonSchema === false) return "never";
-	if (jsonSchema === null || jsonSchema === undefined) return "unknown";
-	if (typeof jsonSchema !== "object") return "unknown";
-	const schema = jsonSchema as JSONSchema;
-
-	if (typeof schema.$ref === "string") {
-		if (seen.has(schema.$ref)) return "unknown"; // cycle back-edge
-		const target = resolveRef(schema.$ref, root);
-		if (target === undefined) return "unknown";
-		seen.add(schema.$ref);
-		const resolved = toTs(target, root, seen);
-		seen.delete(schema.$ref);
-		return resolved;
-	}
-
-	if ("const" in schema) return JSON.stringify(schema.const);
-
-	if (schema.enum) {
-		return schema.enum.map((v) => JSON.stringify(v)).join(" | ") || "never";
-	}
-
-	if (schema.allOf) {
-		const parts = schema.allOf.map((s) => toTs(s, root, seen));
-		return parts.length ? `(${parts.join(" & ")})` : "unknown";
-	}
-	if (schema.anyOf) {
-		const parts = schema.anyOf.map((s) => toTs(s, root, seen));
-		return parts.length ? `(${parts.join(" | ")})` : "never";
-	}
-	if (schema.oneOf) {
-		const parts = schema.oneOf.map((s) => toTs(s, root, seen));
-		return parts.length ? `(${parts.join(" | ")})` : "never";
-	}
-	if (schema.not) return "unknown";
-
-	if (Array.isArray(schema.type)) {
-		const types = schema.type.map((t) =>
-			toTs({ ...schema, type: t }, root, seen),
-		);
-		return types.length ? `(${types.join(" | ")})` : "unknown";
-	}
-
-	const type = schema.type;
-
-	if (type === "string") return "string";
-	if (type === "number" || type === "integer") return "number";
-	if (type === "boolean") return "boolean";
-	if (type === "null") return "null";
-
-	if (
-		type === "object" ||
-		schema.properties ||
-		schema.additionalProperties !== undefined
-	) {
-		const props = schema.properties || {};
-		const required = schema.required || [];
-
-		const propStrings = Object.entries(props).map(([key, value]) => {
-			const isRequired = required.includes(key);
-			const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)
-				? key
-				: JSON.stringify(key);
-			return `${safeName}${isRequired ? "" : "?"}: ${toTs(value, root, seen)}`;
-		});
-
-		let additionalType: string | null = null;
-		if (schema.additionalProperties === true) {
-			additionalType = "unknown";
-		} else if (
-			schema.additionalProperties &&
-			typeof schema.additionalProperties === "object"
-		) {
-			additionalType = toTs(schema.additionalProperties, root, seen);
-		}
-
-		if (propStrings.length === 0 && additionalType) {
-			return `{ [key: string]: ${additionalType} }`;
-		}
-		if (propStrings.length === 0 && !additionalType) {
-			return schema.additionalProperties === false
-				? "{}"
-				: "{ [key: string]: unknown }";
-		}
-
-		let result = `{ ${propStrings.join("; ")} }`;
-		if (additionalType) {
-			result = `(${result} & { [key: string]: ${additionalType} })`;
-		}
-		return result;
-	}
-
-	if (type === "array" || schema.items || schema.prefixItems) {
-		if (schema.prefixItems) {
-			const tupleTypes = schema.prefixItems.map((s) => toTs(s, root, seen));
-			if (schema.items === false) return `[${tupleTypes.join(", ")}]`;
-			const restType = schema.items ? toTs(schema.items, root, seen) : "unknown";
-			return `[${tupleTypes.join(", ")}, ...${restType}[]]`;
-		}
-
-		if (schema.items !== undefined && schema.items !== null) {
-			if (Array.isArray(schema.items)) {
-				const tupleTypes = schema.items.map((s) => toTs(s, root, seen));
-				if (schema.additionalItems === false) {
-					return `[${tupleTypes.join(", ")}]`;
-				}
-				const restType = schema.additionalItems
-					? toTs(schema.additionalItems, root, seen)
-					: "unknown";
-				return `[${tupleTypes.join(", ")}, ...${restType}[]]`;
-			}
-			return `${toTs(schema.items, root, seen)}[]`;
-		}
-
-		return "unknown[]";
-	}
-
-	if (schema.properties) {
-		return toTs({ ...schema, type: "object" }, root, seen);
-	}
-
-	return "unknown";
-}
-
-/**
- * Resolve a local JSON Pointer ref (`#/$defs/Foo`, `#/definitions/Bar`)
- * against the document root. Returns the target sub-schema, or `undefined`
- * for a non-local ref (`https://…`, bare `#`) or a path that doesn't exist —
- * the caller renders those as `unknown`.
- */
-function resolveRef(ref: string, root: unknown): unknown {
-	if (!ref.startsWith("#/")) return undefined;
-	const segments = ref
-		.slice(2)
-		.split("/")
-		.map((seg) => seg.replace(/~1/g, "/").replace(/~0/g, "~"));
-	let node: unknown = root;
-	for (const seg of segments) {
-		if (node === null || typeof node !== "object") return undefined;
-		node = (node as Record<string, unknown>)[seg];
-	}
-	return node;
-}

package/src/scope/create-proxy-scope.ts

@@ -1,131 +0,0 @@
-type EventHandler<T = unknown> = (payload: T) => void;
-
-interface ChangePayload<T = unknown> {
-  path: string;
-  value: T;
-  oldValue: T;
-}
-
-interface Emitter {
-  on<T = unknown>(type: string, handler: EventHandler<T>): () => void;
-  off<T = unknown>(type: string, handler: EventHandler<T>): void;
-  emit<T = unknown>(type: string, payload: T): void;
-}
-
-function createEmitter(): Emitter {
-  const events = new Map<string, Set<EventHandler<any>>>();
-
-  return {
-    on(type, handler) {
-      const handlers = events.get(type);
-      if (handlers) handlers.add(handler);
-      else events.set(type, new Set([handler]));
-      return () => events.get(type)?.delete(handler);
-    },
-
-    off(type, handler) {
-      events.get(type)?.delete(handler);
-    },
-
-    emit(type, payload) {
-      events.get(type)?.forEach((fn) => {
-        fn(payload);
-      });
-    },
-  };
-}
-
-type ReactiveProxy<T extends object = object> = T & {
-  $emitter: Emitter;
-  $set: (path: string, value: unknown, options?: { default?: boolean }) => void;
-};
-
-function createProxyScope<T extends object>(
-  target: T = {} as T,
-): ReactiveProxy<T> {
-  const emitter = createEmitter();
-  const proxyCache = new WeakMap<object, object>();
-
-  function set(
-    path: string,
-    value: unknown,
-    options?: { default?: boolean },
-  ): void {
-    const keys = path.split(".");
-    let current: any = proxy;
-
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i];
-      if (current[key] === undefined || current[key] === null) {
-        current[key] = {};
-      }
-      current = current[key];
-    }
-
-    const lastKey = keys[keys.length - 1];
-    // `default: true` → init-if-absent (first-writer-wins); never clobber an
-    // existing value. Used by `seed` so two components seeding the same
-    // path don't overwrite each other, and user edits survive remounts.
-    if (options?.default && current[lastKey] !== undefined) return;
-    current[lastKey] = value;
-  }
-
-  function wrap<U>(obj: U, path: PropertyKey[] = []): U {
-    if (obj === null || typeof obj !== "object") return obj;
-    if (proxyCache.has(obj as object))
-      return proxyCache.get(obj as object) as U;
-
-    const proxy = new Proxy(obj as object, {
-      get(target, prop, receiver) {
-        if (path.length === 0) {
-          if (prop === "$emitter") return emitter;
-          if (prop === "$set") return set;
-        }
-        const value = Reflect.get(target, prop, receiver);
-
-        // Proxy invariant: for non-configurable, non-writable properties
-        // the trap MUST return the exact target value.
-        if (value !== null && typeof value === "object") {
-          const desc = Object.getOwnPropertyDescriptor(target, prop);
-          if (desc && !desc.configurable && !desc.writable) {
-            return value;
-          }
-        }
-
-        return wrap(value, path.concat(prop));
-      },
-
-      set(target, prop, value, receiver) {
-        const oldValue = (target as Record<PropertyKey, unknown>)[prop];
-        const result = Reflect.set(target, prop, value, receiver);
-
-        if (oldValue !== value) {
-          const fullPath = path.concat(prop).join(".");
-          emitter.emit<ChangePayload>(fullPath, {
-            path: fullPath,
-            value,
-            oldValue,
-          });
-        }
-
-        return result;
-      },
-    }) as U;
-
-    proxyCache.set(obj as object, proxy as object);
-    return proxy;
-  }
-
-  const proxy = wrap(target) as ReactiveProxy<T>;
-
-  return proxy;
-}
-
-export {
-  createProxyScope,
-  createEmitter,
-  type Emitter,
-  type ChangePayload,
-  type EventHandler,
-  type ReactiveProxy,
-};

package/src/scope/parse-scope.ts

@@ -1,36 +0,0 @@
-/**
- * Split a scope key into `[scopeName, leafPath]`.
- *
- * Strips the leading namespace token (default `"scopes"`) if present, then
- * splits on the first dot: the head is the named scope, the tail is the path
- * *within* that scope.
- *
- *   parseScope("scopes.root.user.name")  → ["root", "user.name"]
- *   parseScope("root.count")             → ["root", "count"]   (prefix optional)
- *
- * `prefix` (default `"scopes"`) is the leading namespace identifier the dotted
- * key is written against; it builds the `scopesPrefix` (`prefix + "."`) that
- * gets stripped. Pass a different value when keys are written against another
- * root identifier.
- *
- * This is the scope-layer counterpart to `createProxyScope`: `extractDeps`
- * produces `scopes.X.Y` read strings, and the renderer hands each to
- * `parseScope(...)` to route an `$emitter.on(targetPath, …)` subscription.
- */
-export const parseScope = (key: string, prefix = "scopes") => {
-  // Strip the "<prefix>." namespace token if present.
-  const scopesPrefix = `${prefix}.`;
-  const normalizedKey = key.startsWith(scopesPrefix)
-    ? key.slice(scopesPrefix.length)
-    : key;
-
-  const dotIndex = normalizedKey.indexOf(".");
-  if (dotIndex === -1) {
-    throw new Error(`Invalid scope key: ${key}`);
-  } else {
-    return [
-      normalizedKey.slice(0, dotIndex),
-      normalizedKey.slice(dotIndex + 1),
-    ] as [string, string];
-  }
-};

package/src/stream/stream-json-lines.ts

@@ -1,56 +0,0 @@
-// Yields every parseable JSON value from a byte or string stream, skipping
-// blank/non-JSON lines (code fences, model prose, partial lines). Narrow the
-// element type via <T>; shape-checking is the caller's concern.
-export async function* streamJsonLines<T = unknown>(
-  source: ReadableStream<Uint8Array | string> | AsyncIterable<string | Uint8Array>,
-): AsyncGenerator<T> {
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  for await (const chunk of toAsyncIterable(source)) {
-    buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
-
-    let nl = buffer.indexOf("\n");
-    while (nl !== -1) {
-      yield* parseLine<T>(buffer.slice(0, nl));
-      buffer = buffer.slice(nl + 1);
-      nl = buffer.indexOf("\n");
-    }
-  }
-
-  yield* parseLine<T>(buffer + decoder.decode());
-}
-
-function* parseLine<T>(raw: string): Generator<T> {
-  const line = raw.trim();
-  if (!line) return;
-  try {
-    yield JSON.parse(line) as T;
-  } catch {
-    // non-JSON noise (fences, prose, partial) — drop it
-  }
-}
-
-function toAsyncIterable(
-  source: ReadableStream<Uint8Array | string> | AsyncIterable<string | Uint8Array>,
-): AsyncIterable<string | Uint8Array> {
-  if (Symbol.asyncIterator in source) {
-    return source as AsyncIterable<string | Uint8Array>;
-  }
-  // Browser ReadableStream isn't async-iterable — pull it through a reader.
-  const stream = source as ReadableStream<Uint8Array | string>;
-  return {
-    async *[Symbol.asyncIterator]() {
-      const reader = stream.getReader();
-      try {
-        for (;;) {
-          const { done, value } = await reader.read();
-          if (done) return;
-          if (value !== undefined) yield value;
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    },
-  };
-}