@assistant-ui/react-generative-ui 0.0.24 → 0.1.0

package/dist/answeredValues.js

@@ -1,37 +0,0 @@
-import * as React from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/answeredValues.tsx
-let answeredValuesContext;
-const supportsContext = typeof React.createContext === "function";
-const useValuesContext = supportsContext ? React.useContext : () => void 0;
-const getAnsweredValuesContext = () => supportsContext ? answeredValuesContext ??= React.createContext(void 0) : void 0;
-const isPlainObject = (value) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-const findAnsweredValues = (interactions) => {
-	const entries = interactions?.entries;
-	if (!entries) return void 0;
-	for (let index = entries.length - 1; index >= 0; index--) {
-		const interaction = entries[index];
-		if (interaction.type !== "action" || !isPlainObject(interaction.payload)) continue;
-		const input = interaction.payload["$input"];
-		if (isPlainObject(input)) return input;
-	}
-};
-const AnsweredValuesProvider = ({ values, children }) => {
-	const Context = getAnsweredValuesContext();
-	return Context ? /* @__PURE__ */ jsx(Context.Provider, {
-		value: values,
-		children
-	}) : children;
-};
-const useAnsweredValue = (name) => {
-	const values = useValuesContext(getAnsweredValuesContext());
-	return name !== void 0 && values && Object.hasOwn(values, name) ? values[name] : void 0;
-};
-//#endregion
-export { AnsweredValuesProvider, findAnsweredValues, useAnsweredValue };
-
-//# sourceMappingURL=answeredValues.js.map

package/dist/answeredValues.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"answeredValues.js","names":[],"sources":["../src/answeredValues.tsx"],"sourcesContent":["import * as React from \"react\";\n\ntype AnsweredValues = Readonly<Record<string, unknown>>;\n\ntype ToolInteractionLog = {\n  readonly entries: readonly {\n    readonly type: string;\n    readonly payload: unknown;\n  }[];\n};\n\nlet answeredValuesContext:\n  | React.Context<AnsweredValues | undefined>\n  | undefined;\nconst supportsContext = typeof React.createContext === \"function\";\nconst useValuesContext = supportsContext ? React.useContext : () => undefined;\n\nconst getAnsweredValuesContext = () =>\n  supportsContext\n    ? (answeredValuesContext ??= React.createContext<\n        AnsweredValues | undefined\n      >(undefined))\n    : undefined;\n\nconst isPlainObject = (value: unknown): value is AnsweredValues => {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    return false;\n  }\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n};\n\nexport const findAnsweredValues = (\n  interactions: ToolInteractionLog | undefined,\n): AnsweredValues | undefined => {\n  const entries = interactions?.entries;\n  if (!entries) return undefined;\n\n  for (let index = entries.length - 1; index >= 0; index--) {\n    const interaction = entries[index]!;\n    if (interaction.type !== \"action\" || !isPlainObject(interaction.payload)) {\n      continue;\n    }\n    const input = interaction.payload[\"$input\"];\n    if (isPlainObject(input)) return input;\n  }\n  return undefined;\n};\n\nexport const AnsweredValuesProvider = ({\n  values,\n  children,\n}: {\n  values: AnsweredValues | undefined;\n  children: React.ReactNode;\n}) => {\n  const Context = getAnsweredValuesContext();\n  return Context ? (\n    <Context.Provider value={values}>{children}</Context.Provider>\n  ) : (\n    children\n  );\n};\n\nexport const useAnsweredValue = (name: string | undefined): unknown => {\n  const values = useValuesContext(getAnsweredValuesContext()!);\n  return name !== undefined && values && Object.hasOwn(values, name)\n    ? values[name]\n    : undefined;\n};\n"],"mappings":";;;AAWA,IAAI;AAGJ,MAAM,kBAAkB,OAAO,MAAM,kBAAkB;AACvD,MAAM,mBAAmB,kBAAkB,MAAM,mBAAmB,KAAA;AAEpE,MAAM,iCACJ,kBACK,0BAA0B,MAAM,cAE/B,KAAA,CAAS,IACX,KAAA;AAEN,MAAM,iBAAiB,UAA4C;CACjE,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,OAAO;CAET,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;AAEA,MAAa,sBACX,iBAC+B;CAC/B,MAAM,UAAU,cAAc;CAC9B,IAAI,CAAC,SAAS,OAAO,KAAA;CAErB,KAAK,IAAI,QAAQ,QAAQ,SAAS,GAAG,SAAS,GAAG,SAAS;EACxD,MAAM,cAAc,QAAQ;EAC5B,IAAI,YAAY,SAAS,YAAY,CAAC,cAAc,YAAY,OAAO,GACrE;EAEF,MAAM,QAAQ,YAAY,QAAQ;EAClC,IAAI,cAAc,KAAK,GAAG,OAAO;CACnC;AAEF;AAEA,MAAa,0BAA0B,EACrC,QACA,eAII;CACJ,MAAM,UAAU,yBAAyB;CACzC,OAAO,UACL,oBAAC,QAAQ,UAAT;EAAkB,OAAO;EAAS;CAA2B,CAAA,IAE7D;AAEJ;AAEA,MAAa,oBAAoB,SAAsC;CACrE,MAAM,SAAS,iBAAiB,yBAAyB,CAAE;CAC3D,OAAO,SAAS,KAAA,KAAa,UAAU,OAAO,OAAO,QAAQ,IAAI,IAC7D,OAAO,QACP,KAAA;AACN"}

package/dist/buildPresentParameters.d.ts

@@ -1,21 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import type { GenerativeUILibrary } from "./types.js";
-/**
- * Builds the JSON schema for the `present` tool from a {@link GenerativeUILibrary}.
- *
- * The model produces a node `{ $type, $key?, ...props }` where `$type` selects
- * a component, the optional `$key` pins a stable identity for list items that
- * may reorder, and the rest are its props. The schema is a flat object: `$type`
- * is an enum of the component names, every component's props are merged into
- * one optional bag, and `children` recurses via `$defs` so the tree can nest.
- *
- * It is intentionally flat rather than a per-`$type` discriminated union. Tool /
- * function-call schemas (OpenAI and others) require the top-level parameters to
- * be a plain object and reject a top-level `oneOf`/`anyOf`/`enum`. So props can't
- * be refined per `$type` at the root; the model is guided instead by `$type`'s
- * description (which lists each component) and each prop's own description. The
- * 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.
- */
-export declare function buildPresentParameters(library: GenerativeUILibrary): JSONSchema7;
-//# sourceMappingURL=buildPresentParameters.d.ts.map

package/dist/buildPresentParameters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildPresentParameters.d.ts","sourceRoot":"","sources":["../src/buildPresentParameters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAyB,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAgB;AAGnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,mBAAmB,GAC3B,WAAW,CA+Fb"}

package/dist/buildPresentParameters.js

@@ -1,95 +0,0 @@
-import { TYPE_KEY } from "./constants.js";
-import { scopeSchema } from "./scopeSchema.js";
-import { toJSONSchema } from "assistant-stream";
-//#region src/buildPresentParameters.ts
-/**
-* Builds the JSON schema for the `present` tool from a {@link GenerativeUILibrary}.
-*
-* The model produces a node `{ $type, $key?, ...props }` where `$type` selects
-* a component, the optional `$key` pins a stable identity for list items that
-* may reorder, and the rest are its props. The schema is a flat object: `$type`
-* is an enum of the component names, every component's props are merged into
-* one optional bag, and `children` recurses via `$defs` so the tree can nest.
-*
-* It is intentionally flat rather than a per-`$type` discriminated union. Tool /
-* function-call schemas (OpenAI and others) require the top-level parameters to
-* be a plain object and reject a top-level `oneOf`/`anyOf`/`enum`. So props can't
-* be refined per `$type` at the root; the model is guided instead by `$type`'s
-* description (which lists each component) and each prop's own description. The
-* 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.
-*/
-function buildPresentParameters(library) {
-	const names = Object.keys(library);
-	const props = /* @__PURE__ */ new Map();
-	const propOwners = /* @__PURE__ */ new Map();
-	const componentSchemas = {};
-	for (const [index, name] of names.entries()) {
-		const definition = `component${index}`;
-		const { schema: propsSchema, referenced } = scopeSchema(toJSONSchema(library[name].properties), `#/$defs/${definition}`);
-		if (propsSchema.type !== "object") throw new Error(`[@assistant-ui/react-generative-ui] Component "${name}": \`properties\` must be an object schema (e.g. \`z.object({ ... })\`).`);
-		let merged = false;
-		for (const [key, schema] of Object.entries(propsSchema.properties ?? {})) {
-			if (key.startsWith("$") || key === "children") continue;
-			if (key === "__proto__") continue;
-			if (!props.has(key)) {
-				props.set(key, schema);
-				merged = true;
-			}
-			propOwners.set(key, [...propOwners.get(key) ?? [], name]);
-		}
-		if (referenced && merged) {
-			const { $schema: _, $id: _id, ...embedded } = propsSchema;
-			componentSchemas[definition] = embedded;
-		}
-	}
-	if (process.env["NODE_ENV"] !== "production") for (const [key, owners] of propOwners) {
-		if (owners.length < 2) continue;
-		console.warn(`[@assistant-ui/react-generative-ui] Prop "${key}" is declared by ${formatComponentList(owners)}; keeping "${owners[0]}"'s schema. Rename or align the prop type to avoid an ambiguous schema.`);
-	}
-	const typeDescription = names.length > 0 ? `The component to render. ${names.map((name) => `"${name}": ${library[name].description}`).join("; ")}` : "The component to render.";
-	const node = {
-		type: "object",
-		properties: {
-			[TYPE_KEY]: {
-				type: "string",
-				enum: names,
-				description: typeDescription
-			},
-			$key: {
-				description: "Stable identity for this UI node. Use it for list items that may reorder.",
-				anyOf: [{ type: "string" }, { type: "number" }]
-			},
-			...Object.fromEntries(props),
-			children: { $ref: "#/$defs/children" }
-		},
-		required: [TYPE_KEY]
-	};
-	const children = {
-		description: "Nested generative UI rendered inside this component.",
-		anyOf: [
-			{ type: "string" },
-			{ $ref: "#/$defs/node" },
-			{
-				type: "array",
-				items: { anyOf: [{ type: "string" }, { $ref: "#/$defs/node" }] }
-			}
-		]
-	};
-	return {
-		...node,
-		$defs: {
-			node,
-			children,
-			...componentSchemas
-		}
-	};
-}
-function formatComponentList(names) {
-	if (names.length <= 2) return names.map((name) => `"${name}"`).join(" and ");
-	return `${names.slice(0, -1).map((name) => `"${name}"`).join(", ")}, and "${names[names.length - 1]}"`;
-}
-//#endregion
-export { buildPresentParameters };
-
-//# sourceMappingURL=buildPresentParameters.js.map

package/dist/buildPresentParameters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildPresentParameters.js","names":[],"sources":["../src/buildPresentParameters.ts"],"sourcesContent":["import { toJSONSchema } from \"assistant-stream\";\nimport type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport { TYPE_KEY } from \"./constants\";\nimport type { GenerativeUILibrary } from \"./types\";\nimport { scopeSchema } from \"./scopeSchema\";\n\n/**\n * Builds the JSON schema for the `present` tool from a {@link GenerativeUILibrary}.\n *\n * The model produces a node `{ $type, $key?, ...props }` where `$type` selects\n * a component, the optional `$key` pins a stable identity for list items that\n * may reorder, and the rest are its props. The schema is a flat object: `$type`\n * is an enum of the component names, every component's props are merged into\n * one optional bag, and `children` recurses via `$defs` so the tree can nest.\n *\n * It is intentionally flat rather than a per-`$type` discriminated union. Tool /\n * function-call schemas (OpenAI and others) require the top-level parameters to\n * be a plain object and reject a top-level `oneOf`/`anyOf`/`enum`. So props can't\n * be refined per `$type` at the root; the model is guided instead by `$type`'s\n * description (which lists each component) and each prop's own description. The\n * renderer validates nothing here — an unknown `$type` or stray prop is handled\n * at render time — so a looser schema only costs the model a hint, not safety.\n */\nexport function buildPresentParameters(\n  library: GenerativeUILibrary,\n): JSONSchema7 {\n  const names = Object.keys(library);\n\n  // Merge every component's props into one optional bag. `$`-prefixed keys and\n  // `children` are framework-reserved (see ir.ts), so drop any author-declared\n  // copies. On a name clash the first component's schema wins — props are an\n  // advisory hint here, not a strict per-component contract.\n  const props = new Map<string, JSONSchema7Definition>();\n  const propOwners = new Map<string, string[]>();\n  const componentSchemas: Record<string, JSONSchema7> = {};\n  for (const [index, name] of names.entries()) {\n    const definition = `component${index}`;\n    const { schema: propsSchema, referenced } = scopeSchema(\n      toJSONSchema(library[name]!.properties),\n      `#/$defs/${definition}`,\n    );\n    if (propsSchema.type !== \"object\") {\n      throw new Error(\n        `[@assistant-ui/react-generative-ui] Component \"${name}\": ` +\n          \"`properties` must be an object schema (e.g. `z.object({ ... })`).\",\n      );\n    }\n    let merged = false;\n    for (const [key, schema] of Object.entries(propsSchema.properties ?? {})) {\n      if (key.startsWith(\"$\") || key === \"children\") continue;\n      // secure-json-parse rejects the whole tool-argument payload on this key,\n      // so advertising it would cost the model the node rather than one prop.\n      if (key === \"__proto__\") continue;\n      if (!props.has(key)) {\n        props.set(key, schema);\n        merged = true;\n      }\n      propOwners.set(key, [...(propOwners.get(key) ?? []), name]);\n    }\n    if (referenced && merged) {\n      // `$schema` is only valid at a schema-resource root, and an embedded\n      // `$id` would both collide across components and re-base the pointers\n      // scopeSchema just rewrote to be document-root relative.\n      const { $schema: _, $id: _id, ...embedded } = propsSchema;\n      componentSchemas[definition] = embedded;\n    }\n  }\n\n  if (process.env[\"NODE_ENV\"] !== \"production\") {\n    for (const [key, owners] of propOwners) {\n      if (owners.length < 2) continue;\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[@assistant-ui/react-generative-ui] Prop \"${key}\" is declared by ` +\n          `${formatComponentList(owners)}; keeping \"${owners[0]}\"'s schema. ` +\n          \"Rename or align the prop type to avoid an ambiguous schema.\",\n      );\n    }\n  }\n\n  // Carry each component's description on the `$type` enum, since there are no\n  // per-branch schemas to hang them on anymore.\n  const typeDescription =\n    names.length > 0\n      ? `The component to render. ${names\n          .map((name) => `\"${name}\": ${library[name]!.description}`)\n          .join(\"; \")}`\n      : \"The component to render.\";\n\n  const node: JSONSchema7 = {\n    type: \"object\",\n    properties: {\n      [TYPE_KEY]: { type: \"string\", enum: names, description: typeDescription },\n      $key: {\n        description:\n          \"Stable identity for this UI node. Use it for list items that may reorder.\",\n        anyOf: [{ type: \"string\" }, { type: \"number\" }],\n      },\n      ...Object.fromEntries(props),\n      children: { $ref: \"#/$defs/children\" },\n    },\n    required: [TYPE_KEY],\n  };\n\n  const children: JSONSchema7 = {\n    description: \"Nested generative UI rendered inside this component.\",\n    anyOf: [\n      { type: \"string\" },\n      { $ref: \"#/$defs/node\" },\n      {\n        type: \"array\",\n        items: { anyOf: [{ type: \"string\" }, { $ref: \"#/$defs/node\" }] },\n      },\n    ],\n  };\n\n  return {\n    ...node,\n    $defs: { node, children, ...componentSchemas },\n  };\n}\n\nfunction formatComponentList(names: string[]) {\n  if (names.length <= 2) return names.map((name) => `\"${name}\"`).join(\" and \");\n\n  return `${names\n    .slice(0, -1)\n    .map((name) => `\"${name}\"`)\n    .join(\", \")}, and \"${names[names.length - 1]}\"`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,uBACd,SACa;CACb,MAAM,QAAQ,OAAO,KAAK,OAAO;CAMjC,MAAM,wBAAQ,IAAI,IAAmC;CACrD,MAAM,6BAAa,IAAI,IAAsB;CAC7C,MAAM,mBAAgD,CAAC;CACvD,KAAK,MAAM,CAAC,OAAO,SAAS,MAAM,QAAQ,GAAG;EAC3C,MAAM,aAAa,YAAY;EAC/B,MAAM,EAAE,QAAQ,aAAa,eAAe,YAC1C,aAAa,QAAQ,KAAK,CAAE,UAAU,GACtC,WAAW,YACb;EACA,IAAI,YAAY,SAAS,UACvB,MAAM,IAAI,MACR,kDAAkD,KAAK,yEAEzD;EAEF,IAAI,SAAS;EACb,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,YAAY,cAAc,CAAC,CAAC,GAAG;GACxE,IAAI,IAAI,WAAW,GAAG,KAAK,QAAQ,YAAY;GAG/C,IAAI,QAAQ,aAAa;GACzB,IAAI,CAAC,MAAM,IAAI,GAAG,GAAG;IACnB,MAAM,IAAI,KAAK,MAAM;IACrB,SAAS;GACX;GACA,WAAW,IAAI,KAAK,CAAC,GAAI,WAAW,IAAI,GAAG,KAAK,CAAC,GAAI,IAAI,CAAC;EAC5D;EACA,IAAI,cAAc,QAAQ;GAIxB,MAAM,EAAE,SAAS,GAAG,KAAK,KAAK,GAAG,aAAa;GAC9C,iBAAiB,cAAc;EACjC;CACF;CAEA,IAAI,QAAQ,IAAI,gBAAgB,cAC9B,KAAK,MAAM,CAAC,KAAK,WAAW,YAAY;EACtC,IAAI,OAAO,SAAS,GAAG;EAEvB,QAAQ,KACN,6CAA6C,IAAI,mBAC5C,oBAAoB,MAAM,EAAE,aAAa,OAAO,GAAG,wEAE1D;CACF;CAKF,MAAM,kBACJ,MAAM,SAAS,IACX,4BAA4B,MACzB,KAAK,SAAS,IAAI,KAAK,KAAK,QAAQ,KAAK,CAAE,aAAa,CAAC,CACzD,KAAK,IAAI,MACZ;CAEN,MAAM,OAAoB;EACxB,MAAM;EACN,YAAY;IACT,WAAW;IAAE,MAAM;IAAU,MAAM;IAAO,aAAa;GAAgB;GACxE,MAAM;IACJ,aACE;IACF,OAAO,CAAC,EAAE,MAAM,SAAS,GAAG,EAAE,MAAM,SAAS,CAAC;GAChD;GACA,GAAG,OAAO,YAAY,KAAK;GAC3B,UAAU,EAAE,MAAM,mBAAmB;EACvC;EACA,UAAU,CAAC,QAAQ;CACrB;CAEA,MAAM,WAAwB;EAC5B,aAAa;EACb,OAAO;GACL,EAAE,MAAM,SAAS;GACjB,EAAE,MAAM,eAAe;GACvB;IACE,MAAM;IACN,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,SAAS,GAAG,EAAE,MAAM,eAAe,CAAC,EAAE;GACjE;EACF;CACF;CAEA,OAAO;EACL,GAAG;EACH,OAAO;GAAE;GAAM;GAAU,GAAG;EAAiB;CAC/C;AACF;AAEA,SAAS,oBAAoB,OAAiB;CAC5C,IAAI,MAAM,UAAU,GAAG,OAAO,MAAM,KAAK,SAAS,IAAI,KAAK,EAAE,CAAC,CAAC,KAAK,OAAO;CAE3E,OAAO,GAAG,MACP,MAAM,GAAG,EAAE,CAAC,CACZ,KAAK,SAAS,IAAI,KAAK,EAAE,CAAC,CAC1B,KAAK,IAAI,EAAE,SAAS,MAAM,MAAM,SAAS,GAAG;AACjD"}

package/dist/constants.d.ts

@@ -1,15 +0,0 @@
-/**
- * The wire key naming the component to render.
- *
- * The model emits nodes as flat objects `{ [TYPE_KEY]: name, ...props }`. We
- * use `$type` rather than `type` so a component's own `type` prop (e.g. a
- * button's `type="submit"`) flows through as an ordinary prop without
- * colliding with the discriminator. It mirrors the `$type` discriminator
- * convention used by JSON polymorphism elsewhere.
- */
-export declare const TYPE_KEY = "$type";
-export declare const GENERATED_NAME_ATTR = "data-aui-generated-name";
-export declare const FIELD_NAME_ATTR = "data-aui-field-name";
-export declare const FIELD_VALUE_ATTR = "data-aui-field-value";
-export declare const CHECKBOX_GROUP_ATTR = "data-aui-checkbox-group";
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,UAAU,CAAC;AAEhC,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,eAAO,MAAM,eAAe,wBAAwB,CAAC;AACrD,eAAO,MAAM,gBAAgB,yBAAyB,CAAC;AAEvD,eAAO,MAAM,mBAAmB,4BAA4B,CAAC"}

package/dist/constants.js

@@ -1,19 +0,0 @@
-//#region src/constants.ts
-/**
-* The wire key naming the component to render.
-*
-* The model emits nodes as flat objects `{ [TYPE_KEY]: name, ...props }`. We
-* use `$type` rather than `type` so a component's own `type` prop (e.g. a
-* button's `type="submit"`) flows through as an ordinary prop without
-* colliding with the discriminator. It mirrors the `$type` discriminator
-* convention used by JSON polymorphism elsewhere.
-*/
-const TYPE_KEY = "$type";
-const GENERATED_NAME_ATTR = "data-aui-generated-name";
-const FIELD_NAME_ATTR = "data-aui-field-name";
-const FIELD_VALUE_ATTR = "data-aui-field-value";
-const CHECKBOX_GROUP_ATTR = "data-aui-checkbox-group";
-//#endregion
-export { CHECKBOX_GROUP_ATTR, FIELD_NAME_ATTR, FIELD_VALUE_ATTR, GENERATED_NAME_ATTR, TYPE_KEY };
-
-//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"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\nexport const FIELD_NAME_ATTR = \"data-aui-field-name\";\nexport const FIELD_VALUE_ATTR = \"data-aui-field-value\";\n\nexport const CHECKBOX_GROUP_ATTR = \"data-aui-checkbox-group\";\n"],"mappings":";;;;;;;;;;AASA,MAAa,WAAW;AAExB,MAAa,sBAAsB;AAEnC,MAAa,kBAAkB;AAC/B,MAAa,mBAAmB;AAEhC,MAAa,sBAAsB"}

package/dist/convert/boundSpec.d.ts

@@ -1,48 +0,0 @@
-/** The maximum traversal depth, counted in visited values, not tree levels. */
-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.
- */
-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
- * `normalizeSpec`. Bounds a hostile array's reported `length` so the pre-pass
- * can never be made to walk further than this regardless of what the array
- * claims about itself.
- */
-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
- * combinatorial work a DAG of shared or self-referential nodes would
- * otherwise force even though each individual array stays within
- * {@link CHILDREN_CAP}.
- */
-export declare const NODE_BUDGET = 5000;
-export type ClampReason = "children" | "budget" | "cycle" | "depth";
-/** Renders the warning detail a protocol reports for one {@link ClampReason}. */
-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
- * `children` array walks the full reported length of a hostile proxied
- * array before any per-field cap downstream ever applies. Every array
- * (root, or `children` at any depth) is capped to {@link CHILDREN_CAP}
- * entries by index, which bounds a proxy however it fabricates `length` or
- * replaces its array methods; recursion itself is capped at
- * {@link MAX_TRAVERSAL_DEPTH}. Every object is returned as a plain copy whose
- * `children` came from a single read, because a record that answers
- * `[[HasProperty]]` and `[[Get]]`, or two `[[Get]]`s, differently would
- * otherwise hand the bound one value and `normalizeSpec` another, skipping
- * every bound here for that subtree. `onClamp` fires once per level that was
- * truncated, receiving the reason for that truncation: `"children"`,
- * `"depth"`, `"budget"`, or `"cycle"`. The walk also spends a total budget of
- * {@link NODE_BUDGET} nodes, so shared references cannot multiply work
- * exponentially, and a node that is its own ancestor is cut to `null`.
- */
-export declare function boundSpec(spec: unknown, onClamp: (reason: ClampReason) => void): unknown;
-//# sourceMappingURL=boundSpec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"boundSpec.d.ts","sourceRoot":"","sources":["../../src/convert/boundSpec.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAA0B,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAEpE,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAS7D;AA6DD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACrC,OAAO,CAQT"}

package/dist/convert/boundSpec.js

@@ -1,108 +0,0 @@
-import { copyBounded } from "./copyBounded.js";
-//#region src/convert/boundSpec.ts
-/** The maximum traversal depth, counted in visited values, not tree levels. */
-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.
-*/
-const MAX_ELEMENT_DEPTH = 32;
-/**
-* 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
-* `normalizeSpec`. Bounds a hostile array's reported `length` so the pre-pass
-* can never be made to walk further than this regardless of what the array
-* claims about itself.
-*/
-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
-* combinatorial work a DAG of shared or self-referential nodes would
-* otherwise force even though each individual array stays within
-* {@link CHILDREN_CAP}.
-*/
-const NODE_BUDGET = 5e3;
-/** Renders the warning detail a protocol reports for one {@link ClampReason}. */
-function clampReasonDetail(reason) {
-	if (reason === "budget") return `the tree was truncated after ${NODE_BUDGET} nodes.`;
-	if (reason === "cycle") return "a self-referencing node was dropped.";
-	if (reason === "depth") return `nodes deeper than 32 levels were dropped.`;
-	return `children were clamped to 200 entries.`;
-}
-function boundNode(value, depth, onClamp, state, ancestors) {
-	if (state.remaining <= 0) {
-		if (!state.exhausted) {
-			state.exhausted = true;
-			onClamp("budget");
-		}
-		return null;
-	}
-	state.remaining -= 1;
-	if (depth > 64) {
-		onClamp("depth");
-		return null;
-	}
-	if (Array.isArray(value)) {
-		if (ancestors.has(value)) {
-			onClamp("cycle");
-			return null;
-		}
-		ancestors.add(value);
-		const { items: bounded, truncated } = copyBounded(value, 200);
-		if (truncated) onClamp("children");
-		const result = bounded.map((item) => boundNode(item, depth + 1, onClamp, state, ancestors));
-		ancestors.delete(value);
-		return result;
-	}
-	if (value !== null && typeof value === "object") {
-		const record = value;
-		const children = record["children"];
-		if (children === void 0) return {
-			...record,
-			children: void 0
-		};
-		if (ancestors.has(value)) {
-			onClamp("cycle");
-			return null;
-		}
-		ancestors.add(value);
-		const result = {
-			...record,
-			children: boundNode(children, depth + 1, onClamp, state, ancestors)
-		};
-		ancestors.delete(value);
-		return result;
-	}
-	return value;
-}
-/**
-* Produces a bounded plain copy of a raw generative-ui spec before it
-* reaches `normalizeSpec`, whose own traversal of the root array or any
-* `children` array walks the full reported length of a hostile proxied
-* array before any per-field cap downstream ever applies. Every array
-* (root, or `children` at any depth) is capped to {@link CHILDREN_CAP}
-* entries by index, which bounds a proxy however it fabricates `length` or
-* replaces its array methods; recursion itself is capped at
-* {@link MAX_TRAVERSAL_DEPTH}. Every object is returned as a plain copy whose
-* `children` came from a single read, because a record that answers
-* `[[HasProperty]]` and `[[Get]]`, or two `[[Get]]`s, differently would
-* otherwise hand the bound one value and `normalizeSpec` another, skipping
-* every bound here for that subtree. `onClamp` fires once per level that was
-* truncated, receiving the reason for that truncation: `"children"`,
-* `"depth"`, `"budget"`, or `"cycle"`. The walk also spends a total budget of
-* {@link NODE_BUDGET} nodes, so shared references cannot multiply work
-* exponentially, and a node that is its own ancestor is cut to `null`.
-*/
-function boundSpec(spec, onClamp) {
-	return boundNode(spec, 0, onClamp, {
-		remaining: NODE_BUDGET,
-		exhausted: false
-	}, /* @__PURE__ */ new WeakSet());
-}
-//#endregion
-export { CHILDREN_CAP, MAX_ELEMENT_DEPTH, MAX_TRAVERSAL_DEPTH, NODE_BUDGET, boundSpec, clampReasonDetail };
-
-//# sourceMappingURL=boundSpec.js.map

package/dist/convert/boundSpec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boundSpec.js","names":[],"sources":["../../src/convert/boundSpec.ts"],"sourcesContent":["import { copyBounded } from \"./copyBounded\";\n\n/** The maximum traversal depth, counted in visited values, not tree levels. */\nexport const MAX_TRAVERSAL_DEPTH = 64;\n\n/**\n * The element-nesting ceiling a caller observes. `boundNode` visits an element\n * and its `children` array separately, so one level of nesting spends two of\n * {@link MAX_TRAVERSAL_DEPTH}; it runs before the conversion walk and is never\n * the looser of the two. A root array costs one more level than a root object.\n */\nexport const MAX_ELEMENT_DEPTH = MAX_TRAVERSAL_DEPTH / 2;\n\n/**\n * The maximum number of entries kept at any single level (root, or a\n * `children` array at any depth) of the raw spec, before it ever reaches\n * `normalizeSpec`. Bounds a hostile array's reported `length` so the pre-pass\n * can never be made to walk further than this regardless of what the array\n * claims about itself.\n */\nexport const CHILDREN_CAP = 200;\n\n/**\n * The total number of nodes {@link boundSpec} will visit across one walk,\n * regardless of how many times a shared reference recurs. Bounds the\n * combinatorial work a DAG of shared or self-referential nodes would\n * otherwise force even though each individual array stays within\n * {@link CHILDREN_CAP}.\n */\nexport const NODE_BUDGET = 5000;\n\nexport type ClampReason = \"children\" | \"budget\" | \"cycle\" | \"depth\";\n\n/** Renders the warning detail a protocol reports for one {@link ClampReason}. */\nexport function clampReasonDetail(reason: ClampReason): string {\n  if (reason === \"budget\") {\n    return `the tree was truncated after ${NODE_BUDGET} nodes.`;\n  }\n  if (reason === \"cycle\") return \"a self-referencing node was dropped.\";\n  if (reason === \"depth\") {\n    return `nodes deeper than ${MAX_ELEMENT_DEPTH} levels were dropped.`;\n  }\n  return `children were clamped to ${CHILDREN_CAP} entries.`;\n}\n\ninterface BoundState {\n  remaining: number;\n  exhausted: boolean;\n}\n\nfunction boundNode(\n  value: unknown,\n  depth: number,\n  onClamp: (reason: ClampReason) => void,\n  state: BoundState,\n  ancestors: WeakSet<object>,\n): unknown {\n  if (state.remaining <= 0) {\n    if (!state.exhausted) {\n      state.exhausted = true;\n      onClamp(\"budget\");\n    }\n    return null;\n  }\n  state.remaining -= 1;\n  if (depth > MAX_TRAVERSAL_DEPTH) {\n    onClamp(\"depth\");\n    return null;\n  }\n  if (Array.isArray(value)) {\n    if (ancestors.has(value)) {\n      onClamp(\"cycle\");\n      return null;\n    }\n    ancestors.add(value);\n    const { items: bounded, truncated } = copyBounded(value, CHILDREN_CAP);\n    if (truncated) onClamp(\"children\");\n    const result = bounded.map((item) =>\n      boundNode(item, depth + 1, onClamp, state, ancestors),\n    );\n    ancestors.delete(value);\n    return result;\n  }\n  if (value !== null && typeof value === \"object\") {\n    const record = value as Record<string, unknown>;\n    const children = record[\"children\"];\n    // The spread performs a `children` read of its own, so the copy states the\n    // bounded value even when there is none.\n    if (children === undefined) return { ...record, children: undefined };\n    if (ancestors.has(value)) {\n      onClamp(\"cycle\");\n      return null;\n    }\n    ancestors.add(value);\n    const result = {\n      ...record,\n      children: boundNode(children, depth + 1, onClamp, state, ancestors),\n    };\n    ancestors.delete(value);\n    return result;\n  }\n  return value;\n}\n\n/**\n * Produces a bounded plain copy of a raw generative-ui spec before it\n * reaches `normalizeSpec`, whose own traversal of the root array or any\n * `children` array walks the full reported length of a hostile proxied\n * array before any per-field cap downstream ever applies. Every array\n * (root, or `children` at any depth) is capped to {@link CHILDREN_CAP}\n * entries by index, which bounds a proxy however it fabricates `length` or\n * replaces its array methods; recursion itself is capped at\n * {@link MAX_TRAVERSAL_DEPTH}. Every object is returned as a plain copy whose\n * `children` came from a single read, because a record that answers\n * `[[HasProperty]]` and `[[Get]]`, or two `[[Get]]`s, differently would\n * otherwise hand the bound one value and `normalizeSpec` another, skipping\n * every bound here for that subtree. `onClamp` fires once per level that was\n * truncated, receiving the reason for that truncation: `\"children\"`,\n * `\"depth\"`, `\"budget\"`, or `\"cycle\"`. The walk also spends a total budget of\n * {@link NODE_BUDGET} nodes, so shared references cannot multiply work\n * exponentially, and a node that is its own ancestor is cut to `null`.\n */\nexport function boundSpec(\n  spec: unknown,\n  onClamp: (reason: ClampReason) => void,\n): unknown {\n  return boundNode(\n    spec,\n    0,\n    onClamp,\n    { remaining: NODE_BUDGET, exhausted: false },\n    new WeakSet(),\n  );\n}\n"],"mappings":";;;AAGA,MAAa,sBAAsB;;;;;;;AAQnC,MAAa,oBAAA;;;;;;;;AASb,MAAa,eAAe;;;;;;;;AAS5B,MAAa,cAAc;;AAK3B,SAAgB,kBAAkB,QAA6B;CAC7D,IAAI,WAAW,UACb,OAAO,gCAAgC,YAAY;CAErD,IAAI,WAAW,SAAS,OAAO;CAC/B,IAAI,WAAW,SACb,OAAO;CAET,OAAO;AACT;AAOA,SAAS,UACP,OACA,OACA,SACA,OACA,WACS;CACT,IAAI,MAAM,aAAa,GAAG;EACxB,IAAI,CAAC,MAAM,WAAW;GACpB,MAAM,YAAY;GAClB,QAAQ,QAAQ;EAClB;EACA,OAAO;CACT;CACA,MAAM,aAAa;CACnB,IAAI,QAAA,IAA6B;EAC/B,QAAQ,OAAO;EACf,OAAO;CACT;CACA,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,IAAI,UAAU,IAAI,KAAK,GAAG;GACxB,QAAQ,OAAO;GACf,OAAO;EACT;EACA,UAAU,IAAI,KAAK;EACnB,MAAM,EAAE,OAAO,SAAS,cAAc,YAAY,OAAA,GAAmB;EACrE,IAAI,WAAW,QAAQ,UAAU;EACjC,MAAM,SAAS,QAAQ,KAAK,SAC1B,UAAU,MAAM,QAAQ,GAAG,SAAS,OAAO,SAAS,CACtD;EACA,UAAU,OAAO,KAAK;EACtB,OAAO;CACT;CACA,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAC/C,MAAM,SAAS;EACf,MAAM,WAAW,OAAO;EAGxB,IAAI,aAAa,KAAA,GAAW,OAAO;GAAE,GAAG;GAAQ,UAAU,KAAA;EAAU;EACpE,IAAI,UAAU,IAAI,KAAK,GAAG;GACxB,QAAQ,OAAO;GACf,OAAO;EACT;EACA,UAAU,IAAI,KAAK;EACnB,MAAM,SAAS;GACb,GAAG;GACH,UAAU,UAAU,UAAU,QAAQ,GAAG,SAAS,OAAO,SAAS;EACpE;EACA,UAAU,OAAO,KAAK;EACtB,OAAO;CACT;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,UACd,MACA,SACS;CACT,OAAO,UACL,MACA,GACA,SACA;EAAE,WAAW;EAAa,WAAW;CAAM,mBAC3C,IAAI,QAAQ,CACd;AACF"}

package/dist/convert/copyBounded.d.ts

@@ -1,25 +0,0 @@
-/**
- * Copies at most `cap` entries out of `value` by index.
- *
- * Every array method dispatches on the input: a replaced `slice` is called
- * directly, and the intrinsic `Array.prototype.slice.call` still reaches a
- * `constructor` with a `@@species` whose `[[Construct]]` returns an arbitrary
- * object, which then supplies the `map` or `some` the caller runs next. Reading
- * indices consults neither, so it is the only form that bounds a hostile array.
- *
- * Absent indices stay absent, matching what `slice` produces for a sparse
- * input, so callers that skip holes still skip them. `truncated` comes from the
- * same `length` read as the bound, so an input cannot report one figure to the
- * cap and another to the caller's warning.
- *
- * A reported `length` is normalized the way `ToLength` does before it reaches
- * `count`, because a fractional one would otherwise reach `items.length` and
- * throw `RangeError` where `slice` returns a bounded result. `truncated` reads
- * that same normalized figure, so a `length` whose `valueOf` answers differently
- * on a second conversion cannot separate the warning from the bound.
- */
-export declare const copyBounded: <T>(value: readonly T[], cap: number) => {
-    readonly items: T[];
-    readonly truncated: boolean;
-};
-//# sourceMappingURL=copyBounded.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"copyBounded.d.ts","sourceRoot":"","sources":["../../src/convert/copyBounded.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,OAAO,SAAS,CAAC,EAAE,EACnB,KAAK,MAAM,KACV;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAcpD,CAAC"}

package/dist/convert/copyBounded.js

@@ -1,38 +0,0 @@
-//#region src/convert/copyBounded.ts
-/**
-* Copies at most `cap` entries out of `value` by index.
-*
-* Every array method dispatches on the input: a replaced `slice` is called
-* directly, and the intrinsic `Array.prototype.slice.call` still reaches a
-* `constructor` with a `@@species` whose `[[Construct]]` returns an arbitrary
-* object, which then supplies the `map` or `some` the caller runs next. Reading
-* indices consults neither, so it is the only form that bounds a hostile array.
-*
-* Absent indices stay absent, matching what `slice` produces for a sparse
-* input, so callers that skip holes still skip them. `truncated` comes from the
-* same `length` read as the bound, so an input cannot report one figure to the
-* cap and another to the caller's warning.
-*
-* A reported `length` is normalized the way `ToLength` does before it reaches
-* `count`, because a fractional one would otherwise reach `items.length` and
-* throw `RangeError` where `slice` returns a bounded result. `truncated` reads
-* that same normalized figure, so a `length` whose `valueOf` answers differently
-* on a second conversion cannot separate the warning from the bound.
-*/
-const copyBounded = (value, cap) => {
-	const reported = value.length;
-	const integral = Math.trunc(Number(reported));
-	const usable = Number.isNaN(integral) || integral <= 0 ? 0 : Math.min(integral, Number.MAX_SAFE_INTEGER);
-	const count = Math.min(cap, usable);
-	const items = [];
-	for (let index = 0; index < count; index += 1) if (index in value) items[index] = value[index];
-	items.length = count;
-	return {
-		items,
-		truncated: usable > cap
-	};
-};
-//#endregion
-export { copyBounded };
-
-//# sourceMappingURL=copyBounded.js.map

package/dist/convert/copyBounded.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"copyBounded.js","names":[],"sources":["../../src/convert/copyBounded.ts"],"sourcesContent":["/**\n * Copies at most `cap` entries out of `value` by index.\n *\n * Every array method dispatches on the input: a replaced `slice` is called\n * directly, and the intrinsic `Array.prototype.slice.call` still reaches a\n * `constructor` with a `@@species` whose `[[Construct]]` returns an arbitrary\n * object, which then supplies the `map` or `some` the caller runs next. Reading\n * indices consults neither, so it is the only form that bounds a hostile array.\n *\n * Absent indices stay absent, matching what `slice` produces for a sparse\n * input, so callers that skip holes still skip them. `truncated` comes from the\n * same `length` read as the bound, so an input cannot report one figure to the\n * cap and another to the caller's warning.\n *\n * A reported `length` is normalized the way `ToLength` does before it reaches\n * `count`, because a fractional one would otherwise reach `items.length` and\n * throw `RangeError` where `slice` returns a bounded result. `truncated` reads\n * that same normalized figure, so a `length` whose `valueOf` answers differently\n * on a second conversion cannot separate the warning from the bound.\n */\nexport const copyBounded = <T>(\n  value: readonly T[],\n  cap: number,\n): { readonly items: T[]; readonly truncated: boolean } => {\n  const reported = value.length;\n  const integral = Math.trunc(Number(reported));\n  const usable =\n    Number.isNaN(integral) || integral <= 0\n      ? 0\n      : Math.min(integral, Number.MAX_SAFE_INTEGER);\n  const count = Math.min(cap, usable);\n  const items: T[] = [];\n  for (let index = 0; index < count; index += 1) {\n    if (index in value) items[index] = value[index] as T;\n  }\n  items.length = count;\n  return { items, truncated: usable > cap };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,eACX,OACA,QACyD;CACzD,MAAM,WAAW,MAAM;CACvB,MAAM,WAAW,KAAK,MAAM,OAAO,QAAQ,CAAC;CAC5C,MAAM,SACJ,OAAO,MAAM,QAAQ,KAAK,YAAY,IAClC,IACA,KAAK,IAAI,UAAU,OAAO,gBAAgB;CAChD,MAAM,QAAQ,KAAK,IAAI,KAAK,MAAM;CAClC,MAAM,QAAa,CAAC;CACpB,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,SAAS,GAC1C,IAAI,SAAS,OAAO,MAAM,SAAS,MAAM;CAE3C,MAAM,SAAS;CACf,OAAO;EAAE;EAAO,WAAW,SAAS;CAAI;AAC1C"}

package/dist/convert/isElement.d.ts

@@ -1,3 +0,0 @@
-import type { NormalizedUIElement, NormalizedUINode } from "../ir.js";
-export declare const isElement: (node: NormalizedUINode) => node is NormalizedUIElement;
-//# sourceMappingURL=isElement.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"isElement.d.ts","sourceRoot":"","sources":["../../src/convert/isElement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,iBAAc;AAEnE,eAAO,MAAM,SAAS,GACpB,MAAM,gBAAgB,KACrB,IAAI,IAAI,mBACwD,CAAC"}

package/dist/convert/isElement.js

@@ -1,6 +0,0 @@
-//#region src/convert/isElement.ts
-const isElement = (node) => typeof node === "object" && node !== null && !Array.isArray(node);
-//#endregion
-export { isElement };
-
-//# sourceMappingURL=isElement.js.map

package/dist/convert/isElement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isElement.js","names":[],"sources":["../../src/convert/isElement.ts"],"sourcesContent":["import type { NormalizedUIElement, NormalizedUINode } from \"../ir\";\n\nexport const isElement = (\n  node: NormalizedUINode,\n): node is NormalizedUIElement =>\n  typeof node === \"object\" && node !== null && !Array.isArray(node);\n"],"mappings":";AAEA,MAAa,aACX,SAEA,OAAO,SAAS,YAAY,SAAS,QAAQ,CAAC,MAAM,QAAQ,IAAI"}

package/dist/convert/takeRun.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"takeRun.d.ts","sourceRoot":"","sources":["../../src/convert/takeRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,iBAAc;AAGnE,wBAAgB,OAAO,CACrB,KAAK,EAAE,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,EAAE,EAChD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,GACjD;IAAE,GAAG,EAAE,mBAAmB,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAW9C"}

package/dist/convert/takeRun.js

@@ -1,20 +0,0 @@
-import { isElement } from "./isElement.js";
-//#region src/convert/takeRun.ts
-function takeRun(nodes, index, matches) {
-	const run = [];
-	let next = index;
-	while (next < nodes.length) {
-		const candidate = nodes[next];
-		if (candidate === void 0 || !isElement(candidate) || !matches(candidate)) break;
-		run.push(candidate);
-		next += 1;
-	}
-	return {
-		run,
-		next
-	};
-}
-//#endregion
-export { takeRun };
-
-//# sourceMappingURL=takeRun.js.map

package/dist/convert/takeRun.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"takeRun.js","names":[],"sources":["../../src/convert/takeRun.ts"],"sourcesContent":["import type { NormalizedUIElement, NormalizedUINode } from \"../ir\";\nimport { isElement } from \"./isElement\";\n\nexport function takeRun(\n  nodes: readonly (NormalizedUINode | undefined)[],\n  index: number,\n  matches: (element: NormalizedUIElement) => boolean,\n): { run: NormalizedUIElement[]; next: number } {\n  const run: NormalizedUIElement[] = [];\n  let next = index;\n  while (next < nodes.length) {\n    const candidate = nodes[next];\n    if (candidate === undefined || !isElement(candidate) || !matches(candidate))\n      break;\n    run.push(candidate);\n    next += 1;\n  }\n  return { run, next };\n}\n"],"mappings":";;AAGA,SAAgB,QACd,OACA,OACA,SAC8C;CAC9C,MAAM,MAA6B,CAAC;CACpC,IAAI,OAAO;CACX,OAAO,OAAO,MAAM,QAAQ;EAC1B,MAAM,YAAY,MAAM;EACxB,IAAI,cAAc,KAAA,KAAa,CAAC,UAAU,SAAS,KAAK,CAAC,QAAQ,SAAS,GACxE;EACF,IAAI,KAAK,SAAS;EAClB,QAAQ;CACV;CACA,OAAO;EAAE;EAAK;CAAK;AACrB"}

package/dist/defineGenerativeComponents.d.ts

@@ -1,29 +0,0 @@
-import type { GenerativeUILibrary } from "./types.js";
-/**
- * Authoring helper for a `"use generative"` generative-UI library — the set of
- * components the model may render. Each component colocates its `properties`
- * schema (kept on every build, drives the tool parameters) with its `render`
- * (kept only on the client). Pass the result to {@link JSONGenerativeUI}:
- *
- * ```tsx
- * "use generative";
- * const generative = new JSONGenerativeUI({
- *   library: defineGenerativeComponents({
- *     Card: {
- *       description: "A card.",
- *       properties: z.object({ title: z.string() }),
- *       render: (props) => <Card {...props} />,
- *     },
- *   }),
- * });
- * ```
- *
- * Unlike {@link defineToolkit}, it has **no runtime implementation**. A
- * `"use generative"` compiler unwraps the `defineGenerativeComponents(...)` call
- * per build, dropping each `render` (and its client-only imports) from the server
- * build. Reaching it at runtime means the module wasn't compiled (the directive
- * is missing, or it was used outside a `"use generative"` file), so it throws
- * rather than shipping client `render` code to the server.
- */
-export declare function defineGenerativeComponents(_library: GenerativeUILibrary): GenerativeUILibrary;
-//# sourceMappingURL=defineGenerativeComponents.d.ts.map

package/dist/defineGenerativeComponents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineGenerativeComponents.d.ts","sourceRoot":"","sources":["../src/defineGenerativeComponents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAgB;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,mBAAmB,GAC5B,mBAAmB,CAOrB"}

package/dist/defineGenerativeComponents.js

@@ -1,34 +0,0 @@
-//#region src/defineGenerativeComponents.ts
-/**
-* Authoring helper for a `"use generative"` generative-UI library — the set of
-* components the model may render. Each component colocates its `properties`
-* schema (kept on every build, drives the tool parameters) with its `render`
-* (kept only on the client). Pass the result to {@link JSONGenerativeUI}:
-*
-* ```tsx
-* "use generative";
-* const generative = new JSONGenerativeUI({
-*   library: defineGenerativeComponents({
-*     Card: {
-*       description: "A card.",
-*       properties: z.object({ title: z.string() }),
-*       render: (props) => <Card {...props} />,
-*     },
-*   }),
-* });
-* ```
-*
-* Unlike {@link defineToolkit}, it has **no runtime implementation**. A
-* `"use generative"` compiler unwraps the `defineGenerativeComponents(...)` call
-* per build, dropping each `render` (and its client-only imports) from the server
-* build. Reaching it at runtime means the module wasn't compiled (the directive
-* is missing, or it was used outside a `"use generative"` file), so it throws
-* rather than shipping client `render` code to the server.
-*/
-function defineGenerativeComponents(_library) {
-	throw new Error("[assistant-ui] defineGenerativeComponents() has no runtime implementation — it is stripped at build time by the use-generative compiler. Reaching it means this module was not compiled (e.g. used outside a \"use generative\" file). Add the directive, or do not use it here.");
-}
-//#endregion
-export { defineGenerativeComponents };
-
-//# sourceMappingURL=defineGenerativeComponents.js.map

package/dist/defineGenerativeComponents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineGenerativeComponents.js","names":[],"sources":["../src/defineGenerativeComponents.ts"],"sourcesContent":["import type { GenerativeUILibrary } from \"./types\";\n\n/**\n * Authoring helper for a `\"use generative\"` generative-UI library — the set of\n * components the model may render. Each component colocates its `properties`\n * schema (kept on every build, drives the tool parameters) with its `render`\n * (kept only on the client). Pass the result to {@link JSONGenerativeUI}:\n *\n * ```tsx\n * \"use generative\";\n * const generative = new JSONGenerativeUI({\n *   library: defineGenerativeComponents({\n *     Card: {\n *       description: \"A card.\",\n *       properties: z.object({ title: z.string() }),\n *       render: (props) => <Card {...props} />,\n *     },\n *   }),\n * });\n * ```\n *\n * Unlike {@link defineToolkit}, it has **no runtime implementation**. A\n * `\"use generative\"` compiler unwraps the `defineGenerativeComponents(...)` call\n * per build, dropping each `render` (and its client-only imports) from the server\n * build. Reaching it at runtime means the module wasn't compiled (the directive\n * is missing, or it was used outside a `\"use generative\"` file), so it throws\n * rather than shipping client `render` code to the server.\n */\nexport function defineGenerativeComponents(\n  _library: GenerativeUILibrary,\n): GenerativeUILibrary {\n  throw new Error(\n    \"[assistant-ui] defineGenerativeComponents() has no runtime implementation \" +\n      \"— it is stripped at build time by the use-generative compiler. Reaching \" +\n      \"it means this module was not compiled (e.g. used outside a \" +\n      '\"use generative\" file). Add the directive, or do not use it here.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,2BACd,UACqB;CACrB,MAAM,IAAI,MACR,kRAIF;AACF"}

package/dist/fieldReferences.d.ts

@@ -1,9 +0,0 @@
-/**
- * Whether `value` contains a `{ "$field": name }` or `{ "$field": name, "fallback": value }` reference within 64 levels.
- */
-export declare const hasFieldReference: (value: unknown) => boolean;
-/**
- * Replaces each `{ "$field": name }` reference inside `value` with the own property `name` of `fields`, or with the reference's own `fallback` when that is `undefined`. A reference that still resolves to `undefined` is dropped from its object or array, and a cyclic reference or anything nested deeper than 64 levels is kept as is.
- */
-export declare const resolveFieldReferences: (value: unknown, fields: Readonly<Record<string, unknown>>) => unknown;
-//# sourceMappingURL=fieldReferences.d.ts.map