@jucie.io/cli 1.0.0

package/dist/stage-bundles/preact/chunks/chunk-MBN7CVNW.js

@@ -0,0 +1,4290 @@
+import {
+  setTextContent
+} from "./chunk-YMVTSVEM.js";
+import {
+  createFrame
+} from "./chunk-3NLDBJQD.js";
+import {
+  L
+} from "./chunk-JJVRBJGQ.js";
+import {
+  updateHtml
+} from "./chunk-DCKGUW2M.js";
+import {
+  addParamToRoute
+} from "./chunk-KF4MVCJ6.js";
+import {
+  removeParamFromRoute
+} from "./chunk-W5CGYUVM.js";
+import {
+  updateLifecycleHook
+} from "./chunk-EB5FGFFG.js";
+import {
+  removeLifecycleHook
+} from "./chunk-MAPYANXA.js";
+import {
+  addOption
+} from "./chunk-UHGV762U.js";
+import {
+  updateOption
+} from "./chunk-IIIXGKVH.js";
+import {
+  removeOption
+} from "./chunk-CHZVDVQC.js";
+import {
+  setOptionsExpression
+} from "./chunk-U7U7L7XZ.js";
+import {
+  clearOptionsExpression
+} from "./chunk-CXATTVPL.js";
+import {
+  setTagName
+} from "./chunk-CJOJNMRC.js";
+import {
+  addState
+} from "./chunk-667SIQGW.js";
+import {
+  updateState
+} from "./chunk-RZG5LCPH.js";
+import {
+  removeState
+} from "./chunk-IO3NSIEJ.js";
+import {
+  setHtmlId
+} from "./chunk-MMCB6GGX.js";
+import {
+  addAttribute
+} from "./chunk-BWZPEI76.js";
+import {
+  updateAttribute
+} from "./chunk-6E57QUN7.js";
+import {
+  removeAttribute
+} from "./chunk-VZNGMF63.js";
+import {
+  addLifecycleHook
+} from "./chunk-P7UUT7BU.js";
+import {
+  updateRoute
+} from "./chunk-TVGXBOIT.js";
+import {
+  setHomePage
+} from "./chunk-VK4FEQKG.js";
+import {
+  createDestination,
+  setDestination
+} from "./chunk-SF5BLQ7P.js";
+import {
+  clearDestination
+} from "./chunk-F77HGOQB.js";
+import {
+  createRepeat,
+  setRepeat
+} from "./chunk-2H2EQ2RG.js";
+import {
+  clearRepeat
+} from "./chunk-XKFPCFZH.js";
+import {
+  createRender,
+  setRender
+} from "./chunk-V6MKKC23.js";
+import {
+  clearRender
+} from "./chunk-TVB3GD7L.js";
+import {
+  removeStyle,
+  setNodeLayout
+} from "./chunk-RCIDQRAS.js";
+import {
+  clearName
+} from "./chunk-WXDXWNWW.js";
+import {
+  setName
+} from "./chunk-JDIO27MU.js";
+import {
+  addComponent,
+  clone,
+  cloneNodes,
+  copyNode
+} from "./chunk-ISOZDDO2.js";
+import {
+  addEvent
+} from "./chunk-2Y25YY3N.js";
+import {
+  updateEvent
+} from "./chunk-S4NZQRJJ.js";
+import {
+  removeEvent
+} from "./chunk-WMV5J37V.js";
+import {
+  addNode,
+  createNodeEntry
+} from "./chunk-CYH47R7O.js";
+import {
+  createFrameOverrides,
+  getFramePreset
+} from "./chunk-6R3QXFFF.js";
+import {
+  createTextContent
+} from "./chunk-KHURU62K.js";
+import {
+  createDescriptor
+} from "./chunk-H75SQT4U.js";
+import {
+  canMoveFrame,
+  getNodeLevel,
+  moveNodeToLastChildOf,
+  moveNodeToRoot
+} from "./chunk-236DY7EE.js";
+import {
+  canAcceptChildren
+} from "./chunk-K7ZULZJF.js";
+import {
+  applyNodePatch,
+  clearPosition,
+  normalizeLayoutContext,
+  resetNodeBehavior,
+  setNodeBehavior
+} from "./chunk-6B6PKOOA.js";
+import {
+  toBpKey,
+  updateStyle
+} from "./chunk-W7QH4UII.js";
+import {
+  updateBounds
+} from "./chunk-22J4JOPG.js";
+import {
+  removeNode,
+  removeNodeIdFromAllInstanceSlots
+} from "./chunk-LH4ZDX3T.js";
+import {
+  findDescendantIds
+} from "./chunk-IDGFZWZY.js";
+import {
+  disconnectNode
+} from "./chunk-3MJKS6VX.js";
+import {
+  nodeExists
+} from "./chunk-KOBPYD4N.js";
+import {
+  __export
+} from "./chunk-4A4WKSGY.js";
+
+// ../scene-graph/nodes/mutations/setActiveBreakpoint.js
+function setActiveBreakpoint(state, id, breakpoint) {
+  const key = breakpoint ?? "default";
+  state.set([id, ".activeBreakpoint"], key);
+  if (key !== "default") {
+    state.push([id, "locked"], "width");
+  } else {
+    const locked = state.get([id, "locked"]) ?? [];
+    const index = locked.indexOf("width");
+    if (index !== -1) {
+      state.splice([id, "locked"], index, 1);
+    }
+  }
+}
+
+// ../scene-graph/nodes/mutations/clearActiveBreakpoint.js
+function clearActiveBreakpoint(state, id) {
+  state.remove([id, ".activeBreakpoint"]);
+}
+
+// ../scene-graph/nodes/contracts/breakpoint.js
+var breakpointContracts = L("node:breakpoint", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      namespace: "scene-graph",
+      schema: ["String", "Number"],
+      handler: (id, name) => {
+        setActiveBreakpoint(nodes, id, name);
+      }
+    },
+    clear: {
+      namespace: "scene-graph",
+      schema: ["String"],
+      handler: (id) => {
+        clearActiveBreakpoint(nodes, id);
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/factories/createClassName.js
+function createClassName({ name, mode, ...rest } = {}) {
+  return createDescriptor({ name, mode: mode ?? "value", ...rest });
+}
+
+// ../scene-graph/nodes/mutations/addClassName.js
+function addClassName(state, id, input2 = {}) {
+  const opts = typeof input2 === "string" ? { value: input2 } : input2;
+  return state.push([id, "className"], createClassName({ mode: "value", ...opts }));
+}
+
+// ../scene-graph/nodes/mutations/updateClassName.js
+function updateClassName(state, id, value, className) {
+  return state.setWhere([id, "className"], { value }, createClassName(className));
+}
+
+// ../scene-graph/nodes/mutations/removeClassName.js
+function removeClassName(state, id, value) {
+  return state.removeWhere([id, "className"], { value });
+}
+
+// ../scene-graph/nodes/contracts/className.js
+var classNameContracts = L("node:className", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, value) => addClassName(nodes, id, value)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, value, className) => updateClassName(nodes, id, value, className)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, value) => removeClassName(nodes, id, value)
+    }
+  };
+});
+
+// ../scene-graph/nodes/operations/cutNodes.js
+function cutNodes(state, ids) {
+  const descendantIds = ids.flatMap((id) => findDescendantIds(state, id));
+  ids.forEach((id) => {
+    disconnectNode(state, id);
+  });
+  ids = [...ids, ...descendantIds];
+  const nodes = {};
+  for (const id of ids) {
+    nodes[id] = state.remove([id]);
+  }
+  return clone(nodes);
+}
+
+// ../scene-graph/nodes/operations/copyNodes.js
+function copyNodes(state, ids) {
+  const descendantIds = ids.flatMap((id) => findDescendantIds(state, id));
+  ids = [...ids, ...descendantIds];
+  const nodes = {};
+  for (const id of ids) {
+    const node = state.get([id]);
+    if (node) {
+      nodes[id] = node;
+    }
+  }
+  return clone(nodes);
+}
+
+// ../scene-graph/nodes/operations/moveNodeToTemp.js
+function moveNodeToTemp(state, id) {
+  state.update(["temp", "children"], (children = []) => {
+    if (children.indexOf(id) === -1) {
+      return [...children, id];
+    }
+    return children;
+  });
+  return true;
+}
+
+// ../scene-graph/nodes/operations/moveNodeAfter.js
+function moveNodeAfter(state, id, prev) {
+  if (!canMoveFrame(state, id, prev, "after")) {
+    moveNodeToRoot(state, id);
+    return;
+  }
+  const prevIsRoot = state.get(["app", "children"])?.includes(prev);
+  if (prevIsRoot) {
+    state.update(["app", "children"], (roots = []) => {
+      const previousIndex = roots.indexOf(prev);
+      if (previousIndex === -1) {
+        return [...roots, id];
+      }
+      const newRoots = [...roots];
+      newRoots.splice(previousIndex + 1, 0, id);
+      return newRoots;
+    });
+    normalizeLayoutContext(state, id, "app");
+    return true;
+  }
+  const path = state.findWhen("children", "includes", prev);
+  if (!path) {
+    return new Error("Failed to move node after: parent not found");
+  }
+  const parentId = path[0];
+  const childEx = state.get([id, "ex"]) ?? state.get([id, "type"]);
+  if (!canAcceptChildren(state, parentId, childEx)) return;
+  state.update(path, (children = []) => {
+    const indexOfPrev = children.indexOf(prev);
+    if (indexOfPrev === -1) {
+      return [...children, id];
+    }
+    const newChildren = [...children];
+    newChildren.splice(indexOfPrev + 1, 0, id);
+    return newChildren;
+  });
+  normalizeLayoutContext(state, id, parentId);
+  return true;
+}
+
+// ../scene-graph/nodes/operations/moveNodeBefore.js
+function moveNodeBefore(state, id, next) {
+  if (!canMoveFrame(state, id, next, "before")) {
+    moveNodeToRoot(state, id);
+    return;
+  }
+  const nextIsRoot = state.get(["app", "children"])?.includes(next);
+  if (nextIsRoot) {
+    moveNodeToRoot(state, id);
+    return true;
+  }
+  const path = state.findWhen("children", "includes", next);
+  if (!path) {
+    return new Error("Failed to move node before: parent not found");
+  }
+  const parentId = path[0];
+  const childEx = state.get([id, "ex"]) ?? state.get([id, "type"]);
+  if (!canAcceptChildren(state, parentId, childEx)) return;
+  state.update(path, (children = []) => {
+    const indexOfNext = children.indexOf(next);
+    if (indexOfNext === -1) {
+      return [id, ...children];
+    }
+    const newChildren = [...children];
+    newChildren.splice(indexOfNext, 0, id);
+    return newChildren;
+  });
+  normalizeLayoutContext(state, id, parentId);
+  return true;
+}
+
+// ../scene-graph/nodes/operations/pasteNodes.js
+function pasteNodes(state, nodes, { parent, after, before, root, temp } = {}) {
+  const [rootIds, clonedNodes] = cloneNodes(nodes);
+  for (const [id, node] of Object.entries(clonedNodes)) {
+    state.set(id, node);
+  }
+  if (temp) {
+    for (const id of rootIds) {
+      moveNodeToTemp(state, id);
+    }
+  }
+  if (root) {
+    for (const id of rootIds) {
+      moveNodeToRoot(state, id);
+    }
+  }
+  if (parent) {
+    for (const id of rootIds) {
+      moveNodeToLastChildOf(state, id, parent);
+    }
+  }
+  if (after) {
+    for (const id of rootIds) {
+      moveNodeAfter(state, id, after);
+      after = id;
+    }
+  }
+  if (before) {
+    for (const id of rootIds) {
+      moveNodeBefore(state, id, before);
+      before = id;
+    }
+  }
+  return rootIds;
+}
+
+// ../scene-graph/nodes/operations/duplicateNodes.js
+function duplicateNodes(state, ids) {
+  let rootIds = [];
+  for (const id of ids) {
+    const nodes = copyNode(state, id);
+    rootIds = rootIds.concat(pasteNodes(state, nodes, { after: id }));
+  }
+  return rootIds;
+}
+
+// ../scene-graph/nodes/validators/canEditNode.js
+function canEditNode(state, nodeId) {
+  const locked = state.get([nodeId, "locked"]);
+  return !locked || !locked.includes("*");
+}
+
+// ../scene-graph/nodes/contracts/clipboard.js
+var clipboardContracts = L("node:clipboard", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    cut: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        const editableIds = ids.filter((id) => canEditNode(nodes, id));
+        if (editableIds.length === 0) return {};
+        const removedNodes = cutNodes(nodes, editableIds);
+        return removedNodes;
+      }
+    },
+    copy: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        const copiedNodes = copyNodes(nodes, ids);
+        return copiedNodes;
+      }
+    },
+    paste: {
+      namespace: "scene-graph",
+      schema: ["Object", "Object"],
+      handler: (nodesToPaste, opts) => {
+        const rootIds = pasteNodes(nodes, nodesToPaste, opts);
+        if (opts.parent) {
+          for (const id of rootIds) {
+            normalizeLayoutContext(nodes, id, opts.parent);
+          }
+        }
+        return rootIds;
+      }
+    },
+    duplicate: {
+      namespace: "scene-graph",
+      schema: ["Array", "Object", "Object"],
+      handler: (uids, opts, cb) => {
+        const rootIds = duplicateNodes(nodes, uids, opts);
+        if (cb && typeof cb === "function") {
+          cb(rootIds);
+        }
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/setContextName.js
+function setContextName(state, id, contextName) {
+  return state.set([id, "contextName"], contextName);
+}
+
+// ../scene-graph/nodes/mutations/updateContextName.js
+function updateContextName(state, id, contextName) {
+  return state.set([id, "contextName"], contextName);
+}
+
+// ../scene-graph/nodes/mutations/clearContextName.js
+function clearContextName(state, id) {
+  return state.set([id, "contextName"], null);
+}
+
+// ../scene-graph/nodes/contracts/contextName.js
+var contextNameContracts = L("node:contextName", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "String"],
+      handler: (id, contextName) => {
+        setContextName(nodes, id, contextName);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "String"],
+      handler: (id, contextName) => {
+        updateContextName(nodes, id, contextName);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearContextName(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/states.js
+var statesContracts = L("node:state", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => addState(nodes, id, name)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, name, stateEntry) => updateState(nodes, id, name, stateEntry)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => removeState(nodes, id, name)
+    }
+  };
+});
+
+// ../scene-graph/nodes/operations/addTemp.js
+function addTemp(state, type, props) {
+  const id = createNodeEntry(state, type, props);
+  moveNodeToTemp(state, id);
+  return id;
+}
+
+// ../scene-graph/nodes/operations/addSlot.js
+var SLOT_NAME_RE = /^Slot (\d+)$/;
+function nextSlotName(state, parent) {
+  const children = state.get([parent, "children"]) ?? [];
+  let max = 0;
+  for (const childId of children) {
+    const child = state.get([childId]);
+    if (child?.type !== "slot") continue;
+    const match = SLOT_NAME_RE.exec(child.name ?? "");
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return `Slot ${max + 1}`;
+}
+function addSlot(state, parent, props = {}) {
+  const name = props.name ?? nextSlotName(state, parent);
+  const id = createNodeEntry(state, "slot", { ...props, name });
+  state.update([parent, "children"], (children = []) => [...children, id]);
+  return id;
+}
+
+// ../scene-graph/nodes/contracts/add.js
+var addContracts = L("node:add", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    element: {
+      namespace: "scene-graph",
+      schema: ["String", "Object", "Object"],
+      handler: (type, props, placement) => {
+        if (type === "slot") {
+          const id2 = addSlot(nodes, placement?.parent ?? "app", props);
+          return [id2];
+        }
+        const id = createNodeEntry(nodes, type, props);
+        if (placement?.after) {
+          moveNodeAfter(nodes, id, placement.after);
+        } else {
+          moveNodeToLastChildOf(nodes, id, placement?.parent ?? "app");
+        }
+        return [id];
+      }
+    },
+    tempNode: {
+      namespace: "scene-graph",
+      schema: ["String", "Object"],
+      handler: (type, props) => {
+        const id = addTemp(nodes, type, props);
+        return [id];
+      }
+    },
+    component: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (childId, name, bounds) => {
+        const id = addComponent(nodes, childId, name, bounds);
+        return [id];
+      }
+    },
+    duplicates: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          clearPosition(nodes, id);
+        }
+        const newIds = duplicateNodes(nodes, ids);
+        return newIds;
+      }
+    },
+    images: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (uploadedFiles) => {
+        const ids = [];
+        const endBatch = nodes.batch();
+        for (const uploadedFile of uploadedFiles) {
+          const id = addNode(nodes, "element", { tagName: "img", attributes: [{ name: "src", value: uploadedFile.url }, { name: "alt", value: uploadedFile.meta.name }] });
+          ids.push(id);
+        }
+        endBatch();
+        return ids;
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/events.js
+var eventsContracts = L("node:event", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => addEvent(nodes, id, name)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, name, event) => updateEvent(nodes, id, name, event)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => removeEvent(nodes, id, name)
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/attribute.js
+var attributeContracts = L("node:attribute", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, input2) => addAttribute(nodes, id, input2)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, name, attribute) => updateAttribute(nodes, id, name, attribute)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => removeAttribute(nodes, id, name)
+    }
+  };
+});
+
+// ../scene-graph/nodes/factories/createProp.js
+function createProp({ name, mode, ...rest } = {}) {
+  return createDescriptor({ name, mode: mode ?? "value", ...rest });
+}
+
+// ../scene-graph/nodes/mutations/addProp.js
+function addProp(state, id, input2 = {}) {
+  const opts = typeof input2 === "string" ? { name: input2 } : input2;
+  const desc = createProp(opts);
+  return state.unshift([id, "props"], desc);
+}
+
+// ../scene-graph/nodes/mutations/updateProp.js
+function updateProp(state, id, name, prop) {
+  const desc = createProp(prop);
+  const existing = state.findWhere([id, "props"], { name });
+  if (existing !== void 0) {
+    state.setWhere([id, "props"], { name }, desc);
+  } else {
+    state.push([id, "props"], desc);
+  }
+}
+
+// ../scene-graph/nodes/mutations/removeProp.js
+function removeProp(state, id, name) {
+  if (typeof state.removeAllWhere === "function") {
+    state.removeAllWhere([id, "props"], { name });
+  } else {
+    state.removeWhere([id, "props"], { name });
+  }
+}
+
+// ../scene-graph/nodes/contracts/prop.js
+var propContracts = L("node:prop", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "Object"],
+      handler: (id, input2) => addProp(nodes, id, input2)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, name, prop) => updateProp(nodes, id, name, prop)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, name) => removeProp(nodes, id, name)
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateSlot.js
+function updateSlot(state, instanceId, slotId, updatedSlot) {
+  console.log("updateSlot", state, instanceId, slotId, updatedSlot);
+  state.updateWhere([instanceId, "slots"], { id: slotId }, (currentSlot) => {
+    console.log("currentSlot", currentSlot, "updatedSlot", updatedSlot);
+    switch (currentSlot.childrenType) {
+      case "text":
+        return {
+          ...currentSlot,
+          textContent: createDescriptor(updatedSlot)
+        };
+      default:
+        return currentSlot;
+    }
+  });
+}
+
+// ../scene-graph/nodes/factories/buildSlotsFromMeta.js
+function buildSlotsFromMeta(metaSlots = []) {
+  if (!Array.isArray(metaSlots)) return [];
+  const fills = [];
+  for (const entry of metaSlots) {
+    if (!entry || typeof entry === "string") continue;
+    if (!entry.id) continue;
+    const childrenType = entry.childrenType ?? "children";
+    const shouldSeed = entry.required === true || childrenType === "text" && entry.textContent != null;
+    if (!shouldSeed) continue;
+    if (childrenType === "text") {
+      const value = entry.textContent?.value ?? "";
+      fills.push({
+        id: entry.id,
+        name: entry.name,
+        childrenType: "text",
+        textContent: createTextContent({ value }),
+        children: null
+      });
+      continue;
+    }
+    fills.push({
+      id: entry.id,
+      name: entry.name,
+      childrenType,
+      textContent: null,
+      children: []
+    });
+  }
+  return fills;
+}
+function mergeMissingSlotsFromMeta(existing = [], metaSlots = []) {
+  const current = Array.isArray(existing) ? [...existing] : [];
+  const byId = new Set(current.map((s) => s?.id).filter(Boolean));
+  for (const fill of buildSlotsFromMeta(metaSlots)) {
+    if (byId.has(fill.id)) continue;
+    current.push(fill);
+    byId.add(fill.id);
+  }
+  return current;
+}
+
+// ../scene-graph/nodes/mutations/ensureSlotsFromMeta.js
+function ensureSlotsFromMeta(state, instanceId, metaSlots = []) {
+  if (!instanceId) return;
+  const existing = state.get([instanceId, "slots"]) ?? [];
+  const merged = mergeMissingSlotsFromMeta(existing, metaSlots);
+  const existingIds = new Set(existing.map((s) => s?.id).filter(Boolean));
+  const added = merged.some((s) => s?.id && !existingIds.has(s.id));
+  if (!added) return;
+  state.set([instanceId, "slots"], merged);
+}
+
+// ../scene-graph/nodes/contracts/slot.js
+var slotContracts = L("node:slot", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (instanceId, slotId, slot) => {
+        console.log("updateSlot", instanceId, slotId, slot);
+        updateSlot(nodes, instanceId, slotId, slot);
+      }
+    },
+    ensureFromMeta: {
+      namespace: "scene-graph",
+      schema: ["String", "Array"],
+      handler: (instanceId, metaSlots) => {
+        ensureSlotsFromMeta(nodes, instanceId, metaSlots);
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/html.js
+var htmlContracts = L("node:html", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    update: {
+      schema: ["String", "String"],
+      handler: (id, html) => {
+        updateHtml(nodes, id, html);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateDestination.js
+function updateDestination(state, id, destination) {
+  return state.update([id, "destination"], (currentDestination = {}) => {
+    return createDestination({
+      ...currentDestination,
+      ...destination
+    });
+  });
+}
+
+// ../scene-graph/nodes/contracts/destination.js
+var destinationContracts = L("node:destination", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      namespace: "scene-graph",
+      schema: ["String", "Object"],
+      handler: (id, destination = {}) => {
+        setDestination(nodes, id, destination);
+      }
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "Object"],
+      handler: (id, destination) => {
+        updateDestination(nodes, id, destination);
+      }
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String"],
+      handler: (id) => {
+        clearDestination(nodes, id);
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updatePosition.js
+function updatePosition(state, id, position) {
+  return state.update([id, ".position"], (oldPosition = { x: 0, y: 0 }) => ({ ...oldPosition, ...position }));
+}
+
+// ../scene-graph/nodes/contracts/drag.js
+var dragContracts = L("node:drag", (inject) => {
+  const state = inject("state");
+  const nodes = state?.ref(["nodes"]) ?? null;
+  let commit = null;
+  if (!state || !nodes) {
+    throw new Error("State or node cache not found");
+  }
+  return {
+    start: {
+      namespace: "scene-graph",
+      handler: () => commit = state.history?.group()
+    },
+    apply: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (patches) => {
+        for (const [id, patch] of patches) {
+          if (!id) continue;
+          if (!patch[".position"]) continue;
+          updatePosition(nodes, id, patch[".position"]);
+        }
+      }
+    },
+    end: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          if (!id) continue;
+          clearPosition(nodes, id);
+        }
+        if (commit) {
+          commit("Drag nodes");
+          commit = null;
+        } else {
+          state.history?.commit("Drag nodes");
+        }
+      }
+    },
+    clear: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          if (!id) continue;
+          clearPosition(nodes, id);
+        }
+        if (commit) {
+          commit();
+          commit = null;
+        }
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/lifecycle.js
+var lifecycleContracts = L("node:lifecycle", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) throw new Error("Node cache not found");
+  return {
+    add: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, hookName) => addLifecycleHook(nodes, id, hookName)
+    },
+    update: {
+      namespace: "scene-graph",
+      schema: ["String", "String", "Object"],
+      handler: (id, key, hook) => updateLifecycleHook(nodes, id, key, hook)
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, key) => removeLifecycleHook(nodes, id, key)
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/addInteractionState.js
+function addInteractionState(state, id, stateName) {
+  const current = state.get([id, ".interactionState"]) ?? [];
+  if (current.includes(stateName)) return;
+  return state.push([id, ".interactionState"], stateName);
+}
+
+// ../scene-graph/nodes/mutations/removeInteractionState.js
+function removeInteractionState(state, id, stateName) {
+  const current = state.get([id, ".interactionState"]) ?? [];
+  const index = current.indexOf(stateName);
+  if (index === -1) return;
+  return state.splice([id, ".interactionState"], index, 1);
+}
+
+// ../scene-graph/nodes/mutations/clearInteractionState.js
+function clearInteractionState(state, id) {
+  state.remove([id, ".interactionState"]);
+  return;
+}
+
+// ../scene-graph/nodes/contracts/interactionState.js
+var interactionStateContracts = L("node:interactionState", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    add: {
+      schema: ["String", "String"],
+      namespace: "scene-graph",
+      handler: (id, stateName) => {
+        addInteractionState(nodes, id, stateName);
+      }
+    },
+    remove: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (id, stateName) => {
+        removeInteractionState(nodes, id, stateName);
+      }
+    },
+    clear: {
+      namespace: "scene-graph",
+      schema: ["String"],
+      handler: (id) => {
+        clearInteractionState(nodes, id);
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/patch.js
+var patchContracts = L("node:patch", (useContext) => {
+  const [state, sceneCompiler] = useContext("state", "sceneCompiler");
+  const nodes = state?.ref(["nodes"]) ?? null;
+  let commit = null;
+  if (!state || !nodes) {
+    throw new Error("State or node cache not found");
+  }
+  return {
+    start: {
+      namespace: "scene-graph",
+      schema: "*",
+      handler: () => {
+        commit = state.history?.group();
+      }
+    },
+    apply: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (patches) => {
+        const endBatch = state.batch();
+        for (const [id, entry] of patches) {
+          if (!id || !entry) continue;
+          if (!canEditNode(nodes, id)) continue;
+          const breakpoint = sceneCompiler.getActiveBreakpoint(id);
+          applyNodePatch(nodes, id, entry, breakpoint);
+        }
+        endBatch();
+      }
+    },
+    end: {
+      namespace: "scene-graph",
+      schema: ["String"],
+      handler: (message = "Patch") => {
+        if (commit) {
+          commit(message);
+          commit = null;
+        } else {
+          state.history?.commit(message);
+        }
+      }
+    },
+    clear: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          if (!id) continue;
+          clearPosition(nodes, id);
+        }
+        if (commit) {
+          commit();
+          commit = null;
+        }
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/behavior.js
+var behaviorContracts = L("node:behavior", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "Object"],
+      handler: (id, behaviorUpdates) => {
+        setNodeBehavior(nodes, id, behaviorUpdates);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["Array"],
+      handler: (patches) => {
+        for (const [nodeId, patch] of patches) {
+          applyNodePatch(nodes, nodeId, patch);
+        }
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        resetNodeBehavior(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/layout.js
+var layoutContracts = L("node:layout", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "String"],
+      handler: (nodeId, layout) => {
+        if (!canEditNode(nodes, nodeId)) return;
+        return setNodeLayout(nodes, nodeId, layout);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/factories/createSlotChild.js
+function createSlotChild({ id = null, name = void 0, children = [] } = {}) {
+  return {
+    id,
+    name,
+    children
+  };
+}
+
+// ../scene-graph/nodes/operations/moveNodeToSlotChildOf.js
+function insertIntoSlotChildren(children, id, { before, after } = {}) {
+  if (children.includes(id)) return children;
+  if (before) {
+    const index = children.indexOf(before);
+    if (index === -1) return [id, ...children];
+    const next = [...children];
+    next.splice(index, 0, id);
+    return next;
+  }
+  if (after) {
+    const index = children.indexOf(after);
+    if (index === -1) return [...children, id];
+    const next = [...children];
+    next.splice(index + 1, 0, id);
+    return next;
+  }
+  return [...children, id];
+}
+function moveNodeToSlotChildOf(state, id, instance, { slotId = null, name = void 0, before, after } = {}) {
+  if (!nodeExists(state, instance)) return;
+  if (!nodeExists(state, id)) return;
+  if (!canMoveFrame(state, id, instance, "lastChildOf")) {
+    moveNodeToRoot(state, id);
+    return;
+  }
+  state.update([instance, "slots"], (slots = []) => {
+    const slotIndex = slots.findIndex((slot) => slot.id === slotId);
+    if (slotIndex === -1) {
+      return [...slots, createSlotChild({ id: slotId, name, children: [id] })];
+    }
+    const existing = slots[slotIndex];
+    const prevChildren = existing.children || [];
+    const newSlots = [...slots];
+    newSlots[slotIndex] = {
+      ...existing,
+      children: insertIntoSlotChildren(prevChildren, id, { before, after })
+    };
+    return newSlots;
+  });
+  normalizeLayoutContext(state, id, slotId || instance);
+  return true;
+}
+
+// ../scene-graph/nodes/validators/canNestUnder.js
+function canNestUnder(state, childId, parentId, moveType) {
+  if (!nodeExists(state, childId)) return false;
+  if (!nodeExists(state, parentId)) return false;
+  const childEx = state.get([childId, "ex"]) ?? state.get([childId, "type"]);
+  if (!canAcceptChildren(state, parentId, childEx)) return false;
+  if (!canMoveFrame(state, childId, parentId, moveType)) return false;
+  return true;
+}
+
+// ../scene-graph/nodes/contracts/move.js
+var moveContracts = L("node:move", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    apply: {
+      namespace: "scene-graph",
+      schema: ["Array", "Object"],
+      handler: (ids, placement) => {
+        console.log("moveContracts", ids, placement);
+        const editableIds = ids.filter((id) => canEditNode(nodes, id));
+        const validIds = [];
+        const tempViewportsToRoot = [];
+        for (const id of editableIds) {
+          if (placement.before || placement.after) {
+            validIds.push(id);
+          } else if (placement.instance) {
+            validIds.push(id);
+          } else if (placement.parent) {
+            if (canNestUnder(nodes, id, placement.parent, "lastChildOf")) {
+              validIds.push(id);
+            } else {
+              const nodeLevel = getNodeLevel(nodes, id);
+              if (nodeLevel === "temp") tempViewportsToRoot.push(id);
+            }
+          } else {
+            validIds.push(id);
+          }
+        }
+        if (validIds.length === 0 && tempViewportsToRoot.length === 0) return;
+        for (const id of validIds) {
+          disconnectNode(nodes, id);
+          clearPosition(nodes, id);
+          removeNodeIdFromAllInstanceSlots(nodes, id);
+        }
+        if (placement.instance) {
+          for (const id of validIds) {
+            moveNodeToSlotChildOf(nodes, id, placement.instance, {
+              slotId: placement.slotId,
+              name: placement.name,
+              before: placement.before,
+              after: placement.after
+            });
+          }
+        } else if (placement.before) {
+          for (const id of validIds) {
+            moveNodeBefore(nodes, id, placement.before);
+          }
+        } else if (placement.after) {
+          for (const id of validIds) {
+            moveNodeAfter(nodes, id, placement.after);
+          }
+        } else if (placement.parent) {
+          for (const id of validIds) {
+            moveNodeToLastChildOf(nodes, id, placement.parent);
+          }
+        }
+        for (const id of tempViewportsToRoot) {
+          disconnectNode(nodes, id);
+          clearPosition(nodes, id);
+          moveNodeToRoot(nodes, id);
+        }
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateName.js
+function updateName(state, id, name) {
+  return state.set([id, "name"], name);
+}
+
+// ../scene-graph/nodes/contracts/name.js
+var nameContracts = L("node:name", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "String"],
+      handler: (id, name) => {
+        setName(nodes, id, name);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "String"],
+      handler: (id, name) => {
+        console.log("updateName", id, name);
+        updateName(nodes, id, name);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearName(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/options.js
+var optionsContracts = L("node:options", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    add: {
+      schema: ["String", "Object"],
+      handler: (id, option) => {
+        addOption(nodes, id, option);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "String", "Object"],
+      handler: (id, value, option) => {
+        updateOption(nodes, id, value, option);
+      },
+      namespace: "scene-graph"
+    },
+    remove: {
+      schema: ["String", "String"],
+      handler: (id, value) => {
+        removeOption(nodes, id, value);
+      },
+      namespace: "scene-graph"
+    },
+    setExpression: {
+      schema: ["String", "Object"],
+      handler: (id, expression) => {
+        setOptionsExpression(nodes, id, expression);
+      },
+      namespace: "scene-graph"
+    },
+    clearExpression: {
+      schema: ["String"],
+      handler: (id) => {
+        clearOptionsExpression(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/order.js
+var orderContracts = L("node:order", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    bringToFront: {
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          const path = nodes.findWhen("children", "includes", id);
+          if (!path) continue;
+          nodes.update(path, (children = []) => {
+            const filtered = children.filter((c) => c !== id);
+            return [...filtered, id];
+          });
+        }
+      },
+      namespace: "scene-graph"
+    },
+    sendToBack: {
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          const path = nodes.findWhen("children", "includes", id);
+          if (!path) continue;
+          nodes.update(path, (children = []) => {
+            const filtered = children.filter((c) => c !== id);
+            return [id, ...filtered];
+          });
+        }
+      },
+      namespace: "scene-graph"
+    },
+    moveForward: {
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          const path = nodes.findWhen("children", "includes", id);
+          if (!path) continue;
+          nodes.update(path, (children = []) => {
+            const index = children.indexOf(id);
+            if (index === -1 || index === children.length - 1) {
+              return children;
+            }
+            const newChildren = [...children];
+            [newChildren[index], newChildren[index + 1]] = [newChildren[index + 1], newChildren[index]];
+            return newChildren;
+          });
+        }
+      },
+      namespace: "scene-graph"
+    },
+    moveBackward: {
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          const path = nodes.findWhen("children", "includes", id);
+          if (!path) continue;
+          nodes.update(path, (children = []) => {
+            const index = children.indexOf(id);
+            if (index === -1 || index === 0) {
+              return children;
+            }
+            const newChildren = [...children];
+            [newChildren[index], newChildren[index - 1]] = [newChildren[index - 1], newChildren[index]];
+            return newChildren;
+          });
+        }
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/remove.js
+var removeContracts = L("node:remove", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    nodes: {
+      namespace: "scene-graph",
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          removeNode(nodes, id);
+        }
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateRender.js
+function updateRender(state, id, render) {
+  return state.update([id, "render"], (current = {}) => {
+    return createRender({ ...current, ...render });
+  });
+}
+
+// ../scene-graph/nodes/contracts/render.js
+var renderContracts = L("node:render", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "Object"],
+      handler: (id, render) => {
+        setRender(nodes, id, render);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "Object"],
+      handler: (id, render) => {
+        updateRender(nodes, id, render);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearRender(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateRepeat.js
+function updateRepeat(state, id, repeat) {
+  return state.update([id, "repeat"], (current = {}) => {
+    return createRepeat({ ...current, ...repeat });
+  });
+}
+
+// ../scene-graph/nodes/mutations/enableRepeat.js
+function enableRepeat(state, id) {
+  const current = state.get([id, "repeat"]);
+  if (!current) {
+    return setRepeat(state, id, {});
+  }
+  return state;
+}
+
+// ../scene-graph/nodes/mutations/disableRepeat.js
+function disableRepeat(state, id) {
+  return clearRepeat(state, id);
+}
+
+// ../scene-graph/nodes/contracts/repeat.js
+var repeatContracts = L("node:repeat", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "Object"],
+      handler: (id, repeat) => {
+        setRepeat(nodes, id, repeat);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "Object"],
+      handler: (id, repeat) => {
+        updateRepeat(nodes, id, repeat);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearRepeat(nodes, id);
+      },
+      namespace: "scene-graph"
+    },
+    enable: {
+      schema: ["String"],
+      handler: (id) => {
+        enableRepeat(nodes, id);
+      },
+      namespace: "scene-graph"
+    },
+    disable: {
+      schema: ["String"],
+      handler: (id) => {
+        disableRepeat(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/contracts/route.js
+var routeContracts = L("node:route", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    update: {
+      schema: ["String", "Object"],
+      namespace: "scene-graph",
+      handler: (id, route) => {
+        updateRoute(nodes, id, route);
+      }
+    },
+    addParam: {
+      schema: ["String"],
+      namespace: "scene-graph",
+      handler: (id) => {
+        addParamToRoute(nodes, id);
+      }
+    },
+    removeParam: {
+      namespace: "scene-graph",
+      schema: ["String", "Number"],
+      handler: (id, index) => {
+        removeParamFromRoute(nodes, id, index);
+      }
+    },
+    setHomePage: {
+      schema: ["String", "Boolean"],
+      namespace: "scene-graph",
+      handler: (id, isHomePage) => {
+        setHomePage(nodes, id, isHomePage);
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/clearStyle.js
+function clearStyle(state, id, { breakpoint = "default", interactionState = [] } = {}) {
+  const bpKey = toBpKey(breakpoint);
+  return state.remove([id, "style", bpKey, ...interactionState]);
+}
+
+// ../scene-graph/nodes/validators/isContainerNode.js
+function isContainerNode(state, id) {
+  const node = state.get([id]);
+  const t = node?.type;
+  return t === "frame" || t === "component" || t === "viewport";
+}
+
+// ../scene-graph/nodes/contracts/style.js
+var styleContracts = L("node:style", (useContext) => {
+  const [state, sceneCompiler] = useContext("state", "sceneCompiler");
+  const nodes = state?.ref(["nodes"]) ?? null;
+  return {
+    update: {
+      schema: ["Object"],
+      handler: (styleMap) => {
+        for (const [id, style] of Object.entries(styleMap)) {
+          if (!canEditNode(nodes, id)) continue;
+          delete style.position;
+          const breakpoint = isContainerNode(nodes, id) ? "default" : sceneCompiler.getActiveBreakpoint(id);
+          updateStyle(nodes, id, style, { breakpoint });
+        }
+      },
+      namespace: "scene-graph"
+    },
+    remove: {
+      schema: ["Array", "Array"],
+      handler: (ids, properties) => {
+        for (const id of ids) {
+          if (!canEditNode(nodes, id)) continue;
+          const breakpoint = isContainerNode(nodes, id) ? "default" : sceneCompiler.getActiveBreakpoint(id);
+          for (const property of properties) {
+            removeStyle(nodes, id, property, { breakpoint });
+          }
+        }
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["Array"],
+      handler: (ids) => {
+        for (const id of ids) {
+          if (!canEditNode(nodes, id)) continue;
+          const breakpoint = isContainerNode(nodes, id) ? "default" : sceneCompiler.getActiveBreakpoint(id);
+          if (breakpoint === "default" || breakpoint == null) continue;
+          clearStyle(nodes, id, { breakpoint });
+        }
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateTagName.js
+function updateTagName(state, id, tagName) {
+  return state.set([id, "tagName"], tagName);
+}
+
+// ../scene-graph/nodes/mutations/clearTagName.js
+function clearTagName(state, id) {
+  return state.set([id, "tagName"], null);
+}
+
+// ../scene-graph/nodes/contracts/tagName.js
+var tagNameContracts = L("node:tagName", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "String"],
+      handler: (id, tagName) => {
+        setTagName(nodes, id, tagName);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "String"],
+      handler: (id, tagName) => {
+        updateTagName(nodes, id, tagName);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearTagName(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/updateTextContent.js
+function updateTextContent(state, id, patch = {}) {
+  if (canAcceptChildren(state, id)) return;
+  const p2 = typeof patch === "string" ? { value: patch } : patch;
+  return state.update([id, "textContent"], (current = {}) => {
+    const merged = { ...current, ...p2 };
+    if (!Object.prototype.hasOwnProperty.call(p2, "specificPatterns") && current.specificPatterns !== void 0) {
+      merged.specificPatterns = current.specificPatterns;
+    }
+    return createTextContent(merged);
+  });
+}
+
+// ../scene-graph/nodes/mutations/clearTextContent.js
+function clearTextContent(state, id) {
+  return state.remove([id, "textContent"]);
+}
+
+// ../scene-graph/nodes/mutations/setEditingTextContent.js
+function setEditingTextContent(state, id, value = true) {
+  return state.set([id, ".editingTextContent"], value);
+}
+
+// ../scene-graph/nodes/mutations/removeEditingTextContent.js
+function removeEditingTextContent(state, id) {
+  return state.remove([id, ".editingTextContent"]);
+}
+
+// ../scene-graph/nodes/contracts/textContent.js
+var textContentContracts = L("node:textContent", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  let editingId = null;
+  return {
+    set: {
+      schema: ["String", "Object"],
+      handler: (id, textContent) => {
+        setTextContent(nodes, id, textContent);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "Object"],
+      handler: (id, textContent) => {
+        updateTextContent(nodes, id, textContent);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearTextContent(nodes, id);
+      },
+      namespace: "scene-graph"
+    },
+    "editing:enable": {
+      schema: ["String"],
+      namespace: "scene-graph",
+      handler: (id) => {
+        if (editingId) {
+          setEditingTextContent(nodes, editingId, false);
+          editingId = null;
+        }
+        editingId = id;
+        setEditingTextContent(nodes, id, true);
+        return true;
+      }
+    },
+    "editing:disable": {
+      schema: "*",
+      namespace: "scene-graph",
+      handler: (id) => {
+        if (id) {
+          setEditingTextContent(nodes, id, false);
+        } else if (editingId) {
+          setEditingTextContent(nodes, editingId, false);
+          editingId = null;
+        }
+        editingId = null;
+        return true;
+      }
+    },
+    "editing:remove": {
+      schema: ["String"],
+      namespace: "scene-graph",
+      handler: (id) => {
+        removeEditingTextContent(nodes, id);
+        return true;
+      }
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/setType.js
+function setType(state, id, type) {
+  return state.set([id, "type"], type);
+}
+
+// ../scene-graph/nodes/mutations/updateType.js
+function updateType(state, id, type) {
+  return state.set([id, "type"], type);
+}
+
+// ../scene-graph/nodes/mutations/clearType.js
+function clearType(state, id) {
+  return state.set([id, "type"], null);
+}
+
+// ../scene-graph/nodes/contracts/type.js
+var typeContracts = L("node:type", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "String"],
+      handler: (id, type) => {
+        setType(nodes, id, type);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "String"],
+      handler: (id, type) => {
+        updateType(nodes, id, type);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearType(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/setFramePreset.js
+function setFramePreset(state, id, key, options = {}) {
+  const { name, bounds } = createFrameOverrides(key, options);
+  const current = state.get([id, "bounds"]) ?? {};
+  state.set([id, "frame"], key);
+  state.set([id, "name"], name);
+  state.update([id, "bounds"], () => ({
+    ...current,
+    width: bounds.width,
+    height: bounds.height
+  }));
+}
+
+// ../scene-graph/nodes/mutations/setViewport.js
+function setViewport(state, id, { name, width, height }) {
+  if (name === "custom") {
+    setFramePreset(state, id, "custom", { name, width, height });
+    return;
+  }
+  const preset = getFramePreset(name);
+  if (!preset) return new Error(`Invalid viewport name "${name}"`);
+  setFramePreset(state, id, name);
+}
+
+// ../scene-graph/nodes/mutations/clearViewport.js
+function clearViewport(state, id) {
+  state.set([id, "frame"], void 0);
+  return state.set([id, "viewport"], null);
+}
+
+// ../scene-graph/nodes/contracts/viewport.js
+var viewportContracts = L("node:viewport", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      schema: ["String", "Object"],
+      handler: (id, viewport) => {
+        setViewport(nodes, id, viewport);
+      },
+      namespace: "scene-graph"
+    },
+    setPreset: {
+      schema: ["String", "String", "Object"],
+      handler: (id, key, options = {}) => {
+        setFramePreset(nodes, id, key, options);
+      },
+      namespace: "scene-graph"
+    },
+    update: {
+      schema: ["String", "Object"],
+      handler: (id, boundsPatch) => {
+        updateBounds(nodes, id, boundsPatch);
+      },
+      namespace: "scene-graph"
+    },
+    clear: {
+      schema: ["String"],
+      handler: (id) => {
+        clearViewport(nodes, id);
+      },
+      namespace: "scene-graph"
+    }
+  };
+});
+
+// ../scene-graph/nodes/mutations/clearHtmlId.js
+function clearHtmlId(state, nodeId) {
+  return state.set([nodeId, "id"], null);
+}
+
+// ../scene-graph/nodes/contracts/htmlId.js
+var htmlIdContracts = L("node:id", (useContext) => {
+  const nodes = useContext("state")?.ref(["nodes"]) ?? null;
+  if (!nodes) {
+    throw new Error("Node cache not found");
+  }
+  return {
+    set: {
+      namespace: "scene-graph",
+      schema: ["String", "String"],
+      handler: (nodeId, id) => {
+        setHtmlId(nodes, nodeId, id);
+      }
+    },
+    clear: {
+      namespace: "scene-graph",
+      schema: ["String"],
+      handler: (nodeId) => {
+        clearHtmlId(nodes, nodeId);
+      }
+    }
+  };
+});
+
+// ../utilities/src/iterateEntries.js
+function iterateEntries(obj, callback) {
+  const entries = Object.entries(obj);
+  const result = {};
+  for (const [key, value] of entries) {
+    result[key] = callback(key, value);
+  }
+  return result;
+}
+
+// ../utilities/src/deepMerge.js
+function deepMerge(target, source) {
+  if (!source) return target;
+  if (Array.isArray(source)) {
+    return Array.isArray(target) ? [...target, ...source] : source;
+  }
+  if (!(source instanceof Object) || source === null) {
+    return source;
+  }
+  return {
+    ...target,
+    ...iterateEntries(source, (key, value) => {
+      if (Array.isArray(value)) {
+        return Array.isArray(target[key]) ? [...target[key], ...value] : value;
+      }
+      if (value instanceof Object && value !== null) {
+        return deepMerge(target[key] || {}, value);
+      }
+      return value;
+    })
+  };
+}
+
+// ../scene-graph/nodes/factories/elements/form/index.js
+var form_exports = {};
+__export(form_exports, {
+  fieldset: () => fieldset,
+  legend: () => legend,
+  meter: () => meter,
+  progress: () => progress
+});
+
+// ../scene-graph/nodes/factories/nodeDefaults.js
+var nodeDefaults = () => ({
+  __version: 1,
+  type: null,
+  render: {
+    name: null,
+    mode: "value",
+    value: true,
+    binding: null,
+    computed: null,
+    code: null,
+    error: null
+  },
+  name: null,
+  id: null,
+  tagName: null,
+  viewport: null,
+  layout: "none",
+  draggable: true,
+  resizable: true,
+  selectable: true,
+  locked: [],
+  anchor: [],
+  dimensions: [],
+  childrenType: null,
+  repeat: null,
+  contextName: null,
+  attributes: [],
+  events: [],
+  className: [],
+  states: [],
+  lifecycle: [],
+  animations: [],
+  style: {}
+});
+
+// ../scene-graph/nodes/factories/elements/elementDefaults.js
+var elementDefaults = () => deepMerge(nodeDefaults(), {
+  type: "element"
+});
+
+// ../scene-graph/nodes/factories/elements/form/formDefaults.js
+var formDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "auto",
+      height: "auto"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/form/fieldset.js
+var fieldset = () => deepMerge(formDefaults(), {
+  tagName: "fieldset",
+  style: {
+    default: {
+      border: "1px solid #cccccc",
+      padding: "16px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/form/legend.js
+var legend = () => deepMerge(formDefaults(), {
+  tagName: "legend",
+  childrenType: "text",
+  dimensions: ["width"],
+  textContent: {
+    value: "Legend",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-weight": "bold"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/form/progress.js
+var progress = () => deepMerge(formDefaults(), {
+  tagName: "progress",
+  childrenType: "none",
+  dimensions: ["width"],
+  attributes: [
+    {
+      key: "value",
+      value: "50"
+    },
+    {
+      key: "max",
+      value: "100"
+    }
+  ],
+  style: {
+    default: {
+      width: "200px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/form/meter.js
+var meter = () => deepMerge(formDefaults(), {
+  tagName: "meter",
+  childrenType: "none",
+  dimensions: ["width"],
+  attributes: [
+    {
+      key: "value",
+      value: "50"
+    },
+    {
+      key: "min",
+      value: "0"
+    },
+    {
+      key: "max",
+      value: "100"
+    }
+  ],
+  style: {
+    default: {
+      width: "200px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/index.js
+var headings_exports = {};
+__export(headings_exports, {
+  h1: () => h1,
+  h2: () => h2,
+  h3: () => h3,
+  h4: () => h4,
+  h5: () => h5,
+  h6: () => h6
+});
+
+// ../scene-graph/nodes/factories/elements/headings/headingDefaults.js
+var headingDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  childrenType: "text",
+  anchor: ["top", "left"],
+  dimensions: ["width"],
+  textContent: {
+    value: "",
+    binding: null
+  },
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      margin: "0",
+      width: "180px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h1.js
+var h1 = () => deepMerge(headingDefaults(), {
+  tagName: "h1",
+  textContent: {
+    value: "Heading 1",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h2.js
+var h2 = () => deepMerge(headingDefaults(), {
+  tagName: "h2",
+  textContent: {
+    value: "Heading 2",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h3.js
+var h3 = () => deepMerge(headingDefaults(), {
+  tagName: "h3",
+  textContent: {
+    value: "Heading 3",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h4.js
+var h4 = () => deepMerge(headingDefaults(), {
+  tagName: "h4",
+  textContent: {
+    value: "Heading 4",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h5.js
+var h5 = () => deepMerge(headingDefaults(), {
+  tagName: "h5",
+  textContent: {
+    value: "Heading 5",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/headings/h6.js
+var h6 = () => deepMerge(headingDefaults(), {
+  tagName: "h6",
+  textContent: {
+    value: "Heading 6",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/index.js
+var inputs_exports = {};
+__export(inputs_exports, {
+  checkbox: () => checkbox,
+  color: () => color,
+  date: () => date,
+  email: () => email,
+  file: () => file,
+  hidden: () => hidden,
+  input: () => input,
+  number: () => number,
+  password: () => password,
+  phone: () => phone,
+  radio: () => radio,
+  range: () => range,
+  search: () => search,
+  select: () => select,
+  text: () => text,
+  textarea: () => textarea
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/inputDefaults.js
+var inputDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "input",
+  anchor: ["top", "left"],
+  dimensions: ["width"],
+  childrenType: "none",
+  attributes: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "auto",
+      height: "auto"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/checkbox.js
+var checkbox = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "checkbox"
+    }
+  ]
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/email.js
+var email = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "email"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/password.js
+var password = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "password"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/phone.js
+var phone = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "tel"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/radio.js
+var radio = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "radio"
+    }
+  ],
+  style: {
+    default: {
+      margin: "0"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/text.js
+var text = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "text"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/select.js
+var select = () => deepMerge(inputDefaults(), {
+  tagName: "select",
+  childrenType: "options",
+  options: {
+    type: "set",
+    set: [],
+    binding: null,
+    expression: null,
+    dependencies: [],
+    valueKey: {
+      value: "value",
+      expression: null,
+      dependencies: []
+    },
+    labelKey: {
+      value: "label",
+      expression: null,
+      dependencies: []
+    }
+  },
+  attributes: [],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/color.js
+var color = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "color"
+    }
+  ],
+  style: {
+    default: {
+      width: "40px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/date.js
+var date = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "date"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/file.js
+var file = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "file"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/hidden.js
+var hidden = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "hidden"
+    }
+  ]
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/number.js
+var number = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "number"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/range.js
+var range = () => deepMerge(inputDefaults(), {
+  dimensions: ["width"],
+  attributes: [
+    {
+      key: "type",
+      value: "range"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/search.js
+var search = () => deepMerge(inputDefaults(), {
+  attributes: [
+    {
+      key: "type",
+      value: "search"
+    }
+  ],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/textarea.js
+var textarea = () => deepMerge(inputDefaults(), {
+  tagName: "textarea",
+  childrenType: "none",
+  attributes: [],
+  style: {
+    default: {
+      width: "240px",
+      height: "80px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/inputs/input.js
+var input = () => deepMerge(inputDefaults(), {
+  attributes: [],
+  style: {
+    default: {
+      width: "240px",
+      height: "32px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/index.js
+var interactive_exports = {};
+__export(interactive_exports, {
+  a: () => a,
+  button: () => button,
+  details: () => details,
+  dialog: () => dialog,
+  summary: () => summary
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/interactiveDefaults.js
+var interactiveDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  interactive: true,
+  childrenType: "text",
+  anchor: ["top", "left"],
+  attributes: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "auto",
+      height: "auto",
+      cursor: "pointer"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/button.js
+var button = () => deepMerge(interactiveDefaults(), {
+  tagName: "button",
+  childrenType: "text",
+  dimensions: ["width", "height"],
+  textContent: {
+    value: "Button text",
+    binding: null
+  },
+  style: {
+    default: {
+      "background-color": "#e9e9e9",
+      border: "1px solid #d5d5d5",
+      "border-radius": "4px",
+      padding: "6px 12px",
+      width: "120px",
+      height: "auto"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/a.js
+var a = () => deepMerge(interactiveDefaults(), {
+  tagName: "a",
+  textContent: {
+    value: "Link text",
+    binding: null
+  },
+  destination: {
+    type: "page",
+    // Optional: 'route' | 'url' | 'component' | 'modal' | 'page'.
+    id: null,
+    path: null,
+    target: null,
+    // Optional: '_blank', '_self', etc. (used if it's an external URL)
+    replace: false,
+    // Optional: use history.replace instead of push (for internal routes)
+    params: null,
+    // Optional: route params for dynamic routes
+    query: null
+    // Optional: query string params (as object)
+  },
+  style: {}
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/details.js
+var details = () => deepMerge(interactiveDefaults(), {
+  tagName: "details",
+  childrenType: "children",
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      cursor: "default"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/summary.js
+var summary = () => deepMerge(interactiveDefaults(), {
+  tagName: "summary",
+  textContent: {
+    value: "Summary text",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/interactive/dialog.js
+var dialog = () => deepMerge(interactiveDefaults(), {
+  tagName: "dialog",
+  childrenType: "children",
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      cursor: "default",
+      width: "300px",
+      height: "200px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/layout/index.js
+var layout_exports = {};
+__export(layout_exports, {
+  article: () => article,
+  aside: () => aside,
+  div: () => div,
+  footer: () => footer,
+  form: () => form,
+  header: () => header,
+  main: () => main,
+  nav: () => nav,
+  section: () => section,
+  template: () => template
+});
+
+// ../scene-graph/nodes/factories/elements/layout/layoutDefaults.js
+var layoutDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  childrenType: "children",
+  children: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "1px",
+      height: "1px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/layout/aside.js
+var aside = () => deepMerge(layoutDefaults(), {
+  tagName: "aside"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/footer.js
+var footer = () => deepMerge(layoutDefaults(), {
+  tagName: "footer"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/form.js
+var form = () => deepMerge(layoutDefaults(), {
+  tagName: "form"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/header.js
+var header = () => deepMerge(layoutDefaults(), {
+  tagName: "header"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/main.js
+var main = () => deepMerge(layoutDefaults(), {
+  tagName: "main"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/section.js
+var section = () => deepMerge(layoutDefaults(), {
+  tagName: "section"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/article.js
+var article = () => deepMerge(layoutDefaults(), {
+  tagName: "article"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/nav.js
+var nav = () => deepMerge(layoutDefaults(), {
+  tagName: "nav"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/div.js
+var div = () => deepMerge(layoutDefaults(), {
+  tagName: "div"
+});
+
+// ../scene-graph/nodes/factories/elements/layout/template.js
+var template = () => deepMerge(layoutDefaults(), {
+  type: "template",
+  tagName: "template",
+  html: "<div>HTML template</div>",
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "250px",
+      height: "100px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/lists/index.js
+var lists_exports = {};
+__export(lists_exports, {
+  dd: () => dd,
+  dl: () => dl,
+  dt: () => dt,
+  li: () => li,
+  ol: () => ol,
+  ul: () => ul
+});
+
+// ../scene-graph/nodes/factories/elements/lists/listDefaults.js
+var listDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  childrenType: "children",
+  children: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      margin: "0",
+      width: "100px",
+      height: "10px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/lists/ol.js
+var ol = () => deepMerge(listDefaults(), {
+  tagName: "ol"
+});
+
+// ../scene-graph/nodes/factories/elements/lists/ul.js
+var ul = () => deepMerge(listDefaults(), {
+  tagName: "ul"
+});
+
+// ../scene-graph/nodes/factories/elements/lists/li.js
+var li = () => deepMerge(listDefaults(), {
+  tagName: "li",
+  children: []
+});
+
+// ../scene-graph/nodes/factories/elements/lists/dl.js
+var dl = () => deepMerge(listDefaults(), {
+  tagName: "dl"
+});
+
+// ../scene-graph/nodes/factories/elements/lists/dt.js
+var dt = () => deepMerge(listDefaults(), {
+  tagName: "dt",
+  childrenType: "text",
+  textContent: {
+    value: "Term",
+    binding: null
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/lists/dd.js
+var dd = () => deepMerge(listDefaults(), {
+  tagName: "dd",
+  childrenType: "text",
+  textContent: {
+    value: "Description",
+    binding: null
+  },
+  style: {
+    default: {
+      "margin-left": "0"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/index.js
+var media_exports = {};
+__export(media_exports, {
+  audio: () => audio,
+  figcaption: () => figcaption,
+  figure: () => figure,
+  iframe: () => iframe,
+  img: () => img,
+  video: () => video
+});
+
+// ../scene-graph/nodes/factories/elements/media/mediaDefaults.js
+var mediaDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  attributes: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "auto",
+      height: "auto",
+      "object-fit": "contain"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/img.js
+var img = () => deepMerge(mediaDefaults(), {
+  tagName: "img",
+  childrenType: "none"
+});
+
+// ../scene-graph/nodes/factories/elements/media/video.js
+var video = () => deepMerge(mediaDefaults(), {
+  tagName: "video",
+  childrenType: "children",
+  attributes: [
+    { key: "controls", value: true }
+  ],
+  style: {
+    default: {
+      width: "320px",
+      height: "240px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/audio.js
+var audio = () => deepMerge(mediaDefaults(), {
+  tagName: "audio",
+  childrenType: "none",
+  dimensions: ["width"],
+  attributes: [
+    { key: "controls", value: true }
+  ],
+  style: {
+    default: {
+      width: "320px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/iframe.js
+var iframe = () => deepMerge(mediaDefaults(), {
+  tagName: "iframe",
+  childrenType: "none",
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      width: "320px",
+      height: "240px",
+      "object-fit": void 0
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/figure.js
+var figure = () => deepMerge(mediaDefaults(), {
+  tagName: "figure",
+  childrenType: "children",
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      width: "auto",
+      height: "auto",
+      margin: "0"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/textDefaults.js
+var textDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  childrenType: "text",
+  anchor: ["top", "left"],
+  textContent: {
+    value: "",
+    binding: null
+  },
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      margin: "0",
+      width: "auto",
+      height: "auto"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/media/figcaption.js
+var figcaption = () => deepMerge(textDefaults(), {
+  tagName: "figcaption",
+  textContent: {
+    value: "Caption text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "14px",
+      color: "#666666"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/tables/index.js
+var tables_exports = {};
+__export(tables_exports, {
+  table: () => table,
+  tbody: () => tbody,
+  td: () => td,
+  tfoot: () => tfoot,
+  th: () => th,
+  thead: () => thead,
+  tr: () => tr
+});
+
+// ../scene-graph/nodes/factories/elements/tables/tableDefaults.js
+var tableDefaults = () => deepMerge(elementDefaults(), {
+  tagName: "",
+  anchor: ["top", "left"],
+  dimensions: ["width"],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "auto"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/tables/table.js
+var table = () => deepMerge(tableDefaults(), {
+  tagName: "table",
+  dimensions: ["width", "height"],
+  style: {
+    default: {
+      "border-collapse": "collapse"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/tables/thead.js
+var thead = () => deepMerge(tableDefaults(), {
+  tagName: "thead"
+});
+
+// ../scene-graph/nodes/factories/elements/tables/tbody.js
+var tbody = () => deepMerge(tableDefaults(), {
+  tagName: "tbody"
+});
+
+// ../scene-graph/nodes/factories/elements/tables/tfoot.js
+var tfoot = () => deepMerge(tableDefaults(), {
+  tagName: "tfoot"
+});
+
+// ../scene-graph/nodes/factories/elements/tables/tr.js
+var tr = () => deepMerge(tableDefaults(), {
+  tagName: "tr"
+});
+
+// ../scene-graph/nodes/factories/elements/tables/th.js
+var th = () => deepMerge(tableDefaults(), {
+  tagName: "th",
+  childrenType: "text",
+  textContent: {
+    value: "Header",
+    binding: null
+  },
+  style: {
+    default: {
+      padding: "8px",
+      "text-align": "left",
+      "font-weight": "bold"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/tables/td.js
+var td = () => deepMerge(tableDefaults(), {
+  tagName: "td",
+  childrenType: "text",
+  textContent: {
+    value: "Cell",
+    binding: null
+  },
+  style: {
+    default: {
+      padding: "8px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/index.js
+var text_exports = {};
+__export(text_exports, {
+  blockquote: () => blockquote,
+  br: () => br,
+  code: () => code,
+  em: () => em,
+  hr: () => hr,
+  label: () => label,
+  mark: () => mark,
+  p: () => p,
+  pre: () => pre,
+  small: () => small,
+  span: () => span,
+  strong: () => strong
+});
+
+// ../scene-graph/nodes/factories/elements/text/p.js
+var p = () => deepMerge(textDefaults(), {
+  tagName: "p",
+  textContent: {
+    value: "Paragraph text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      "line-height": "1.5",
+      color: "#333333"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/label.js
+var label = () => deepMerge(textDefaults(), {
+  tagName: "label",
+  textContent: {
+    value: "Label text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "14px",
+      "font-weight": "500",
+      color: "#666666"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/span.js
+var span = () => deepMerge(textDefaults(), {
+  tagName: "span",
+  textContent: {
+    value: "",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      color: "#333333"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/blockquote.js
+var blockquote = () => deepMerge(textDefaults(), {
+  tagName: "blockquote",
+  textContent: {
+    value: "Blockquote text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      "line-height": "1.5",
+      color: "#333333",
+      "padding-left": "16px",
+      "border-left": "3px solid #cccccc"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/pre.js
+var pre = () => deepMerge(textDefaults(), {
+  tagName: "pre",
+  textContent: {
+    value: "Preformatted text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "14px",
+      "font-family": "monospace",
+      "line-height": "1.4",
+      color: "#333333",
+      "white-space": "pre"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/code.js
+var code = () => deepMerge(textDefaults(), {
+  tagName: "code",
+  textContent: {
+    value: "code",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "14px",
+      "font-family": "monospace",
+      color: "#333333"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/strong.js
+var strong = () => deepMerge(textDefaults(), {
+  tagName: "strong",
+  textContent: {
+    value: "Bold text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      "font-weight": "bold",
+      color: "#333333"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/em.js
+var em = () => deepMerge(textDefaults(), {
+  tagName: "em",
+  textContent: {
+    value: "Emphasized text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      "font-style": "italic",
+      color: "#333333"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/small.js
+var small = () => deepMerge(textDefaults(), {
+  tagName: "small",
+  textContent: {
+    value: "Small text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "12px",
+      color: "#666666"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/mark.js
+var mark = () => deepMerge(textDefaults(), {
+  tagName: "mark",
+  textContent: {
+    value: "Highlighted text",
+    binding: null
+  },
+  style: {
+    default: {
+      "font-size": "16px",
+      color: "#333333",
+      "background-color": "#ffff00"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/hr.js
+var hr = () => deepMerge(elementDefaults(), {
+  tagName: "hr",
+  anchor: ["top", "left"],
+  dimensions: ["width"],
+  childrenType: "none",
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "100%",
+      border: "none",
+      "border-top": "1px solid #cccccc"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/elements/text/br.js
+var br = () => deepMerge(elementDefaults(), {
+  tagName: "br",
+  childrenType: "none"
+});
+
+// ../scene-graph/nodes/factories/elements/createElement.js
+var getAllElements = () => ({
+  ...form_exports,
+  ...headings_exports,
+  ...inputs_exports,
+  ...interactive_exports,
+  ...layout_exports,
+  ...lists_exports,
+  ...media_exports,
+  ...tables_exports,
+  ...text_exports
+});
+var getElement = (name) => getAllElements()[name];
+var hasElement = (name) => !!getElement(name);
+function createElement(name) {
+  if (!hasElement(name)) {
+    return new Error(`Element ${name} not found`);
+  }
+  return getElement(name)();
+}
+
+// ../scene-graph/nodes/factories/instances/instanceDefaults.js
+var instanceDefaults = () => deepMerge(nodeDefaults(), {
+  name: null,
+  type: "instance",
+  component: null,
+  library: null,
+  props: [],
+  slots: [],
+  layout: "none",
+  draggable: true,
+  resizable: true,
+  selectable: true,
+  locked: [],
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  childrenType: "children"
+});
+
+// ../scene-graph/nodes/factories/instances/createInstance.js
+function createInstance(component, library) {
+  return deepMerge(instanceDefaults(), { component, library });
+}
+
+// ../scene-graph/nodes/factories/graphics/graphicDefaults.js
+var graphicDefaults = () => deepMerge(nodeDefaults(), {
+  type: "template",
+  tagName: "div",
+  props: {},
+  template: [],
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      margin: "0",
+      width: "100px",
+      height: "100px"
+    }
+  }
+});
+
+// ../scene-graph/nodes/factories/graphics/rectangle.js
+var rectangle_default = () => deepMerge(graphicDefaults(), {
+  name: "rectangle",
+  props: {
+    fill: {
+      type: "color",
+      default: "black"
+    },
+    stroke: {
+      type: "color",
+      default: "black"
+    },
+    strokeWidth: {
+      type: "cssNumber",
+      default: "1px",
+      units: ["px", "rem", "em", "%"]
+    }
+  },
+  context: {},
+  template: [
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      style: "width: 100%; height: 100%; top: 0; left: 0; position: absolute;"
+    },
+    [
+      ["rect", {
+        x: "0",
+        y: "0",
+        width: "100%",
+        height: "100%",
+        fill: { ref: "fill" }
+      }]
+    ]
+  ]
+});
+
+// ../scene-graph/nodes/factories/graphics/roundedRectangle.js
+var roundedRectangle_default = () => deepMerge(graphicDefaults(), {
+  name: "rounded_rectangle",
+  props: {
+    rx: {
+      type: "cssNumber",
+      default: "10px",
+      units: ["px", "rem", "em", "%"]
+    },
+    ry: {
+      type: "cssNumber",
+      default: "10px",
+      units: ["px", "rem", "em", "%"]
+    },
+    fill: {
+      type: "color",
+      default: "black"
+    },
+    stroke: {
+      type: "color",
+      default: "black"
+    },
+    strokeWidth: {
+      type: "cssNumber",
+      default: "1px",
+      units: ["px", "rem", "em", "%"]
+    },
+    width: {
+      type: "cssNumber",
+      default: "100px",
+      units: ["px", "rem", "em", "%"]
+    },
+    height: {
+      type: "cssNumber",
+      default: "100px",
+      units: ["px", "rem", "em", "%"]
+    }
+  },
+  context: {},
+  template: [
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      style: "width: 100%; height: 100%;"
+    },
+    [
+      ["rect", {
+        x: "0",
+        y: "0",
+        width: "100%",
+        height: "100%",
+        fill: { ref: "fill" },
+        rx: {
+          ref: "rx"
+        },
+        ry: {
+          ref: "ry"
+        }
+      }]
+    ]
+  ]
+});
+
+// ../scene-graph/nodes/factories/graphics/ellipse.js
+var ellipse_default = () => deepMerge(defaults(), {
+  name: "ellipse",
+  props: {
+    fill: {
+      type: "color",
+      default: "black"
+    },
+    stroke: {
+      type: "color",
+      default: "black"
+    },
+    strokeWidth: {
+      type: "cssNumber",
+      default: "1px",
+      units: ["px", "rem", "em", "%"]
+    }
+  },
+  context: {},
+  template: [
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      style: "width: 100%; height: 100%; top: 0; left: 0; position: absolute;",
+      preserveAspectRatio: "none"
+    },
+    [
+      ["svg", {
+        viewBox: "0 0 100 100",
+        width: "100%",
+        height: "100%",
+        top: "0",
+        left: "0",
+        preserveAspectRatio: "none"
+      }, [
+        ["ellipse", {
+          cx: "50px",
+          cy: "50px",
+          rx: "50px",
+          ry: "50px",
+          fill: { ref: "fill" },
+          strokeWidth: { ref: "strokeWidth" }
+        }]
+      ]]
+    ]
+  ]
+}, base());
+
+// ../scene-graph/nodes/factories/graphics/triangle.js
+var triangle_default = () => deepMerge(graphicDefaults(), {
+  name: "triangle",
+  props: {
+    fill: {
+      type: "color",
+      default: "black"
+    },
+    stroke: {
+      type: "color",
+      default: "black"
+    },
+    strokeWidth: {
+      type: "cssNumber",
+      default: "1px",
+      units: ["px", "rem", "em", "%"]
+    }
+  },
+  context: {},
+  template: [
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      style: "width: 100%; height: 100%; top: 0; left: 0; position: absolute;",
+      preserveAspectRatio: "none"
+    },
+    [
+      ["svg", {
+        viewBox: "0 0 100 100",
+        width: "100%",
+        height: "100%",
+        top: "0",
+        left: "0",
+        preserveAspectRatio: "none"
+      }, [
+        ["polygon", {
+          points: "50,0 100,100 0,100",
+          fill: { ref: "fill" },
+          strokeWidth: { ref: "strokeWidth" }
+        }]
+      ]]
+    ]
+  ]
+});
+
+// ../scene-graph/nodes/factories/graphics/createGraphic.js
+var getAllGraphics = () => ({
+  rectangle: rectangle_default,
+  roundedRectangle: roundedRectangle_default,
+  ellipse: ellipse_default,
+  triangle: triangle_default
+});
+var getGraphic = (name) => getAllGraphics()[name];
+var hasGraphic = (name) => !!getGraphic(name);
+function createGraphic(name) {
+  if (!hasGraphic(name)) {
+    return new Error(`Graphic ${name} not found`);
+  }
+  return deepMerge(getGraphic(name)());
+}
+
+// ../scene-graph/nodes/factories/containers/containerDefaults.js
+var containerDefaults = () => deepMerge(nodeDefaults(), {
+  childrenType: "*",
+  bounds: {
+    width: 0,
+    height: 0,
+    x: 0,
+    y: 0
+  },
+  breakpoints: [
+    { name: "Mobile", type: "mobile", min: 320, editable: false },
+    { name: "Tablet", type: "mobile", min: 768, editable: false },
+    { name: "Desktop", type: "desktop", min: 1280, editable: false }
+  ]
+});
+
+// ../scene-graph/nodes/factories/components/componentDefaults.js
+var componentDefaults = () => deepMerge(containerDefaults(), {
+  name: "",
+  type: "component",
+  library: "local",
+  props: [],
+  emits: [],
+  data: [],
+  children: []
+});
+
+// ../scene-graph/nodes/factories/components/createComponent.js
+function createComponent(children = [], name = "", viewport = null) {
+  return deepMerge(componentDefaults(), { children, name, viewport });
+}
+
+// ../scene-graph/nodes/factories/animations/animationDefaults.js
+var animationDefaults = () => ({
+  __version: 1,
+  type: "animation",
+  scope: "node",
+  name: null,
+  duration: 300,
+  easing: "ease",
+  fill: "none",
+  direction: "normal",
+  iterations: 1,
+  delay: 0,
+  endDelay: 0,
+  iterationStart: 0,
+  composite: "replace",
+  keyframes: []
+});
+
+// ../scene-graph/nodes/factories/animations/createAnimation.js
+function createAnimation(props = {}) {
+  const defaults2 = animationDefaults();
+  return {
+    ...defaults2,
+    scope: props.scope ?? defaults2.scope,
+    name: props.name ?? defaults2.name,
+    duration: props.duration ?? defaults2.duration,
+    easing: props.easing ?? defaults2.easing,
+    fill: props.fill ?? defaults2.fill,
+    direction: props.direction ?? defaults2.direction,
+    iterations: props.iterations ?? defaults2.iterations,
+    delay: props.delay ?? defaults2.delay,
+    endDelay: props.endDelay ?? defaults2.endDelay,
+    iterationStart: props.iterationStart ?? defaults2.iterationStart,
+    composite: props.composite ?? defaults2.composite,
+    keyframes: props.keyframes ?? defaults2.keyframes
+  };
+}
+
+// ../scene-graph/nodes/factories/elements/special/slot.js
+var slotDefaults = () => deepMerge(nodeDefaults(), {
+  type: "slot",
+  tagName: "slot",
+  anchor: ["top", "left"],
+  dimensions: ["width", "height"],
+  draggable: true,
+  resizable: false,
+  selectable: true,
+  locked: [],
+  childrenType: "children",
+  style: {
+    default: {
+      top: "0",
+      left: "0",
+      width: "100px",
+      height: "80px",
+      "min-width": "40px",
+      "min-height": "40px"
+    }
+  },
+  attributes: [],
+  events: [],
+  className: [
+    {
+      name: "slot",
+      mode: "value",
+      value: true,
+      binding: null,
+      computed: null,
+      code: null,
+      error: null,
+      system: true
+    }
+  ],
+  states: [],
+  lifecycle: [],
+  animations: []
+});
+function createSlot(name = "Slot 1") {
+  return deepMerge(slotDefaults(), { name });
+}
+
+// ../scene-graph/nodes/factories/createNode.js
+function getNode(type, { shape, tagName, viewport, width, height, name, component, library, children, ...rest }) {
+  switch (type) {
+    case "component":
+      return createComponent(children, name, viewport);
+    case "instance":
+      return createInstance(component, library);
+    case "frame":
+    case "viewport":
+      return createFrame(viewport, { width, height, name });
+    case "element":
+      return createElement(tagName);
+    case "graphic":
+      return createGraphic(shape);
+    case "animation":
+      return createAnimation({ name, ...rest });
+    case "slot":
+      return createSlot(name);
+  }
+}
+function createNode(type, props) {
+  const newNode = getNode(type, props);
+  return newNode;
+}
+
+// ../scene-graph/nodes/factories/elements/form/meta.js
+var meta = [
+  {
+    type: "element",
+    displayName: "Fieldset",
+    category: "form",
+    swapGroup: null,
+    keywords: ["form"],
+    tagName: "fieldset"
+  },
+  {
+    type: "element",
+    displayName: "Legend",
+    category: "form",
+    swapGroup: null,
+    keywords: ["form"],
+    tagName: "legend"
+  },
+  {
+    type: "element",
+    displayName: "Progress",
+    category: "form",
+    swapGroup: null,
+    keywords: ["form"],
+    tagName: "progress"
+  },
+  {
+    type: "element",
+    displayName: "Meter",
+    category: "form",
+    swapGroup: null,
+    keywords: ["form"],
+    tagName: "meter"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/headings/meta.js
+var meta2 = [
+  {
+    type: "element",
+    displayName: "Heading 1",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h1"
+  },
+  {
+    type: "element",
+    displayName: "Heading 2",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h2"
+  },
+  {
+    type: "element",
+    displayName: "Heading 3",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h3"
+  },
+  {
+    type: "element",
+    displayName: "Heading 4",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h4"
+  },
+  {
+    type: "element",
+    displayName: "Heading 5",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h5"
+  },
+  {
+    type: "element",
+    displayName: "Heading 6",
+    keywords: ["headings"],
+    category: "headings",
+    swapGroup: "headings",
+    tagName: "h6"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/inputs/meta.js
+var meta3 = [
+  {
+    type: "element",
+    displayName: "Radio",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "radio"
+  },
+  {
+    type: "element",
+    displayName: "Text",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "text"
+  },
+  {
+    type: "element",
+    displayName: "Checkbox",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "checkbox"
+  },
+  {
+    type: "element",
+    displayName: "Phone",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "phone"
+  },
+  {
+    type: "element",
+    displayName: "Email",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "email"
+  },
+  {
+    type: "element",
+    displayName: "Password",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "password"
+  },
+  {
+    type: "element",
+    displayName: "Select",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "select"
+  },
+  {
+    type: "element",
+    displayName: "Textarea",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "textarea"
+  },
+  {
+    type: "element",
+    displayName: "Number",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "number"
+  },
+  {
+    type: "element",
+    displayName: "Date",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "date"
+  },
+  {
+    type: "element",
+    displayName: "Range",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "range"
+  },
+  {
+    type: "element",
+    displayName: "File Upload",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "file"
+  },
+  {
+    type: "element",
+    displayName: "Search",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "search"
+  },
+  {
+    type: "element",
+    displayName: "Color Picker",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "color"
+  },
+  {
+    type: "element",
+    displayName: "Hidden",
+    category: "inputs",
+    swapGroup: null,
+    keywords: ["inputs"],
+    tagName: "hidden"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/interactive/meta.js
+var meta4 = [
+  {
+    type: "element",
+    displayName: "Button",
+    category: "interactive",
+    swapGroup: "interactive",
+    keywords: ["interactive"],
+    tagName: "button"
+  },
+  {
+    type: "element",
+    displayName: "Link",
+    category: "interactive",
+    swapGroup: "interactive",
+    keywords: ["interactive"],
+    tagName: "a"
+  },
+  {
+    type: "element",
+    displayName: "Details",
+    category: "interactive",
+    swapGroup: null,
+    keywords: ["interactive"],
+    tagName: "details"
+  },
+  {
+    type: "element",
+    displayName: "Summary",
+    category: "interactive",
+    swapGroup: null,
+    keywords: ["interactive"],
+    tagName: "summary"
+  },
+  {
+    type: "element",
+    displayName: "Dialog",
+    category: "interactive",
+    swapGroup: null,
+    keywords: ["interactive"],
+    tagName: "dialog"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/layout/meta.js
+var meta5 = [
+  {
+    type: "element",
+    displayName: "Aside",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "aside"
+  },
+  {
+    type: "element",
+    displayName: "Footer",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "footer"
+  },
+  {
+    type: "element",
+    displayName: "Form",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "form"
+  },
+  {
+    type: "element",
+    displayName: "Header",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "header"
+  },
+  {
+    type: "element",
+    displayName: "Main",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "main"
+  },
+  {
+    type: "element",
+    displayName: "Section",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "section"
+  },
+  {
+    type: "element",
+    displayName: "Article",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "article"
+  },
+  {
+    type: "element",
+    displayName: "Nav",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "nav"
+  },
+  {
+    type: "element",
+    displayName: "Div",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "div"
+  },
+  {
+    type: "element",
+    displayName: "Template",
+    category: "layout",
+    swapGroup: "layout",
+    keywords: ["layout"],
+    tagName: "template"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/lists/meta.js
+var meta6 = [
+  {
+    type: "element",
+    displayName: "Ordered List",
+    category: "lists",
+    swapGroup: "list-container",
+    keywords: ["lists"],
+    tagName: "ol"
+  },
+  {
+    type: "element",
+    displayName: "Unordered List",
+    category: "lists",
+    swapGroup: "list-container",
+    keywords: ["lists"],
+    tagName: "ul"
+  },
+  {
+    type: "element",
+    displayName: "List Item",
+    category: "lists",
+    swapGroup: null,
+    keywords: ["lists"],
+    tagName: "li"
+  },
+  {
+    type: "element",
+    displayName: "Definition List",
+    category: "lists",
+    swapGroup: "list-container",
+    keywords: ["lists"],
+    tagName: "dl"
+  },
+  {
+    type: "element",
+    displayName: "Definition Term",
+    category: "lists",
+    swapGroup: null,
+    keywords: ["lists"],
+    tagName: "dt"
+  },
+  {
+    type: "element",
+    displayName: "Definition Description",
+    category: "lists",
+    swapGroup: null,
+    keywords: ["lists"],
+    tagName: "dd"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/media/meta.js
+var meta7 = [
+  {
+    type: "element",
+    displayName: "Image",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "img"
+  },
+  {
+    type: "element",
+    displayName: "Video",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "video"
+  },
+  {
+    type: "element",
+    displayName: "Audio",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "audio"
+  },
+  {
+    type: "element",
+    displayName: "Iframe",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "iframe"
+  },
+  {
+    type: "element",
+    displayName: "Figure",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "figure"
+  },
+  {
+    type: "element",
+    displayName: "Figcaption",
+    category: "media",
+    swapGroup: null,
+    keywords: ["media"],
+    tagName: "figcaption"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/tables/meta.js
+var meta8 = [
+  {
+    type: "element",
+    displayName: "Table",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "table"
+  },
+  {
+    type: "element",
+    displayName: "Table Head",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "thead"
+  },
+  {
+    type: "element",
+    displayName: "Table Body",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "tbody"
+  },
+  {
+    type: "element",
+    displayName: "Table Foot",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "tfoot"
+  },
+  {
+    type: "element",
+    displayName: "Table Row",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "tr"
+  },
+  {
+    type: "element",
+    displayName: "Table Header Cell",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "th"
+  },
+  {
+    type: "element",
+    displayName: "Table Cell",
+    category: "tables",
+    swapGroup: null,
+    keywords: ["tables"],
+    tagName: "td"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/text/meta.js
+var meta9 = [{
+  type: "element",
+  displayName: "Paragraph",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "p"
+}, {
+  type: "element",
+  displayName: "Label",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "label"
+}, {
+  type: "element",
+  displayName: "Span",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "span"
+}, {
+  type: "element",
+  displayName: "Blockquote",
+  category: "text",
+  swapGroup: null,
+  keywords: ["text"],
+  tagName: "blockquote"
+}, {
+  type: "element",
+  displayName: "Preformatted",
+  category: "text",
+  swapGroup: null,
+  keywords: ["text"],
+  tagName: "pre"
+}, {
+  type: "element",
+  displayName: "Code",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "code"
+}, {
+  type: "element",
+  displayName: "Strong",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "strong"
+}, {
+  type: "element",
+  displayName: "Emphasis",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "em"
+}, {
+  type: "element",
+  displayName: "Small",
+  category: "text",
+  swapGroup: "text",
+  keywords: ["text"],
+  tagName: "small"
+}, {
+  type: "element",
+  displayName: "Mark",
+  category: "text",
+  swapGroup: null,
+  keywords: ["text"],
+  tagName: "mark"
+}, {
+  type: "element",
+  displayName: "Horizontal Rule",
+  category: "text",
+  swapGroup: null,
+  keywords: ["text", "divider"],
+  tagName: "hr"
+}, {
+  type: "element",
+  displayName: "Line Break",
+  category: "text",
+  swapGroup: null,
+  keywords: ["text"],
+  tagName: "br"
+}];
+
+// ../scene-graph/nodes/factories/elements/special/meta.js
+var meta10 = [
+  {
+    type: "slot",
+    displayName: "Slot",
+    category: "special",
+    keywords: ["slot", "placeholder", "component", "template"],
+    tagName: "slot"
+  }
+];
+
+// ../scene-graph/nodes/factories/elements/meta.js
+var meta11 = [
+  ...meta5,
+  ...meta2,
+  ...meta3,
+  ...meta4,
+  ...meta6,
+  ...meta7,
+  ...meta9,
+  ...meta,
+  ...meta8,
+  ...meta10
+];
+
+// ../scene-graph/nodes/factories/graphics/meta.js
+var meta12 = [
+  {
+    displayName: "Rectangle",
+    keywords: ["rectangle"],
+    category: "shapes",
+    shape: "rectangle"
+  },
+  {
+    displayName: "Rounded Rectangle",
+    keywords: ["rounded", "rectangle"],
+    category: "shapes",
+    shape: "roundedRectangle"
+  },
+  {
+    displayName: "Ellipse",
+    keywords: ["ellipse"],
+    category: "shapes",
+    shape: "ellipse"
+  },
+  {
+    displayName: "Triangle",
+    keywords: ["triangle"],
+    category: "shapes",
+    shape: "triangle"
+  }
+];
+
+// ../scene-graph/nodes/main.js
+var contracts = [
+  breakpointContracts,
+  classNameContracts,
+  clipboardContracts,
+  contextNameContracts,
+  statesContracts,
+  eventsContracts,
+  addContracts,
+  attributeContracts,
+  propContracts,
+  slotContracts,
+  htmlContracts,
+  destinationContracts,
+  dragContracts,
+  lifecycleContracts,
+  interactionStateContracts,
+  patchContracts,
+  behaviorContracts,
+  layoutContracts,
+  moveContracts,
+  nameContracts,
+  optionsContracts,
+  orderContracts,
+  removeContracts,
+  renderContracts,
+  repeatContracts,
+  routeContracts,
+  styleContracts,
+  tagNameContracts,
+  textContentContracts,
+  typeContracts,
+  viewportContracts,
+  htmlIdContracts
+];
+
+export {
+  breakpointContracts,
+  classNameContracts,
+  clipboardContracts,
+  contextNameContracts,
+  statesContracts,
+  addContracts,
+  eventsContracts,
+  attributeContracts,
+  createProp,
+  propContracts,
+  buildSlotsFromMeta,
+  mergeMissingSlotsFromMeta,
+  slotContracts,
+  htmlContracts,
+  destinationContracts,
+  dragContracts,
+  lifecycleContracts,
+  interactionStateContracts,
+  patchContracts,
+  behaviorContracts,
+  layoutContracts,
+  moveContracts,
+  nameContracts,
+  optionsContracts,
+  orderContracts,
+  removeContracts,
+  renderContracts,
+  repeatContracts,
+  routeContracts,
+  styleContracts,
+  tagNameContracts,
+  textContentContracts,
+  typeContracts,
+  viewportContracts,
+  htmlIdContracts,
+  createNode,
+  meta11 as meta,
+  meta12 as meta2,
+  contracts
+};