@ulearning/ai-generative-frame 0.0.0-stage → 1.0.0-next.0

package/dist/spec/resolved.d.ts

@@ -0,0 +1,3 @@
+import type { PropsSchema } from "./catalog.js";
+export declare function rejectedPropType(schema: PropsSchema | undefined, props: Record<string, unknown>): string | undefined;
+//# sourceMappingURL=resolved.d.ts.map

package/dist/spec/resolved.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolved.d.ts","mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAW;AAoC5C,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,GAAG,SAAS","names":[],"ignoreList":[],"sources":["../../src/spec/resolved.ts"],"sourcesContent":[null]}

package/dist/spec/resolved.js

@@ -0,0 +1,36 @@
+import { toJsonSchema } from "../json-schema.js";
+// src/spec/resolved.ts
+const primitiveTypes = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+]);
+const listedValues = "one of the listed values";
+function expectedPrimitive(schema) {
+	if (schema.type !== void 0) {
+		const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+		return types.length > 0 && types.every((type) => primitiveTypes.has(type)) ? [...new Set(types)].join(" or ") : void 0;
+	}
+	const alternatives = schema.anyOf ?? schema.oneOf;
+	if (alternatives !== void 0) {
+		if (alternatives.length === 0) return void 0;
+		const expected = alternatives.map(expectedPrimitive);
+		return expected.every((type) => type !== void 0) ? [...new Set(expected)].join(" or ") : void 0;
+	}
+	if (schema.enum?.length) return schema.enum.every((value) => value === null || typeof value !== "object") ? listedValues : void 0;
+}
+function rejectedPropType(schema, props) {
+	const properties = toJsonSchema(schema)?.properties;
+	if (!properties) return void 0;
+	for (const [name, property] of Object.entries(properties)) {
+		const value = props[name];
+		if (value === null || typeof value !== "object") continue;
+		const expected = expectedPrimitive(property);
+		if (expected) return `${name} expected ${expected}, got ${Array.isArray(value) ? "array" : "object"}`;
+	}
+}
+export { rejectedPropType };
+
+//# sourceMappingURL=resolved.js.map

package/dist/spec/resolved.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolved.js","names":[],"sources":["../../src/spec/resolved.ts"],"sourcesContent":["import { toJsonSchema, type JsonSchema } from \"../json-schema\";\nimport type { PropsSchema } from \"./catalog\";\n\nconst primitiveTypes = new Set([\n  \"string\",\n  \"number\",\n  \"integer\",\n  \"boolean\",\n  \"null\",\n]);\nconst listedValues = \"one of the listed values\";\n\nfunction expectedPrimitive(schema: JsonSchema): string | undefined {\n  if (schema.type !== undefined) {\n    const types = Array.isArray(schema.type) ? schema.type : [schema.type];\n    return types.length > 0 && types.every((type) => primitiveTypes.has(type))\n      ? [...new Set(types)].join(\" or \")\n      : undefined;\n  }\n  const alternatives = schema.anyOf ?? schema.oneOf;\n  if (alternatives !== undefined) {\n    if (alternatives.length === 0) return undefined;\n    const expected = alternatives.map(expectedPrimitive);\n    return expected.every((type): type is string => type !== undefined)\n      ? [...new Set(expected)].join(\" or \")\n      : undefined;\n  }\n  if (schema.enum?.length) {\n    return schema.enum.every(\n      (value) => value === null || typeof value !== \"object\",\n    )\n      ? listedValues\n      : undefined;\n  }\n  return undefined;\n}\n\nexport function rejectedPropType(\n  schema: PropsSchema | undefined,\n  props: Record<string, unknown>,\n): string | undefined {\n  const properties = toJsonSchema(schema)?.properties;\n  if (!properties) return undefined;\n  for (const [name, property] of Object.entries(properties)) {\n    const value = props[name];\n    if (value === null || typeof value !== \"object\") continue;\n    const expected = expectedPrimitive(property);\n    if (expected) {\n      return `${name} expected ${expected}, got ${Array.isArray(value) ? \"array\" : \"object\"}`;\n    }\n  }\n  return undefined;\n}\n"],"mappings":";;AAGA,MAAM,iCAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;AACF,CAAC;AACD,MAAM,eAAe;AAErB,SAAS,kBAAkB,QAAwC;CACjE,IAAI,OAAO,SAAS,KAAA,GAAW;EAC7B,MAAM,QAAQ,MAAM,QAAQ,OAAO,IAAI,IAAI,OAAO,OAAO,CAAC,OAAO,IAAI;EACrE,OAAO,MAAM,SAAS,KAAK,MAAM,OAAO,SAAS,eAAe,IAAI,IAAI,CAAC,IACrE,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,IAC/B,KAAA;CACN;CACA,MAAM,eAAe,OAAO,SAAS,OAAO;CAC5C,IAAI,iBAAiB,KAAA,GAAW;EAC9B,IAAI,aAAa,WAAW,GAAG,OAAO,KAAA;EACtC,MAAM,WAAW,aAAa,IAAI,iBAAiB;EACnD,OAAO,SAAS,OAAO,SAAyB,SAAS,KAAA,CAAS,IAC9D,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,IAClC,KAAA;CACN;CACA,IAAI,OAAO,MAAM,QACf,OAAO,OAAO,KAAK,OAChB,UAAU,UAAU,QAAQ,OAAO,UAAU,QAChD,IACI,eACA,KAAA;AAGR;AAEA,SAAgB,iBACd,QACA,OACoB;CACpB,MAAM,aAAa,aAAa,MAAM,CAAC,EAAE;CACzC,IAAI,CAAC,YAAY,OAAO,KAAA;CACxB,KAAK,MAAM,CAAC,MAAM,aAAa,OAAO,QAAQ,UAAU,GAAG;EACzD,MAAM,QAAQ,MAAM;EACpB,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EACjD,MAAM,WAAW,kBAAkB,QAAQ;EAC3C,IAAI,UACF,OAAO,GAAG,KAAK,YAAY,SAAS,QAAQ,MAAM,QAAQ,KAAK,IAAI,UAAU;CAEjF;AAEF"}

package/dist/spec/state.d.ts

@@ -0,0 +1,34 @@
+export type StateListener = (state: Record<string, unknown>) => void;
+/** A value written at a JSON Pointer with `set`: an optional mode marks a replacement, and optional array-parent paths keep the shape of arrays the write went through. */
+export type SpecStateWrite = readonly [
+    path: string,
+    value: unknown,
+    mode?: "add" | "replace",
+    arrayParents?: readonly string[]
+];
+/** A small state container for spec expressions and `setState` actions. */
+export type SpecStateStore = {
+    getState(): Record<string, unknown>;
+    /** The value at a JSON Pointer, or undefined. */
+    get(path: string): unknown;
+    /** Writes at a JSON Pointer, creating missing parent objects. Defaults to add (inserting at array indices); replace updates an existing array item. */
+    set(path: string, value: unknown, mode?: "add" | "replace"): void;
+    /**
+     * Replaces the base state, typically the spec's `state` as it streams in,
+     * and re-applies every `set` made so far on top of it, so model updates
+     * never discard what the user already changed.
+     */
+    seed(state: Record<string, unknown>): void;
+    subscribe(listener: StateListener): () => void;
+};
+export type StateStoreOptions = {
+    /** Writes to apply over the initial state and keep, such as changes saved from an earlier session. One that no longer applies is dropped. */
+    writes?: readonly SpecStateWrite[];
+};
+export declare function createStateStore(initial?: Record<string, unknown>, options?: StateStoreOptions): SpecStateStore & {
+    /**
+     * The writes `seed` re-applies, oldest first, as `[path, value]`, `[path, value, "replace"]`, or, for a write that went through an array, `[path, value, mode, arrayParents]`, whose array-parent paths recreate those arrays when the write is replayed without them: what to save to restore the user's changes later. A write that replaces a value drops earlier writes at its path and below it, except those made before an insert at an index of an array on its path, which may have moved them to another item; one that inserts into an array, at an index or at `-`, keeps them, so replaying the list in order gives the same state. The array is replaced, never mutated, when it changes.
+     */
+    writes(): readonly SpecStateWrite[];
+};
+//# sourceMappingURL=state.d.ts.map

package/dist/spec/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","mappings":"AAOA,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;AAEpE;AACA,MAAM,MAAM,cAAc,GAAG,SAAS;IACpC,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,CAAC,EAAE,KAAK,GAAG,SAAS;IACxB,YAAY,CAAC,EAAE,SAAS,MAAM;CAC/B;AAED;AACA,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACnC;IACA,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAC1B;IACA,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI;IACjE;;;;;IAKA,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAC1C,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,IAAI;CAC/C;AAKD,MAAM,MAAM,iBAAiB,GAAG;IAC9B;IACA,MAAM,CAAC,EAAE,SAAS,cAAc,EAAE;CACnC;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACrC,OAAO,GAAE,iBAAsB,GAC9B,cAAc,GAAG;IAClB;;;IAGA,MAAM,IAAI,SAAS,cAAc,EAAE;CACpC","names":[],"ignoreList":[],"sources":["../../src/spec/state.ts"],"sourcesContent":[null]}

package/dist/spec/state.js

@@ -0,0 +1,111 @@
+import { getAtPointer, joinPointer, parsePointer, writeAtPointer } from "./pointer.js";
+// src/spec/state.ts
+const normalize = (path) => path === "" || path.startsWith("/") ? path : `/${path}`;
+function createStateStore(initial = {}, options = {}) {
+	let base = initial;
+	let state = initial;
+	let writes = [];
+	const shifting = /* @__PURE__ */ new WeakSet();
+	const listeners = /* @__PURE__ */ new Set();
+	const arrayParentsAt = (target, path) => {
+		const tokens = parsePointer(path);
+		return tokens.flatMap((_, index) => {
+			const parent = joinPointer(tokens.slice(0, index));
+			return Array.isArray(getAtPointer(target, parent)) ? [parent] : [];
+		});
+	};
+	const parentOf = (path) => path.slice(0, path.lastIndexOf("/"));
+	const apply = (target, path, value, mode, savedArrayParents = []) => {
+		const arrayParents = [.../* @__PURE__ */ new Set([...savedArrayParents, ...arrayParentsAt(target, path)])];
+		const parent = path === "" ? void 0 : getAtPointer(target, parentOf(path));
+		const inserted = mode === "add" && path !== "" && (Array.isArray(parent) || parent === void 0 && arrayParents.includes(parentOf(path)));
+		return {
+			next: writeAtPointer(target, parsePointer(path), mode, value, { createMissing: true }, arrayParents),
+			inserted,
+			arrayParents
+		};
+	};
+	const entryFor = (path, value, mode, arrayParents) => {
+		if (arrayParents.length > 0) return [
+			path,
+			value,
+			mode,
+			arrayParents
+		];
+		return mode === "replace" ? [
+			path,
+			value,
+			mode
+		] : [path, value];
+	};
+	const record = (entry, inserted) => {
+		const path = entry[0];
+		if (inserted) {
+			if (!path.endsWith("/-")) shifting.add(entry);
+			writes = [...writes, entry];
+			return;
+		}
+		const moved = writes.findLastIndex((write) => shifting.has(write) && path.startsWith(`${parentOf(write[0])}/`));
+		writes = [...writes.filter(([written], index) => index <= moved || written !== path && !written.startsWith(`${path}/`)), entry];
+	};
+	const modeOf = (saved) => saved === "replace" ? "replace" : "add";
+	const emit = () => {
+		for (const listener of [...listeners]) listener(state);
+	};
+	for (const [rawPath, value, saved, savedArrayParents] of options.writes ?? []) {
+		const path = normalize(rawPath);
+		const mode = modeOf(saved);
+		try {
+			const result = apply(state, path, value, mode, savedArrayParents?.map(normalize));
+			state = result.next;
+			record(entryFor(path, value, mode, result.arrayParents), result.inserted);
+		} catch {}
+	}
+	return {
+		getState: () => state,
+		get: (path) => getAtPointer(state, normalize(path)),
+		set(rawPath, value, mode = "add") {
+			const path = normalize(rawPath);
+			const result = apply(state, path, value, mode);
+			record(entryFor(path, value, mode, result.arrayParents), result.inserted);
+			state = result.next;
+			emit();
+		},
+		writes: () => writes,
+		seed(next) {
+			if (next === base) return;
+			base = next;
+			let merged = next;
+			let changed = false;
+			const applied = [];
+			for (const write of writes) {
+				const [path, value, saved, savedArrayParents] = write;
+				const mode = modeOf(saved);
+				try {
+					const result = apply(merged, path, value, mode, savedArrayParents);
+					merged = result.next;
+					if (result.arrayParents.length === (savedArrayParents?.length ?? 0)) {
+						applied.push(write);
+						continue;
+					}
+					const entry = entryFor(path, value, mode, result.arrayParents);
+					if (shifting.has(write)) shifting.add(entry);
+					applied.push(entry);
+					changed = true;
+				} catch {
+					changed = true;
+				}
+			}
+			if (changed) writes = applied;
+			state = merged;
+			emit();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+export { createStateStore };
+
+//# sourceMappingURL=state.js.map

package/dist/spec/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":[],"sources":["../../src/spec/state.ts"],"sourcesContent":["import {\n  getAtPointer,\n  joinPointer,\n  parsePointer,\n  writeAtPointer,\n} from \"./pointer\";\n\nexport type StateListener = (state: Record<string, unknown>) => void;\n\n/** A value written at a JSON Pointer with `set`: an optional mode marks a replacement, and optional array-parent paths keep the shape of arrays the write went through. */\nexport type SpecStateWrite = readonly [\n  path: string,\n  value: unknown,\n  mode?: \"add\" | \"replace\",\n  arrayParents?: readonly string[],\n];\n\n/** A small state container for spec expressions and `setState` actions. */\nexport type SpecStateStore = {\n  getState(): Record<string, unknown>;\n  /** The value at a JSON Pointer, or undefined. */\n  get(path: string): unknown;\n  /** Writes at a JSON Pointer, creating missing parent objects. Defaults to add (inserting at array indices); replace updates an existing array item. */\n  set(path: string, value: unknown, mode?: \"add\" | \"replace\"): void;\n  /**\n   * Replaces the base state, typically the spec's `state` as it streams in,\n   * and re-applies every `set` made so far on top of it, so model updates\n   * never discard what the user already changed.\n   */\n  seed(state: Record<string, unknown>): void;\n  subscribe(listener: StateListener): () => void;\n};\n\nconst normalize = (path: string) =>\n  path === \"\" || path.startsWith(\"/\") ? path : `/${path}`;\n\nexport type StateStoreOptions = {\n  /** Writes to apply over the initial state and keep, such as changes saved from an earlier session. One that no longer applies is dropped. */\n  writes?: readonly SpecStateWrite[];\n};\n\nexport function createStateStore(\n  initial: Record<string, unknown> = {},\n  options: StateStoreOptions = {},\n): SpecStateStore & {\n  /**\n   * The writes `seed` re-applies, oldest first, as `[path, value]`, `[path, value, \"replace\"]`, or, for a write that went through an array, `[path, value, mode, arrayParents]`, whose array-parent paths recreate those arrays when the write is replayed without them: what to save to restore the user's changes later. A write that replaces a value drops earlier writes at its path and below it, except those made before an insert at an index of an array on its path, which may have moved them to another item; one that inserts into an array, at an index or at `-`, keeps them, so replaying the list in order gives the same state. The array is replaced, never mutated, when it changes.\n   */\n  writes(): readonly SpecStateWrite[];\n} {\n  let base = initial;\n  let state = initial;\n  let writes: readonly SpecStateWrite[] = [];\n  const shifting = new WeakSet<SpecStateWrite>();\n  const listeners = new Set<StateListener>();\n\n  const arrayParentsAt = (target: Record<string, unknown>, path: string) => {\n    const tokens = parsePointer(path);\n    return tokens.flatMap((_, index) => {\n      const parent = joinPointer(tokens.slice(0, index));\n      return Array.isArray(getAtPointer(target, parent)) ? [parent] : [];\n    });\n  };\n\n  const parentOf = (path: string) => path.slice(0, path.lastIndexOf(\"/\"));\n\n  const apply = (\n    target: Record<string, unknown>,\n    path: string,\n    value: unknown,\n    mode: \"add\" | \"replace\",\n    savedArrayParents: readonly string[] = [],\n  ) => {\n    const arrayParents = [\n      ...new Set([...savedArrayParents, ...arrayParentsAt(target, path)]),\n    ];\n    const parent =\n      path === \"\" ? undefined : getAtPointer(target, parentOf(path));\n    const inserted =\n      mode === \"add\" &&\n      path !== \"\" &&\n      (Array.isArray(parent) ||\n        (parent === undefined && arrayParents.includes(parentOf(path))));\n    const next = writeAtPointer(\n      target,\n      parsePointer(path),\n      mode,\n      value,\n      { createMissing: true },\n      arrayParents,\n    ) as Record<string, unknown>;\n    return { next, inserted, arrayParents };\n  };\n\n  const entryFor = (\n    path: string,\n    value: unknown,\n    mode: \"add\" | \"replace\",\n    arrayParents: readonly string[],\n  ): SpecStateWrite => {\n    if (arrayParents.length > 0) return [path, value, mode, arrayParents];\n    return mode === \"replace\" ? [path, value, mode] : [path, value];\n  };\n\n  const record = (entry: SpecStateWrite, inserted: boolean) => {\n    const path = entry[0];\n    if (inserted) {\n      if (!path.endsWith(\"/-\")) shifting.add(entry);\n      writes = [...writes, entry];\n      return;\n    }\n    const moved = writes.findLastIndex(\n      (write) =>\n        shifting.has(write) && path.startsWith(`${parentOf(write[0])}/`),\n    );\n    writes = [\n      ...writes.filter(\n        ([written], index) =>\n          index <= moved ||\n          (written !== path && !written.startsWith(`${path}/`)),\n      ),\n      entry,\n    ];\n  };\n\n  const modeOf = (saved: unknown) => (saved === \"replace\" ? \"replace\" : \"add\");\n\n  const emit = () => {\n    for (const listener of [...listeners]) listener(state);\n  };\n\n  for (const [rawPath, value, saved, savedArrayParents] of options.writes ??\n    []) {\n    const path = normalize(rawPath);\n    const mode = modeOf(saved);\n    try {\n      const result = apply(\n        state,\n        path,\n        value,\n        mode,\n        savedArrayParents?.map(normalize),\n      );\n      state = result.next;\n      record(entryFor(path, value, mode, result.arrayParents), result.inserted);\n    } catch {}\n  }\n\n  return {\n    getState: () => state,\n    get: (path) => getAtPointer(state, normalize(path)),\n    set(rawPath, value, mode = \"add\") {\n      const path = normalize(rawPath);\n      const result = apply(state, path, value, mode);\n      record(entryFor(path, value, mode, result.arrayParents), result.inserted);\n      state = result.next;\n      emit();\n    },\n    writes: () => writes,\n    seed(next) {\n      if (next === base) return;\n      base = next;\n      let merged = next;\n      let changed = false;\n      const applied: SpecStateWrite[] = [];\n      for (const write of writes) {\n        const [path, value, saved, savedArrayParents] = write;\n        const mode = modeOf(saved);\n        try {\n          const result = apply(merged, path, value, mode, savedArrayParents);\n          merged = result.next;\n          if (result.arrayParents.length === (savedArrayParents?.length ?? 0)) {\n            applied.push(write);\n            continue;\n          }\n          const entry = entryFor(path, value, mode, result.arrayParents);\n          if (shifting.has(write)) shifting.add(entry);\n          applied.push(entry);\n          changed = true;\n        } catch {\n          changed = true;\n        }\n      }\n      if (changed) writes = applied;\n      state = merged;\n      emit();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/spec/stream.d.ts

@@ -0,0 +1,50 @@
+import { type PatchOperation, type Spec } from "./types.js";
+/**
+ * `jsonl`: every non-empty line is a patch operation (what `render_spec`
+ * receives). `inline`: prose and patches interleave, as in a chat reply;
+ * patch lines sit in a ```spec fence or start with `{"op"`, everything else
+ * is text.
+ */
+export type SpecStreamMode = "jsonl" | "inline";
+export type SpecStreamError = {
+    line: number;
+    message: string;
+    text: string;
+};
+export type SpecStreamUpdate = {
+    /** The spec after every patch so far. A new object only when it changed. */
+    spec: Spec;
+    /** Operations applied by this push. */
+    patches: PatchOperation[];
+    /** Prose added by this push (inline mode). */
+    text: string;
+    /** Errors from lines completed by this push. */
+    errors: SpecStreamError[];
+};
+export type SpecStreamResult = {
+    spec: Spec;
+    patches: PatchOperation[];
+    text: string;
+    errors: SpecStreamError[];
+};
+export type SpecStream = {
+    /** Feeds raw model output; partial lines wait for their newline. */
+    push(chunk: string): SpecStreamUpdate;
+    /** Processes a trailing line without a newline and returns everything so far. */
+    result(): SpecStreamResult;
+    readonly spec: Spec;
+};
+export type CreateSpecStreamOptions = {
+    mode?: SpecStreamMode;
+    /** Spec to apply patches onto. Defaults to an empty spec. */
+    initial?: Spec;
+};
+/**
+ * Turns a stream of JSONL patch lines (optionally interleaved with prose)
+ * into a progressively built spec. Bad lines are reported and skipped, so
+ * one malformed patch does not stop the rest of the UI from rendering.
+ */
+export declare function createSpecStream(options?: CreateSpecStreamOptions): SpecStream;
+/** Parses complete JSONL or inline output in one go. */
+export declare function parseSpecStream(source: string, options?: CreateSpecStreamOptions): SpecStreamResult;
+//# sourceMappingURL=stream.d.ts.map

package/dist/spec/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","mappings":"AACA,OAAO,EAAa,KAAK,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,YAAS;AAEnE;;;;;;AAMA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,QAAQ;AAE/C,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM;IAAE,OAAO,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;CAAE;AAE7E,MAAM,MAAM,gBAAgB,GAAG;IAC7B;IACA,IAAI,EAAE,IAAI;IACV;IACA,OAAO,EAAE,cAAc,EAAE;IACzB;IACA,IAAI,EAAE,MAAM;IACZ;IACA,MAAM,EAAE,eAAe,EAAE;CAC1B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,IAAI;IACV,OAAO,EAAE,cAAc,EAAE;IACzB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,eAAe,EAAE;CAC1B;AAED,MAAM,MAAM,UAAU,GAAG;IACvB;IACA,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACrC;IACA,MAAM,IAAI,gBAAgB;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI;CACpB;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,CAAC,EAAE,cAAc;IACrB;IACA,OAAO,CAAC,EAAE,IAAI;CACf;AAiBD;;;;;AAKA,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,uBAA4B,GACpC,UAAU;AA0Jb;AACA,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,uBAA4B,GACpC,gBAAgB","names":[],"ignoreList":[],"sources":["../../src/spec/stream.ts"],"sourcesContent":[null]}

package/dist/spec/stream.js

@@ -0,0 +1,168 @@
+import { emptySpec } from "./types.js";
+import { applyPatchOperation, checkPatchOperation } from "./patch.js";
+// src/spec/stream.ts
+const FENCE = /^\s*(`{3,}|~{3,})\s*([\w-]*)\s*$/;
+const SPEC_FENCES = /* @__PURE__ */ new Set([
+	"spec",
+	"jsonl",
+	"json-patch",
+	"spec-jsonl"
+]);
+const LOOKS_LIKE_PATCH = /^\s*\{\s*"op"\s*:/;
+/** A partial line that can no longer turn into a patch or a fence. */
+const PROSE_START = /^\s*[^\s{`~]/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isSpecShape = (value) => isRecord(value) && typeof value["root"] === "string" && isRecord(value["elements"]) && (value["state"] === void 0 || isRecord(value["state"]));
+/**
+* Turns a stream of JSONL patch lines (optionally interleaved with prose)
+* into a progressively built spec. Bad lines are reported and skipped, so
+* one malformed patch does not stop the rest of the UI from rendering.
+*/
+function createSpecStream(options = {}) {
+	const mode = options.mode ?? "jsonl";
+	let spec = options.initial ?? emptySpec();
+	let buffer = "";
+	let lineNumber = 0;
+	let fence;
+	let fenceIsSpec = false;
+	let finished = false;
+	/** Characters of the current, unfinished line already emitted as prose. */
+	let proseEmitted = 0;
+	const allPatches = [];
+	const allErrors = [];
+	let allText = "";
+	const applyLine = (raw, update, terminated) => {
+		lineNumber++;
+		const line = raw.replace(/\r$/, "");
+		const emitted = proseEmitted;
+		proseEmitted = 0;
+		const prose = () => {
+			const text = (terminated ? `${line}\n` : line).slice(emitted);
+			update.text += text;
+			allText += text;
+		};
+		if (mode === "inline") {
+			const fenceMatch = FENCE.exec(line);
+			if (fenceMatch) {
+				if (fence === void 0) {
+					fence = fenceMatch[1];
+					fenceIsSpec = SPEC_FENCES.has(fenceMatch[2].toLowerCase());
+					if (!fenceIsSpec) prose();
+					return;
+				}
+				if (fenceMatch[1].startsWith(fence) && !fenceMatch[2]) {
+					if (!fenceIsSpec) prose();
+					fence = void 0;
+					fenceIsSpec = false;
+					return;
+				}
+			}
+			if (!(fence !== void 0 && fenceIsSpec || fence === void 0 && LOOKS_LIKE_PATCH.test(line))) {
+				prose();
+				return;
+			}
+		}
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		const fail = (message) => {
+			const error = {
+				line: lineNumber,
+				message,
+				text: trimmed.slice(0, 200)
+			};
+			update.errors.push(error);
+			allErrors.push(error);
+		};
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			fail("not valid JSON");
+			return;
+		}
+		if (isSpecShape(parsed)) {
+			spec = {
+				state: {},
+				...parsed
+			};
+			return;
+		}
+		const operations = Array.isArray(parsed) ? parsed : [parsed];
+		for (const candidate of operations) {
+			const checked = checkPatchOperation(candidate);
+			if (!checked.ok) {
+				fail(checked.error);
+				continue;
+			}
+			try {
+				const next = applyPatchOperation(spec, checked.op, { createMissing: true });
+				if (!isSpecShape(next)) throw new Error("A spec needs a string root, an elements object, and optional state object");
+				spec = next;
+				update.patches.push(checked.op);
+				allPatches.push(checked.op);
+			} catch (error) {
+				fail(error instanceof Error ? error.message : String(error));
+			}
+		}
+	};
+	const push = (chunk) => {
+		if (finished) throw new Error("The spec stream already finished");
+		const update = {
+			patches: [],
+			text: "",
+			errors: []
+		};
+		buffer += chunk;
+		let newline = buffer.indexOf("\n");
+		while (newline !== -1) {
+			const line = buffer.slice(0, newline);
+			buffer = buffer.slice(newline + 1);
+			applyLine(line, update, true);
+			newline = buffer.indexOf("\n");
+		}
+		if (mode === "inline" && fence === void 0 && buffer.length > proseEmitted && PROSE_START.test(buffer)) {
+			const end = buffer.endsWith("\r") ? buffer.length - 1 : buffer.length;
+			const text = buffer.slice(proseEmitted, end);
+			proseEmitted = end;
+			update.text += text;
+			allText += text;
+		}
+		return {
+			spec,
+			...update
+		};
+	};
+	return {
+		push,
+		result() {
+			if (!finished && buffer) {
+				const rest = buffer;
+				buffer = "";
+				applyLine(rest, {
+					patches: [],
+					text: "",
+					errors: []
+				}, false);
+			}
+			finished = true;
+			return {
+				spec,
+				patches: [...allPatches],
+				text: allText,
+				errors: [...allErrors]
+			};
+		},
+		get spec() {
+			return spec;
+		}
+	};
+}
+/** Parses complete JSONL or inline output in one go. */
+function parseSpecStream(source, options = {}) {
+	const stream = createSpecStream(options);
+	stream.push(source);
+	return stream.result();
+}
+export { createSpecStream, parseSpecStream };
+
+//# sourceMappingURL=stream.js.map

package/dist/spec/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":[],"sources":["../../src/spec/stream.ts"],"sourcesContent":["import { applyPatchOperation, checkPatchOperation } from \"./patch\";\nimport { emptySpec, type PatchOperation, type Spec } from \"./types\";\n\n/**\n * `jsonl`: every non-empty line is a patch operation (what `render_spec`\n * receives). `inline`: prose and patches interleave, as in a chat reply;\n * patch lines sit in a ```spec fence or start with `{\"op\"`, everything else\n * is text.\n */\nexport type SpecStreamMode = \"jsonl\" | \"inline\";\n\nexport type SpecStreamError = { line: number; message: string; text: string };\n\nexport type SpecStreamUpdate = {\n  /** The spec after every patch so far. A new object only when it changed. */\n  spec: Spec;\n  /** Operations applied by this push. */\n  patches: PatchOperation[];\n  /** Prose added by this push (inline mode). */\n  text: string;\n  /** Errors from lines completed by this push. */\n  errors: SpecStreamError[];\n};\n\nexport type SpecStreamResult = {\n  spec: Spec;\n  patches: PatchOperation[];\n  text: string;\n  errors: SpecStreamError[];\n};\n\nexport type SpecStream = {\n  /** Feeds raw model output; partial lines wait for their newline. */\n  push(chunk: string): SpecStreamUpdate;\n  /** Processes a trailing line without a newline and returns everything so far. */\n  result(): SpecStreamResult;\n  readonly spec: Spec;\n};\n\nexport type CreateSpecStreamOptions = {\n  mode?: SpecStreamMode;\n  /** Spec to apply patches onto. Defaults to an empty spec. */\n  initial?: Spec;\n};\n\nconst FENCE = /^\\s*(`{3,}|~{3,})\\s*([\\w-]*)\\s*$/;\nconst SPEC_FENCES = new Set([\"spec\", \"jsonl\", \"json-patch\", \"spec-jsonl\"]);\nconst LOOKS_LIKE_PATCH = /^\\s*\\{\\s*\"op\"\\s*:/;\n/** A partial line that can no longer turn into a patch or a fence. */\nconst PROSE_START = /^\\s*[^\\s{`~]/;\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst isSpecShape = (value: unknown): value is Spec =>\n  isRecord(value) &&\n  typeof value[\"root\"] === \"string\" &&\n  isRecord(value[\"elements\"]) &&\n  (value[\"state\"] === undefined || isRecord(value[\"state\"]));\n\n/**\n * Turns a stream of JSONL patch lines (optionally interleaved with prose)\n * into a progressively built spec. Bad lines are reported and skipped, so\n * one malformed patch does not stop the rest of the UI from rendering.\n */\nexport function createSpecStream(\n  options: CreateSpecStreamOptions = {},\n): SpecStream {\n  const mode = options.mode ?? \"jsonl\";\n  let spec: Spec = options.initial ?? emptySpec();\n  let buffer = \"\";\n  let lineNumber = 0;\n  let fence: string | undefined;\n  let fenceIsSpec = false;\n  let finished = false;\n  /** Characters of the current, unfinished line already emitted as prose. */\n  let proseEmitted = 0;\n  const allPatches: PatchOperation[] = [];\n  const allErrors: SpecStreamError[] = [];\n  let allText = \"\";\n\n  const applyLine = (\n    raw: string,\n    update: {\n      patches: PatchOperation[];\n      text: string;\n      errors: SpecStreamError[];\n    },\n    terminated: boolean,\n  ) => {\n    lineNumber++;\n    const line = raw.replace(/\\r$/, \"\");\n    const emitted = proseEmitted;\n    proseEmitted = 0;\n    const prose = () => {\n      const text = (terminated ? `${line}\\n` : line).slice(emitted);\n      update.text += text;\n      allText += text;\n    };\n\n    if (mode === \"inline\") {\n      const fenceMatch = FENCE.exec(line);\n      if (fenceMatch) {\n        if (fence === undefined) {\n          fence = fenceMatch[1]!;\n          fenceIsSpec = SPEC_FENCES.has(fenceMatch[2]!.toLowerCase());\n          if (!fenceIsSpec) prose();\n          return;\n        }\n        if (fenceMatch[1]!.startsWith(fence) && !fenceMatch[2]) {\n          if (!fenceIsSpec) prose();\n          fence = undefined;\n          fenceIsSpec = false;\n          return;\n        }\n      }\n      const isPatchLine =\n        (fence !== undefined && fenceIsSpec) ||\n        (fence === undefined && LOOKS_LIKE_PATCH.test(line));\n      if (!isPatchLine) {\n        prose();\n        return;\n      }\n    }\n\n    const trimmed = line.trim();\n    if (!trimmed) return;\n    const fail = (message: string) => {\n      const error = { line: lineNumber, message, text: trimmed.slice(0, 200) };\n      update.errors.push(error);\n      allErrors.push(error);\n    };\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(trimmed);\n    } catch {\n      fail(\"not valid JSON\");\n      return;\n    }\n\n    if (isSpecShape(parsed)) {\n      spec = { state: {}, ...parsed };\n      return;\n    }\n    const operations = Array.isArray(parsed) ? parsed : [parsed];\n    for (const candidate of operations) {\n      const checked = checkPatchOperation(candidate);\n      if (!checked.ok) {\n        fail(checked.error);\n        continue;\n      }\n      try {\n        const next = applyPatchOperation(spec, checked.op, {\n          createMissing: true,\n        });\n        if (!isSpecShape(next)) {\n          throw new Error(\n            \"A spec needs a string root, an elements object, and optional state object\",\n          );\n        }\n        spec = next;\n        update.patches.push(checked.op);\n        allPatches.push(checked.op);\n      } catch (error) {\n        fail(error instanceof Error ? error.message : String(error));\n      }\n    }\n  };\n\n  const push = (chunk: string): SpecStreamUpdate => {\n    if (finished) throw new Error(\"The spec stream already finished\");\n    const update = { patches: [], text: \"\", errors: [] } as Omit<\n      SpecStreamUpdate,\n      \"spec\"\n    >;\n    buffer += chunk;\n    let newline = buffer.indexOf(\"\\n\");\n    while (newline !== -1) {\n      const line = buffer.slice(0, newline);\n      buffer = buffer.slice(newline + 1);\n      applyLine(line, update, true);\n      newline = buffer.indexOf(\"\\n\");\n    }\n    if (\n      mode === \"inline\" &&\n      fence === undefined &&\n      buffer.length > proseEmitted &&\n      PROSE_START.test(buffer)\n    ) {\n      const end = buffer.endsWith(\"\\r\") ? buffer.length - 1 : buffer.length;\n      const text = buffer.slice(proseEmitted, end);\n      proseEmitted = end;\n      update.text += text;\n      allText += text;\n    }\n    return { spec, ...update };\n  };\n\n  return {\n    push,\n    result() {\n      if (!finished && buffer) {\n        const rest = buffer;\n        buffer = \"\";\n        applyLine(rest, { patches: [], text: \"\", errors: [] }, false);\n      }\n      finished = true;\n      return {\n        spec,\n        patches: [...allPatches],\n        text: allText,\n        errors: [...allErrors],\n      };\n    },\n    get spec() {\n      return spec;\n    },\n  };\n}\n\n/** Parses complete JSONL or inline output in one go. */\nexport function parseSpecStream(\n  source: string,\n  options: CreateSpecStreamOptions = {},\n): SpecStreamResult {\n  const stream = createSpecStream(options);\n  stream.push(source);\n  return stream.result();\n}\n"],"mappings":"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"}

package/dist/spec/tools.d.ts

@@ -0,0 +1,3 @@
+export { createSpecTools, SPEC_TOOL_RESULTS_RULE, specGuidanceModule, type CreateSpecToolsOptions, type RenderSpecInput, type RenderSpecResult, type RenderSpecTool, type SpecTools, } from "./render-spec.js";
+export { getToolDeclarations, toAISDKTools, type GuidanceModule, type JsonSchema, type ToolDefinition, } from "../tools/define.js";
+//# sourceMappingURL=tools.d.ts.map

package/dist/spec/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","mappings":"AAAA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,SAAS,GACf,MAAM,kBAAe;AACtB,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,cAAc,GACpB,MAAM,oBAAiB","names":[],"ignoreList":[],"sources":["../../src/spec/tools.ts"],"sourcesContent":[null]}

package/dist/spec/tools.js

@@ -0,0 +1,3 @@
+import { SPEC_TOOL_RESULTS_RULE, createSpecTools, specGuidanceModule } from "./render-spec.js";
+import { getToolDeclarations, toAISDKTools } from "../tools/define.js";
+export { SPEC_TOOL_RESULTS_RULE, createSpecTools, getToolDeclarations, specGuidanceModule, toAISDKTools };

package/dist/spec/tree.d.ts

@@ -0,0 +1,21 @@
+import { type ExpressionContext } from "./expressions.js";
+import type { SpecElement } from "./types.js";
+/** What the children of a `repeat` read about their item. */
+export type RepeatScope = Pick<ExpressionContext, "item" | "index" | "itemPath">;
+/** The element ids in a slot, where `default` is `children`. */
+export declare const childIdsOf: (element: SpecElement, slot: string) => string[];
+/** A JSON Pointer for a state path written with or without its leading slash. */
+export declare const safePointer: (path: string) => string;
+/**
+ * The items a `repeat` renders its children for, each with its key (the
+ * item's `key` field, else its index) and the scope its children read, or
+ * `undefined` when the state at `path` is not an array.
+ */
+export declare function repeatItems(repeat: {
+    path: string;
+    key?: string;
+}, state: unknown): {
+    key: string;
+    scope: RepeatScope;
+}[] | undefined;
+//# sourceMappingURL=tree.d.ts.map

package/dist/spec/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","mappings":"AAAA,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,kBAAe;AAEnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAS;AAE1C;AACA,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,iBAAiB,EACjB,MAAM,GAAG,OAAO,GAAG,UAAU,CAC9B;AAED;AACA,eAAO,MAAM,UAAU,GAAI,SAAS,WAAW,EAAE,MAAM,MAAM,aACU;AAEvE;AACA,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,WACiB;AAEzD;;;;;AAKA,wBAAgB,WAAW,CACzB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM;IAAE,GAAG,CAAC,EAAE,MAAM;CAAE,EACtC,KAAK,EAAE,OAAO,GACb;IAAE,GAAG,EAAE,MAAM;IAAE,KAAK,EAAE,WAAW;CAAE,EAAE,GAAG,SAAS","names":[],"ignoreList":[],"sources":["../../src/spec/tree.ts"],"sourcesContent":[null]}

package/dist/spec/tree.js

@@ -0,0 +1,27 @@
+import { getAtPointer } from "./pointer.js";
+import { itemPointer } from "./expressions.js";
+// src/spec/tree.ts
+/** The element ids in a slot, where `default` is `children`. */
+const childIdsOf = (element, slot) => (slot === "default" ? element.children : element.slots?.[slot]) ?? [];
+/** A JSON Pointer for a state path written with or without its leading slash. */
+const safePointer = (path) => path.startsWith("/") || path === "" ? path : `/${path}`;
+/**
+* The items a `repeat` renders its children for, each with its key (the
+* item's `key` field, else its index) and the scope its children read, or
+* `undefined` when the state at `path` is not an array.
+*/
+function repeatItems(repeat, state) {
+	const items = getAtPointer(state, safePointer(repeat.path));
+	if (!Array.isArray(items)) return void 0;
+	return items.map((item, index) => ({
+		key: repeat.key && item && typeof item === "object" ? String(item[repeat.key] ?? index) : String(index),
+		scope: {
+			item,
+			index,
+			itemPath: itemPointer(repeat.path, index)
+		}
+	}));
+}
+export { childIdsOf, repeatItems, safePointer };
+
+//# sourceMappingURL=tree.js.map

package/dist/spec/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","names":[],"sources":["../../src/spec/tree.ts"],"sourcesContent":["import { itemPointer, type ExpressionContext } from \"./expressions\";\nimport { getAtPointer } from \"./pointer\";\nimport type { SpecElement } from \"./types\";\n\n/** What the children of a `repeat` read about their item. */\nexport type RepeatScope = Pick<\n  ExpressionContext,\n  \"item\" | \"index\" | \"itemPath\"\n>;\n\n/** The element ids in a slot, where `default` is `children`. */\nexport const childIdsOf = (element: SpecElement, slot: string) =>\n  (slot === \"default\" ? element.children : element.slots?.[slot]) ?? [];\n\n/** A JSON Pointer for a state path written with or without its leading slash. */\nexport const safePointer = (path: string) =>\n  path.startsWith(\"/\") || path === \"\" ? path : `/${path}`;\n\n/**\n * The items a `repeat` renders its children for, each with its key (the\n * item's `key` field, else its index) and the scope its children read, or\n * `undefined` when the state at `path` is not an array.\n */\nexport function repeatItems(\n  repeat: { path: string; key?: string },\n  state: unknown,\n): { key: string; scope: RepeatScope }[] | undefined {\n  const items = getAtPointer(state, safePointer(repeat.path));\n  if (!Array.isArray(items)) return undefined;\n  return items.map((item: unknown, index) => ({\n    key:\n      repeat.key && item && typeof item === \"object\"\n        ? String((item as Record<string, unknown>)[repeat.key] ?? index)\n        : String(index),\n    scope: { item, index, itemPath: itemPointer(repeat.path, index) },\n  }));\n}\n"],"mappings":";;;;AAWA,MAAa,cAAc,SAAsB,UAC9C,SAAS,YAAY,QAAQ,WAAW,QAAQ,QAAQ,UAAU,CAAC;;AAGtE,MAAa,eAAe,SAC1B,KAAK,WAAW,GAAG,KAAK,SAAS,KAAK,OAAO,IAAI;;;;;;AAOnD,SAAgB,YACd,QACA,OACmD;CACnD,MAAM,QAAQ,aAAa,OAAO,YAAY,OAAO,IAAI,CAAC;CAC1D,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO,KAAA;CAClC,OAAO,MAAM,KAAK,MAAe,WAAW;EAC1C,KACE,OAAO,OAAO,QAAQ,OAAO,SAAS,WAClC,OAAQ,KAAiC,OAAO,QAAQ,KAAK,IAC7D,OAAO,KAAK;EAClB,OAAO;GAAE;GAAM;GAAO,UAAU,YAAY,OAAO,MAAM,KAAK;EAAE;CAClE,EAAE;AACJ"}

package/dist/spec/types.d.ts

@@ -0,0 +1,66 @@
+/** Runs a catalog action, or the built-in `setState`, when an element emits an event. */
+export type ActionBinding = {
+    action: string;
+    params?: Record<string, unknown>;
+};
+/**
+ * A visibility condition: a boolean, a value expression (truthy test), a
+ * comparison (`{ $state: "/x", gt: 3 }`), `{ not: condition }`,
+ * `{ $and: [...] }`, `{ $or: [...] }`, or an array (all must hold).
+ */
+export type Condition = boolean | readonly Condition[] | {
+    readonly [key: string]: unknown;
+};
+/** One node of a spec. Children are referenced by element id. */
+export type SpecElement = {
+    type: string;
+    props?: Record<string, unknown>;
+    /** Ids of the elements in the component's default slot. */
+    children?: string[];
+    /** Ids per named slot, for components that declare more than `default`. */
+    slots?: Record<string, string[]>;
+    /** Renders the element only while the condition holds. */
+    visible?: Condition;
+    /** Renders the children once per item of the array at `path` in state. */
+    repeat?: {
+        path: string;
+        key?: string;
+    };
+    /** Actions to run when the component emits an event, keyed by event name. */
+    on?: Record<string, ActionBinding | ActionBinding[]>;
+    /** Actions to run when the state value at a path changes, keyed by JSON Pointer. */
+    watch?: Record<string, ActionBinding | ActionBinding[]>;
+};
+/** A flat spec: the root element id, every element by id, and initial state. */
+export type Spec = {
+    root: string;
+    elements: Record<string, SpecElement>;
+    state?: Record<string, unknown>;
+};
+/** One RFC 6902 operation. Paths are JSON Pointers into the spec. */
+export type PatchOperation = {
+    op: "add";
+    path: string;
+    value: unknown;
+} | {
+    op: "replace";
+    path: string;
+    value: unknown;
+} | {
+    op: "remove";
+    path: string;
+} | {
+    op: "move";
+    from: string;
+    path: string;
+} | {
+    op: "copy";
+    from: string;
+    path: string;
+} | {
+    op: "test";
+    path: string;
+    value: unknown;
+};
+export declare const emptySpec: () => Spec;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","mappings":"AAAA;AACA,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CACjC;AAED;;;;;AAKA,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,SAAS,SAAS,EAAE,GACpB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;CAAE;AAEvC;AACA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/B;IACA,QAAQ,CAAC,EAAE,MAAM,EAAE;IACnB;IACA,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAChC;IACA,OAAO,CAAC,EAAE,SAAS;IACnB;IACA,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM;QAAE,GAAG,CAAC,EAAE,MAAM;KAAE;IACvC;IACA,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;IACpD;IACA,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;CACxD;AAED;AACA,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAChC;AAED;AACA,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,KAAK;IAAE,IAAI,EAAE,MAAM;IAAE,KAAK,EAAE,OAAO;CAAE,GAC3C;IAAE,EAAE,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM;IAAE,KAAK,EAAE,OAAO;CAAE,GAC/C;IAAE,EAAE,EAAE,QAAQ;IAAE,IAAI,EAAE,MAAM;CAAE,GAC9B;IAAE,EAAE,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;CAAE,GAC1C;IAAE,EAAE,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;CAAE,GAC1C;IAAE,EAAE,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;IAAE,KAAK,EAAE,OAAO;CAAE;AAEhD,eAAO,MAAM,SAAS,QAAO,IAA+C","names":[],"ignoreList":[],"sources":["../../src/spec/types.ts"],"sourcesContent":[null]}

package/dist/spec/types.js

@@ -0,0 +1,9 @@
+// src/spec/types.ts
+const emptySpec = () => ({
+	root: "",
+	elements: {},
+	state: {}
+});
+export { emptySpec };
+
+//# sourceMappingURL=types.js.map

package/dist/spec/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/spec/types.ts"],"sourcesContent":["/** Runs a catalog action, or the built-in `setState`, when an element emits an event. */\nexport type ActionBinding = {\n  action: string;\n  params?: Record<string, unknown>;\n};\n\n/**\n * A visibility condition: a boolean, a value expression (truthy test), a\n * comparison (`{ $state: \"/x\", gt: 3 }`), `{ not: condition }`,\n * `{ $and: [...] }`, `{ $or: [...] }`, or an array (all must hold).\n */\nexport type Condition =\n  | boolean\n  | readonly Condition[]\n  | { readonly [key: string]: unknown };\n\n/** One node of a spec. Children are referenced by element id. */\nexport type SpecElement = {\n  type: string;\n  props?: Record<string, unknown>;\n  /** Ids of the elements in the component's default slot. */\n  children?: string[];\n  /** Ids per named slot, for components that declare more than `default`. */\n  slots?: Record<string, string[]>;\n  /** Renders the element only while the condition holds. */\n  visible?: Condition;\n  /** Renders the children once per item of the array at `path` in state. */\n  repeat?: { path: string; key?: string };\n  /** Actions to run when the component emits an event, keyed by event name. */\n  on?: Record<string, ActionBinding | ActionBinding[]>;\n  /** Actions to run when the state value at a path changes, keyed by JSON Pointer. */\n  watch?: Record<string, ActionBinding | ActionBinding[]>;\n};\n\n/** A flat spec: the root element id, every element by id, and initial state. */\nexport type Spec = {\n  root: string;\n  elements: Record<string, SpecElement>;\n  state?: Record<string, unknown>;\n};\n\n/** One RFC 6902 operation. Paths are JSON Pointers into the spec. */\nexport type PatchOperation =\n  | { op: \"add\"; path: string; value: unknown }\n  | { op: \"replace\"; path: string; value: unknown }\n  | { op: \"remove\"; path: string }\n  | { op: \"move\"; from: string; path: string }\n  | { op: \"copy\"; from: string; path: string }\n  | { op: \"test\"; path: string; value: unknown };\n\nexport const emptySpec = (): Spec => ({ root: \"\", elements: {}, state: {} });\n"],"mappings":";AAkDA,MAAa,mBAAyB;CAAE,MAAM;CAAI,UAAU,CAAC;CAAG,OAAO,CAAC;AAAE"}