@momoyu-ink/kit 0.2.0 → 0.4.0

package/dist/hooks/useStage.d.ts

@@ -1,5 +1,5 @@
 import { ZodType } from 'zod';
-import { TextLine } from '../events';
+import { ResolvedCommandLine, TextLine } from '../events';
 /** Flow control interface passed to every handler. */
 export interface GameControl {
     /** Timed wait — blocks auto-advance. Engine fires scenariowaitingcancelled on timeout or skip. */
@@ -10,6 +10,8 @@ export interface GameControl {
     nextLine(): void;
     /** Mark this dispatch cycle as unskippable. If skipping, hold() will stop skip instead of advancing. */
     unskippable(): void;
+    /** Record the current runtime snapshot for backlog usage. */
+    record(meta: Record<string, any>): string;
 }
 export interface ScenarioCommandBaseType {
     command: string;
@@ -19,12 +21,28 @@ export interface ScenarioCommandBaseType {
 export type CommandHandler<T extends ScenarioCommandBaseType = ScenarioCommandBaseType> = (cmd: T, control: GameControl) => void;
 /** Text line handler function. */
 export type TextLineHandler = (text: TextLine, control: GameControl) => void;
+export interface AutoTicketOptions {
+    label?: string;
+    tailMs?: number;
+}
+export interface AutoTicketHandle {
+    done(): void;
+    cancel(): void;
+}
 /** Reactive skip state. Actors read via useIsSkipping(). */
 export declare const skipState: {
     active: boolean;
 };
+/** Reactive auto state. Actors read via useIsAutoing(). */
+export declare const autoState: {
+    active: boolean;
+};
 /** Reactively returns whether skip (Ctrl fast-forward) is active. */
 export declare function useIsSkipping(): boolean;
+/** Reactively returns whether auto mode is active. */
+export declare function useIsAutoing(): boolean;
+/** Set the default tail delay in milliseconds for newly created auto tickets. */
+export declare function setDefaultAutoTailMs(ms: number): void;
 export declare function createStage(): {
     registerCommandSchema: <T extends ZodType>(schema: T) => () => void;
     registerCommand: <T extends ScenarioCommandBaseType>(commands: string | string[], handler: CommandHandler<T>) => () => void;
@@ -32,11 +50,16 @@ export declare function createStage(): {
     addSkipCallback: (cb: () => void) => () => void;
     addInterruptCallback: (cb: () => boolean) => () => void;
     addSkipBlocker: (cb: () => boolean) => () => void;
-    addBeforeHandleCommandCallback: (cb: () => void) => () => void;
+    addAutoBlocker: (cb: () => boolean) => () => void;
+    addBeforeHandleCommandCallback: (cb: (upcomingCommand: ResolvedCommandLine) => void) => () => void;
+    issueAutoTicket: (options?: AutoTicketOptions) => AutoTicketHandle | null;
     tryInterrupt: () => boolean;
     startSkip: () => void;
     stopSkip: () => void;
     isSkipping: () => boolean;
+    startAuto: () => void;
+    stopAuto: () => void;
+    isAutoing: () => boolean;
     bindEvents: () => () => void;
 };
 export type StageInstance = ReturnType<typeof createStage>;
@@ -52,11 +75,16 @@ export declare function StageContextProvider({ stage, children }: {
     addSkipCallback: (cb: () => void) => () => void;
     addInterruptCallback: (cb: () => boolean) => () => void;
     addSkipBlocker: (cb: () => boolean) => () => void;
-    addBeforeHandleCommandCallback: (cb: () => void) => () => void;
+    addAutoBlocker: (cb: () => boolean) => () => void;
+    addBeforeHandleCommandCallback: (cb: (upcomingCommand: ResolvedCommandLine) => void) => () => void;
+    issueAutoTicket: (options?: AutoTicketOptions) => AutoTicketHandle | null;
     tryInterrupt: () => boolean;
     startSkip: () => void;
     stopSkip: () => void;
     isSkipping: () => boolean;
+    startAuto: () => void;
+    stopAuto: () => void;
+    isAutoing: () => boolean;
     bindEvents: () => () => void;
 } | null>>;
 /**
@@ -78,8 +106,21 @@ export declare function useInterruptCallback(callback: () => boolean): void;
  * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
  */
 export declare function useSkipBlocker(callback: () => boolean): void;
+/**
+ * Register an auto blocker callback. Return `true` to block auto mode.
+ * Automatically removed on unmount.
+ *
+ * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
+ */
+export declare function useAutoBlocker(callback: () => boolean): void;
+/**
+ * Get a function that issues an auto ticket for the current active barrier.
+ * Returns `null` when auto is inactive or the collection window has closed.
+ */
+export declare function useAutoTicket(): (options?: AutoTicketOptions) => AutoTicketHandle | null;
 /**
  * Register a callback to be invoked before handling each command.
+ * The callback receives the upcoming command object, allowing conditional logic.
  * Automatically removed on unmount.
  */
-export declare function useBeforeHandleCommandCallback(callback: () => void): void;
+export declare function useBeforeHandleCommandCallback(callback: (upcomingCommand: ResolvedCommandLine) => void): void;

package/dist/hooks/useStage.js

@@ -1,28 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skipState = void 0;
+exports.autoState = exports.skipState = void 0;
 exports.useIsSkipping = useIsSkipping;
+exports.useIsAutoing = useIsAutoing;
+exports.setDefaultAutoTailMs = setDefaultAutoTailMs;
 exports.createStage = createStage;
 exports.useStageContext = useStageContext;
 exports.StageContextProvider = StageContextProvider;
 exports.useSkipCallback = useSkipCallback;
 exports.useInterruptCallback = useInterruptCallback;
 exports.useSkipBlocker = useSkipBlocker;
+exports.useAutoBlocker = useAutoBlocker;
+exports.useAutoTicket = useAutoTicket;
 exports.useBeforeHandleCommandCallback = useBeforeHandleCommandCallback;
 const react_1 = require("react");
 const valtio_1 = require("valtio");
 const useScenario_1 = require("./useScenario");
 const events_1 = require("../events");
+const moyu_1 = require("../moyu");
 // ---------------------------------------------------------------------------
 // Skip state — independent valtio proxy (not serialized with game saves)
 // ---------------------------------------------------------------------------
 const SKIP_INTERVAL_MS = 5;
+const autoRuntime = {
+    defaultTailMs: 0,
+};
 /** Reactive skip state. Actors read via useIsSkipping(). */
 exports.skipState = (0, valtio_1.proxy)({ active: false });
+/** Reactive auto state. Actors read via useIsAutoing(). */
+exports.autoState = (0, valtio_1.proxy)({ active: false });
 /** Reactively returns whether skip (Ctrl fast-forward) is active. */
 function useIsSkipping() {
     return (0, valtio_1.useSnapshot)(exports.skipState).active;
 }
+/** Reactively returns whether auto mode is active. */
+function useIsAutoing() {
+    return (0, valtio_1.useSnapshot)(exports.autoState).active;
+}
+/** Set the default tail delay in milliseconds for newly created auto tickets. */
+function setDefaultAutoTailMs(ms) {
+    if (!Number.isFinite(ms)) {
+        autoRuntime.defaultTailMs = 0;
+        return;
+    }
+    autoRuntime.defaultTailMs = Math.max(0, ms);
+}
 // ---------------------------------------------------------------------------
 // createStage — module-level infrastructure
 // ---------------------------------------------------------------------------
@@ -34,8 +56,18 @@ function createStage() {
     const skipCallbacks = [];
     const interruptCallbacks = [];
     const skipBlockers = [];
+    const autoBlockers = [];
     const beforeHandleCommandCallbacks = [];
     // --- registration functions ---
+    /** Push `item` to `registry` and return a function that removes it. */
+    function addToRegistry(registry, item) {
+        registry.push(item);
+        return () => {
+            const idx = registry.indexOf(item);
+            if (idx !== -1)
+                registry.splice(idx, 1);
+        };
+    }
     /**
      * Register command schema.
      * Returns an unregister function.
@@ -76,24 +108,14 @@ function createStage() {
      * Returns an unregister function.
      */
     function registerTextLine(handler) {
-        textLineHandlers.push(handler);
-        return () => {
-            const idx = textLineHandlers.indexOf(handler);
-            if (idx !== -1)
-                textLineHandlers.splice(idx, 1);
-        };
+        return addToRegistry(textLineHandlers, handler);
     }
     /**
      * Add a skip callback (called when scenariowaitingcancelled fires).
      * Returns a remove function.
      */
     function addSkipCallback(cb) {
-        skipCallbacks.push(cb);
-        return () => {
-            const idx = skipCallbacks.indexOf(cb);
-            if (idx !== -1)
-                skipCallbacks.splice(idx, 1);
-        };
+        return addToRegistry(skipCallbacks, cb);
     }
     /**
      * Add an interrupt callback (called on user click, in order).
@@ -101,12 +123,7 @@ function createStage() {
      * Returns a remove function.
      */
     function addInterruptCallback(cb) {
-        interruptCallbacks.push(cb);
-        return () => {
-            const idx = interruptCallbacks.indexOf(cb);
-            if (idx !== -1)
-                interruptCallbacks.splice(idx, 1);
-        };
+        return addToRegistry(interruptCallbacks, cb);
     }
     /**
      * Try to interrupt: iterate through interrupt callbacks until one returns true.
@@ -130,12 +147,7 @@ function createStage() {
      * Returns a remove function.
      */
     function addSkipBlocker(cb) {
-        skipBlockers.push(cb);
-        return () => {
-            const idx = skipBlockers.indexOf(cb);
-            if (idx !== -1)
-                skipBlockers.splice(idx, 1);
-        };
+        return addToRegistry(skipBlockers, cb);
     }
     /** Returns true if any registered skip blocker is active. */
     function isAnyBlockerActive() {
@@ -150,19 +162,230 @@ function createStage() {
         }
         return false;
     }
+    /**
+     * Add an auto blocker callback. Return `true` from the callback to block auto mode.
+     * Returns a remove function.
+     */
+    function addAutoBlocker(cb) {
+        return addToRegistry(autoBlockers, cb);
+    }
+    /** Returns true if any registered auto blocker is active. */
+    function isAnyAutoBlockerActive() {
+        for (const cb of autoBlockers) {
+            try {
+                if (cb())
+                    return true;
+            }
+            catch (err) {
+                console.error('Error in auto blocker callback:', err);
+            }
+        }
+        return false;
+    }
     /** Add a callback to be invoked before handling each command. */
     function addBeforeHandleCommandCallback(cb) {
-        beforeHandleCommandCallbacks.push(cb);
-        return () => {
-            const idx = beforeHandleCommandCallbacks.indexOf(cb);
-            if (idx !== -1)
-                beforeHandleCommandCallbacks.splice(idx, 1);
-        };
+        return addToRegistry(beforeHandleCommandCallbacks, cb);
     }
     // --- skip (Ctrl fast-forward) management ---
     let _skipTimer = null;
+    let _autoTimer = null;
+    let _autoBarrier = null;
+    let _autoResumeTimer = null;
+    let _autoCollectFrame = null;
+    let _autoBarrierSeq = 0;
+    let _autoTicketSeq = 0;
+    const _pendingAutoTickets = 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 (!exports.autoState.active)
+                return;
+            if (_autoBarrier === null || _autoBarrier.id !== barrierId)
+                return;
+            _autoBarrier = null;
+            void (0, useScenario_1.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: new Map(),
+            settled: false,
+        };
+        adoptPendingAutoTickets(_autoBarrier);
+        scheduleAutoCollectionClose(_autoBarrier.id);
+    }
+    function issueAutoTicket(options) {
+        if (!exports.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);
+    }
+    /** Schedule a delayed nextLine() call for the auto. */
+    function scheduleAutoNextLine() {
+        if (_autoTimer !== null)
+            clearTimeout(_autoTimer);
+        _autoTimer = setTimeout(() => {
+            _autoTimer = null;
+            if (!exports.autoState.active)
+                return;
+            if (isAnyAutoBlockerActive()) {
+                stopAuto();
+                return;
+            }
+            if (_autoBarrier === null) {
+                void (0, useScenario_1.nextLine)();
+            }
+        }, autoRuntime.defaultTailMs);
+    }
     /** Schedule a delayed nextLine() call for the skip chain. */
-    function scheduleNextLine() {
+    function scheduleSkipNextLine() {
         if (_skipTimer !== null)
             clearTimeout(_skipTimer);
         _skipTimer = setTimeout(() => {
@@ -180,7 +403,7 @@ function createStage() {
         exports.skipState.active = true;
         invokeSkipCallbacks(); // finish current animations
         tryInterrupt(); // finish current printing
-        scheduleNextLine(); // kick off the chain
+        scheduleSkipNextLine(); // kick off the chain
     }
     /** Exit skip mode. Called when Ctrl is released, window blurs, or Stage unmounts. */
     function stopSkip() {
@@ -195,6 +418,27 @@ function createStage() {
     function isSkipping() {
         return exports.skipState.active;
     }
+    function startAuto() {
+        if (exports.autoState.active)
+            return;
+        if (isAnyAutoBlockerActive())
+            return;
+        exports.autoState.active = true;
+        tryInterrupt(); // finish current printing
+        scheduleAutoNextLine(); // kick off the chain
+    }
+    function stopAuto() {
+        exports.autoState.active = false;
+        if (_autoTimer !== null) {
+            clearTimeout(_autoTimer);
+            _autoTimer = null;
+        }
+        clearAutoBarrier();
+        clearPendingAutoTickets();
+    }
+    function isAutoing() {
+        return exports.autoState.active;
+    }
     // --- internal helpers ---
     /** Build a one-shot GameControl for a single dispatch cycle. */
     function buildControl() {
@@ -206,7 +450,16 @@ function createStage() {
                 if (exports.skipState.active) {
                     // Skip mode: finish residual animations and continue the chain
                     invokeSkipCallbacks();
-                    scheduleNextLine();
+                    scheduleSkipNextLine();
+                }
+                else if (exports.autoState.active) {
+                    if (isAnyAutoBlockerActive()) {
+                        stopAuto();
+                        (0, useScenario_1.setWaiting)(time, skippable);
+                    }
+                    else {
+                        openAutoBarrier('wait', time);
+                    }
                 }
                 else {
                     (0, useScenario_1.setWaiting)(time, skippable);
@@ -219,12 +472,20 @@ function createStage() {
                         stopSkip();
                     }
                     else {
-                        scheduleNextLine();
+                        scheduleSkipNextLine();
                     }
                 }
                 else if (exports.skipState.active && unskippableFlag) {
                     stopSkip();
                 }
+                else if (exports.autoState.active) {
+                    if (isAnyAutoBlockerActive()) {
+                        stopAuto();
+                    }
+                    else {
+                        openAutoBarrier('hold', 0);
+                    }
+                }
                 // When not skipping: do nothing (normal hold behavior)
             },
             nextLine() {
@@ -234,6 +495,16 @@ function createStage() {
             unskippable() {
                 unskippableFlag = true;
             },
+            record(meta) {
+                const result = (0, moyu_1.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 };
     }
@@ -253,10 +524,9 @@ function createStage() {
     }
     /** Dispatch a scenariocommandline event. */
     function dispatchCommand(e) {
-        // execute beforeHandleCommand callbacks
         for (const cb of beforeHandleCommandCallbacks) {
             try {
-                cb();
+                cb(e);
             }
             catch (err) {
                 console.error('Error in beforeHandleCommand callback:', err);
@@ -333,11 +603,16 @@ function createStage() {
         addSkipCallback,
         addInterruptCallback,
         addSkipBlocker,
+        addAutoBlocker,
         addBeforeHandleCommandCallback,
+        issueAutoTicket,
         tryInterrupt,
         startSkip,
         stopSkip,
         isSkipping,
+        startAuto,
+        stopAuto,
+        isAutoing,
         bindEvents,
     };
 }
@@ -396,8 +671,31 @@ function useSkipBlocker(callback) {
         return stage.addSkipBlocker(callback);
     }, [stage, callback]);
 }
+/**
+ * Register an auto blocker callback. Return `true` to block auto mode.
+ * Automatically removed on unmount.
+ *
+ * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
+ */
+function useAutoBlocker(callback) {
+    const stage = useStageContext();
+    (0, react_1.useEffect)(() => {
+        return stage.addAutoBlocker(callback);
+    }, [stage, callback]);
+}
+/**
+ * Get a function that issues an auto ticket for the current active barrier.
+ * Returns `null` when auto is inactive or the collection window has closed.
+ */
+function useAutoTicket() {
+    const stage = useStageContext();
+    return (0, react_1.useCallback)((options) => {
+        return stage.issueAutoTicket(options);
+    }, [stage]);
+}
 /**
  * Register a callback to be invoked before handling each command.
+ * The callback receives the upcoming command object, allowing conditional logic.
  * Automatically removed on unmount.
  */
 function useBeforeHandleCommandCallback(callback) {
@@ -406,4 +704,3 @@ function useBeforeHandleCommandCallback(callback) {
         return stage.addBeforeHandleCommandCallback(callback);
     }, [stage, callback]);
 }
-//# sourceMappingURL=useStage.js.map

package/dist/hooks.js

@@ -18,4 +18,3 @@ __exportStar(require("./hooks/useFadeInOut"), exports);
 __exportStar(require("./hooks/useScenario"), exports);
 __exportStar(require("./hooks/useSoundEffect"), exports);
 __exportStar(require("./hooks/useStage"), exports);
-//# sourceMappingURL=hooks.js.map

package/dist/lib.d.ts

@@ -1,5 +1,6 @@
 export * from './react';
 import * as moyu from './moyu';
+import './sandbox';
 export { executeNodeCommand, executePluginCommand } from './moyu';
 export * from './spring';
 export type * from './declaration';

package/dist/lib.js

@@ -40,6 +40,7 @@ exports.moyu = exports.executePluginCommand = exports.executeNodeCommand = void
 __exportStar(require("./react"), exports);
 const moyu = __importStar(require("./moyu"));
 exports.moyu = moyu;
+require("./sandbox");
 var moyu_1 = require("./moyu");
 Object.defineProperty(exports, "executeNodeCommand", { enumerable: true, get: function () { return moyu_1.executeNodeCommand; } });
 Object.defineProperty(exports, "executePluginCommand", { enumerable: true, get: function () { return moyu_1.executePluginCommand; } });
@@ -50,4 +51,3 @@ __exportStar(require("./commands"), exports);
 __exportStar(require("./runtime-globals"), exports);
 __exportStar(require("./components/navigation"), exports);
 __exportStar(require("./hooks"), exports);
-//# sourceMappingURL=lib.js.map

package/dist/moyu.d.ts

@@ -5,6 +5,7 @@ declare global {
         moyu: any;
     }
     var __moyu_receive_event: (event: MoyuEvent) => void;
+    var __moyu_eval_sandbox: (code: string) => any;
 }
 export declare function createInstance(nodeType: string, label: string | undefined, props: Record<string, any>): number;
 export declare function destroyInstance(nodeId: number): void;

package/dist/moyu.js

@@ -47,4 +47,3 @@ function executeNodeCommand(nodeId, payload) {
 function executePluginCommand(pluginName, payload) {
     return moyu.executePluginCommand(pluginName, payload);
 }
-//# sourceMappingURL=moyu.js.map

package/dist/node.js

@@ -103,4 +103,3 @@ function filterProps(props) {
     }
     return [ret, listeners];
 }
-//# sourceMappingURL=node.js.map

package/dist/react.js

@@ -220,4 +220,3 @@ function createRoot(options) {
         },
     };
 }
-//# sourceMappingURL=react.js.map

package/dist/runtime-globals.d.ts

@@ -60,4 +60,6 @@ declare global {
     function cancelAnimationFrame(handle: number): void;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */
     function requestAnimationFrame(callback: FrameRequestCallback): number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */
+    function queueMicrotask(callback: () => void): void;
 }

package/dist/runtime-globals.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=runtime-globals.js.map

package/dist/sandbox.d.ts

@@ -0,0 +1 @@
+export {};