@momoyu-ink/kit 0.4.1 → 0.5.0

package/dist/lib.mjs

@@ -0,0 +1,1534 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  MoyuRenderer: () => MoyuRenderer,
+  OverlayParamsContext: () => OverlayParamsContext,
+  PageParamsContext: () => PageParamsContext,
+  StageContextProvider: () => StageContextProvider,
+  a: () => animated,
+  addEventListener: () => addEventListener,
+  animated: () => animated,
+  autoState: () => autoState,
+  createBubbleEvent: () => createBubbleEvent,
+  createRoot: () => createRoot,
+  createStackNavigator: () => createStackNavigator,
+  createStage: () => createStage,
+  createStaticNavigation: () => createStaticNavigation,
+  executeNodeCommand: () => executeNodeCommand,
+  executePluginCommand: () => executePluginCommand,
+  getNavigator: () => getNavigator,
+  getStageSize: () => getStageSize,
+  globalEventListeners: () => globalEventListeners,
+  globalRequestAnimationFrameListeners: () => globalRequestAnimationFrameListeners,
+  moyu: () => moyu_exports,
+  nextLine: () => nextLine,
+  setDefaultAutoTailMs: () => setDefaultAutoTailMs,
+  setWaiting: () => setWaiting,
+  skipState: () => skipState,
+  useAutoBlocker: () => useAutoBlocker,
+  useAutoTicket: () => useAutoTicket,
+  useBeforeHandleCommandCallback: () => useBeforeHandleCommandCallback,
+  useFadeIn: () => useFadeIn,
+  useFadeInOut: () => useFadeInOut,
+  useFadeOut: () => useFadeOut,
+  useInterruptCallback: () => useInterruptCallback,
+  useIsAutoing: () => useIsAutoing,
+  useIsSkipping: () => useIsSkipping,
+  useNavigation: () => useNavigation,
+  useNavigationParams: () => useNavigationParams,
+  useNavigationState: () => useNavigationState,
+  useScenario: () => useScenario,
+  useSkipBlocker: () => useSkipBlocker,
+  useSkipCallback: () => useSkipCallback,
+  useSoundEffect: () => useSoundEffect,
+  useStageContext: () => useStageContext
+});
+
+// src/react.ts
+import React from "react";
+import Reconciler from "react-reconciler";
+import { DefaultEventPriority, NoEventPriority } from "react-reconciler/constants.js";
+
+// src/moyu.ts
+var moyu_exports = {};
+__export(moyu_exports, {
+  addChild: () => addChild,
+  createInstance: () => createInstance,
+  destroyInstance: () => destroyInstance,
+  executeNodeCommand: () => executeNodeCommand,
+  executePluginCommand: () => executePluginCommand,
+  insertChild: () => insertChild,
+  insertChildBefore: () => insertChildBefore,
+  removeChild: () => removeChild,
+  removeChildAt: () => removeChildAt,
+  updateProps: () => updateProps
+});
+function createInstance(nodeType, label, props) {
+  let node_id = 0;
+  const ret = moyu.pushCommand("create_instance", [nodeType, label, props], (id) => {
+    node_id = id;
+  });
+  if (ret) {
+    return ret;
+  }
+  return node_id;
+}
+function destroyInstance(nodeId) {
+  moyu.pushCommand("destroy_instance", [nodeId]);
+}
+function addChild(nodeId, childNodeId) {
+  moyu.pushCommand("add_child", [nodeId, childNodeId]);
+}
+function insertChild(nodeId, index, childNodeId) {
+  moyu.pushCommand("insert_child", [nodeId, index, childNodeId]);
+}
+function insertChildBefore(nodeId, beforeChildNodeId, childNodeId) {
+  moyu.pushCommand("insert_child_before", [nodeId, beforeChildNodeId, childNodeId]);
+}
+function removeChildAt(nodeId, index) {
+  moyu.pushCommand("remove_child_at", [nodeId, index]);
+}
+function removeChild(nodeId, childNodeId) {
+  moyu.pushCommand("remove_child", [nodeId, childNodeId]);
+}
+function updateProps(nodeId, props) {
+  moyu.pushCommand("update_props", [nodeId, props]);
+}
+function executeNodeCommand(nodeId, payload) {
+  return moyu.executeNodeCommand(nodeId, payload);
+}
+function executePluginCommand(pluginName, payload) {
+  return moyu.executePluginCommand(pluginName, payload);
+}
+
+// src/state.ts
+var STATE = {
+  nodeMap: {},
+  touchMoved: {}
+};
+
+// src/node.ts
+var Node = class _Node {
+  nodeId;
+  label;
+  props = {};
+  listeners = {};
+  static create(label, type, props) {
+    const { children: _, ...rest } = props;
+    const node = new _Node();
+    node.label = label;
+    const [restProps, listeners] = filterProps(rest);
+    node.props = restProps;
+    node.listeners = listeners;
+    node.nodeId = createInstance(type, label, restProps);
+    STATE.nodeMap[node.nodeId] = node;
+    return node;
+  }
+  static rootNode() {
+    const node = new _Node();
+    node.label = "rootNode";
+    node.nodeId = 0;
+    return node;
+  }
+  addChild(child) {
+    addChild(this.nodeId, child.nodeId);
+  }
+  insertChild(_index, child) {
+    insertChild(this.nodeId, 0, child.nodeId);
+  }
+  insertChildBefore(beforeChild, child) {
+    insertChildBefore(this.nodeId, beforeChild.nodeId, child.nodeId);
+  }
+  // removeChildAt(index: number): Node | undefined {
+  //   return this.children.splice(index, 1)[0];
+  // }
+  removeChild(child) {
+    removeChild(this.nodeId, child.nodeId);
+    destroyInstance(child.nodeId);
+  }
+  updateProps(props) {
+    const [restProps, listeners] = filterProps(props);
+    Object.assign(this.props, restProps);
+    Object.assign(this.listeners, listeners);
+    if (Object.keys(restProps).length > 0) {
+      updateProps(this.nodeId, restProps);
+    }
+  }
+  executeCommand(payload) {
+    return executeNodeCommand(this.nodeId, payload);
+  }
+};
+function filterProps(props) {
+  const ret = {};
+  const listeners = {};
+  for (const key in props) {
+    if (key.startsWith("on")) {
+      listeners[key] = props[key];
+    } else {
+      ret[key] = props[key];
+    }
+  }
+  return [ret, listeners];
+}
+
+// src/react.ts
+var currentUpdatePriority = NoEventPriority;
+var hostConfig = {
+  isPrimaryRenderer: true,
+  supportsHydration: false,
+  supportsMutation: true,
+  supportsPersistence: false,
+  /**
+   * @required
+   */
+  createInstance(type, props, _root, _hostContext, _internalInstanceHandle) {
+    const node = Node.create(props.label ?? "", type, props);
+    return node;
+  },
+  /**
+   * throw if not supported
+   * @required
+   */
+  createTextInstance(_text, _rootContainerInstance, _hostContext, _internalInstanceHandle) {
+    throw new Error("Text nodes are not supported yet");
+  },
+  /**
+   * @required
+   */
+  appendInitialChild(parentInstance, child) {
+    parentInstance.addChild(child);
+  },
+  /**
+   * return true if needs `commitMount`
+   * @required
+   */
+  finalizeInitialChildren(_parentInstance, _type, _props, _rootContainerInstance, _hostContext) {
+    return true;
+  },
+  shouldSetTextContent(_type, _props) {
+    return false;
+  },
+  getRootHostContext: (_rootContainerInstance) => {
+    return {};
+  },
+  getChildHostContext(_parentHostContext, _type, _rootContainerInstance) {
+    return _parentHostContext;
+  },
+  getPublicInstance(node) {
+    return node;
+  },
+  prepareForCommit(_containerInfo) {
+    return null;
+  },
+  resetAfterCommit(_container) {
+  },
+  preparePortalMount: () => {
+  },
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: -1,
+  // optional
+  appendChild(parent, child) {
+    parent.addChild(child);
+  },
+  appendChildToContainer(container, child) {
+    container.addChild(child);
+  },
+  insertBefore: (parent, child, before) => {
+    parent.insertChildBefore(before, child);
+  },
+  insertInContainerBefore: (parent, child, before) => {
+    parent.insertChildBefore(before, child);
+  },
+  removeChild: (parent, child) => {
+    parent.removeChild(child);
+  },
+  removeChildFromContainer: (parent, child) => {
+    parent.removeChild(child);
+  },
+  finalizeContainerChildren: () => {
+  },
+  commitMount(_instance, _type, _props, _internalInstanceHandle) {
+  },
+  commitUpdate(instance, _type, prevProps, nextProps, _internalHandle) {
+    const { label: _oldLabel, children: _oldChildren, ...oldProps } = prevProps;
+    const { label, children, ...newProps } = nextProps;
+    const changedProps = {};
+    for (const key in newProps) {
+      if (newProps[key] !== oldProps[key]) {
+        changedProps[key] = newProps[key];
+      }
+    }
+    for (const key in oldProps) {
+      if (!(key in newProps)) {
+        changedProps[key] = null;
+      }
+    }
+    if (label !== _oldLabel) {
+      changedProps.label = label ?? null;
+    }
+    if (Object.keys(changedProps).length) {
+      instance.updateProps(changedProps);
+    }
+  },
+  commitTextUpdate: (_textInstance, _oldText, _newText) => {
+  },
+  clearContainer: (_container) => {
+  },
+  getInstanceFromNode(_node) {
+    console.error("getInstanceFromNode not implement");
+    throw new Error("Function not implemented.");
+  },
+  beforeActiveInstanceBlur: () => {
+    console.error("beforeActiveInstanceBlur not implement");
+  },
+  afterActiveInstanceBlur: () => {
+    console.error("afterActiveInstanceBlur not implement");
+  },
+  prepareScopeUpdate: (_scopeInstance, _instance) => {
+    console.error("prepareScopeUpdate not implement");
+  },
+  getInstanceFromScope: (_scopeInstance) => {
+    console.error("getInstanceFromScope not implement");
+    return null;
+  },
+  detachDeletedInstance: (_node) => {
+  },
+  NotPendingTransition: void 0,
+  // see https://github.com/pmndrs/react-three-fiber/blob/2541e81fb6ddc22d0869b9eb5cdbedcbbc62324c/packages/fiber/src/core/reconciler.tsx#L570
+  HostTransitionContext: /* @__PURE__ */ React.createContext(
+    null
+  ),
+  setCurrentUpdatePriority(newPriority) {
+    currentUpdatePriority = newPriority;
+  },
+  getCurrentUpdatePriority() {
+    return currentUpdatePriority;
+  },
+  resolveUpdatePriority() {
+    if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
+    return DefaultEventPriority;
+  },
+  resetFormInstance() {
+  },
+  requestPostPaintCallback() {
+  },
+  shouldAttemptEagerTransition: () => false,
+  trackSchedulerEvent: () => {
+  },
+  resolveEventType: () => null,
+  resolveEventTimeStamp: () => -1.1,
+  maySuspendCommit: () => false,
+  preloadInstance: () => true,
+  startSuspendingCommit() {
+  },
+  suspendInstance() {
+  },
+  waitForCommitToBeReady: () => null
+};
+var MoyuRenderer = Reconciler(hostConfig);
+function createRoot(options) {
+  const rootNode = Node.rootNode();
+  const rootElement = MoyuRenderer.createContainer(
+    rootNode,
+    0,
+    null,
+    false,
+    false,
+    options?.identifierPrefix ?? "moyu",
+    options?.onUncaughtError ?? ((err) => {
+      console.error("uncaught error: ", err);
+    }),
+    options?.onCaughtError ?? ((err) => {
+      console.error("caught error: ", err);
+    }),
+    options?.onRecoverableError ?? ((err) => {
+      console.error("unrecoverable error: ", err);
+    }),
+    options?.onDefaultTransitionIndicator ?? (() => {
+    })
+  );
+  MoyuRenderer.injectIntoDevTools({
+    bundleType: process.env.NODE_ENV === "production" ? 0 : 1,
+    version: "0.1.0",
+    rendererPackageName: "@momoyu-ink/kit",
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    findFiberByHostInstance: (instance) => {
+      return instance;
+    }
+  });
+  return {
+    render: (reactElement, callback) => {
+      return MoyuRenderer.updateContainer(reactElement, rootElement, null, callback);
+    }
+  };
+}
+
+// src/sandbox.ts
+var JS_GLOBAL_KEYS = new Set(Object.getOwnPropertyNames(globalThis));
+var JS_GLOBAL_KEYS_EXCLUDED = /* @__PURE__ */ new Set(["window", "globalThis", "ARCHIVE", "GLOBAL"]);
+JS_GLOBAL_KEYS_EXCLUDED.forEach((key) => JS_GLOBAL_KEYS.delete(key));
+var archiveVariables = new Proxy(
+  {},
+  {
+    get(_, key) {
+      if (typeof key === "string") {
+        return executePluginCommand("scenario", {
+          subCommand: "getVariable",
+          name: key
+        });
+      }
+      return void 0;
+    },
+    set(_, key, value) {
+      if (typeof key === "string") {
+        executePluginCommand("scenario", {
+          subCommand: "setVariable",
+          name: key,
+          value
+        });
+        return true;
+      }
+      return false;
+    }
+  }
+);
+var globalVariables = new Proxy(
+  {},
+  {
+    get(_, key) {
+      if (typeof key === "string") {
+        return executePluginCommand("scenario", {
+          subCommand: "getPermanentVariable",
+          key
+        });
+      }
+      return void 0;
+    },
+    set(_, key, value) {
+      if (typeof key === "string") {
+        executePluginCommand("scenario", {
+          subCommand: "setPermanentVariable",
+          key,
+          value
+        });
+        return true;
+      }
+      return false;
+    }
+  }
+);
+function safeEval(code, sandbox) {
+  const proxy3 = new Proxy(sandbox, {
+    has(target, key) {
+      if (typeof key === "string" && JS_GLOBAL_KEYS.has(key)) {
+        return false;
+      }
+      return key in target || key === "ARCHIVE" || key === "GLOBAL" || key === "window" || key === "globalThis";
+    },
+    get(target, key) {
+      if (key === "window" || key === "globalThis") return proxy3;
+      if (key === "ARCHIVE") return archiveVariables;
+      if (key === "GLOBAL") return globalVariables;
+      if (key === Symbol.unscopables) return void 0;
+      return target[key];
+    },
+    set(target, key, value) {
+      target[key] = value;
+      return true;
+    }
+  });
+  return new Function("sandbox", `with(sandbox) { return (${code}) }`).bind(proxy3)(proxy3);
+}
+globalThis.__moyu_eval_sandbox = (code) => {
+  try {
+    return safeEval(code, {});
+  } catch (err) {
+    console.error("Error evaluating code in sandbox:", err);
+    throw err;
+  }
+};
+
+// src/spring/index.ts
+var spring_exports = {};
+__export(spring_exports, {
+  a: () => animated,
+  animated: () => animated
+});
+import { createHost } from "@react-spring/animated";
+import { Globals, colors, createStringInterpolator } from "@react-spring/shared";
+
+// src/spring/primitives.ts
+var primitives = [
+  "container",
+  "sprite",
+  "text",
+  "clip",
+  "filter",
+  "backdrop",
+  "animation",
+  "video"
+];
+
+// src/spring/index.ts
+__reExport(spring_exports, core_star);
+import * as core_star from "@react-spring/core";
+Globals.assign({
+  createStringInterpolator,
+  colors,
+  frameLoop: "always",
+  requestAnimationFrame: (cb) => requestAnimationFrame(cb)
+});
+var host = createHost(primitives, {
+  applyAnimatedValues(instance, props) {
+    instance.updateProps(props);
+  }
+});
+var animated = host.animated;
+
+// src/lib.ts
+__reExport(lib_exports, spring_exports);
+
+// src/events/base.ts
+function createBubbleEvent(body, targetId) {
+  const event = {
+    ...body,
+    targetId,
+    currentTargetId: targetId,
+    stopPropagation: () => {
+      event.bubbles = false;
+    },
+    preventDefault: () => {
+      event.defaultPrevented = true;
+    },
+    defaultPrevented: false,
+    bubbles: true
+  };
+  return event;
+}
+
+// src/events/globals.ts
+var globalEventListeners = {};
+var globalRequestAnimationFrameListeners = [];
+var BUBBLE_EVENT_NAMES = ["mouseevent", "touchevent", "keyboardevent", "wheelevent"];
+globalThis.__moyu_receive_event = (raw_event) => {
+  const { name, body } = raw_event;
+  if (BUBBLE_EVENT_NAMES.includes(name)) {
+    handleBubbleEvent(name, body);
+  } else {
+    switch (name) {
+      case "customevent": {
+        const { name: name2, body: _body, targetId } = body;
+        if (targetId === 0) {
+          for (const listener of globalEventListeners[name2.toLowerCase()] ?? []) {
+            listener(_body);
+          }
+          return;
+        }
+        STATE.nodeMap[targetId]?.listeners?.[`on${name2.charAt(0).toUpperCase() + name2.slice(1)}`]?.(_body);
+        return;
+      }
+      case "nodeevent": {
+        const { kind, targetId } = body;
+        if (kind === "Destory") {
+          delete STATE.nodeMap[targetId];
+        }
+        return;
+      }
+      case "animationframecallbackevent": {
+        const listeners = globalRequestAnimationFrameListeners.splice(0);
+        const { timestamp } = body;
+        for (const listener of listeners) {
+          listener?.(timestamp);
+        }
+        return;
+      }
+      default: {
+        globalEventListeners[name]?.forEach((listener) => void listener(body));
+        return;
+      }
+    }
+  }
+};
+function handleBubbleEvent(name, body) {
+  const event = createBubbleEvent(body, body.targetId);
+  const { kind, bubbleTargetIds } = body;
+  if (body.targetId !== 0) {
+    const node = STATE.nodeMap[body.targetId];
+    if (!node) {
+      return;
+    }
+    if (["mouseevent", "keyboardevent", "wheelevent"].includes(name)) {
+      node?.listeners?.[`on${kind}`]?.(event);
+      while (event.bubbles && bubbleTargetIds.length) {
+        event.currentTargetId = bubbleTargetIds.pop();
+        event.currentTargetLabel = STATE.nodeMap[event.currentTargetId]?.label;
+        STATE.nodeMap[event.currentTargetId]?.listeners?.[`on${kind}`]?.(event);
+      }
+    } else if (name === "touchevent") {
+      const { identifier } = body;
+      event.identifier = identifier;
+      node?.listeners?.[`on${kind}`]?.(event);
+      {
+        const _bubbleTargetIds = [...bubbleTargetIds];
+        while (event.bubbles && _bubbleTargetIds.length) {
+          event.currentTargetId = _bubbleTargetIds.pop();
+          event.currentTargetLabel = STATE.nodeMap[event.currentTargetId]?.label;
+          STATE.nodeMap[event.currentTargetId]?.listeners?.[`on${kind}`]?.(event);
+        }
+      }
+      if (kind === "TouchStart") {
+        STATE.touchMoved[identifier] = false;
+      } else if (kind === "TouchMove") {
+        STATE.touchMoved[identifier] = true;
+      } else if (kind === "TouchEnd" || kind === "TouchCancel") {
+        delete STATE.touchMoved[identifier];
+      }
+    }
+  }
+  if (event.bubbles) {
+    for (const listener of globalEventListeners[kind.toLowerCase()] ?? []) {
+      listener(event);
+    }
+  }
+}
+if (globalThis.__moyu_native) {
+  globalThis.requestAnimationFrame = (callback) => {
+    return globalRequestAnimationFrameListeners.push(callback) - 1;
+  };
+  globalThis.cancelAnimationFrame = (handle) => {
+    globalRequestAnimationFrameListeners.splice(handle, 1);
+  };
+}
+
+// src/events/listener.ts
+function addEventListener(name, callback) {
+  if (!globalEventListeners[name]) {
+    globalEventListeners[name] = [];
+  }
+  globalEventListeners[name].push(callback);
+  return () => {
+    globalEventListeners[name] = globalEventListeners[name].filter((cb) => cb !== callback);
+  };
+}
+
+// src/utils.ts
+function getStageSize() {
+  const stageSize = executePluginCommand("system", {
+    subCommand: "getStageSize"
+  });
+  return stageSize;
+}
+
+// src/components/navigation.tsx
+import React2 from "react";
+import { createContext, useContext } from "react";
+import { proxy, useSnapshot } from "valtio";
+var PageParamsContext = createContext(void 0);
+var OverlayParamsContext = createContext(void 0);
+var overlayIdCounter = 0;
+var generateOverlayId = () => {
+  return `overlay-${++overlayIdCounter}-${Date.now()}`;
+};
+function validateParams(type, name, descriptor, params) {
+  if (!descriptor?.requiredParams) return;
+  const actualParams = params ?? {};
+  for (const key of descriptor.requiredParams) {
+    if (actualParams[key] === void 0) {
+      throw new Error(
+        `Navigation Error: Missing required parameter "${key}" for ${type} "${name}". Expected: { ${descriptor.requiredParams.join(", ")} }`
+      );
+    }
+  }
+}
+var globalNavigator = null;
+function normalizeDescriptor(config) {
+  if (typeof config === "function" || config.$$typeof) {
+    return { component: config };
+  }
+  return config;
+}
+function createStackNavigator(options) {
+  const normalizedPages = {};
+  for (const [key, config] of Object.entries(options.pages)) {
+    normalizedPages[key] = normalizeDescriptor(config);
+  }
+  const normalizedOverlays = {};
+  if (options.overlays) {
+    for (const [key, config] of Object.entries(options.overlays)) {
+      normalizedOverlays[key] = normalizeDescriptor(config);
+    }
+  }
+  const navigationState = proxy({
+    currentPage: options.initialPage,
+    pageParams: {},
+    overlayStack: [],
+    overlayParams: {}
+  });
+  const navigator = {
+    navigate: (page, params) => {
+      if (!normalizedPages[page]) {
+        console.error(`Navigation Error: Page "${page}" not found in navigator configuration.`);
+        return;
+      }
+      validateParams("page", page, normalizedPages[page], params);
+      navigationState.currentPage = page;
+      if (params !== void 0) {
+        navigationState.pageParams[page] = params;
+      } else {
+        delete navigationState.pageParams[page];
+      }
+    },
+    goBack: () => {
+      console.warn("goBack() not implemented yet");
+    },
+    pushOverlay: (overlay, params) => {
+      if (!normalizedOverlays[overlay]) {
+        console.error(`Navigation Error: Overlay "${overlay}" not found in navigator configuration.`);
+        return;
+      }
+      validateParams("overlay", overlay, normalizedOverlays[overlay], params);
+      const id = generateOverlayId();
+      const overlayInfo = { type: overlay, id };
+      navigationState.overlayStack.push(overlayInfo);
+      if (params !== void 0) {
+        navigationState.overlayParams[id] = params;
+      }
+    },
+    popOverlay: () => {
+      const overlay = navigationState.overlayStack.pop();
+      if (overlay) {
+        delete navigationState.overlayParams[overlay.id];
+      }
+    },
+    clearOverlays: () => {
+      for (const overlay of navigationState.overlayStack) {
+        delete navigationState.overlayParams[overlay.id];
+      }
+      navigationState.overlayStack = [];
+    },
+    getCurrentPage: () => {
+      return navigationState.currentPage;
+    },
+    getParams: () => {
+      return navigationState.pageParams[navigationState.currentPage];
+    },
+    getOverlayStack: () => {
+      return [...navigationState.overlayStack];
+    },
+    isOverlayActive: (type) => {
+      return navigationState.overlayStack.some((overlay) => overlay.type === type);
+    },
+    _descriptors: {
+      pages: normalizedPages,
+      overlays: normalizedOverlays
+    },
+    _state: navigationState
+  };
+  globalNavigator = navigator;
+  return navigator;
+}
+function createStaticNavigation(navigator) {
+  return () => {
+    const navState = useSnapshot(navigator._state);
+    const { pages, overlays } = navigator._descriptors;
+    const pageDescriptor = pages[navState.currentPage];
+    const Page = pageDescriptor?.component || (() => null);
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(PageParamsContext.Provider, { value: navState.pageParams[navState.currentPage] }, /* @__PURE__ */ React2.createElement(Page, null)), navState.overlayStack.map((overlay) => {
+      const overlayDescriptor = overlays[overlay.type];
+      const OverlayComponent = overlayDescriptor?.component || (() => null);
+      return /* @__PURE__ */ React2.createElement(OverlayParamsContext.Provider, { key: overlay.id, value: navState.overlayParams[overlay.id] }, /* @__PURE__ */ React2.createElement(OverlayComponent, null));
+    }));
+  };
+}
+function getNavigator() {
+  if (!globalNavigator) {
+    throw new Error("Navigator not initialized. Call createStackNavigator first.");
+  }
+  return globalNavigator;
+}
+var useNavigation = getNavigator;
+function useNavigationState() {
+  return useSnapshot(getNavigator()._state);
+}
+function useNavigationParams() {
+  const overlayParams = useContext(OverlayParamsContext);
+  const pageParams = useContext(PageParamsContext);
+  return overlayParams ?? pageParams ?? {};
+}
+
+// src/hooks/useFadeInOut.ts
+function useFadeInOut(inTime, _keepTime, _outTime, pause = false, onFinished) {
+  const [style, api] = (0, spring_exports.useSpring)(
+    () => ({
+      from: { opacity: 0 },
+      to: { opacity: 1 },
+      config: { duration: inTime },
+      pause,
+      onRest: (result) => {
+        if (result.value.opacity === 1) {
+          void api.start({ reverse: true, delay: 1500, config: { duration: 1e3 } });
+        } else {
+          onFinished?.();
+        }
+      }
+    }),
+    []
+  );
+  const skip = () => {
+    api.stop();
+    api.set({ opacity: 0 });
+    onFinished?.();
+  };
+  return [style, api, skip];
+}
+function useFadeIn(inTime, pause = false, onFinished) {
+  const [style, api] = (0, spring_exports.useSpring)(
+    () => ({
+      from: { opacity: 0 },
+      to: { opacity: 1 },
+      config: { duration: inTime },
+      pause,
+      onRest: () => {
+        onFinished?.();
+      }
+    }),
+    []
+  );
+  const skip = () => {
+    api.stop();
+    api.set({ opacity: 1 });
+    onFinished?.();
+  };
+  return [style, api, skip];
+}
+function useFadeOut(outTime, pause = false, onFinished) {
+  const [style, api] = (0, spring_exports.useSpring)(
+    () => ({
+      from: { opacity: 1 },
+      to: { opacity: 0 },
+      config: { duration: outTime },
+      pause,
+      onRest: () => {
+        onFinished?.();
+      }
+    }),
+    []
+  );
+  const skip = () => {
+    api.stop();
+    api.set({ opacity: 1 });
+    onFinished?.();
+  };
+  return [style, api, skip];
+}
+
+// src/hooks/useScenario.ts
+import { useEffect } from "react";
+function nextLine() {
+  return executePluginCommand("scenario", { subCommand: "nextLine" });
+}
+function setWaiting(time, skippable) {
+  executePluginCommand("scenario", { subCommand: "setWaiting", time, skippable });
+}
+function useScenario(stories, startName, entryName, goNextOnLoad = false) {
+  useEffect(() => {
+    const loadScenario = async () => {
+      for (const story of stories) {
+        if (!story) continue;
+        try {
+          await executePluginCommand("scenario", {
+            subCommand: "addStory",
+            name: story
+          });
+        } catch (error) {
+          console.error(`Failed to load scenario:`, error);
+        }
+      }
+    };
+    void loadScenario().then(async () => {
+      try {
+        if (startName) {
+          await executePluginCommand("scenario", {
+            subCommand: "startStory",
+            name: startName,
+            entry: entryName
+          });
+        }
+        if (goNextOnLoad) {
+          await nextLine();
+        }
+      } catch (error) {
+        console.error(`Failed to start scenario ${startName}:`, error);
+      }
+    });
+    return () => {
+      executePluginCommand("scenario", {
+        subCommand: "terminateStory"
+      });
+    };
+  }, [stories, startName, entryName, goNextOnLoad]);
+}
+
+// src/hooks/useSoundEffect.ts
+import { useCallback, useEffect as useEffect2 } from "react";
+var LOADED_SOUNDS = /* @__PURE__ */ new Set();
+function useSoundEffect(src) {
+  useEffect2(() => {
+    const loadSound = async () => {
+      try {
+        await executePluginCommand("audio", {
+          subCommand: "load",
+          name: src,
+          src
+        });
+      } catch (error) {
+        console.error(`Failed to load sound effect ${src}:`, error);
+      }
+      LOADED_SOUNDS.add(src);
+    };
+    let needRelease = false;
+    if (!LOADED_SOUNDS.has(src)) {
+      void loadSound();
+      needRelease = true;
+    }
+    return () => {
+      const releaseSound = () => {
+        try {
+          executePluginCommand("audio", {
+            subCommand: "release",
+            name: src
+          });
+        } catch (error) {
+          console.error(`Failed to release sound effect ${src}:`, error);
+        }
+        LOADED_SOUNDS.delete(src);
+      };
+      if (needRelease) {
+        releaseSound();
+      }
+    };
+  }, [src]);
+  return useCallback(() => {
+    try {
+      executePluginCommand("audio", {
+        subCommand: "play",
+        name: src
+      });
+    } catch (error) {
+      console.error(`Failed to play sound effect ${src}:`, error);
+    }
+  }, [src]);
+}
+
+// src/hooks/useStage.ts
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect3, createElement, useCallback as useCallback2 } from "react";
+import { proxy as proxy2, useSnapshot as useSnapshot2 } from "valtio";
+var SKIP_INTERVAL_MS = 80;
+var autoRuntime = {
+  defaultTailMs: 0
+};
+var skipState = proxy2({ active: false });
+var autoState = proxy2({ active: false });
+function useIsSkipping() {
+  return useSnapshot2(skipState).active;
+}
+function useIsAutoing() {
+  return useSnapshot2(autoState).active;
+}
+function setDefaultAutoTailMs(ms) {
+  if (!Number.isFinite(ms)) {
+    autoRuntime.defaultTailMs = 0;
+    return;
+  }
+  autoRuntime.defaultTailMs = Math.max(0, ms);
+}
+function createStage() {
+  let commandSchema = null;
+  const commandHandlers = /* @__PURE__ */ new Map();
+  const textLineHandlers = [];
+  const skipCallbacks = [];
+  const interruptCallbacks = [];
+  const skipBlockers = [];
+  const autoBlockers = [];
+  const beforeHandleCommandCallbacks = [];
+  function addToRegistry(registry, item) {
+    registry.push(item);
+    return () => {
+      const idx = registry.indexOf(item);
+      if (idx !== -1) registry.splice(idx, 1);
+    };
+  }
+  function registerCommandSchema(schema) {
+    if (commandSchema !== null) {
+      console.warn("[Stage] Command schema is already registered \u2014 overwriting.");
+    }
+    commandSchema = schema;
+    return () => {
+      if (commandSchema === schema) {
+        commandSchema = null;
+      }
+    };
+  }
+  function registerCommand(commands, handler) {
+    const names = Array.isArray(commands) ? commands : [commands];
+    for (const name of names) {
+      if (commandHandlers.has(name)) {
+        console.warn(`[Stage] Command handler for "${name}" is already registered \u2014 overwriting.`);
+      }
+      commandHandlers.set(name, handler);
+    }
+    return () => {
+      for (const name of names) {
+        if (commandHandlers.get(name) === handler) {
+          commandHandlers.delete(name);
+        }
+      }
+    };
+  }
+  function registerTextLine(handler) {
+    return addToRegistry(textLineHandlers, handler);
+  }
+  function addSkipCallback(cb) {
+    return addToRegistry(skipCallbacks, cb);
+  }
+  function addInterruptCallback(cb) {
+    return addToRegistry(interruptCallbacks, cb);
+  }
+  function tryInterrupt() {
+    for (const cb of interruptCallbacks) {
+      try {
+        if (cb()) return true;
+      } catch (err) {
+        console.error("Error in interrupt callback:", err);
+      }
+    }
+    return false;
+  }
+  function addSkipBlocker(cb) {
+    return addToRegistry(skipBlockers, cb);
+  }
+  function isAnyBlockerActive() {
+    for (const cb of skipBlockers) {
+      try {
+        if (cb()) return true;
+      } catch (err) {
+        console.error("Error in skip blocker callback:", err);
+      }
+    }
+    return false;
+  }
+  function addAutoBlocker(cb) {
+    return addToRegistry(autoBlockers, cb);
+  }
+  function isAnyAutoBlockerActive() {
+    for (const cb of autoBlockers) {
+      try {
+        if (cb()) return true;
+      } catch (err) {
+        console.error("Error in auto blocker callback:", err);
+      }
+    }
+    return false;
+  }
+  function addBeforeHandleCommandCallback(cb) {
+    return addToRegistry(beforeHandleCommandCallbacks, cb);
+  }
+  let _skipTimer = null;
+  let _autoTimer = null;
+  let _autoBarrier = null;
+  let _autoResumeTimer = null;
+  let _autoCollectFrame = null;
+  let _autoBarrierSeq = 0;
+  let _autoTicketSeq = 0;
+  const _pendingAutoTickets = /* @__PURE__ */ new Map();
+  function clearAutoResumeTimer() {
+    if (_autoResumeTimer !== null) {
+      clearTimeout(_autoResumeTimer);
+      _autoResumeTimer = null;
+    }
+  }
+  function clearAutoCollectFrame() {
+    if (_autoCollectFrame !== null) {
+      cancelAnimationFrame(_autoCollectFrame);
+      _autoCollectFrame = null;
+    }
+  }
+  function clearAutoBarrier() {
+    clearAutoCollectFrame();
+    clearAutoResumeTimer();
+    _autoBarrier = null;
+  }
+  function clearPendingAutoTickets() {
+    _pendingAutoTickets.clear();
+  }
+  function getActiveAutoBarrier(barrierId) {
+    if (_autoBarrier === null || _autoBarrier.id !== barrierId) {
+      return null;
+    }
+    return _autoBarrier;
+  }
+  function scheduleAutoResume(barrierId, delayMs) {
+    clearAutoResumeTimer();
+    const safeDelayMs = Number.isFinite(delayMs) ? Math.max(0, delayMs) : 0;
+    _autoResumeTimer = setTimeout(() => {
+      _autoResumeTimer = null;
+      if (!autoState.active) return;
+      if (_autoBarrier === null || _autoBarrier.id !== barrierId) return;
+      _autoBarrier = null;
+      void nextLine();
+    }, safeDelayMs);
+  }
+  function trySettleAutoBarrier(barrier) {
+    if (barrier.collecting || barrier.settled) return;
+    const activeTickets = [...barrier.tickets.values()].filter((ticket) => !ticket.canceled);
+    const hasPending = activeTickets.some((ticket) => ticket.doneAt === null);
+    if (hasPending) return;
+    const latestTicketReadyAt = activeTickets.reduce((maxReadyAt, ticket) => {
+      const ticketReadyAt = (ticket.doneAt ?? barrier.openedAt) + ticket.tailMs;
+      return Math.max(maxReadyAt, ticketReadyAt);
+    }, barrier.fallbackReadyAt);
+    barrier.settled = true;
+    scheduleAutoResume(barrier.id, latestTicketReadyAt - Date.now());
+  }
+  function closeAutoCollection(barrierId) {
+    const barrier = getActiveAutoBarrier(barrierId);
+    if (barrier === null || barrier.settled) return;
+    barrier.collecting = false;
+    trySettleAutoBarrier(barrier);
+  }
+  function scheduleAutoCollectionClose(barrierId) {
+    queueMicrotask(() => {
+      const barrier = getActiveAutoBarrier(barrierId);
+      if (barrier === null || barrier.settled) return;
+      _autoCollectFrame = requestAnimationFrame(() => {
+        _autoCollectFrame = null;
+        closeAutoCollection(barrierId);
+      });
+    });
+  }
+  function markAutoTicketDone(ticket) {
+    if (ticket.canceled || ticket.doneAt !== null) return;
+    ticket.doneAt = Date.now();
+    if (ticket.barrierId === null) return;
+    const barrier = getActiveAutoBarrier(ticket.barrierId);
+    if (barrier === null || barrier.settled) return;
+    trySettleAutoBarrier(barrier);
+  }
+  function cancelAutoTicket(ticket) {
+    if (ticket.canceled) return;
+    ticket.canceled = true;
+    if (ticket.barrierId === null) {
+      _pendingAutoTickets.delete(ticket.id);
+      return;
+    }
+    const barrier = getActiveAutoBarrier(ticket.barrierId);
+    if (barrier === null || barrier.settled) return;
+    trySettleAutoBarrier(barrier);
+  }
+  function createAutoTicketHandle(ticket) {
+    return {
+      done() {
+        markAutoTicketDone(ticket);
+      },
+      cancel() {
+        cancelAutoTicket(ticket);
+      }
+    };
+  }
+  function schedulePendingAutoTicketExpiry(ticketId) {
+    queueMicrotask(() => {
+      requestAnimationFrame(() => {
+        _pendingAutoTickets.delete(ticketId);
+      });
+    });
+  }
+  function createPendingAutoTicket(options) {
+    const ticketId = ++_autoTicketSeq;
+    const ticket = {
+      id: ticketId,
+      label: options?.label,
+      tailMs: options?.tailMs ?? autoRuntime.defaultTailMs,
+      doneAt: null,
+      canceled: false,
+      barrierId: null
+    };
+    _pendingAutoTickets.set(ticketId, ticket);
+    schedulePendingAutoTicketExpiry(ticketId);
+    return createAutoTicketHandle(ticket);
+  }
+  function adoptPendingAutoTickets(barrier) {
+    for (const [ticketId, ticket] of _pendingAutoTickets) {
+      _pendingAutoTickets.delete(ticketId);
+      if (ticket.canceled) continue;
+      ticket.barrierId = barrier.id;
+      barrier.tickets.set(ticketId, ticket);
+    }
+  }
+  function openAutoBarrier(reason, fallbackMs) {
+    const safeFallbackMs = Number.isFinite(fallbackMs) ? Math.max(0, fallbackMs) : 0;
+    clearAutoBarrier();
+    _autoBarrier = {
+      id: ++_autoBarrierSeq,
+      reason,
+      collecting: true,
+      openedAt: Date.now(),
+      fallbackReadyAt: Date.now() + safeFallbackMs,
+      tickets: /* @__PURE__ */ new Map(),
+      settled: false
+    };
+    adoptPendingAutoTickets(_autoBarrier);
+    scheduleAutoCollectionClose(_autoBarrier.id);
+  }
+  function issueAutoTicket(options) {
+    if (!autoState.active) {
+      return null;
+    }
+    if (_autoBarrier === null) {
+      return createPendingAutoTicket(options);
+    }
+    if (!_autoBarrier.collecting || _autoBarrier.settled) {
+      return null;
+    }
+    const ticketId = ++_autoTicketSeq;
+    const ticket = {
+      id: ticketId,
+      label: options?.label,
+      tailMs: options?.tailMs ?? autoRuntime.defaultTailMs,
+      doneAt: null,
+      canceled: false,
+      barrierId: _autoBarrier.id
+    };
+    _autoBarrier.tickets.set(ticketId, ticket);
+    return createAutoTicketHandle(ticket);
+  }
+  function scheduleAutoNextLine() {
+    if (_autoTimer !== null) clearTimeout(_autoTimer);
+    _autoTimer = setTimeout(() => {
+      _autoTimer = null;
+      if (!autoState.active) return;
+      if (isAnyAutoBlockerActive()) {
+        stopAuto();
+        return;
+      }
+      if (_autoBarrier === null) {
+        void nextLine();
+      }
+    }, autoRuntime.defaultTailMs);
+  }
+  function scheduleSkipNextLine() {
+    if (_skipTimer !== null) clearTimeout(_skipTimer);
+    _skipTimer = setTimeout(() => {
+      _skipTimer = null;
+      if (skipState.active) nextLine();
+    }, SKIP_INTERVAL_MS);
+  }
+  function startSkip() {
+    if (skipState.active) return;
+    if (isAnyBlockerActive()) return;
+    skipState.active = true;
+    invokeSkipCallbacks();
+    tryInterrupt();
+    scheduleSkipNextLine();
+  }
+  function stopSkip() {
+    skipState.active = false;
+    if (_skipTimer !== null) {
+      clearTimeout(_skipTimer);
+      _skipTimer = null;
+      nextLine();
+    }
+  }
+  function isSkipping() {
+    return skipState.active;
+  }
+  function startAuto() {
+    if (autoState.active) return;
+    if (isAnyAutoBlockerActive()) return;
+    autoState.active = true;
+    tryInterrupt();
+    scheduleAutoNextLine();
+  }
+  function stopAuto() {
+    autoState.active = false;
+    if (_autoTimer !== null) {
+      clearTimeout(_autoTimer);
+      _autoTimer = null;
+    }
+    clearAutoBarrier();
+    clearPendingAutoTickets();
+  }
+  function isAutoing() {
+    return autoState.active;
+  }
+  function buildControl() {
+    let handled = false;
+    let unskippableFlag = false;
+    const control = {
+      setWaiting(time, skippable) {
+        handled = true;
+        if (skipState.active) {
+          invokeSkipCallbacks();
+          scheduleSkipNextLine();
+        } else if (autoState.active) {
+          if (isAnyAutoBlockerActive()) {
+            stopAuto();
+            setWaiting(time, skippable);
+          } else {
+            openAutoBarrier("wait", time);
+          }
+        } else {
+          setWaiting(time, skippable);
+        }
+      },
+      hold() {
+        handled = true;
+        if (skipState.active && !unskippableFlag) {
+          if (isAnyBlockerActive()) {
+            stopSkip();
+          } else {
+            scheduleSkipNextLine();
+          }
+        } else if (skipState.active && unskippableFlag) {
+          stopSkip();
+        } else if (autoState.active) {
+          if (isAnyAutoBlockerActive()) {
+            stopAuto();
+          } else {
+            openAutoBarrier("hold", 0);
+          }
+        }
+      },
+      nextLine() {
+        handled = true;
+        void nextLine();
+      },
+      unskippable() {
+        unskippableFlag = true;
+      },
+      record(meta) {
+        const result = executePluginCommand("scenario", {
+          subCommand: "record",
+          meta
+        });
+        if (result && typeof result.then === "function") {
+          throw new Error("Scenario record command unexpectedly returned a Promise");
+        }
+        return result;
+      }
+    };
+    return { control, wasHandled: () => handled };
+  }
+  function transformCommand(command) {
+    if (commandSchema === null) {
+      throw new Error("No command schema registered in Stage");
+    }
+    const parsed = commandSchema.safeParse({
+      command: command.command,
+      ...Object.fromEntries(command.arguments.map((arg) => [arg.name, arg.value]))
+    });
+    if (!parsed.success) {
+      throw new Error(`Invalid command: ${command.command} with arguments ${JSON.stringify(command.arguments)}`);
+    }
+    return parsed.data;
+  }
+  function dispatchCommand(e) {
+    for (const cb of beforeHandleCommandCallbacks) {
+      try {
+        cb(e);
+      } catch (err) {
+        console.error("Error in beforeHandleCommand callback:", err);
+      }
+    }
+    let cmd;
+    try {
+      cmd = transformCommand(e);
+    } catch (err) {
+      console.error("Failed to transform scenario command:", err);
+      void nextLine();
+      return;
+    }
+    const handler = commandHandlers.get(cmd.command);
+    if (!handler) {
+      console.warn(`[Stage] No handler registered for command "${cmd.command}". Auto-advancing.`);
+      void nextLine();
+      return;
+    }
+    const { control, wasHandled } = buildControl();
+    handler(cmd, control);
+    if (!wasHandled()) {
+      void nextLine();
+    }
+  }
+  function dispatchTextLine(e) {
+    const { control, wasHandled } = buildControl();
+    for (const handler of textLineHandlers) {
+      handler(e, control);
+    }
+    if (!wasHandled()) {
+      void nextLine();
+    }
+  }
+  function invokeSkipCallbacks() {
+    for (const cb of skipCallbacks) {
+      try {
+        cb();
+      } catch (err) {
+        console.error("Error in skip callback:", err);
+      }
+    }
+  }
+  function bindEvents() {
+    const cleanups = [
+      addEventListener("scenariocommandline", (e) => {
+        dispatchCommand(e);
+      }),
+      addEventListener("scenariotext", (e) => {
+        dispatchTextLine(e);
+      }),
+      addEventListener("scenariowaiting", () => {
+        console.log("still waiting...");
+      }),
+      addEventListener("scenariowaitingcancelled", () => {
+        invokeSkipCallbacks();
+      })
+    ];
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  }
+  return {
+    registerCommandSchema,
+    registerCommand,
+    registerTextLine,
+    addSkipCallback,
+    addInterruptCallback,
+    addSkipBlocker,
+    addAutoBlocker,
+    addBeforeHandleCommandCallback,
+    issueAutoTicket,
+    tryInterrupt,
+    startSkip,
+    stopSkip,
+    isSkipping,
+    startAuto,
+    stopAuto,
+    isAutoing,
+    bindEvents
+  };
+}
+var StageContext = createContext2(null);
+function useStageContext() {
+  const ctx = useContext2(StageContext);
+  if (!ctx) throw new Error("useStageContext must be used within StageContextProvider");
+  return ctx;
+}
+function StageContextProvider({ stage, children }) {
+  useEffect3(() => {
+    return stage.bindEvents();
+  }, [stage]);
+  return createElement(StageContext.Provider, { value: stage }, children);
+}
+function useSkipCallback(callback) {
+  const stage = useStageContext();
+  useEffect3(() => {
+    return stage.addSkipCallback(callback);
+  }, [stage, callback]);
+}
+function useInterruptCallback(callback) {
+  const stage = useStageContext();
+  useEffect3(() => {
+    return stage.addInterruptCallback(callback);
+  }, [stage, callback]);
+}
+function useSkipBlocker(callback) {
+  const stage = useStageContext();
+  useEffect3(() => {
+    return stage.addSkipBlocker(callback);
+  }, [stage, callback]);
+}
+function useAutoBlocker(callback) {
+  const stage = useStageContext();
+  useEffect3(() => {
+    return stage.addAutoBlocker(callback);
+  }, [stage, callback]);
+}
+function useAutoTicket() {
+  const stage = useStageContext();
+  return useCallback2(
+    (options) => {
+      return stage.issueAutoTicket(options);
+    },
+    [stage]
+  );
+}
+function useBeforeHandleCommandCallback(callback) {
+  const stage = useStageContext();
+  useEffect3(() => {
+    return stage.addBeforeHandleCommandCallback(callback);
+  }, [stage, callback]);
+}
+
+// src/lib.ts
+export * from "@react-spring/core";
+export {
+  MoyuRenderer,
+  OverlayParamsContext,
+  PageParamsContext,
+  StageContextProvider,
+  animated as a,
+  addEventListener,
+  animated,
+  autoState,
+  createBubbleEvent,
+  createRoot,
+  createStackNavigator,
+  createStage,
+  createStaticNavigation,
+  executeNodeCommand,
+  executePluginCommand,
+  getNavigator,
+  getStageSize,
+  globalEventListeners,
+  globalRequestAnimationFrameListeners,
+  moyu_exports as moyu,
+  nextLine,
+  setDefaultAutoTailMs,
+  setWaiting,
+  skipState,
+  useAutoBlocker,
+  useAutoTicket,
+  useBeforeHandleCommandCallback,
+  useFadeIn,
+  useFadeInOut,
+  useFadeOut,
+  useInterruptCallback,
+  useIsAutoing,
+  useIsSkipping,
+  useNavigation,
+  useNavigationParams,
+  useNavigationState,
+  useScenario,
+  useSkipBlocker,
+  useSkipCallback,
+  useSoundEffect,
+  useStageContext
+};