@novely/core 0.19.5 → 0.20.0

package/dist/index.js

@@ -2,13 +2,29 @@
 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) => {
@@ -152,6 +168,189 @@ var getOppositeAction = (action) => {
   };
   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();
@@ -171,10 +370,13 @@ var store = (current, subscribers = /* @__PURE__ */ new Set()) => {
   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
@@ -422,6 +624,7 @@ var novely = ({
     }
   });
   function state(value) {
+    const stack = useStack(MAIN_CONTEXT_KEY);
     if (!value)
       return stack.value[1];
     const prev = stack.value[1];
@@ -438,26 +641,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);
   };
@@ -499,11 +682,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();
@@ -515,6 +697,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;
@@ -544,139 +727,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();
+    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");
+    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]);
           }
         }
-        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;
       }
     }
-    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;
-        }
-      } 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 = [];
@@ -707,10 +816,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) => {
@@ -721,13 +832,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,
@@ -736,62 +872,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") {
@@ -803,16 +944,17 @@ var novely = ({
         }
         return c || "";
       })();
-      const run = renderer.dialog(unwrap2(content), unwrap2(name), character, emotion);
-      run(forward, goingBack);
+      const run = ctx.dialog(unwrap2(content, data2), unwrap2(name, data2), character, emotion);
+      run(() => 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);
@@ -822,46 +964,57 @@ var novely = ({
         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) {
         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);
+      const run = ctx.choices(unwrap2(question, data2), unwrapped);
       run((selected) => {
-        enmemory();
+        if (!ctx.meta.preview) {
+          enmemory(ctx);
+        }
+        const stack = useStack(ctx);
         const offset = isWithoutQuestion ? 0 : 1;
         if (DEV && !unwrapped[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);
+      const run = ctx.clear(
+        keep || EMPTY_SET,
+        characters2 || EMPTY_SET,
+        audio || { music: EMPTY_SET, sounds: EMPTY_SET }
+      );
+      run(() => 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}"`);
@@ -869,46 +1022,56 @@ 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)(() => {
+        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;
@@ -924,18 +1087,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 = [];
@@ -949,7 +1117,10 @@ var novely = ({
       if (isExitImpossible(path)) {
         const referred = refer(path);
         if (isAction(referred) && isSkippedDuringRestore(referred[0])) {
-          match("end", []);
+          match("end", [], {
+            ctx,
+            data: data2
+          });
         }
         return;
       }
@@ -974,36 +1145,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])) {
@@ -1012,33 +1186,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];
@@ -1078,7 +1261,7 @@ var novely = ({
      * Unwraps translatable content to a string value
      */
     unwrap(content) {
-      return unwrap2(content, true);
+      return unwrap2(content, $.get().data);
     }
   };
 };