@assistant-ui/react-generative-ui 0.0.18 → 0.0.19

package/dist/JSONGenerativeUI.client.d.ts

@@ -11,7 +11,7 @@ import { JSONGenerativeUIOptions, PresentTool, PresentToolOptions, PromptUserToo
  * `actions` registry (if provided) is threaded into the render context so
  * interactive components can fire `$action` through `$dispatch`.
  */
-declare class JSONGenerativeUI {
+export declare class JSONGenerativeUI {
   private readonly library;
   private readonly parameters;
   private readonly actions;
@@ -26,5 +26,4 @@ declare class JSONGenerativeUI {
   promptUser(): PromptUserTool;
 }
 //#endregion
-export { JSONGenerativeUI };
 //# sourceMappingURL=JSONGenerativeUI.client.d.ts.map

package/dist/JSONGenerativeUI.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JSONGenerativeUI.client.d.ts","names":[],"sources":["../src/JSONGenerativeUI.client.tsx"],"mappings":";;;;;;;;;;;;;cAkCa;mBACM;mBACA;mBACA;EAEL,YAAA,SAAS;;;;;;mBAWJ;EAejB,QAAQ,UAAU,qBAAqB;EASvC,cAAc"}
+{"version":3,"file":"JSONGenerativeUI.client.d.ts","names":[],"sources":["../src/JSONGenerativeUI.client.tsx"],"mappings":";;;;;;;;;;;;;qBAkCa;mBACM;mBACA;mBACA;EAEL,YAAA,SAAS;;;;;;mBAWJ;EAejB,QAAQ,UAAU,qBAAqB;EASvC,cAAc"}

package/dist/JSONGenerativeUI.server.d.ts

@@ -13,12 +13,11 @@ import { JSONGenerativeUIOptions, PresentTool, PresentToolOptions, PromptUserToo
  * `as` casts here because the tool types require a `render` for frontend/human
  * tools; on the server it is structurally absent and never read.
  */
-declare class JSONGenerativeUI {
+export declare class JSONGenerativeUI {
   private readonly parameters;
   constructor(options: JSONGenerativeUIOptions);
   present(options?: PresentToolOptions): PresentTool;
   promptUser(): PromptUserTool;
 }
 //#endregion
-export { JSONGenerativeUI };
 //# sourceMappingURL=JSONGenerativeUI.server.d.ts.map

package/dist/JSONGenerativeUI.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JSONGenerativeUI.server.d.ts","names":[],"sources":["../src/JSONGenerativeUI.server.tsx"],"mappings":";;;;;;;;;;;;;;;cAwBa;mBACM;EAEL,YAAA,SAAS;EAIrB,QAAQ,UAAU,qBAAqB;EAIvC,cAAc"}
+{"version":3,"file":"JSONGenerativeUI.server.d.ts","names":[],"sources":["../src/JSONGenerativeUI.server.tsx"],"mappings":";;;;;;;;;;;;;;;qBAwBa;mBACM;EAEL,YAAA,SAAS;EAIrB,QAAQ,UAAU,qBAAqB;EAIvC,cAAc"}

package/dist/JSONGenerativeUI.shared.d.ts

@@ -1,10 +1,10 @@
-import { JSONSchema7 } from "./node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.js";
 import { ActionRegistry } from "./actionRegistry.js";
 import { GenerativeUILibrary } from "./types.js";
 import { ToolDefinition } from "@assistant-ui/react";
+import { JSONSchema7 } from "json-schema";
 //#region src/JSONGenerativeUI.shared.d.ts
 /** Options for {@link JSONGenerativeUI}. */
-type JSONGenerativeUIOptions = {
+export type JSONGenerativeUIOptions = {
   /**
    * The components the model is allowed to render, keyed by the `$type` it
    * selects them with. Author it with `defineGenerativeComponents({ ... })` so a
@@ -20,7 +20,7 @@ type JSONGenerativeUIOptions = {
   actions?: ActionRegistry;
 };
 /** Options for {@link JSONGenerativeUI.present}. */
-type PresentToolOptions = {
+export type PresentToolOptions = {
   /**
    * Set `"standalone"` to render the component on its own surface (outside the
    * chain-of-thought trace), e.g. a full-bleed artifact like a card. Omit it for
@@ -35,17 +35,17 @@ type BackendDefaultMetadata = {
   };
 };
 /** The `present` tool, as the model sees it (no client `render`/`execute`). */
-type PresentTool = ToolDefinition<Record<string, unknown>, Record<string, never>> & BackendDefaultMetadata;
+export type PresentTool = ToolDefinition<Record<string, unknown>, Record<string, never>> & BackendDefaultMetadata;
 /** The `prompt_user` tool, as the model sees it (no client `render`). */
-type PromptUserTool = ToolDefinition<Record<string, unknown>, unknown> & BackendDefaultMetadata;
+export type PromptUserTool = ToolDefinition<Record<string, unknown>, unknown> & BackendDefaultMetadata;
 /** The tool `parameters` schema, built once per instance (see `buildPresentParameters`). */
-type PresentParameters = JSONSchema7;
+export type PresentParameters = JSONSchema7;
 /**
  * The schema-only half of the `present` tool, shared by both builds. The server
  * build returns exactly this; the client build adds `execute` and `render`.
  * Takes the already-built `parameters` so it isn't recomputed per tool.
  */
-declare function presentToolBase(parameters: PresentParameters, options?: PresentToolOptions): {
+export declare function presentToolBase(parameters: PresentParameters, options?: PresentToolOptions): {
   display?: "standalone";
   type: "frontend";
   description: string;
@@ -55,11 +55,10 @@ declare function presentToolBase(parameters: PresentParameters, options?: Presen
  * The schema-only half of the `prompt_user` tool, shared by both builds. The
  * server build returns exactly this; the client build adds `render`.
  */
-declare function promptUserToolBase(parameters: PresentParameters): {
+export declare function promptUserToolBase(parameters: PresentParameters): {
   type: "human";
   description: string;
   parameters: JSONSchema7;
 };
 //#endregion
-export { JSONGenerativeUIOptions, PresentParameters, PresentTool, PresentToolOptions, PromptUserTool, presentToolBase, promptUserToolBase };
 //# sourceMappingURL=JSONGenerativeUI.shared.d.ts.map

package/dist/JSONGenerativeUI.shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JSONGenerativeUI.shared.d.ts","names":[],"sources":["../src/JSONGenerativeUI.shared.ts"],"mappings":";;;;;;KAMY;;;;;;EAMV,SAAS;;;;;;;EAOT,UAAU;;;KAIA;;;;;;;EAOV;;KAGG;EACH;IACE;;;;KAKQ,cAAc,eACxB,yBACA,yBAEA;;KAGU,iBAAiB,eAAe,oCAC1C;;KAYU,oBAAoB;;;;;;iBAOhB,gBACd,YAAY,mBACZ,UAAU;;;;;;;;;;iBAcI,mBAAmB,YAAY;;;cAAA"}
+{"version":3,"file":"JSONGenerativeUI.shared.d.ts","names":[],"sources":["../src/JSONGenerativeUI.shared.ts"],"mappings":";;;;;;YAMY;;;;;;EAMV,SAAS;;;;;;;EAOT,UAAU;;;YAIA;;;;;;;EAOV;;KAGG;EACH;IACE;;;;YAKQ,cAAc,eACxB,yBACA,yBAEA;;YAGU,iBAAiB,eAAe,oCAC1C;;YAYU,oBAAoB;;;;;;wBAOhB,gBACd,YAAY,mBACZ,UAAU;;;;;;;;;;wBAcI,mBAAmB,YAAY;;;cAAA"}

package/dist/a2ui/convert.d.ts

@@ -1,10 +1,9 @@
 import { UIElement } from "../ir.js";
 import { A2uiSurfaceState } from "./types.js";
 //#region src/a2ui/convert.d.ts
-declare function convertSurfaceToUISpec(surface: A2uiSurfaceState): {
+export declare function convertSurfaceToUISpec(surface: A2uiSurfaceState): {
   spec: UIElement | null;
   warnings: string[];
 };
 //#endregion
-export { convertSurfaceToUISpec };
 //# sourceMappingURL=convert.d.ts.map

package/dist/a2ui/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","names":[],"sources":["../../src/a2ui/convert.ts"],"mappings":";;;iBAscgB,uBAAuB,SAAS;EAC9C,MAAM;EACN"}
+{"version":3,"file":"convert.d.ts","names":[],"sources":["../../src/a2ui/convert.ts"],"mappings":";;;wBAscgB,uBAAuB,SAAS;EAC9C,MAAM;EACN"}

package/dist/a2ui/reducer.d.ts

@@ -1,6 +1,5 @@
 import { A2uiOperationResult, A2uiState } from "./types.js";
 //#region src/a2ui/reducer.d.ts
-declare function applyA2uiOperations(state: A2uiState, operations: unknown): A2uiOperationResult;
+export declare function applyA2uiOperations(state: A2uiState, operations: unknown): A2uiOperationResult;
 //#endregion
-export { applyA2uiOperations };
 //# sourceMappingURL=reducer.d.ts.map

package/dist/a2ui/reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducer.d.ts","names":[],"sources":["../../src/a2ui/reducer.ts"],"mappings":";;iBAuNgB,oBACd,OAAO,WACP,sBACC"}
+{"version":3,"file":"reducer.d.ts","names":[],"sources":["../../src/a2ui/reducer.ts"],"mappings":";;wBAuNgB,oBACd,OAAO,WACP,sBACC"}

package/dist/a2ui/types.d.ts

@@ -1,73 +1,72 @@
 //#region src/a2ui/types.d.ts
-declare const A2UI_SURFACE_ID: unique symbol;
-type A2uiVersion = "v0.9" | "v1.0";
-interface A2uiTemplateChildren {
+export declare const A2UI_SURFACE_ID: unique symbol;
+export type A2uiVersion = "v0.9" | "v1.0";
+export interface A2uiTemplateChildren {
   readonly template: {
     readonly componentId: string;
     readonly path: string;
   };
 }
-interface ComponentNode extends Record<string, unknown> {
+export interface ComponentNode extends Record<string, unknown> {
   readonly id: string;
   readonly component: string;
   readonly children?: readonly string[] | A2uiTemplateChildren;
 }
-interface A2uiCreateSurfaceV09Payload {
+export interface A2uiCreateSurfaceV09Payload {
   readonly surfaceId: string;
   readonly catalogId?: string;
   readonly theme?: unknown;
   readonly attachDataModel?: unknown;
 }
-interface A2uiCreateSurfaceV10Payload {
+export interface A2uiCreateSurfaceV10Payload {
   readonly surfaceId: string;
   readonly surfaceProperties?: unknown;
   readonly sendDataModel?: unknown;
   readonly components?: readonly ComponentNode[];
   readonly dataModel?: unknown;
 }
-interface A2uiUpdateComponentsPayload {
+export interface A2uiUpdateComponentsPayload {
   readonly surfaceId: string;
   readonly components: readonly ComponentNode[];
 }
-interface A2uiUpdateDataModelPayload {
+export interface A2uiUpdateDataModelPayload {
   readonly surfaceId: string;
   readonly path?: string;
   readonly contents?: unknown;
   readonly value?: unknown;
   readonly data?: unknown;
 }
-interface A2uiDeleteSurfacePayload {
+export interface A2uiDeleteSurfacePayload {
   readonly surfaceId: string;
 }
-type A2uiCreateSurfaceOperation = {
+export type A2uiCreateSurfaceOperation = {
   readonly version: "v0.9";
   readonly createSurface: A2uiCreateSurfaceV09Payload;
 } | {
   readonly version: "v1.0";
   readonly createSurface: A2uiCreateSurfaceV10Payload;
 };
-interface A2uiUpdateComponentsOperation {
+export interface A2uiUpdateComponentsOperation {
   readonly version: A2uiVersion;
   readonly updateComponents: A2uiUpdateComponentsPayload;
 }
-interface A2uiUpdateDataModelOperation {
+export interface A2uiUpdateDataModelOperation {
   readonly version: A2uiVersion;
   readonly updateDataModel: A2uiUpdateDataModelPayload;
 }
-interface A2uiDeleteSurfaceOperation {
+export interface A2uiDeleteSurfaceOperation {
   readonly version: A2uiVersion;
   readonly deleteSurface: A2uiDeleteSurfacePayload;
 }
-type A2uiOperation = A2uiCreateSurfaceOperation | A2uiUpdateComponentsOperation | A2uiUpdateDataModelOperation | A2uiDeleteSurfaceOperation;
-type A2uiSurfaceState = {
+export type A2uiOperation = A2uiCreateSurfaceOperation | A2uiUpdateComponentsOperation | A2uiUpdateDataModelOperation | A2uiDeleteSurfaceOperation;
+export type A2uiSurfaceState = {
   components: Map<string, Record<string, unknown>>;
   dataModel: unknown;
 };
-type A2uiState = ReadonlyMap<string, A2uiSurfaceState>;
-interface A2uiOperationResult {
+export type A2uiState = ReadonlyMap<string, A2uiSurfaceState>;
+export interface A2uiOperationResult {
   readonly state: A2uiState;
   readonly warnings: string[];
 }
 //#endregion
-export { A2UI_SURFACE_ID, A2uiCreateSurfaceOperation, A2uiCreateSurfaceV09Payload, A2uiCreateSurfaceV10Payload, A2uiDeleteSurfaceOperation, A2uiDeleteSurfacePayload, A2uiOperation, A2uiOperationResult, A2uiState, A2uiSurfaceState, A2uiTemplateChildren, A2uiUpdateComponentsOperation, A2uiUpdateComponentsPayload, A2uiUpdateDataModelOperation, A2uiUpdateDataModelPayload, A2uiVersion, ComponentNode };
 //# sourceMappingURL=types.d.ts.map

package/dist/a2ui/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/a2ui/types.ts"],"mappings":";cAAa;KAED;UAEK;WACN;aACE;aACA;;;UAII,sBAAsB;WAC5B;WACA;WACA,+BAA+B;;UAGzB;WACN;WACA;WACA;WACA;;UAGM;WACN;WACA;WACA;WACA,sBAAsB;WACtB;;UAGM;WACN;WACA,qBAAqB;;UAGf;WACN;WACA;WACA;WACA;WACA;;UAGM;WACN;;KAGC;WAEG;WACA,eAAe;;WAGf;WACA,eAAe;;UAGb;WACN,SAAS;WACT,kBAAkB;;UAGZ;WACN,SAAS;WACT,iBAAiB;;UAGX;WACN,SAAS;WACT,eAAe;;KAGd,gBACR,6BACA,gCACA,+BACA;KAEQ;EACV,YAAY,YAAY;EACxB;;KAGU,YAAY,oBAAoB;UAE3B;WACN,OAAO;WACP"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/a2ui/types.ts"],"mappings":";qBAAa;YAED;iBAEK;WACN;aACE;aACA;;;iBAII,sBAAsB;WAC5B;WACA;WACA,+BAA+B;;iBAGzB;WACN;WACA;WACA;WACA;;iBAGM;WACN;WACA;WACA;WACA,sBAAsB;WACtB;;iBAGM;WACN;WACA,qBAAqB;;iBAGf;WACN;WACA;WACA;WACA;WACA;;iBAGM;WACN;;YAGC;WAEG;WACA,eAAe;;WAGf;WACA,eAAe;;iBAGb;WACN,SAAS;WACT,kBAAkB;;iBAGZ;WACN,SAAS;WACT,iBAAiB;;iBAGX;WACN,SAAS;WACT,eAAe;;YAGd,gBACR,6BACA,gCACA,+BACA;YAEQ;EACV,YAAY,YAAY;EACxB;;YAGU,YAAY,oBAAoB;iBAE3B;WACN,OAAO;WACP"}

package/dist/actionRegistry.d.ts

@@ -1,7 +1,7 @@
 import { Action } from "./ir.js";
 //#region src/actionRegistry.d.ts
 /** Context handed to an {@link ActionHandler} when an `$action` fires. */
-type ActionDispatchContext = {
+export type ActionDispatchContext = {
   /**
    * The action payload. For fire-and-forget actions this is the `$action` as the model emitted it. For an interactive component the user's runtime input is merged in under the reserved `$input` key: a single value for a standalone control's dispatch, or an object keyed by each field's `name` for a `Form` or a `Card` with `asForm` set. A model-supplied `value` field is never clobbered.
    */
@@ -14,19 +14,18 @@ type ActionDispatchContext = {
  * value is left as `unknown` and documented per-action). The return value is
  * handed back to `dispatch`'s caller as `unknown`.
  */
-type ActionHandler = (ctx: ActionDispatchContext) => unknown | Promise<unknown>;
+export type ActionHandler = (ctx: ActionDispatchContext) => unknown | Promise<unknown>;
 /**
  * The host-provided map from `$action.type` to {@link ActionHandler}. This is the single dispatch target for rendered generative UI: every interactive component fires its `$action` here through the injected `$dispatch` (a submit Button defers to its ancestor form's dispatch instead). The payload's `$input` takes one of two shapes: a single value for a standalone control's dispatch (`Select`, `Input`, `DatePicker`, `Checkbox`, `RadioGroup`), or an object keyed by field `name` for a `Form` or a `Card` with `asForm` set. Construct it with {@link createActionRegistry} and pass it to `JSONGenerativeUI`.
  */
-type ActionRegistry = {
+export type ActionRegistry = {
   dispatch(action: Action): unknown;
   has(type: string): boolean;
 };
-declare function createActionRegistry(handlers: Readonly<Record<string, ActionHandler>>): ActionRegistry;
+export declare function createActionRegistry(handlers: Readonly<Record<string, ActionHandler>>): ActionRegistry;
 /** A no-op registry used when no handlers are provided. Dispatch resolves to
  * `undefined` and logs a warning in dev for unknown types, so a model-emitted
  * action with no handler degrades to "does nothing" rather than throwing. */
-declare const emptyActionRegistry: ActionRegistry;
+export declare const emptyActionRegistry: ActionRegistry;
 //#endregion
-export { ActionDispatchContext, ActionHandler, ActionRegistry, createActionRegistry, emptyActionRegistry };
 //# sourceMappingURL=actionRegistry.d.ts.map

package/dist/actionRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actionRegistry.d.ts","names":[],"sources":["../src/actionRegistry.ts"],"mappings":";;;KAGY;;;;WAID,SAAS;;;;;;;;;KAUR,iBACV,KAAK,oCACQ;;;;KAKH;EACV,SAAS,QAAQ;EACjB,IAAI;;iBAGU,qBACd,UAAU,SAAS,eAAe,kBACjC;;;;cA0CU,qBAAqB"}
+{"version":3,"file":"actionRegistry.d.ts","names":[],"sources":["../src/actionRegistry.ts"],"mappings":";;;YAGY;;;;WAID,SAAS;;;;;;;;;YAUR,iBACV,KAAK,oCACQ;;;;YAKH;EACV,SAAS,QAAQ;EACjB,IAAI;;wBAGU,qBACd,UAAU,SAAS,eAAe,kBACjC;;;;qBA0CU,qBAAqB"}

package/dist/buildPresentParameters.d.ts

@@ -1,5 +1,5 @@
-import { JSONSchema7 } from "./node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.js";
 import { GenerativeUILibrary } from "./types.js";
+import { JSONSchema7 } from "json-schema";
 //#region src/buildPresentParameters.d.ts
 /**
  * Builds the JSON schema for the `present` tool from a {@link GenerativeUILibrary}.
@@ -18,7 +18,6 @@ import { GenerativeUILibrary } from "./types.js";
  * renderer validates nothing here — an unknown `$type` or stray prop is handled
  * at render time — so a looser schema only costs the model a hint, not safety.
  */
-declare function buildPresentParameters(library: GenerativeUILibrary): JSONSchema7;
+export declare function buildPresentParameters(library: GenerativeUILibrary): JSONSchema7;
 //#endregion
-export { buildPresentParameters };
 //# sourceMappingURL=buildPresentParameters.d.ts.map

package/dist/buildPresentParameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildPresentParameters.d.ts","names":[],"sources":["../src/buildPresentParameters.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAsBgB,uBACd,SAAS,sBACR"}
+{"version":3,"file":"buildPresentParameters.d.ts","names":[],"sources":["../src/buildPresentParameters.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAsBgB,uBACd,SAAS,sBACR"}

package/dist/constants.d.ts

@@ -8,7 +8,7 @@
  * colliding with the discriminator. It mirrors the `$type` discriminator
  * convention used by JSON polymorphism elsewhere.
  */
-declare const TYPE_KEY = "$type";
+export declare const TYPE_KEY = "$type";
+export declare const GENERATED_NAME_ATTR = "data-aui-generated-name";
 //#endregion
-export { TYPE_KEY };
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/constants.ts"],"mappings":";;;;;;;;;;cASa"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/constants.ts"],"mappings":";;;;;;;;;;qBASa;qBAEA"}

package/dist/constants.js

@@ -9,7 +9,8 @@
 * convention used by JSON polymorphism elsewhere.
 */
 const TYPE_KEY = "$type";
+const GENERATED_NAME_ATTR = "data-aui-generated-name";
 //#endregion
-export { TYPE_KEY };
+export { GENERATED_NAME_ATTR, TYPE_KEY };
 
 //# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * The wire key naming the component to render.\n *\n * The model emits nodes as flat objects `{ [TYPE_KEY]: name, ...props }`. We\n * use `$type` rather than `type` so a component's own `type` prop (e.g. a\n * button's `type=\"submit\"`) flows through as an ordinary prop without\n * colliding with the discriminator. It mirrors the `$type` discriminator\n * convention used by JSON polymorphism elsewhere.\n */\nexport const TYPE_KEY = \"$type\";\n"],"mappings":";;;;;;;;;;AASA,MAAa,WAAW"}
+{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * The wire key naming the component to render.\n *\n * The model emits nodes as flat objects `{ [TYPE_KEY]: name, ...props }`. We\n * use `$type` rather than `type` so a component's own `type` prop (e.g. a\n * button's `type=\"submit\"`) flows through as an ordinary prop without\n * colliding with the discriminator. It mirrors the `$type` discriminator\n * convention used by JSON polymorphism elsewhere.\n */\nexport const TYPE_KEY = \"$type\";\n\nexport const GENERATED_NAME_ATTR = \"data-aui-generated-name\";\n"],"mappings":";;;;;;;;;;AASA,MAAa,WAAW;AAExB,MAAa,sBAAsB"}

package/dist/convert/boundSpec.d.ts

@@ -1,13 +1,13 @@
 //#region src/convert/boundSpec.d.ts
 /** The maximum traversal depth, counted in visited values, not tree levels. */
-declare const MAX_TRAVERSAL_DEPTH = 64;
+export declare const MAX_TRAVERSAL_DEPTH = 64;
 /**
  * The element-nesting ceiling a caller observes. `boundNode` visits an element
  * and its `children` array separately, so one level of nesting spends two of
  * {@link MAX_TRAVERSAL_DEPTH}; it runs before the conversion walk and is never
  * the looser of the two. A root array costs one more level than a root object.
  */
-declare const MAX_ELEMENT_DEPTH: number;
+export declare const MAX_ELEMENT_DEPTH: number;
 /**
  * The maximum number of entries kept at any single level (root, or a
  * `children` array at any depth) of the raw spec, before it ever reaches
@@ -15,7 +15,7 @@ declare const MAX_ELEMENT_DEPTH: number;
  * can never be made to walk further than this regardless of what the array
  * claims about itself.
  */
-declare const CHILDREN_CAP = 200;
+export declare const CHILDREN_CAP = 200;
 /**
  * The total number of nodes {@link boundSpec} will visit across one walk,
  * regardless of how many times a shared reference recurs. Bounds the
@@ -23,10 +23,10 @@ declare const CHILDREN_CAP = 200;
  * otherwise force even though each individual array stays within
  * {@link CHILDREN_CAP}.
  */
-declare const NODE_BUDGET = 5000;
-type ClampReason = "children" | "budget" | "cycle" | "depth";
+export declare const NODE_BUDGET = 5000;
+export type ClampReason = "children" | "budget" | "cycle" | "depth";
 /** Renders the warning detail a protocol reports for one {@link ClampReason}. */
-declare function clampReasonDetail(reason: ClampReason): string;
+export declare function clampReasonDetail(reason: ClampReason): string;
 /**
  * Produces a bounded plain copy of a raw generative-ui spec before it
  * reaches `normalizeSpec`, whose own traversal of the root array or any
@@ -45,7 +45,6 @@ declare function clampReasonDetail(reason: ClampReason): string;
  * {@link NODE_BUDGET} nodes, so shared references cannot multiply work
  * exponentially, and a node that is its own ancestor is cut to `null`.
  */
-declare function boundSpec(spec: unknown, onClamp: (reason: ClampReason) => void): unknown;
+export declare function boundSpec(spec: unknown, onClamp: (reason: ClampReason) => void): unknown;
 //#endregion
-export { CHILDREN_CAP, ClampReason, MAX_ELEMENT_DEPTH, MAX_TRAVERSAL_DEPTH, NODE_BUDGET, boundSpec, clampReasonDetail };
 //# sourceMappingURL=boundSpec.d.ts.map

package/dist/convert/boundSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundSpec.d.ts","names":[],"sources":["../../src/convert/boundSpec.ts"],"mappings":";;cAGa;;;;;;;cAQA;;;;;;;;cASA;;;;;;;;cASA;KAED;;iBAGI,kBAAkB,QAAQ;;;;;;;;;;;;;;;;;;;iBAwF1B,UACd,eACA,UAAU,QAAQ"}
+{"version":3,"file":"boundSpec.d.ts","names":[],"sources":["../../src/convert/boundSpec.ts"],"mappings":";;qBAGa;;;;;;;qBAQA;;;;;;;;qBASA;;;;;;;;qBASA;YAED;;wBAGI,kBAAkB,QAAQ;;;;;;;;;;;;;;;;;;;wBAwF1B,UACd,eACA,UAAU,QAAQ"}

package/dist/convert/copyBounded.d.ts

@@ -19,10 +19,9 @@
  * that same normalized figure, so a `length` whose `valueOf` answers differently
  * on a second conversion cannot separate the warning from the bound.
  */
-declare const copyBounded: <T>(value: readonly T[], cap: number) => {
+export declare const copyBounded: <T>(value: readonly T[], cap: number) => {
   readonly items: T[];
   readonly truncated: boolean;
 };
 //#endregion
-export { copyBounded };
 //# sourceMappingURL=copyBounded.d.ts.map

package/dist/convert/copyBounded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copyBounded.d.ts","names":[],"sources":["../../src/convert/copyBounded.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cAoBa,cAAe,GAC1B,gBAAgB,KAChB;WACY,OAAO;WAAc"}
+{"version":3,"file":"copyBounded.d.ts","names":[],"sources":["../../src/convert/copyBounded.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBAoBa,cAAe,GAC1B,gBAAgB,KAChB;WACY,OAAO;WAAc"}

package/dist/convert/isElement.d.ts

@@ -1,6 +1,5 @@
 import { NormalizedUIElement, NormalizedUINode } from "../ir.js";
 //#region src/convert/isElement.d.ts
-declare const isElement: (node: NormalizedUINode) => node is NormalizedUIElement;
+export declare const isElement: (node: NormalizedUINode) => node is NormalizedUIElement;
 //#endregion
-export { isElement };
 //# sourceMappingURL=isElement.d.ts.map

package/dist/convert/isElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isElement.d.ts","names":[],"sources":["../../src/convert/isElement.ts"],"mappings":";;cAEa,YACX,MAAM,qBACL,QAAQ"}
+{"version":3,"file":"isElement.d.ts","names":[],"sources":["../../src/convert/isElement.ts"],"mappings":";;qBAEa,YACX,MAAM,qBACL,QAAQ"}

package/dist/convert/takeRun.d.ts

@@ -1,9 +1,8 @@
 import { NormalizedUIElement, NormalizedUINode } from "../ir.js";
 //#region src/convert/takeRun.d.ts
-declare function takeRun(nodes: readonly (NormalizedUINode | undefined)[], index: number, matches: (element: NormalizedUIElement) => boolean): {
+export declare function takeRun(nodes: readonly (NormalizedUINode | undefined)[], index: number, matches: (element: NormalizedUIElement) => boolean): {
   run: NormalizedUIElement[];
   next: number;
 };
 //#endregion
-export { takeRun };
 //# sourceMappingURL=takeRun.d.ts.map

package/dist/convert/takeRun.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"takeRun.d.ts","names":[],"sources":["../../src/convert/takeRun.ts"],"mappings":";;iBAGgB,QACd,iBAAiB,iCACjB,eACA,UAAU,SAAS;EAChB,KAAK;EAAuB"}
+{"version":3,"file":"takeRun.d.ts","names":[],"sources":["../../src/convert/takeRun.ts"],"mappings":";;wBAGgB,QACd,iBAAiB,iCACjB,eACA,UAAU,SAAS;EAChB,KAAK;EAAuB"}

package/dist/defineGenerativeComponents.d.ts

@@ -26,7 +26,6 @@ import { GenerativeUILibrary } from "./types.js";
  * is missing, or it was used outside a `"use generative"` file), so it throws
  * rather than shipping client `render` code to the server.
  */
-declare function defineGenerativeComponents(_library: GenerativeUILibrary): GenerativeUILibrary;
+export declare function defineGenerativeComponents(_library: GenerativeUILibrary): GenerativeUILibrary;
 //#endregion
-export { defineGenerativeComponents };
 //# sourceMappingURL=defineGenerativeComponents.d.ts.map

package/dist/defineGenerativeComponents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defineGenerativeComponents.d.ts","names":[],"sources":["../src/defineGenerativeComponents.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BgB,2BACd,UAAU,sBACT"}
+{"version":3,"file":"defineGenerativeComponents.d.ts","names":[],"sources":["../src/defineGenerativeComponents.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BgB,2BACd,UAAU,sBACT"}

package/dist/generativeUIToJSX.d.ts

@@ -1,6 +1,6 @@
 //#region src/generativeUIToJSX.d.ts
 /** Options for {@link generativeUIToJSX}. */
-interface GenerativeUIToJSXOptions {
+export interface GenerativeUIToJSXOptions {
   /** Escape string children so the output is safe to paste back into a JSX file. Defaults to `false`. */
   escape?: boolean;
   /** Pretty-print nested element trees with two-space indentation. Defaults to `false`. */
@@ -15,7 +15,6 @@ interface GenerativeUIToJSXOptions {
  *
  * Pass `{ pretty: true }` to pretty-print nested element trees with two-space indentation, while pure text children stay on one line.
  */
-declare function generativeUIToJSX(node: unknown, options?: GenerativeUIToJSXOptions): string;
+export declare function generativeUIToJSX(node: unknown, options?: GenerativeUIToJSXOptions): string;
 //#endregion
-export { GenerativeUIToJSXOptions, generativeUIToJSX };
 //# sourceMappingURL=generativeUIToJSX.d.ts.map

package/dist/generativeUIToJSX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generativeUIToJSX.d.ts","names":[],"sources":["../src/generativeUIToJSX.ts"],"mappings":";;UAGiB;;EAEf;;EAEA;;;;;;;;;;;iBAYc,kBACd,eACA,UAAU"}
+{"version":3,"file":"generativeUIToJSX.d.ts","names":[],"sources":["../src/generativeUIToJSX.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;;;;;;;;;;wBAYc,kBACd,eACA,UAAU"}

package/dist/ir.d.ts

@@ -15,30 +15,30 @@
  * - `children` is additionally reserved (the JSX convention).
  * - every other key is an inline prop passed straight to the component.
  */
-declare const TEXT_SIZES: readonly ["sm", "md", "lg", "xl", "2xl", "3xl"];
-type TextSize = (typeof TEXT_SIZES)[number];
-declare const IMAGE_SIZE_TOKENS: readonly ["sm", "md", "lg"];
-type ImageSize = (typeof IMAGE_SIZE_TOKENS)[number] | number;
-declare const WEIGHTS: readonly ["normal", "medium", "semibold", "bold"];
-type Weight = (typeof WEIGHTS)[number];
-declare const COLORS: readonly ["emphasis", "secondary", "alpha-70", "white", "white-70", "white-50"];
-type Color = (typeof COLORS)[number];
-declare const ALIGNS: readonly ["start", "center", "end"];
-type Align = (typeof ALIGNS)[number];
-declare const JUSTIFIES: readonly ["start", "center", "end", "between"];
-type Justify = (typeof JUSTIFIES)[number];
-declare const BUTTON_STYLES: readonly ["primary", "secondary", "outline", "ghost", "danger"];
-type ButtonStyle = (typeof BUTTON_STYLES)[number];
-declare const ALERT_TONES: readonly ["info", "success", "warning", "danger"];
+export declare const TEXT_SIZES: readonly ["sm", "md", "lg", "xl", "2xl", "3xl"];
+export type TextSize = (typeof TEXT_SIZES)[number];
+export declare const IMAGE_SIZE_TOKENS: readonly ["sm", "md", "lg"];
+export type ImageSize = (typeof IMAGE_SIZE_TOKENS)[number] | number;
+export declare const WEIGHTS: readonly ["normal", "medium", "semibold", "bold"];
+export type Weight = (typeof WEIGHTS)[number];
+export declare const COLORS: readonly ["emphasis", "secondary", "alpha-70", "white", "white-70", "white-50"];
+export type Color = (typeof COLORS)[number];
+export declare const ALIGNS: readonly ["start", "center", "end"];
+export type Align = (typeof ALIGNS)[number];
+export declare const JUSTIFIES: readonly ["start", "center", "end", "between"];
+export type Justify = (typeof JUSTIFIES)[number];
+export declare const BUTTON_STYLES: readonly ["primary", "secondary", "outline", "ghost", "danger"];
+export type ButtonStyle = (typeof BUTTON_STYLES)[number];
+export declare const ALERT_TONES: readonly ["info", "success", "warning", "danger"];
 /** A severity level, from informational to destructive. */
-type AlertTone = (typeof ALERT_TONES)[number];
-declare const ICON_NAMES: readonly ["sun", "moon", "cloud", "rain", "snow", "wind", "play", "pause", "check", "x", "star", "heart", "arrow-right", "arrow-up-right", "chevron-right", "calendar", "clock", "map-pin", "plane", "truck", "credit-card", "user", "search", "bell"];
+export type AlertTone = (typeof ALERT_TONES)[number];
+export declare const ICON_NAMES: readonly ["sun", "moon", "cloud", "rain", "snow", "wind", "play", "pause", "check", "x", "star", "heart", "arrow-right", "arrow-up-right", "chevron-right", "calendar", "clock", "map-pin", "plane", "truck", "credit-card", "user", "search", "bell"];
 /** A name from the built-in icon set; the closed enum lets the model see exactly which icons exist. */
-type IconName = (typeof ICON_NAMES)[number];
+export type IconName = (typeof ICON_NAMES)[number];
 /**
  * Behavior payload carried by an interactive node. `type` is resolved by the host's action registry, not the renderer; keeping behavior as data keeps the tree serializable, so the same node renders on web while converters may bind the type to a native action id on other platforms.
  */
-interface Action {
+export interface Action {
   readonly type: string;
   readonly [payload: string]: unknown;
 }
@@ -48,12 +48,12 @@ interface Action {
  * input boundary (numbers render as text, falsy/boolean as nothing, arrays as
  * lists); {@link normalizeUINode} accepts that full range.
  */
-type UINode = string | number | UIElement | LegacyComponentNode;
-type UIChildren = UINode | readonly UINode[];
+export type UINode = string | number | UIElement | LegacyComponentNode;
+export type UIChildren = UINode | readonly UINode[];
 /** The flat node shape: inline props keep the tree compact and natural for a
  * model to emit, instead of a nested `{ type, props }` bag. Reserved keys are
  * stripped before props reach the component (see the module header). */
-interface UIElement {
+export interface UIElement {
   readonly $type: string;
   readonly $key?: string | number;
   readonly children?: UIChildren;
@@ -65,13 +65,13 @@ interface UIElement {
  * for backward compatibility. New code authors the flat {@link UIElement}
  * shape instead.
  */
-interface LegacyComponentNode {
+export interface LegacyComponentNode {
   readonly component: string;
   readonly props?: Record<string, unknown>;
   readonly children?: UIChildren;
   readonly key?: string;
 }
-type UISpec = UINode | readonly UINode[];
+export type UISpec = UINode | readonly UINode[];
 /**
  * A node normalized to a single canonical shape: a `type` string, an inline
  * `props` bag, recursive `children`, an optional `key`, and an optional
@@ -80,14 +80,14 @@ type UISpec = UINode | readonly UINode[];
  * `component` shape, and they never see the reserved `$`-prefixed keys leak
  * into component props.
  */
-interface NormalizedUIElement {
+export interface NormalizedUIElement {
   readonly type: string;
   readonly props: Readonly<Record<string, unknown>>;
   readonly children?: NormalizedUINode | undefined;
   readonly key?: string | number | undefined;
   readonly action?: Action | undefined;
 }
-type NormalizedUINode = string | number | readonly NormalizedUINode[] | NormalizedUIElement | null;
+export type NormalizedUINode = string | number | readonly NormalizedUINode[] | NormalizedUIElement | null;
 /**
  * Normalizes a generative-ui input to {@link NormalizedUINode}. The flat
  * `$type` shape and the legacy `component` shape both map to the same canonical
@@ -102,14 +102,13 @@ type NormalizedUINode = string | number | readonly NormalizedUINode[] | Normaliz
  * node is held back while completed siblings render. Omit it for a
  * non-streaming (converter) normalize.
  */
-declare function normalizeUINode(node: unknown, partialPath?: readonly string[] | undefined, depth?: number): NormalizedUINode;
+export declare function normalizeUINode(node: unknown, partialPath?: readonly string[] | undefined, depth?: number): NormalizedUINode;
 /**
  * Normalizes the root of a {@link UISpec}, preserving whether the root was a
  * single node or a list.
  */
-declare function normalizeSpec(spec: UISpec): {
+export declare function normalizeSpec(spec: UISpec): {
   readonly root: NormalizedUINode | readonly NormalizedUINode[];
 };
 //#endregion
-export { ALERT_TONES, ALIGNS, Action, AlertTone, Align, BUTTON_STYLES, ButtonStyle, COLORS, Color, ICON_NAMES, IMAGE_SIZE_TOKENS, IconName, ImageSize, JUSTIFIES, Justify, LegacyComponentNode, NormalizedUIElement, NormalizedUINode, TEXT_SIZES, TextSize, UIChildren, UIElement, UINode, UISpec, WEIGHTS, Weight, normalizeSpec, normalizeUINode };
 //# sourceMappingURL=ir.d.ts.map

package/dist/ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.ts","names":[],"sources":["../src/ir.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa;KACD,mBAAmB;cAElB;KACD,oBAAoB;cAEnB;KACD,iBAAiB;cAEhB;KAQD,gBAAgB;cAEf;KACD,gBAAgB;cAEf;KACD,kBAAkB;cAEjB;KAOD,sBAAsB;cAErB;;KAED,oBAAoB;cAEnB;;KA2BD,mBAAmB;;;;UAKd;WACN;YACC;;;;;;;;KASA,2BAA2B,YAAY;KAEvC,aAAa,kBAAkB;;;;UAK1B;WACN;WACA;WACA,WAAW;WACX,UAAU;YACT;;;;;;;UAQK;WACN;WACA,QAAQ;WACR,WAAW;WACX;;KAGC,SAAS,kBAAkB;;;;;;;;;UAUtB;WACN;WACA,OAAO,SAAS;WAChB,WAAW;WACX;WACA,SAAS;;KAGR,8CAGC,qBACT;;;;;;;;;;;;;;;iBA6CY,gBACd,eACA,6CACA,iBACC;;;;;iBAuEa,cAAc,MAAM;WACzB,MAAM,4BAA4B"}
+{"version":3,"file":"ir.d.ts","names":[],"sources":["../src/ir.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAmBa;YACD,mBAAmB;qBAElB;YACD,oBAAoB;qBAEnB;YACD,iBAAiB;qBAEhB;YAQD,gBAAgB;qBAEf;YACD,gBAAgB;qBAEf;YACD,kBAAkB;qBAEjB;YAOD,sBAAsB;qBAErB;;YAED,oBAAoB;qBAEnB;;YA2BD,mBAAmB;;;;iBAKd;WACN;YACC;;;;;;;;YASA,2BAA2B,YAAY;YAEvC,aAAa,kBAAkB;;;;iBAK1B;WACN;WACA;WACA,WAAW;WACX,UAAU;YACT;;;;;;;iBAQK;WACN;WACA,QAAQ;WACR,WAAW;WACX;;YAGC,SAAS,kBAAkB;;;;;;;;;iBAUtB;WACN;WACA,OAAO,SAAS;WAChB,WAAW;WACX;WACA,SAAS;;YAGR,8CAGC,qBACT;;;;;;;;;;;;;;;wBA6CY,gBACd,eACA,6CACA,iBACC;;;;;wBAuEa,cAAc,MAAM;WACzB,MAAM,4BAA4B"}

package/dist/renderGenerativeUI.d.ts

@@ -11,7 +11,6 @@ import { ReactNode } from "react";
  * `render(props, context)`, with `children` rendered recursively so components
  * can nest.
  */
-declare function renderGenerativeUI(node: unknown, library: GenerativeUILibrary, context?: GenerativeUIRenderContext): ReactNode;
+export declare function renderGenerativeUI(node: unknown, library: GenerativeUILibrary, context?: GenerativeUIRenderContext): ReactNode;
 //#endregion
-export { renderGenerativeUI };
 //# sourceMappingURL=renderGenerativeUI.d.ts.map

package/dist/renderGenerativeUI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderGenerativeUI.d.ts","names":[],"sources":["../src/renderGenerativeUI.tsx"],"mappings":";;;;;;;;;;;;;iBAwBgB,mBACd,eACA,SAAS,qBACT,UAAS,4BACR"}
+{"version":3,"file":"renderGenerativeUI.d.ts","names":[],"sources":["../src/renderGenerativeUI.tsx"],"mappings":";;;;;;;;;;;;;wBAwBgB,mBACd,eACA,SAAS,qBACT,UAAS,4BACR"}