@json-render/core 0.8.0 → 0.9.1

package/dist/index.mjs

@@ -1,598 +1,67 @@
-// src/types.ts
+import {
+  DynamicBooleanSchema,
+  DynamicNumberSchema,
+  DynamicStringSchema,
+  DynamicValueSchema,
+  SPEC_DATA_PART,
+  SPEC_DATA_PART_TYPE,
+  addByPath,
+  applySpecPatch,
+  applySpecStreamPatch,
+  compileSpecStream,
+  createJsonRenderTransform,
+  createMixedStreamParser,
+  createSpecStreamCompiler,
+  createStateStore,
+  findFormValue,
+  getByPath,
+  nestedToFlat,
+  parseSpecStreamLine,
+  pipeJsonRender,
+  removeByPath,
+  resolveDynamicValue,
+  setByPath
+} from "./chunk-4ZGEEX7K.mjs";
+
+// src/visibility.ts
 import { z } from "zod";
-var DynamicValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null(),
-  z.object({ $state: z.string() })
-]);
-var DynamicStringSchema = z.union([
-  z.string(),
-  z.object({ $state: z.string() })
-]);
-var DynamicNumberSchema = z.union([
+var numericOrStateRef = z.union([
   z.number(),
   z.object({ $state: z.string() })
 ]);
-var DynamicBooleanSchema = z.union([
-  z.boolean(),
-  z.object({ $state: z.string() })
-]);
-function resolveDynamicValue(value, stateModel) {
-  if (value === null || value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "object" && "$state" in value) {
-    return getByPath(stateModel, value.$state);
-  }
-  return value;
-}
-function unescapeJsonPointer(token) {
-  return token.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-function parseJsonPointer(path) {
-  const raw = path.startsWith("/") ? path.slice(1).split("/") : path.split("/");
-  return raw.map(unescapeJsonPointer);
-}
-function getByPath(obj, path) {
-  if (!path || path === "/") {
-    return obj;
-  }
-  const segments = parseJsonPointer(path);
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0) {
-      return void 0;
-    }
-    if (Array.isArray(current)) {
-      const index = parseInt(segment, 10);
-      current = current[index];
-    } else if (typeof current === "object") {
-      current = current[segment];
-    } else {
-      return void 0;
-    }
-  }
-  return current;
-}
-function isNumericIndex(str) {
-  return /^\d+$/.test(str);
-}
-function setByPath(obj, path, value) {
-  const segments = parseJsonPointer(path);
-  if (segments.length === 0) return;
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    const nextSegment = segments[i + 1];
-    const nextIsNumeric = nextSegment !== void 0 && (isNumericIndex(nextSegment) || nextSegment === "-");
-    if (Array.isArray(current)) {
-      const index = parseInt(segment, 10);
-      if (current[index] === void 0 || typeof current[index] !== "object") {
-        current[index] = nextIsNumeric ? [] : {};
-      }
-      current = current[index];
-    } else {
-      if (!(segment in current) || typeof current[segment] !== "object") {
-        current[segment] = nextIsNumeric ? [] : {};
-      }
-      current = current[segment];
-    }
-  }
-  const lastSegment = segments[segments.length - 1];
-  if (Array.isArray(current)) {
-    if (lastSegment === "-") {
-      current.push(value);
-    } else {
-      const index = parseInt(lastSegment, 10);
-      current[index] = value;
-    }
-  } else {
-    current[lastSegment] = value;
-  }
-}
-function addByPath(obj, path, value) {
-  const segments = parseJsonPointer(path);
-  if (segments.length === 0) return;
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    const nextSegment = segments[i + 1];
-    const nextIsNumeric = nextSegment !== void 0 && (isNumericIndex(nextSegment) || nextSegment === "-");
-    if (Array.isArray(current)) {
-      const index = parseInt(segment, 10);
-      if (current[index] === void 0 || typeof current[index] !== "object") {
-        current[index] = nextIsNumeric ? [] : {};
-      }
-      current = current[index];
-    } else {
-      if (!(segment in current) || typeof current[segment] !== "object") {
-        current[segment] = nextIsNumeric ? [] : {};
-      }
-      current = current[segment];
-    }
-  }
-  const lastSegment = segments[segments.length - 1];
-  if (Array.isArray(current)) {
-    if (lastSegment === "-") {
-      current.push(value);
-    } else {
-      const index = parseInt(lastSegment, 10);
-      current.splice(index, 0, value);
-    }
-  } else {
-    current[lastSegment] = value;
-  }
-}
-function removeByPath(obj, path) {
-  const segments = parseJsonPointer(path);
-  if (segments.length === 0) return;
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i];
-    if (Array.isArray(current)) {
-      const index = parseInt(segment, 10);
-      if (current[index] === void 0 || typeof current[index] !== "object") {
-        return;
-      }
-      current = current[index];
-    } else {
-      if (!(segment in current) || typeof current[segment] !== "object") {
-        return;
-      }
-      current = current[segment];
-    }
-  }
-  const lastSegment = segments[segments.length - 1];
-  if (Array.isArray(current)) {
-    const index = parseInt(lastSegment, 10);
-    if (index >= 0 && index < current.length) {
-      current.splice(index, 1);
-    }
-  } else {
-    delete current[lastSegment];
-  }
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object") return false;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) return false;
-    if (a.length !== b.length) return false;
-    return a.every((item, i) => deepEqual(item, b[i]));
-  }
-  const aObj = a;
-  const bObj = b;
-  const aKeys = Object.keys(aObj);
-  const bKeys = Object.keys(bObj);
-  if (aKeys.length !== bKeys.length) return false;
-  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
-}
-function findFormValue(fieldName, params, state) {
-  if (params?.[fieldName] !== void 0) {
-    const val = params[fieldName];
-    if (typeof val !== "string" || !val.includes(".")) {
-      return val;
-    }
-  }
-  if (params) {
-    for (const key of Object.keys(params)) {
-      if (key.endsWith(`.${fieldName}`)) {
-        const val = params[key];
-        if (typeof val !== "string" || !val.includes(".")) {
-          return val;
-        }
-      }
-    }
-  }
-  if (state) {
-    for (const key of Object.keys(state)) {
-      if (key === fieldName || key.endsWith(`.${fieldName}`)) {
-        return state[key];
-      }
-    }
-    const val = getByPath(state, fieldName);
-    if (val !== void 0) {
-      return val;
-    }
-  }
-  return void 0;
-}
-function parseSpecStreamLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed || !trimmed.startsWith("{")) return null;
-  try {
-    const patch = JSON.parse(trimmed);
-    if (patch.op && patch.path !== void 0) {
-      return patch;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function applySpecStreamPatch(obj, patch) {
-  switch (patch.op) {
-    case "add":
-      addByPath(obj, patch.path, patch.value);
-      break;
-    case "replace":
-      setByPath(obj, patch.path, patch.value);
-      break;
-    case "remove":
-      removeByPath(obj, patch.path);
-      break;
-    case "move": {
-      if (!patch.from) break;
-      const moveValue = getByPath(obj, patch.from);
-      removeByPath(obj, patch.from);
-      addByPath(obj, patch.path, moveValue);
-      break;
-    }
-    case "copy": {
-      if (!patch.from) break;
-      const copyValue = getByPath(obj, patch.from);
-      addByPath(obj, patch.path, copyValue);
-      break;
-    }
-    case "test": {
-      const actual = getByPath(obj, patch.path);
-      if (!deepEqual(actual, patch.value)) {
-        throw new Error(
-          `Test operation failed: value at "${patch.path}" does not match`
-        );
-      }
-      break;
-    }
-  }
-  return obj;
-}
-function applySpecPatch(spec, patch) {
-  applySpecStreamPatch(spec, patch);
-  return spec;
-}
-function nestedToFlat(nested) {
-  const elements = {};
-  let counter = 0;
-  function walk(node) {
-    const key = `el-${counter++}`;
-    const { type, props, children: rawChildren, ...rest } = node;
-    const childKeys = [];
-    if (Array.isArray(rawChildren)) {
-      for (const child of rawChildren) {
-        if (child && typeof child === "object" && "type" in child) {
-          childKeys.push(walk(child));
-        }
-      }
-    }
-    const element = {
-      type: type ?? "unknown",
-      props: props ?? {},
-      children: childKeys
-    };
-    for (const [k, v] of Object.entries(rest)) {
-      if (k !== "state" && v !== void 0) {
-        element[k] = v;
-      }
-    }
-    elements[key] = element;
-    return key;
-  }
-  const root = walk(nested);
-  const spec = { root, elements };
-  if (nested.state && typeof nested.state === "object" && !Array.isArray(nested.state)) {
-    spec.state = nested.state;
-  }
-  return spec;
-}
-function compileSpecStream(stream, initial = {}) {
-  const lines = stream.split("\n");
-  const result = { ...initial };
-  for (const line of lines) {
-    const patch = parseSpecStreamLine(line);
-    if (patch) {
-      applySpecStreamPatch(result, patch);
-    }
-  }
-  return result;
-}
-function createSpecStreamCompiler(initial = {}) {
-  let result = { ...initial };
-  let buffer = "";
-  const appliedPatches = [];
-  const processedLines = /* @__PURE__ */ new Set();
-  return {
-    push(chunk) {
-      buffer += chunk;
-      const newPatches = [];
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || processedLines.has(trimmed)) continue;
-        processedLines.add(trimmed);
-        const patch = parseSpecStreamLine(trimmed);
-        if (patch) {
-          applySpecStreamPatch(result, patch);
-          appliedPatches.push(patch);
-          newPatches.push(patch);
-        }
-      }
-      if (newPatches.length > 0) {
-        result = { ...result };
-      }
-      return { result, newPatches };
-    },
-    getResult() {
-      if (buffer.trim()) {
-        const patch = parseSpecStreamLine(buffer);
-        if (patch && !processedLines.has(buffer.trim())) {
-          processedLines.add(buffer.trim());
-          applySpecStreamPatch(result, patch);
-          appliedPatches.push(patch);
-          result = { ...result };
-        }
-        buffer = "";
-      }
-      return result;
-    },
-    getPatches() {
-      return [...appliedPatches];
-    },
-    reset(newInitial = {}) {
-      result = { ...newInitial };
-      buffer = "";
-      appliedPatches.length = 0;
-      processedLines.clear();
-    }
-  };
-}
-function createMixedStreamParser(callbacks) {
-  let buffer = "";
-  let inSpecFence = false;
-  function processLine(line) {
-    const trimmed = line.trim();
-    if (!inSpecFence && trimmed.startsWith("```spec")) {
-      inSpecFence = true;
-      return;
-    }
-    if (inSpecFence && trimmed === "```") {
-      inSpecFence = false;
-      return;
-    }
-    if (!trimmed) return;
-    if (inSpecFence) {
-      const patch2 = parseSpecStreamLine(trimmed);
-      if (patch2) {
-        callbacks.onPatch(patch2);
-      }
-      return;
-    }
-    const patch = parseSpecStreamLine(trimmed);
-    if (patch) {
-      callbacks.onPatch(patch);
-    } else {
-      callbacks.onText(line);
-    }
-  }
-  return {
-    push(chunk) {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        processLine(line);
-      }
-    },
-    flush() {
-      if (buffer.trim()) {
-        processLine(buffer);
-      }
-      buffer = "";
-    }
-  };
-}
-var SPEC_FENCE_OPEN = "```spec";
-var SPEC_FENCE_CLOSE = "```";
-function createJsonRenderTransform() {
-  let lineBuffer = "";
-  let currentTextId = "";
-  let buffering = false;
-  let inSpecFence = false;
-  let inTextBlock = false;
-  let textIdCounter = 0;
-  function closeTextBlock(controller) {
-    if (inTextBlock) {
-      controller.enqueue({ type: "text-end", id: currentTextId });
-      inTextBlock = false;
-    }
-  }
-  function ensureTextBlock(controller) {
-    if (!inTextBlock) {
-      textIdCounter++;
-      currentTextId = String(textIdCounter);
-      controller.enqueue({ type: "text-start", id: currentTextId });
-      inTextBlock = true;
-    }
-  }
-  function emitTextDelta(delta, controller) {
-    ensureTextBlock(controller);
-    controller.enqueue({ type: "text-delta", id: currentTextId, delta });
-  }
-  function emitPatch(patch, controller) {
-    closeTextBlock(controller);
-    controller.enqueue({
-      type: SPEC_DATA_PART_TYPE,
-      data: { type: "patch", patch }
-    });
-  }
-  function flushBuffer(controller) {
-    if (!lineBuffer) return;
-    const trimmed = lineBuffer.trim();
-    if (inSpecFence) {
-      if (trimmed) {
-        const patch = parseSpecStreamLine(trimmed);
-        if (patch) emitPatch(patch, controller);
-      }
-      lineBuffer = "";
-      buffering = false;
-      return;
-    }
-    if (trimmed) {
-      const patch = parseSpecStreamLine(trimmed);
-      if (patch) {
-        emitPatch(patch, controller);
-      } else {
-        emitTextDelta(lineBuffer, controller);
-      }
-    } else {
-      emitTextDelta(lineBuffer, controller);
-    }
-    lineBuffer = "";
-    buffering = false;
-  }
-  function processCompleteLine(line, controller) {
-    const trimmed = line.trim();
-    if (!inSpecFence && trimmed.startsWith(SPEC_FENCE_OPEN)) {
-      inSpecFence = true;
-      return;
-    }
-    if (inSpecFence && trimmed === SPEC_FENCE_CLOSE) {
-      inSpecFence = false;
-      return;
-    }
-    if (inSpecFence) {
-      if (trimmed) {
-        const patch2 = parseSpecStreamLine(trimmed);
-        if (patch2) emitPatch(patch2, controller);
-      }
-      return;
-    }
-    if (!trimmed) {
-      emitTextDelta("\n", controller);
-      return;
-    }
-    const patch = parseSpecStreamLine(trimmed);
-    if (patch) {
-      emitPatch(patch, controller);
-    } else {
-      emitTextDelta(line + "\n", controller);
-    }
-  }
-  return new TransformStream({
-    transform(chunk, controller) {
-      switch (chunk.type) {
-        case "text-start": {
-          const id = chunk.id;
-          const idNum = parseInt(id, 10);
-          if (!isNaN(idNum) && idNum >= textIdCounter) {
-            textIdCounter = idNum;
-          }
-          currentTextId = id;
-          inTextBlock = true;
-          controller.enqueue(chunk);
-          break;
-        }
-        case "text-delta": {
-          const delta = chunk;
-          const text = delta.delta;
-          for (let i = 0; i < text.length; i++) {
-            const ch = text.charAt(i);
-            if (ch === "\n") {
-              if (buffering) {
-                processCompleteLine(lineBuffer, controller);
-                lineBuffer = "";
-                buffering = false;
-              } else {
-                if (!inSpecFence) {
-                  emitTextDelta("\n", controller);
-                }
-              }
-            } else if (lineBuffer.length === 0 && !buffering) {
-              if (inSpecFence || ch === "{" || ch === "`") {
-                buffering = true;
-                lineBuffer += ch;
-              } else {
-                emitTextDelta(ch, controller);
-              }
-            } else if (buffering) {
-              lineBuffer += ch;
-            } else {
-              emitTextDelta(ch, controller);
-            }
-          }
-          break;
-        }
-        case "text-end": {
-          flushBuffer(controller);
-          if (inTextBlock) {
-            controller.enqueue({ type: "text-end", id: currentTextId });
-            inTextBlock = false;
-          }
-          break;
-        }
-        default: {
-          controller.enqueue(chunk);
-          break;
-        }
-      }
-    },
-    flush(controller) {
-      flushBuffer(controller);
-      closeTextBlock(controller);
-    }
-  });
-}
-var SPEC_DATA_PART = "spec";
-var SPEC_DATA_PART_TYPE = `data-${SPEC_DATA_PART}`;
-function pipeJsonRender(stream) {
-  return stream.pipeThrough(
-    createJsonRenderTransform()
-  );
-}
-
-// src/visibility.ts
-import { z as z2 } from "zod";
-var numericOrStateRef = z2.union([
-  z2.number(),
-  z2.object({ $state: z2.string() })
-]);
 var comparisonOps = {
-  eq: z2.unknown().optional(),
-  neq: z2.unknown().optional(),
+  eq: z.unknown().optional(),
+  neq: z.unknown().optional(),
   gt: numericOrStateRef.optional(),
   gte: numericOrStateRef.optional(),
   lt: numericOrStateRef.optional(),
   lte: numericOrStateRef.optional(),
-  not: z2.literal(true).optional()
+  not: z.literal(true).optional()
 };
-var StateConditionSchema = z2.object({
-  $state: z2.string(),
+var StateConditionSchema = z.object({
+  $state: z.string(),
   ...comparisonOps
 });
-var ItemConditionSchema = z2.object({
-  $item: z2.string(),
+var ItemConditionSchema = z.object({
+  $item: z.string(),
   ...comparisonOps
 });
-var IndexConditionSchema = z2.object({
-  $index: z2.literal(true),
+var IndexConditionSchema = z.object({
+  $index: z.literal(true),
   ...comparisonOps
 });
-var SingleConditionSchema = z2.union([
+var SingleConditionSchema = z.union([
   StateConditionSchema,
   ItemConditionSchema,
   IndexConditionSchema
 ]);
-var VisibilityConditionSchema = z2.lazy(
-  () => z2.union([
-    z2.boolean(),
+var VisibilityConditionSchema = z.lazy(
+  () => z.union([
+    z.boolean(),
     SingleConditionSchema,
-    z2.array(SingleConditionSchema),
-    z2.object({ $and: z2.array(VisibilityConditionSchema) }),
-    z2.object({ $or: z2.array(VisibilityConditionSchema) })
+    z.array(SingleConditionSchema),
+    z.object({ $and: z.array(VisibilityConditionSchema) }),
+    z.object({ $or: z.array(VisibilityConditionSchema) })
   ])
 );
 function resolveComparisonValue(value, ctx) {
@@ -817,30 +286,30 @@ function resolveActionParam(value, ctx) {
 }
 
 // src/actions.ts
-import { z as z3 } from "zod";
-var ActionConfirmSchema = z3.object({
-  title: z3.string(),
-  message: z3.string(),
-  confirmLabel: z3.string().optional(),
-  cancelLabel: z3.string().optional(),
-  variant: z3.enum(["default", "danger"]).optional()
+import { z as z2 } from "zod";
+var ActionConfirmSchema = z2.object({
+  title: z2.string(),
+  message: z2.string(),
+  confirmLabel: z2.string().optional(),
+  cancelLabel: z2.string().optional(),
+  variant: z2.enum(["default", "danger"]).optional()
 });
-var ActionOnSuccessSchema = z3.union([
-  z3.object({ navigate: z3.string() }),
-  z3.object({ set: z3.record(z3.string(), z3.unknown()) }),
-  z3.object({ action: z3.string() })
+var ActionOnSuccessSchema = z2.union([
+  z2.object({ navigate: z2.string() }),
+  z2.object({ set: z2.record(z2.string(), z2.unknown()) }),
+  z2.object({ action: z2.string() })
 ]);
-var ActionOnErrorSchema = z3.union([
-  z3.object({ set: z3.record(z3.string(), z3.unknown()) }),
-  z3.object({ action: z3.string() })
+var ActionOnErrorSchema = z2.union([
+  z2.object({ set: z2.record(z2.string(), z2.unknown()) }),
+  z2.object({ action: z2.string() })
 ]);
-var ActionBindingSchema = z3.object({
-  action: z3.string(),
-  params: z3.record(z3.string(), DynamicValueSchema).optional(),
+var ActionBindingSchema = z2.object({
+  action: z2.string(),
+  params: z2.record(z2.string(), DynamicValueSchema).optional(),
   confirm: ActionConfirmSchema.optional(),
   onSuccess: ActionOnSuccessSchema.optional(),
   onError: ActionOnErrorSchema.optional(),
-  preventDefault: z3.boolean().optional()
+  preventDefault: z2.boolean().optional()
 });
 var ActionSchema = ActionBindingSchema;
 function resolveAction(binding, stateModel) {
@@ -924,15 +393,15 @@ var actionBinding = {
 var action = actionBinding;
 
 // src/validation.ts
-import { z as z4 } from "zod";
-var ValidationCheckSchema = z4.object({
-  type: z4.string(),
-  args: z4.record(z4.string(), DynamicValueSchema).optional(),
-  message: z4.string()
+import { z as z3 } from "zod";
+var ValidationCheckSchema = z3.object({
+  type: z3.string(),
+  args: z3.record(z3.string(), DynamicValueSchema).optional(),
+  message: z3.string()
 });
-var ValidationConfigSchema = z4.object({
-  checks: z4.array(ValidationCheckSchema).optional(),
-  validateOn: z4.enum(["change", "blur", "submit"]).optional(),
+var ValidationConfigSchema = z3.object({
+  checks: z3.array(ValidationCheckSchema).optional(),
+  validateOn: z3.enum(["change", "blur", "submit"]).optional(),
   enabled: VisibilityConditionSchema.optional()
 });
 var builtInValidationFunctions = {
@@ -1275,7 +744,7 @@ function formatSpecIssues(issues) {
 }
 
 // src/schema.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 function createBuilder() {
   return {
     string: () => ({ kind: "string" }),
@@ -1349,16 +818,16 @@ function buildZodSchemaFromDefinition(definition, catalogData) {
 function buildZodType(schemaType, catalogData) {
   switch (schemaType.kind) {
     case "string":
-      return z5.string();
+      return z4.string();
     case "number":
-      return z5.number();
+      return z4.number();
     case "boolean":
-      return z5.boolean();
+      return z4.boolean();
     case "any":
-      return z5.any();
+      return z4.any();
     case "array": {
       const inner = buildZodType(schemaType.inner, catalogData);
-      return z5.array(inner);
+      return z4.array(inner);
     }
     case "object": {
       const shape = schemaType.inner;
@@ -1370,36 +839,36 @@ function buildZodType(schemaType, catalogData) {
         }
         zodShape[key] = zodType;
       }
-      return z5.object(zodShape);
+      return z4.object(zodShape);
     }
     case "record": {
       const inner = buildZodType(schemaType.inner, catalogData);
-      return z5.record(z5.string(), inner);
+      return z4.record(z4.string(), inner);
     }
     case "ref": {
       const path = schemaType.inner;
       const keys = getKeysFromPath(path, catalogData);
       if (keys.length === 0) {
-        return z5.string();
+        return z4.string();
       }
       if (keys.length === 1) {
-        return z5.literal(keys[0]);
+        return z4.literal(keys[0]);
       }
-      return z5.enum(keys);
+      return z4.enum(keys);
     }
     case "propsOf": {
       const path = schemaType.inner;
       const propsSchemas = getPropsFromPath(path, catalogData);
       if (propsSchemas.length === 0) {
-        return z5.record(z5.string(), z5.unknown());
+        return z4.record(z4.string(), z4.unknown());
       }
       if (propsSchemas.length === 1) {
         return propsSchemas[0];
       }
-      return z5.record(z5.string(), z5.unknown());
+      return z4.record(z4.string(), z4.unknown());
     }
     default:
-      return z5.unknown();
+      return z4.unknown();
   }
 }
 function getKeysFromPath(path, catalogData) {
@@ -1940,7 +1409,7 @@ function formatZodType(schema) {
     }
     case "ZodArray":
     case "array": {
-      const inner = def.type ?? def.element;
+      const inner = typeof def.element === "object" ? def.element : typeof def.type === "object" ? def.type : void 0;
       return inner ? `Array<${formatZodType(inner)}>` : "Array<unknown>";
     }
     case "ZodObject":
@@ -2113,6 +1582,7 @@ export {
   createJsonRenderTransform,
   createMixedStreamParser,
   createSpecStreamCompiler,
+  createStateStore,
   defineCatalog,
   defineSchema,
   evaluateVisibility,