@novely/core 0.19.5 → 0.21.0

package/dist/index.global.js

@@ -164,13 +164,29 @@ var Novely = (() => {
   var SKIPPED_DURING_RESTORE = /* @__PURE__ */ new Set(["dialog", "choice", "input", "vibrate", "text"]);
   var BLOCK_EXIT_STATEMENTS = /* @__PURE__ */ new Set(["choice:exit", "condition:exit", "block:exit"]);
   var BLOCK_STATEMENTS = /* @__PURE__ */ new Set(["choice", "condition", "block"]);
+  var AUDIO_ACTIONS = /* @__PURE__ */ new Set([
+    "playMusic",
+    "stopMusic",
+    "playSound",
+    "stopSound",
+    "voice",
+    "stopVoice"
+  ]);
   var EMPTY_SET = /* @__PURE__ */ new Set();
   var DEFAULT_TYPEWRITER_SPEED = "Medium";
+  var MAIN_CONTEXT_KEY = "$MAIN";
+
+  // src/shared.ts
+  var STACK_MAP = /* @__PURE__ */ new Map();
 
   // src/utils.ts
-  var matchAction = (values) => {
-    return (action, props) => {
-      return values[action](props);
+  var matchAction = (getContext, values) => {
+    return (action, props, { ctx, data }) => {
+      const context = typeof ctx === "string" ? getContext(ctx) : ctx;
+      return values[action]({
+        ctx: context,
+        data
+      }, props);
     };
   };
   var isNumber = (val) => {
@@ -314,6 +330,189 @@ var Novely = (() => {
     };
     return MAP[action];
   };
+  var getActionsFromPath = (story, path, raw = false) => {
+    let current = story;
+    let precurrent;
+    let ignoreNested = false;
+    let index = 0;
+    const max = path.reduce((acc, [type, val]) => {
+      if (isNull(type) && isNumber(val)) {
+        return acc + 1;
+      }
+      return acc;
+    }, 0);
+    const queue = [];
+    const blocks = [];
+    for (const [type, val] of path) {
+      if (type === "jump") {
+        precurrent = story;
+        current = current[val];
+      } else if (type === null) {
+        precurrent = current;
+        if (isNumber(val)) {
+          index++;
+          let startIndex = 0;
+          if (ignoreNested) {
+            const prev = findLastPathItemBeforeItemOfType(path.slice(0, index), "block");
+            if (prev) {
+              startIndex = prev[1];
+              ignoreNested = false;
+            }
+          }
+          for (let i = startIndex; i <= val; i++) {
+            const item = current[i];
+            if (!isAction(item))
+              continue;
+            const [action, ...meta] = item;
+            const push = () => {
+              queue.push([action, meta]);
+            };
+            if (raw) {
+              push();
+              continue;
+            }
+            if (isSkippedDuringRestore(action) || isUserRequiredAction(action, meta)) {
+              if (index === max && i === val) {
+                push();
+              }
+              continue;
+            } else {
+              push();
+            }
+          }
+        }
+        current = current[val];
+      } else if (type === "choice") {
+        blocks.push(precurrent);
+        current = current[val + 1][1];
+      } else if (type === "condition") {
+        blocks.push(precurrent);
+        current = current[2][val];
+      } else if (type === "block") {
+        blocks.push(precurrent);
+        current = story[val];
+      } else if (type === "block:exit" || type === "choice:exit" || type === "condition:exit") {
+        current = blocks.pop();
+        ignoreNested = true;
+      }
+    }
+    return queue;
+  };
+  var createQueueProcessor = (queue) => {
+    const processedQueue = [];
+    const keep = /* @__PURE__ */ new Set();
+    const characters = /* @__PURE__ */ new Set();
+    const audio = {
+      music: /* @__PURE__ */ new Set(),
+      sound: /* @__PURE__ */ new Set()
+    };
+    const next = (i) => queue.slice(i + 1);
+    for (const [i, [action, meta]] of queue.entries()) {
+      keep.add(action);
+      if (action === "function" || action === "custom") {
+        if (action === "custom" && meta[0].callOnlyLatest) {
+          const notLatest = next(i).some(([, _meta]) => {
+            if (!_meta || !meta)
+              return false;
+            const c0 = _meta[0];
+            const c1 = meta[0];
+            const isIdenticalID = c0.id && c1.id && c0.id === c1.id;
+            const isIdenticalByReference = c0 === c1;
+            return isIdenticalID || isIdenticalByReference || str(c0) === str(c1);
+          });
+          if (notLatest)
+            continue;
+        }
+        processedQueue.push([action, meta]);
+      } else if (action === "showCharacter" || action === "playSound" || action === "playMusic" || action === "voice") {
+        const closing = getOppositeAction(action);
+        const skip = next(i).some(([_action, _meta]) => {
+          if (!_meta || !meta)
+            return false;
+          if (_meta[0] !== meta[0])
+            return false;
+          return _action === closing || _action === action;
+        });
+        if (skip)
+          continue;
+        if (action === "showCharacter") {
+          characters.add(meta[0]);
+        } else if (action === "playMusic") {
+          audio.music.add(meta[0]);
+        } else if (action === "playSound") {
+          audio.sound.add(meta[0]);
+        }
+        processedQueue.push([action, meta]);
+      } else if (action === "showBackground" || action === "animateCharacter" || action === "preload") {
+        const skip = next(i).some(([_action], i2, array) => action === _action);
+        if (skip)
+          continue;
+        processedQueue.push([action, meta]);
+      } else {
+        processedQueue.push([action, meta]);
+      }
+    }
+    const run = async (match) => {
+      for await (const [action, meta] of processedQueue) {
+        const result = match(action, meta);
+        if (isPromise(result)) {
+          await result;
+        }
+      }
+      processedQueue.length = 0;
+    };
+    const getKeep = () => {
+      return {
+        keep,
+        characters,
+        audio
+      };
+    };
+    return {
+      run,
+      getKeep
+    };
+  };
+  var getStack = (ctx) => {
+    const { id } = ctx;
+    const cached = STACK_MAP.get(id);
+    if (cached)
+      return cached;
+    const stack = [];
+    STACK_MAP.set(id, stack);
+    return stack;
+  };
+  var createUseStackFunction = (renderer) => {
+    const useStack = (context) => {
+      const ctx = typeof context === "string" ? renderer.getContext(context) : context;
+      const stack = getStack(ctx);
+      return {
+        get previous() {
+          return stack.previous;
+        },
+        get value() {
+          return stack.at(-1);
+        },
+        set value(value) {
+          stack[stack.length - 1] = value;
+        },
+        back() {
+          if (stack.length > 1) {
+            stack.previous = stack.pop();
+            ctx.meta.goingBack = true;
+          }
+        },
+        push(value) {
+          stack.push(value);
+        },
+        clear() {
+          stack.length = 0;
+          stack.length = 1;
+        }
+      };
+    };
+    return useStack;
+  };
 
   // src/global.ts
   var PRELOADED_ASSETS = /* @__PURE__ */ new Set();
@@ -333,10 +532,13 @@ var Novely = (() => {
     const update = (fn) => {
       push(current = fn(current));
     };
+    const set = (val) => {
+      update(() => val);
+    };
     const get = () => {
       return current;
     };
-    return { subscribe, update, get };
+    return { subscribe, update, set, get };
   };
 
   // ../deepmerge/dist/index.js
@@ -588,6 +790,7 @@ var Novely = (() => {
       }
     });
     function state(value) {
+      const stack = useStack(MAIN_CONTEXT_KEY);
       if (!value)
         return stack.value[1];
       const prev = stack.value[1];
@@ -604,26 +807,6 @@ var Novely = (() => {
         [intime(Date.now()), "auto"]
       ];
     };
-    const createStack = (current, stack2 = [current]) => {
-      return {
-        get value() {
-          return stack2.at(-1);
-        },
-        set value(value) {
-          stack2[stack2.length - 1] = value;
-        },
-        back() {
-          if (stack2.length > 1)
-            stack2.pop(), goingBack = true;
-        },
-        push(value) {
-          stack2.push(value);
-        },
-        clear() {
-          stack2 = [getDefaultSave(klona(defaultState))];
-        }
-      };
-    };
     const getLanguageWithoutParameters = () => {
       return getLanguage2(languages, getLanguage);
     };
@@ -665,11 +848,10 @@ var Novely = (() => {
       }
       $$.update((prev) => (prev.dataLoaded = true, prev));
       dataLoaded.resolve();
-      $.update(() => stored);
+      $.set(stored);
     };
     storageDelay.then(getStoredData);
     const initial = getDefaultSave(klona(defaultState));
-    const stack = createStack(initial);
     addEventListener("visibilitychange", () => {
       if (document.visibilityState === "hidden") {
         throttledEmergencyOnStorageDataChange();
@@ -681,6 +863,7 @@ var Novely = (() => {
         return;
       if (!autosaves && type === "auto")
         return;
+      const stack = useStack(MAIN_CONTEXT_KEY);
       const current = klona(stack.value);
       $.update((prev) => {
         const isLatest = findLastIndex(prev.saves, (value) => times.has(value[2][0])) === prev.saves.length - 1;
@@ -710,139 +893,65 @@ var Novely = (() => {
       }
       restore(save2);
     };
-    const set = (save2) => {
+    const set = (save2, ctx) => {
+      const stack = useStack(ctx || renderer.getContext(MAIN_CONTEXT_KEY));
       stack.value = save2;
       return restore(save2);
     };
-    let restoring = false;
-    let goingBack = false;
     let interacted = 0;
     const restore = async (save2) => {
       if (!$$.get().dataLoaded)
         return;
       let latest = save2 || $.get().saves.at(-1);
       if (!latest) {
-        $.update(() => ({
+        $.set({
           saves: [initial],
           data: klona(defaultData),
           meta: [getLanguageWithoutParameters(), DEFAULT_TYPEWRITER_SPEED, 1, 1, 1]
-        }));
+        });
         latest = klona(initial);
       }
-      restoring = true, stack.value = latest;
-      const path = stack.value[0];
-      let current = story;
-      let precurrent;
-      let ignoreNested = false;
-      let index = 0;
-      const max = stack.value[0].reduce((acc, [type, val]) => {
-        if (isNull(type) && isNumber(val)) {
-          return acc + 1;
-        }
-        return acc;
-      }, 0);
-      const queue = [];
-      const keep = /* @__PURE__ */ new Set();
-      const characters2 = /* @__PURE__ */ new Set();
-      const blocks = [];
-      for (const [type, val] of path) {
-        if (type === "jump") {
-          precurrent = story;
-          current = current[val];
-        } else if (type === null) {
-          precurrent = current;
-          if (isNumber(val)) {
-            index++;
-            let startIndex = 0;
-            if (ignoreNested) {
-              const prev = findLastPathItemBeforeItemOfType(path.slice(0, index), "block");
-              if (prev) {
-                startIndex = prev[1];
-                ignoreNested = false;
-              }
-            }
-            for (let i = startIndex; i <= val; i++) {
-              const item = current[i];
-              if (!isAction(item))
-                continue;
-              const [action2, ...meta] = item;
-              const push2 = () => {
-                keep.add(action2);
-                queue.push([action2, meta]);
-              };
-              if (action2 === "showCharacter")
-                characters2.add(meta[0]);
-              if (isSkippedDuringRestore(action2) || isUserRequiredAction(action2, meta)) {
-                if (index === max && i === val) {
-                  push2();
-                } else {
-                  continue;
-                }
-              }
-              push2();
-            }
-          }
-          current = current[val];
-        } else if (type === "choice") {
-          blocks.push(precurrent);
-          current = current[val + 1][1];
-        } else if (type === "condition") {
-          blocks.push(precurrent);
-          current = current[2][val];
-        } else if (type === "block") {
-          blocks.push(precurrent);
-          current = story[val];
-        } else if (type === "block:exit" || type === "choice:exit" || type === "condition:exit") {
-          current = blocks.pop();
-          ignoreNested = true;
-        }
-      }
+      const context = renderer.getContext(MAIN_CONTEXT_KEY);
+      const stack = useStack(context);
+      context.meta.restoring = true;
+      const previous = stack.previous;
+      const [path] = stack.value = latest;
       renderer.ui.showScreen("game");
-      match("clear", [keep, characters2]);
-      const next2 = (i) => queue.slice(i + 1);
-      for await (const [i, [action2, meta]] of queue.entries()) {
-        if (action2 === "function" || action2 === "custom") {
-          if (action2 === "custom" && meta[0].callOnlyLatest) {
-            const notLatest = next2(i).some(([, _meta]) => {
-              if (!_meta || !meta)
-                return false;
-              const c0 = _meta[0];
-              const c1 = meta[0];
-              const isIdenticalID = c0.id && c1.id && c0.id === c1.id;
-              const isIdenticalByReference = c0 === c1;
-              return isIdenticalID || isIdenticalByReference || str(c0) === str(c1);
-            });
-            if (notLatest)
-              continue;
-          }
-          const result = match(action2, meta);
-          if (isPromise(result)) {
-            await result;
+      const queue = getActionsFromPath(story, path);
+      const processor = createQueueProcessor(queue);
+      const { keep, characters: characters2, audio } = processor.getKeep();
+      if (previous) {
+        const prevQueue = getActionsFromPath(story, previous[0], true);
+        const currQueue = getActionsFromPath(story, path, true);
+        for (let i = prevQueue.length - 1; i > currQueue.length; i--) {
+          const element = prevQueue[i];
+          if (isAction(element)) {
+            const [action2, props] = element;
+            if (action2 === "custom") {
+              context.clearCustom(props[0]);
+            }
           }
-        } else if (action2 === "showCharacter" || action2 === "playSound" || action2 === "playMusic" || action2 === "voice") {
-          const closing = getOppositeAction(action2);
-          const skip = next2(i).some(([_action, _meta]) => {
-            if (!_meta || !meta)
-              return false;
-            if (_meta[0] !== meta[0])
-              return false;
-            return _action === closing || _action === action2;
-          });
-          if (skip)
-            continue;
-          match(action2, meta);
-        } else if (action2 === "showBackground" || action2 === "animateCharacter" || action2 === "preload") {
-          const notLatest = next2(i).some(([_action]) => action2 === _action);
-          if (notLatest)
-            continue;
-          match(action2, meta);
-        } else {
-          match(action2, meta);
         }
       }
-      restoring = goingBack = false, render();
+      match("clear", [keep, characters2, audio], {
+        ctx: context,
+        data: latest[1]
+      });
+      await processor.run((action2, props) => {
+        if (!latest)
+          return;
+        return match(action2, props, {
+          ctx: context,
+          data: latest[1]
+        });
+      });
+      context.meta.restoring = context.meta.restoring = false;
+      render(context);
     };
-    const refer = (path = stack.value[0]) => {
+    const refer = (path) => {
+      if (!path) {
+        path = useStack(MAIN_CONTEXT_KEY).value[0];
+      }
       let current = story;
       let precurrent = story;
       const blocks = [];
@@ -873,10 +982,12 @@ var Novely = (() => {
         renderer.ui.showExitPrompt();
         return;
       }
+      const ctx = renderer.getContext(MAIN_CONTEXT_KEY);
+      const stack = useStack(ctx);
       const current = stack.value;
       stack.clear();
       renderer.ui.showScreen("mainmenu");
-      renderer.audio.destroy();
+      ctx.audio.destroy();
       const [time, type] = current[2];
       if (type === "auto" && interacted <= 1 && times.has(time)) {
         $.update((prev) => {
@@ -887,13 +998,38 @@ var Novely = (() => {
       interactivity(false);
       times.clear();
     };
-    const back = () => {
-      return stack.back(), restore(stack.value);
+    const back = async () => {
+      const stack = useStack(MAIN_CONTEXT_KEY);
+      stack.back();
+      await restore(stack.value);
     };
     const t = (key, lang) => {
       return translation[lang].internal[key];
     };
+    const preview = async ([path, data2], name) => {
+      const queue = getActionsFromPath(story, path);
+      const ctx = renderer.getContext(name);
+      ctx.meta.restoring = true;
+      ctx.meta.preview = true;
+      const processor = createQueueProcessor(queue);
+      await processor.run((action2, props) => {
+        if (AUDIO_ACTIONS.has(action2))
+          return;
+        if (action2 === "vibrate")
+          return;
+        if (action2 === "end")
+          return;
+        return match(action2, props, {
+          ctx,
+          data: data2
+        });
+      });
+    };
+    const removeContext = (name) => {
+      STACK_MAP.delete(name);
+    };
     const renderer = createRenderer({
+      mainContextKey: MAIN_CONTEXT_KEY,
       characters,
       set,
       restore,
@@ -902,62 +1038,67 @@ var Novely = (() => {
       exit,
       back,
       t,
-      stack,
+      preview,
+      removeContext,
       languages,
       $,
       $$
     });
+    const useStack = createUseStackFunction(renderer);
+    useStack(MAIN_CONTEXT_KEY).push(initial);
     renderer.ui.start();
-    const match = matchAction({
-      wait([time]) {
-        if (!restoring)
+    const match = matchAction(renderer.getContext, {
+      wait({ ctx }, [time]) {
+        if (!ctx.meta.restoring)
           setTimeout(push, isFunction(time) ? time() : time);
       },
-      showBackground([background]) {
-        renderer.background(background);
-        push();
+      showBackground({ ctx }, [background]) {
+        ctx.background(background);
+        push(ctx);
       },
-      playMusic([source]) {
-        renderer.audio.music(source, "music", true).play();
-        push();
+      playMusic({ ctx }, [source]) {
+        ctx.audio.music(source, "music", true).play();
+        push(ctx);
       },
-      stopMusic([source]) {
-        renderer.audio.music(source, "music").stop();
-        push();
+      stopMusic({ ctx }, [source]) {
+        ctx.audio.music(source, "music").stop();
+        push(ctx);
       },
-      playSound([source, loop]) {
-        renderer.audio.music(source, "sound", loop || false).play();
-        push();
+      playSound({ ctx }, [source, loop]) {
+        ctx.audio.music(source, "sound", loop || false).play();
+        push(ctx);
       },
-      stopSound([source]) {
-        renderer.audio.music(source, "sound").stop();
-        push();
+      stopSound({ ctx }, [source]) {
+        ctx.audio.music(source, "sound").stop();
+        push(ctx);
       },
-      voice([source]) {
-        renderer.audio.voice(source);
-        push();
+      voice({ ctx }, [source]) {
+        ctx.audio.voice(source);
+        push(ctx);
       },
-      stopVoice() {
-        renderer.audio.voiceStop();
-        push();
+      stopVoice({ ctx }) {
+        ctx.audio.voiceStop();
+        push(ctx);
       },
-      showCharacter([character, emotion, className, style]) {
+      showCharacter({ ctx }, [character, emotion, className, style]) {
         if (DEV && !characters[character].emotions[emotion]) {
           throw new Error(`Attempt to show character "${character}" with unknown emotion "${emotion}"`);
         }
-        const handle = renderer.character(character);
-        handle.append(className, style, restoring);
-        handle.withEmotion(emotion)();
-        push();
+        const handle = ctx.character(character);
+        handle.append(className, style, ctx.meta.restoring);
+        handle.emotion(emotion, true);
+        push(ctx);
       },
-      hideCharacter([character, className, style, duration]) {
-        renderer.character(character).remove(className, style, duration)(push, restoring);
+      hideCharacter({ ctx }, [character, className, style, duration]) {
+        ctx.character(character).remove(className, style, duration, ctx.meta.restoring).then(() => {
+          push(ctx);
+        });
       },
-      dialog([character, content, emotion]) {
+      dialog({ ctx, data: data2 }, [character, content, emotion]) {
         const name = (() => {
           const c = character;
           const cs = characters;
-          const lang = $.get().meta[0];
+          const [lang] = $.get().meta;
           if (c && c in cs) {
             const block = cs[c].name;
             if (typeof block === "string") {
@@ -969,65 +1110,81 @@ var Novely = (() => {
           }
           return c || "";
         })();
-        const run = renderer.dialog(unwrap2(content), unwrap2(name), character, emotion);
-        run(forward, goingBack);
+        ctx.dialog(
+          unwrap2(content, data2),
+          unwrap2(name, data2),
+          character,
+          emotion,
+          () => forward(ctx)
+        );
       },
-      function([fn]) {
-        const result = fn(restoring, goingBack);
-        if (!restoring)
-          result ? result.then(push) : push();
+      function({ ctx }, [fn]) {
+        const result = fn(ctx.meta.restoring, ctx.meta.goingBack, ctx.meta.preview);
+        if (!ctx.meta.restoring) {
+          result ? result.then(() => push(ctx)) : push(ctx);
+        }
         return result;
       },
-      choice([question, ...choices]) {
+      choice({ ctx, data: data2 }, [question, ...choices]) {
         const isWithoutQuestion = Array.isArray(question);
         if (isWithoutQuestion) {
           choices.unshift(question);
           question = "";
         }
-        const unwrapped = choices.map(([content, action2, visible]) => {
+        const unwrappedChoices = choices.map(([content, action2, visible]) => {
           if (DEV && action2.length === 0 && (!visible || visible())) {
             console.warn(`Choice children should not be empty, either add content there or make item not selectable`);
           }
-          return [unwrap2(content), action2, visible];
+          return [unwrap2(content, data2), action2, visible];
         });
-        if (DEV && unwrapped.length === 0) {
+        if (DEV && unwrappedChoices.length === 0) {
           throw new Error(`Running choice without variants to choose from, look at how to use Choice action properly [https://novely.pages.dev/guide/actions/choice#usage]`);
         }
-        const run = renderer.choices(unwrap2(question), unwrapped);
-        run((selected) => {
-          enmemory();
+        ctx.choices(unwrap2(question, data2), unwrappedChoices, (selected) => {
+          if (!ctx.meta.preview) {
+            enmemory(ctx);
+          }
+          const stack = useStack(ctx);
           const offset = isWithoutQuestion ? 0 : 1;
-          if (DEV && !unwrapped[selected + offset]) {
+          if (DEV && !unwrappedChoices[selected + offset]) {
             throw new Error("Choice children is empty, either add content there or make item not selectable");
           }
           stack.value[0].push(["choice", selected + offset], [null, 0]);
-          render();
+          render(ctx);
           interactivity(true);
         });
       },
-      jump([scene]) {
+      jump({ ctx, data: data2 }, [scene]) {
         if (DEV && !story[scene]) {
           throw new Error(`Attempt to jump to unknown scene "${scene}"`);
         }
         if (DEV && story[scene].length === 0) {
           throw new Error(`Attempt to jump to empty scene "${scene}"`);
         }
+        const stack = useStack(ctx);
         stack.value[0] = [
           ["jump", scene],
           [null, -1]
         ];
-        match("clear", []);
+        match("clear", [], {
+          ctx,
+          data: data2
+        });
       },
-      clear([keep, characters2]) {
-        renderer.vibrate(0);
-        renderer.clear(goingBack, keep || EMPTY_SET, characters2 || EMPTY_SET)(push);
-        renderer.audio.clear();
+      clear({ ctx }, [keep, characters2, audio]) {
+        ctx.vibrate(0);
+        ctx.clear(
+          keep || EMPTY_SET,
+          characters2 || EMPTY_SET,
+          audio || { music: EMPTY_SET, sounds: EMPTY_SET },
+          () => push(ctx)
+        );
       },
-      condition([condition, variants]) {
+      condition({ ctx }, [condition, variants]) {
         if (DEV && Object.values(variants).length === 0) {
           throw new Error(`Attempt to use Condition action with empty variants object`);
         }
-        if (!restoring) {
+        if (!ctx.meta.restoring) {
           const val = String(condition());
           if (DEV && !variants[val]) {
             throw new Error(`Attempt to go to unknown variant "${val}"`);
@@ -1035,46 +1192,59 @@ var Novely = (() => {
           if (DEV && variants[val].length === 0) {
             throw new Error(`Attempt to go to empty variant "${val}"`);
           }
+          const stack = useStack(MAIN_CONTEXT_KEY);
           stack.value[0].push(["condition", val], [null, 0]);
-          render();
+          render(ctx);
         }
       },
-      end() {
-        renderer.vibrate(0);
-        renderer.clear(goingBack, EMPTY_SET, EMPTY_SET)(noop);
+      end({ ctx }) {
+        if (ctx.meta.preview)
+          return;
+        ctx.vibrate(0);
+        ctx.clear(EMPTY_SET, EMPTY_SET, { music: EMPTY_SET, sounds: EMPTY_SET }, noop);
         renderer.ui.showScreen("mainmenu");
         interactivity(false);
         times.clear();
       },
-      input([question, onInput, setup]) {
-        renderer.input(unwrap2(question), onInput, setup)(forward);
+      input({ ctx, data: data2 }, [question, onInput, setup]) {
+        ctx.input(
+          unwrap2(question, data2),
+          onInput,
+          setup || noop,
+          () => forward(ctx)
+        );
       },
-      custom([handler]) {
-        const result = renderer.custom(handler, goingBack, () => {
-          if (!restoring && handler.requireUserAction)
-            enmemory(), interactivity(true);
-          if (!restoring)
-            push();
+      custom({ ctx }, [handler]) {
+        const result = ctx.custom(handler, () => {
+          if (ctx.meta.restoring)
+            return;
+          if (handler.requireUserAction && !ctx.meta.preview) {
+            enmemory(ctx);
+            interactivity(true);
+          }
+          push(ctx);
         });
         return result;
       },
-      vibrate(pattern) {
-        renderer.vibrate(pattern);
-        push();
+      vibrate({ ctx }, pattern) {
+        ctx.vibrate(pattern);
+        push(ctx);
       },
-      next() {
-        push();
+      next({ ctx }) {
+        push(ctx);
       },
-      animateCharacter([character, timeout, ...classes]) {
+      animateCharacter({ ctx, data: data2 }, [character, timeout, ...classes]) {
         if (DEV && classes.length === 0) {
           throw new Error("Attempt to use AnimateCharacter without classes. Classes should be provided [https://novely.pages.dev/guide/actions/animateCharacter.html]");
         }
         if (DEV && (timeout <= 0 || !Number.isFinite(timeout) || Number.isNaN(timeout))) {
           throw new Error("Attempt to use AnimateCharacter with unacceptable timeout. It should be finite and greater than zero");
         }
+        if (ctx.meta.preview)
+          return;
         const handler = (get) => {
-          const { clear } = get("@@internal-animate-character", false);
-          const char = renderer.store.characters[character];
+          const { clear } = get(false);
+          const char = ctx.getCharacter(character);
           if (!char)
             return;
           const target = char.canvas;
@@ -1090,18 +1260,23 @@ var Novely = (() => {
             clearTimeout(timeoutId);
           });
         };
-        match("custom", [handler]);
+        handler.key = "@@internal-animate-character";
+        match("custom", [handler], {
+          ctx,
+          data: data2
+        });
       },
-      text(text) {
-        const string = text.map((content) => unwrap2(content)).join(" ");
+      text({ ctx, data: data2 }, text) {
+        const string = text.map((content) => unwrap2(content, data2)).join(" ");
         if (DEV && string.length === 0) {
           throw new Error(`Action Text was called with empty string or array`);
         }
-        renderer.text(string, forward, goingBack);
+        ctx.text(string, () => forward(ctx));
       },
-      exit() {
-        if (restoring)
+      exit({ ctx, data: data2 }) {
+        if (ctx.meta.restoring)
           return;
+        const stack = useStack(ctx);
         const path = stack.value[0];
         const last = path.at(-1);
         const ignore = [];
@@ -1115,7 +1290,10 @@ var Novely = (() => {
         if (isExitImpossible(path)) {
           const referred = refer(path);
           if (isAction(referred) && isSkippedDuringRestore(referred[0])) {
-            match("end", []);
+            match("end", [], {
+              ctx,
+              data: data2
+            });
           }
           return;
         }
@@ -1140,36 +1318,39 @@ var Novely = (() => {
           }
           break;
         }
-        render();
+        render(ctx);
       },
-      preload([source]) {
-        if (!goingBack && !restoring && !PRELOADED_ASSETS.has(source)) {
+      preload({ ctx }, [source]) {
+        if (!ctx.meta.goingBack && !ctx.meta.restoring && !PRELOADED_ASSETS.has(source)) {
           PRELOADED_ASSETS.add(renderer.misc.preloadImage(source));
         }
-        push();
+        push(ctx);
       },
-      block([scene]) {
+      block({ ctx }, [scene]) {
         if (DEV && !story[scene]) {
           throw new Error(`Attempt to call Block action with unknown scene "${scene}"`);
         }
         if (DEV && story[scene].length === 0) {
           throw new Error(`Attempt to call Block action with empty scene "${scene}"`);
         }
-        if (!restoring) {
+        if (!ctx.meta.restoring) {
+          const stack = useStack(ctx);
           stack.value[0].push(["block", scene], [null, 0]);
-          render();
+          render(ctx);
         }
       }
     });
-    const enmemory = () => {
-      if (restoring)
+    const enmemory = (ctx) => {
+      if (ctx.meta.restoring)
         return;
+      const stack = useStack(ctx);
       const current = klona(stack.value);
       current[2][1] = "auto";
       stack.push(current);
       save(true, "auto");
     };
-    const next = () => {
+    const next = (ctx) => {
+      const stack = useStack(ctx);
       const path = stack.value[0];
       const last = path.at(-1);
       if (last && (isNull(last[0]) || last[0] === "jump") && isNumber(last[1])) {
@@ -1178,33 +1359,42 @@ var Novely = (() => {
         path.push([null, 0]);
       }
     };
-    const render = () => {
-      const referred = refer();
+    const render = (ctx) => {
+      const stack = useStack(ctx);
+      const referred = refer(stack.value[0]);
       if (isAction(referred)) {
         const [action2, ...props] = referred;
-        match(action2, props);
+        match(action2, props, {
+          ctx,
+          data: stack.value[1]
+        });
       } else {
-        match("exit", []);
+        match("exit", [], {
+          ctx,
+          data: stack.value[1]
+        });
       }
     };
-    const push = () => {
-      if (!restoring)
-        next(), render();
+    const push = (ctx) => {
+      if (!ctx.meta.restoring)
+        next(ctx), render(ctx);
     };
-    const forward = () => {
-      enmemory();
-      push();
-      interactivity(true);
+    const forward = (ctx) => {
+      if (!ctx.meta.preview)
+        enmemory(ctx);
+      push(ctx);
+      if (!ctx.meta.preview)
+        interactivity(true);
     };
     const interactivity = (value = false) => {
       interacted = value ? interacted + 1 : 0;
     };
-    const unwrap2 = (content, global = false) => {
+    const unwrap2 = (content, values) => {
       const {
         data: data2,
         meta: [lang]
       } = $.get();
-      const obj = global ? data2 : state();
+      const obj = values ? values : data2;
       const cnt = isFunction(content) ? content() : typeof content === "string" ? content : content[lang];
       const str2 = isFunction(cnt) ? cnt() : cnt;
       const trans = translation[lang];
@@ -1244,7 +1434,7 @@ var Novely = (() => {
        * Unwraps translatable content to a string value
        */
       unwrap(content) {
-        return unwrap2(content, true);
+        return unwrap2(content, $.get().data);
       }
     };
   };