@kubuild/core 0.0.1

package/dist/index.js

@@ -0,0 +1,3614 @@
+// src/binding-resolver.ts
+var FORBIDDEN_KEY_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function resolveBinding(binding, context) {
+  const segments = binding.key.split(".").filter(Boolean);
+  let current = context?.variables;
+  for (const segment of segments) {
+    if (FORBIDDEN_KEY_SEGMENTS.has(segment)) {
+      return applyMissingPolicy(binding);
+    }
+    if (current === null || typeof current !== "object") {
+      return applyMissingPolicy(binding);
+    }
+    if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+      return applyMissingPolicy(binding);
+    }
+    current = current[segment];
+  }
+  if (current === void 0 || typeof current === "function") {
+    return applyMissingPolicy(binding);
+  }
+  return { status: "resolved", value: current };
+}
+function applyMissingPolicy(binding) {
+  if (binding.fallback !== void 0) {
+    return { status: "fallback", value: binding.fallback };
+  }
+  return { status: "empty", value: "" };
+}
+function resolveBindingValue(binding, context) {
+  return resolveBinding(binding, context).value;
+}
+
+// src/variable-catalog.ts
+var FORBIDDEN_KEY_SEGMENTS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function buildSampleVariablesFromCatalog(catalog) {
+  const result = {};
+  if (!catalog) {
+    return result;
+  }
+  for (const entry of catalog) {
+    const segments = entry.key.split(".").filter(Boolean);
+    if (segments.length === 0 || segments.some((segment) => FORBIDDEN_KEY_SEGMENTS2.has(segment))) {
+      continue;
+    }
+    let cursor = result;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+      const segment = segments[i];
+      const existing = cursor[segment];
+      if (existing === null || typeof existing !== "object" || Array.isArray(existing)) {
+        cursor[segment] = {};
+      }
+      cursor = cursor[segment];
+    }
+    cursor[segments[segments.length - 1]] = entry.sampleValue;
+  }
+  return result;
+}
+
+// src/validator.ts
+import {
+  PageDocumentSchema,
+  SCHEMA_NAME
+} from "@kubuild/schema";
+
+// src/security.ts
+var DEFAULT_DOCUMENT_SECURITY_LIMITS = {
+  maxNodeCount: 5e3,
+  maxTreeDepth: 32,
+  maxPropsCount: 200,
+  maxStringLength: 1e5,
+  maxChildrenPerNode: 1e3,
+  maxDocumentSizeBytes: 10 * 1024 * 1024,
+  // 10 MB
+  allowedUrlSchemes: ["http:", "https:", "mailto:", "tel:", "#", "relative", "data:image/"],
+  prohibitedPropertyKeys: [
+    "__proto__",
+    "constructor",
+    "prototype",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__"
+  ],
+  prohibitedAssetExtensions: [
+    ".exe",
+    ".dll",
+    ".so",
+    ".sh",
+    ".bat",
+    ".cmd",
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".php",
+    ".py",
+    ".vbs",
+    ".wasm",
+    ".bin",
+    ".com",
+    ".scr",
+    ".pif",
+    ".hta",
+    ".jar"
+  ],
+  maxZipExpansionRatio: 100
+};
+function isSafeUrl(url, options) {
+  if (typeof url !== "string") return false;
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return true;
+  if (trimmed.startsWith("/") || trimmed.startsWith("#") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("?")) {
+    return true;
+  }
+  if (/[\u0000-\u001F\u007F-\u009F]/.test(trimmed)) {
+    return false;
+  }
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    return true;
+  }
+  const scheme = trimmed.substring(0, colonIndex + 1).toLowerCase();
+  const dangerousSchemes = ["javascript:", "vbscript:", "file:", "data:"];
+  if (scheme !== "data:" && dangerousSchemes.includes(scheme)) {
+    if (scheme === "blob:" && options?.allowBlobMedia) {
+      return true;
+    }
+    return false;
+  }
+  if (scheme === "data:") {
+    const allowDataImage = options?.allowDataImage ?? true;
+    if (!allowDataImage) return false;
+    const dataPrefix = trimmed.substring(0, 30).toLowerCase();
+    const safeDataImagePrefixes = [
+      "data:image/png",
+      "data:image/jpeg",
+      "data:image/jpg",
+      "data:image/webp",
+      "data:image/gif",
+      "data:image/avif",
+      "data:image/svg+xml"
+    ];
+    return safeDataImagePrefixes.some((p) => dataPrefix.startsWith(p));
+  }
+  const allowed = options?.allowedSchemes || DEFAULT_DOCUMENT_SECURITY_LIMITS.allowedUrlSchemes;
+  return allowed.some((s) => s.toLowerCase() === scheme);
+}
+function sanitizeUrl(url, fallback = "", options) {
+  if (typeof url !== "string") return fallback;
+  return isSafeUrl(url, options) ? url : fallback;
+}
+function containsProhibitedKeys(obj, prohibitedKeys = DEFAULT_DOCUMENT_SECURITY_LIMITS.prohibitedPropertyKeys) {
+  const prohibitedSet = new Set(prohibitedKeys.map((k) => k.toLowerCase()));
+  const visited = /* @__PURE__ */ new WeakSet();
+  function check(value, currentPath) {
+    if (!value || typeof value !== "object") {
+      return { found: false, path: "", key: "" };
+    }
+    if (visited.has(value)) {
+      return { found: false, path: "", key: "" };
+    }
+    visited.add(value);
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const res = check(value[i], `${currentPath}[${i}]`);
+        if (res.found) return res;
+      }
+      return { found: false, path: "", key: "" };
+    }
+    const record = value;
+    const keysToCheck = Array.from(/* @__PURE__ */ new Set([...Object.keys(record), ...Object.getOwnPropertyNames(record)]));
+    for (const key of keysToCheck) {
+      if (prohibitedSet.has(key.toLowerCase())) {
+        return { found: true, path: currentPath ? `${currentPath}.${key}` : key, key };
+      }
+      const res = check(record[key], currentPath ? `${currentPath}.${key}` : key);
+      if (res.found) return res;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, "__proto__")) {
+      return { found: true, path: currentPath ? `${currentPath}.__proto__` : "__proto__", key: "__proto__" };
+    }
+    return { found: false, path: "", key: "" };
+  }
+  return check(obj, "");
+}
+function validateDocumentSecurity(doc, customLimits) {
+  const limits = { ...DEFAULT_DOCUMENT_SECURITY_LIMITS, ...customLimits };
+  const errors = [];
+  if (!doc || typeof doc !== "object") {
+    return { safe: true, errors: [] };
+  }
+  const protoCheck = containsProhibitedKeys(doc, limits.prohibitedPropertyKeys);
+  if (protoCheck.found) {
+    errors.push({
+      code: "PROTOTYPE_POLLUTION_DETECTED",
+      message: `Prohibited property key "${protoCheck.key}" detected at path "${protoCheck.path}" (Prototype Pollution Defense).`,
+      path: protoCheck.path,
+      details: { key: protoCheck.key }
+    });
+  }
+  try {
+    const jsonStr = JSON.stringify(doc);
+    if (jsonStr.length > limits.maxDocumentSizeBytes) {
+      errors.push({
+        code: "MAX_DOCUMENT_SIZE_EXCEEDED",
+        message: `Document size (${jsonStr.length} bytes) exceeds limit of ${limits.maxDocumentSizeBytes} bytes.`,
+        details: { size: jsonStr.length, limit: limits.maxDocumentSizeBytes }
+      });
+    }
+  } catch {
+  }
+  const docObj = doc;
+  const rootNode = docObj.document;
+  if (rootNode && typeof rootNode === "object") {
+    let traverse2 = function(node, depth, currentPath) {
+      if (!node || typeof node !== "object" || Array.isArray(node)) return;
+      totalNodes++;
+      if (totalNodes > limits.maxNodeCount) {
+        errors.push({
+          code: "MAX_NODE_COUNT_EXCEEDED",
+          message: `Total document nodes (${totalNodes}) exceeded security limit of ${limits.maxNodeCount}.`,
+          path: currentPath,
+          details: { nodeCount: totalNodes, limit: limits.maxNodeCount }
+        });
+        return;
+      }
+      if (depth > limits.maxTreeDepth) {
+        errors.push({
+          code: "MAX_TREE_DEPTH_EXCEEDED",
+          message: `Document nesting depth (${depth}) exceeded security limit of ${limits.maxTreeDepth}.`,
+          path: currentPath,
+          details: { depth, limit: limits.maxTreeDepth }
+        });
+        return;
+      }
+      const nodeRecord = node;
+      if (nodeRecord.props && typeof nodeRecord.props === "object" && !Array.isArray(nodeRecord.props)) {
+        const propsRecord = nodeRecord.props;
+        const propKeys = Object.keys(propsRecord);
+        if (propKeys.length > limits.maxPropsCount) {
+          errors.push({
+            code: "MAX_PROPS_COUNT_EXCEEDED",
+            message: `Node has ${propKeys.length} props, exceeding limit of ${limits.maxPropsCount}.`,
+            path: `${currentPath}/props`,
+            details: { count: propKeys.length, limit: limits.maxPropsCount }
+          });
+        }
+        for (const [k, val] of Object.entries(propsRecord)) {
+          if (typeof val === "string" && val.length > limits.maxStringLength) {
+            errors.push({
+              code: "MAX_STRING_LENGTH_EXCEEDED",
+              message: `Prop "${k}" string length (${val.length}) exceeds limit of ${limits.maxStringLength}.`,
+              path: `${currentPath}/props/${k}`,
+              details: { length: val.length, limit: limits.maxStringLength }
+            });
+          }
+        }
+      }
+      if (nodeRecord.children && Array.isArray(nodeRecord.children)) {
+        if (nodeRecord.children.length > limits.maxChildrenPerNode) {
+          errors.push({
+            code: "MAX_CHILDREN_COUNT_EXCEEDED",
+            message: `Node has ${nodeRecord.children.length} direct children, exceeding limit of ${limits.maxChildrenPerNode}.`,
+            path: `${currentPath}/children`,
+            details: { count: nodeRecord.children.length, limit: limits.maxChildrenPerNode }
+          });
+        }
+        for (let i = 0; i < nodeRecord.children.length; i++) {
+          traverse2(nodeRecord.children[i], depth + 1, `${currentPath}/children/${i}`);
+        }
+      }
+    };
+    var traverse = traverse2;
+    let totalNodes = 0;
+    traverse2(rootNode, 1, "/document");
+  }
+  return {
+    safe: errors.length === 0,
+    errors
+  };
+}
+function isDangerousAssetFilename(filename, prohibitedExtensions = DEFAULT_DOCUMENT_SECURITY_LIMITS.prohibitedAssetExtensions) {
+  if (!filename || typeof filename !== "string") return true;
+  const lower = filename.toLowerCase().trim();
+  return prohibitedExtensions.some((ext) => {
+    const extLower = ext.toLowerCase();
+    return lower.endsWith(extLower) || lower.includes(`${extLower}.`);
+  });
+}
+function checkZipBomb(compressedSize, uncompressedSize, maxRatio = DEFAULT_DOCUMENT_SECURITY_LIMITS.maxZipExpansionRatio) {
+  if (compressedSize <= 0) return false;
+  if (uncompressedSize > 10 * 1024 * 1024) {
+    const ratio = uncompressedSize / compressedSize;
+    return ratio > maxRatio;
+  }
+  return false;
+}
+function sanitizeHtml(rawHtml) {
+  if (typeof rawHtml !== "string") return "";
+  let html = rawHtml;
+  html = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
+  html = html.replace(/<\/?(object|embed|applet|base|link)\b[^>]*>/gi, "");
+  html = html.replace(/\s+on[a-z0-9_-]+\s*=\s*(?:'[^']*'|"[^"]*"|[^\s>]+)/gi, "");
+  html = html.replace(
+    /\b(href|src|data|action)\s*=\s*(['"])\s*(?:javascript:|vbscript:|data:text\/html)[^'"]*\2/gi,
+    '$1="#"'
+  );
+  html = html.replace(
+    /\b(href|src|data|action)\s*=\s*(?:javascript:|vbscript:|data:text\/html)[^\s>]+/gi,
+    '$1="#"'
+  );
+  return html;
+}
+
+// src/validator.ts
+function validateDocument(input, options = {}) {
+  const errors = [];
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return {
+      valid: false,
+      success: false,
+      errors: [
+        {
+          code: "GLOBAL_SCHEMA_INVALID",
+          message: "Document must be a valid non-null object",
+          path: ""
+        }
+      ]
+    };
+  }
+  const doc = input;
+  const securityCheck = validateDocumentSecurity(doc, options.securityLimits);
+  if (!securityCheck.safe) {
+    for (const secErr of securityCheck.errors) {
+      errors.push({
+        code: secErr.code === "PROTOTYPE_POLLUTION_DETECTED" ? "PROTOTYPE_POLLUTION_DETECTED" : "SECURITY_LIMIT_EXCEEDED",
+        message: secErr.message,
+        path: secErr.path || "",
+        details: secErr.details
+      });
+    }
+    if (securityCheck.errors.some((e) => e.code === "PROTOTYPE_POLLUTION_DETECTED")) {
+      return {
+        valid: false,
+        success: false,
+        errors
+      };
+    }
+  }
+  if (doc.schema !== SCHEMA_NAME) {
+    errors.push({
+      code: "GLOBAL_SCHEMA_INVALID",
+      message: `Invalid schema identifier. Expected "${SCHEMA_NAME}", received "${String(doc.schema)}"`,
+      path: "/schema"
+    });
+  }
+  if (typeof doc.version !== "string" || doc.version.trim().length === 0) {
+    errors.push({
+      code: "GLOBAL_SCHEMA_INVALID",
+      message: "Schema version must be a non-empty string",
+      path: "/version"
+    });
+  }
+  if (!doc.document || typeof doc.document !== "object" || Array.isArray(doc.document)) {
+    errors.push({
+      code: "GLOBAL_SCHEMA_INVALID",
+      message: "Document must contain a root document node object",
+      path: "/document"
+    });
+    return {
+      valid: false,
+      success: false,
+      errors
+    };
+  }
+  const rootNode = doc.document;
+  if (rootNode.type !== "page") {
+    errors.push({
+      code: "ROOT_NODE_INVALID",
+      message: `Root node type must be "page", received "${String(rootNode.type)}"`,
+      path: "/document/type",
+      nodeId: typeof rootNode.id === "string" ? rootNode.id : void 0
+    });
+  }
+  if (doc.metadata !== void 0) {
+    if (typeof doc.metadata !== "object" || doc.metadata === null || Array.isArray(doc.metadata)) {
+      errors.push({
+        code: "INVALID_METADATA",
+        message: "Document metadata must be an object",
+        path: "/metadata"
+      });
+    } else {
+      const meta = doc.metadata;
+      if (meta.title !== void 0 && (typeof meta.title !== "string" || meta.title.trim().length === 0)) {
+        errors.push({
+          code: "INVALID_METADATA",
+          message: "Metadata title must be a non-empty string when provided",
+          path: "/metadata/title"
+        });
+      }
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Map();
+  const visitedObjects = /* @__PURE__ */ new Set();
+  validateNodeRecursive(
+    rootNode,
+    "/document",
+    void 0,
+    seenIds,
+    visitedObjects,
+    options,
+    errors
+  );
+  if (errors.length === 0) {
+    const zodResult = PageDocumentSchema.safeParse(input);
+    if (!zodResult.success) {
+      for (const issue of zodResult.error.issues) {
+        const jsonPath = "/" + issue.path.join("/");
+        errors.push({
+          code: "GLOBAL_SCHEMA_INVALID",
+          message: issue.message,
+          path: jsonPath === "/" ? "" : jsonPath
+        });
+      }
+    } else {
+      return {
+        valid: true,
+        success: true,
+        errors: [],
+        data: zodResult.data
+      };
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    success: errors.length === 0,
+    errors
+  };
+}
+function validateNodeRecursive(nodeObj, currentPath, parentNode, seenIds, visitedObjects, options, errors) {
+  if (visitedObjects.has(nodeObj)) {
+    errors.push({
+      code: "TREE_CYCLE_DETECTED",
+      message: `Cyclic reference detected at node path ${currentPath}`,
+      path: currentPath,
+      nodeId: typeof nodeObj.id === "string" ? nodeObj.id : void 0
+    });
+    return;
+  }
+  visitedObjects.add(nodeObj);
+  const nodeId = nodeObj.id;
+  if (typeof nodeId !== "string" || nodeId.trim().length === 0) {
+    errors.push({
+      code: "NODE_SHAPE_INVALID",
+      message: "Node id must be a non-empty string",
+      path: `${currentPath}/id`
+    });
+  } else {
+    if (seenIds.has(nodeId)) {
+      errors.push({
+        code: "DUPLICATE_NODE_ID",
+        message: `Duplicate node ID "${nodeId}" found at ${currentPath} (first seen at ${seenIds.get(nodeId)})`,
+        path: `${currentPath}/id`,
+        nodeId,
+        details: { firstSeenAt: seenIds.get(nodeId) }
+      });
+    } else {
+      seenIds.set(nodeId, currentPath);
+    }
+  }
+  const nodeType = nodeObj.type;
+  if (typeof nodeType !== "string" || nodeType.trim().length === 0) {
+    errors.push({
+      code: "NODE_SHAPE_INVALID",
+      message: "Node type must be a non-empty string",
+      path: `${currentPath}/type`,
+      nodeId: typeof nodeId === "string" ? nodeId : void 0
+    });
+  }
+  const effectiveNodeId = typeof nodeId === "string" ? nodeId : void 0;
+  const effectiveNodeType = typeof nodeType === "string" ? nodeType : "";
+  let componentDef;
+  if (effectiveNodeType) {
+    if (options.componentRegistry) {
+      componentDef = options.componentRegistry.get(effectiveNodeType);
+      if (!componentDef && (options.strictComponentTypes || !options.componentRegistry.has(effectiveNodeType))) {
+        errors.push({
+          code: "UNKNOWN_COMPONENT_TYPE",
+          message: `Unknown component type: "${effectiveNodeType}"`,
+          path: `${currentPath}/type`,
+          nodeId: effectiveNodeId
+        });
+      }
+    } else if (options.knownComponentTypes) {
+      const isKnown = Array.isArray(options.knownComponentTypes) ? options.knownComponentTypes.includes(effectiveNodeType) : options.knownComponentTypes.has(effectiveNodeType);
+      if (!isKnown && options.strictComponentTypes) {
+        errors.push({
+          code: "UNKNOWN_COMPONENT_TYPE",
+          message: `Unknown component type: "${effectiveNodeType}"`,
+          path: `${currentPath}/type`,
+          nodeId: effectiveNodeId
+        });
+      }
+    }
+  }
+  const children = nodeObj.children;
+  if (children !== void 0) {
+    if (!Array.isArray(children)) {
+      errors.push({
+        code: "NODE_SHAPE_INVALID",
+        message: "Node children must be an array",
+        path: `${currentPath}/children`,
+        nodeId: effectiveNodeId
+      });
+    } else {
+      if (componentDef && componentDef.acceptsChildren === false && children.length > 0) {
+        errors.push({
+          code: "CHILD_POLICY_VIOLATION",
+          message: `Component "${effectiveNodeType}" does not accept children, but found ${children.length} child node(s)`,
+          path: `${currentPath}/children`,
+          nodeId: effectiveNodeId
+        });
+      }
+      if (parentNode && componentDef?.disallowedParents?.includes(parentNode.type)) {
+        errors.push({
+          code: "CHILD_POLICY_VIOLATION",
+          message: `Component "${effectiveNodeType}" cannot be a child of "${parentNode.type}"`,
+          path: currentPath,
+          nodeId: effectiveNodeId
+        });
+      }
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const childPath = `${currentPath}/children/${i}`;
+        if (!child || typeof child !== "object" || Array.isArray(child)) {
+          errors.push({
+            code: "NODE_SHAPE_INVALID",
+            message: `Child at index ${i} must be a valid node object`,
+            path: childPath,
+            nodeId: effectiveNodeId
+          });
+          continue;
+        }
+        const childRecord = child;
+        const childType = typeof childRecord.type === "string" ? childRecord.type : "";
+        const childIsKnown = !options.componentRegistry || options.componentRegistry.has(childType);
+        const childCategory = options.componentRegistry?.get(childType)?.category;
+        if (componentDef?.allowedChildren && childType && childIsKnown && !componentDef.allowedChildren.includes(childType) && !componentDef.allowedChildren.includes("*") && !(childCategory && componentDef.allowedChildren.includes(childCategory))) {
+          errors.push({
+            code: "CHILD_POLICY_VIOLATION",
+            message: `Component type "${childType}" is not allowed as a child of "${effectiveNodeType}". Allowed types: ${componentDef.allowedChildren.join(", ")}`,
+            path: `${childPath}/type`,
+            nodeId: typeof childRecord.id === "string" ? childRecord.id : void 0
+          });
+        }
+        validateNodeRecursive(
+          childRecord,
+          childPath,
+          { id: effectiveNodeId || "", type: effectiveNodeType },
+          seenIds,
+          visitedObjects,
+          options,
+          errors
+        );
+      }
+    }
+  }
+  if (nodeObj.props !== void 0) {
+    if (typeof nodeObj.props !== "object" || nodeObj.props === null || Array.isArray(nodeObj.props)) {
+      errors.push({
+        code: "NODE_SHAPE_INVALID",
+        message: "Node props must be an object",
+        path: `${currentPath}/props`,
+        nodeId: effectiveNodeId
+      });
+    } else {
+      validatePropsBindings(
+        nodeObj.props,
+        `${currentPath}/props`,
+        effectiveNodeId,
+        options,
+        errors
+      );
+    }
+  }
+  if (nodeObj.styles !== void 0) {
+    if (typeof nodeObj.styles !== "object" || nodeObj.styles === null || Array.isArray(nodeObj.styles)) {
+      errors.push({
+        code: "NODE_SHAPE_INVALID",
+        message: "Node styles must be an object",
+        path: `${currentPath}/styles`,
+        nodeId: effectiveNodeId
+      });
+    }
+  }
+}
+function validatePropsBindings(propsObj, propsPath, nodeId, options, errors) {
+  for (const [key, value] of Object.entries(propsObj)) {
+    const currentPath = `${propsPath}/${key}`;
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          validatePropsBindings(
+            item,
+            `${currentPath}/${index}`,
+            nodeId,
+            options,
+            errors
+          );
+        }
+      });
+      continue;
+    }
+    const record = value;
+    if (record.type === "asset") {
+      if (typeof record.assetId !== "string" || record.assetId.trim().length === 0) {
+        errors.push({
+          code: "INVALID_ASSET_REFERENCE",
+          message: 'Asset reference must have a non-empty "assetId"',
+          path: `${currentPath}/assetId`,
+          nodeId
+        });
+      }
+      if (record.fallbackUrl !== void 0 && typeof record.fallbackUrl !== "string") {
+        errors.push({
+          code: "INVALID_ASSET_REFERENCE",
+          message: "Asset fallbackUrl must be a string if provided",
+          path: `${currentPath}/fallbackUrl`,
+          nodeId
+        });
+      }
+    } else if (record.type === "variable") {
+      if (typeof record.key !== "string" || record.key.trim().length === 0) {
+        errors.push({
+          code: "INVALID_VARIABLE_BINDING",
+          message: 'Variable binding must have a non-empty "key"',
+          path: `${currentPath}/key`,
+          nodeId
+        });
+      }
+    } else if (key === "action" || typeof record.type === "string" && record.payload !== void 0) {
+      if (typeof record.type !== "string" || record.type.trim().length === 0) {
+        errors.push({
+          code: "INVALID_ACTION_BINDING",
+          message: 'Action binding must have a non-empty "type"',
+          path: `${currentPath}/type`,
+          nodeId
+        });
+      }
+    } else {
+      validatePropsBindings(record, currentPath, nodeId, options, errors);
+    }
+  }
+}
+
+// src/document-utils.ts
+import { SCHEMA_NAME as SCHEMA_NAME2 } from "@kubuild/schema";
+function createBlankDocument(title = "Untitled Page") {
+  return {
+    schema: SCHEMA_NAME2,
+    version: "1.0.0",
+    metadata: {
+      title,
+      description: "",
+      author: "",
+      tags: [],
+      category: "general",
+      version: "1.0.0",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    document: {
+      id: "root-page",
+      type: "page",
+      props: { title },
+      styles: { base: { minHeight: "100vh", backgroundColor: "#ffffff" } },
+      children: []
+    }
+  };
+}
+function findNodeById(rootNode, targetId) {
+  if (rootNode.id === targetId) return rootNode;
+  if (!rootNode.children) return null;
+  for (const child of rootNode.children) {
+    const found = findNodeById(child, targetId);
+    if (found) return found;
+  }
+  return null;
+}
+function collectAssetReferences(rootNode) {
+  const results = [];
+  function traverseProps(propsObj, currentPath, nodeId) {
+    if (!propsObj || typeof propsObj !== "object") return;
+    if (Array.isArray(propsObj)) {
+      propsObj.forEach((item, index) => {
+        traverseProps(item, `${currentPath}/${index}`, nodeId);
+      });
+      return;
+    }
+    const record = propsObj;
+    if (record.type === "asset" && typeof record.assetId === "string" && record.assetId.trim().length > 0) {
+      results.push({
+        assetId: record.assetId,
+        reference: {
+          type: "asset",
+          assetId: record.assetId,
+          filename: typeof record.filename === "string" ? record.filename : void 0,
+          mimeType: typeof record.mimeType === "string" ? record.mimeType : void 0,
+          fallbackUrl: typeof record.fallbackUrl === "string" ? record.fallbackUrl : void 0
+        },
+        nodeId,
+        propPath: currentPath
+      });
+    }
+    for (const [key, val] of Object.entries(record)) {
+      if (val && typeof val === "object") {
+        traverseProps(val, `${currentPath}/${key}`, nodeId);
+      }
+    }
+  }
+  function traverseNode(node) {
+    if (node.props) {
+      traverseProps(node.props, `/document/${node.id}/props`, node.id);
+    }
+    if (node.children && Array.isArray(node.children)) {
+      for (const child of node.children) {
+        traverseNode(child);
+      }
+    }
+  }
+  traverseNode(rootNode);
+  return results;
+}
+function extractRequirementsFromTree(rootNode, registry) {
+  const requiredComponents = /* @__PURE__ */ new Set();
+  const requiredCapabilities = /* @__PURE__ */ new Set();
+  function traverse(node) {
+    if (registry) {
+      const def = registry.get(node.type);
+      if (def?.category === "custom") {
+        requiredComponents.add(node.type);
+      }
+      if (def?.capabilities && Array.isArray(def.capabilities)) {
+        for (const cap of def.capabilities) {
+          requiredCapabilities.add(cap);
+        }
+      }
+    }
+    if (node.children && Array.isArray(node.children)) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(rootNode);
+  return {
+    requiredComponents: Array.from(requiredComponents).sort(),
+    requiredCapabilities: Array.from(requiredCapabilities).sort()
+  };
+}
+function remapAssetReferences(rootNode, idMap) {
+  let remappedCount = 0;
+  const getMappedId = (id) => {
+    if (idMap instanceof Map) return idMap.get(id);
+    return idMap[id];
+  };
+  function traverseProps(propsObj) {
+    if (!propsObj || typeof propsObj !== "object") return;
+    if (Array.isArray(propsObj)) {
+      for (const item of propsObj) {
+        traverseProps(item);
+      }
+      return;
+    }
+    const record = propsObj;
+    if (record.type === "asset" && typeof record.assetId === "string") {
+      const newId = getMappedId(record.assetId);
+      if (newId !== void 0 && newId !== record.assetId) {
+        record.assetId = newId;
+        remappedCount++;
+      }
+    }
+    for (const val of Object.values(record)) {
+      if (val && typeof val === "object") {
+        traverseProps(val);
+      }
+    }
+  }
+  function traverseNode(node) {
+    if (node.props) {
+      traverseProps(node.props);
+    }
+    if (node.children && Array.isArray(node.children)) {
+      for (const child of node.children) {
+        traverseNode(child);
+      }
+    }
+  }
+  traverseNode(rootNode);
+  return remappedCount;
+}
+function remapDocumentAssetReferences(doc, idMap) {
+  if (doc && doc.document) {
+    remapAssetReferences(doc.document, idMap);
+  }
+  return doc;
+}
+function findMissingComponentNodes(rootNode, registry, knownTypes) {
+  const missing = [];
+  const knownSet = /* @__PURE__ */ new Set();
+  if (knownTypes) {
+    for (const t of knownTypes) knownSet.add(t);
+  }
+  const standardBuiltIns = [
+    "page",
+    "section",
+    "container",
+    "columns",
+    "heading",
+    "text",
+    "image",
+    "button",
+    "collection"
+  ];
+  for (const b of standardBuiltIns) knownSet.add(b);
+  function checkNode(node) {
+    let isSupported = knownSet.has(node.type);
+    if (!isSupported && registry) {
+      isSupported = registry.has(node.type);
+    }
+    if (!isSupported) {
+      missing.push({
+        nodeId: node.id,
+        componentType: node.type,
+        props: node.props ? { ...node.props } : {},
+        node
+      });
+    }
+    if (node.children && Array.isArray(node.children)) {
+      for (const child of node.children) {
+        checkNode(child);
+      }
+    }
+  }
+  checkNode(rootNode);
+  return missing;
+}
+
+// src/commands.ts
+import {
+  StyleDefinitionSchema,
+  ResponsiveStylesSchema
+} from "@kubuild/schema";
+
+// src/command-tree-utils.ts
+import { collectNodeIds } from "@kubuild/schema";
+function deepClone(val) {
+  return JSON.parse(JSON.stringify(val));
+}
+function findNodeLocation(root, targetId) {
+  if (root.id === targetId) {
+    return {
+      node: root,
+      parent: null,
+      index: -1
+    };
+  }
+  return searchNodeLocationRecursive(root, targetId);
+}
+function searchNodeLocationRecursive(currentParent, targetId) {
+  if (!currentParent.children || currentParent.children.length === 0) {
+    return null;
+  }
+  for (let i = 0; i < currentParent.children.length; i++) {
+    const child = currentParent.children[i];
+    if (child.id === targetId) {
+      return {
+        node: child,
+        parent: currentParent,
+        index: i
+      };
+    }
+    const foundInSubtree = searchNodeLocationRecursive(child, targetId);
+    if (foundInSubtree) {
+      return foundInSubtree;
+    }
+  }
+  return null;
+}
+function getNavigationTarget(root, nodeId, direction) {
+  const location = findNodeLocation(root, nodeId);
+  if (!location) return null;
+  switch (direction) {
+    case "parent":
+      return location.parent?.id ?? null;
+    case "child":
+      return location.node.children?.[0]?.id ?? null;
+    case "previous-sibling": {
+      if (!location.parent) return null;
+      return (location.parent.children ?? [])[location.index - 1]?.id ?? null;
+    }
+    case "next-sibling": {
+      if (!location.parent) return null;
+      return (location.parent.children ?? [])[location.index + 1]?.id ?? null;
+    }
+  }
+}
+function getAncestorChain(root, targetId) {
+  if (root.id === targetId) return [];
+  function walk(node, acc) {
+    if (!node.children) return null;
+    for (const child of node.children) {
+      if (child.id === targetId) return acc;
+      const found = walk(child, [...acc, child.id]);
+      if (found) return found;
+    }
+    return null;
+  }
+  return walk(root, [root.id]) ?? [];
+}
+function getParentNodeId(root, targetId) {
+  if (root.id === targetId) return null;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const children = current.children;
+    if (!children) continue;
+    for (const child of children) {
+      if (child.id === targetId) return current.id;
+      stack.push(child);
+    }
+  }
+  return null;
+}
+function getNodeAncestors(root, targetId) {
+  const path = [];
+  function walk(node) {
+    path.push(node);
+    if (node.id === targetId) return true;
+    if (node.children) {
+      for (const child of node.children) {
+        if (walk(child)) return true;
+      }
+    }
+    path.pop();
+    return false;
+  }
+  return walk(root) ? path : [];
+}
+function isDescendantOf(ancestorNode, targetId) {
+  if (ancestorNode.id === targetId) {
+    return true;
+  }
+  if (!ancestorNode.children || ancestorNode.children.length === 0) {
+    return false;
+  }
+  for (const child of ancestorNode.children) {
+    if (isDescendantOf(child, targetId)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectNodeIdSet(root) {
+  return new Set(collectNodeIds(root));
+}
+function defaultIdGenerator(oldId, existingIds) {
+  const baseName = oldId.replace(/_copy(_\d+)?$/, "");
+  let candidate = `${baseName}_copy`;
+  let counter = 1;
+  if (existingIds) {
+    while (existingIds.has(candidate)) {
+      candidate = `${baseName}_copy_${counter}`;
+      counter++;
+    }
+    existingIds.add(candidate);
+  }
+  return candidate;
+}
+function cloneTreeWithNewIds(root, idGenerator, existingIds) {
+  const idMap = /* @__PURE__ */ new Map();
+  const idGen = idGenerator || ((oldId) => defaultIdGenerator(oldId, existingIds));
+  function cloneRecursive(node) {
+    const newId = idGen(node.id);
+    idMap.set(node.id, newId);
+    const clonedProps = node.props ? deepClone(node.props) : void 0;
+    const clonedStyles = node.styles ? deepClone(node.styles) : void 0;
+    const clonedChildren = node.children ? node.children.map((child) => cloneRecursive(child)) : [];
+    return {
+      id: newId,
+      type: node.type,
+      ...clonedProps ? { props: clonedProps } : {},
+      ...clonedStyles ? { styles: clonedStyles } : {},
+      children: clonedChildren
+    };
+  }
+  const clonedNode = cloneRecursive(root);
+  return { clonedNode, idMap };
+}
+
+// src/commands.ts
+function insertNode(document, params) {
+  const { parentId, node, index } = params;
+  if (!node || typeof node !== "object" || !node.id || !node.type) {
+    throw new Error('Invalid node: Node must be an object with non-empty "id" and "type"');
+  }
+  const newDoc = deepClone(document);
+  const existingIds = collectNodeIdSet(newDoc.document);
+  const incomingIds = collectNodeIdSet(node);
+  for (const incId of incomingIds) {
+    if (existingIds.has(incId)) {
+      throw new Error(`Cannot insert node: Duplicate node ID "${incId}" already exists in document.`);
+    }
+  }
+  const parentLoc = findNodeLocation(newDoc.document, parentId);
+  if (!parentLoc) {
+    throw new Error(`Cannot insert node: Target parent node with ID "${parentId}" not found.`);
+  }
+  const parentNode = parentLoc.node;
+  if (!parentNode.children) {
+    parentNode.children = [];
+  }
+  const insertIndex = typeof index === "number" && index >= 0 && index <= parentNode.children.length ? index : parentNode.children.length;
+  parentNode.children.splice(insertIndex, 0, deepClone(node));
+  return {
+    document: newDoc,
+    event: {
+      type: "NODE_INSERTED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId: node.id,
+      parentId,
+      index: insertIndex,
+      payload: {
+        nodeType: node.type
+      }
+    }
+  };
+}
+function moveNode(document, params) {
+  const { nodeId, targetParentId, index } = params;
+  if (nodeId === document.document.id) {
+    throw new Error("Cannot move the root page node.");
+  }
+  const newDoc = deepClone(document);
+  const sourceLoc = findNodeLocation(newDoc.document, nodeId);
+  if (!sourceLoc || !sourceLoc.parent) {
+    throw new Error(`Cannot move node: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetLoc = findNodeLocation(newDoc.document, targetParentId);
+  if (!targetLoc) {
+    throw new Error(`Cannot move node: Target parent with ID "${targetParentId}" not found in document.`);
+  }
+  if (isDescendantOf(sourceLoc.node, targetParentId)) {
+    throw new Error(
+      `Cannot move node: Target parent "${targetParentId}" is the node itself or a descendant of node "${nodeId}".`
+    );
+  }
+  const previousParentId = sourceLoc.parent.id;
+  const previousIndex = sourceLoc.index;
+  const [removedNode] = sourceLoc.parent.children.splice(previousIndex, 1);
+  const targetParent = targetLoc.node;
+  if (!targetParent.children) {
+    targetParent.children = [];
+  }
+  let targetIndex = typeof index === "number" && index >= 0 && index <= targetParent.children.length ? index : targetParent.children.length;
+  targetParent.children.splice(targetIndex, 0, removedNode);
+  return {
+    document: newDoc,
+    event: {
+      type: "NODE_MOVED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: targetParentId,
+      previousParentId,
+      index: targetIndex,
+      previousIndex
+    }
+  };
+}
+function updateProps(document, params) {
+  const { nodeId, props, merge = true } = params;
+  if (!props || typeof props !== "object" || Array.isArray(props)) {
+    throw new Error("Props must be an object.");
+  }
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc) {
+    throw new Error(`Cannot update props: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetNode = loc.node;
+  const previousProps = targetNode.props ? deepClone(targetNode.props) : {};
+  if (merge) {
+    targetNode.props = {
+      ...previousProps,
+      ...deepClone(props)
+    };
+  } else {
+    targetNode.props = deepClone(props);
+  }
+  return {
+    document: newDoc,
+    event: {
+      type: "PROPS_UPDATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: loc.parent ? loc.parent.id : void 0,
+      payload: {
+        props: targetNode.props,
+        previousProps
+      }
+    }
+  };
+}
+function updateStyle(document, params) {
+  const { nodeId, styles, breakpoint, state, merge = true } = params;
+  if (!styles || typeof styles !== "object" || Array.isArray(styles)) {
+    throw new Error("Styles must be an object.");
+  }
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc) {
+    throw new Error(`Cannot update style: Node with ID "${nodeId}" not found in document.`);
+  }
+  const targetNode = loc.node;
+  const currentStyles = targetNode.styles ? deepClone(targetNode.styles) : {};
+  const previousStyles = deepClone(currentStyles);
+  if (state) {
+    const newBreakpointStyles = StyleDefinitionSchema.parse(styles);
+    const states = { ...currentStyles.states ?? {} };
+    const currentStateStyles = states[state] ?? {};
+    if (merge) {
+      states[state] = { ...currentStateStyles, ...deepClone(newBreakpointStyles) };
+    } else {
+      states[state] = deepClone(newBreakpointStyles);
+    }
+    targetNode.styles = { ...currentStyles, states };
+    return {
+      document: newDoc,
+      event: {
+        type: "STYLE_UPDATED",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        nodeId,
+        parentId: loc.parent ? loc.parent.id : void 0,
+        payload: {
+          styles: targetNode.styles,
+          previousStyles,
+          state
+        }
+      }
+    };
+  }
+  if (breakpoint) {
+    const currentBreakpointStyles = currentStyles[breakpoint] || {};
+    const newBreakpointStyles = StyleDefinitionSchema.parse(styles);
+    if (merge) {
+      currentStyles[breakpoint] = {
+        ...currentBreakpointStyles,
+        ...deepClone(newBreakpointStyles)
+      };
+    } else {
+      currentStyles[breakpoint] = deepClone(newBreakpointStyles);
+    }
+  } else {
+    const responsiveStylesInput = ResponsiveStylesSchema.parse(styles);
+    if (merge) {
+      for (const bp of ["base", "desktop", "tablet", "mobile"]) {
+        if (responsiveStylesInput[bp] !== void 0) {
+          const currentBp = currentStyles[bp] || {};
+          const incomingBp = responsiveStylesInput[bp] || {};
+          currentStyles[bp] = {
+            ...currentBp,
+            ...deepClone(incomingBp)
+          };
+        }
+      }
+    } else {
+      targetNode.styles = deepClone(responsiveStylesInput);
+      return {
+        document: newDoc,
+        event: {
+          type: "STYLE_UPDATED",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          nodeId,
+          parentId: loc.parent ? loc.parent.id : void 0,
+          payload: {
+            styles: targetNode.styles,
+            previousStyles
+          }
+        }
+      };
+    }
+  }
+  targetNode.styles = currentStyles;
+  return {
+    document: newDoc,
+    event: {
+      type: "STYLE_UPDATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId: loc.parent ? loc.parent.id : void 0,
+      payload: {
+        styles: currentStyles,
+        previousStyles,
+        breakpoint
+      }
+    }
+  };
+}
+function removeNode(document, params) {
+  const { nodeId } = params;
+  if (nodeId === document.document.id) {
+    throw new Error("Cannot remove the root page node.");
+  }
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc || !loc.parent) {
+    throw new Error(`Cannot remove node: Node with ID "${nodeId}" not found in document.`);
+  }
+  const parentId = loc.parent.id;
+  const index = loc.index;
+  const [removedNode] = loc.parent.children.splice(index, 1);
+  return {
+    document: newDoc,
+    event: {
+      type: "NODE_REMOVED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId,
+      parentId,
+      index,
+      payload: {
+        node: removedNode
+      }
+    }
+  };
+}
+function duplicateNode(document, params) {
+  const { nodeId, targetParentId, index, idGenerator } = params;
+  if (nodeId === document.document.id) {
+    throw new Error("Cannot duplicate the root page node.");
+  }
+  const newDoc = deepClone(document);
+  const loc = findNodeLocation(newDoc.document, nodeId);
+  if (!loc || !loc.parent) {
+    throw new Error(`Cannot duplicate node: Node with ID "${nodeId}" not found in document.`);
+  }
+  const existingIds = collectNodeIdSet(newDoc.document);
+  const { clonedNode, idMap } = cloneTreeWithNewIds(loc.node, idGenerator, existingIds);
+  const destinationParentId = targetParentId || loc.parent.id;
+  const destParentLoc = findNodeLocation(newDoc.document, destinationParentId);
+  if (!destParentLoc) {
+    throw new Error(`Cannot duplicate node: Destination parent "${destinationParentId}" not found.`);
+  }
+  const destParent = destParentLoc.node;
+  if (!destParent.children) {
+    destParent.children = [];
+  }
+  let insertIndex;
+  if (typeof index === "number" && index >= 0 && index <= destParent.children.length) {
+    insertIndex = index;
+  } else if (destinationParentId === loc.parent.id) {
+    insertIndex = loc.index + 1;
+  } else {
+    insertIndex = destParent.children.length;
+  }
+  destParent.children.splice(insertIndex, 0, clonedNode);
+  return {
+    document: newDoc,
+    event: {
+      type: "NODE_DUPLICATED",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId: clonedNode.id,
+      parentId: destinationParentId,
+      index: insertIndex,
+      payload: {
+        originalNodeId: nodeId,
+        idMap: Object.fromEntries(idMap.entries())
+      }
+    }
+  };
+}
+
+// src/history.ts
+var DEFAULT_MAX_HISTORY = 50;
+var HistoryEngine = class {
+  past = [];
+  current;
+  future = [];
+  maxHistory;
+  constructor(initialState, options = {}) {
+    if (initialState === void 0 || initialState === null) {
+      throw new Error("Initial state must be defined.");
+    }
+    const limit = options.maxHistory ?? DEFAULT_MAX_HISTORY;
+    if (typeof limit !== "number" || limit <= 0 || !Number.isFinite(limit)) {
+      throw new Error("maxHistory option must be a positive integer.");
+    }
+    this.maxHistory = Math.floor(limit);
+    this.current = {
+      state: deepClone(initialState),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get the current active state (returns an immutable clone).
+   */
+  get present() {
+    return deepClone(this.current.state);
+  }
+  /**
+   * Check if undo is available.
+   */
+  canUndo() {
+    return this.past.length > 0;
+  }
+  /**
+   * Check if redo is available.
+   */
+  canRedo() {
+    return this.future.length > 0;
+  }
+  /**
+   * Get total number of states in undo stack.
+   */
+  get undoCount() {
+    return this.past.length;
+  }
+  /**
+   * Get total number of states in redo stack.
+   */
+  get redoCount() {
+    return this.future.length;
+  }
+  /**
+   * Get max history limit.
+   */
+  get limit() {
+    return this.maxHistory;
+  }
+  /**
+   * Push a new state.
+   * Clears the redo stack and shifts oldest past entries if maxHistory is exceeded.
+   */
+  push(nextState, event) {
+    if (nextState === void 0 || nextState === null) {
+      throw new Error("Cannot push undefined or null state into history.");
+    }
+    this.past.push(this.current);
+    while (this.past.length > this.maxHistory) {
+      this.past.shift();
+    }
+    this.current = {
+      state: deepClone(nextState),
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.future = [];
+  }
+  /**
+   * Undo to the previous state.
+   * Returns the restored state, or undefined if undo is not possible.
+   */
+  undo() {
+    if (!this.canUndo()) {
+      return void 0;
+    }
+    const previousEntry = this.past.pop();
+    this.future.unshift(this.current);
+    this.current = previousEntry;
+    return this.present;
+  }
+  /**
+   * Redo to the next state in future stack.
+   * Returns the restored state, or undefined if redo is not possible.
+   */
+  redo() {
+    if (!this.canRedo()) {
+      return void 0;
+    }
+    const nextEntry = this.future.shift();
+    this.past.push(this.current);
+    this.current = nextEntry;
+    return this.present;
+  }
+  /**
+   * Reset the history engine with a new initial state.
+   * Clears both undo and redo stacks (e.g. when loading a new document).
+   */
+  reset(newState) {
+    if (newState === void 0 || newState === null) {
+      throw new Error("New state must be defined when resetting history.");
+    }
+    this.past = [];
+    this.future = [];
+    this.current = {
+      state: deepClone(newState),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Clear both past and future stacks without changing the current state.
+   */
+  clear() {
+    this.past = [];
+    this.future = [];
+  }
+  /**
+   * Get a snapshot of current history status.
+   */
+  getState() {
+    return {
+      canUndo: this.canUndo(),
+      canRedo: this.canRedo(),
+      undoCount: this.undoCount,
+      redoCount: this.redoCount,
+      present: this.present
+    };
+  }
+};
+var DocumentHistoryManager = class {
+  history;
+  constructor(initialDocument, options) {
+    this.history = new HistoryEngine(initialDocument, options);
+  }
+  get document() {
+    return this.history.present;
+  }
+  get canUndo() {
+    return this.history.canUndo();
+  }
+  get canRedo() {
+    return this.history.canRedo();
+  }
+  /**
+   * Execute a mutation command immutably and record the resulting state and change event in history.
+   */
+  execute(executor) {
+    const currentDoc = this.history.present;
+    const result = executor(currentDoc);
+    this.history.push(result.document, result.event);
+    return result;
+  }
+  undo() {
+    return this.history.undo();
+  }
+  redo() {
+    return this.history.redo();
+  }
+  reset(newDocument) {
+    this.history.reset(newDocument);
+  }
+  clear() {
+    this.history.clear();
+  }
+  getState() {
+    return this.history.getState();
+  }
+};
+
+// src/migration.ts
+import {
+  CURRENT_SCHEMA_VERSION,
+  SCHEMA_NAME as SCHEMA_NAME3
+} from "@kubuild/schema";
+var MigrationRegistry = class {
+  steps = /* @__PURE__ */ new Map();
+  /**
+   * Register a migration step from one version to another.
+   */
+  register(step) {
+    const key = this.getKey(step.fromVersion, step.toVersion);
+    this.steps.set(key, step);
+  }
+  getKey(fromVersion, toVersion) {
+    return `${fromVersion}->${toVersion}`;
+  }
+  /**
+   * Find shortest path of versions to migrate from source to target using BFS.
+   */
+  findPath(sourceVersion, targetVersion) {
+    if (sourceVersion === targetVersion) {
+      return [sourceVersion];
+    }
+    const queue = [
+      { version: sourceVersion, path: [sourceVersion] }
+    ];
+    const visited = /* @__PURE__ */ new Set([sourceVersion]);
+    while (queue.length > 0) {
+      const { version: currentVersion, path } = queue.shift();
+      for (const step of this.steps.values()) {
+        if (step.fromVersion === currentVersion) {
+          const nextVersion = step.toVersion;
+          if (nextVersion === targetVersion) {
+            return [...path, nextVersion];
+          }
+          if (!visited.has(nextVersion)) {
+            visited.add(nextVersion);
+            queue.push({ version: nextVersion, path: [...path, nextVersion] });
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a valid migration path exists between source and target versions.
+   */
+  hasPath(sourceVersion, targetVersion) {
+    return this.findPath(sourceVersion, targetVersion) !== null;
+  }
+  /**
+   * Get the migration step handler for a direct version step.
+   */
+  getStep(fromVersion, toVersion) {
+    return this.steps.get(this.getKey(fromVersion, toVersion));
+  }
+};
+function convertNodeStylesToResponsive(node) {
+  if (node.styles && typeof node.styles === "object" && !Array.isArray(node.styles)) {
+    const styles = node.styles;
+    const hasBreakpointKeys = "base" in styles || "desktop" in styles || "tablet" in styles || "mobile" in styles;
+    if (!hasBreakpointKeys) {
+      node.styles = {
+        base: { ...styles }
+      };
+    }
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (child && typeof child === "object") {
+        convertNodeStylesToResponsive(child);
+      }
+    }
+  }
+}
+var defaultMigrationRegistry = new MigrationRegistry();
+defaultMigrationRegistry.register({
+  fromVersion: "0.1.0",
+  toVersion: "1.0.0",
+  description: "Migrate alpha 0.1.0 schema (root node key, flat styles) to v1.0.0",
+  migrate: (rawDoc) => {
+    const migrated = deepClone(rawDoc);
+    migrated.schema = SCHEMA_NAME3;
+    migrated.version = "1.0.0";
+    if (migrated.root && !migrated.document) {
+      migrated.document = migrated.root;
+      delete migrated.root;
+    }
+    if (!migrated.metadata || typeof migrated.metadata !== "object") {
+      migrated.metadata = {
+        title: "Migrated Page",
+        description: "",
+        author: "",
+        tags: [],
+        category: "general",
+        version: "1.0.0",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else {
+      const meta = migrated.metadata;
+      meta.title = meta.title || "Migrated Page";
+      meta.tags = Array.isArray(meta.tags) ? meta.tags : [];
+      meta.version = "1.0.0";
+    }
+    if (migrated.document && typeof migrated.document === "object") {
+      convertNodeStylesToResponsive(migrated.document);
+    }
+    return migrated;
+  }
+});
+defaultMigrationRegistry.register({
+  fromVersion: "0.2.0",
+  toVersion: "1.0.0",
+  description: "Migrate 0.2.0 schema to v1.0.0",
+  migrate: (rawDoc) => {
+    const migrated = deepClone(rawDoc);
+    migrated.schema = SCHEMA_NAME3;
+    migrated.version = "1.0.0";
+    if (migrated.document && typeof migrated.document === "object") {
+      convertNodeStylesToResponsive(migrated.document);
+    }
+    return migrated;
+  }
+});
+defaultMigrationRegistry.register({
+  fromVersion: "0.9.0",
+  toVersion: "1.0.0",
+  description: "Migrate 0.9.0 beta schema to v1.0.0",
+  migrate: (rawDoc) => {
+    const migrated = deepClone(rawDoc);
+    migrated.schema = SCHEMA_NAME3;
+    migrated.version = "1.0.0";
+    if (!migrated.metadata || typeof migrated.metadata !== "object") {
+      migrated.metadata = {
+        title: "Migrated Page",
+        description: "",
+        author: "",
+        tags: [],
+        category: "general",
+        version: "1.0.0"
+      };
+    }
+    return migrated;
+  }
+});
+defaultMigrationRegistry.register({
+  fromVersion: "1.0",
+  toVersion: "1.0.0",
+  description: "Normalize 1.0 version string to 1.0.0",
+  migrate: (rawDoc) => {
+    const migrated = deepClone(rawDoc);
+    migrated.version = "1.0.0";
+    return migrated;
+  }
+});
+function canMigrate(sourceVersion, targetVersion = CURRENT_SCHEMA_VERSION, registry = defaultMigrationRegistry) {
+  if (!sourceVersion || !targetVersion) return false;
+  if (sourceVersion === targetVersion) return true;
+  return registry.hasPath(sourceVersion, targetVersion);
+}
+function getMigrationPath(sourceVersion, targetVersion = CURRENT_SCHEMA_VERSION, registry = defaultMigrationRegistry) {
+  if (!sourceVersion || !targetVersion) return null;
+  return registry.findPath(sourceVersion, targetVersion);
+}
+function migrateDocument(rawDocument, options = {}) {
+  const targetVersion = options.targetVersion ?? CURRENT_SCHEMA_VERSION;
+  const dryRun = options.dryRun ?? false;
+  const registry = options.registry ?? defaultMigrationRegistry;
+  const validate = options.validate ?? true;
+  if (!rawDocument || typeof rawDocument !== "object" || Array.isArray(rawDocument)) {
+    const error = {
+      code: "INVALID_SOURCE_DOCUMENT",
+      message: "Source document must be a non-null object.",
+      sourceVersion: "unknown",
+      targetVersion
+    };
+    return {
+      success: false,
+      diagnostic: {
+        success: false,
+        sourceVersion: "unknown",
+        targetVersion,
+        migrationPath: [],
+        stepsApplied: 0,
+        dryRun,
+        errors: [error]
+      }
+    };
+  }
+  const doc = rawDocument;
+  const sourceVersion = typeof doc.version === "string" ? doc.version.trim() : "unknown";
+  if (sourceVersion === targetVersion) {
+    const cloned = deepClone(doc);
+    if (validate) {
+      const validation = validateDocument(cloned);
+      if (!validation.valid) {
+        return {
+          success: false,
+          diagnostic: {
+            success: false,
+            sourceVersion,
+            targetVersion,
+            migrationPath: [sourceVersion],
+            stepsApplied: 0,
+            dryRun,
+            errors: validation.errors.map((e) => ({
+              code: "INVALID_SOURCE_DOCUMENT",
+              message: `Validation error: ${e.message} at ${e.path}`,
+              sourceVersion,
+              targetVersion
+            }))
+          }
+        };
+      }
+    }
+    return {
+      success: true,
+      document: cloned,
+      diagnostic: {
+        success: true,
+        sourceVersion,
+        targetVersion,
+        migrationPath: [sourceVersion],
+        stepsApplied: 0,
+        dryRun
+      }
+    };
+  }
+  const path = registry.findPath(sourceVersion, targetVersion);
+  if (!path || path.length <= 1) {
+    const error = {
+      code: "NO_MIGRATION_PATH",
+      message: `No migration path found from schema version "${sourceVersion}" to "${targetVersion}".`,
+      sourceVersion,
+      targetVersion
+    };
+    return {
+      success: false,
+      diagnostic: {
+        success: false,
+        sourceVersion,
+        targetVersion,
+        migrationPath: [],
+        stepsApplied: 0,
+        dryRun,
+        errors: [error]
+      }
+    };
+  }
+  if (dryRun) {
+    return {
+      success: true,
+      diagnostic: {
+        success: true,
+        sourceVersion,
+        targetVersion,
+        migrationPath: path,
+        stepsApplied: path.length - 1,
+        dryRun: true
+      }
+    };
+  }
+  let currentDoc = deepClone(doc);
+  let stepsApplied = 0;
+  for (let i = 0; i < path.length - 1; i++) {
+    const fromVer = path[i];
+    const toVer = path[i + 1];
+    const step = registry.getStep(fromVer, toVer);
+    if (!step) {
+      const error = {
+        code: "MIGRATION_EXECUTION_FAILED",
+        message: `Registered migration step for "${fromVer}" -> "${toVer}" is missing executor.`,
+        sourceVersion,
+        targetVersion
+      };
+      return {
+        success: false,
+        diagnostic: {
+          success: false,
+          sourceVersion,
+          targetVersion,
+          migrationPath: path,
+          stepsApplied,
+          dryRun,
+          errors: [error]
+        }
+      };
+    }
+    try {
+      currentDoc = step.migrate(currentDoc);
+      stepsApplied++;
+    } catch (err) {
+      const error = {
+        code: "MIGRATION_EXECUTION_FAILED",
+        message: `Failed executing migration step from "${fromVer}" to "${toVer}": ${err instanceof Error ? err.message : String(err)}`,
+        sourceVersion,
+        targetVersion,
+        details: { stepFrom: fromVer, stepTo: toVer }
+      };
+      return {
+        success: false,
+        diagnostic: {
+          success: false,
+          sourceVersion,
+          targetVersion,
+          migrationPath: path,
+          stepsApplied,
+          dryRun,
+          errors: [error]
+        }
+      };
+    }
+  }
+  const finalDoc = currentDoc;
+  if (validate) {
+    const validation = validateDocument(finalDoc);
+    if (!validation.valid) {
+      return {
+        success: false,
+        diagnostic: {
+          success: false,
+          sourceVersion,
+          targetVersion,
+          migrationPath: path,
+          stepsApplied,
+          dryRun,
+          errors: validation.errors.map((e) => ({
+            code: "MIGRATION_EXECUTION_FAILED",
+            message: `Post-migration validation error: ${e.message} at ${e.path}`,
+            sourceVersion,
+            targetVersion
+          }))
+        }
+      };
+    }
+  }
+  return {
+    success: true,
+    document: finalDoc,
+    diagnostic: {
+      success: true,
+      sourceVersion,
+      targetVersion,
+      migrationPath: path,
+      stepsApplied,
+      dryRun: false
+    }
+  };
+}
+
+// src/exporter.ts
+import { zipSync, strToU8 } from "fflate";
+import {
+  SCHEMA_NAME as SCHEMA_NAME4,
+  CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2
+} from "@kubuild/schema";
+function sha256Sync(data) {
+  const K = [
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ];
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const length = data.length;
+  const bitLength = length * 8;
+  const newLength = length + 9 + 63 >>> 6 << 6;
+  const padded = new Uint8Array(newLength);
+  padded.set(data);
+  padded[length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(newLength - 4, bitLength >>> 0, false);
+  view.setUint32(newLength - 8, Math.floor(bitLength / 4294967296), false);
+  const w = new Uint32Array(64);
+  for (let chunk = 0; chunk < newLength; chunk += 64) {
+    for (let i = 0; i < 16; i++) {
+      w[i] = view.getUint32(chunk + i * 4, false);
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = (w[i - 15] >>> 7 | w[i - 15] << 25) ^ (w[i - 15] >>> 18 | w[i - 15] << 14) ^ w[i - 15] >>> 3;
+      const s1 = (w[i - 2] >>> 17 | w[i - 2] << 15) ^ (w[i - 2] >>> 19 | w[i - 2] << 13) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const result = [h0, h1, h2, h3, h4, h5, h6, h7].map((val) => val.toString(16).padStart(8, "0")).join("");
+  return result;
+}
+async function calculateChecksum(data) {
+  if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle?.digest) {
+    try {
+      const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", buffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      return `sha256:${hashHex}`;
+    } catch {
+    }
+  }
+  return `sha256:${sha256Sync(data)}`;
+}
+function sanitizeFilename(filename, assetId, mimeType) {
+  let name = (filename || "").trim();
+  name = name.replace(/^[./\\]+/, "").replace(/[/\\]+/g, "_").replace(/\0/g, "");
+  name = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  if (!name || name === "." || name === "..") {
+    const ext = getExtensionFromMime(mimeType) || "bin";
+    const cleanId = assetId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    name = `${cleanId}.${ext}`;
+  }
+  return name;
+}
+function getExtensionFromMime(mimeType) {
+  if (!mimeType) return null;
+  const m = mimeType.toLowerCase();
+  if (m.includes("png")) return "png";
+  if (m.includes("jpeg") || m.includes("jpg")) return "jpg";
+  if (m.includes("webp")) return "webp";
+  if (m.includes("svg")) return "svg";
+  if (m.includes("gif")) return "gif";
+  if (m.includes("json")) return "json";
+  if (m.includes("pdf")) return "pdf";
+  if (m.includes("mp4")) return "mp4";
+  if (m.includes("mp3")) return "mp3";
+  return null;
+}
+async function convertToUint8Array(input) {
+  if (!input) return null;
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const arrayBuffer = await input.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  }
+  if (typeof input === "string") {
+    if (input.startsWith("data:")) {
+      const commaIdx = input.indexOf(",");
+      if (commaIdx !== -1) {
+        const meta = input.substring(0, commaIdx);
+        const rawData = input.substring(commaIdx + 1);
+        if (meta.includes(";base64")) {
+          if (typeof atob === "function") {
+            const binary = atob(rawData);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+              bytes[i] = binary.charCodeAt(i);
+            }
+            return bytes;
+          }
+        }
+      }
+    }
+    return new TextEncoder().encode(input);
+  }
+  return null;
+}
+async function exportPackage(document, options = {}) {
+  const validation = validateDocument(document, {
+    componentRegistry: options.componentRegistry,
+    knownComponentTypes: options.knownComponentTypes,
+    ...options.validationOptions
+  });
+  if (!validation.valid || !validation.data) {
+    const diagnosticMessage = `Document validation failed with ${validation.errors.length} error(s):
+` + validation.errors.map((e) => `[${e.code}] ${e.path}: ${e.message}`).join("\n");
+    return {
+      success: false,
+      errors: validation.errors,
+      diagnosticMessage
+    };
+  }
+  const pageDoc = JSON.parse(JSON.stringify(validation.data));
+  if (options.metadata) {
+    pageDoc.metadata = {
+      ...pageDoc.metadata || {
+        title: "Untitled Page",
+        description: "",
+        author: "",
+        tags: [],
+        category: "general",
+        version: "1.0.0"
+      },
+      ...options.metadata,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const collectedAssets = collectAssetReferences(pageDoc.document);
+  const assetRefsById = /* @__PURE__ */ new Map();
+  for (const item of collectedAssets) {
+    if (!assetRefsById.has(item.assetId)) {
+      assetRefsById.set(item.assetId, item);
+    }
+  }
+  const requirements = extractRequirementsFromTree(pageDoc.document, options.componentRegistry);
+  const manifestAssets = [];
+  const archiveFiles = {};
+  const assetCollectionErrors = [];
+  const usedArchivePaths = /* @__PURE__ */ new Set();
+  for (const [assetId, assetRef] of assetRefsById.entries()) {
+    let rawAsset;
+    let customMime = assetRef.reference.mimeType;
+    let customFilename = assetRef.reference.filename;
+    if (options.assets) {
+      if (options.assets instanceof Map) {
+        rawAsset = options.assets.get(assetId);
+      } else if (typeof options.assets === "object" && assetId in options.assets) {
+        rawAsset = options.assets[assetId];
+      }
+    }
+    if (!rawAsset && options.getAssetBytes) {
+      try {
+        rawAsset = await options.getAssetBytes(assetId, assetRef);
+      } catch (err) {
+        assetCollectionErrors.push({
+          code: "INVALID_ASSET_REFERENCE",
+          message: `Failed to retrieve asset bytes for "${assetId}": ${err instanceof Error ? err.message : String(err)}`,
+          path: assetRef.propPath,
+          nodeId: assetRef.nodeId
+        });
+        continue;
+      }
+    }
+    if (!rawAsset && options.assetProvider?.resolve) {
+      try {
+        const resolved = await options.assetProvider.resolve(assetId);
+        if (resolved) {
+          rawAsset = resolved;
+        }
+      } catch {
+      }
+    }
+    let dataToConvert = rawAsset;
+    if (rawAsset && typeof rawAsset === "object" && "data" in rawAsset) {
+      const assetObj = rawAsset;
+      dataToConvert = assetObj.data;
+      if (assetObj.mimeType) customMime = assetObj.mimeType;
+      if (assetObj.filename) customFilename = assetObj.filename;
+    }
+    const assetBytes = await convertToUint8Array(dataToConvert);
+    if (assetBytes) {
+      const sanitizedName = sanitizeFilename(customFilename, assetId, customMime);
+      let archivePath = `assets/${sanitizedName}`;
+      let counter = 1;
+      while (usedArchivePaths.has(archivePath)) {
+        const extDot = sanitizedName.lastIndexOf(".");
+        if (extDot !== -1) {
+          archivePath = `assets/${sanitizedName.substring(0, extDot)}_${counter}${sanitizedName.substring(extDot)}`;
+        } else {
+          archivePath = `assets/${sanitizedName}_${counter}`;
+        }
+        counter++;
+      }
+      usedArchivePaths.add(archivePath);
+      const mimeType = customMime || "application/octet-stream";
+      const checksum = await calculateChecksum(assetBytes);
+      manifestAssets.push({
+        id: assetId,
+        path: archivePath,
+        mimeType,
+        size: assetBytes.byteLength,
+        checksum
+      });
+      archiveFiles[archivePath] = assetBytes;
+    } else {
+      const isExternal = Boolean(assetRef.reference.fallbackUrl || options.allowExternalFallback);
+      if (!isExternal) {
+        assetCollectionErrors.push({
+          code: "INVALID_ASSET_REFERENCE",
+          message: `Required asset "${assetId}" could not be collected for export and has no external fallback`,
+          path: assetRef.propPath,
+          nodeId: assetRef.nodeId
+        });
+      }
+    }
+  }
+  if (assetCollectionErrors.length > 0) {
+    const diagnosticMessage = `Asset collection failed with ${assetCollectionErrors.length} error(s):
+` + assetCollectionErrors.map((e) => `[${e.code}] ${e.path}: ${e.message}`).join("\n");
+    return {
+      success: false,
+      errors: assetCollectionErrors,
+      diagnosticMessage
+    };
+  }
+  const metadata = pageDoc.metadata || {
+    title: "Untitled Page",
+    description: "",
+    author: "",
+    tags: [],
+    category: "general",
+    version: "1.0.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const manifest = {
+    schema: SCHEMA_NAME4,
+    schemaVersion: pageDoc.version || CURRENT_SCHEMA_VERSION2,
+    packageVersion: options.packageVersion || "1.0.0",
+    builderCompatibility: options.builderCompatibility || ">=0.1.0",
+    requiredComponents: requirements.requiredComponents,
+    requiredCapabilities: requirements.requiredCapabilities,
+    assets: manifestAssets,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  archiveFiles["manifest.json"] = strToU8(JSON.stringify(manifest, null, 2));
+  archiveFiles["page.json"] = strToU8(JSON.stringify(pageDoc, null, 2));
+  archiveFiles["metadata.json"] = strToU8(JSON.stringify(metadata, null, 2));
+  const archive = zipSync(archiveFiles, { level: 6 });
+  return {
+    success: true,
+    archive,
+    manifest,
+    page: pageDoc,
+    metadata,
+    assetCount: manifestAssets.length
+  };
+}
+var exportStoraPackage = exportPackage;
+
+// src/importer.ts
+import { unzipSync, strFromU8 } from "fflate";
+import {
+  ManifestSchema,
+  CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION3
+} from "@kubuild/schema";
+var DEFAULT_SECURITY_LIMITS = {
+  maxArchiveSize: 50 * 1024 * 1024,
+  // 50 MB
+  maxUncompressedSize: 100 * 1024 * 1024,
+  // 100 MB
+  maxFileCount: 1e3,
+  maxAssetSize: 25 * 1024 * 1024
+  // 25 MB
+};
+function isDangerousPath(filepath) {
+  if (!filepath || typeof filepath !== "string") return true;
+  if (filepath.includes("\0")) return true;
+  if (filepath.startsWith("/") || filepath.startsWith("\\") || /^[a-zA-Z]:/.test(filepath)) {
+    return true;
+  }
+  const normalized = filepath.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  for (const seg of segments) {
+    if (seg === ".." || seg.trim() === "..") {
+      return true;
+    }
+  }
+  return false;
+}
+async function preflightPackage(archiveData, options = {}) {
+  const limits = {
+    ...DEFAULT_SECURITY_LIMITS,
+    ...options.securityLimits
+  };
+  const targetVersion = options.targetSchemaVersion || CURRENT_SCHEMA_VERSION3;
+  const migrationRegistry = options.migrationRegistry || defaultMigrationRegistry;
+  const diagnostics = [];
+  let dependencyPolicy = options.dependencyPolicy || "cancel";
+  if (!options.dependencyPolicy) {
+    if (options.allowMissingComponents && options.allowMissingCapabilities) {
+      dependencyPolicy = "import-with-placeholder";
+    }
+  }
+  const assetCollisionStrategy = options.assetCollisionStrategy || "reject";
+  const archiveBytes = archiveData instanceof Uint8Array ? archiveData : new Uint8Array(archiveData);
+  if (!archiveBytes || archiveBytes.byteLength === 0) {
+    diagnostics.push({
+      code: "ARCHIVE_EMPTY",
+      severity: "error",
+      message: "Archive is empty or 0 bytes."
+    });
+    return buildReport(false, false, { targetVersion, dependencyPolicy, assetCollisionStrategy, diagnostics });
+  }
+  if (archiveBytes.byteLength > limits.maxArchiveSize) {
+    diagnostics.push({
+      code: "SIZE_LIMIT_EXCEEDED",
+      severity: "error",
+      message: `Archive size (${archiveBytes.byteLength} bytes) exceeds maximum limit of ${limits.maxArchiveSize} bytes.`,
+      details: { actualBytes: archiveBytes.byteLength, limitBytes: limits.maxArchiveSize }
+    });
+    return buildReport(false, false, { targetVersion, dependencyPolicy, assetCollisionStrategy, diagnostics });
+  }
+  let unzipped;
+  try {
+    unzipped = unzipSync(archiveBytes);
+  } catch (err) {
+    diagnostics.push({
+      code: "ARCHIVE_CORRUPT",
+      severity: "error",
+      message: `Failed to unzip archive: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return buildReport(false, false, { targetVersion, dependencyPolicy, assetCollisionStrategy, diagnostics });
+  }
+  const entries = Object.keys(unzipped);
+  if (entries.length > limits.maxFileCount) {
+    diagnostics.push({
+      code: "FILE_COUNT_EXCEEDED",
+      severity: "error",
+      message: `Archive file count (${entries.length}) exceeds maximum limit of ${limits.maxFileCount}.`,
+      details: { fileCount: entries.length, limit: limits.maxFileCount }
+    });
+  }
+  let totalUncompressedBytes = 0;
+  for (const entryPath of entries) {
+    if (isDangerousPath(entryPath)) {
+      diagnostics.push({
+        code: "ZIP_SLIP_DETECTED",
+        severity: "error",
+        message: `Security violation: Path traversal or Zip-Slip attempt detected in archive entry "${entryPath}".`,
+        path: entryPath
+      });
+    }
+    if (entryPath.startsWith("assets/") && isDangerousAssetFilename(entryPath)) {
+      diagnostics.push({
+        code: "EXECUTABLE_ASSET_DETECTED",
+        severity: "error",
+        message: `Security violation: Executable or dangerous asset file extension detected in archive entry "${entryPath}".`,
+        path: entryPath
+      });
+    }
+    const fileBytes = unzipped[entryPath];
+    if (fileBytes) {
+      totalUncompressedBytes += fileBytes.byteLength;
+      if (entryPath.startsWith("assets/") && fileBytes.byteLength > limits.maxAssetSize) {
+        diagnostics.push({
+          code: "ASSET_LIMIT_EXCEEDED",
+          severity: "error",
+          message: `Asset "${entryPath}" size (${fileBytes.byteLength} bytes) exceeds maximum limit of ${limits.maxAssetSize} bytes.`,
+          path: entryPath,
+          details: { actualBytes: fileBytes.byteLength, limitBytes: limits.maxAssetSize }
+        });
+      }
+    }
+  }
+  if (totalUncompressedBytes > limits.maxUncompressedSize) {
+    diagnostics.push({
+      code: "SIZE_LIMIT_EXCEEDED",
+      severity: "error",
+      message: `Total uncompressed archive size (${totalUncompressedBytes} bytes) exceeds maximum limit of ${limits.maxUncompressedSize} bytes.`,
+      details: { actualBytes: totalUncompressedBytes, limitBytes: limits.maxUncompressedSize }
+    });
+  }
+  if (checkZipBomb(archiveBytes.byteLength, totalUncompressedBytes)) {
+    diagnostics.push({
+      code: "SIZE_LIMIT_EXCEEDED",
+      severity: "error",
+      message: `Security violation: Potential Zip Bomb attack detected (excessive compression ratio).`,
+      details: { compressedBytes: archiveBytes.byteLength, uncompressedBytes: totalUncompressedBytes }
+    });
+  }
+  const manifestEntry = unzipped["manifest.json"];
+  if (!manifestEntry) {
+    diagnostics.push({
+      code: "MISSING_MANIFEST",
+      severity: "error",
+      message: 'Archive is missing mandatory "manifest.json" file.'
+    });
+  }
+  const pageEntry = unzipped["page.json"];
+  if (!pageEntry) {
+    diagnostics.push({
+      code: "MISSING_PAGE_DOCUMENT",
+      severity: "error",
+      message: 'Archive is missing mandatory "page.json" file.'
+    });
+  }
+  if (!manifestEntry || !pageEntry || diagnostics.some((d) => d.code === "ZIP_SLIP_DETECTED")) {
+    return buildReport(false, false, {
+      targetVersion,
+      dependencyPolicy,
+      assetCollisionStrategy,
+      totalUncompressedBytes,
+      diagnostics
+    });
+  }
+  let parsedManifest;
+  try {
+    const manifestJson = JSON.parse(strFromU8(manifestEntry));
+    const manifestProtoCheck = containsProhibitedKeys(manifestJson);
+    if (manifestProtoCheck.found) {
+      diagnostics.push({
+        code: "PROTOTYPE_POLLUTION_DETECTED",
+        severity: "error",
+        message: `Security violation: Prohibited key "${manifestProtoCheck.key}" in manifest.json.`,
+        path: manifestProtoCheck.path
+      });
+    }
+    const parseResult = ManifestSchema.safeParse(manifestJson);
+    if (!parseResult.success) {
+      const issues = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+      diagnostics.push({
+        code: "INVALID_MANIFEST",
+        severity: "error",
+        message: `Manifest validation failed: ${issues}`,
+        details: { issues: parseResult.error.issues }
+      });
+    } else {
+      parsedManifest = parseResult.data;
+    }
+  } catch (err) {
+    diagnostics.push({
+      code: "INVALID_MANIFEST",
+      severity: "error",
+      message: `Failed to parse "manifest.json" as valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  let rawMetadata;
+  const metadataEntry = unzipped["metadata.json"];
+  if (metadataEntry) {
+    try {
+      rawMetadata = JSON.parse(strFromU8(metadataEntry));
+    } catch {
+    }
+  }
+  let rawPageDoc;
+  try {
+    rawPageDoc = JSON.parse(strFromU8(pageEntry));
+    const pageProtoCheck = containsProhibitedKeys(rawPageDoc);
+    if (pageProtoCheck.found) {
+      diagnostics.push({
+        code: "PROTOTYPE_POLLUTION_DETECTED",
+        severity: "error",
+        message: `Security violation: Prohibited key "${pageProtoCheck.key}" in page.json.`,
+        path: pageProtoCheck.path
+      });
+    }
+  } catch (err) {
+    diagnostics.push({
+      code: "INVALID_PAGE_DOCUMENT",
+      severity: "error",
+      message: `Failed to parse "page.json" as valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  const docVersion = typeof rawPageDoc?.version === "string" ? rawPageDoc.version : parsedManifest?.schemaVersion || "unknown";
+  let requiresMigration = false;
+  let migrationPath;
+  if (rawPageDoc) {
+    if (docVersion !== targetVersion) {
+      if (canMigrate(docVersion, targetVersion, migrationRegistry)) {
+        requiresMigration = true;
+        migrationPath = getMigrationPath(docVersion, targetVersion, migrationRegistry) || void 0;
+        diagnostics.push({
+          code: "UNSUPPORTED_SCHEMA_VERSION",
+          severity: "info",
+          message: `Document schema version "${docVersion}" requires migration to current version "${targetVersion}".`,
+          details: { sourceVersion: docVersion, targetVersion, migrationPath }
+        });
+      } else {
+        diagnostics.push({
+          code: "NO_MIGRATION_PATH",
+          severity: "error",
+          message: `Document schema version "${docVersion}" is not compatible and no migration path exists to "${targetVersion}".`,
+          details: { sourceVersion: docVersion, targetVersion }
+        });
+      }
+    } else {
+      const docValidation = validateDocument(rawPageDoc, {
+        componentRegistry: options.componentRegistry,
+        knownComponentTypes: options.knownComponentTypes
+      });
+      const criticalDocErrors = docValidation.errors.filter((e) => {
+        if (e.code === "UNKNOWN_COMPONENT_TYPE" && dependencyPolicy !== "cancel") {
+          return false;
+        }
+        return true;
+      });
+      if (criticalDocErrors.length > 0) {
+        diagnostics.push({
+          code: "INVALID_PAGE_DOCUMENT",
+          severity: "error",
+          message: `Document validation failed with ${criticalDocErrors.length} error(s):
+` + criticalDocErrors.map((e) => `[${e.code}] ${e.path}: ${e.message}`).join("\n")
+        });
+      }
+    }
+  }
+  const missingComponents = [];
+  const missingCapabilities = [];
+  const assetConflicts = [];
+  const existingAssetIdsSet = /* @__PURE__ */ new Set();
+  if (options.existingAssetIds) {
+    if (Array.isArray(options.existingAssetIds)) {
+      for (const id of options.existingAssetIds) existingAssetIdsSet.add(id);
+    } else if (options.existingAssetIds instanceof Set) {
+      for (const id of options.existingAssetIds) existingAssetIdsSet.add(id);
+    }
+  }
+  if (options.assetProvider?.list && !options.existingAssetIds) {
+    try {
+      const list = await options.assetProvider.list();
+      if (Array.isArray(list)) {
+        for (const item of list) {
+          if (item?.id) existingAssetIdsSet.add(item.id);
+        }
+      }
+    } catch {
+    }
+  }
+  if (parsedManifest) {
+    for (const assetItem of parsedManifest.assets) {
+      const assetFile = unzipped[assetItem.path];
+      if (!assetFile) {
+        diagnostics.push({
+          code: "ASSET_FILE_MISSING",
+          severity: "error",
+          message: `Declared asset "${assetItem.id}" is missing in archive at path "${assetItem.path}".`,
+          path: assetItem.path,
+          details: { assetId: assetItem.id }
+        });
+        continue;
+      }
+      if (assetFile.byteLength !== assetItem.size) {
+        diagnostics.push({
+          code: "ASSET_SIZE_MISMATCH",
+          severity: "error",
+          message: `Asset "${assetItem.id}" size mismatch: expected ${assetItem.size} bytes, found ${assetFile.byteLength} bytes.`,
+          path: assetItem.path,
+          details: { assetId: assetItem.id, expected: assetItem.size, actual: assetFile.byteLength }
+        });
+      }
+      if (assetItem.checksum) {
+        const actualChecksum = await calculateChecksum(assetFile);
+        if (actualChecksum !== assetItem.checksum) {
+          diagnostics.push({
+            code: "ASSET_CHECKSUM_MISMATCH",
+            severity: "error",
+            message: `Asset "${assetItem.id}" checksum mismatch: expected ${assetItem.checksum}, calculated ${actualChecksum}.`,
+            path: assetItem.path,
+            details: { assetId: assetItem.id, expected: assetItem.checksum, actual: actualChecksum }
+          });
+        }
+      }
+      let isConflict = false;
+      if (typeof options.existingAssetIds === "function") {
+        const fnRes = await options.existingAssetIds(assetItem.id);
+        if (fnRes) isConflict = true;
+      } else if (existingAssetIdsSet.has(assetItem.id)) {
+        isConflict = true;
+      }
+      if (isConflict) {
+        assetConflicts.push({
+          assetId: assetItem.id,
+          path: assetItem.path,
+          mimeType: assetItem.mimeType,
+          size: assetItem.size
+        });
+      }
+    }
+    if (assetConflicts.length > 0) {
+      const conflictIds = assetConflicts.map((c) => c.assetId).join(", ");
+      if (assetCollisionStrategy === "reject" && !options.onAssetConflict) {
+        diagnostics.push({
+          code: "ASSET_CONFLICT",
+          severity: "error",
+          message: `Asset collision detected for asset(s): ${conflictIds}. Host assets will not be overwritten without an explicit assetCollisionStrategy.`,
+          details: { assetConflicts, strategy: assetCollisionStrategy }
+        });
+      } else {
+        diagnostics.push({
+          code: "ASSET_CONFLICT",
+          severity: "info",
+          message: `Asset collision detected for asset(s): ${conflictIds}. Strategy "${assetCollisionStrategy}" will be applied on import.`,
+          details: { assetConflicts, strategy: assetCollisionStrategy }
+        });
+      }
+    }
+    const knownSet = /* @__PURE__ */ new Set();
+    if (options.knownComponentTypes) {
+      for (const t of options.knownComponentTypes) knownSet.add(t);
+    }
+    const builtIns = ["page", "section", "container", "columns", "heading", "text", "image", "button", "collection"];
+    for (const b of builtIns) knownSet.add(b);
+    for (const compType of parsedManifest.requiredComponents) {
+      let isSupported = knownSet.has(compType);
+      if (!isSupported && options.componentRegistry) {
+        isSupported = options.componentRegistry.has(compType);
+      }
+      if (!isSupported) {
+        missingComponents.push(compType);
+      }
+    }
+    if (missingComponents.length > 0) {
+      if (dependencyPolicy === "cancel" && !options.allowMissingComponents) {
+        diagnostics.push({
+          code: "MISSING_COMPONENTS",
+          severity: "error",
+          message: `Package requires custom component(s) not registered in host: ${missingComponents.join(", ")}.`,
+          details: { missingComponents, policy: dependencyPolicy }
+        });
+      } else if (dependencyPolicy === "import-with-placeholder" || options.allowMissingComponents) {
+        diagnostics.push({
+          code: "MISSING_COMPONENTS",
+          severity: "warning",
+          message: `Package requires custom component(s) [${missingComponents.join(", ")}] not registered in host. Nodes and props are preserved intact for placeholder rendering.`,
+          details: { missingComponents, policy: dependencyPolicy }
+        });
+      } else if (dependencyPolicy === "install-or-register-before-import") {
+        diagnostics.push({
+          code: "MISSING_COMPONENTS",
+          severity: "info",
+          message: `Package requires custom component(s) [${missingComponents.join(", ")}]. Installation/registration required before import.`,
+          details: { missingComponents, policy: dependencyPolicy }
+        });
+      }
+    }
+    const supportedCaps = /* @__PURE__ */ new Set();
+    if (options.supportedCapabilities) {
+      for (const c of options.supportedCapabilities) supportedCaps.add(c);
+    }
+    for (const cap of parsedManifest.requiredCapabilities) {
+      if (!supportedCaps.has(cap)) {
+        missingCapabilities.push(cap);
+      }
+    }
+    if (missingCapabilities.length > 0) {
+      if (dependencyPolicy === "cancel" && !options.allowMissingCapabilities) {
+        diagnostics.push({
+          code: "MISSING_CAPABILITIES",
+          severity: "error",
+          message: `Package requires capability/capabilities not supported by host: ${missingCapabilities.join(", ")}.`,
+          details: { missingCapabilities, policy: dependencyPolicy }
+        });
+      } else if (dependencyPolicy === "import-with-placeholder" || options.allowMissingCapabilities) {
+        diagnostics.push({
+          code: "MISSING_CAPABILITIES",
+          severity: "warning",
+          message: `Package requires capability/capabilities [${missingCapabilities.join(", ")}] not supported by host. Placeholder rendering enabled.`,
+          details: { missingCapabilities, policy: dependencyPolicy }
+        });
+      } else if (dependencyPolicy === "install-or-register-before-import") {
+        diagnostics.push({
+          code: "MISSING_CAPABILITIES",
+          severity: "info",
+          message: `Package requires capability/capabilities [${missingCapabilities.join(", ")}]. Registration required before import.`,
+          details: { missingCapabilities, policy: dependencyPolicy }
+        });
+      }
+    }
+  }
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  const valid = !hasErrors;
+  const canImport = valid;
+  return buildReport(valid, canImport, {
+    manifest: parsedManifest,
+    rawMetadata,
+    sourceVersion: docVersion,
+    targetVersion,
+    requiresMigration,
+    migrationPath,
+    missingComponents,
+    missingCapabilities,
+    dependencyPolicy,
+    assetCount: parsedManifest?.assets.length || 0,
+    assetConflicts,
+    assetCollisionStrategy,
+    totalUncompressedBytes,
+    diagnostics
+  });
+}
+function buildReport(valid, canImport, fields) {
+  return {
+    valid,
+    canImport,
+    targetVersion: fields.targetVersion || CURRENT_SCHEMA_VERSION3,
+    requiresMigration: fields.requiresMigration || false,
+    missingComponents: fields.missingComponents || [],
+    missingCapabilities: fields.missingCapabilities || [],
+    dependencyPolicy: fields.dependencyPolicy || "cancel",
+    assetCount: fields.assetCount || 0,
+    assetConflicts: fields.assetConflicts || [],
+    assetCollisionStrategy: fields.assetCollisionStrategy || "reject",
+    totalUncompressedBytes: fields.totalUncompressedBytes || 0,
+    diagnostics: fields.diagnostics || [],
+    ...fields
+  };
+}
+var previewImportPackage = preflightPackage;
+var inspectPackage = preflightPackage;
+function defaultRenameAssetStrategy(incoming, existingIds) {
+  let candidate = `${incoming.id}_imported`;
+  let counter = 1;
+  while (existingIds.has(candidate)) {
+    candidate = `${incoming.id}_imported_${counter}`;
+    counter++;
+  }
+  return candidate;
+}
+async function importPackage(archiveData, options = {}) {
+  let preflight = await preflightPackage(archiveData, options);
+  const dependencyPolicy = options.dependencyPolicy || preflight.dependencyPolicy;
+  if (dependencyPolicy === "install-or-register-before-import" && (preflight.missingComponents.length > 0 || preflight.missingCapabilities.length > 0) && options.onMissingDependency) {
+    try {
+      await options.onMissingDependency(
+        {
+          components: [...preflight.missingComponents],
+          capabilities: [...preflight.missingCapabilities]
+        },
+        preflight
+      );
+      preflight = await preflightPackage(archiveData, {
+        ...options,
+        dependencyPolicy: "cancel"
+        // Strict check after install attempt
+      });
+    } catch (err) {
+      const diag = {
+        code: "HOST_ADAPTER_ERROR",
+        severity: "error",
+        message: `Dynamic dependency registration failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+      return {
+        success: false,
+        errors: [diag],
+        diagnosticMessage: diag.message,
+        preflight
+      };
+    }
+  }
+  if (!preflight.canImport || !preflight.manifest) {
+    const errorDiagnostics = preflight.diagnostics.filter((d) => d.severity === "error");
+    const diagnosticMessage = `Package import rejected with ${errorDiagnostics.length} error(s):
+` + errorDiagnostics.map((d) => `[${d.code}] ${d.path ? d.path + ": " : ""}${d.message}`).join("\n");
+    return {
+      success: false,
+      errors: errorDiagnostics,
+      diagnosticMessage,
+      preflight
+    };
+  }
+  const archiveBytes = archiveData instanceof Uint8Array ? archiveData : new Uint8Array(archiveData);
+  const unzipped = unzipSync(archiveBytes);
+  const pageRaw = JSON.parse(strFromU8(unzipped["page.json"]));
+  let finalDocument;
+  if (preflight.requiresMigration) {
+    const migrationRegistry = options.migrationRegistry || defaultMigrationRegistry;
+    const migrationRes = migrateDocument(pageRaw, {
+      targetVersion: options.targetSchemaVersion || CURRENT_SCHEMA_VERSION3,
+      registry: migrationRegistry,
+      validate: true
+    });
+    if (!migrationRes.success || !migrationRes.document) {
+      const err = {
+        code: "MIGRATION_FAILED",
+        severity: "error",
+        message: `Failed to migrate document from "${preflight.sourceVersion}" to "${preflight.targetVersion}".`,
+        details: { diagnostic: migrationRes.diagnostic }
+      };
+      return {
+        success: false,
+        errors: [err],
+        diagnosticMessage: err.message,
+        preflight
+      };
+    }
+    finalDocument = migrationRes.document;
+  } else {
+    finalDocument = pageRaw;
+  }
+  let metadata = finalDocument.metadata || {
+    title: "Imported Page",
+    description: "",
+    author: "",
+    tags: [],
+    category: "general",
+    version: finalDocument.version || CURRENT_SCHEMA_VERSION3
+  };
+  if (unzipped["metadata.json"]) {
+    try {
+      const metaFromFile = JSON.parse(strFromU8(unzipped["metadata.json"]));
+      metadata = {
+        ...metadata,
+        ...metaFromFile
+      };
+    } catch {
+    }
+  }
+  finalDocument.metadata = metadata;
+  const existingAssetIdsSet = /* @__PURE__ */ new Set();
+  if (options.existingAssetIds) {
+    if (Array.isArray(options.existingAssetIds)) {
+      for (const id of options.existingAssetIds) existingAssetIdsSet.add(id);
+    } else if (options.existingAssetIds instanceof Set) {
+      for (const id of options.existingAssetIds) existingAssetIdsSet.add(id);
+    }
+  }
+  if (options.assetProvider?.list && !options.existingAssetIds) {
+    try {
+      const list = await options.assetProvider.list();
+      if (Array.isArray(list)) {
+        for (const item of list) {
+          if (item?.id) existingAssetIdsSet.add(item.id);
+        }
+      }
+    } catch {
+    }
+  }
+  const renameAssetFn = options.renameAssetStrategy || defaultRenameAssetStrategy;
+  const renameMap = {};
+  const extractedAssets = /* @__PURE__ */ new Map();
+  for (const assetItem of preflight.manifest.assets) {
+    const assetBytes = unzipped[assetItem.path];
+    if (assetBytes) {
+      let targetAssetId = assetItem.id;
+      let effectiveStrategy = options.assetCollisionStrategy || "reject";
+      const conflictInfo = preflight.assetConflicts.find((c) => c.assetId === assetItem.id);
+      if (conflictInfo) {
+        if (options.onAssetConflict) {
+          try {
+            const conflictRes = await options.onAssetConflict(conflictInfo);
+            if (typeof conflictRes === "string") {
+              effectiveStrategy = conflictRes;
+            } else {
+              effectiveStrategy = conflictRes.action;
+              if (conflictRes.newAssetId) {
+                targetAssetId = conflictRes.newAssetId;
+              }
+            }
+          } catch (err) {
+            const diag = {
+              code: "HOST_ADAPTER_ERROR",
+              severity: "error",
+              message: `Asset conflict resolution handler failed for "${assetItem.id}": ${err instanceof Error ? err.message : String(err)}`,
+              path: assetItem.path
+            };
+            return {
+              success: false,
+              errors: [diag],
+              diagnosticMessage: diag.message,
+              preflight
+            };
+          }
+        }
+        if (effectiveStrategy === "reject") {
+          const diag = {
+            code: "ASSET_CONFLICT",
+            severity: "error",
+            message: `Import aborted: Asset "${assetItem.id}" collides with host asset. No overwrite strategy specified.`,
+            path: assetItem.path
+          };
+          return {
+            success: false,
+            errors: [diag],
+            diagnosticMessage: diag.message,
+            preflight
+          };
+        }
+        if (effectiveStrategy === "rename") {
+          if (targetAssetId === assetItem.id) {
+            targetAssetId = renameAssetFn(assetItem, existingAssetIdsSet);
+          }
+          renameMap[assetItem.id] = targetAssetId;
+          existingAssetIdsSet.add(targetAssetId);
+        }
+      }
+      let hostInfo;
+      if (effectiveStrategy === "reuse-existing" && conflictInfo) {
+        if (options.assetProvider?.resolve) {
+          hostInfo = await options.assetProvider.resolve(targetAssetId);
+        }
+      } else {
+        const effectiveMeta = {
+          ...assetItem,
+          id: targetAssetId
+        };
+        if (options.onAssetImport) {
+          try {
+            const result = await options.onAssetImport(targetAssetId, assetBytes, effectiveMeta);
+            if (result) hostInfo = result;
+          } catch (err) {
+            const diag = {
+              code: "HOST_ADAPTER_ERROR",
+              severity: "error",
+              message: `Host asset import hook failed for "${targetAssetId}": ${err instanceof Error ? err.message : String(err)}`,
+              path: assetItem.path
+            };
+            return {
+              success: false,
+              errors: [diag],
+              diagnosticMessage: diag.message,
+              preflight
+            };
+          }
+        } else if (options.assetProvider?.upload) {
+          try {
+            const blob = new Blob([assetBytes], { type: assetItem.mimeType });
+            const filename = assetItem.path.replace(/^assets\//, "");
+            const file = new File([blob], filename, { type: assetItem.mimeType });
+            const info = await options.assetProvider.upload(file, {
+              assetId: targetAssetId,
+              originalAssetId: assetItem.id
+            });
+            if (info) hostInfo = info;
+          } catch {
+          }
+        }
+      }
+      extractedAssets.set(targetAssetId, {
+        bytes: assetBytes,
+        meta: {
+          ...assetItem,
+          id: targetAssetId
+        },
+        hostInfo
+      });
+    }
+  }
+  if (Object.keys(renameMap).length > 0) {
+    remapDocumentAssetReferences(finalDocument, renameMap);
+  }
+  return {
+    success: true,
+    document: finalDocument,
+    manifest: preflight.manifest,
+    metadata,
+    extractedAssets,
+    renamedAssets: Object.keys(renameMap).length > 0 ? renameMap : void 0,
+    preflight
+  };
+}
+var importStoraPackage = importPackage;
+
+// src/round-trip-comparator.ts
+function isAssetReferenceLike(val) {
+  if (!val || typeof val !== "object") return false;
+  const obj = val;
+  return obj.type === "asset" && typeof obj.assetId === "string" && obj.assetId.trim().length > 0;
+}
+function isVariableBindingLike(val) {
+  if (!val || typeof val !== "object") return false;
+  const obj = val;
+  return obj.type === "variable" && typeof obj.key === "string" && obj.key.trim().length > 0;
+}
+function isActionBindingLike(val) {
+  if (!val || typeof val !== "object") return false;
+  const obj = val;
+  return obj.type !== void 0 && typeof obj.type === "string" && obj.type.trim().length > 0 && ("payload" in obj || Object.keys(obj).length <= 2);
+}
+function normalizeAssetId(id, assetIdMap) {
+  if (!assetIdMap) return id;
+  if (assetIdMap instanceof Map) {
+    return assetIdMap.get(id) ?? id;
+  }
+  return assetIdMap[id] ?? id;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const k of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, k)) return false;
+    if (!deepEqual(objA[k], objB[k])) return false;
+  }
+  return true;
+}
+function comparePropValues(path, expected, actual, differences, options) {
+  if (isVariableBindingLike(expected)) {
+    if (!isVariableBindingLike(actual)) {
+      differences.push({
+        path,
+        kind: "BINDING_MISMATCH",
+        message: `Expected variable binding at "${path}", but got non-binding value.`,
+        expected,
+        actual
+      });
+      return;
+    }
+    const expBinding = expected;
+    const actBinding = actual;
+    if (expBinding.key !== actBinding.key) {
+      differences.push({
+        path: `${path}.key`,
+        kind: "BINDING_MISMATCH",
+        message: `Variable binding key mismatch at "${path}": expected "${expBinding.key}", got "${actBinding.key}".`,
+        expected: expBinding.key,
+        actual: actBinding.key
+      });
+    }
+    if (!deepEqual(expBinding.fallback, actBinding.fallback)) {
+      differences.push({
+        path: `${path}.fallback`,
+        kind: "BINDING_MISMATCH",
+        message: `Variable binding fallback mismatch at "${path}".`,
+        expected: expBinding.fallback,
+        actual: actBinding.fallback
+      });
+    }
+    return;
+  }
+  if (isActionBindingLike(expected) && !isAssetReferenceLike(expected) && !isVariableBindingLike(expected)) {
+    if (!isActionBindingLike(actual)) {
+      differences.push({
+        path,
+        kind: "ACTION_MISMATCH",
+        message: `Expected action binding at "${path}", but got non-action value.`,
+        expected,
+        actual
+      });
+      return;
+    }
+    const expAction = expected;
+    const actAction = actual;
+    if (expAction.type !== actAction.type) {
+      differences.push({
+        path: `${path}.type`,
+        kind: "ACTION_MISMATCH",
+        message: `Action binding type mismatch at "${path}": expected "${expAction.type}", got "${actAction.type}".`,
+        expected: expAction.type,
+        actual: actAction.type
+      });
+    }
+    if (!deepEqual(expAction.payload ?? {}, actAction.payload ?? {})) {
+      differences.push({
+        path: `${path}.payload`,
+        kind: "ACTION_MISMATCH",
+        message: `Action binding payload mismatch at "${path}".`,
+        expected: expAction.payload,
+        actual: actAction.payload
+      });
+    }
+    return;
+  }
+  if (isAssetReferenceLike(expected)) {
+    if (!isAssetReferenceLike(actual)) {
+      differences.push({
+        path,
+        kind: "ASSET_MISMATCH",
+        message: `Expected asset reference at "${path}", but got non-asset value.`,
+        expected,
+        actual
+      });
+      return;
+    }
+    const expAsset = expected;
+    const actAsset = actual;
+    const expectedMappedId = normalizeAssetId(expAsset.assetId, options?.assetIdMap);
+    if (actAsset.assetId !== expectedMappedId) {
+      differences.push({
+        path: `${path}.assetId`,
+        kind: "ASSET_MISMATCH",
+        message: `Asset reference ID mismatch at "${path}": expected "${expectedMappedId}" (original: "${expAsset.assetId}"), got "${actAsset.assetId}".`,
+        expected: expectedMappedId,
+        actual: actAsset.assetId
+      });
+    }
+    if (expAsset.filename !== actAsset.filename) {
+      differences.push({
+        path: `${path}.filename`,
+        kind: "ASSET_MISMATCH",
+        message: `Asset reference filename mismatch at "${path}": expected "${expAsset.filename}", got "${actAsset.filename}".`,
+        expected: expAsset.filename,
+        actual: actAsset.filename
+      });
+    }
+    if (expAsset.mimeType !== actAsset.mimeType) {
+      differences.push({
+        path: `${path}.mimeType`,
+        kind: "ASSET_MISMATCH",
+        message: `Asset reference mimeType mismatch at "${path}": expected "${expAsset.mimeType}", got "${actAsset.mimeType}".`,
+        expected: expAsset.mimeType,
+        actual: actAsset.mimeType
+      });
+    }
+    return;
+  }
+  if (expected !== null && actual !== null && typeof expected === "object" && typeof actual === "object") {
+    if (Array.isArray(expected) !== Array.isArray(actual)) {
+      differences.push({
+        path,
+        kind: "PROP_MISMATCH",
+        message: `Type mismatch at "${path}": one is array, other is object.`,
+        expected,
+        actual
+      });
+      return;
+    }
+    if (Array.isArray(expected) && Array.isArray(actual)) {
+      if (expected.length !== actual.length) {
+        differences.push({
+          path,
+          kind: "PROP_MISMATCH",
+          message: `Array length mismatch at "${path}": expected length ${expected.length}, got ${actual.length}.`,
+          expected,
+          actual
+        });
+        return;
+      }
+      for (let i = 0; i < expected.length; i++) {
+        comparePropValues(`${path}[${i}]`, expected[i], actual[i], differences, options);
+      }
+      return;
+    }
+    const expObj = expected;
+    const actObj = actual;
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(expObj), ...Object.keys(actObj)]);
+    for (const key of allKeys) {
+      if (!(key in expObj)) {
+        differences.push({
+          path: `${path}.${key}`,
+          kind: "PROP_MISMATCH",
+          message: `Unexpected extra prop key "${key}" at "${path}".`,
+          actual: actObj[key]
+        });
+      } else if (!(key in actObj)) {
+        differences.push({
+          path: `${path}.${key}`,
+          kind: "PROP_MISMATCH",
+          message: `Missing expected prop key "${key}" at "${path}".`,
+          expected: expObj[key]
+        });
+      } else {
+        comparePropValues(`${path}.${key}`, expObj[key], actObj[key], differences, options);
+      }
+    }
+    return;
+  }
+  if (expected !== actual) {
+    differences.push({
+      path,
+      kind: "PROP_MISMATCH",
+      message: `Value mismatch at "${path}": expected "${String(expected)}", got "${String(actual)}".`,
+      expected,
+      actual
+    });
+  }
+}
+function compareStyles(nodePath, expected, actual, differences = []) {
+  const breakpoints = ["base", "desktop", "tablet", "mobile"];
+  const expStyles = expected || {};
+  const actStyles = actual || {};
+  for (const bp of breakpoints) {
+    const expBp = expStyles[bp] || {};
+    const actBp = actStyles[bp] || {};
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(expBp), ...Object.keys(actBp)]);
+    for (const key of allKeys) {
+      const expVal = expBp[key];
+      const actVal = actBp[key];
+      const expNorm = expVal === void 0 || expVal === "" ? void 0 : expVal;
+      const actNorm = actVal === void 0 || actVal === "" ? void 0 : actVal;
+      if (expNorm !== actNorm) {
+        differences.push({
+          path: `${nodePath}.styles.${bp}.${key}`,
+          kind: "STYLE_MISMATCH",
+          message: `Style mismatch at "${nodePath}.styles.${bp}.${key}": expected "${String(expVal)}", got "${String(actVal)}".`,
+          expected: expVal,
+          actual: actVal
+        });
+      }
+    }
+  }
+}
+function compareNodes(expected, actual, nodePath, differences, options) {
+  if (expected.id !== actual.id) {
+    differences.push({
+      path: `${nodePath}.id`,
+      kind: "NODE_MISSING",
+      message: `Node ID mismatch at "${nodePath}": expected "${expected.id}", got "${actual.id}".`,
+      expected: expected.id,
+      actual: actual.id
+    });
+  }
+  if (expected.type !== actual.type) {
+    differences.push({
+      path: `${nodePath}.type`,
+      kind: "NODE_TYPE",
+      message: `Node type mismatch for "${expected.id}": expected "${expected.type}", got "${actual.type}".`,
+      expected: expected.type,
+      actual: actual.type
+    });
+  }
+  comparePropValues(`${nodePath}.props`, expected.props || {}, actual.props || {}, differences, options);
+  compareStyles(nodePath, expected.styles, actual.styles, differences);
+  const expChildren = expected.children || [];
+  const actChildren = actual.children || [];
+  if (expChildren.length !== actChildren.length) {
+    differences.push({
+      path: `${nodePath}.children`,
+      kind: "NODE_ORDER",
+      message: `Children count mismatch for node "${expected.id}": expected ${expChildren.length}, got ${actChildren.length}.`,
+      expected: expChildren.map((c) => c.id),
+      actual: actChildren.map((c) => c.id)
+    });
+  }
+  const maxLen = Math.max(expChildren.length, actChildren.length);
+  for (let i = 0; i < maxLen; i++) {
+    const expChild = expChildren[i];
+    const actChild = actChildren[i];
+    if (!expChild && actChild) {
+      differences.push({
+        path: `${nodePath}.children[${i}]`,
+        kind: "NODE_EXTRA",
+        message: `Unexpected extra child node "${actChild.id}" at index ${i}.`,
+        actual: actChild.id
+      });
+    } else if (expChild && !actChild) {
+      differences.push({
+        path: `${nodePath}.children[${i}]`,
+        kind: "NODE_MISSING",
+        message: `Missing child node "${expChild.id}" at index ${i}.`,
+        expected: expChild.id
+      });
+    } else if (expChild && actChild) {
+      if (expChild.id !== actChild.id) {
+        differences.push({
+          path: `${nodePath}.children[${i}]`,
+          kind: "NODE_ORDER",
+          message: `Node order mismatch at index ${i}: expected node "${expChild.id}", got "${actChild.id}".`,
+          expected: expChild.id,
+          actual: actChild.id
+        });
+      }
+      compareNodes(expChild, actChild, `${nodePath}.children[${i}](${expChild.id})`, differences, options);
+    }
+  }
+}
+function compareDocumentsSemantically(expected, actual, options = {}) {
+  const differences = [];
+  const { ignoreTimestamps = true } = options;
+  if (expected.schema !== actual.schema) {
+    differences.push({
+      path: "schema",
+      kind: "METADATA_MISMATCH",
+      message: `Schema mismatch: expected "${expected.schema}", got "${actual.schema}".`,
+      expected: expected.schema,
+      actual: actual.schema
+    });
+  }
+  if (expected.version !== actual.version) {
+    differences.push({
+      path: "version",
+      kind: "METADATA_MISMATCH",
+      message: `Schema version mismatch: expected "${expected.version}", got "${actual.version}".`,
+      expected: expected.version,
+      actual: actual.version
+    });
+  }
+  const expMeta = expected.metadata || {};
+  const actMeta = actual.metadata || {};
+  const metaKeys = /* @__PURE__ */ new Set([...Object.keys(expMeta), ...Object.keys(actMeta)]);
+  for (const k of metaKeys) {
+    if (ignoreTimestamps && (k === "updatedAt" || k === "createdAt")) {
+      continue;
+    }
+    const expVal = expMeta[k];
+    const actVal = actMeta[k];
+    if (!deepEqual(expVal, actVal)) {
+      differences.push({
+        path: `metadata.${k}`,
+        kind: "METADATA_MISMATCH",
+        message: `Metadata mismatch at "metadata.${k}": expected "${String(expVal)}", got "${String(actVal)}".`,
+        expected: expVal,
+        actual: actVal
+      });
+    }
+  }
+  compareNodes(
+    expected.document,
+    actual.document,
+    `root(${expected.document.id})`,
+    differences,
+    options
+  );
+  return {
+    equivalent: differences.length === 0,
+    differences
+  };
+}
+function compareManifestsSemantically(expected, actual, options = {}) {
+  const differences = [];
+  const { ignoreTimestamps = true } = options;
+  if (expected.schema !== actual.schema) {
+    differences.push({
+      path: "manifest.schema",
+      kind: "METADATA_MISMATCH",
+      message: `Manifest schema mismatch: expected "${expected.schema}", got "${actual.schema}".`,
+      expected: expected.schema,
+      actual: actual.schema
+    });
+  }
+  if (expected.schemaVersion !== actual.schemaVersion) {
+    differences.push({
+      path: "manifest.schemaVersion",
+      kind: "METADATA_MISMATCH",
+      message: `Manifest schemaVersion mismatch: expected "${expected.schemaVersion}", got "${actual.schemaVersion}".`,
+      expected: expected.schemaVersion,
+      actual: actual.schemaVersion
+    });
+  }
+  const expComponents = new Set(expected.requiredComponents || []);
+  const actComponents = new Set(actual.requiredComponents || []);
+  for (const c of expComponents) {
+    if (!actComponents.has(c)) {
+      differences.push({
+        path: "manifest.requiredComponents",
+        kind: "DEPENDENCY_MISMATCH",
+        message: `Missing required component in manifest: "${c}".`,
+        expected: c
+      });
+    }
+  }
+  for (const c of actComponents) {
+    if (!expComponents.has(c)) {
+      differences.push({
+        path: "manifest.requiredComponents",
+        kind: "DEPENDENCY_MISMATCH",
+        message: `Unexpected extra required component in manifest: "${c}".`,
+        actual: c
+      });
+    }
+  }
+  const expCaps = new Set(expected.requiredCapabilities || []);
+  const actCaps = new Set(actual.requiredCapabilities || []);
+  for (const c of expCaps) {
+    if (!actCaps.has(c)) {
+      differences.push({
+        path: "manifest.requiredCapabilities",
+        kind: "DEPENDENCY_MISMATCH",
+        message: `Missing required capability in manifest: "${c}".`,
+        expected: c
+      });
+    }
+  }
+  for (const c of actCaps) {
+    if (!expCaps.has(c)) {
+      differences.push({
+        path: "manifest.requiredCapabilities",
+        kind: "DEPENDENCY_MISMATCH",
+        message: `Unexpected extra required capability in manifest: "${c}".`,
+        actual: c
+      });
+    }
+  }
+  if (expected.assets.length !== actual.assets.length) {
+    differences.push({
+      path: "manifest.assets",
+      kind: "ASSET_MISMATCH",
+      message: `Manifest asset count mismatch: expected ${expected.assets.length}, got ${actual.assets.length}.`,
+      expected: expected.assets.length,
+      actual: actual.assets.length
+    });
+  }
+  return {
+    equivalent: differences.length === 0,
+    differences
+  };
+}
+
+// src/template-utils.ts
+import {
+  TemplateRecordSchema,
+  collectNodeIds as collectNodeIds2,
+  isTemplateRecord
+} from "@kubuild/schema";
+var CORE_BUILTIN_COMPONENTS = /* @__PURE__ */ new Set([
+  "page",
+  "section",
+  "container",
+  "columns",
+  "column",
+  "heading",
+  "text",
+  "image",
+  "button",
+  "collection"
+]);
+function validateTemplate(value) {
+  const parseResult = TemplateRecordSchema.safeParse(value);
+  if (parseResult.success) {
+    return {
+      valid: true,
+      data: parseResult.data
+    };
+  }
+  const errors = parseResult.error.issues.map((issue) => ({
+    code: issue.code,
+    message: issue.message,
+    path: `/${issue.path.join("/")}`
+  }));
+  return {
+    valid: false,
+    errors
+  };
+}
+function collectComponentTypes(node, types) {
+  if (node.type) {
+    types.add(node.type);
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      collectComponentTypes(child, types);
+    }
+  }
+}
+function extractTemplateRequirements(doc, builtinComponents = CORE_BUILTIN_COMPONENTS) {
+  const componentTypes = /* @__PURE__ */ new Set();
+  if (doc?.document) {
+    collectComponentTypes(doc.document, componentTypes);
+  }
+  const customComponents = [];
+  for (const type of componentTypes) {
+    if (!builtinComponents.has(type)) {
+      customComponents.push(type);
+    }
+  }
+  return {
+    requiredComponents: customComponents.sort(),
+    requiredCapabilities: []
+  };
+}
+function createTemplateRecord(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let requirements = params.requirements;
+  if (!requirements && params.document) {
+    requirements = extractTemplateRequirements(params.document);
+  }
+  const candidate = {
+    id: params.id,
+    name: params.name,
+    description: params.description ?? "",
+    category: params.category ?? "general",
+    tags: params.tags ?? [],
+    thumbnail: params.thumbnail,
+    author: params.author ?? "",
+    version: params.version ?? "1.0.0",
+    document: params.document,
+    packageReference: params.packageReference,
+    requirements: requirements ?? { requiredComponents: [], requiredCapabilities: [] },
+    createdAt: params.createdAt ?? now,
+    updatedAt: params.updatedAt ?? now,
+    custom: params.custom
+  };
+  const validation = validateTemplate(candidate);
+  if (!validation.valid || !validation.data) {
+    const errorDetails = validation.errors?.map((e) => `${e.path}: ${e.message}`).join(", ");
+    throw new Error(`Invalid template record: ${errorDetails}`);
+  }
+  return validation.data;
+}
+function saveDraftAsTemplate(draft, metadata, options = {}) {
+  if (!metadata || typeof metadata !== "object") {
+    throw new Error("Save as template requires metadata with id and name.");
+  }
+  const cleanId = metadata.id?.trim();
+  if (!cleanId) {
+    throw new Error("Template ID is required and cannot be empty.");
+  }
+  const cleanName = metadata.name?.trim();
+  if (!cleanName) {
+    throw new Error("Template name is required and cannot be empty.");
+  }
+  if (!draft || !draft.document) {
+    throw new Error("Invalid draft document: document tree is missing.");
+  }
+  if (options.validateDraft !== false) {
+    const validation = validateDocument(draft);
+    if (!validation.valid) {
+      const errorMsg = validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+      throw new Error(`Cannot save invalid draft as template: ${errorMsg}`);
+    }
+  }
+  const draftSnapshot = deepClone(draft);
+  return createTemplateRecord({
+    id: cleanId,
+    name: cleanName,
+    description: metadata.description?.trim() ?? "",
+    category: metadata.category?.trim() ?? "general",
+    tags: metadata.tags ? [...metadata.tags] : [],
+    thumbnail: metadata.thumbnail,
+    author: metadata.author?.trim() ?? "",
+    version: metadata.version?.trim() ?? "1.0.0",
+    document: draftSnapshot,
+    requirements: options.requirements,
+    custom: metadata.custom ? deepClone(metadata.custom) : void 0
+  });
+}
+function cloneTreeWithFreshIds(root, idGen) {
+  function cloneRec(node) {
+    const newId = idGen(node.id, node);
+    const clonedProps = node.props ? deepClone(node.props) : void 0;
+    const clonedStyles = node.styles ? deepClone(node.styles) : void 0;
+    const clonedChildren = node.children ? node.children.map((child) => cloneRec(child)) : [];
+    return {
+      id: newId,
+      type: node.type,
+      ...clonedProps ? { props: clonedProps } : {},
+      ...clonedStyles ? { styles: clonedStyles } : {},
+      children: clonedChildren
+    };
+  }
+  return cloneRec(root);
+}
+function cloneTemplateAsPage(templateOrDoc, options = {}) {
+  let sourceDoc;
+  let templateOrigin = null;
+  if (isTemplateRecord(templateOrDoc)) {
+    if (!templateOrDoc.document) {
+      throw new Error(
+        `Template "${templateOrDoc.name}" (${templateOrDoc.id}) does not contain an inline document snapshot to clone from.`
+      );
+    }
+    sourceDoc = templateOrDoc.document;
+    templateOrigin = {
+      id: templateOrDoc.id,
+      name: templateOrDoc.name,
+      version: templateOrDoc.version ?? "1.0.0"
+    };
+  } else if ("schema" in templateOrDoc && "document" in templateOrDoc) {
+    sourceDoc = templateOrDoc;
+  } else {
+    throw new Error("Invalid input: expected a TemplateRecord or PageDocument.");
+  }
+  const existingIdsInSource = new Set(collectNodeIds2(sourceDoc.document));
+  const assignedNewIds = /* @__PURE__ */ new Set();
+  const prefix = options.idPrefix || `page_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 6)}`;
+  let counter = 1;
+  const defaultIdGen = (oldId, node) => {
+    let candidate = `${node.type}_${prefix}_${counter}`;
+    while (existingIdsInSource.has(candidate) || assignedNewIds.has(candidate)) {
+      counter++;
+      candidate = `${node.type}_${prefix}_${counter}`;
+    }
+    counter++;
+    assignedNewIds.add(candidate);
+    return candidate;
+  };
+  const idGen = options.idGenerator || defaultIdGen;
+  const clonedRootNode = cloneTreeWithFreshIds(sourceDoc.document, idGen);
+  const rootPageNode = {
+    ...clonedRootNode,
+    type: "page"
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const pageTitle = options.title ?? (templateOrigin ? `${templateOrigin.name}` : sourceDoc.metadata?.title ?? "Untitled Page");
+  const customMetadata = {
+    ...sourceDoc.metadata?.custom ? deepClone(sourceDoc.metadata.custom) : {},
+    ...options.customMetadata ? deepClone(options.customMetadata) : {}
+  };
+  if (options.recordOrigin !== false && templateOrigin) {
+    customMetadata.originTemplate = templateOrigin;
+  }
+  const newDoc = {
+    schema: sourceDoc.schema,
+    version: sourceDoc.version,
+    metadata: {
+      title: pageTitle,
+      description: sourceDoc.metadata?.description ?? "",
+      author: options.author ?? sourceDoc.metadata?.author ?? "",
+      tags: sourceDoc.metadata?.tags ? [...sourceDoc.metadata.tags] : [],
+      category: sourceDoc.metadata?.category ?? "general",
+      version: "1.0.0",
+      createdAt: now,
+      updatedAt: now,
+      custom: customMetadata
+    },
+    document: rootPageNode
+  };
+  return newDoc;
+}
+function areNodeIdsCompletelyDistinct(docA, docB) {
+  if (!docA?.document || !docB?.document) return true;
+  const idsA = new Set(collectNodeIds2(docA.document));
+  const idsB = collectNodeIds2(docB.document);
+  for (const id of idsB) {
+    if (idsA.has(id)) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  CORE_BUILTIN_COMPONENTS,
+  DEFAULT_DOCUMENT_SECURITY_LIMITS,
+  DEFAULT_MAX_HISTORY,
+  DEFAULT_SECURITY_LIMITS,
+  DocumentHistoryManager,
+  HistoryEngine,
+  MigrationRegistry,
+  areNodeIdsCompletelyDistinct,
+  buildSampleVariablesFromCatalog,
+  calculateChecksum,
+  canMigrate,
+  checkZipBomb,
+  cloneTemplateAsPage,
+  cloneTreeWithNewIds,
+  collectAssetReferences,
+  collectNodeIdSet,
+  compareDocumentsSemantically,
+  compareManifestsSemantically,
+  containsProhibitedKeys,
+  createBlankDocument,
+  createTemplateRecord,
+  deepClone,
+  defaultIdGenerator,
+  defaultMigrationRegistry,
+  defaultRenameAssetStrategy,
+  duplicateNode,
+  exportPackage,
+  exportStoraPackage,
+  extractRequirementsFromTree,
+  extractTemplateRequirements,
+  findMissingComponentNodes,
+  findNodeById,
+  findNodeLocation,
+  getAncestorChain,
+  getMigrationPath,
+  getNavigationTarget,
+  getNodeAncestors,
+  getParentNodeId,
+  importPackage,
+  importStoraPackage,
+  insertNode,
+  inspectPackage,
+  isDangerousAssetFilename,
+  isDangerousPath,
+  isDescendantOf,
+  isSafeUrl,
+  migrateDocument,
+  moveNode,
+  preflightPackage,
+  previewImportPackage,
+  remapAssetReferences,
+  remapDocumentAssetReferences,
+  removeNode,
+  resolveBinding,
+  resolveBindingValue,
+  sanitizeFilename,
+  sanitizeHtml,
+  sanitizeUrl,
+  saveDraftAsTemplate,
+  sha256Sync,
+  updateProps,
+  updateStyle,
+  validateDocument,
+  validateDocumentSecurity,
+  validateTemplate
+};
+//# sourceMappingURL=index.js.map