@duckmind/dm-darwin-x64 0.33.2 → 0.33.5

package/extensions/dm-design-md/node_modules/@json-render/core/dist/index.js

@@ -1,2880 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ActionBindingSchema: () => ActionBindingSchema,
-  ActionConfirmSchema: () => ActionConfirmSchema,
-  ActionOnErrorSchema: () => ActionOnErrorSchema,
-  ActionOnSuccessSchema: () => ActionOnSuccessSchema,
-  ActionSchema: () => ActionSchema,
-  DynamicBooleanSchema: () => DynamicBooleanSchema,
-  DynamicNumberSchema: () => DynamicNumberSchema,
-  DynamicStringSchema: () => DynamicStringSchema,
-  DynamicValueSchema: () => DynamicValueSchema,
-  SPEC_DATA_PART: () => SPEC_DATA_PART,
-  SPEC_DATA_PART_TYPE: () => SPEC_DATA_PART_TYPE,
-  ValidationCheckSchema: () => ValidationCheckSchema,
-  ValidationConfigSchema: () => ValidationConfigSchema,
-  VisibilityConditionSchema: () => VisibilityConditionSchema,
-  action: () => action,
-  actionBinding: () => actionBinding,
-  addByPath: () => addByPath,
-  applySpecPatch: () => applySpecPatch,
-  applySpecStreamPatch: () => applySpecStreamPatch,
-  autoFixSpec: () => autoFixSpec,
-  buildEditInstructions: () => buildEditInstructions,
-  buildEditUserPrompt: () => buildEditUserPrompt,
-  buildUserPrompt: () => buildUserPrompt,
-  builtInValidationFunctions: () => builtInValidationFunctions,
-  check: () => check,
-  compileSpecStream: () => compileSpecStream,
-  createJsonRenderTransform: () => createJsonRenderTransform,
-  createMixedStreamParser: () => createMixedStreamParser,
-  createSpecStreamCompiler: () => createSpecStreamCompiler,
-  createStateStore: () => createStateStore,
-  deepMergeSpec: () => deepMergeSpec,
-  defineCatalog: () => defineCatalog,
-  defineSchema: () => defineSchema,
-  diffToPatches: () => diffToPatches,
-  evaluateVisibility: () => evaluateVisibility,
-  executeAction: () => executeAction,
-  findFormValue: () => findFormValue,
-  formatSpecIssues: () => formatSpecIssues,
-  getByPath: () => getByPath,
-  interpolateString: () => interpolateString,
-  isNonEmptySpec: () => isNonEmptySpec,
-  nestedToFlat: () => nestedToFlat,
-  parseSpecStreamLine: () => parseSpecStreamLine,
-  pipeJsonRender: () => pipeJsonRender,
-  removeByPath: () => removeByPath,
-  resolveAction: () => resolveAction,
-  resolveActionParam: () => resolveActionParam,
-  resolveBindings: () => resolveBindings,
-  resolveDynamicValue: () => resolveDynamicValue,
-  resolveElementProps: () => resolveElementProps,
-  resolvePropValue: () => resolvePropValue,
-  runValidation: () => runValidation,
-  runValidationCheck: () => runValidationCheck,
-  setByPath: () => setByPath,
-  validateSpec: () => validateSpec,
-  visibility: () => visibility
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types.ts
-var import_zod = require("zod");
-var DynamicValueSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.null(),
-  import_zod.z.object({ $state: import_zod.z.string() })
-]);
-var DynamicStringSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.object({ $state: import_zod.z.string() })
-]);
-var DynamicNumberSchema = import_zod.z.union([
-  import_zod.z.number(),
-  import_zod.z.object({ $state: import_zod.z.string() })
-]);
-var DynamicBooleanSchema = import_zod.z.union([
-  import_zod.z.boolean(),
-  import_zod.z.object({ $state: import_zod.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/state-store.ts
-function immutableSetByPath(root, path, value) {
-  const segments = parseJsonPointer(path);
-  if (segments.length === 0) return root;
-  const result = { ...root };
-  let current = result;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const seg = segments[i];
-    const child = current[seg];
-    if (Array.isArray(child)) {
-      current[seg] = [...child];
-    } else if (child !== null && typeof child === "object") {
-      current[seg] = { ...child };
-    } else {
-      const nextSeg = segments[i + 1];
-      current[seg] = nextSeg !== void 0 && /^\d+$/.test(nextSeg) ? [] : {};
-    }
-    current = current[seg];
-  }
-  const lastSeg = segments[segments.length - 1];
-  if (Array.isArray(current)) {
-    if (lastSeg === "-") {
-      current.push(value);
-    } else {
-      current[parseInt(lastSeg, 10)] = value;
-    }
-  } else {
-    current[lastSeg] = value;
-  }
-  return result;
-}
-function createStateStore(initialState = {}) {
-  let state = { ...initialState };
-  const listeners = /* @__PURE__ */ new Set();
-  function notify() {
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  return {
-    get(path) {
-      return getByPath(state, path);
-    },
-    set(path, value) {
-      if (getByPath(state, path) === value) return;
-      state = immutableSetByPath(state, path, value);
-      notify();
-    },
-    update(updates) {
-      let changed = false;
-      let next = state;
-      for (const [path, value] of Object.entries(updates)) {
-        if (getByPath(next, path) !== value) {
-          next = immutableSetByPath(next, path, value);
-          changed = true;
-        }
-      }
-      if (!changed) return;
-      state = next;
-      notify();
-    },
-    getSnapshot() {
-      return state;
-    },
-    getServerSnapshot() {
-      return state;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
-}
-
-// src/visibility.ts
-var import_zod2 = require("zod");
-var numericOrStateRef = import_zod2.z.union([
-  import_zod2.z.number(),
-  import_zod2.z.object({ $state: import_zod2.z.string() })
-]);
-var comparisonOps = {
-  eq: import_zod2.z.unknown().optional(),
-  neq: import_zod2.z.unknown().optional(),
-  gt: numericOrStateRef.optional(),
-  gte: numericOrStateRef.optional(),
-  lt: numericOrStateRef.optional(),
-  lte: numericOrStateRef.optional(),
-  not: import_zod2.z.literal(true).optional()
-};
-var StateConditionSchema = import_zod2.z.object({
-  $state: import_zod2.z.string(),
-  ...comparisonOps
-});
-var ItemConditionSchema = import_zod2.z.object({
-  $item: import_zod2.z.string(),
-  ...comparisonOps
-});
-var IndexConditionSchema = import_zod2.z.object({
-  $index: import_zod2.z.literal(true),
-  ...comparisonOps
-});
-var SingleConditionSchema = import_zod2.z.union([
-  StateConditionSchema,
-  ItemConditionSchema,
-  IndexConditionSchema
-]);
-var VisibilityConditionSchema = import_zod2.z.lazy(
-  () => import_zod2.z.union([
-    import_zod2.z.boolean(),
-    SingleConditionSchema,
-    import_zod2.z.array(SingleConditionSchema),
-    import_zod2.z.object({ $and: import_zod2.z.array(VisibilityConditionSchema) }),
-    import_zod2.z.object({ $or: import_zod2.z.array(VisibilityConditionSchema) })
-  ])
-);
-function resolveComparisonValue(value, ctx) {
-  if (typeof value === "object" && value !== null) {
-    if ("$state" in value && typeof value.$state === "string") {
-      return getByPath(ctx.stateModel, value.$state);
-    }
-  }
-  return value;
-}
-function isItemCondition(cond) {
-  return "$item" in cond;
-}
-function isIndexCondition(cond) {
-  return "$index" in cond;
-}
-function resolveConditionValue(cond, ctx) {
-  if (isIndexCondition(cond)) {
-    return ctx.repeatIndex;
-  }
-  if (isItemCondition(cond)) {
-    if (ctx.repeatItem === void 0) return void 0;
-    return cond.$item === "" ? ctx.repeatItem : getByPath(ctx.repeatItem, cond.$item);
-  }
-  return getByPath(ctx.stateModel, cond.$state);
-}
-function evaluateCondition(cond, ctx) {
-  const value = resolveConditionValue(cond, ctx);
-  let result;
-  if (cond.eq !== void 0) {
-    const rhs = resolveComparisonValue(cond.eq, ctx);
-    result = value === rhs;
-  } else if (cond.neq !== void 0) {
-    const rhs = resolveComparisonValue(cond.neq, ctx);
-    result = value !== rhs;
-  } else if (cond.gt !== void 0) {
-    const rhs = resolveComparisonValue(cond.gt, ctx);
-    result = typeof value === "number" && typeof rhs === "number" ? value > rhs : false;
-  } else if (cond.gte !== void 0) {
-    const rhs = resolveComparisonValue(cond.gte, ctx);
-    result = typeof value === "number" && typeof rhs === "number" ? value >= rhs : false;
-  } else if (cond.lt !== void 0) {
-    const rhs = resolveComparisonValue(cond.lt, ctx);
-    result = typeof value === "number" && typeof rhs === "number" ? value < rhs : false;
-  } else if (cond.lte !== void 0) {
-    const rhs = resolveComparisonValue(cond.lte, ctx);
-    result = typeof value === "number" && typeof rhs === "number" ? value <= rhs : false;
-  } else {
-    result = Boolean(value);
-  }
-  return cond.not === true ? !result : result;
-}
-function isAndCondition(condition) {
-  return typeof condition === "object" && condition !== null && !Array.isArray(condition) && "$and" in condition;
-}
-function isOrCondition(condition) {
-  return typeof condition === "object" && condition !== null && !Array.isArray(condition) && "$or" in condition;
-}
-function evaluateVisibility(condition, ctx) {
-  if (condition === void 0) {
-    return true;
-  }
-  if (typeof condition === "boolean") {
-    return condition;
-  }
-  if (Array.isArray(condition)) {
-    return condition.every((c) => evaluateCondition(c, ctx));
-  }
-  if (isAndCondition(condition)) {
-    return condition.$and.every((child) => evaluateVisibility(child, ctx));
-  }
-  if (isOrCondition(condition)) {
-    return condition.$or.some((child) => evaluateVisibility(child, ctx));
-  }
-  return evaluateCondition(condition, ctx);
-}
-var visibility = {
-  /** Always visible */
-  always: true,
-  /** Never visible */
-  never: false,
-  /** Visible when state path is truthy */
-  when: (path) => ({ $state: path }),
-  /** Visible when state path is falsy */
-  unless: (path) => ({ $state: path, not: true }),
-  /** Equality check */
-  eq: (path, value) => ({
-    $state: path,
-    eq: value
-  }),
-  /** Not equal check */
-  neq: (path, value) => ({
-    $state: path,
-    neq: value
-  }),
-  /** Greater than */
-  gt: (path, value) => ({
-    $state: path,
-    gt: value
-  }),
-  /** Greater than or equal */
-  gte: (path, value) => ({
-    $state: path,
-    gte: value
-  }),
-  /** Less than */
-  lt: (path, value) => ({
-    $state: path,
-    lt: value
-  }),
-  /** Less than or equal */
-  lte: (path, value) => ({
-    $state: path,
-    lte: value
-  }),
-  /** AND multiple conditions */
-  and: (...conditions) => ({
-    $and: conditions
-  }),
-  /** OR multiple conditions */
-  or: (...conditions) => ({
-    $or: conditions
-  })
-};
-
-// src/props.ts
-function isStateExpression(value) {
-  return typeof value === "object" && value !== null && "$state" in value && typeof value.$state === "string";
-}
-function isItemExpression(value) {
-  return typeof value === "object" && value !== null && "$item" in value && typeof value.$item === "string";
-}
-function isIndexExpression(value) {
-  return typeof value === "object" && value !== null && "$index" in value && value.$index === true;
-}
-function isBindStateExpression(value) {
-  return typeof value === "object" && value !== null && "$bindState" in value && typeof value.$bindState === "string";
-}
-function isBindItemExpression(value) {
-  return typeof value === "object" && value !== null && "$bindItem" in value && typeof value.$bindItem === "string";
-}
-function isCondExpression(value) {
-  return typeof value === "object" && value !== null && "$cond" in value && "$then" in value && "$else" in value;
-}
-function isComputedExpression(value) {
-  return typeof value === "object" && value !== null && "$computed" in value && typeof value.$computed === "string";
-}
-function isTemplateExpression(value) {
-  return typeof value === "object" && value !== null && "$template" in value && typeof value.$template === "string";
-}
-var WARNED_COMPUTED_MAX = 100;
-var warnedComputedFns = /* @__PURE__ */ new Set();
-var WARNED_TEMPLATE_MAX = 100;
-var warnedTemplatePaths = /* @__PURE__ */ new Set();
-function resolveBindItemPath(itemPath, ctx) {
-  if (ctx.repeatBasePath == null) {
-    console.warn(`$bindItem used outside repeat scope: "${itemPath}"`);
-    return void 0;
-  }
-  if (itemPath === "") return ctx.repeatBasePath;
-  return ctx.repeatBasePath + "/" + itemPath;
-}
-function resolvePropValue(value, ctx) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (isStateExpression(value)) {
-    return getByPath(ctx.stateModel, value.$state);
-  }
-  if (isItemExpression(value)) {
-    if (ctx.repeatItem === void 0) return void 0;
-    return value.$item === "" ? ctx.repeatItem : getByPath(ctx.repeatItem, value.$item);
-  }
-  if (isIndexExpression(value)) {
-    return ctx.repeatIndex;
-  }
-  if (isBindStateExpression(value)) {
-    return getByPath(ctx.stateModel, value.$bindState);
-  }
-  if (isBindItemExpression(value)) {
-    const resolvedPath = resolveBindItemPath(value.$bindItem, ctx);
-    if (resolvedPath === void 0) return void 0;
-    return getByPath(ctx.stateModel, resolvedPath);
-  }
-  if (isCondExpression(value)) {
-    const result = evaluateVisibility(value.$cond, ctx);
-    return resolvePropValue(result ? value.$then : value.$else, ctx);
-  }
-  if (isComputedExpression(value)) {
-    const fn = ctx.functions?.[value.$computed];
-    if (!fn) {
-      if (!warnedComputedFns.has(value.$computed)) {
-        if (warnedComputedFns.size < WARNED_COMPUTED_MAX) {
-          warnedComputedFns.add(value.$computed);
-        }
-        console.warn(`Unknown $computed function: "${value.$computed}"`);
-      }
-      return void 0;
-    }
-    const resolvedArgs = {};
-    if (value.args) {
-      for (const [key, arg] of Object.entries(value.args)) {
-        resolvedArgs[key] = resolvePropValue(arg, ctx);
-      }
-    }
-    return fn(resolvedArgs);
-  }
-  if (isTemplateExpression(value)) {
-    return value.$template.replace(
-      /\$\{([^}]+)\}/g,
-      (_match, rawPath) => {
-        let path = rawPath;
-        if (!path.startsWith("/")) {
-          if (!warnedTemplatePaths.has(path)) {
-            if (warnedTemplatePaths.size < WARNED_TEMPLATE_MAX) {
-              warnedTemplatePaths.add(path);
-            }
-            console.warn(
-              `$template path "${path}" should be a JSON Pointer starting with "/". Automatically resolving as "/${path}".`
-            );
-          }
-          path = "/" + path;
-        }
-        const resolved = getByPath(ctx.stateModel, path);
-        return resolved != null ? String(resolved) : "";
-      }
-    );
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => resolvePropValue(item, ctx));
-  }
-  if (typeof value === "object") {
-    const resolved = {};
-    for (const [key, val] of Object.entries(value)) {
-      resolved[key] = resolvePropValue(val, ctx);
-    }
-    return resolved;
-  }
-  return value;
-}
-function resolveElementProps(props, ctx) {
-  const resolved = {};
-  for (const [key, value] of Object.entries(props)) {
-    resolved[key] = resolvePropValue(value, ctx);
-  }
-  return resolved;
-}
-function resolveBindings(props, ctx) {
-  let bindings;
-  for (const [key, value] of Object.entries(props)) {
-    if (isBindStateExpression(value)) {
-      if (!bindings) bindings = {};
-      bindings[key] = value.$bindState;
-    } else if (isBindItemExpression(value)) {
-      const resolved = resolveBindItemPath(value.$bindItem, ctx);
-      if (resolved !== void 0) {
-        if (!bindings) bindings = {};
-        bindings[key] = resolved;
-      }
-    }
-  }
-  return bindings;
-}
-function resolveActionParam(value, ctx) {
-  if (isItemExpression(value)) {
-    return resolveBindItemPath(value.$item, ctx);
-  }
-  if (isIndexExpression(value)) {
-    return ctx.repeatIndex;
-  }
-  return resolvePropValue(value, ctx);
-}
-
-// src/actions.ts
-var import_zod3 = require("zod");
-var ActionConfirmSchema = import_zod3.z.object({
-  title: import_zod3.z.string(),
-  message: import_zod3.z.string(),
-  confirmLabel: import_zod3.z.string().optional(),
-  cancelLabel: import_zod3.z.string().optional(),
-  variant: import_zod3.z.enum(["default", "danger"]).optional()
-});
-var ActionOnSuccessSchema = import_zod3.z.union([
-  import_zod3.z.object({ navigate: import_zod3.z.string() }),
-  import_zod3.z.object({ set: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()) }),
-  import_zod3.z.object({ action: import_zod3.z.string() })
-]);
-var ActionOnErrorSchema = import_zod3.z.union([
-  import_zod3.z.object({ set: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()) }),
-  import_zod3.z.object({ action: import_zod3.z.string() })
-]);
-var ActionBindingSchema = import_zod3.z.object({
-  action: import_zod3.z.string(),
-  params: import_zod3.z.record(import_zod3.z.string(), DynamicValueSchema).optional(),
-  confirm: ActionConfirmSchema.optional(),
-  onSuccess: ActionOnSuccessSchema.optional(),
-  onError: ActionOnErrorSchema.optional(),
-  preventDefault: import_zod3.z.boolean().optional()
-});
-var ActionSchema = ActionBindingSchema;
-function resolveAction(binding, stateModel) {
-  const resolvedParams = {};
-  if (binding.params) {
-    for (const [key, value] of Object.entries(binding.params)) {
-      resolvedParams[key] = resolveDynamicValue(value, stateModel);
-    }
-  }
-  let confirm = binding.confirm;
-  if (confirm) {
-    confirm = {
-      ...confirm,
-      message: interpolateString(confirm.message, stateModel),
-      title: interpolateString(confirm.title, stateModel)
-    };
-  }
-  return {
-    action: binding.action,
-    params: resolvedParams,
-    confirm,
-    onSuccess: binding.onSuccess,
-    onError: binding.onError
-  };
-}
-function interpolateString(template, stateModel) {
-  return template.replace(/\$\{([^}]+)\}/g, (_, path) => {
-    const value = resolveDynamicValue({ $state: path }, stateModel);
-    return String(value ?? "");
-  });
-}
-async function executeAction(ctx) {
-  const { action: action2, handler, setState, navigate, executeAction: executeAction2 } = ctx;
-  try {
-    await handler(action2.params);
-    if (action2.onSuccess) {
-      if ("navigate" in action2.onSuccess && navigate) {
-        navigate(action2.onSuccess.navigate);
-      } else if ("set" in action2.onSuccess) {
-        for (const [path, value] of Object.entries(action2.onSuccess.set)) {
-          setState(path, value);
-        }
-      } else if ("action" in action2.onSuccess && executeAction2) {
-        await executeAction2(action2.onSuccess.action);
-      }
-    }
-  } catch (error) {
-    if (action2.onError) {
-      if ("set" in action2.onError) {
-        for (const [path, value] of Object.entries(action2.onError.set)) {
-          const resolvedValue = typeof value === "string" && value === "$error.message" ? error.message : value;
-          setState(path, resolvedValue);
-        }
-      } else if ("action" in action2.onError && executeAction2) {
-        await executeAction2(action2.onError.action);
-      }
-    } else {
-      throw error;
-    }
-  }
-}
-var actionBinding = {
-  /** Create a simple action binding */
-  simple: (actionName, params) => ({
-    action: actionName,
-    params
-  }),
-  /** Create an action binding with confirmation */
-  withConfirm: (actionName, confirm, params) => ({
-    action: actionName,
-    params,
-    confirm
-  }),
-  /** Create an action binding with success handler */
-  withSuccess: (actionName, onSuccess, params) => ({
-    action: actionName,
-    params,
-    onSuccess
-  })
-};
-var action = actionBinding;
-
-// src/validation.ts
-var import_zod4 = require("zod");
-var ValidationCheckSchema = import_zod4.z.object({
-  type: import_zod4.z.string(),
-  args: import_zod4.z.record(import_zod4.z.string(), DynamicValueSchema).optional(),
-  message: import_zod4.z.string()
-});
-var ValidationConfigSchema = import_zod4.z.object({
-  checks: import_zod4.z.array(ValidationCheckSchema).optional(),
-  validateOn: import_zod4.z.enum(["change", "blur", "submit"]).optional(),
-  enabled: VisibilityConditionSchema.optional()
-});
-var matchesImpl = (value, args) => {
-  const other = args?.other;
-  return value === other;
-};
-var builtInValidationFunctions = {
-  /**
-   * Check if value is not null, undefined, or empty string
-   */
-  required: (value) => {
-    if (value === null || value === void 0) return false;
-    if (typeof value === "string") return value.trim().length > 0;
-    if (Array.isArray(value)) return value.length > 0;
-    return true;
-  },
-  /**
-   * Check if value is a valid email address
-   */
-  email: (value) => {
-    if (typeof value !== "string") return false;
-    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-  },
-  /**
-   * Check minimum string length
-   */
-  minLength: (value, args) => {
-    if (typeof value !== "string") return false;
-    const min = args?.min;
-    if (typeof min !== "number") return false;
-    return value.length >= min;
-  },
-  /**
-   * Check maximum string length
-   */
-  maxLength: (value, args) => {
-    if (typeof value !== "string") return false;
-    const max = args?.max;
-    if (typeof max !== "number") return false;
-    return value.length <= max;
-  },
-  /**
-   * Check if string matches a regex pattern
-   */
-  pattern: (value, args) => {
-    if (typeof value !== "string") return false;
-    const pattern = args?.pattern;
-    if (typeof pattern !== "string") return false;
-    try {
-      return new RegExp(pattern).test(value);
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Check minimum numeric value
-   */
-  min: (value, args) => {
-    if (typeof value !== "number") return false;
-    const min = args?.min;
-    if (typeof min !== "number") return false;
-    return value >= min;
-  },
-  /**
-   * Check maximum numeric value
-   */
-  max: (value, args) => {
-    if (typeof value !== "number") return false;
-    const max = args?.max;
-    if (typeof max !== "number") return false;
-    return value <= max;
-  },
-  /**
-   * Check if value is a number
-   */
-  numeric: (value) => {
-    if (typeof value === "number") return !isNaN(value);
-    if (typeof value === "string") return !isNaN(parseFloat(value));
-    return false;
-  },
-  /**
-   * Check if value is a valid URL
-   */
-  url: (value) => {
-    if (typeof value !== "string") return false;
-    try {
-      new URL(value);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Check if value matches another field
-   */
-  matches: matchesImpl,
-  /**
-   * Alias for matches with a more descriptive name for cross-field equality
-   */
-  equalTo: matchesImpl,
-  /**
-   * Check if value is less than another field's value.
-   * Supports numbers, strings (useful for ISO date comparison), and
-   * cross-type numeric coercion (e.g. string "3" vs number 5).
-   */
-  lessThan: (value, args) => {
-    const other = args?.other;
-    if (value == null || other == null || value === "" || other === "")
-      return false;
-    if (typeof value === "number" && typeof other === "number")
-      return value < other;
-    if (typeof value === "string" && typeof other === "string")
-      return value < other;
-    const numVal = Number(value);
-    const numOther = Number(other);
-    if (!isNaN(numVal) && !isNaN(numOther)) return numVal < numOther;
-    return false;
-  },
-  /**
-   * Check if value is greater than another field's value.
-   * Supports numbers, strings (useful for ISO date comparison), and
-   * cross-type numeric coercion (e.g. string "7" vs number 5).
-   */
-  greaterThan: (value, args) => {
-    const other = args?.other;
-    if (value == null || other == null || value === "" || other === "")
-      return false;
-    if (typeof value === "number" && typeof other === "number")
-      return value > other;
-    if (typeof value === "string" && typeof other === "string")
-      return value > other;
-    const numVal = Number(value);
-    const numOther = Number(other);
-    if (!isNaN(numVal) && !isNaN(numOther)) return numVal > numOther;
-    return false;
-  },
-  /**
-   * Required only when a condition is met.
-   * Uses JS truthiness: 0, false, "", null, and undefined are all
-   * treated as "condition not met" (field not required), matching
-   * the visibility system's bare-condition semantics.
-   */
-  requiredIf: (value, args) => {
-    const condition = args?.field;
-    if (!condition) return true;
-    if (value === null || value === void 0) return false;
-    if (typeof value === "string") return value.trim().length > 0;
-    if (Array.isArray(value)) return value.length > 0;
-    return true;
-  }
-};
-function runValidationCheck(check2, ctx) {
-  const { value, stateModel, customFunctions } = ctx;
-  const resolvedArgs = {};
-  if (check2.args) {
-    for (const [key, argValue] of Object.entries(check2.args)) {
-      resolvedArgs[key] = resolvePropValue(argValue, { stateModel });
-    }
-  }
-  const validationFn = builtInValidationFunctions[check2.type] ?? customFunctions?.[check2.type];
-  if (!validationFn) {
-    console.warn(`Unknown validation function: ${check2.type}`);
-    return {
-      type: check2.type,
-      valid: true,
-      // Don't fail on unknown functions
-      message: check2.message
-    };
-  }
-  const valid = validationFn(value, resolvedArgs);
-  return {
-    type: check2.type,
-    valid,
-    message: check2.message
-  };
-}
-function runValidation(config, ctx) {
-  const checks = [];
-  const errors = [];
-  if (config.enabled) {
-    const enabled = evaluateVisibility(config.enabled, {
-      stateModel: ctx.stateModel
-    });
-    if (!enabled) {
-      return { valid: true, errors: [], checks: [] };
-    }
-  }
-  if (config.checks) {
-    for (const check2 of config.checks) {
-      const result = runValidationCheck(check2, ctx);
-      checks.push(result);
-      if (!result.valid) {
-        errors.push(result.message);
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    checks
-  };
-}
-var check = {
-  required: (message = "This field is required") => ({
-    type: "required",
-    message
-  }),
-  email: (message = "Invalid email address") => ({
-    type: "email",
-    message
-  }),
-  minLength: (min, message) => ({
-    type: "minLength",
-    args: { min },
-    message: message ?? `Must be at least ${min} characters`
-  }),
-  maxLength: (max, message) => ({
-    type: "maxLength",
-    args: { max },
-    message: message ?? `Must be at most ${max} characters`
-  }),
-  pattern: (pattern, message = "Invalid format") => ({
-    type: "pattern",
-    args: { pattern },
-    message
-  }),
-  min: (min, message) => ({
-    type: "min",
-    args: { min },
-    message: message ?? `Must be at least ${min}`
-  }),
-  max: (max, message) => ({
-    type: "max",
-    args: { max },
-    message: message ?? `Must be at most ${max}`
-  }),
-  url: (message = "Invalid URL") => ({
-    type: "url",
-    message
-  }),
-  numeric: (message = "Must be a number") => ({
-    type: "numeric",
-    message
-  }),
-  matches: (otherPath, message = "Fields must match") => ({
-    type: "matches",
-    args: { other: { $state: otherPath } },
-    message
-  }),
-  equalTo: (otherPath, message = "Fields must match") => ({
-    type: "equalTo",
-    args: { other: { $state: otherPath } },
-    message
-  }),
-  lessThan: (otherPath, message) => ({
-    type: "lessThan",
-    args: { other: { $state: otherPath } },
-    message: message ?? "Must be less than the compared field"
-  }),
-  greaterThan: (otherPath, message) => ({
-    type: "greaterThan",
-    args: { other: { $state: otherPath } },
-    message: message ?? "Must be greater than the compared field"
-  }),
-  requiredIf: (fieldPath, message = "This field is required") => ({
-    type: "requiredIf",
-    args: { field: { $state: fieldPath } },
-    message
-  })
-};
-
-// src/spec-validator.ts
-function validateSpec(spec, options = {}) {
-  const { checkOrphans = false } = options;
-  const issues = [];
-  if (!spec.root) {
-    issues.push({
-      severity: "error",
-      message: "Spec has no root element defined.",
-      code: "missing_root"
-    });
-    return { valid: false, issues };
-  }
-  if (!spec.elements[spec.root]) {
-    issues.push({
-      severity: "error",
-      message: `Root element "${spec.root}" not found in elements map.`,
-      code: "root_not_found"
-    });
-  }
-  if (Object.keys(spec.elements).length === 0) {
-    issues.push({
-      severity: "error",
-      message: "Spec has no elements.",
-      code: "empty_spec"
-    });
-    return { valid: false, issues };
-  }
-  for (const [key, element] of Object.entries(spec.elements)) {
-    if (element.children) {
-      for (const childKey of element.children) {
-        if (!spec.elements[childKey]) {
-          issues.push({
-            severity: "error",
-            message: `Element "${key}" references child "${childKey}" which does not exist in the elements map.`,
-            elementKey: key,
-            code: "missing_child"
-          });
-        }
-      }
-    }
-    const props = element.props;
-    if (props && "visible" in props && props.visible !== void 0) {
-      issues.push({
-        severity: "error",
-        message: `Element "${key}" has "visible" inside "props". It should be a top-level field on the element (sibling of type/props/children).`,
-        elementKey: key,
-        code: "visible_in_props"
-      });
-    }
-    if (props && "on" in props && props.on !== void 0) {
-      issues.push({
-        severity: "error",
-        message: `Element "${key}" has "on" inside "props". It should be a top-level field on the element (sibling of type/props/children).`,
-        elementKey: key,
-        code: "on_in_props"
-      });
-    }
-    if (props && "repeat" in props && props.repeat !== void 0) {
-      issues.push({
-        severity: "error",
-        message: `Element "${key}" has "repeat" inside "props". It should be a top-level field on the element (sibling of type/props/children).`,
-        elementKey: key,
-        code: "repeat_in_props"
-      });
-    }
-    if (props && "watch" in props && props.watch !== void 0) {
-      issues.push({
-        severity: "error",
-        message: `Element "${key}" has "watch" inside "props". It should be a top-level field on the element (sibling of type/props/children).`,
-        elementKey: key,
-        code: "watch_in_props"
-      });
-    }
-  }
-  if (checkOrphans) {
-    const reachable = /* @__PURE__ */ new Set();
-    const walk = (key) => {
-      if (reachable.has(key)) return;
-      reachable.add(key);
-      const el = spec.elements[key];
-      if (el?.children) {
-        for (const childKey of el.children) {
-          if (spec.elements[childKey]) {
-            walk(childKey);
-          }
-        }
-      }
-    };
-    if (spec.elements[spec.root]) {
-      walk(spec.root);
-    }
-    for (const key of Object.keys(spec.elements)) {
-      if (!reachable.has(key)) {
-        issues.push({
-          severity: "warning",
-          message: `Element "${key}" is not reachable from root "${spec.root}".`,
-          elementKey: key,
-          code: "orphaned_element"
-        });
-      }
-    }
-  }
-  const hasErrors = issues.some((i) => i.severity === "error");
-  return { valid: !hasErrors, issues };
-}
-function autoFixSpec(spec) {
-  const fixes = [];
-  const fixedElements = {};
-  for (const [key, element] of Object.entries(spec.elements)) {
-    const props = element.props;
-    let fixed = element;
-    if (props && "visible" in props && props.visible !== void 0) {
-      const { visible, ...restProps } = fixed.props;
-      fixed = {
-        ...fixed,
-        props: restProps,
-        visible
-      };
-      fixes.push(`Moved "visible" from props to element level on "${key}".`);
-    }
-    let currentProps = fixed.props;
-    if (currentProps && "on" in currentProps && currentProps.on !== void 0) {
-      const { on, ...restProps } = currentProps;
-      fixed = {
-        ...fixed,
-        props: restProps,
-        on
-      };
-      fixes.push(`Moved "on" from props to element level on "${key}".`);
-    }
-    currentProps = fixed.props;
-    if (currentProps && "repeat" in currentProps && currentProps.repeat !== void 0) {
-      const { repeat, ...restProps } = currentProps;
-      fixed = {
-        ...fixed,
-        props: restProps,
-        repeat
-      };
-      fixes.push(`Moved "repeat" from props to element level on "${key}".`);
-    }
-    currentProps = fixed.props;
-    if (currentProps && "watch" in currentProps && currentProps.watch !== void 0) {
-      const { watch, ...restProps } = currentProps;
-      fixed = {
-        ...fixed,
-        props: restProps,
-        watch
-      };
-      fixes.push(`Moved "watch" from props to element level on "${key}".`);
-    }
-    fixedElements[key] = fixed;
-  }
-  return {
-    spec: { root: spec.root, elements: fixedElements, state: spec.state },
-    fixes
-  };
-}
-function formatSpecIssues(issues) {
-  const errors = issues.filter((i) => i.severity === "error");
-  if (errors.length === 0) return "";
-  const lines = ["The generated UI spec has the following errors:"];
-  for (const issue of errors) {
-    lines.push(`- ${issue.message}`);
-  }
-  return lines.join("\n");
-}
-
-// src/schema.ts
-var import_zod5 = require("zod");
-
-// src/edit-modes.ts
-var DEFAULT_MODES = ["patch"];
-function normalizeModes(config) {
-  if (!config?.modes?.length) return DEFAULT_MODES;
-  return config.modes;
-}
-function jsonPatchInstructions() {
-  return [
-    "PATCH MODE (RFC 6902 JSON Patch):",
-    "Output one JSON object per line. Each line is a patch operation.",
-    '- Add: {"op":"add","path":"/elements/new-key","value":{...}}',
-    '- Replace: {"op":"replace","path":"/elements/existing-key","value":{...}}',
-    '- Remove: {"op":"remove","path":"/elements/old-key"}',
-    "Only output patches for what needs to change."
-  ].join("\n");
-}
-function jsonMergeInstructions() {
-  return [
-    "MERGE MODE (RFC 7396 JSON Merge Patch):",
-    "Output a single JSON object on one line with __json_edit set to true.",
-    "Include only the keys that changed. Unmentioned keys are preserved.",
-    "Set a key to null to delete it.",
-    "",
-    "Example (update a title and add an element):",
-    '{"__json_edit":true,"elements":{"main":{"props":{"title":"New Title"}},"new-el":{"type":"Card","props":{},"children":[]}}}',
-    "",
-    "Example (delete an element):",
-    '{"__json_edit":true,"elements":{"old-widget":null}}'
-  ].join("\n");
-}
-function jsonDiffInstructions() {
-  return [
-    "DIFF MODE (unified diff):",
-    "Output a unified diff inside a ```diff code fence.",
-    "The diff applies against the JSON-serialized current spec.",
-    "",
-    "Example:",
-    "```diff",
-    "--- a/spec.json",
-    "+++ b/spec.json",
-    "@@ -3,1 +3,1 @@",
-    '-      "title": "Login"',
-    '+      "title": "Welcome Back"',
-    "```"
-  ].join("\n");
-}
-function yamlPatchInstructions() {
-  return [
-    "PATCH MODE (RFC 6902 JSON Patch):",
-    "Output RFC 6902 JSON Patch lines inside a ```yaml-patch code fence.",
-    "Each line is one JSON patch operation.",
-    "",
-    "Example:",
-    "```yaml-patch",
-    '{"op":"replace","path":"/elements/main/props/title","value":"New Title"}',
-    '{"op":"add","path":"/elements/new-el","value":{"type":"Card","props":{},"children":[]}}',
-    "```"
-  ].join("\n");
-}
-function yamlMergeInstructions() {
-  return [
-    "MERGE MODE (RFC 7396 JSON Merge Patch):",
-    "Output only the changed parts in a ```yaml-edit code fence.",
-    "Uses deep merge semantics: only keys you include are updated. Unmentioned elements and props are preserved.",
-    "Set a key to null to delete it.",
-    "",
-    "Example edit (update title, add a new element):",
-    "```yaml-edit",
-    "elements:",
-    "  main:",
-    "    props:",
-    "      title: Updated Title",
-    "  new-chart:",
-    "    type: Card",
-    "    props: {}",
-    "    children: []",
-    "```",
-    "",
-    "Example deletion:",
-    "```yaml-edit",
-    "elements:",
-    "  old-widget: null",
-    "```"
-  ].join("\n");
-}
-function yamlDiffInstructions() {
-  return [
-    "DIFF MODE (unified diff):",
-    "Output a unified diff inside a ```diff code fence.",
-    "The diff applies against the YAML-serialized current spec.",
-    "",
-    "Example:",
-    "```diff",
-    "--- a/spec.yaml",
-    "+++ b/spec.yaml",
-    "@@ -6,1 +6,1 @@",
-    "-      title: Login",
-    "+      title: Welcome Back",
-    "```"
-  ].join("\n");
-}
-function modeSelectionGuidance(modes) {
-  if (modes.length === 1) return "";
-  const parts = ["Choose the best edit strategy for the requested change:"];
-  if (modes.includes("patch")) {
-    parts.push("- PATCH: best for precise, targeted single-field updates");
-  }
-  if (modes.includes("merge")) {
-    parts.push(
-      "- MERGE: best for structural changes (add/remove elements, reparent children, update multiple props at once)"
-    );
-  }
-  if (modes.includes("diff")) {
-    parts.push(
-      "- DIFF: best for small text-level changes when you can see the exact lines to change"
-    );
-  }
-  return parts.join("\n");
-}
-function buildEditInstructions(config, format) {
-  const modes = normalizeModes(config);
-  const sections = [];
-  sections.push("EDITING EXISTING SPECS:");
-  sections.push("");
-  const guidance = modeSelectionGuidance(modes);
-  if (guidance) {
-    sections.push(guidance);
-    sections.push("");
-  }
-  for (const mode of modes) {
-    if (format === "json") {
-      switch (mode) {
-        case "patch":
-          sections.push(jsonPatchInstructions());
-          break;
-        case "merge":
-          sections.push(jsonMergeInstructions());
-          break;
-        case "diff":
-          sections.push(jsonDiffInstructions());
-          break;
-      }
-    } else {
-      switch (mode) {
-        case "patch":
-          sections.push(yamlPatchInstructions());
-          break;
-        case "merge":
-          sections.push(yamlMergeInstructions());
-          break;
-        case "diff":
-          sections.push(yamlDiffInstructions());
-          break;
-      }
-    }
-    sections.push("");
-  }
-  return sections.join("\n");
-}
-function addLineNumbers(text) {
-  const lines = text.split("\n");
-  const width = String(lines.length).length;
-  return lines.map((line, i) => `${String(i + 1).padStart(width)}| ${line}`).join("\n");
-}
-function isNonEmptySpec(spec) {
-  if (!spec || typeof spec !== "object") return false;
-  const s = spec;
-  return typeof s.root === "string" && typeof s.elements === "object" && s.elements !== null && Object.keys(s.elements).length > 0;
-}
-function buildEditUserPrompt(options) {
-  const { prompt, currentSpec, config, format, maxPromptLength, serializer } = options;
-  let userText = String(prompt || "");
-  if (maxPromptLength !== void 0 && maxPromptLength > 0) {
-    userText = userText.slice(0, maxPromptLength);
-  }
-  if (!isNonEmptySpec(currentSpec)) {
-    return userText;
-  }
-  const modes = normalizeModes(config);
-  const showLineNumbers = modes.includes("diff");
-  const serialize = serializer ?? ((s) => JSON.stringify(s, null, 2));
-  const specText = serialize(currentSpec);
-  const parts = [];
-  if (showLineNumbers) {
-    parts.push("CURRENT UI STATE (line numbers for reference):");
-    parts.push("```");
-    parts.push(addLineNumbers(specText));
-    parts.push("```");
-  } else {
-    parts.push(
-      "CURRENT UI STATE (already loaded, DO NOT recreate existing elements):"
-    );
-    parts.push("```");
-    parts.push(specText);
-    parts.push("```");
-  }
-  parts.push("");
-  parts.push(`USER REQUEST: ${userText}`);
-  parts.push("");
-  if (modes.length === 1) {
-    const mode = modes[0];
-    switch (mode) {
-      case "patch":
-        parts.push(
-          format === "yaml" ? "Output ONLY the patches in a ```yaml-patch fence." : "Output ONLY the JSON Patch lines needed for the change."
-        );
-        break;
-      case "merge":
-        parts.push(
-          format === "yaml" ? "Output ONLY the changes in a ```yaml-edit fence. Include only keys that need to change." : "Output ONLY a single JSON merge line with __json_edit set to true. Include only keys that need to change."
-        );
-        break;
-      case "diff":
-        parts.push("Output ONLY the unified diff in a ```diff fence.");
-        break;
-    }
-  } else {
-    const modeNames = modes.map((m) => {
-      switch (m) {
-        case "patch":
-          return format === "yaml" ? "```yaml-patch fence" : "JSON Patch lines";
-        case "merge":
-          return format === "yaml" ? "```yaml-edit fence" : "JSON merge line (__json_edit)";
-        case "diff":
-          return "```diff fence";
-      }
-    });
-    parts.push(
-      `Choose the best edit strategy and output using one of: ${modeNames.join(", ")}`
-    );
-  }
-  return parts.join("\n");
-}
-
-// src/schema.ts
-function createBuilder() {
-  return {
-    string: () => ({ kind: "string" }),
-    number: () => ({ kind: "number" }),
-    boolean: () => ({ kind: "boolean" }),
-    array: (item) => ({ kind: "array", inner: item }),
-    object: (shape) => ({ kind: "object", inner: shape }),
-    record: (value) => ({ kind: "record", inner: value }),
-    any: () => ({ kind: "any" }),
-    zod: () => ({ kind: "zod" }),
-    ref: (path) => ({ kind: "ref", inner: path }),
-    propsOf: (path) => ({ kind: "propsOf", inner: path }),
-    map: (entryShape) => ({ kind: "map", inner: entryShape }),
-    optional: () => ({ optional: true })
-  };
-}
-function defineSchema(builder, options) {
-  const s = createBuilder();
-  const definition = builder(s);
-  return {
-    definition,
-    promptTemplate: options?.promptTemplate,
-    defaultRules: options?.defaultRules,
-    builtInActions: options?.builtInActions,
-    createCatalog(catalog) {
-      return createCatalogFromSchema(this, catalog);
-    }
-  };
-}
-function createCatalogFromSchema(schema, catalogData) {
-  const components = catalogData.components;
-  const actions = catalogData.actions;
-  const componentNames = components ? Object.keys(components) : [];
-  const actionNames = actions ? Object.keys(actions) : [];
-  const zodSchema = buildZodSchemaFromDefinition(
-    schema.definition,
-    catalogData
-  );
-  return {
-    schema,
-    data: catalogData,
-    componentNames,
-    actionNames,
-    prompt(options = {}) {
-      return generatePrompt(this, options);
-    },
-    jsonSchema(options = {}) {
-      return zodToJsonSchema(zodSchema, options.strict ?? false);
-    },
-    validate(spec) {
-      const result = zodSchema.safeParse(spec);
-      if (result.success) {
-        return {
-          success: true,
-          data: result.data
-        };
-      }
-      return { success: false, error: result.error };
-    },
-    zodSchema() {
-      return zodSchema;
-    },
-    get _specType() {
-      throw new Error("_specType is only for type inference");
-    }
-  };
-}
-function buildZodSchemaFromDefinition(definition, catalogData) {
-  return buildZodType(definition.spec, catalogData);
-}
-function buildZodType(schemaType, catalogData) {
-  switch (schemaType.kind) {
-    case "string":
-      return import_zod5.z.string();
-    case "number":
-      return import_zod5.z.number();
-    case "boolean":
-      return import_zod5.z.boolean();
-    case "any":
-      return import_zod5.z.any();
-    case "array": {
-      const inner = buildZodType(schemaType.inner, catalogData);
-      return import_zod5.z.array(inner);
-    }
-    case "object": {
-      const shape = schemaType.inner;
-      const zodShape = {};
-      for (const [key, value] of Object.entries(shape)) {
-        let zodType = buildZodType(value, catalogData);
-        if (value.optional) {
-          zodType = zodType.optional();
-        }
-        zodShape[key] = zodType;
-      }
-      return import_zod5.z.object(zodShape);
-    }
-    case "record": {
-      const inner = buildZodType(schemaType.inner, catalogData);
-      return import_zod5.z.record(import_zod5.z.string(), inner);
-    }
-    case "ref": {
-      const path = schemaType.inner;
-      const keys = getKeysFromPath(path, catalogData);
-      if (keys.length === 0) {
-        return import_zod5.z.string();
-      }
-      if (keys.length === 1) {
-        return import_zod5.z.literal(keys[0]);
-      }
-      return import_zod5.z.enum(keys);
-    }
-    case "propsOf": {
-      const path = schemaType.inner;
-      const propsSchemas = getPropsFromPath(path, catalogData);
-      if (propsSchemas.length === 0) {
-        return import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown());
-      }
-      if (propsSchemas.length === 1) {
-        return propsSchemas[0];
-      }
-      return import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown());
-    }
-    default:
-      return import_zod5.z.unknown();
-  }
-}
-function getKeysFromPath(path, catalogData) {
-  const parts = path.split(".");
-  let current = { catalog: catalogData };
-  for (const part of parts) {
-    if (current && typeof current === "object") {
-      current = current[part];
-    } else {
-      return [];
-    }
-  }
-  if (current && typeof current === "object") {
-    return Object.keys(current);
-  }
-  return [];
-}
-function getPropsFromPath(path, catalogData) {
-  const parts = path.split(".");
-  let current = { catalog: catalogData };
-  for (const part of parts) {
-    if (current && typeof current === "object") {
-      current = current[part];
-    } else {
-      return [];
-    }
-  }
-  if (current && typeof current === "object") {
-    return Object.values(current).map((entry) => entry.props).filter((props) => props !== void 0);
-  }
-  return [];
-}
-function generatePrompt(catalog, options) {
-  if (catalog.schema.promptTemplate) {
-    const context = {
-      catalog: catalog.data,
-      componentNames: catalog.componentNames,
-      actionNames: catalog.actionNames,
-      options,
-      formatZodType
-    };
-    return catalog.schema.promptTemplate(context);
-  }
-  const {
-    system = "You are a UI generator that outputs JSON.",
-    customRules = [],
-    mode: rawMode = "standalone"
-  } = options;
-  const mode = rawMode === "chat" ? (console.warn(
-    '[json-render] mode "chat" is deprecated, use "inline" instead'
-  ), "inline") : rawMode === "generate" ? (console.warn(
-    '[json-render] mode "generate" is deprecated, use "standalone" instead'
-  ), "standalone") : rawMode;
-  const lines = [];
-  lines.push(system);
-  lines.push("");
-  if (mode === "inline") {
-    lines.push("OUTPUT FORMAT (text + JSONL, RFC 6902 JSON Patch):");
-    lines.push(
-      "You respond conversationally. When generating UI, first write a brief explanation (1-3 sentences), then output JSONL patch lines wrapped in a ```spec code fence."
-    );
-    lines.push(
-      "The JSONL lines use RFC 6902 JSON Patch operations to build a UI tree. Always wrap them in a ```spec fence block:"
-    );
-    lines.push("  ```spec");
-    lines.push('  {"op":"add","path":"/root","value":"main"}');
-    lines.push(
-      '  {"op":"add","path":"/elements/main","value":{"type":"Card","props":{"title":"Hello"},"children":[]}}'
-    );
-    lines.push("  ```");
-    lines.push(
-      "If the user's message does not require a UI (e.g. a greeting or clarifying question), respond with text only \u2014 no JSONL."
-    );
-  } else {
-    lines.push("OUTPUT FORMAT (JSONL, RFC 6902 JSON Patch):");
-    lines.push(
-      "Output JSONL (one JSON object per line) using RFC 6902 JSON Patch operations to build a UI tree."
-    );
-  }
-  lines.push(
-    "Each line is a JSON patch operation (add, remove, replace). Start with /root, then stream /elements and /state patches interleaved so the UI fills in progressively as it streams."
-  );
-  lines.push("");
-  lines.push("Example output (each line is a separate JSON object):");
-  lines.push("");
-  const allComponents = catalog.data.components;
-  const cn = catalog.componentNames;
-  const comp1 = cn[0] || "Component";
-  const comp2 = cn.length > 1 ? cn[1] : comp1;
-  const comp1Def = allComponents?.[comp1];
-  const comp2Def = allComponents?.[comp2];
-  const comp1Props = comp1Def ? getExampleProps(comp1Def) : {};
-  const comp2Props = comp2Def ? getExampleProps(comp2Def) : {};
-  const dynamicPropName = comp2Def?.props ? findFirstStringProp(comp2Def.props) : null;
-  const dynamicProps = dynamicPropName ? { ...comp2Props, [dynamicPropName]: { $item: "title" } } : comp2Props;
-  const exampleOutput = [
-    JSON.stringify({ op: "add", path: "/root", value: "main" }),
-    JSON.stringify({
-      op: "add",
-      path: "/elements/main",
-      value: {
-        type: comp1,
-        props: comp1Props,
-        children: ["child-1", "list"]
-      }
-    }),
-    JSON.stringify({
-      op: "add",
-      path: "/elements/child-1",
-      value: { type: comp2, props: comp2Props, children: [] }
-    }),
-    JSON.stringify({
-      op: "add",
-      path: "/elements/list",
-      value: {
-        type: comp1,
-        props: comp1Props,
-        repeat: { statePath: "/items", key: "id" },
-        children: ["item"]
-      }
-    }),
-    JSON.stringify({
-      op: "add",
-      path: "/elements/item",
-      value: { type: comp2, props: dynamicProps, children: [] }
-    }),
-    JSON.stringify({ op: "add", path: "/state/items", value: [] }),
-    JSON.stringify({
-      op: "add",
-      path: "/state/items/0",
-      value: { id: "1", title: "First Item" }
-    }),
-    JSON.stringify({
-      op: "add",
-      path: "/state/items/1",
-      value: { id: "2", title: "Second Item" }
-    })
-  ].join("\n");
-  lines.push(`${exampleOutput}
-
-Note: state patches appear right after the elements that use them, so the UI fills in as it streams. ONLY use component types from the AVAILABLE COMPONENTS list below.`);
-  lines.push("");
-  lines.push("INITIAL STATE:");
-  lines.push(
-    "Specs include a /state field to seed the state model. Components with { $bindState } or { $bindItem } read from and write to this state, and $state expressions read from it."
-  );
-  lines.push(
-    "CRITICAL: You MUST include state patches whenever your UI displays data via $state, $bindState, $bindItem, $item, or $index expressions, or uses repeat to iterate over arrays. Without state, these references resolve to nothing and repeat lists render zero items."
-  );
-  lines.push(
-    "Output state patches right after the elements that reference them, so the UI fills in progressively as it streams."
-  );
-  lines.push(
-    "Stream state progressively - output one patch per array item instead of one giant blob:"
-  );
-  lines.push(
-    '  For arrays: {"op":"add","path":"/state/posts/0","value":{"id":"1","title":"First Post",...}} then /state/posts/1, /state/posts/2, etc.'
-  );
-  lines.push(
-    '  For scalars: {"op":"add","path":"/state/newTodoText","value":""}'
-  );
-  lines.push(
-    '  Initialize the array first if needed: {"op":"add","path":"/state/posts","value":[]}'
-  );
-  lines.push(
-    'When content comes from the state model, use { "$state": "/some/path" } dynamic props to display it instead of hardcoding the same value in both state and props. The state model is the single source of truth.'
-  );
-  lines.push(
-    "Include realistic sample data in state. For blogs: 3-4 posts with titles, excerpts, authors, dates. For product lists: 3-5 items with names, prices, descriptions. Never leave arrays empty."
-  );
-  lines.push("");
-  lines.push("DYNAMIC LISTS (repeat field):");
-  lines.push(
-    'Any element can have a top-level "repeat" field to render its children once per item in a state array: { "repeat": { "statePath": "/arrayPath", "key": "id" } }.'
-  );
-  lines.push(
-    'The element itself renders once (as the container), and its children are expanded once per array item. "statePath" is the state array path. "key" is an optional field name on each item for stable React keys.'
-  );
-  lines.push(
-    `Example: ${JSON.stringify({ type: comp1, props: comp1Props, repeat: { statePath: "/todos", key: "id" }, children: ["todo-item"] })}`
-  );
-  lines.push(
-    'Inside children of a repeated element, use { "$item": "field" } to read a field from the current item, and { "$index": true } to get the current array index. For two-way binding to an item field use { "$bindItem": "completed" } on the appropriate prop.'
-  );
-  lines.push(
-    "ALWAYS use the repeat field for lists backed by state arrays. NEVER hardcode individual elements for each array item."
-  );
-  lines.push(
-    'IMPORTANT: "repeat" is a top-level field on the element (sibling of type/props/children), NOT inside props.'
-  );
-  lines.push("");
-  lines.push("ARRAY STATE ACTIONS:");
-  lines.push(
-    'Use action "pushState" to append items to arrays. Params: { statePath: "/arrayPath", value: { ...item }, clearStatePath: "/inputPath" }.'
-  );
-  lines.push(
-    'Values inside pushState can contain { "$state": "/statePath" } references to read current state (e.g. the text from an input field).'
-  );
-  lines.push(
-    'Use "$id" inside a pushState value to auto-generate a unique ID.'
-  );
-  lines.push(
-    'Example: on: { "press": { "action": "pushState", "params": { "statePath": "/todos", "value": { "id": "$id", "title": { "$state": "/newTodoText" }, "completed": false }, "clearStatePath": "/newTodoText" } } }'
-  );
-  lines.push(
-    `Use action "removeState" to remove items from arrays by index. Params: { statePath: "/arrayPath", index: N }. Inside a repeated element's children, use { "$index": true } for the current item index. Action params support the same expressions as props: { "$item": "field" } resolves to the absolute state path, { "$index": true } resolves to the index number, and { "$state": "/path" } reads a value from state.`
-  );
-  lines.push(
-    "For lists where users can add/remove items (todos, carts, etc.), use pushState and removeState instead of hardcoding with setState."
-  );
-  lines.push("");
-  lines.push(
-    'IMPORTANT: State paths use RFC 6901 JSON Pointer syntax (e.g. "/todos/0/title"). Do NOT use JavaScript-style dot notation (e.g. "/todos.length" is WRONG). To generate unique IDs for new items, use "$id" instead of trying to read array length.'
-  );
-  lines.push("");
-  const components = allComponents;
-  if (components) {
-    lines.push(`AVAILABLE COMPONENTS (${catalog.componentNames.length}):`);
-    lines.push("");
-    for (const [name, def] of Object.entries(components)) {
-      const propsStr = def.props ? formatZodType(def.props) : "{}";
-      const hasChildren = def.slots && def.slots.length > 0;
-      const childrenStr = hasChildren ? " [accepts children]" : "";
-      const eventsStr = def.events && def.events.length > 0 ? ` [events: ${def.events.join(", ")}]` : "";
-      const descStr = def.description ? ` - ${def.description}` : "";
-      lines.push(`- ${name}: ${propsStr}${descStr}${childrenStr}${eventsStr}`);
-    }
-    lines.push("");
-  }
-  const actions = catalog.data.actions;
-  const builtInActions = catalog.schema.builtInActions ?? [];
-  const hasCustomActions = actions && catalog.actionNames.length > 0;
-  const hasBuiltInActions = builtInActions.length > 0;
-  if (hasCustomActions || hasBuiltInActions) {
-    lines.push("AVAILABLE ACTIONS:");
-    lines.push("");
-    for (const action2 of builtInActions) {
-      lines.push(`- ${action2.name}: ${action2.description} [built-in]`);
-    }
-    if (hasCustomActions) {
-      for (const [name, def] of Object.entries(actions)) {
-        lines.push(`- ${name}${def.description ? `: ${def.description}` : ""}`);
-      }
-    }
-    lines.push("");
-  }
-  lines.push("EVENTS (the `on` field):");
-  lines.push(
-    "Elements can have an optional `on` field to bind events to actions. The `on` field is a top-level field on the element (sibling of type/props/children), NOT inside props."
-  );
-  lines.push(
-    'Each key in `on` is an event name (from the component\'s supported events), and the value is an action binding: `{ "action": "<actionName>", "params": { ... } }`.'
-  );
-  lines.push("");
-  lines.push("Example:");
-  lines.push(
-    `  ${JSON.stringify({ type: comp1, props: comp1Props, on: { press: { action: "setState", params: { statePath: "/saved", value: true } } }, children: [] })}`
-  );
-  lines.push("");
-  lines.push(
-    'Action params can use dynamic references to read from state: { "$state": "/statePath" }.'
-  );
-  lines.push(
-    "IMPORTANT: Do NOT put action/actionParams inside props. Always use the `on` field for event bindings."
-  );
-  lines.push("");
-  lines.push("VISIBILITY CONDITIONS:");
-  lines.push(
-    "Elements can have an optional `visible` field to conditionally show/hide based on state. IMPORTANT: `visible` is a top-level field on the element object (sibling of type/props/children), NOT inside props."
-  );
-  lines.push(
-    `Correct: ${JSON.stringify({ type: comp1, props: comp1Props, visible: { $state: "/activeTab", eq: "home" }, children: ["..."] })}`
-  );
-  lines.push(
-    '- `{ "$state": "/path" }` - visible when state at path is truthy'
-  );
-  lines.push(
-    '- `{ "$state": "/path", "not": true }` - visible when state at path is falsy'
-  );
-  lines.push(
-    '- `{ "$state": "/path", "eq": "value" }` - visible when state equals value'
-  );
-  lines.push(
-    '- `{ "$state": "/path", "neq": "value" }` - visible when state does not equal value'
-  );
-  lines.push(
-    '- `{ "$state": "/path", "gt": N }` / `gte` / `lt` / `lte` - numeric comparisons'
-  );
-  lines.push(
-    "- Use ONE operator per condition (eq, neq, gt, gte, lt, lte). Do not combine multiple operators."
-  );
-  lines.push('- Any condition can add `"not": true` to invert its result');
-  lines.push(
-    "- `[condition, condition]` - all conditions must be true (implicit AND)"
-  );
-  lines.push(
-    '- `{ "$and": [condition, condition] }` - explicit AND (use when nesting inside $or)'
-  );
-  lines.push(
-    '- `{ "$or": [condition, condition] }` - at least one must be true (OR)'
-  );
-  lines.push("- `true` / `false` - always visible/hidden");
-  lines.push("");
-  lines.push(
-    "Use a component with on.press bound to setState to update state and drive visibility."
-  );
-  lines.push(
-    `Example: A ${comp1} with on: { "press": { "action": "setState", "params": { "statePath": "/activeTab", "value": "home" } } } sets state, then a container with visible: { "$state": "/activeTab", "eq": "home" } shows only when that tab is active.`
-  );
-  lines.push("");
-  lines.push(
-    'For tab patterns where the first/default tab should be visible when no tab is selected yet, use $or to handle both cases: visible: { "$or": [{ "$state": "/activeTab", "eq": "home" }, { "$state": "/activeTab", "not": true }] }. This ensures the first tab is visible both when explicitly selected AND when /activeTab is not yet set.'
-  );
-  lines.push("");
-  lines.push("DYNAMIC PROPS:");
-  lines.push(
-    "Any prop value can be a dynamic expression that resolves based on state. Three forms are supported:"
-  );
-  lines.push("");
-  lines.push(
-    '1. Read-only state: `{ "$state": "/statePath" }` - resolves to the value at that state path (one-way read).'
-  );
-  lines.push(
-    '   Example: `"color": { "$state": "/theme/primary" }` reads the color from state.'
-  );
-  lines.push("");
-  lines.push(
-    '2. Two-way binding: `{ "$bindState": "/statePath" }` - resolves to the value at the state path AND enables write-back. Use on form input props (value, checked, pressed, etc.).'
-  );
-  lines.push(
-    '   Example: `"value": { "$bindState": "/form/email" }` binds the input value to /form/email.'
-  );
-  lines.push(
-    '   Inside repeat scopes: `"checked": { "$bindItem": "completed" }` binds to the current item\'s completed field.'
-  );
-  lines.push("");
-  lines.push(
-    '3. Conditional: `{ "$cond": <condition>, "$then": <value>, "$else": <value> }` - evaluates the condition (same syntax as visibility conditions) and picks the matching value.'
-  );
-  lines.push(
-    '   Example: `"color": { "$cond": { "$state": "/activeTab", "eq": "home" }, "$then": "#007AFF", "$else": "#8E8E93" }`'
-  );
-  lines.push("");
-  lines.push(
-    "Use $bindState for form inputs (text fields, checkboxes, selects, sliders, etc.) and $state for read-only data display. Inside repeat scopes, use $bindItem for form inputs bound to the current item. Use dynamic props instead of duplicating elements with opposing visible conditions when only prop values differ."
-  );
-  lines.push("");
-  lines.push(
-    '4. Template: `{ "$template": "Hello, ${/name}!" }` - interpolates `${/path}` references in the string with values from the state model.'
-  );
-  lines.push(
-    '   Example: `"label": { "$template": "Items: ${/cart/count} | Total: ${/cart/total}" }` renders "Items: 3 | Total: 42.00" when /cart/count is 3 and /cart/total is 42.00.'
-  );
-  lines.push("");
-  const catalogFunctions = catalog.data.functions;
-  if (catalogFunctions && Object.keys(catalogFunctions).length > 0) {
-    lines.push(
-      '5. Computed: `{ "$computed": "<functionName>", "args": { "key": <expression> } }` - calls a registered function with resolved args and returns the result.'
-    );
-    lines.push(
-      '   Example: `"value": { "$computed": "fullName", "args": { "first": { "$state": "/form/firstName" }, "last": { "$state": "/form/lastName" } } }`'
-    );
-    lines.push("   Available functions:");
-    for (const name of Object.keys(
-      catalogFunctions
-    )) {
-      lines.push(`   - ${name}`);
-    }
-    lines.push("");
-  }
-  const hasChecksComponents = allComponents ? Object.entries(allComponents).some(([, def]) => {
-    if (!def.props) return false;
-    const formatted = formatZodType(def.props);
-    return formatted.includes("checks");
-  }) : false;
-  if (hasChecksComponents) {
-    lines.push("VALIDATION:");
-    lines.push(
-      "Form components that accept a `checks` prop support client-side validation."
-    );
-    lines.push(
-      'Each check is an object: { "type": "<name>", "message": "...", "args": { ... } }'
-    );
-    lines.push("");
-    lines.push("Built-in validation types:");
-    lines.push("  - required \u2014 value must be non-empty");
-    lines.push("  - email \u2014 valid email format");
-    lines.push('  - minLength \u2014 minimum string length (args: { "min": N })');
-    lines.push('  - maxLength \u2014 maximum string length (args: { "max": N })');
-    lines.push('  - pattern \u2014 match a regex (args: { "pattern": "regex" })');
-    lines.push('  - min \u2014 minimum numeric value (args: { "min": N })');
-    lines.push('  - max \u2014 maximum numeric value (args: { "max": N })');
-    lines.push("  - numeric \u2014 value must be a number");
-    lines.push("  - url \u2014 valid URL format");
-    lines.push(
-      '  - matches \u2014 must equal another field (args: { "other": { "$state": "/path" } })'
-    );
-    lines.push(
-      '  - equalTo \u2014 alias for matches (args: { "other": { "$state": "/path" } })'
-    );
-    lines.push(
-      '  - lessThan \u2014 value must be less than another field (args: { "other": { "$state": "/path" } })'
-    );
-    lines.push(
-      '  - greaterThan \u2014 value must be greater than another field (args: { "other": { "$state": "/path" } })'
-    );
-    lines.push(
-      '  - requiredIf \u2014 required only when another field is truthy (args: { "field": { "$state": "/path" } })'
-    );
-    lines.push("");
-    lines.push("Example:");
-    lines.push(
-      '  "checks": [{ "type": "required", "message": "Email is required" }, { "type": "email", "message": "Invalid email" }]'
-    );
-    lines.push("");
-    lines.push(
-      "IMPORTANT: When using checks, the component must also have a { $bindState } or { $bindItem } on its value/checked prop for two-way binding."
-    );
-    lines.push(
-      "Always include validation checks on form inputs for a good user experience (e.g. required, email, minLength)."
-    );
-    lines.push("");
-  }
-  if (hasCustomActions || hasBuiltInActions) {
-    lines.push("STATE WATCHERS:");
-    lines.push(
-      "Elements can have an optional `watch` field to react to state changes and trigger actions. The `watch` field is a top-level field on the element (sibling of type/props/children), NOT inside props."
-    );
-    lines.push(
-      "Maps state paths (JSON Pointers) to action bindings. When the value at a watched path changes, the bound actions fire automatically."
-    );
-    lines.push("");
-    lines.push(
-      "Example (cascading select \u2014 country changes trigger city loading):"
-    );
-    lines.push(
-      `  ${JSON.stringify({ type: "Select", props: { value: { $bindState: "/form/country" }, options: ["US", "Canada", "UK"] }, watch: { "/form/country": { action: "loadCities", params: { country: { $state: "/form/country" } } } }, children: [] })}`
-    );
-    lines.push("");
-    lines.push(
-      "Use `watch` for cascading dependencies where changing one field should trigger side effects (loading data, resetting dependent fields, computing derived values)."
-    );
-    lines.push(
-      "IMPORTANT: `watch` is a top-level field on the element (sibling of type/props/children), NOT inside props. Watchers only fire when the value changes, not on initial render."
-    );
-    lines.push("");
-  }
-  const editModes = options.editModes;
-  if (editModes && editModes.length > 0) {
-    lines.push(buildEditInstructions({ modes: editModes }, "json"));
-  }
-  lines.push("RULES:");
-  const baseRules = mode === "inline" ? [
-    "When generating UI, wrap all JSONL patches in a ```spec code fence - one JSON object per line inside the fence",
-    "Write a brief conversational response before any JSONL output",
-    'First set root: {"op":"add","path":"/root","value":"<root-key>"}',
-    'Then add each element: {"op":"add","path":"/elements/<key>","value":{...}}',
-    "Output /state patches right after the elements that use them, one per array item for progressive loading. REQUIRED whenever using $state, $bindState, $bindItem, $item, $index, or repeat.",
-    "ONLY use components listed above",
-    "Each element value needs: type, props, children (array of child keys)",
-    "Use unique keys for the element map entries (e.g., 'header', 'metric-1', 'chart-revenue')"
-  ] : [
-    "Output ONLY JSONL patches - one JSON object per line, no markdown, no code fences",
-    'First set root: {"op":"add","path":"/root","value":"<root-key>"}',
-    'Then add each element: {"op":"add","path":"/elements/<key>","value":{...}}',
-    "Output /state patches right after the elements that use them, one per array item for progressive loading. REQUIRED whenever using $state, $bindState, $bindItem, $item, $index, or repeat.",
-    "ONLY use components listed above",
-    "Each element value needs: type, props, children (array of child keys)",
-    "Use unique keys for the element map entries (e.g., 'header', 'metric-1', 'chart-revenue')"
-  ];
-  const schemaRules = catalog.schema.defaultRules ?? [];
-  const allRules = [...baseRules, ...schemaRules, ...customRules];
-  allRules.forEach((rule, i) => {
-    lines.push(`${i + 1}. ${rule}`);
-  });
-  return lines.join("\n");
-}
-function getExampleProps(def) {
-  if (def.example && Object.keys(def.example).length > 0) {
-    return def.example;
-  }
-  if (def.props) {
-    return generateExamplePropsFromZod(def.props);
-  }
-  return {};
-}
-function generateExamplePropsFromZod(schema) {
-  if (!schema || !schema._def) return {};
-  const def = schema._def;
-  const typeName = getZodTypeName(schema);
-  if (typeName !== "ZodObject" && typeName !== "object") return {};
-  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-  if (!shape) return {};
-  const result = {};
-  for (const [key, value] of Object.entries(shape)) {
-    const innerTypeName = getZodTypeName(value);
-    if (innerTypeName === "ZodOptional" || innerTypeName === "optional" || innerTypeName === "ZodNullable" || innerTypeName === "nullable") {
-      continue;
-    }
-    result[key] = generateExampleValue(value);
-  }
-  return result;
-}
-function generateExampleValue(schema) {
-  if (!schema || !schema._def) return "...";
-  const def = schema._def;
-  const typeName = getZodTypeName(schema);
-  switch (typeName) {
-    case "ZodString":
-    case "string":
-      return "example";
-    case "ZodNumber":
-    case "number":
-      return 0;
-    case "ZodBoolean":
-    case "boolean":
-      return true;
-    case "ZodLiteral":
-    case "literal":
-      return def.value;
-    case "ZodEnum":
-    case "enum": {
-      if (Array.isArray(def.values) && def.values.length > 0)
-        return def.values[0];
-      if (def.entries && typeof def.entries === "object") {
-        const values = Object.values(def.entries);
-        return values.length > 0 ? values[0] : "example";
-      }
-      return "example";
-    }
-    case "ZodOptional":
-    case "optional":
-    case "ZodNullable":
-    case "nullable":
-    case "ZodDefault":
-    case "default": {
-      const inner = def.innerType ?? def.wrapped;
-      return inner ? generateExampleValue(inner) : null;
-    }
-    case "ZodArray":
-    case "array":
-      return [];
-    case "ZodObject":
-    case "object":
-      return generateExamplePropsFromZod(schema);
-    case "ZodUnion":
-    case "union": {
-      const options = def.options;
-      return options && options.length > 0 ? generateExampleValue(options[0]) : "...";
-    }
-    default:
-      return "...";
-  }
-}
-function findFirstStringProp(schema) {
-  if (!schema || !schema._def) return null;
-  const def = schema._def;
-  const typeName = getZodTypeName(schema);
-  if (typeName !== "ZodObject" && typeName !== "object") return null;
-  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-  if (!shape) return null;
-  for (const [key, value] of Object.entries(shape)) {
-    const innerTypeName = getZodTypeName(value);
-    if (innerTypeName === "ZodOptional" || innerTypeName === "optional" || innerTypeName === "ZodNullable" || innerTypeName === "nullable") {
-      continue;
-    }
-    if (innerTypeName === "ZodString" || innerTypeName === "string") {
-      return key;
-    }
-  }
-  return null;
-}
-function getZodTypeName(schema) {
-  if (!schema || !schema._def) return "";
-  const def = schema._def;
-  return def.typeName ?? def.type ?? "";
-}
-function formatZodType(schema) {
-  if (!schema || !schema._def) return "unknown";
-  const def = schema._def;
-  const typeName = getZodTypeName(schema);
-  switch (typeName) {
-    case "ZodString":
-    case "string":
-      return "string";
-    case "ZodNumber":
-    case "number":
-      return "number";
-    case "ZodBoolean":
-    case "boolean":
-      return "boolean";
-    case "ZodLiteral":
-    case "literal":
-      return JSON.stringify(def.value);
-    case "ZodEnum":
-    case "enum": {
-      let values;
-      if (Array.isArray(def.values)) {
-        values = def.values;
-      } else if (def.entries && typeof def.entries === "object") {
-        values = Object.values(def.entries);
-      } else {
-        return "enum";
-      }
-      return values.map((v) => `"${v}"`).join(" | ");
-    }
-    case "ZodArray":
-    case "array": {
-      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":
-    case "object": {
-      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-      if (!shape) return "object";
-      const props = Object.entries(shape).map(([key, value]) => {
-        const innerTypeName = getZodTypeName(value);
-        const isOptional = innerTypeName === "ZodOptional" || innerTypeName === "ZodNullable" || innerTypeName === "optional" || innerTypeName === "nullable";
-        return `${key}${isOptional ? "?" : ""}: ${formatZodType(value)}`;
-      }).join(", ");
-      return `{ ${props} }`;
-    }
-    case "ZodOptional":
-    case "optional":
-    case "ZodNullable":
-    case "nullable": {
-      const inner = def.innerType ?? def.wrapped;
-      return inner ? formatZodType(inner) : "unknown";
-    }
-    case "ZodUnion":
-    case "union": {
-      const options = def.options;
-      return options ? options.map((opt) => formatZodType(opt)).join(" | ") : "unknown";
-    }
-    default:
-      return "unknown";
-  }
-}
-function zodTypeName(def) {
-  if (typeof def.type === "string") return def.type;
-  if (typeof def.typeName === "string") return def.typeName;
-  return "";
-}
-function normalizeTypeName(raw) {
-  if (raw.startsWith("Zod")) {
-    return raw.slice(3).toLowerCase();
-  }
-  return raw.toLowerCase();
-}
-function zodToJsonSchema(schema, strict = false) {
-  const def = schema._def;
-  const kind = normalizeTypeName(zodTypeName(def));
-  switch (kind) {
-    case "string":
-      return { type: "string" };
-    case "number":
-      return { type: "number" };
-    case "boolean":
-      return { type: "boolean" };
-    case "literal": {
-      const values = def.values;
-      const value = values ? values[0] : def.value;
-      return { const: value };
-    }
-    case "enum": {
-      const entries = def.entries;
-      const values = entries ? Object.values(entries) : def.values;
-      return { enum: values ?? [] };
-    }
-    case "array": {
-      const inner = def.element ?? def.type;
-      return {
-        type: "array",
-        items: inner ? zodToJsonSchema(inner, strict) : {}
-      };
-    }
-    case "object": {
-      const rawShape = def.shape;
-      const shape = typeof rawShape === "function" ? rawShape() : rawShape;
-      if (!shape) {
-        if (strict) {
-          return {
-            type: "object",
-            properties: {},
-            required: [],
-            additionalProperties: false
-          };
-        }
-        return { type: "object" };
-      }
-      const properties = {};
-      const required = [];
-      for (const [key, value] of Object.entries(shape)) {
-        const innerDef = value._def;
-        const innerKind = normalizeTypeName(zodTypeName(innerDef));
-        const isOptional = innerKind === "optional" || innerKind === "nullable";
-        if (strict) {
-          required.push(key);
-          if (isOptional) {
-            const unwrapped = zodToJsonSchema(value, strict);
-            properties[key] = { anyOf: [unwrapped, { type: "null" }] };
-          } else {
-            properties[key] = zodToJsonSchema(value, strict);
-          }
-        } else {
-          properties[key] = zodToJsonSchema(value);
-          if (!isOptional) {
-            required.push(key);
-          }
-        }
-      }
-      return {
-        type: "object",
-        properties,
-        required: required.length > 0 ? required : void 0,
-        additionalProperties: false
-      };
-    }
-    case "record": {
-      const valueType = def.valueType;
-      if (strict) {
-        return {
-          type: "object",
-          properties: {},
-          required: [],
-          additionalProperties: false
-        };
-      }
-      return {
-        type: "object",
-        additionalProperties: valueType ? zodToJsonSchema(valueType) : true
-      };
-    }
-    case "optional":
-    case "nullable": {
-      const inner = def.innerType;
-      return inner ? zodToJsonSchema(inner, strict) : {};
-    }
-    case "union": {
-      const options = def.options;
-      return options ? { anyOf: options.map((o) => zodToJsonSchema(o, strict)) } : {};
-    }
-    case "any":
-    case "unknown":
-      if (strict) {
-        return {
-          type: "object",
-          properties: {},
-          required: [],
-          additionalProperties: false
-        };
-      }
-      return {};
-    default:
-      return {};
-  }
-}
-function defineCatalog(schema, catalog) {
-  return schema.createCatalog(catalog);
-}
-
-// src/prompt.ts
-function buildUserPrompt(options) {
-  const {
-    prompt,
-    currentSpec,
-    state,
-    maxPromptLength,
-    editModes,
-    format,
-    serializer
-  } = options;
-  let userText = String(prompt || "");
-  if (maxPromptLength !== void 0 && maxPromptLength > 0) {
-    userText = userText.slice(0, maxPromptLength);
-  }
-  if (isNonEmptySpec(currentSpec)) {
-    const editPrompt = buildEditUserPrompt({
-      prompt: userText,
-      currentSpec,
-      config: { modes: editModes ?? ["patch"] },
-      format: format ?? "json",
-      serializer
-    });
-    if (state && Object.keys(state).length > 0) {
-      return `${editPrompt}
-
-AVAILABLE STATE:
-${JSON.stringify(state, null, 2)}`;
-    }
-    return editPrompt;
-  }
-  const parts = [userText];
-  if (state && Object.keys(state).length > 0) {
-    parts.push(`
-AVAILABLE STATE:
-${JSON.stringify(state, null, 2)}`);
-  }
-  if (format === "yaml") {
-    parts.push(
-      `
-Output the full spec in a \`\`\`yaml-spec fence. Stream progressively \u2014 output elements one at a time.`
-    );
-  } else {
-    parts.push(
-      `
-Remember: Output /root first, then interleave /elements and /state patches so the UI fills in progressively as it streams. Output each state patch right after the elements that use it, one per array item.`
-    );
-  }
-  return parts.join("\n");
-}
-
-// src/merge.ts
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function deepMergeSpec(base, patch) {
-  const result = { ...base };
-  for (const key of Object.keys(patch)) {
-    const patchVal = patch[key];
-    if (patchVal === null) {
-      delete result[key];
-      continue;
-    }
-    const baseVal = result[key];
-    if (isPlainObject(patchVal) && isPlainObject(baseVal)) {
-      result[key] = deepMergeSpec(baseVal, patchVal);
-    } else {
-      result[key] = patchVal;
-    }
-  }
-  return result;
-}
-
-// src/diff.ts
-function escapeToken(token) {
-  return token.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function buildPath(basePath, key) {
-  return `${basePath}/${escapeToken(key)}`;
-}
-function isPlainObject2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function arraysEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function diffToPatches(oldObj, newObj, basePath = "") {
-  const patches = [];
-  for (const key of Object.keys(newObj)) {
-    const path = buildPath(basePath, key);
-    const oldVal = oldObj[key];
-    const newVal = newObj[key];
-    if (!(key in oldObj)) {
-      patches.push({ op: "add", path, value: newVal });
-      continue;
-    }
-    if (isPlainObject2(oldVal) && isPlainObject2(newVal)) {
-      patches.push(...diffToPatches(oldVal, newVal, path));
-    } else if (Array.isArray(oldVal) && Array.isArray(newVal)) {
-      if (!arraysEqual(oldVal, newVal)) {
-        patches.push({ op: "replace", path, value: newVal });
-      }
-    } else if (oldVal !== newVal) {
-      patches.push({ op: "replace", path, value: newVal });
-    }
-  }
-  for (const key of Object.keys(oldObj)) {
-    if (!(key in newObj)) {
-      patches.push({ op: "remove", path: buildPath(basePath, key) });
-    }
-  }
-  return patches;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ActionBindingSchema,
-  ActionConfirmSchema,
-  ActionOnErrorSchema,
-  ActionOnSuccessSchema,
-  ActionSchema,
-  DynamicBooleanSchema,
-  DynamicNumberSchema,
-  DynamicStringSchema,
-  DynamicValueSchema,
-  SPEC_DATA_PART,
-  SPEC_DATA_PART_TYPE,
-  ValidationCheckSchema,
-  ValidationConfigSchema,
-  VisibilityConditionSchema,
-  action,
-  actionBinding,
-  addByPath,
-  applySpecPatch,
-  applySpecStreamPatch,
-  autoFixSpec,
-  buildEditInstructions,
-  buildEditUserPrompt,
-  buildUserPrompt,
-  builtInValidationFunctions,
-  check,
-  compileSpecStream,
-  createJsonRenderTransform,
-  createMixedStreamParser,
-  createSpecStreamCompiler,
-  createStateStore,
-  deepMergeSpec,
-  defineCatalog,
-  defineSchema,
-  diffToPatches,
-  evaluateVisibility,
-  executeAction,
-  findFormValue,
-  formatSpecIssues,
-  getByPath,
-  interpolateString,
-  isNonEmptySpec,
-  nestedToFlat,
-  parseSpecStreamLine,
-  pipeJsonRender,
-  removeByPath,
-  resolveAction,
-  resolveActionParam,
-  resolveBindings,
-  resolveDynamicValue,
-  resolveElementProps,
-  resolvePropValue,
-  runValidation,
-  runValidationCheck,
-  setByPath,
-  validateSpec,
-  visibility
-});
-//# sourceMappingURL=index.js.map