@jucie.io/cli 1.0.0

package/dist/stage-bundles/react/chunks/bootstrap-6YUSZ2AL.js

@@ -0,0 +1,4080 @@
+import {
+  CREATED,
+  DELETED,
+  GLOBAL_TAG,
+  Plugin,
+  R,
+  SceneCompiler,
+  UPDATED,
+  createMarker,
+  decode,
+  decodeAddress,
+  dispatch,
+  elements,
+  encode,
+  encodePath,
+  f,
+  f2,
+  initializeNode,
+  normalizeSceneViewportKinds,
+  palette as palette2,
+  re,
+  s
+} from "./chunk-RZDFRJVR.js";
+import "./chunk-5EXNWE4S.js";
+import "./chunk-YMVTSVEM.js";
+import "./chunk-7MWSPEGH.js";
+import "./chunk-3NLDBJQD.js";
+import {
+  G,
+  T,
+  g,
+  v
+} from "./chunk-3BDWFE4Q.js";
+import "./chunk-QCQXLZJH.js";
+import "./chunk-DBHMBCBM.js";
+import "./chunk-ILZWSEWK.js";
+import "./chunk-65Q2CFW7.js";
+import "./chunk-QIOKODGT.js";
+import "./chunk-YCZNHFZA.js";
+import "./chunk-YM3NAGCN.js";
+import "./chunk-YEEGISBQ.js";
+import "./chunk-PU2GET2S.js";
+import "./chunk-6RLI7CFQ.js";
+import "./chunk-SPTKNGHA.js";
+import "./chunk-6BXKZHN6.js";
+import "./chunk-F6JYAVEC.js";
+import "./chunk-RI7XWDHX.js";
+import "./chunk-DCKGUW2M.js";
+import "./chunk-KF4MVCJ6.js";
+import "./chunk-W5CGYUVM.js";
+import "./chunk-O3KQTA3H.js";
+import "./chunk-EB5FGFFG.js";
+import "./chunk-MAPYANXA.js";
+import "./chunk-UHGV762U.js";
+import "./chunk-IIIXGKVH.js";
+import "./chunk-FSIANI7E.js";
+import "./chunk-CHZVDVQC.js";
+import "./chunk-U7U7L7XZ.js";
+import "./chunk-CXATTVPL.js";
+import "./chunk-CJOJNMRC.js";
+import "./chunk-667SIQGW.js";
+import "./chunk-RZG5LCPH.js";
+import "./chunk-6QYYO5LM.js";
+import "./chunk-IO3NSIEJ.js";
+import "./chunk-MMCB6GGX.js";
+import "./chunk-BWZPEI76.js";
+import "./chunk-6E57QUN7.js";
+import "./chunk-TKHCH4WB.js";
+import "./chunk-VZNGMF63.js";
+import "./chunk-P7UUT7BU.js";
+import "./chunk-6TDZGYJG.js";
+import "./chunk-TVGXBOIT.js";
+import "./chunk-VK4FEQKG.js";
+import "./chunk-SF5BLQ7P.js";
+import "./chunk-F77HGOQB.js";
+import "./chunk-2H2EQ2RG.js";
+import "./chunk-XKFPCFZH.js";
+import "./chunk-V6MKKC23.js";
+import "./chunk-TVB3GD7L.js";
+import "./chunk-RCIDQRAS.js";
+import "./chunk-WXDXWNWW.js";
+import "./chunk-JDIO27MU.js";
+import "./chunk-A65NYJEZ.js";
+import "./chunk-2Y25YY3N.js";
+import "./chunk-S4NZQRJJ.js";
+import "./chunk-M3YT4JBL.js";
+import "./chunk-WMV5J37V.js";
+import "./chunk-QTTED7GZ.js";
+import {
+  palette
+} from "./chunk-6R3QXFFF.js";
+import {
+  PROTOTYPES
+} from "./chunk-XVJJ3LG4.js";
+import "./chunk-KHURU62K.js";
+import "./chunk-H75SQT4U.js";
+import "./chunk-AI3MQHWR.js";
+import "./chunk-236DY7EE.js";
+import "./chunk-K7ZULZJF.js";
+import "./chunk-6B6PKOOA.js";
+import "./chunk-W7QH4UII.js";
+import "./chunk-22J4JOPG.js";
+import "./chunk-LH4ZDX3T.js";
+import "./chunk-IDGFZWZY.js";
+import "./chunk-3MJKS6VX.js";
+import "./chunk-KOBPYD4N.js";
+import "./chunk-ABVPSM2D.js";
+import "./chunk-ZP3VSN3A.js";
+import "./chunk-5C4ODH2L.js";
+import "./chunk-QVH24VHP.js";
+import "./chunk-S5L2YBXG.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __privateWrapper,
+  __publicField
+} from "./chunk-ZHZLVPR6.js";
+
+// ../engine-ai/src/AiGatewayService.js
+var RATE_WINDOW_MS = 60 * 60 * 1e3;
+
+// ../engine-ai/src/defineAiOperations.js
+var defineAiOperations = g("AI_OPERATIONS", [Object]);
+function extractOperationsMetadata(operationDefinition) {
+  const namespace = operationDefinition._name;
+  const operations = operationDefinition();
+  return {
+    namespace,
+    operations: Object.entries(operations).map(([name, op]) => ({
+      name,
+      fullName: `${namespace}:${name}`,
+      alias: op.alias || null,
+      mcpName: op.mcpName || null,
+      description: op.description || "",
+      schema: op.schema || [],
+      examples: op.examples || [],
+      returns: op.returns || "Object"
+    }))
+  };
+}
+function validateOperationArgs(args, schema, operationName) {
+  if (!Array.isArray(schema) || schema.length === 0) {
+    return true;
+  }
+  const typeDef = schema[0];
+  if (typeof typeDef !== "object" || Array.isArray(typeDef)) {
+    console.warn(`Schema for ${operationName} should be an object with named parameters`);
+    return true;
+  }
+  for (const [key, typeSpec] of Object.entries(typeDef)) {
+    const optional = typeof typeSpec === "string" && typeSpec.endsWith("?");
+    const expectedType = optional ? typeSpec.slice(0, -1) : typeSpec;
+    const value = args[key];
+    if (!(key in args) || value === void 0) {
+      if (optional) continue;
+      throw new Error(`Missing required parameter "${key}" in ${operationName}`);
+    }
+    const actualType = Array.isArray(value) ? "Array" : value === null ? "Null" : typeof value === "object" ? "Object" : value.constructor.name;
+    if (actualType !== expectedType && expectedType !== "Any") {
+      throw new Error(
+        `Parameter "${key}" in ${operationName} must be of type ${expectedType}, got ${actualType}`
+      );
+    }
+  }
+  return true;
+}
+
+// ../engine-ai/src/buildAnthropicTools.js
+var RESPOND_TOOL = {
+  name: "respond",
+  description: "Send a conversational response to the user. Use this for greetings, questions, clarifications, status updates, or when the build task is fully complete.",
+  input_schema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "Your conversational response to the user"
+      }
+    },
+    required: ["message"]
+  }
+};
+function buildAnthropicTools(allOperations2) {
+  const namespaces = normalizeNamespaces(allOperations2);
+  return [RESPOND_TOOL, ...namespaces.map(buildNamespaceTool)];
+}
+function buildNamespaceTool(ns) {
+  const opDescriptions = ns.operations.map((op) => {
+    const typeDef = Array.isArray(op.schema) ? op.schema[0] : null;
+    const params = typeDef && typeof typeDef === "object" ? Object.entries(typeDef).map(([k, t]) => `${k}: ${t}`).join(", ") : "";
+    const example = op.examples?.[0] ? `
+    Example: ${JSON.stringify(op.examples[0].args)}` : "";
+    return `  ${op.name} \u2014 ${op.description}
+    Args: { ${params} }${example}`;
+  }).join("\n\n");
+  return {
+    name: ns.namespace,
+    description: `${ns.namespace} operations. Pass "op" as the operation name and "args" matching that op's schema.
+
+${opDescriptions}`,
+    input_schema: {
+      type: "object",
+      properties: {
+        op: {
+          type: "string",
+          description: `Operation name within ${ns.namespace}`
+        },
+        args: {
+          type: "object",
+          description: "Arguments matching the operation's schema"
+        },
+        ref: {
+          type: "string",
+          description: "Optional {{name}} reference for cross-operation use"
+        },
+        message: {
+          type: "string",
+          description: "Short explanation of what you are doing (1 sentence)"
+        }
+      },
+      required: ["op", "args"]
+    }
+  };
+}
+function normalizeNamespaces(allOperations2) {
+  if (!Array.isArray(allOperations2) || allOperations2.length === 0) return [];
+  if (allOperations2[0]?.namespace && Array.isArray(allOperations2[0]?.operations)) {
+    return allOperations2;
+  }
+  return allOperations2.map((def) => extractOperationsMetadata(def));
+}
+
+// ../engine-ai/src/AiOperations.js
+var _operations, _operationDefinitions, _aliases, _names, _AiOperations_instances, setupOperations_fn, resolveReferences_fn;
+var AiOperations = class extends v {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _AiOperations_instances);
+    __privateAdd(this, _operations, /* @__PURE__ */ new Map());
+    // namespace:name → operation
+    __privateAdd(this, _operationDefinitions, []);
+    // Store definitions for metadata
+    __privateAdd(this, _aliases, /* @__PURE__ */ new Map());
+    // explicit alias → namespace:name
+    __privateAdd(this, _names, /* @__PURE__ */ new Map());
+  }
+  // bare name → namespace:name (null when ambiguous)
+  getters() {
+    return {
+      operationsMetadata: () => this.getOperationsMetadata(),
+      anthropicTools: () => this.getAnthropicTools()
+    };
+  }
+  actions() {
+    return {
+      use: (...operationDefinitions) => {
+        for (const operationDef of operationDefinitions) {
+          __privateMethod(this, _AiOperations_instances, setupOperations_fn).call(this, operationDef);
+        }
+        return this;
+      },
+      has: (type) => __privateGet(this, _operations).has(type),
+      resolveType: (type) => this.resolveType(type),
+      describeUnresolved: (type) => this.describeUnresolved(type),
+      executeOperation: (type, args, ref) => this.executeOperation(type, args, ref),
+      executeBatch: (response) => this.executeBatch(response)
+    };
+  }
+  /**
+   * Resolve an operation reference to its full `namespace:name` type.
+   * Accepts full names, explicit aliases, or unambiguous bare names.
+   * Returns null when unknown or ambiguous.
+   */
+  resolveType(type) {
+    if (typeof type !== "string" || !type) return null;
+    if (type.includes(":")) {
+      return __privateGet(this, _operations).has(type) ? type : null;
+    }
+    return __privateGet(this, _aliases).get(type) ?? __privateGet(this, _names).get(type) ?? null;
+  }
+  /**
+   * Human-readable reason a type failed to resolve, or null if it resolves.
+   */
+  describeUnresolved(type) {
+    if (this.resolveType(type)) return null;
+    if (typeof type === "string" && !type.includes(":") && __privateGet(this, _names).has(type) && __privateGet(this, _names).get(type) === null) {
+      const candidates = [];
+      for (const [fullName, operation] of __privateGet(this, _operations)) {
+        if (operation.name === type) {
+          candidates.push(operation.alias ? `${fullName} (alias: ${operation.alias})` : fullName);
+        }
+      }
+      const hint = candidates.length ? candidates.join(" or ") : type;
+      return `Ambiguous operation: "${type}". Use ${hint}.`;
+    }
+    return `Unknown operation: ${type}`;
+  }
+  /**
+   * Get metadata for all registered operations (for AI prompt / MCP tools)
+   */
+  getOperationsMetadata() {
+    return __privateGet(this, _operationDefinitions).map((def) => extractOperationsMetadata(def));
+  }
+  /**
+   * Anthropic tool schemas derived from registered operations (one tool per namespace + respond).
+   */
+  getAnthropicTools() {
+    return buildAnthropicTools(__privateGet(this, _operationDefinitions));
+  }
+  /**
+   * Execute a single AI operation
+   */
+  async executeOperation(operationType, args, ref = null) {
+    const resolved = this.resolveType(operationType);
+    const operation = __privateGet(this, _operations).get(resolved);
+    if (!operation) {
+      throw new Error(this.describeUnresolved(operationType));
+    }
+    try {
+      validateOperationArgs(args, operation.schema, operationType);
+    } catch (error) {
+      console.error(`Validation failed for ${operationType}:`, error);
+      throw error;
+    }
+    try {
+      const result = await operation.handler(args);
+      return { result, ref };
+    } catch (error) {
+      console.error(`Handler failed for ${operationType}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Execute a batch of AI operations
+   */
+  async executeBatch(response) {
+    const { operations, description, expectation } = response;
+    console.log("AiOperations: Executing batch", {
+      count: operations.length,
+      description
+    });
+    const refMap = /* @__PURE__ */ new Map();
+    const results = [];
+    const createdIds = [];
+    try {
+      for (let i2 = 0; i2 < operations.length; i2++) {
+        const op = operations[i2];
+        console.log(`AiOperations: Executing [${i2 + 1}/${operations.length}] ${op.type}`);
+        const resolvedArgs = __privateMethod(this, _AiOperations_instances, resolveReferences_fn).call(this, op.args, refMap);
+        const { result } = await this.executeOperation(op.type, resolvedArgs, op.ref);
+        const refId = result.id ?? result.rootId;
+        if (op.ref && refId) {
+          refMap.set(op.ref, refId);
+          createdIds.push(refId);
+        }
+        if (result.treeMap) {
+          for (const [ref, id] of Object.entries(result.treeMap)) {
+            refMap.set(ref, id);
+            createdIds.push(id);
+          }
+        }
+        if (result.createdIds?.length) {
+          createdIds.push(...result.createdIds);
+        }
+        results.push({
+          operation: op.type,
+          success: true,
+          result
+        });
+      }
+      console.log("AiOperations: Execution complete", {
+        total: operations.length,
+        successful: results.length,
+        createdIds
+      });
+      return {
+        success: true,
+        description,
+        expectation,
+        results,
+        createdIds,
+        refMap: Object.fromEntries(refMap)
+      };
+    } catch (error) {
+      console.error("AiOperations: Batch execution failed", error);
+      return {
+        success: false,
+        description,
+        error: error.message,
+        failedAt: results.length,
+        results
+      };
+    }
+  }
+};
+_operations = new WeakMap();
+_operationDefinitions = new WeakMap();
+_aliases = new WeakMap();
+_names = new WeakMap();
+_AiOperations_instances = new WeakSet();
+/**
+ * Setup operations from a definition (similar to MessageChannel's #setupSubscriptions)
+ */
+setupOperations_fn = function(operationFactory) {
+  const log = this.inject("log");
+  if (!operationFactory || typeof operationFactory !== "function") {
+    throw new Error("Operation factory must be a function");
+  }
+  const namespace = operationFactory._name;
+  if (!namespace) {
+    throw new Error("Operation factory must have a _name property (use defineAiOperations)");
+  }
+  log.info(`AiOperations: Registering operations for namespace "${namespace}"`);
+  __privateGet(this, _operationDefinitions).push(operationFactory);
+  const operations = operationFactory(this.inject);
+  for (const [name, operation] of Object.entries(operations)) {
+    const { handler, schema, description, examples, returns, alias } = operation;
+    const fullName = `${namespace}:${name}`;
+    if (!handler || typeof handler !== "function") {
+      throw new Error(`Operation ${fullName} must have a handler function`);
+    }
+    if (!description) {
+      console.warn(`Operation ${fullName} missing description`);
+    }
+    __privateGet(this, _operations).set(fullName, {
+      namespace,
+      name,
+      handler,
+      schema: schema || [],
+      description: description || "",
+      examples: examples || [],
+      returns: returns || "Object",
+      alias: alias || null
+    });
+    if (alias) {
+      if (__privateGet(this, _aliases).has(alias) && __privateGet(this, _aliases).get(alias) !== fullName) {
+        console.warn(`AiOperations: alias "${alias}" already registered for ${__privateGet(this, _aliases).get(alias)}, overriding with ${fullName}`);
+      }
+      __privateGet(this, _aliases).set(alias, fullName);
+    }
+    if (__privateGet(this, _names).has(name) && __privateGet(this, _names).get(name) !== fullName) {
+      __privateGet(this, _names).set(name, null);
+    } else {
+      __privateGet(this, _names).set(name, fullName);
+    }
+  }
+};
+resolveReferences_fn = function(args, refMap) {
+  if (!args) return args;
+  return JSON.parse(JSON.stringify(args), (key, value) => {
+    if (key === "ref") return value;
+    if (typeof value === "string" && value.match(/^\{\{.*\}\}$/)) {
+      const resolved = refMap.get(value) ?? refMap.get(value.replace(/\.[^}]+(?=\}\}$)/, ""));
+      return resolved ?? value;
+    }
+    return value;
+  });
+};
+__publicField(AiOperations, "manifest", {
+  name: "AiOperations",
+  namespace: "aiOps",
+  version: "1.0.0",
+  description: "AI operation registry and executor",
+  author: "",
+  license: "MIT",
+  homepage: ""
+});
+
+// ../engine-lifecycle/src/PageLifecycle.js
+var _subscribers, _visible, _focused, _frozen, _lastActiveTimestamp, _sleepCheckInterval, _config, _PageLifecycle_instances, on_fn, off_fn, emit_fn, setupSources_fn, _handleVisibility, _handleFocus, _handleBlur, _handleFreeze, _handleDocResume, _handlePageShow, _handlePageHide, startSleepDetection_fn, teardown_fn;
+var PageLifecycle = class extends v {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _PageLifecycle_instances);
+    __privateAdd(this, _subscribers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _visible, true);
+    __privateAdd(this, _focused, true);
+    __privateAdd(this, _frozen, false);
+    __privateAdd(this, _lastActiveTimestamp, Date.now());
+    __privateAdd(this, _sleepCheckInterval, null);
+    __privateAdd(this, _config, null);
+    __privateAdd(this, _handleVisibility, () => {
+      const wasVisible = __privateGet(this, _visible);
+      __privateSet(this, _visible, !document.hidden);
+      if (__privateGet(this, _visible) && !wasVisible) {
+        __privateSet(this, _lastActiveTimestamp, Date.now());
+        __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "visible");
+      } else if (!__privateGet(this, _visible) && wasVisible) {
+        __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "hidden");
+      }
+    });
+    __privateAdd(this, _handleFocus, () => {
+      __privateSet(this, _focused, true);
+      __privateSet(this, _lastActiveTimestamp, Date.now());
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "focus");
+    });
+    __privateAdd(this, _handleBlur, () => {
+      __privateSet(this, _focused, false);
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "blur");
+    });
+    __privateAdd(this, _handleFreeze, () => {
+      __privateSet(this, _frozen, true);
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "suspend", { reason: "freeze" });
+    });
+    __privateAdd(this, _handleDocResume, () => {
+      __privateSet(this, _frozen, false);
+      __privateSet(this, _lastActiveTimestamp, Date.now());
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "resume", { reason: "freeze" });
+    });
+    __privateAdd(this, _handlePageShow, (event) => {
+      if (event.persisted) {
+        __privateSet(this, _lastActiveTimestamp, Date.now());
+        __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "resume", { reason: "bfcache" });
+      }
+    });
+    __privateAdd(this, _handlePageHide, (event) => {
+      if (event.persisted) {
+        __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "suspend", { reason: "bfcache" });
+      }
+    });
+  }
+  initialize() {
+    if (typeof document !== "undefined") {
+      __privateSet(this, _visible, !document.hidden);
+      __privateSet(this, _focused, document.hasFocus());
+    }
+    __privateSet(this, _lastActiveTimestamp, Date.now());
+  }
+  getters() {
+    return {
+      visible: () => __privateGet(this, _visible),
+      focused: () => __privateGet(this, _focused),
+      frozen: () => __privateGet(this, _frozen)
+    };
+  }
+  actions(_, config) {
+    __privateSet(this, _config, config || {});
+    __privateMethod(this, _PageLifecycle_instances, setupSources_fn).call(this, __privateGet(this, _config));
+    return {
+      on: (event, callback) => __privateMethod(this, _PageLifecycle_instances, on_fn).call(this, event, callback),
+      off: (event, callback) => __privateMethod(this, _PageLifecycle_instances, off_fn).call(this, event, callback),
+      isVisible: () => __privateGet(this, _visible),
+      isFocused: () => __privateGet(this, _focused),
+      isFrozen: () => __privateGet(this, _frozen),
+      lastActiveTimestamp: () => __privateGet(this, _lastActiveTimestamp),
+      destroy: () => __privateMethod(this, _PageLifecycle_instances, teardown_fn).call(this)
+    };
+  }
+  destroy() {
+    __privateMethod(this, _PageLifecycle_instances, teardown_fn).call(this);
+  }
+};
+_subscribers = new WeakMap();
+_visible = new WeakMap();
+_focused = new WeakMap();
+_frozen = new WeakMap();
+_lastActiveTimestamp = new WeakMap();
+_sleepCheckInterval = new WeakMap();
+_config = new WeakMap();
+_PageLifecycle_instances = new WeakSet();
+on_fn = function(event, callback) {
+  if (!__privateGet(this, _subscribers).has(event)) {
+    __privateGet(this, _subscribers).set(event, /* @__PURE__ */ new Set());
+  }
+  __privateGet(this, _subscribers).get(event).add(callback);
+  return () => __privateMethod(this, _PageLifecycle_instances, off_fn).call(this, event, callback);
+};
+off_fn = function(event, callback) {
+  const callbacks = __privateGet(this, _subscribers).get(event);
+  if (callbacks) {
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      __privateGet(this, _subscribers).delete(event);
+    }
+  }
+};
+emit_fn = function(event, data) {
+  const callbacks = __privateGet(this, _subscribers).get(event);
+  if (callbacks) {
+    for (const callback of callbacks) {
+      callback(data);
+    }
+  }
+};
+setupSources_fn = function(config) {
+  if (typeof document !== "undefined") {
+    if (config.visibility !== false) {
+      document.addEventListener("visibilitychange", __privateGet(this, _handleVisibility));
+    }
+    if (config.freeze !== false) {
+      document.addEventListener("freeze", __privateGet(this, _handleFreeze));
+      document.addEventListener("resume", __privateGet(this, _handleDocResume));
+    }
+  }
+  if (typeof window !== "undefined") {
+    if (config.focus) {
+      window.addEventListener("focus", __privateGet(this, _handleFocus));
+      window.addEventListener("blur", __privateGet(this, _handleBlur));
+    }
+    if (config.freeze !== false) {
+      window.addEventListener("pageshow", __privateGet(this, _handlePageShow));
+      window.addEventListener("pagehide", __privateGet(this, _handlePageHide));
+    }
+  }
+  if (config.sleepDetection?.enabled !== false) {
+    const threshold = config.sleepDetection?.threshold || 1e4;
+    __privateMethod(this, _PageLifecycle_instances, startSleepDetection_fn).call(this, threshold);
+  }
+};
+_handleVisibility = new WeakMap();
+_handleFocus = new WeakMap();
+_handleBlur = new WeakMap();
+_handleFreeze = new WeakMap();
+_handleDocResume = new WeakMap();
+_handlePageShow = new WeakMap();
+_handlePageHide = new WeakMap();
+startSleepDetection_fn = function(threshold) {
+  const interval = Math.min(threshold / 2, 5e3);
+  __privateSet(this, _sleepCheckInterval, setInterval(() => {
+    const now = Date.now();
+    const gap = now - __privateGet(this, _lastActiveTimestamp);
+    if (gap > threshold) {
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "suspend", { reason: "sleep", gap });
+      __privateMethod(this, _PageLifecycle_instances, emit_fn).call(this, "resume", { reason: "sleep", gap });
+    }
+    __privateSet(this, _lastActiveTimestamp, now);
+  }, interval));
+};
+teardown_fn = function() {
+  if (typeof document !== "undefined") {
+    document.removeEventListener("visibilitychange", __privateGet(this, _handleVisibility));
+    document.removeEventListener("freeze", __privateGet(this, _handleFreeze));
+    document.removeEventListener("resume", __privateGet(this, _handleDocResume));
+  }
+  if (typeof window !== "undefined") {
+    window.removeEventListener("focus", __privateGet(this, _handleFocus));
+    window.removeEventListener("blur", __privateGet(this, _handleBlur));
+    window.removeEventListener("pageshow", __privateGet(this, _handlePageShow));
+    window.removeEventListener("pagehide", __privateGet(this, _handlePageHide));
+  }
+  if (__privateGet(this, _sleepCheckInterval)) {
+    clearInterval(__privateGet(this, _sleepCheckInterval));
+    __privateSet(this, _sleepCheckInterval, null);
+  }
+  __privateGet(this, _subscribers).clear();
+};
+__publicField(PageLifecycle, "manifest", {
+  name: "PageLifecycle",
+  namespace: "pageLifecycle",
+  version: "1.0.0",
+  description: "Browser lifecycle detection for tab visibility, focus, and sleep/wake"
+});
+
+// ../engine-content-editor/src/utils/getCaretCharacterOffset.js
+function getCaretCharacterOffset(element) {
+  const sel = window.getSelection();
+  if (sel.rangeCount === 0) {
+    return { start: 0, end: 0 };
+  }
+  const range = sel.getRangeAt(0);
+  const preStartRange = range.cloneRange();
+  preStartRange.selectNodeContents(element);
+  preStartRange.setEnd(range.startContainer, range.startOffset);
+  const start = preStartRange.toString().length;
+  const preEndRange = range.cloneRange();
+  preEndRange.selectNodeContents(element);
+  preEndRange.setEnd(range.endContainer, range.endOffset);
+  const end = preEndRange.toString().length;
+  return {
+    start: Math.min(start, end),
+    end: Math.max(start, end)
+  };
+}
+
+// ../engine-content-editor/src/utils/setCaretToCharacterPosition.js
+function setCaretToCharacterPosition(element, position) {
+  if (!element?.isConnected || position < 0) return;
+  const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+  let charCount = 0;
+  let lastNode = null;
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    lastNode = node;
+    if (position <= charCount + node.length) {
+      const range = document.createRange();
+      range.setStart(node, position - charCount);
+      range.collapse(true);
+      const sel = window.getSelection();
+      sel.removeAllRanges();
+      sel.addRange(range);
+      return;
+    }
+    charCount += node.length;
+  }
+  if (lastNode) {
+    const range = document.createRange();
+    range.setStart(lastNode, lastNode.length);
+    range.collapse(true);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+}
+
+// ../engine-content-editor/src/utils/spliceString.js
+function spliceString(str, offset, deleteCount = 0, newStr = "") {
+  return str.slice(0, offset) + newStr + str.slice(offset + deleteCount);
+}
+
+// ../engine-content-editor/src/utils/getWordBoundsAtPosition.js
+function getWordBoundsAtPosition(str, position) {
+  const isSpace = (c) => /[\s\n]/.exec(c);
+  let start = position - 1;
+  let end = position;
+  while (start >= 0 && !isSpace(str[start])) {
+    start -= 1;
+  }
+  start = Math.max(0, start + 1);
+  while (end < str.length && !isSpace(str[end])) {
+    end += 1;
+  }
+  end = Math.max(start, end);
+  return [start, end];
+}
+
+// ../engine-content-editor/src/utils/getTriggerMatchesAtCursor.js
+function buildMatch({ pattern, word, match, regexMatch, triggerLen, start, end, cursorPos }) {
+  const queryEnd = cursorPos - start;
+  return {
+    pattern,
+    word,
+    match,
+    regexMatch,
+    start,
+    end,
+    query: word.slice(triggerLen, queryEnd)
+  };
+}
+function getTriggerMatchesAtCursor(text, cursorPos, patterns = []) {
+  if (!text || cursorPos === 0 || patterns.length === 0) return [];
+  const [start, end] = getWordBoundsAtPosition(text, cursorPos);
+  const word = text.slice(start, end);
+  if (!word) return [];
+  const matches = [];
+  for (const pattern of patterns) {
+    if (pattern.regex) {
+      const m = word.match(pattern.trigger);
+      if (m) {
+        matches.push(buildMatch({
+          pattern,
+          word,
+          match: m[0],
+          regexMatch: m,
+          triggerLen: 1,
+          start,
+          end,
+          cursorPos
+        }));
+      }
+      continue;
+    }
+    const trig = pattern.trigger;
+    const triggerLen = trig.length;
+    if (pattern.exact && word === trig) {
+      matches.push(buildMatch({ pattern, word, match: trig, regexMatch: null, triggerLen, start, end, cursorPos }));
+    } else if (pattern.startsWith && word.startsWith(trig)) {
+      matches.push(buildMatch({ pattern, word, match: trig, regexMatch: null, triggerLen, start, end, cursorPos }));
+    } else if (pattern.endsWith && word.endsWith(trig)) {
+      matches.push(buildMatch({ pattern, word, match: trig, regexMatch: null, triggerLen, start, end, cursorPos }));
+    }
+  }
+  return matches;
+}
+
+// ../engine-content-editor/src/Target.js
+var PREVENT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "insertText",
+  "insertParagraph",
+  "insertLineBreak",
+  "deleteContentBackward",
+  "deleteContentForward"
+]);
+var OBSERVER_OPTIONS = { childList: true, characterData: true, subtree: true };
+var _patterns, _inheritedPatterns, _ownListeners, _host, _content, _start, _end, _nextOffset, _initial, _destroyed, _observer, _composing, _onWheelBound, _Target_instances, init_fn, updateCaret_fn, _handlePaste, _handleBeforeInput, _handleBlur2, _handleWheel, _handleKeyDown, _handleMutation, _handleCompositionStart, _handleCompositionEnd, applyEdit_fn;
+var _Target = class _Target {
+  constructor($el, { onInput, onBlur, onWheel } = {}, host = {}) {
+    __privateAdd(this, _Target_instances);
+    __privateAdd(this, _patterns, []);
+    __privateAdd(this, _inheritedPatterns, []);
+    __privateAdd(this, _ownListeners, []);
+    __privateAdd(this, _host, {});
+    __privateAdd(this, _content, "");
+    __privateAdd(this, _start, 0);
+    __privateAdd(this, _end, 0);
+    __privateAdd(this, _nextOffset, 0);
+    __privateAdd(this, _initial, { content: "", start: 0, end: 0 });
+    __privateAdd(this, _destroyed, false);
+    __privateAdd(this, _observer, null);
+    __privateAdd(this, _composing, false);
+    __privateAdd(this, _onWheelBound, null);
+    __privateAdd(this, _handlePaste, (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+      const data = e.clipboardData;
+      if (!data) return;
+      const pasted = data.getData("text/plain") || data.getData("text/html");
+      if (!pasted) return;
+      let plainText = pasted;
+      if (pasted !== data.getData("text/plain")) {
+        const tmp = document.createElement("div");
+        tmp.innerHTML = pasted;
+        plainText = tmp.textContent || "";
+      }
+      __privateMethod(this, _Target_instances, updateCaret_fn).call(this);
+      __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), plainText);
+    });
+    __privateAdd(this, _handleBeforeInput, (e) => {
+      console.log("beforeinput", e);
+      e.stopPropagation();
+      if (PREVENT_INPUT_TYPES.has(e.inputType)) e.preventDefault();
+      __privateMethod(this, _Target_instances, updateCaret_fn).call(this);
+      switch (e.inputType) {
+        case "insertText":
+          __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), e.data ?? "");
+          break;
+        case "insertParagraph":
+        case "insertLineBreak":
+          __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), "\n");
+          break;
+        case "deleteContentBackward":
+          if (__privateGet(this, _start) !== __privateGet(this, _end)) {
+            __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), "");
+          } else {
+            __privateMethod(this, _Target_instances, applyEdit_fn).call(this, Math.max(0, __privateGet(this, _start) - 1), Math.min(1, __privateGet(this, _start)), "");
+          }
+          break;
+        case "deleteContentForward":
+          if (__privateGet(this, _start) !== __privateGet(this, _end)) {
+            __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), "");
+          } else {
+            __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), 1, "");
+          }
+          break;
+      }
+    });
+    __privateAdd(this, _handleBlur2, () => {
+      this.onBlur?.(__privateGet(this, _content));
+    });
+    __privateAdd(this, _handleWheel, (e) => {
+      e.preventDefault();
+      this.onWheel({ deltaX: e.deltaX, deltaY: e.deltaY, ctrlKey: e.ctrlKey, x: e.clientX, y: e.clientY });
+    });
+    // Buttons suppress beforeinput for spacebar (the browser treats space as button
+    // activation and never fires insertText). Intercept at keydown and insert manually.
+    __privateAdd(this, _handleKeyDown, (e) => {
+      if (e.key !== " ") return;
+      e.preventDefault();
+      __privateMethod(this, _Target_instances, updateCaret_fn).call(this);
+      __privateMethod(this, _Target_instances, applyEdit_fn).call(this, __privateGet(this, _start), __privateGet(this, _end) - __privateGet(this, _start), " ");
+    });
+    __privateAdd(this, _handleMutation, () => {
+      if (__privateGet(this, _destroyed) || __privateGet(this, _composing)) return;
+      setCaretToCharacterPosition(this.$el, __privateGet(this, _nextOffset));
+    });
+    __privateAdd(this, _handleCompositionStart, () => {
+      __privateSet(this, _composing, true);
+    });
+    __privateAdd(this, _handleCompositionEnd, () => {
+      __privateSet(this, _composing, false);
+      __privateSet(this, _content, this.$el.textContent || "");
+      this.onInput?.(__privateGet(this, _content));
+    });
+    this.$el = $el;
+    this.onInput = onInput;
+    this.onBlur = onBlur;
+    this.onWheel = onWheel;
+    __privateSet(this, _inheritedPatterns, host.inheritedPatterns ?? []);
+    __privateSet(this, _host, host);
+    __privateMethod(this, _Target_instances, init_fn).call(this);
+  }
+  static create($el, opts = {}, host = {}) {
+    if (this.instances.has($el)) {
+      return this.instances.get($el);
+    }
+    const target = new _Target($el, opts, host);
+    _Target.instances.set($el, target);
+    return target;
+  }
+  get content() {
+    return __privateGet(this, _content);
+  }
+  get cursor() {
+    return { start: __privateGet(this, _start), end: __privateGet(this, _end) };
+  }
+  /**
+   * Register a passthrough DOM listener on the underlying contenteditable
+   * element. Returns an unsubscribe function. Use this to expose raw browser
+   * events (keydown for Enter-to-submit, focus, mouseup, etc.). Listeners can
+   * call `e.preventDefault()` to suppress the default action and the
+   * corresponding `beforeinput` Target would otherwise process.
+   *
+   * @param {string} eventName
+   * @param {(event: Event) => void} callback
+   * @param {boolean | AddEventListenerOptions} [options]
+   * @returns {() => void} unsubscribe
+   */
+  on(eventName, callback, options = false) {
+    this.$el.addEventListener(eventName, callback, options);
+    const entry = { eventName, callback, options };
+    __privateGet(this, _ownListeners).push(entry);
+    return () => {
+      this.$el.removeEventListener(eventName, callback, options);
+      const i2 = __privateGet(this, _ownListeners).indexOf(entry);
+      if (i2 !== -1) __privateGet(this, _ownListeners).splice(i2, 1);
+    };
+  }
+  onMatch(trigger, callback, { exact = true, startsWith = false, endsWith = false } = {}) {
+    const isRegex = trigger instanceof RegExp;
+    const pattern = {
+      trigger: isRegex ? trigger : trigger?.trim?.(),
+      regex: isRegex,
+      exact,
+      startsWith,
+      endsWith,
+      callback
+    };
+    __privateGet(this, _patterns).push(pattern);
+    return () => {
+      const i2 = __privateGet(this, _patterns).indexOf(pattern);
+      if (i2 !== -1) __privateGet(this, _patterns).splice(i2, 1);
+    };
+  }
+  reset() {
+    __privateSet(this, _content, __privateGet(this, _initial).content);
+    __privateSet(this, _nextOffset, __privateGet(this, _initial).start);
+    this.onInput?.(__privateGet(this, _content));
+  }
+  destroy() {
+    if (__privateGet(this, _destroyed)) return;
+    __privateSet(this, _destroyed, true);
+    __privateGet(this, _observer)?.disconnect();
+    this.$el.removeEventListener("paste", __privateGet(this, _handlePaste));
+    this.$el.removeEventListener("beforeinput", __privateGet(this, _handleBeforeInput));
+    this.$el.removeEventListener("blur", __privateGet(this, _handleBlur2));
+    this.$el.removeEventListener("compositionstart", __privateGet(this, _handleCompositionStart));
+    this.$el.removeEventListener("compositionend", __privateGet(this, _handleCompositionEnd));
+    this.$el.removeEventListener("keydown", __privateGet(this, _handleKeyDown));
+    if (__privateGet(this, _onWheelBound)) {
+      document.removeEventListener("wheel", __privateGet(this, _onWheelBound), { passive: false, capture: true });
+      __privateSet(this, _onWheelBound, null);
+    }
+    for (const { eventName, callback, options } of __privateGet(this, _ownListeners)) {
+      this.$el.removeEventListener(eventName, callback, options);
+    }
+    __privateSet(this, _ownListeners, []);
+    __privateSet(this, _patterns, []);
+    _Target.instances.delete(this.$el);
+    __privateGet(this, _host).onDestroy?.(this);
+  }
+};
+_patterns = new WeakMap();
+_inheritedPatterns = new WeakMap();
+_ownListeners = new WeakMap();
+_host = new WeakMap();
+_content = new WeakMap();
+_start = new WeakMap();
+_end = new WeakMap();
+_nextOffset = new WeakMap();
+_initial = new WeakMap();
+_destroyed = new WeakMap();
+_observer = new WeakMap();
+_composing = new WeakMap();
+_onWheelBound = new WeakMap();
+_Target_instances = new WeakSet();
+init_fn = function() {
+  __privateSet(this, _content, this.$el.textContent || "");
+  const { start, end } = getCaretCharacterOffset(this.$el);
+  __privateSet(this, _start, start);
+  __privateSet(this, _end, end);
+  __privateSet(this, _nextOffset, start);
+  __privateSet(this, _initial, { content: __privateGet(this, _content), start, end });
+  this.$el.addEventListener("paste", __privateGet(this, _handlePaste));
+  this.$el.addEventListener("beforeinput", __privateGet(this, _handleBeforeInput));
+  this.$el.addEventListener("blur", __privateGet(this, _handleBlur2));
+  this.$el.addEventListener("compositionstart", __privateGet(this, _handleCompositionStart));
+  this.$el.addEventListener("compositionend", __privateGet(this, _handleCompositionEnd));
+  if (this.$el.tagName === "BUTTON") {
+    this.$el.addEventListener("keydown", __privateGet(this, _handleKeyDown));
+  }
+  __privateSet(this, _observer, new MutationObserver(__privateGet(this, _handleMutation)));
+  __privateGet(this, _observer).observe(this.$el, OBSERVER_OPTIONS);
+  if (this.onWheel) {
+    __privateSet(this, _onWheelBound, __privateGet(this, _handleWheel));
+    document.addEventListener("wheel", __privateGet(this, _onWheelBound), { passive: false, capture: true });
+  }
+};
+updateCaret_fn = function() {
+  const { start, end } = getCaretCharacterOffset(this.$el);
+  __privateSet(this, _start, start);
+  __privateSet(this, _end, end);
+};
+_handlePaste = new WeakMap();
+_handleBeforeInput = new WeakMap();
+_handleBlur2 = new WeakMap();
+_handleWheel = new WeakMap();
+_handleKeyDown = new WeakMap();
+_handleMutation = new WeakMap();
+_handleCompositionStart = new WeakMap();
+_handleCompositionEnd = new WeakMap();
+applyEdit_fn = function(offset, deleteCount, insert) {
+  __privateSet(this, _content, spliceString(__privateGet(this, _content), offset, deleteCount, insert));
+  __privateSet(this, _nextOffset, offset + insert.length);
+  const allPatterns = __privateGet(this, _inheritedPatterns).length ? [...__privateGet(this, _patterns), ...__privateGet(this, _inheritedPatterns)] : __privateGet(this, _patterns);
+  const matches = getTriggerMatchesAtCursor(__privateGet(this, _content), __privateGet(this, _nextOffset), allPatterns);
+  for (const m of matches) {
+    m.pattern.callback({
+      word: m.word,
+      trigger: m.match,
+      start: m.start,
+      end: m.end,
+      query: m.query,
+      match: m.regexMatch
+    });
+  }
+  this.onInput?.(__privateGet(this, _content));
+};
+__publicField(_Target, "instances", /* @__PURE__ */ new WeakMap());
+var Target = _Target;
+
+// ../engine-content-editor/src/ContentEditor.js
+var _patterns2, _listeners, _targets;
+var ContentEditor = class extends v {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _patterns2, []);
+    __privateAdd(this, _listeners, []);
+    __privateAdd(this, _targets, /* @__PURE__ */ new Set());
+  }
+  actions() {
+    return {
+      create: ($el, opts = {}) => {
+        try {
+          if (!($el instanceof HTMLElement)) {
+            throw new Error("ContentEditor.create: $el must be an HTMLElement");
+          }
+          if (!$el.isContentEditable) {
+            $el.contentEditable = "true";
+          }
+          const target = Target.create($el, opts, {
+            inheritedPatterns: __privateGet(this, _patterns2),
+            onDestroy: (t) => {
+              for (const { eventName, callback, options } of __privateGet(this, _listeners)) {
+                t.$el.removeEventListener(eventName, callback, options);
+              }
+              __privateGet(this, _targets).delete(t);
+              Target.instances.delete($el);
+            }
+          });
+          for (const { eventName, callback, options } of __privateGet(this, _listeners)) {
+            $el.addEventListener(eventName, callback, options);
+          }
+          __privateGet(this, _targets).add(target);
+          return target;
+        } catch (error) {
+          console.error(error);
+          return null;
+        }
+      },
+      getTarget: ($el) => Target.instances.get($el),
+      onMatch: (trigger, callback, opts = {}) => {
+        const isRegex = trigger instanceof RegExp;
+        const pattern = {
+          trigger: isRegex ? trigger : trigger?.trim?.(),
+          regex: isRegex,
+          exact: opts.exact ?? true,
+          startsWith: opts.startsWith ?? false,
+          endsWith: opts.endsWith ?? false,
+          callback
+        };
+        __privateGet(this, _patterns2).push(pattern);
+        return () => {
+          const i2 = __privateGet(this, _patterns2).indexOf(pattern);
+          if (i2 !== -1) __privateGet(this, _patterns2).splice(i2, 1);
+        };
+      },
+      /**
+       * Register a passthrough DOM listener applied to every Target's element
+       * (existing and future). Mirrors `target.on()` but at the service level
+       * so Enter-to-submit-style behaviors only have to be wired once.
+       *
+       * @param {string} eventName
+       * @param {(event: Event) => void} callback
+       * @param {boolean | AddEventListenerOptions} [options]
+       * @returns {() => void} unsubscribe
+       */
+      on: (eventName, callback, options = false) => {
+        const entry = { eventName, callback, options };
+        __privateGet(this, _listeners).push(entry);
+        for (const t of __privateGet(this, _targets)) {
+          t.$el.addEventListener(eventName, callback, options);
+        }
+        return () => {
+          const i2 = __privateGet(this, _listeners).indexOf(entry);
+          if (i2 !== -1) __privateGet(this, _listeners).splice(i2, 1);
+          for (const t of __privateGet(this, _targets)) {
+            t.$el.removeEventListener(eventName, callback, options);
+          }
+        };
+      },
+      reset: ($el) => Target.instances.get($el)?.reset(),
+      destroy: ($el) => Target.instances.get($el)?.destroy()
+    };
+  }
+};
+_patterns2 = new WeakMap();
+_listeners = new WeakMap();
+_targets = new WeakMap();
+__publicField(ContentEditor, "manifest", {
+  name: "Content Editor",
+  namespace: "contentEditor",
+  version: "1.0.0",
+  description: "Content editor extension"
+});
+
+// ../../node_modules/@jucie.io/state/dist/lib/change.js
+var OPERATION_INVERSES = {
+  [CREATED]: DELETED,
+  [DELETED]: CREATED,
+  [UPDATED]: UPDATED
+};
+var ARRAY_METHODS = /* @__PURE__ */ new Set(["push", "unshift", "splice", "removeMatch"]);
+function invertChange(change) {
+  const { address, path, method, from, to, operation } = change;
+  if (ARRAY_METHODS.has(method)) {
+    return invertArrayChange(change);
+  }
+  return {
+    address,
+    path,
+    method,
+    to: from,
+    from: to,
+    operation: invertOperation(operation)
+  };
+}
+function invertArrayChange(change) {
+  const { address, path, method, from, to } = change;
+  if (method === "push" || method === "unshift") {
+    return { address, path, method: "removeMatch", operation: UPDATED, to };
+  }
+  const [start, , ...inserted] = to;
+  const removed = from || [];
+  return {
+    address,
+    path,
+    method: "splice",
+    operation: UPDATED,
+    to: [start, inserted.length, ...removed],
+    from: inserted
+  };
+}
+function invertOperation(operation) {
+  return OPERATION_INVERSES[operation];
+}
+
+// ../../node_modules/@jucie.io/state/dist/utils/defer.js
+function defer(arg1, arg2) {
+  let callback = null;
+  let delay = 0;
+  if (typeof arg1 === "function") {
+    callback = arg1;
+    if (typeof arg2 === "number") {
+      delay = arg2;
+    }
+  } else if (typeof arg1 === "number") {
+    delay = arg1;
+  }
+  return (...args) => new Promise((resolve, reject) => {
+    setTimeout(() => {
+      try {
+        const result = callback ? callback(...args) : void 0;
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    }, delay);
+  });
+}
+
+// ../../node_modules/@jucie.io/state-history/dist/main.js
+var f3 = Object.defineProperty;
+var i = (n, t) => f3(n, "name", { value: t, configurable: true });
+var _a;
+var o = (_a = class {
+  constructor(t = "") {
+    this.isMarker = true, this.description = t;
+  }
+}, i(_a, "Marker"), _a);
+var _a2, _t, _a3, _n, _e, _o, _s, _i, _r, _a_instances, d_fn, _f, u_fn, h_fn;
+var a = (_a2 = class extends Plugin {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _a_instances);
+    __privateAdd(this, _t, []);
+    __privateAdd(this, _a3, false);
+    __privateAdd(this, _n, /* @__PURE__ */ new Set());
+    __privateAdd(this, _e, 0);
+    __privateAdd(this, _o, false);
+    __privateAdd(this, _s, /* @__PURE__ */ new Map());
+    __privateAdd(this, _i, true);
+    __privateAdd(this, _r, false);
+    __publicField(this, "onUndoRedo", null);
+    __privateAdd(this, _f, defer(() => {
+      __privateMethod(this, _a_instances, h_fn).call(this), __privateSet(this, _r, false);
+    }));
+    __publicField(this, "undo", defer((t) => {
+      if (!this.onUndoRedo) throw new Error("Undo/redo handler is required for undo operation");
+      if (__privateMethod(this, _a_instances, h_fn).call(this), __privateGet(this, _e) <= 0) return false;
+      if (__privateSet(this, _i, false), !(__privateGet(this, _t)[__privateGet(this, _e)] instanceof o)) return console.warn("Expected to be at a marker for undo operation"), false;
+      let e = /* @__PURE__ */ new Set(), s3 = __privateGet(this, _e) - 1;
+      for (; s3 > 0; ) {
+        let r2 = __privateGet(this, _t)[s3];
+        if (r2 instanceof o) break;
+        e.add(invertChange(r2)), s3--;
+      }
+      return __privateSet(this, _e, s3), this.onUndoRedo(Array.from(e)), t && typeof t == "function" && t(), __privateSet(this, _i, true), true;
+    }));
+    __publicField(this, "redo", defer((t) => {
+      if (!this.onUndoRedo) throw new Error("Undo/redo handler is required for redo operation");
+      if (__privateGet(this, _e) >= __privateGet(this, _t).length - 1) return false;
+      if (__privateSet(this, _i, false), !(__privateGet(this, _t)[__privateGet(this, _e)] instanceof o)) return console.warn("Expected to be at a marker for redo operation"), false;
+      let e = /* @__PURE__ */ new Set();
+      for (__privateWrapper(this, _e)._++; __privateGet(this, _e) < __privateGet(this, _t).length; ) {
+        let s3 = __privateGet(this, _t)[__privateGet(this, _e)];
+        if (s3 instanceof o) break;
+        e.add(s3), __privateWrapper(this, _e)._++;
+      }
+      return this.onUndoRedo(e), t && typeof t == "function" && t(), __privateSet(this, _i, true), true;
+    }));
+  }
+  initialize(t) {
+    this.onUndoRedo = (e) => t.apply(e);
+  }
+  actions(t) {
+    return { undo: i((e) => this.undo(e), "undo"), redo: i((e) => this.redo(e), "redo"), canUndo: i(() => this.canUndo(), "canUndo"), canRedo: i(() => this.canRedo(), "canRedo"), group: i((e) => this.group(e), "group"), commit: i((e) => this.commit(e), "commit"), onCommit: i((e) => this.onCommit(e), "onCommit"), addMarker: i((e) => this.addMarker(e), "addMarker"), size: i(() => this.size(), "size"), start: i(() => __privateMethod(this, _a_instances, d_fn).call(this), "start") };
+  }
+  onStateChange(t, e, s3) {
+    if (!__privateGet(this, _a3) || !__privateGet(this, _i) || e.method === "apply") return;
+    let r2 = __privateGet(this, _s).get(t.address), d = r2 ? { ...e, from: r2.from } : e;
+    __privateGet(this, _s).set(t.address, d), !s3 && !__privateGet(this, _o) && __privateMethod(this, _a_instances, u_fn).call(this);
+  }
+  addMarker(t = "") {
+    __privateMethod(this, _a_instances, h_fn).call(this, t), __privateSet(this, _e, __privateGet(this, _t).length - 1);
+  }
+  canUndo() {
+    return __privateGet(this, _e) > 0;
+  }
+  canRedo() {
+    return __privateGet(this, _e) < __privateGet(this, _t).length - 1;
+  }
+  size() {
+    return __privateGet(this, _t).length;
+  }
+  group(t) {
+    return __privateSet(this, _o, true), typeof t == "function" ? (t(this), this.commit()) : () => this.commit();
+  }
+  commit(t = "") {
+    return __privateMethod(this, _a_instances, h_fn).call(this, t), __privateSet(this, _o, false), this;
+  }
+  pause() {
+    __privateSet(this, _i, false);
+  }
+  resume() {
+    __privateSet(this, _i, true);
+  }
+  onCommit(t) {
+    return __privateGet(this, _n).add(t), () => {
+      __privateGet(this, _n).delete(t);
+    };
+  }
+  reset() {
+    __privateSet(this, _t, [new o("History Start")]), __privateSet(this, _n, /* @__PURE__ */ new Set()), __privateSet(this, _e, 0), __privateSet(this, _o, false), __privateSet(this, _s, /* @__PURE__ */ new Map()), __privateSet(this, _i, true), __privateSet(this, _r, false), __privateSet(this, _a3, false), this.onUndoRedo = null;
+  }
+}, _t = new WeakMap(), _a3 = new WeakMap(), _n = new WeakMap(), _e = new WeakMap(), _o = new WeakMap(), _s = new WeakMap(), _i = new WeakMap(), _r = new WeakMap(), _a_instances = new WeakSet(), d_fn = function() {
+  __privateSet(this, _t, [new o("History Start")]), __privateSet(this, _e, 0), __privateSet(this, _a3, true), __privateGet(this, _s).clear(), __privateSet(this, _o, false), __privateSet(this, _r, false);
+}, _f = new WeakMap(), u_fn = function() {
+  __privateGet(this, _r) || (__privateSet(this, _r, true), __privateGet(this, _f).call(this));
+}, h_fn = function(t = "") {
+  if (__privateGet(this, _s).size === 0) return;
+  __privateGet(this, _e) < __privateGet(this, _t).length - 1 && __privateGet(this, _t).splice(__privateGet(this, _e) + 1);
+  let e = Array.from(__privateGet(this, _s).values());
+  for (__privateGet(this, _t).push(...e), __privateGet(this, _n).forEach((r2) => r2(e)), __privateGet(this, _t)[__privateGet(this, _t).length - 1] instanceof o || __privateGet(this, _t).push(new o(t || Date.now().toString())); __privateGet(this, _t).length > this.options.maxSize; ) __privateGet(this, _t).shift();
+  __privateGet(this, _s).clear(), __privateSet(this, _e, __privateGet(this, _t).length - 1);
+}, __publicField(_a2, "name", "history"), __publicField(_a2, "options", { maxSize: 100 }), _a2);
+
+// ../../node_modules/@jucie.io/state-on-change/dist/main.js
+var h = Object.defineProperty;
+var s2 = (i2, e) => h(i2, "name", { value: e, configurable: true });
+var _a4, _t2, _e2, _r2, _s2, _n2, _r_instances, o_fn, u_fn2, h_fn2, i_fn, f_fn;
+var r = (_a4 = class extends Plugin {
+  constructor(e = {}) {
+    super(e);
+    __privateAdd(this, _r_instances);
+    __privateAdd(this, _t2, /* @__PURE__ */ new Set());
+    __privateAdd(this, _e2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _r2, false);
+    __privateAdd(this, _s2, false);
+    __privateAdd(this, _n2, 0);
+    __privateSet(this, _n2, e.debounce ?? 0);
+  }
+  actions() {
+    return { addListener: s2((e) => {
+      if (typeof e == "function") return __privateMethod(this, _r_instances, h_fn2).call(this, e);
+    }, "addListener"), subscribe: s2((e) => {
+      if (typeof e == "function") return __privateMethod(this, _r_instances, h_fn2).call(this, e);
+    }, "subscribe"), unsubscribe: s2((e) => {
+      if (typeof e == "function") return __privateMethod(this, _r_instances, i_fn).call(this, e);
+    }, "unsubscribe"), removeListener: s2((e) => __privateMethod(this, _r_instances, i_fn).call(this, e), "removeListener"), clear: s2(() => __privateMethod(this, _r_instances, f_fn).call(this), "clear") };
+  }
+  onStateChange(e, t) {
+    !__privateGet(this, _s2) || t.method === "apply" || __privateMethod(this, _r_instances, o_fn).call(this, e, t);
+  }
+}, _t2 = new WeakMap(), _e2 = new WeakMap(), _r2 = new WeakMap(), _s2 = new WeakMap(), _n2 = new WeakMap(), _r_instances = new WeakSet(), o_fn = function(e, t) {
+  __privateGet(this, _e2).has(e.address) && __privateGet(this, _e2).delete(e.address), __privateGet(this, _e2).set(e.address, t), __privateMethod(this, _r_instances, u_fn2).call(this);
+}, u_fn2 = function() {
+  if (!__privateGet(this, _r2)) {
+    __privateSet(this, _r2, true);
+    try {
+      setTimeout(() => {
+        let e = Array.from(__privateGet(this, _e2).values());
+        __privateGet(this, _e2).clear();
+        for (let t of __privateGet(this, _t2)) try {
+          t(e);
+        } catch (n) {
+          console.error("Error in onChange listener:", n);
+        }
+        __privateSet(this, _r2, false);
+      }, __privateGet(this, _n2));
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}, h_fn2 = function(e) {
+  return __privateGet(this, _t2).add(e), __privateSet(this, _s2, true), () => __privateMethod(this, _r_instances, i_fn).call(this, e);
+}, i_fn = function(e) {
+  typeof e == "function" && (__privateGet(this, _t2).delete(e), __privateGet(this, _t2).size === 0 && __privateSet(this, _s2, false));
+}, f_fn = function() {
+  __privateGet(this, _t2).clear(), __privateGet(this, _e2).clear(), __privateSet(this, _s2, false);
+}, __publicField(_a4, "name", "onChange"), _a4);
+
+// ../../node_modules/@jucie.io/state/dist/admin/buffer.js
+function defaultReplacer(key, value) {
+  if (key && key[0] === ".") return void 0;
+  return value;
+}
+function applyReplacerDeep(input, replacer = defaultReplacer, parentKey = "") {
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) {
+    return input.map((v2) => applyReplacerDeep(v2, replacer));
+  }
+  const out = {};
+  for (const k of Object.keys(input)) {
+    const v2 = replacer(k, input[k]);
+    if (typeof v2 !== "undefined") {
+      out[k] = applyReplacerDeep(v2, replacer, k);
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/@jucie.io/state/dist/admin/binary.js
+var MAGIC = new Uint8Array([74, 83, 67, 50]);
+var VERSION = 2;
+function base64urlEncode(buffer) {
+  const chunkSize = 8192;
+  let binaryString = "";
+  for (let i2 = 0; i2 < buffer.length; i2 += chunkSize) {
+    const chunk = buffer.slice(i2, i2 + chunkSize);
+    binaryString += String.fromCharCode(...chunk);
+  }
+  return btoa(binaryString).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64urlDecode(str) {
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binaryString = atob(padded);
+  const result = new Uint8Array(binaryString.length);
+  for (let i2 = 0; i2 < binaryString.length; i2++) {
+    result[i2] = binaryString.charCodeAt(i2);
+  }
+  return result;
+}
+function calculateChecksum(buffer) {
+  let checksum = 0;
+  for (let i2 = 0; i2 < buffer.length; i2++) {
+    checksum = (checksum << 5) - checksum + buffer[i2] >>> 0;
+  }
+  return checksum;
+}
+function writeUint32(value, buffer, offset = 0) {
+  const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 4);
+  view.setUint32(0, value, true);
+  return offset + 4;
+}
+function readUint32(buffer, offset = 0) {
+  const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 4);
+  return view.getUint32(0, true);
+}
+function writeUint16(value, buffer, offset = 0) {
+  const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 2);
+  view.setUint16(0, value, true);
+  return offset + 2;
+}
+function readUint16(buffer, offset = 0) {
+  const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 2);
+  return view.getUint16(0, true);
+}
+function writeUint8(value, buffer, offset = 0) {
+  buffer[offset] = value;
+  return offset + 1;
+}
+function readUint8(buffer, offset = 0) {
+  return buffer[offset];
+}
+function encodeObject(obj) {
+  return encode(obj);
+}
+function decodeObject(buffer) {
+  const obj = decode(buffer);
+  return [obj, buffer.length];
+}
+
+// ../../node_modules/@jucie.io/state/dist/admin/pack.js
+async function pack(data, { replacer = defaultReplacer } = {}) {
+  const clean = applyReplacerDeep(data, replacer);
+  const dataBuffer = encodeObject(clean);
+  const payloadLength = 4 + dataBuffer.length;
+  const payload = new Uint8Array(payloadLength);
+  let offset = 0;
+  offset = writeUint32(dataBuffer.length, payload, offset);
+  payload.set(dataBuffer, offset);
+  const checksum = calculateChecksum(payload);
+  const headerLen = 4 + 2 + 1 + 4 + 4;
+  const capsule = new Uint8Array(headerLen + payload.length);
+  capsule.set(MAGIC, 0);
+  writeUint16(VERSION, capsule, 4);
+  writeUint8(0, capsule, 6);
+  writeUint32(checksum, capsule, 7);
+  writeUint32(payload.length, capsule, 11);
+  capsule.set(payload, 15);
+  return base64urlEncode(capsule);
+}
+
+// ../../node_modules/@jucie.io/state/dist/admin/unpack.js
+async function unpack(capsuleString, cb) {
+  const capsule = base64urlDecode(capsuleString);
+  if (capsule.length < 15) {
+    throw new Error("Invalid capsule: too short");
+  }
+  for (let i2 = 0; i2 < 4; i2++) {
+    if (capsule[i2] !== MAGIC[i2]) throw new Error("Invalid capsule: bad magic");
+  }
+  const version = readUint16(capsule, 4);
+  if (version !== VERSION) {
+    throw new Error(`Unsupported capsule version: ${version}`);
+  }
+  const flags = readUint8(capsule, 6);
+  const storedChecksum = readUint32(capsule, 7);
+  const payloadLength = readUint32(capsule, 11);
+  if (payloadLength < 0) throw new Error("Invalid capsule: negative payload length");
+  if (capsule.length !== 15 + payloadLength) throw new Error("Invalid capsule: length mismatch");
+  const payload = capsule.slice(15);
+  const actualChecksum = calculateChecksum(payload);
+  if (storedChecksum !== actualChecksum) {
+    throw new Error("Integrity check failed: checksum mismatch");
+  }
+  let offset = 0;
+  const dataLength = readUint32(payload, offset);
+  offset += 4;
+  if (offset + dataLength > payload.length) {
+    throw new Error(`Data length ${dataLength} exceeds payload bounds at offset ${offset}`);
+  }
+  const [data] = decodeObject(payload.slice(offset, offset + dataLength));
+  if (cb) cb(data);
+  return {
+    data,
+    // Add 'data' key for generic usage
+    meta: {
+      version,
+      flags,
+      bytes: capsule.length,
+      checksum: actualChecksum.toString(16)
+    }
+  };
+}
+
+// ../../node_modules/@jucie.io/state/dist/lib/tree/traverse.js
+var traversalFunctions = [
+  null,
+  // index 0 (unused)
+  null,
+  // index 1 (single property access doesn't need optimization)
+  (obj, path) => obj?.[path[0]]?.[path[1]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]]?.[path[3]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]]?.[path[3]]?.[path[4]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]]?.[path[3]]?.[path[4]]?.[path[5]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]]?.[path[3]]?.[path[4]]?.[path[5]]?.[path[6]],
+  (obj, path) => obj?.[path[0]]?.[path[1]]?.[path[2]]?.[path[3]]?.[path[4]]?.[path[5]]?.[path[6]]?.[path[7]]
+];
+function createTraversalFunction(length) {
+  const accessors = Array.from({ length }, (_, i2) => `?.[path[${i2}]]`);
+  const expr = "obj" + accessors.join("");
+  const fn = new Function("obj", "path", `return ${expr}`);
+  traversalFunctions[length] = fn;
+  return fn;
+}
+function traverse(state, path) {
+  const len = path.length;
+  if (len === 0) return state;
+  if (len === 1) return state[path[0]];
+  if (len < traversalFunctions.length && traversalFunctions[len]) {
+    return traversalFunctions[len](state, path);
+  }
+  if (!traversalFunctions[len]) {
+    return createTraversalFunction(len)(state, path);
+  }
+  return traversalFunctions[len](state, path);
+}
+
+// ../../plugins/ledger/src/Ledger.js
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = typeof process !== "undefined" && process.versions?.node;
+var globalClock = 0;
+var _entries, _tombstones, _tombstoneIndex, _changeQueue, _isProcessing, _isImporting, _actorId, _sessionEpoch, _changeListeners, _hasChangeListeners, _Ledger_instances, createTombstone_fn, removeTombstone_fn, compareEntries_fn, isPathTombstoned_fn, removeEntriesUnderPath_fn, shouldApplyRemoteEntry_fn, rebuildTombstoneIndexes_fn, scheduleIdle_fn, scheduleNextTick_fn, scheduleRecord_fn, updateLedger_fn, continueGlobalClock_fn, checkTombstoneSize_fn, callChangeListeners_fn, cleanupTombstoneConflicts_fn;
+var _Ledger = class _Ledger extends Plugin {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _Ledger_instances);
+    __privateAdd(this, _entries, /* @__PURE__ */ new Map());
+    __privateAdd(this, _tombstones, /* @__PURE__ */ new Map());
+    __privateAdd(this, _tombstoneIndex, /* @__PURE__ */ new Set());
+    // Fast O(1) lookup for exact matches
+    __privateAdd(this, _changeQueue, []);
+    __privateAdd(this, _isProcessing, false);
+    __privateAdd(this, _isImporting, false);
+    // Flag to prevent change listener from creating entries during import
+    __privateAdd(this, _actorId, null);
+    __privateAdd(this, _sessionEpoch);
+    __privateAdd(this, _changeListeners, /* @__PURE__ */ new Set());
+    __privateAdd(this, _hasChangeListeners, false);
+    __publicField(this, "onTombstoneConflict", null);
+  }
+  initialize(state, options) {
+    __privateSet(this, _isProcessing, false);
+    __privateSet(this, _actorId, options.actorId ?? null);
+    __privateSet(this, _sessionEpoch, Date.now());
+  }
+  // Expose batch size for testing
+  get batchSize() {
+    return this.options.batchSize;
+  }
+  actions() {
+    return {
+      addChangeListener: (fn) => this.addChangeListener(fn),
+      removeChangeListener: (fn) => this.removeChangeListener(fn),
+      kill: (...args) => this.kill(args),
+      resurrect: (...args) => this.resurrect(args),
+      export: async () => await this.export(),
+      import: async (data) => await this.import(data),
+      snapshot: async () => await this.snapshot(),
+      importSnapshot: async (snapshot) => await this.importSnapshot(snapshot),
+      getStats: () => this.getStats()
+    };
+  }
+  onStateChange(marker, change) {
+    if (__privateGet(this, _isImporting)) return;
+    dispatch(marker, {
+      global: (marker2) => __privateGet(this, _changeQueue).push({ marker: marker2, change }),
+      path: (marker2) => __privateGet(this, _changeQueue).push({ marker: marker2, change }),
+      ephemeral: () => {
+      }
+    });
+    __privateMethod(this, _Ledger_instances, scheduleRecord_fn).call(this);
+  }
+  addChangeListener(listener) {
+    __privateGet(this, _changeListeners).add(listener);
+    if (__privateGet(this, _changeListeners).size > 0) {
+      __privateSet(this, _hasChangeListeners, true);
+    }
+    return () => this.removeChangeListener(listener);
+  }
+  removeChangeListener(listener) {
+    __privateGet(this, _changeListeners).delete(listener);
+    if (__privateGet(this, _changeListeners).size === 0) {
+      __privateSet(this, _hasChangeListeners, false);
+    }
+  }
+  getEntry(path) {
+    return __privateGet(this, _entries).get(encodePath(path));
+  }
+  getTombstone(path) {
+    return __privateGet(this, _tombstones).get(encodePath(path));
+  }
+  // Get all ledger entries
+  async export() {
+    return await pack({
+      entries: Array.from(__privateGet(this, _entries).entries()),
+      tombstones: Array.from(__privateGet(this, _tombstones).entries())
+    });
+  }
+  // Set ledger from entries
+  async import(data) {
+    const { entries, tombstones } = await unpack(data);
+    __privateSet(this, _entries, new Map(entries));
+    __privateSet(this, _tombstones, new Map(tombstones));
+    __privateMethod(this, _Ledger_instances, rebuildTombstoneIndexes_fn).call(this);
+    __privateMethod(this, _Ledger_instances, continueGlobalClock_fn).call(this);
+    return this;
+  }
+  // Create checkpoint with both state and ledger
+  async snapshot() {
+    return await pack({
+      state: this.state.get(),
+      ledger: {
+        entries: Array.from(__privateGet(this, _entries).entries()),
+        tombstones: Array.from(__privateGet(this, _tombstones).entries())
+      },
+      timestamp: Date.now()
+    });
+  }
+  // Merge state and ledger from checkpoint (expects {state, ledger} format)
+  async importSnapshot(snapshot) {
+    const { data: snapshotData } = await unpack(snapshot);
+    __privateSet(this, _isImporting, true);
+    try {
+      const entriesToApply = [];
+      for (const [address, remoteEntry] of snapshotData?.ledger?.entries || []) {
+        if (__privateMethod(this, _Ledger_instances, shouldApplyRemoteEntry_fn).call(this, address, remoteEntry)) {
+          entriesToApply.push([address, remoteEntry]);
+        }
+      }
+      for (const [address, remoteEntry] of entriesToApply) {
+        __privateGet(this, _entries).set(address, remoteEntry);
+        const path = decodeAddress(address);
+        const value = path === GLOBAL_TAG ? snapshotData?.state : traverse(snapshotData?.state, path);
+        this.state.set(path, value);
+      }
+      for (const [address, tombstone] of snapshotData?.ledger?.tombstones || []) {
+        const localEntry = this.getEntry(address);
+        const localTombstone = this.getTombstone(address);
+        let shouldApplyTombstone = false;
+        if (!localTombstone && !localEntry) {
+          shouldApplyTombstone = true;
+        } else if (localTombstone && tombstone.timestamp > localTombstone.timestamp) {
+          shouldApplyTombstone = true;
+        } else if (localEntry && !localTombstone) {
+          shouldApplyTombstone = true;
+        }
+        if (shouldApplyTombstone) {
+          const path = decodeAddress(address);
+          this.state.remove(path);
+          __privateGet(this, _tombstones).set(address, tombstone);
+          __privateGet(this, _tombstoneIndex).add(address);
+        }
+      }
+    } finally {
+      __privateSet(this, _isImporting, false);
+    }
+    return this.state;
+  }
+  // Clear all entries
+  reset() {
+    __privateGet(this, _entries).clear();
+    __privateGet(this, _tombstones).clear();
+    __privateGet(this, _tombstoneIndex).clear();
+    __privateSet(this, _changeQueue, []);
+    __privateSet(this, _isProcessing, false);
+    __privateSet(this, _actorId, null);
+    __privateSet(this, _sessionEpoch, Date.now());
+    __privateGet(this, _changeListeners).clear();
+    __privateSet(this, _hasChangeListeners, false);
+  }
+  // Get memory stats
+  getStats() {
+    return {
+      entriesCount: __privateGet(this, _entries).size,
+      tombstonesCount: __privateGet(this, _tombstones).size,
+      tombstoneIndexCount: __privateGet(this, _tombstoneIndex).size,
+      changeQueueCount: __privateGet(this, _changeQueue).length,
+      isProcessing: __privateGet(this, _isProcessing),
+      actorId: __privateGet(this, _actorId),
+      sessionEpoch: __privateGet(this, _sessionEpoch),
+      globalClock
+    };
+  }
+  // Kill a path and create a tombstone
+  kill(args) {
+    const marker = createMarker(args);
+    return dispatch(marker, {
+      global: () => {
+        throw new Error("Cannot kill global state");
+      },
+      path: ({ path, address }) => {
+        const removedValue = this.state.remove(path);
+        __privateMethod(this, _Ledger_instances, createTombstone_fn).call(this, address, removedValue);
+        return removedValue;
+      },
+      error: (error) => console.error(error)
+    });
+  }
+  // Resurrect a tombstoned path
+  resurrect(args) {
+    try {
+      const marker = createMarker(args);
+      const tombstone = __privateMethod(this, _Ledger_instances, removeTombstone_fn).call(this, marker.address);
+      if (!tombstone) {
+        throw new Error(`No tombstone found for path: ${marker.path.join(".")}`);
+      }
+      const data = JSON.parse(tombstone.data);
+      this.state.set(marker.path, data);
+      return data;
+    } catch (error) {
+      console.error(error);
+      return void 0;
+    }
+  }
+};
+_entries = new WeakMap();
+_tombstones = new WeakMap();
+_tombstoneIndex = new WeakMap();
+_changeQueue = new WeakMap();
+_isProcessing = new WeakMap();
+_isImporting = new WeakMap();
+_actorId = new WeakMap();
+_sessionEpoch = new WeakMap();
+_changeListeners = new WeakMap();
+_hasChangeListeners = new WeakMap();
+_Ledger_instances = new WeakSet();
+createTombstone_fn = function(address, data) {
+  const tombstone = { data: JSON.stringify(data), timestamp: Date.now() };
+  __privateGet(this, _tombstones).set(address, tombstone);
+  __privateGet(this, _tombstoneIndex).add(address);
+  __privateMethod(this, _Ledger_instances, removeEntriesUnderPath_fn).call(this, address);
+  __privateMethod(this, _Ledger_instances, checkTombstoneSize_fn).call(this);
+};
+removeTombstone_fn = function(address) {
+  const tombstone = __privateGet(this, _tombstones).get(address);
+  if (!tombstone) return void 0;
+  __privateGet(this, _tombstones).delete(address);
+  __privateGet(this, _tombstoneIndex).delete(address);
+  return tombstone;
+};
+compareEntries_fn = function(entry1, entry2) {
+  if (!entry1) return -1;
+  if (!entry2) return 1;
+  const [clock1, globalclock1, sessionEpoch1, actorId1] = entry1;
+  const [clock2, globalclock2, sessionEpoch2, actorId2] = entry2;
+  if (clock1 !== clock2) return clock1 > clock2 ? 1 : -1;
+  if (globalclock1 !== globalclock2) return globalclock1 > globalclock2 ? 1 : -1;
+  if (sessionEpoch1 !== sessionEpoch2) return sessionEpoch1 > sessionEpoch2 ? 1 : -1;
+  if (actorId1 !== actorId2) return actorId1.localeCompare(actorId2);
+  return 0;
+};
+// tombstoneIndex: a Set of encoded addresses (strings)
+isPathTombstoned_fn = function(address) {
+  if (__privateGet(this, _tombstoneIndex).has(address)) return true;
+  let i2 = address.length;
+  while (true) {
+    i2 = address.lastIndexOf(".", i2 - 1);
+    if (i2 === -1) break;
+    if (__privateGet(this, _tombstoneIndex).has(address.slice(0, i2))) return true;
+  }
+  return false;
+};
+// Remove ledger entries that are under a tombstoned path
+removeEntriesUnderPath_fn = function(tombstoneAddress) {
+  const entriesToRemove = [];
+  for (const [address] of __privateGet(this, _entries)) {
+    if (address === tombstoneAddress || address.startsWith(tombstoneAddress)) {
+      entriesToRemove.push(address);
+    }
+  }
+  for (const address of entriesToRemove) {
+    __privateGet(this, _entries).delete(address);
+  }
+};
+// Check if a change should be applied
+shouldApplyRemoteEntry_fn = function(address, remoteEntry) {
+  if (__privateMethod(this, _Ledger_instances, isPathTombstoned_fn).call(this, address)) return false;
+  const localEntry = __privateGet(this, _entries).get(address);
+  return __privateMethod(this, _Ledger_instances, compareEntries_fn).call(this, remoteEntry, localEntry) > 0;
+};
+// Rebuild tombstone indexes for optimal performance
+rebuildTombstoneIndexes_fn = function() {
+  __privateGet(this, _tombstoneIndex).clear();
+  for (const [address] of __privateGet(this, _tombstones)) {
+    __privateGet(this, _tombstoneIndex).add(address);
+  }
+};
+scheduleIdle_fn = function(callback) {
+  if (isBrowser && "requestIdleCallback" in window) {
+    window.requestIdleCallback(callback, { timeout: 50 });
+  } else if (isNode) {
+    setImmediate(callback);
+  } else {
+    setTimeout(callback, 0);
+  }
+};
+scheduleNextTick_fn = function(callback) {
+  let called = false;
+  Promise.resolve().then(() => {
+    if (!called) {
+      called = true;
+      callback();
+    }
+  });
+  setTimeout(() => {
+    if (!called) {
+      called = true;
+      callback();
+    }
+  }, 0);
+};
+scheduleRecord_fn = function() {
+  if (__privateGet(this, _isProcessing)) return;
+  __privateSet(this, _isProcessing, true);
+  __privateMethod(this, _Ledger_instances, scheduleNextTick_fn).call(this, () => {
+    const changes = __privateGet(this, _changeQueue).splice(0, this.options.batchSize || _Ledger.options.batchSize);
+    const changeEntries = [];
+    const conflictedPaths = [];
+    for (const { marker, change } of changes) {
+      dispatch(marker, {
+        global: () => {
+          const ledgerEntry = __privateMethod(this, _Ledger_instances, updateLedger_fn).call(this, marker.address);
+          changeEntries.push([GLOBAL_TAG, change, ledgerEntry]);
+        },
+        path: ({ path }) => {
+          if (__privateMethod(this, _Ledger_instances, isPathTombstoned_fn).call(this, marker.address)) {
+            conflictedPaths.push(path);
+            return;
+          }
+          const ledgerEntry = __privateMethod(this, _Ledger_instances, updateLedger_fn).call(this, marker.address);
+          changeEntries.push([marker.address, change, ledgerEntry]);
+        }
+      });
+    }
+    if (conflictedPaths.length > 0) {
+      __privateMethod(this, _Ledger_instances, scheduleIdle_fn).call(this, () => __privateMethod(this, _Ledger_instances, cleanupTombstoneConflicts_fn).call(this, this.state, conflictedPaths));
+    }
+    __privateMethod(this, _Ledger_instances, callChangeListeners_fn).call(this, changeEntries);
+    __privateSet(this, _isProcessing, false);
+    if (__privateGet(this, _changeQueue).length > 0) {
+      __privateMethod(this, _Ledger_instances, scheduleRecord_fn).call(this);
+    }
+  });
+};
+updateLedger_fn = function(address) {
+  const existingEntry = __privateGet(this, _entries).get(address);
+  __privateGet(this, _entries).delete(address);
+  const existingClock = existingEntry ? existingEntry[0] : 0;
+  const newClock = existingClock + 1;
+  const entry = [
+    newClock,
+    globalClock++,
+    __privateGet(this, _sessionEpoch),
+    __privateGet(this, _actorId)
+  ];
+  __privateGet(this, _entries).set(address, entry);
+  if (__privateGet(this, _entries).size > this.options.maxSize) {
+    const entriesToRemove = __privateGet(this, _entries).size - this.options.maxSize;
+    const sorted = Array.from(__privateGet(this, _entries).entries()).sort((a2, b) => __privateMethod(this, _Ledger_instances, compareEntries_fn).call(this, a2[1], b[1]));
+    for (let i2 = 0; i2 < entriesToRemove; i2++) {
+      __privateGet(this, _entries).delete(sorted[i2][0]);
+    }
+  }
+  return entry;
+};
+continueGlobalClock_fn = function() {
+  let maxGlobalClock = -1;
+  for (const entry of __privateGet(this, _entries).values()) {
+    if (entry && entry[1] > maxGlobalClock) {
+      maxGlobalClock = entry[1];
+    }
+  }
+  globalClock = globalClock > maxGlobalClock ? globalClock + 1 : maxGlobalClock + 1;
+};
+checkTombstoneSize_fn = function() {
+  const maxTombstoneSize = 1e3;
+  const maxTombstoneAge = 30 * 24 * 60 * 60 * 1e3;
+  const now = Date.now();
+  for (const [id, { timestamp }] of __privateGet(this, _tombstones)) {
+    if (__privateGet(this, _tombstones).size > maxTombstoneSize || now - timestamp > maxTombstoneAge) {
+      __privateGet(this, _tombstones).delete(id);
+    }
+  }
+};
+callChangeListeners_fn = function(changeEntries) {
+  if (__privateGet(this, _hasChangeListeners)) {
+    __privateGet(this, _changeListeners).forEach((listener) => listener(changeEntries));
+  }
+};
+// Async cleanup of tombstone conflicts detected during ledger processing
+cleanupTombstoneConflicts_fn = function(state, conflictedPaths) {
+  for (const path of conflictedPaths) {
+    try {
+      state.remove(path);
+    } catch (error) {
+      console.warn(`Tombstone cleanup failed for path ${path.join(".")}:`, error.message);
+    }
+  }
+};
+__publicField(_Ledger, "name", "ledger");
+__publicField(_Ledger, "options", {
+  userId: null,
+  maxSize: 1e4,
+  batchSize: 100
+});
+// Callback to clean up state data
+__publicField(_Ledger, "empty", {
+  entries: [],
+  tombstones: []
+});
+var Ledger = _Ledger;
+
+// src/lib/utils/getViewport.js
+function getViewport() {
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  const body = document.body;
+  const transform = body.style.transform || "";
+  let scroll = { x: 0, y: 0 };
+  let scale = 1;
+  if (transform) {
+    const translateMatch = transform.match(/translate\(([^,]+),\s*([^)]+)\)/);
+    if (translateMatch) {
+      scroll.x = parseFloat(translateMatch[1].replace("px", "")) || 0;
+      scroll.y = parseFloat(translateMatch[2].replace("px", "")) || 0;
+    }
+    const scaleMatch = transform.match(/scale\(([^)]+)\)/);
+    if (scaleMatch) {
+      scale = parseFloat(scaleMatch[1]);
+    }
+  }
+  return {
+    scroll,
+    scale,
+    width,
+    height
+  };
+}
+
+// ../ai-tools/operations/nodeOperations.js
+var nodeOperations = defineAiOperations("node", (useContext) => ({
+  create: {
+    description: 'Create a new node in the scene graph. type is a prototype name (e.g. div, header, p, button, frame). Optional props (e.g. name, frame) and parent (defaults to "app").',
+    alias: "create",
+    mcpName: "create_node",
+    schema: [{
+      type: "String",
+      props: "Object?",
+      parent: "String?"
+    }],
+    examples: [
+      {
+        args: {
+          type: "button",
+          parent: "app"
+        },
+        description: "Create a button element"
+      },
+      {
+        args: {
+          type: "nav",
+          parent: "app"
+        },
+        description: "Create a nav element"
+      },
+      {
+        args: {
+          type: "frame",
+          props: { frame: "iPhone SE", name: "Home" }
+        },
+        description: "Create an iPhone SE frame named Home"
+      }
+    ],
+    returns: "{ id: String, type: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addNode } = await import("./addNode-TX462HCE.js");
+      const nodes = state.ref(["nodes"]);
+      const { type, props, parent = "app" } = args;
+      const id = addNode(nodes, type, props, parent);
+      if (id instanceof Error) {
+        throw id;
+      }
+      if (type === "frame") {
+        const appChildren = nodes.get(["app", "children"]) ?? [];
+        const siblings = appChildren.filter((cid) => cid !== id);
+        if (siblings.length > 0) {
+          let maxRight = 0;
+          for (const sid of siblings) {
+            const b = nodes.get([sid, "bounds"]);
+            if (b) maxRight = Math.max(maxRight, (b.x ?? 0) + (b.width ?? 0));
+          }
+          const { updateBounds } = await import("./updateBounds-WKOI6XJ3.js");
+          updateBounds(nodes, id, { x: maxRight + 100, y: 0 });
+        }
+      }
+      return { id, type };
+    }
+  },
+  updateStyle: {
+    description: 'Update styles for a node. Optional breakpoint targets a variant: "@720" (responsive), ":hover" (pseudo-state), "&.is-active" (custom state).',
+    mcpName: "update_style",
+    schema: [{
+      nodeId: "String",
+      styles: "Object",
+      breakpoint: "String?"
+    }],
+    examples: [
+      {
+        args: {
+          nodeId: "nd_123",
+          styles: {
+            "background-color": "#2563eb",
+            padding: "16px",
+            "border-radius": "8px"
+          }
+        },
+        description: "Set background, padding, and border radius"
+      },
+      {
+        args: {
+          nodeId: "nd_123",
+          styles: { "background-color": "#1d4ed8" },
+          breakpoint: ":hover"
+        },
+        description: "Set hover background"
+      }
+    ],
+    returns: "{ id: String, styles: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateStyle } = await import("./updateStyle-FN7CGZTJ.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, styles, breakpoint } = args;
+      const layoutManaged = ["display", "position"].filter((p) => p in styles);
+      const options = {};
+      if (breakpoint) {
+        if (breakpoint.startsWith(":") || breakpoint.startsWith("&")) {
+          options.interactionState = [breakpoint];
+        } else {
+          options.breakpoint = breakpoint;
+        }
+      }
+      const updatedStyles = updateStyle(nodes, nodeId, { ...styles }, options);
+      const result = { id: nodeId, styles: updatedStyles };
+      if (layoutManaged.length) {
+        result.warning = `Ignored ${layoutManaged.join(", ")} \u2014 use node:setAutoLayout to change layout mode.`;
+      }
+      return result;
+    }
+  },
+  updateText: {
+    description: "Set text content for a node. Use {{expression}} syntax for dynamic values.",
+    mcpName: "update_text",
+    schema: [{
+      nodeId: "String",
+      value: "String"
+      // Use {{expression}} syntax for dynamic content
+    }],
+    examples: [
+      {
+        args: {
+          nodeId: "nd_heading",
+          value: "Welcome"
+        },
+        description: 'Set static text to "Welcome"'
+      },
+      {
+        args: {
+          nodeId: "nd_label",
+          value: "{{user.name}}"
+        },
+        description: "Set dynamic text with expression"
+      }
+    ],
+    returns: "{ id: String, textContent: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { createTextContent } = await import("./createTextContent-R5YRKNJL.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, value } = args;
+      const textContent = createTextContent({ value });
+      nodes.set([nodeId, "textContent"], textContent);
+      return { id: nodeId, textContent };
+    }
+  },
+  move: {
+    description: "Move a node to be the last child of another node",
+    mcpName: "move_node",
+    schema: [{
+      nodeId: "String",
+      parentId: "String"
+    }],
+    examples: [
+      {
+        args: {
+          nodeId: "nd_link",
+          parentId: "nd_nav"
+        },
+        description: "Move link into nav"
+      }
+    ],
+    returns: "{ id: String, movedTo: String, success: Boolean }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { disconnectNode } = await import("./disconnectNode-J6YACRLT.js");
+      const { moveNodeToLastChildOf } = await import("./moveNodeToLastChildOf-IUKGA7IO.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, parentId } = args;
+      disconnectNode(nodes, nodeId);
+      const success = moveNodeToLastChildOf(nodes, nodeId, parentId);
+      return { id: nodeId, movedTo: parentId, success };
+    }
+  },
+  remove: {
+    description: "Remove a node and all its descendants from the scene graph",
+    alias: "removeNode",
+    mcpName: "remove_node",
+    schema: [{
+      nodeId: "String"
+    }],
+    examples: [
+      {
+        args: {
+          nodeId: "nd_old_element"
+        },
+        description: "Remove an element"
+      }
+    ],
+    returns: "{ id: String, removed: Boolean, removedNodes: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeNode } = await import("./removeNode-DY2ULYNK.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId } = args;
+      const [id, removedNodes] = removeNode(nodes, nodeId);
+      return { id, removed: true, removedNodes };
+    }
+  },
+  setAutoLayout: {
+    description: 'Set the layout mode of a container node ("none" | "block" | "flex" | "grid"). Sets layout on the parent and the corresponding display style, and normalizes all direct children so they flow correctly. Always use this instead of setting display via updateStyle.',
+    alias: "setLayout",
+    mcpName: "set_layout",
+    schema: [{
+      nodeId: "String",
+      layout: "String"
+    }],
+    examples: [
+      {
+        args: {
+          nodeId: "nd_container",
+          layout: "flex"
+        },
+        description: "Enable flex auto-layout on a container"
+      },
+      {
+        args: {
+          nodeId: "nd_container",
+          layout: "none"
+        },
+        description: "Disable auto-layout, reverting children to absolute positioning"
+      }
+    ],
+    returns: "{ id: String, layout: String, childrenUpdated: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setNodeLayout } = await import("./setNodeLayout-K2VNUD2H.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, layout } = args;
+      return setNodeLayout(nodes, nodeId, layout);
+    }
+  },
+  setName: {
+    description: "Set a display name on a node. Names appear in get_scene output and make the tree readable. Pass an empty string to clear back to the default (tag name).",
+    mcpName: "set_name",
+    schema: [{
+      nodeId: "String",
+      name: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_123", name: "Hero Section" }, description: "Name a section" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name } = args;
+      if (name === "") {
+        const { clearName } = await import("./clearName-AAUKJ3OX.js");
+        clearName(nodes, nodeId);
+        return { id: nodeId, name: "" };
+      }
+      const { setName } = await import("./setName-W4MXGWGB.js");
+      setName(nodes, nodeId, name);
+      return { id: nodeId, name };
+    }
+  },
+  clearName: {
+    description: "Clear the display name from a node, reverting to its tag name.",
+    schema: [{
+      nodeId: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_123" }, description: "Clear name back to default" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { clearName } = await import("./clearName-AAUKJ3OX.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId } = args;
+      clearName(nodes, nodeId);
+      return { id: nodeId };
+    }
+  },
+  addComponent: {
+    description: "Convert an existing node into a reusable local component. The node is replaced in-place by an instance; the original tree becomes the component definition. Returns instanceId and componentId.",
+    mcpName: "add_component",
+    schema: [{
+      nodeId: "String",
+      name: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_card", name: "Card" }, description: "Convert a card node into a reusable component" }
+    ],
+    returns: "{ instanceId: String, componentId: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addComponent } = await import("./addComponent-GUOHFGDG.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name = "" } = args;
+      const instanceId = addComponent(nodes, nodeId, name);
+      const componentId = nodes.get([instanceId, "component"]);
+      return { instanceId, componentId, name };
+    }
+  }
+}));
+
+// ../ai-tools/operations/treeOperations.js
+var treeOperations = defineAiOperations("tree", (useContext) => ({
+  create: {
+    description: 'Create a nested tree of nodes recursively (use for complex structures like mobile pages). For frames, parent MUST be "app".',
+    alias: "createTree",
+    schema: [{
+      tree: "Object",
+      parent: "String?"
+    }],
+    examples: [{
+      args: {
+        tree: {
+          type: "frame",
+          name: "Home",
+          frame: "iPhone SE",
+          bounds: {
+            x: 0,
+            y: 400
+          },
+          styles: { display: "flex", "flex-direction": "column", overflow: "hidden" },
+          children: [
+            {
+              type: "header",
+              styles: { padding: "16px" },
+              children: [
+                {
+                  type: "h1",
+                  text: "App Name"
+                }
+              ]
+            },
+            {
+              type: "main",
+              styles: { flex: "1" }
+            },
+            {
+              type: "footer",
+              styles: { padding: "16px" },
+              text: "Footer"
+            }
+          ]
+        },
+        parent: "app"
+      },
+      description: "Create mobile page with header, main, footer \u2014 frame is the flex container"
+    }],
+    returns: "{ rootId: String, createdIds: Array, treeMap: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const log = useContext("log");
+      const { addNode } = await import("./addNode-TX462HCE.js");
+      const { updateStyle } = await import("./updateStyle-FN7CGZTJ.js");
+      const { setNodeLayout } = await import("./setNodeLayout-K2VNUD2H.js");
+      const { normalizeLayoutContext } = await import("./normalizeLayoutContext-TO4WKUWF.js");
+      const { createTextContent } = await import("./createTextContent-R5YRKNJL.js");
+      const nodes = state.ref(["nodes"]);
+      const { tree, parent = "app" } = args;
+      const createdIds = [];
+      const treeMap = {};
+      const createRecursive = (nodeSpec, parentId) => {
+        const { type, children, styles, style, text, ref, bounds: boundsSpec, ...overrides } = nodeSpec;
+        const id = addNode(nodes, type, overrides, parentId);
+        createdIds.push(id);
+        if (ref) {
+          treeMap[ref] = id;
+        }
+        if (type === "frame" && boundsSpec) {
+          const { x, y } = boundsSpec;
+          const current = nodes.get([id, "bounds"]) ?? {};
+          nodes.set([id, "bounds"], {
+            ...current,
+            ...x != null ? { x } : {},
+            ...y != null ? { y } : {}
+          });
+        }
+        const nodeName = overrides.name;
+        if (nodeName) {
+          nodes.set([id, "name"], nodeName);
+        }
+        const resolvedStyles = styles || style;
+        if (resolvedStyles && Object.keys(resolvedStyles).length > 0) {
+          updateStyle(nodes, id, { ...resolvedStyles });
+        }
+        const resolvedDisplay = resolvedStyles?.display ?? nodes.get([id, "style", "default", "display"]);
+        const isFlowParent = resolvedDisplay === "flex" || resolvedDisplay === "grid";
+        if (isFlowParent) {
+          try {
+            setNodeLayout(nodes, id, resolvedDisplay);
+          } catch (e) {
+            log.warn("setNodeLayout failed for parent", { id, error: e.message });
+          }
+        }
+        if (text && !(children?.length > 0)) {
+          const textContent = createTextContent({ value: text });
+          nodes.set([id, "textContent"], textContent);
+        }
+        if (children && children.length > 0) {
+          children.forEach((child) => {
+            if (isFlowParent) {
+              const childStyles = child.styles || child.style || {};
+              if (childStyles.position !== "absolute") {
+                child = {
+                  ...child,
+                  styles: {
+                    width: "auto",
+                    height: "auto",
+                    top: "auto",
+                    left: "auto",
+                    ...childStyles
+                  }
+                };
+              }
+            }
+            const childId = createRecursive(child, id);
+            if (isFlowParent) {
+              normalizeLayoutContext(nodes, childId, id);
+            }
+          });
+        }
+        return id;
+      };
+      const rootId = createRecursive(tree, parent);
+      return { id: rootId, rootId, createdIds, treeMap, type: "tree" };
+    }
+  }
+}));
+
+// ../ai-tools/operations/behaviorOperations.js
+var behaviorOperations = defineAiOperations("behavior", (useContext) => ({
+  // ── Events ──────────────────────────────────────────────────────────────────
+  addEvent: {
+    description: 'Add or replace an event handler on a node (replaces any existing handler with the same name). Event names use React-style onX format (onClick, onSubmit, onInput, onChange, onMouseEnter, etc.); lowercase names like "click" or "submit" are auto-normalized. Use binding for zero-arg store actions (e.g. "$store.myStore.doSomething"); use code when you need arguments or complex logic \u2014 code MUST be a complete function expression: function (ctx, event) { ... }. Access stores inside the handler via ctx.$store.<storeName>.',
+    mcpName: "add_event",
+    schema: [{
+      nodeId: "String",
+      name: "String",
+      binding: "String?",
+      code: "String?",
+      mode: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_btn", name: "onClick", binding: "$store.default.increment" }, description: "Call store action on click" },
+      { args: { nodeId: "nd_btn", name: "onClick", code: 'function (ctx, event) {\n  ctx.$store.todo.items.push({ text: ctx.$store.todo.newTodo, done: false })\n  ctx.$store.todo.newTodo = ""\n}' }, description: "Add click handler with code" },
+      { args: { nodeId: "nd_form", name: "onSubmit", code: "function (ctx, event) {\n  event.preventDefault()\n}" }, description: "Prevent default on form submit" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addEvent } = await import("./addEvent-GQCCRSGP.js");
+      const { updateEvent } = await import("./updateEvent-4PDSQ3Q4.js");
+      const { normalizeEventName } = await import("./normalizeEventName-EWVVRI6K.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name, binding, code, mode } = args;
+      const normalized = normalizeEventName(name);
+      const events = nodes.get([nodeId, "events"]) ?? [];
+      const existing = events.find((e) => e.name === normalized);
+      if (!existing) {
+        addEvent(nodes, nodeId, normalized);
+      }
+      if (binding !== void 0) {
+        const current = (nodes.get([nodeId, "events"]) ?? []).find((e) => e.name === normalized) ?? { name: normalized };
+        updateEvent(nodes, nodeId, normalized, { ...current, mode: "binding", binding: binding.split("."), code: null });
+      } else if (code !== void 0) {
+        const current = (nodes.get([nodeId, "events"]) ?? []).find((e) => e.name === normalized) ?? { name: normalized };
+        updateEvent(nodes, nodeId, normalized, { ...current, mode: mode ?? "code", code, binding: null });
+      }
+      return { id: nodeId, name: normalized };
+    }
+  },
+  updateEvent: {
+    description: "Update an existing event handler by name",
+    schema: [{
+      nodeId: "String",
+      name: "String",
+      event: "Object"
+    }],
+    examples: [
+      { args: { nodeId: "nd_btn", name: "onClick", event: { mode: "code", code: 'alert("hi")' } }, description: "Update onClick handler" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateEvent } = await import("./updateEvent-4PDSQ3Q4.js");
+      const { normalizeEventName } = await import("./normalizeEventName-EWVVRI6K.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name, event } = args;
+      const lookupName = normalizeEventName(name);
+      const normalized = event?.name !== void 0 ? { ...event, name: normalizeEventName(event.name) } : { ...event, name: lookupName };
+      updateEvent(nodes, nodeId, lookupName, normalized);
+      return { id: nodeId, name: lookupName };
+    }
+  },
+  removeEvent: {
+    description: "Remove an event handler by name",
+    schema: [{
+      nodeId: "String",
+      name: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_btn", name: "onClick" }, description: "Remove onClick handler" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeEvent } = await import("./removeEvent-7ODGVHMT.js");
+      const { normalizeEventName } = await import("./normalizeEventName-EWVVRI6K.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name } = args;
+      const normalized = normalizeEventName(name);
+      removeEvent(nodes, nodeId, normalized);
+      return { id: nodeId, name: normalized };
+    }
+  },
+  // ── Routing ─────────────────────────────────────────────────────────────────
+  updateRoute: {
+    description: "Set the route path on a frame node for multi-page navigation",
+    schema: [{
+      nodeId: "String",
+      route: "Any"
+    }],
+    examples: [
+      { args: { nodeId: "nd_frame", route: "/about" }, description: "Set route path" },
+      { args: { nodeId: "nd_frame", route: { path: "/users/:id" } }, description: "Set route with params" }
+    ],
+    returns: "{ id: String, route: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateRoute } = await import("./updateRoute-P5OTKOOG.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, route } = args;
+      const normalized = typeof route === "string" ? { path: route } : route;
+      updateRoute(nodes, nodeId, normalized);
+      return { id: nodeId, route: normalized };
+    }
+  },
+  setHomePage: {
+    description: "Mark a frame as the home page (root route)",
+    schema: [{
+      nodeId: "String",
+      isHomePage: "Any"
+    }],
+    examples: [
+      { args: { nodeId: "nd_frame", isHomePage: true }, description: "Set as home page" }
+    ],
+    returns: "{ id: String, isHomePage: Any }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setHomePage } = await import("./setHomePage-4U4Z3RU7.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, isHomePage } = args;
+      setHomePage(nodes, nodeId, isHomePage);
+      return { id: nodeId, isHomePage };
+    }
+  },
+  setDestination: {
+    description: "Set a navigation destination on a link or button node",
+    schema: [{
+      nodeId: "String",
+      destination: "Any"
+    }],
+    examples: [
+      { args: { nodeId: "nd_link", destination: "/about" }, description: "Navigate to /about on click" }
+    ],
+    returns: "{ id: String, destination: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setDestination } = await import("./setDestination-M6MQACBQ.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, destination } = args;
+      const normalized = typeof destination === "string" ? { path: destination } : destination;
+      setDestination(nodes, nodeId, normalized);
+      return { id: nodeId, destination: normalized };
+    }
+  },
+  clearDestination: {
+    description: "Remove the navigation destination from a node",
+    schema: [{
+      nodeId: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_link" }, description: "Clear navigation destination" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { clearDestination } = await import("./clearDestination-KO6YHLX2.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId } = args;
+      clearDestination(nodes, nodeId);
+      return { id: nodeId };
+    }
+  },
+  // ── Dynamic behavior ────────────────────────────────────────────────────────
+  setRepeat: {
+    description: 'Repeat a node for each item in a data binding (loop). binding is a dot-path on ctx (e.g. "$store.todo.items").',
+    schema: [{
+      nodeId: "String",
+      binding: "String",
+      as: "String?",
+      index: "String?",
+      key: "Any?",
+      keyOn: "Any?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_card", binding: "$store.todo.items", as: "$item" }, description: "Repeat card for each item in the todo store" }
+    ],
+    returns: "{ id: String, binding: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setRepeat } = await import("./setRepeat-X5GZ4F2P.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, binding, as: asAlias, index: indexAlias, key, keyOn } = args;
+      const bindingPath = binding.split(".");
+      setRepeat(nodes, nodeId, { descriptor: { mode: "binding", binding: bindingPath }, as: asAlias, index: indexAlias, key, keyOn });
+      return { id: nodeId, binding };
+    }
+  },
+  clearRepeat: {
+    description: "Remove repeat binding from a node",
+    schema: [{
+      nodeId: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_card" }, description: "Stop repeating" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { clearRepeat } = await import("./clearRepeat-AZLSTBXI.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId } = args;
+      clearRepeat(nodes, nodeId);
+      return { id: nodeId };
+    }
+  },
+  setRender: {
+    description: 'Conditionally show/hide a node based on an expression. Pass an expression that uses ctx (e.g. "ctx.$store.user.isAdmin"); it is wrapped as a computed function automatically. Stores are at ctx.$store.<name>; loop vars at ctx.$item / ctx.$index.',
+    schema: [{
+      nodeId: "String",
+      value: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_admin", value: "ctx.$store.user.isAdmin" }, description: "Show only for admins" }
+    ],
+    returns: "{ id: String, value: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setRender } = await import("./setRender-UJAXCTRA.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, value } = args;
+      const computed = `function (ctx) {
+  return ${value}
+}`;
+      setRender(nodes, nodeId, { mode: "computed", computed });
+      return { id: nodeId, value };
+    }
+  },
+  clearRender: {
+    description: "Remove conditional rendering from a node (always show)",
+    schema: [{
+      nodeId: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_admin" }, description: "Always render" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { clearRender } = await import("./clearRender-TTNIVIPG.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId } = args;
+      clearRender(nodes, nodeId);
+      return { id: nodeId };
+    }
+  },
+  // ── States ──────────────────────────────────────────────────────────────────
+  addState: {
+    description: 'Register a custom state class on a node (e.g. "is-active"). Style it with updateStyle breakpoint "&.is-active".',
+    schema: [{
+      nodeId: "String",
+      stateName: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_tab", stateName: "is-active" }, description: "Add active state" }
+    ],
+    returns: "{ id: String, stateName: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addState } = await import("./addState-IKDWEJIW.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, stateName } = args;
+      addState(nodes, nodeId, stateName);
+      return { id: nodeId, stateName };
+    }
+  },
+  updateState: {
+    description: "Set the expression that controls when a state is active",
+    schema: [{
+      nodeId: "String",
+      stateName: "String",
+      expression: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_tab", stateName: "is-active", expression: '$router.currentRoute?.path === "/"' }, description: "Activate on home route" }
+    ],
+    returns: "{ id: String, stateName: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateState } = await import("./updateState-B2RIQRWF.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, stateName, expression } = args;
+      updateState(nodes, nodeId, stateName, { name: stateName, mode: "computed", computed: expression ?? null });
+      return { id: nodeId, stateName };
+    }
+  },
+  removeState: {
+    description: "Remove a custom state from a node",
+    schema: [{
+      nodeId: "String",
+      stateName: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_tab", stateName: "is-active" }, description: "Remove active state" }
+    ],
+    returns: "{ id: String, stateName: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeState } = await import("./removeState-EBT6YGSZ.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, stateName } = args;
+      removeState(nodes, nodeId, stateName);
+      return { id: nodeId, stateName };
+    }
+  },
+  // ── Metadata ────────────────────────────────────────────────────────────────
+  updateBounds: {
+    description: "Update the position and size of a node",
+    schema: [{
+      nodeId: "String",
+      bounds: "Object"
+    }],
+    examples: [
+      { args: { nodeId: "nd_frame", bounds: { x: 500, y: 0, width: 375, height: 667 } }, description: "Position a frame" }
+    ],
+    returns: "{ id: String, bounds: Object }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateBounds } = await import("./updateBounds-WKOI6XJ3.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, bounds } = args;
+      updateBounds(nodes, nodeId, bounds);
+      return { id: nodeId, bounds };
+    }
+  },
+  setHtmlId: {
+    description: "Set the HTML id attribute on a node",
+    schema: [{
+      nodeId: "String",
+      id: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_section", id: "hero-section" }, description: "Set HTML id for anchor links" }
+    ],
+    returns: "{ id: String, htmlId: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setHtmlId } = await import("./setHtmlId-MN7AQG5H.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, id } = args;
+      setHtmlId(nodes, nodeId, id);
+      return { id: nodeId, htmlId: id };
+    }
+  },
+  addAttribute: {
+    description: "Add a custom HTML attribute to a node",
+    schema: [{
+      nodeId: "String",
+      name: "String",
+      value: "Any?",
+      mode: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_img", name: "src", value: "/hero.png" }, description: "Set image source" },
+      { args: { nodeId: "nd_img", name: "alt", value: "Hero image" }, description: "Set alt text" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addAttribute } = await import("./addAttribute-V4C3VUVK.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name, value, mode } = args;
+      addAttribute(nodes, nodeId, { name, value, mode });
+      return { id: nodeId, name };
+    }
+  },
+  updateAttribute: {
+    description: 'Update or upsert an attribute by name. For two-way input binding use name "model", mode "binding", and binding "$store.path". model XOR value/checked \u2014 setting model clears value and checked; setting value or checked clears model.',
+    schema: [{
+      nodeId: "String",
+      name: "String",
+      mode: "String?",
+      value: "Any?",
+      binding: "Any?",
+      computed: "String?",
+      code: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_img", name: "src", value: "/new-hero.png" }, description: "Change image source" },
+      { args: { nodeId: "nd_email", name: "model", mode: "binding", binding: "$store.form.email" }, description: "Two-way bind input to store" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateAttribute } = await import("./updateAttribute-VWGV37R7.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, ...attr } = args;
+      if (typeof attr.binding === "string") {
+        attr.binding = attr.binding.split(".");
+      }
+      if (attr.name === "model" && attr.mode == null) {
+        attr.mode = "binding";
+      }
+      updateAttribute(nodes, nodeId, attr.name, attr);
+      return { id: nodeId, name: attr.name };
+    }
+  },
+  removeAttribute: {
+    description: "Remove an attribute by name",
+    schema: [{
+      nodeId: "String",
+      name: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_img", name: "src" }, description: "Remove src attribute" }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeAttribute } = await import("./removeAttribute-4QEKTGTP.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, name } = args;
+      removeAttribute(nodes, nodeId, name);
+      return { id: nodeId, name };
+    }
+  },
+  // ── Lifecycle hooks ─────────────────────────────────────────────────────────
+  addLifecycleHook: {
+    description: 'Add a lifecycle hook to a node (mount, unmount, update). mode is "code" with a code string, or "binding" with a store action binding.',
+    schema: [{
+      nodeId: "String",
+      key: "String",
+      code: "String?",
+      binding: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_page", key: "mount", code: 'console.log("mounted")' }, description: "Run code on mount" },
+      { args: { nodeId: "nd_page", key: "mount", binding: "cart.load" }, description: "Call a store action on mount" }
+    ],
+    returns: "{ id: String, key: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addLifecycleHook } = await import("./addLifecycleHook-GC5MHVSH.js");
+      const { updateLifecycleHook } = await import("./updateLifecycleHook-36JI5KSF.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, key, code, binding } = args;
+      addLifecycleHook(nodes, nodeId, key);
+      if (code !== void 0 || binding !== void 0) {
+        updateLifecycleHook(nodes, nodeId, key, {
+          key,
+          mode: code !== void 0 ? "code" : "binding",
+          code: code ?? "",
+          binding: binding ?? null
+        });
+      }
+      return { id: nodeId, key };
+    }
+  },
+  updateLifecycleHook: {
+    description: "Update a lifecycle hook by key. hook may include key, mode, code, binding.",
+    schema: [{
+      nodeId: "String",
+      key: "String",
+      hook: "Object"
+    }],
+    returns: "{ id: String, key: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateLifecycleHook } = await import("./updateLifecycleHook-36JI5KSF.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, key, hook } = args;
+      const current = (nodes.get([nodeId, "lifecycle"]) ?? []).find((h2) => h2.key === key) ?? { key };
+      updateLifecycleHook(nodes, nodeId, key, { ...current, ...hook });
+      return { id: nodeId, key };
+    }
+  },
+  removeLifecycleHook: {
+    description: "Remove a lifecycle hook by key.",
+    schema: [{
+      nodeId: "String",
+      key: "String"
+    }],
+    returns: "{ id: String, key: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeLifecycleHook } = await import("./removeLifecycleHook-3XIZU6TW.js");
+      removeLifecycleHook(state.ref(["nodes"]), args.nodeId, args.key);
+      return { id: args.nodeId, key: args.key };
+    }
+  },
+  // ── Select options ──────────────────────────────────────────────────────────
+  addOption: {
+    description: "Add a static option to a select node.",
+    schema: [{
+      nodeId: "String",
+      value: "String",
+      label: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_select", value: "us", label: "United States" }, description: "Add a select option" }
+    ],
+    returns: "{ id: String, value: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addOption } = await import("./addOption-7T3ZUC3A.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, value, label } = args;
+      addOption(nodes, nodeId, { value, label: label ?? value });
+      return { id: nodeId, value };
+    }
+  },
+  updateOption: {
+    description: "Update a select option by its current value. Pass the old value to look up, and optionally a new value/label.",
+    schema: [{
+      nodeId: "String",
+      value: "String",
+      newValue: "String?",
+      label: "String?"
+    }],
+    returns: "{ id: String, value: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateOption } = await import("./updateOption-ZEZ4TP7K.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, value, newValue, label } = args;
+      const nextValue = newValue ?? value;
+      updateOption(nodes, nodeId, value, { value: nextValue, label: label ?? nextValue });
+      return { id: nodeId, value: nextValue };
+    }
+  },
+  removeOption: {
+    description: "Remove a select option by value.",
+    schema: [{
+      nodeId: "String",
+      value: "String"
+    }],
+    returns: "{ id: String, value: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeOption } = await import("./removeOption-V4NBH6EE.js");
+      removeOption(state.ref(["nodes"]), args.nodeId, args.value);
+      return { id: args.nodeId, value: args.value };
+    }
+  },
+  setOptionsExpression: {
+    description: "Bind a select node's options to a data expression instead of a static list. binding is a {{expression}} returning an array; valueKey/labelKey pick fields from each item.",
+    schema: [{
+      nodeId: "String",
+      binding: "String",
+      valueKey: "String?",
+      labelKey: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_select", binding: "{{countries}}", valueKey: "code", labelKey: "name" }, description: "Populate options from a store" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setOptionsExpression } = await import("./setOptionsExpression-KQLKXH4C.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, binding, valueKey, labelKey } = args;
+      setOptionsExpression(nodes, nodeId, { binding, valueKey, labelKey });
+      return { id: nodeId };
+    }
+  },
+  clearOptionsExpression: {
+    description: "Switch a select node back to its static options list.",
+    schema: [{
+      nodeId: "String"
+    }],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { clearOptionsExpression } = await import("./clearOptionsExpression-YGCMAZEE.js");
+      clearOptionsExpression(state.ref(["nodes"]), args.nodeId);
+      return { id: args.nodeId };
+    }
+  },
+  // ── Tag name / raw HTML ─────────────────────────────────────────────────────
+  setTagName: {
+    description: "Change the HTML tag of an element node (e.g. div to section).",
+    mcpName: "set_tag_name",
+    schema: [{
+      nodeId: "String",
+      tagName: "String"
+    }],
+    examples: [
+      { args: { nodeId: "nd_box", tagName: "section" }, description: "Make a div semantic" }
+    ],
+    returns: "{ id: String, tagName: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { setTagName } = await import("./setTagName-5DMTFJTJ.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, tagName } = args;
+      setTagName(nodes, nodeId, tagName);
+      return { id: nodeId, tagName };
+    }
+  },
+  updateHtml: {
+    description: "Set the inner HTML of a template node (raw HTML embed).",
+    schema: [{
+      nodeId: "String",
+      html: "String"
+    }],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateHtml } = await import("./updateHtml-EJFF2LPA.js");
+      updateHtml(state.ref(["nodes"]), args.nodeId, args.html);
+      return { id: args.nodeId };
+    }
+  },
+  // ── Route params ────────────────────────────────────────────────────────────
+  addRouteParam: {
+    description: "Add a route parameter to a frame route (e.g. an :id segment). Set key to name it; optional marks it optional.",
+    schema: [{
+      nodeId: "String",
+      key: "String?",
+      optional: "Boolean?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_frame", key: "id" }, description: "Add an :id param to the route" }
+    ],
+    returns: "{ id: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addParamToRoute } = await import("./addParamToRoute-Q6Z5A6RQ.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, key, optional } = args;
+      addParamToRoute(nodes, nodeId);
+      const params = nodes.get([nodeId, "route", "params"]) ?? [];
+      const index = params.length - 1;
+      if (key !== void 0 || optional !== void 0) {
+        nodes.set([nodeId, "route", "params", index], {
+          key: key ?? null,
+          optional: optional ?? false
+        });
+      }
+      return { id: nodeId, index };
+    }
+  },
+  removeRouteParam: {
+    description: "Remove a route parameter from a frame route by index.",
+    schema: [{
+      nodeId: "String",
+      index: "Number"
+    }],
+    returns: "{ id: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeParamFromRoute } = await import("./removeParamFromRoute-IMXTBRSZ.js");
+      removeParamFromRoute(state.ref(["nodes"]), args.nodeId, args.index);
+      return { id: args.nodeId, index: args.index };
+    }
+  }
+}));
+
+// ../ai-tools/operations/tokenOperations.js
+var tokenOperations = defineAiOperations("token", (useContext) => ({
+  create: {
+    description: 'Create a design token. path is the token name (e.g. "color/primary"), type is the token kind (color, dimension, fontFamily, etc.), value is the CSS value. Reference tokens in styles via the slugged path (slashes/dots become dashes): path "color/primary" \u2192 var(--color-primary).',
+    mcpName: "create_token",
+    schema: [{
+      path: "String",
+      value: "String",
+      type: "String?"
+    }],
+    examples: [
+      { args: { path: "color/primary", value: "#3B82F6", type: "color" }, description: "Create a primary color token" },
+      { args: { path: "spacing/lg", value: "24px", type: "dimension" }, description: "Create a spacing token" }
+    ],
+    returns: "{ id: String, path: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addToken } = await import("./addToken-2G5DPV5Z.js");
+      const tokens = state.ref(["tokens"]);
+      const { path, value, type } = args;
+      const id = addToken(tokens, {
+        $path: path,
+        $value: value,
+        ...type !== void 0 ? { $type: type } : {}
+      });
+      return { id, path };
+    }
+  },
+  update: {
+    description: "Update a design token. changes may include path, value, or type.",
+    mcpName: "update_token",
+    schema: [{
+      tokenId: "String",
+      changes: "Object"
+    }],
+    examples: [
+      { args: { tokenId: "tk_abc", changes: { value: "#EF4444" } }, description: "Change a token value" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateToken } = await import("./updateToken-DMJBW7ZK.js");
+      const tokens = state.ref(["tokens"]);
+      const { tokenId, changes = {} } = args;
+      const mapped = {};
+      if (changes.path !== void 0) mapped.$path = changes.path;
+      if (changes.value !== void 0) mapped.$value = changes.value;
+      if (changes.type !== void 0) mapped.$type = changes.type;
+      updateToken(tokens, tokenId, mapped);
+      return { id: tokenId };
+    }
+  },
+  delete: {
+    description: "Delete a design token by id.",
+    mcpName: "delete_token",
+    schema: [{
+      tokenId: "String"
+    }],
+    examples: [
+      { args: { tokenId: "tk_abc" }, description: "Delete a token" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeToken } = await import("./removeToken-EDVBR3OL.js");
+      const tokens = state.ref(["tokens"]);
+      removeToken(tokens, args.tokenId);
+      return { id: args.tokenId };
+    }
+  }
+}));
+
+// ../ai-tools/operations/storeOperations.js
+function coerceValue(value, type) {
+  if (value === void 0 || value === null) return value;
+  if (typeof value !== "string") return value;
+  switch (type) {
+    case "number":
+      return value === "" ? 0 : Number(value);
+    case "boolean":
+      return value === "true" || value === "1";
+    case "array":
+    case "object":
+      if (!value || value === "") return type === "array" ? [] : {};
+      try {
+        return JSON.parse(value);
+      } catch {
+        return type === "array" ? [] : {};
+      }
+    default:
+      return value;
+  }
+}
+function resolveIndex(list, { key, name, index }) {
+  const label = key ?? name;
+  if (label !== void 0) {
+    return list.findIndex((item) => (item.key ?? item.name) === label);
+  }
+  return index ?? -1;
+}
+var storeOperations = defineAiOperations("store", (useContext) => ({
+  // ── Stores ──────────────────────────────────────────────────────────────
+  create: {
+    description: "Create a data store. Stores hold reactive values, computed properties, and actions that nodes can bind to (via repeat, model, render, or {{expressions}}). The store id is its name. Optionally pass state/computed/actions arrays to seed the store in one call. Store actions and computed use this for state (e.g. function () { this.items = []; }), not a context first argument.",
+    alias: "createStore",
+    mcpName: "create_store",
+    schema: [{
+      name: "String",
+      state: "Array?",
+      computed: "Array?",
+      actions: "Array?"
+    }],
+    examples: [
+      {
+        args: {
+          name: "todo",
+          state: [
+            { key: "newText", type: "string", value: "" },
+            { key: "items", type: "array", value: [] }
+          ],
+          actions: [
+            { name: "addTodo", code: 'function () { const text = this.newText.trim(); if (!text) return; this.items = [...this.items, { text, done: false }]; this.newText = ""; }' }
+          ]
+        },
+        description: "Create a todo store with state and actions in one call"
+      }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { validateStorePayload } = await import("./validateStorePayload-HE65PPAB.js");
+      const { addStore } = await import("./addStore-SR7UK24M.js");
+      const { createValue } = await import("./createValue-SL4Y3LPI.js");
+      const { createComputed } = await import("./createComputed-KKULWYID.js");
+      const { createAction } = await import("./createAction-N6UW7YDP.js");
+      validateStorePayload(args);
+      const stores = state.ref(["stores"]);
+      const id = addStore(stores, args.name);
+      if (args.state?.length) {
+        stores.set([id, "state"], args.state.map((item) => createValue({
+          key: item.key,
+          type: item.type,
+          value: coerceValue(item.value, item.type)
+        })));
+      }
+      if (args.computed?.length) {
+        stores.set([id, "computed"], args.computed.map((item) => createComputed({
+          name: item.name,
+          code: item.code
+        })));
+      }
+      if (args.actions?.length) {
+        stores.set([id, "actions"], args.actions.map((item) => createAction({
+          name: item.name,
+          code: item.code
+        })));
+      }
+      return { id };
+    }
+  },
+  remove: {
+    description: "Remove a data store and everything in it.",
+    alias: "removeStore",
+    schema: [{
+      storeId: "String"
+    }],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeStore } = await import("./removeStore-UJA67G3O.js");
+      removeStore(state.ref(["stores"]), args.storeId);
+      return { id: args.storeId };
+    }
+  },
+  // ── Values (reactive state) ─────────────────────────────────────────────
+  addValue: {
+    description: "Add a reactive value to a store. key is the value name, type is string/number/boolean/array/object, value is the initial value.",
+    mcpName: "add_store_value",
+    schema: [{
+      storeId: "String",
+      key: "String?",
+      type: "String?",
+      value: "String?"
+    }],
+    examples: [
+      { args: { storeId: "cart", key: "items", type: "array", value: "[]" }, description: "Add an items array to the cart store" }
+    ],
+    returns: "{ storeId: String, key: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addValue } = await import("./addValue-UYM36PD7.js");
+      const { updateValue } = await import("./updateValue-6FPRH4CG.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, key, type, value } = args;
+      addValue(stores, storeId, type);
+      const list = stores.get([storeId, "state"]) ?? [];
+      const index = 0;
+      const current = list[index];
+      if (key !== void 0 || value !== void 0) {
+        const resolvedType = type ?? current.type;
+        updateValue(stores, storeId, index, {
+          key: key ?? current.key,
+          type: resolvedType,
+          value: coerceValue(value ?? current.value, resolvedType)
+        });
+      }
+      return { storeId, key: key ?? current.key, index };
+    }
+  },
+  updateValue: {
+    description: "Update a store value by key (or index). changes may include key, type, value.",
+    schema: [{
+      storeId: "String",
+      key: "String?",
+      index: "Number?",
+      changes: "Object"
+    }],
+    examples: [
+      { args: { storeId: "cart", key: "items", changes: { value: '[{"id":1}]' } }, description: "Set the items value" }
+    ],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateValue } = await import("./updateValue-6FPRH4CG.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, changes = {} } = args;
+      const list = stores.get([storeId, "state"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store value not found: ${args.key ?? args.index} in ${storeId}`);
+      const merged = { ...list[index], ...changes };
+      if (changes.value !== void 0) {
+        merged.value = coerceValue(merged.value, merged.type);
+      }
+      updateValue(stores, storeId, index, merged);
+      return { storeId, index };
+    }
+  },
+  removeValue: {
+    description: "Remove a store value by key (or index).",
+    schema: [{
+      storeId: "String",
+      key: "String?",
+      index: "Number?"
+    }],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeValue } = await import("./removeValue-UPOTPB3T.js");
+      const stores = state.ref(["stores"]);
+      const list = stores.get([args.storeId, "state"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store value not found: ${args.key ?? args.index} in ${args.storeId}`);
+      removeValue(stores, args.storeId, index);
+      return { storeId: args.storeId, index };
+    }
+  },
+  // ── Computed ────────────────────────────────────────────────────────────
+  addComputed: {
+    description: "Add a computed property to a store. code is a function body string: function () { ... } with store state available on this (e.g. this.items).",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      code: "String?"
+    }],
+    examples: [
+      { args: { storeId: "cart", name: "total", code: "function () { return this.items.reduce((s, i) => s + i.price, 0); }" }, description: "Add a cart total computed" }
+    ],
+    returns: "{ storeId: String, name: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addComputed } = await import("./addComputed-N3SUFIVQ.js");
+      const { updateComputed } = await import("./updateComputed-7QBBBXFC.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, name, code } = args;
+      addComputed(stores, storeId);
+      const list = stores.get([storeId, "computed"]) ?? [];
+      const index = 0;
+      const current = list[index];
+      if (name !== void 0 || code !== void 0) {
+        updateComputed(stores, storeId, index, {
+          name: name ?? current.name,
+          code: code ?? current.code
+        });
+      }
+      return { storeId, name: name ?? current.name, index };
+    }
+  },
+  updateComputed: {
+    description: "Update a store computed property by name (or index). changes may include name, code.",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      index: "Number?",
+      changes: "Object"
+    }],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateComputed } = await import("./updateComputed-7QBBBXFC.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, changes = {} } = args;
+      const list = stores.get([storeId, "computed"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store computed not found: ${args.name ?? args.index} in ${storeId}`);
+      updateComputed(stores, storeId, index, { ...list[index], ...changes });
+      return { storeId, index };
+    }
+  },
+  removeComputed: {
+    description: "Remove a store computed property by name (or index).",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      index: "Number?"
+    }],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeComputed } = await import("./removeComputed-5J772TBY.js");
+      const stores = state.ref(["stores"]);
+      const list = stores.get([args.storeId, "computed"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store computed not found: ${args.name ?? args.index} in ${args.storeId}`);
+      removeComputed(stores, args.storeId, index);
+      return { storeId: args.storeId, index };
+    }
+  },
+  // ── Actions ─────────────────────────────────────────────────────────────
+  addAction: {
+    description: "Add an action to a store. code is a function body string: function () { ... } that can read and mutate store values via this (e.g. this.items).",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      code: "String?"
+    }],
+    examples: [
+      { args: { storeId: "cart", name: "clear", code: "function () { this.items = []; }" }, description: "Add a clear-cart action" }
+    ],
+    returns: "{ storeId: String, name: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addAction } = await import("./addAction-UV7MSISB.js");
+      const { updateAction } = await import("./updateAction-6KYOHLA3.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, name, code } = args;
+      addAction(stores, storeId);
+      const list = stores.get([storeId, "actions"]) ?? [];
+      const index = 0;
+      const current = list[index];
+      if (name !== void 0 || code !== void 0) {
+        updateAction(stores, storeId, index, {
+          name: name ?? current.name,
+          code: code ?? current.code
+        });
+      }
+      return { storeId, name: name ?? current.name, index };
+    }
+  },
+  updateAction: {
+    description: "Update a store action by name (or index). changes may include name, code.",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      index: "Number?",
+      changes: "Object"
+    }],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateAction } = await import("./updateAction-6KYOHLA3.js");
+      const stores = state.ref(["stores"]);
+      const { storeId, changes = {} } = args;
+      const list = stores.get([storeId, "actions"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store action not found: ${args.name ?? args.index} in ${storeId}`);
+      updateAction(stores, storeId, index, { ...list[index], ...changes });
+      return { storeId, index };
+    }
+  },
+  removeAction: {
+    description: "Remove a store action by name (or index).",
+    schema: [{
+      storeId: "String",
+      name: "String?",
+      index: "Number?"
+    }],
+    returns: "{ storeId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeAction } = await import("./removeAction-4PGYJ6CA.js");
+      const stores = state.ref(["stores"]);
+      const list = stores.get([args.storeId, "actions"]) ?? [];
+      const index = resolveIndex(list, args);
+      if (index < 0) throw new Error(`store action not found: ${args.name ?? args.index} in ${args.storeId}`);
+      removeAction(stores, args.storeId, index);
+      return { storeId: args.storeId, index };
+    }
+  }
+}));
+
+// ../ai-tools/operations/animationOperations.js
+var animationOperations = defineAiOperations("animation", (useContext) => ({
+  create: {
+    description: 'Create an animation asset. keyframes is a Web Animations API keyframe array (e.g. [{ opacity: 0 }, { opacity: 1 }]). scope is "project" (reusable) or "node". Bind it to nodes with animation:bind.',
+    mcpName: "create_animation",
+    schema: [{
+      name: "String",
+      keyframes: "Array",
+      duration: "Number?",
+      easing: "String?",
+      iterations: "Number?",
+      fill: "String?",
+      scope: "String?"
+    }],
+    examples: [
+      {
+        args: { name: "Fade In", keyframes: [{ opacity: 0 }, { opacity: 1 }], duration: 400, easing: "ease-out", scope: "project" },
+        description: "Create a reusable fade-in animation"
+      }
+    ],
+    returns: "{ id: String, name: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { createAnimation } = await import("./createAnimation-RIBXIT62.js");
+      const { createAnimationId } = await import("./id-WBHG2QOH.js");
+      const animations2 = state.ref(["animations"]);
+      const { name, keyframes, duration, easing, iterations, fill, scope } = args;
+      const id = createAnimationId();
+      animations2.set([id], createAnimation({
+        name,
+        keyframes,
+        duration,
+        easing,
+        iterations,
+        fill,
+        scope: scope ?? "project"
+      }));
+      return { id, name };
+    }
+  },
+  update: {
+    description: "Update an animation asset. changes may include name, keyframes, duration, easing, iterations, fill, direction, delay.",
+    schema: [{
+      animationId: "String",
+      changes: "Object"
+    }],
+    examples: [
+      { args: { animationId: "anim_abc", changes: { duration: 600 } }, description: "Slow an animation down" }
+    ],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const animations2 = state.ref(["animations"]);
+      const { animationId, changes = {} } = args;
+      const current = animations2.get([animationId]);
+      if (!current) throw new Error(`animation not found: ${animationId}`);
+      for (const [key, value] of Object.entries(changes)) {
+        animations2.set([animationId, key], value);
+      }
+      return { id: animationId };
+    }
+  },
+  delete: {
+    description: "Delete an animation asset by id. Does not remove bindings that reference it.",
+    schema: [{
+      animationId: "String"
+    }],
+    returns: "{ id: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const animations2 = state.ref(["animations"]);
+      animations2.set([args.animationId], null);
+      return { id: args.animationId };
+    }
+  },
+  bind: {
+    description: 'Bind an animation to a node. play is the trigger: "mount", "click", "hover", etc. Set reverse to a trigger to play backwards on that event.',
+    mcpName: "bind_animation",
+    schema: [{
+      nodeId: "String",
+      animationId: "String",
+      play: "String?",
+      reverse: "String?"
+    }],
+    examples: [
+      { args: { nodeId: "nd_hero", animationId: "anim_abc", play: "mount" }, description: "Fade the hero in on mount" }
+    ],
+    returns: "{ nodeId: String, animationId: String, index: Number }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { addAnimationBinding } = await import("./addAnimationBinding-M4VWTNNB.js");
+      const nodes = state.ref(["nodes"]);
+      const { nodeId, animationId, play, reverse } = args;
+      const binding = { id: animationId, play: play ?? "mount" };
+      if (reverse !== void 0) binding.reverse = reverse;
+      addAnimationBinding(nodes, nodeId, binding);
+      return { nodeId, animationId };
+    }
+  },
+  unbind: {
+    description: "Remove an animation binding from a node by animation id.",
+    schema: [{
+      nodeId: "String",
+      animationId: "String"
+    }],
+    returns: "{ nodeId: String, animationId: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { removeAnimationBinding } = await import("./removeAnimationBinding-3SYE7FD3.js");
+      removeAnimationBinding(state.ref(["nodes"]), args.nodeId, args.animationId);
+      return { nodeId: args.nodeId, animationId: args.animationId };
+    }
+  },
+  updateBinding: {
+    description: "Update an animation binding on a node by animation id. binding may include play, reverse, or id.",
+    schema: [{
+      nodeId: "String",
+      animationId: "String",
+      binding: "Object"
+    }],
+    returns: "{ nodeId: String, animationId: String }",
+    handler: async (args) => {
+      const state = useContext("state");
+      const { updateAnimationBinding } = await import("./updateAnimationBinding-SENX3Z5S.js");
+      updateAnimationBinding(state.ref(["nodes"]), args.nodeId, args.animationId, args.binding);
+      return { nodeId: args.nodeId, animationId: args.animationId };
+    }
+  }
+}));
+
+// ../ai-tools/operations/main.js
+var allOperations = [
+  nodeOperations,
+  treeOperations,
+  behaviorOperations,
+  tokenOperations,
+  storeOperations,
+  animationOperations
+];
+
+// ../animation-library/src/categories/entrance.js
+var entrance = {
+  jui_fadeIn: {
+    name: "Fade In",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 600,
+    easing: "ease",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0" } },
+      { offset: 1, properties: { opacity: "1" } }
+    ]
+  },
+  jui_fadeInUp: {
+    name: "Fade In Up",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 600,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateY(30px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateY(0)" } }
+    ]
+  },
+  jui_fadeInDown: {
+    name: "Fade In Down",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 600,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateY(-30px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateY(0)" } }
+    ]
+  },
+  jui_slideInLeft: {
+    name: "Slide In Left",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateX(-60px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateX(0)" } }
+    ]
+  },
+  jui_slideInRight: {
+    name: "Slide In Right",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateX(60px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateX(0)" } }
+    ]
+  },
+  jui_slideInUp: {
+    name: "Slide In Up",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateY(60px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateY(0)" } }
+    ]
+  },
+  jui_slideInDown: {
+    name: "Slide In Down",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "translateY(-60px)" } },
+      { offset: 1, properties: { opacity: "1", transform: "translateY(0)" } }
+    ]
+  },
+  jui_scaleIn: {
+    name: "Scale In",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "scale(0.8)" } },
+      { offset: 1, properties: { opacity: "1", transform: "scale(1)" } }
+    ]
+  },
+  jui_zoomIn: {
+    name: "Zoom In",
+    category: "entrance",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "0", transform: "scale(0.3)" } },
+      { offset: 1, properties: { opacity: "1", transform: "scale(1)" } }
+    ]
+  }
+};
+
+// ../animation-library/src/categories/exit.js
+var exit = {
+  jui_fadeOut: {
+    name: "Fade Out",
+    category: "exit",
+    defaultPlay: "mount",
+    duration: 600,
+    easing: "ease",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1" } },
+      { offset: 1, properties: { opacity: "0" } }
+    ]
+  },
+  jui_fadeOutDown: {
+    name: "Fade Out Down",
+    category: "exit",
+    defaultPlay: "mount",
+    duration: 600,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1", transform: "translateY(0)" } },
+      { offset: 1, properties: { opacity: "0", transform: "translateY(30px)" } }
+    ]
+  },
+  jui_slideOutLeft: {
+    name: "Slide Out Left",
+    category: "exit",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1", transform: "translateX(0)" } },
+      { offset: 1, properties: { opacity: "0", transform: "translateX(-60px)" } }
+    ]
+  },
+  jui_slideOutRight: {
+    name: "Slide Out Right",
+    category: "exit",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1", transform: "translateX(0)" } },
+      { offset: 1, properties: { opacity: "0", transform: "translateX(60px)" } }
+    ]
+  },
+  jui_scaleOut: {
+    name: "Scale Out",
+    category: "exit",
+    defaultPlay: "mount",
+    duration: 500,
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+    fill: "forwards",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1", transform: "scale(1)" } },
+      { offset: 1, properties: { opacity: "0", transform: "scale(0.8)" } }
+    ]
+  }
+};
+
+// ../animation-library/src/categories/emphasis.js
+var emphasis = {
+  jui_pulse: {
+    name: "Pulse",
+    category: "emphasis",
+    defaultPlay: "pointerenter",
+    defaultReset: "pointerleave",
+    duration: 1e3,
+    easing: "ease-in-out",
+    fill: "none",
+    keyframes: [
+      { offset: 0, properties: { transform: "scale(1)" } },
+      { offset: 0.5, properties: { transform: "scale(1.05)" } },
+      { offset: 1, properties: { transform: "scale(1)" } }
+    ]
+  },
+  jui_bounce: {
+    name: "Bounce",
+    category: "emphasis",
+    defaultPlay: "pointerenter",
+    defaultReset: "pointerleave",
+    duration: 800,
+    easing: "cubic-bezier(0.28, 0.84, 0.42, 1)",
+    fill: "none",
+    keyframes: [
+      { offset: 0, properties: { transform: "translateY(0)" } },
+      { offset: 0.2, properties: { transform: "translateY(0)" } },
+      { offset: 0.4, properties: { transform: "translateY(-20px)" } },
+      { offset: 0.5, properties: { transform: "translateY(0)" } },
+      { offset: 0.6, properties: { transform: "translateY(-10px)" } },
+      { offset: 0.8, properties: { transform: "translateY(0)" } },
+      { offset: 1, properties: { transform: "translateY(0)" } }
+    ]
+  },
+  jui_shake: {
+    name: "Shake",
+    category: "emphasis",
+    defaultPlay: "pointerenter",
+    defaultReset: "pointerleave",
+    duration: 600,
+    easing: "ease-in-out",
+    fill: "none",
+    keyframes: [
+      { offset: 0, properties: { transform: "translateX(0)" } },
+      { offset: 0.1, properties: { transform: "translateX(-8px)" } },
+      { offset: 0.2, properties: { transform: "translateX(8px)" } },
+      { offset: 0.3, properties: { transform: "translateX(-8px)" } },
+      { offset: 0.4, properties: { transform: "translateX(8px)" } },
+      { offset: 0.5, properties: { transform: "translateX(-4px)" } },
+      { offset: 0.6, properties: { transform: "translateX(4px)" } },
+      { offset: 0.7, properties: { transform: "translateX(-2px)" } },
+      { offset: 0.8, properties: { transform: "translateX(2px)" } },
+      { offset: 1, properties: { transform: "translateX(0)" } }
+    ]
+  }
+};
+
+// ../animation-library/src/categories/attention.js
+var attention = {
+  jui_flash: {
+    name: "Flash",
+    category: "attention",
+    defaultPlay: "pointerenter",
+    defaultReset: "pointerleave",
+    duration: 800,
+    easing: "ease-in-out",
+    fill: "none",
+    keyframes: [
+      { offset: 0, properties: { opacity: "1" } },
+      { offset: 0.25, properties: { opacity: "0" } },
+      { offset: 0.5, properties: { opacity: "1" } },
+      { offset: 0.75, properties: { opacity: "0" } },
+      { offset: 1, properties: { opacity: "1" } }
+    ]
+  },
+  jui_heartbeat: {
+    name: "Heartbeat",
+    category: "attention",
+    defaultPlay: "pointerenter",
+    defaultReset: "pointerleave",
+    duration: 1200,
+    easing: "ease-in-out",
+    fill: "none",
+    keyframes: [
+      { offset: 0, properties: { transform: "scale(1)" } },
+      { offset: 0.14, properties: { transform: "scale(1.3)" } },
+      { offset: 0.28, properties: { transform: "scale(1)" } },
+      { offset: 0.42, properties: { transform: "scale(1.3)" } },
+      { offset: 0.7, properties: { transform: "scale(1)" } },
+      { offset: 1, properties: { transform: "scale(1)" } }
+    ]
+  }
+};
+
+// ../animation-library/src/main.js
+var animations = { ...entrance, ...exit, ...emphasis, ...attention };
+
+// src/modes/design/bootstrap.js
+var createDesignBootstrap = ({ port = null, config = {}, token = null, portProvider = null, handles = null } = {}) => new Promise(async (resolve, reject) => {
+  try {
+    if (!port) throw new Error("[stage/design] MessagePort is required");
+    const { loadProjectMain } = await import("./react-GONY7QDQ.js");
+    await loadProjectMain();
+    const sources = (await import("/components.js"))?.default ?? {};
+    const $app = initializeNode(config.$el || "app");
+    const $temp = initializeNode("temp");
+    const $components = initializeNode("components");
+    const viewport = getViewport();
+    const state = R.create().install(f, Ledger, a, f2, r);
+    const engine = G.create({ state }).install(
+      SceneCompiler.configure(config),
+      AiOperations,
+      T,
+      s.configure({
+        url: typeof window !== "undefined" ? window.location.origin : `http://localhost:${config.port}`,
+        options: {
+          path: "/socket.io",
+          transports: ["websocket", "polling"]
+        }
+      }),
+      PageLifecycle.configure({
+        visibility: true,
+        focus: false,
+        freeze: true,
+        sleepDetection: { enabled: true, threshold: 1e4 }
+      }),
+      ContentEditor
+    );
+    engine.cache.load({ config, token, $app, $temp, $components, viewport });
+    engine.sceneCompiler.loadPrototypes(PROTOTYPES);
+    engine.sceneCompiler.loadSources(sources);
+    engine.aiOps.use(...allOperations);
+    engine.socket.create();
+    let hasLoaded = false;
+    engine.socket.get().on("studio:load", async (scene) => {
+      normalizeSceneViewportKinds(scene);
+      if (hasLoaded) {
+        engine.state.load(scene);
+        engine.sceneCompiler.forceNodeGraph();
+        return;
+      }
+      hasLoaded = true;
+      engine.state.load(scene);
+      engine.state.history.start();
+      setTimeout(() => engine.state.history.onCommit((changes) => engine.socket.get().emit("server:commit:changes", changes)), 0);
+      await engine.sceneCompiler.create("app", "app");
+      await engine.sceneCompiler.create("temp", "temp", { mode: "temp" });
+      await engine.sceneCompiler.create("components", "components", { mode: "components" });
+    });
+    engine.socket.get().on("stage:changes:apply", (changes) => engine.state.apply(changes));
+    engine.state.onChange.addListener((changes) => engine.socket.get().emit("server:broadcast:changes", changes));
+    if (handles) {
+      handles.reconnect = (newPort) => engine.channel.connect(newPort);
+    }
+    if (portProvider) engine.channel.portProvider(portProvider);
+    const channel = await engine.channel.connect(port);
+    if (channel) {
+      const { nodeGraphContracts } = await import("./nodeGraph-GGV7TAPQ.js");
+      const { historyContracts } = await import("./history-KTZZH7TG.js");
+      const { userContracts } = await import("./user-MDIKS6ZN.js");
+      const { assetsContracts } = await import("./assets-24YGC7SD.js");
+      const { aiContracts } = await import("./aiRelay-RULC7GEA.js");
+      const { contentEditorContracts } = await import("./contentEditor-HE34KY6R.js");
+      const { viewportContracts } = await import("./viewport-DKL3EJOU.js");
+      const { contracts: nodeContracts } = await import("./main-Y7QHSAW7.js");
+      const { contracts: animationContracts } = await import("./main-IVVVSUSO.js");
+      const { contracts: tokenContracts } = await import("./main-EMRULEYO.js");
+      const { contracts: storeContracts } = await import("./main-YSWDZAGN.js");
+      channel.use(
+        viewportContracts,
+        nodeGraphContracts,
+        historyContracts,
+        userContracts,
+        assetsContracts,
+        aiContracts,
+        contentEditorContracts,
+        ...nodeContracts,
+        ...animationContracts,
+        ...tokenContracts,
+        ...storeContracts
+      );
+      re(() => engine.state.get(["nodes"]), (nodes) => {
+        if (!nodes) return;
+        const componentsIds = Object.keys(nodes).filter((id) => nodes[id]?.type === "component");
+        const meta = [...engine.sceneCompiler.getMeta()];
+        for (const id of componentsIds) {
+          const node = nodes[id];
+          meta.push({
+            displayName: node.name || id,
+            category: "local",
+            keywords: [node.name, "component"],
+            library: null,
+            tagName: id
+          });
+        }
+        engine.channel.to("editor").publish("components:set", meta);
+      });
+      re(() => engine.state.get(["tokens"]), (tokens) => {
+        engine.channel.to("editor").publish("tokens:set", tokens ?? {});
+        engine.channel.to("panel-tokens").publish("token:set", tokens ?? {});
+      });
+      re(() => engine.state.get(["stores"]), (stores) => {
+        engine.channel.to("editor").publish("stores:set", stores ?? {});
+      });
+      re(() => engine.state.get(["assets"]), (assets) => {
+        engine.channel.to("editor").publish("assets:set", assets);
+      });
+      re(() => engine.state.get(["libraryClassNames"]), (classNames) => {
+        engine.channel.to("editor").publish("libraryClassNames:set", classNames ?? []);
+      });
+      re(() => {
+        const animations2 = engine.state.get(["animations"]);
+        if (!animations2) return null;
+        return Object.entries(animations2).filter(([, node]) => node !== null && node !== void 0).map(([id, node]) => ({ id, ...node }));
+      }, (animations2) => {
+        engine.channel.to("editor").publish("animations:set", animations2 ?? []);
+      });
+      engine.sceneCompiler.addNodeGraphListener((graph, removed, isFullSync) => {
+        if (isFullSync) {
+          channel.to("renderWorker", "editor").publish("nodeGraph:set", graph);
+        } else {
+          channel.to("renderWorker", "editor").publish("nodeGraph:update", graph, removed);
+        }
+        engine.sceneCompiler.projectPuppetJsx(["app"]);
+      });
+      engine.channel.to("editor").publish("elements:set", elements);
+      engine.channel.to("editor").publish("frames:set", palette);
+      engine.channel.to("editor").publish("graphics:set", palette2);
+      engine.channel.to("editor").publish("globalAnimations:set", animations);
+      engine.channel.to("editor").publish("components:set", engine.sceneCompiler.getMeta());
+      const initialAssets = engine.state.get(["assets"]);
+      if (initialAssets) {
+        engine.channel.to("editor").publish("assets:set", initialAssets);
+      }
+      engine.sceneCompiler.startNodeGraph();
+      engine.pageLifecycle.on("hidden", () => {
+        engine.sceneCompiler.pauseNodeGraph();
+      });
+      engine.pageLifecycle.on("visible", () => {
+        engine.sceneCompiler.forceNodeGraph();
+      });
+      engine.pageLifecycle.on("resume", () => {
+        const socket = engine.socket.get();
+        if (socket.disconnected) socket.connect();
+        engine.sceneCompiler.forceNodeGraph();
+      });
+      engine.channel.onEnable(() => {
+        channel.to("renderWorker").publish("nodeGraph:remove");
+        const graph = engine.sceneCompiler.getNodeGraph();
+        channel.to("renderWorker", "editor").publish("nodeGraph:set", graph);
+        const viewport2 = engine.sceneCompiler.getViewport();
+        const selectedRids = engine.sceneCompiler.getSelectedRids();
+        const focalRid = engine.sceneCompiler.getFocalRid();
+        channel.to("renderWorker").publish("viewport:set", viewport2);
+        channel.to("renderWorker").publish("selection:rids:set", selectedRids);
+        channel.to("renderWorker").publish("selection:focalRid:set", focalRid);
+      });
+      channel.subscribe("selection:rids:set", (rids) => {
+        engine.sceneCompiler.setSelectedRids(rids);
+      });
+      channel.subscribe("selection:focalRid:set", (rid) => {
+        engine.sceneCompiler.setFocalRid(rid || null);
+      });
+      channel.subscribe("animation:preview:play", (animationId, nodeIds) => {
+        for (const nodeId of nodeIds) {
+          const result = engine.sceneCompiler.animate(nodeId, animationId, { fill: "none" });
+          const anims = Array.isArray(result) ? result : result ? [result] : [];
+          for (const anim of anims) {
+            anim.addEventListener("finish", () => {
+              channel.to("editor").publish("animation:preview:finished", animationId);
+            }, { once: true });
+          }
+        }
+      });
+      channel.subscribe("animation:preview:stop", (animationId, nodeIds) => {
+        for (const nodeId of nodeIds) {
+          engine.sceneCompiler.cancelAnimation(nodeId, animationId);
+        }
+      });
+      channel.subscribe("animation:preview:seek", (animationId, timeMs) => {
+        engine.sceneCompiler.seekAnimation(animationId, timeMs);
+      });
+      engine.socket.get().on("stage:relay:user:connected", (id, user) => channel.to("renderWorker").publish("user:connected", id, user));
+      engine.socket.get().on("stage:relay:user:disconnected", (id) => channel.to("renderWorker").publish("user:disconnected", id));
+      engine.socket.get().on("stage:relay:user:update", (id, user) => channel.to("renderWorker").publish("user:update", id, user));
+      engine.socket.get().on("stage:relay:users:set", (users) => channel.to("renderWorker").publish("user:setAll", users));
+      engine.socket.get().on("stage:relay:asset:uploaded", (asset) => engine.channel.to("editor").publish("asset:uploaded", asset));
+      engine.socket.get().on("stage:screenshot:capture", async () => {
+        console.log("[screenshot:relay] capture requested");
+        try {
+          const nodes = engine.state.get(["nodes"]);
+          const appChildren = nodes?.app?.children ?? [];
+          const frameEntries = appChildren.filter((id) => nodes[id]?.type === "frame").map((id) => ({ id, name: nodes[id].name || id, bounds: nodes[id].bounds }));
+          console.log(`[screenshot:relay] found ${frameEntries.length} frames:`, frameEntries.map((f4) => f4.name));
+          const baseConfig = engine.cache.get(["config"]);
+          const frames = [];
+          for (const frame of frameEntries) {
+            console.log(`[screenshot:relay] capturing frame "${frame.name}" (${frame.id})`);
+            const opts = {
+              config: {
+                basePath: baseConfig.basePath ?? `http://localhost:${baseConfig.port}`,
+                view: "screen-capture",
+                env: "dev",
+                nodeId: frame.id
+              },
+              width: frame.bounds?.width ?? 1440,
+              height: frame.bounds?.height ?? 900,
+              result: "base64"
+            };
+            const result = await channel.to("electronMain").request("screenCapture:capture", opts);
+            console.log(`[screenshot:relay] captured frame "${frame.name}" \u2014 ${result?.base64?.length ?? 0} chars`);
+            frames.push({
+              id: frame.id,
+              name: frame.name,
+              imageData: `data:image/png;base64,${result.base64}`
+            });
+          }
+          console.log(`[screenshot:relay] emitting ${frames.length} frames to server`);
+          engine.socket.get().emit("server:screenshot:result", { frames });
+        } catch (error) {
+          console.error("[screenshot:relay] failed:", error);
+          engine.socket.get().emit("server:screenshot:result", { error: error.message });
+        }
+      });
+      resolve(config);
+    } else {
+      reject(new Error("Stage channel failed to connect"));
+    }
+  } catch (error) {
+    reject(error);
+  }
+});
+export {
+  createDesignBootstrap
+};