yuuna-engine 0.3.0 → 0.4.0

package/README.md

@@ -32,14 +32,19 @@ Then describe your game as state + render + nextState:
 ```ts
 import { runEngine } from "yuuna-engine";
 
+// The shape of your game's data — whatever it takes to fully describe
+// what's on screen and how it behaves
 type GameState = { cookies: number };
 
-runEngine<GameState>({
-  initialState: { cookies: 0 },
+// What that state looks like before anything has happened yet
+const initialState: GameState = { cookies: 0 };
 
-  // Optional — size and color the canvas from code instead of HTML/CSS
-  canvas: { width: 960, height: 540, backgroundColor: "#0d1831" },
+runEngine<GameState>({
+  initialState,
 
+  // Given the current state, what should be drawn this frame? Called
+  // every frame — always derive the picture from state, instead of
+  // reaching for the canvas directly.
   render: (state) => ({
     renderables: [
       {
@@ -59,6 +64,9 @@ runEngine<GameState>({
     ],
   }),
 
+  // Given the current state and something that just happened, what's the
+  // next state? Called once per event (a click, a frame tick, ...) — the
+  // only place game logic lives.
   nextState: ({ state, event }) => {
     if (event.tag === "CLICK" && event.id === "cookie") {
       return { cookies: state.cookies + 1 };
@@ -72,110 +80,41 @@ runEngine<GameState>({
 ## Concepts
 
 - **Renderables** — declarative shapes drawn each frame: `RECTANGLE`,
-  `CIRCLE`, `TEXT`, `SPRITE`, `LINE`, `GROUP`, and `ANIMATED_SPRITE`. Give
-  one an `id` plus `isClickable` / `isHoverable` / `trackMouseMovement` to
-  make it interactive. `TEXT` also takes a `fontSize` (defaults to `30`).
-  `GROUP` draws nothing itself — it's just a `position` (plus the usual
-  `scale`/`modulate`/`layer` below) for `children` to hang off of, for
-  grouping renderables that should move/scale/tint together without
-  needing a shape of its own; it's never interactable, since it has no
-  shape to hit-test. `ANIMATED_SPRITE` is `SPRITE` with an `animation`
-  (name of one defined on that resource — see Sprites below) and an
-  optional `timeScale` instead of a `frame` number; the engine picks the
-  frame for you based on how long it's been playing. Unlike every other
-  renderable, its `id` is required — that's how the engine recognizes
-  "this is the same sprite as last frame" across renders (and switches to
-  frame 0 if `animation` changes for that `id`), so reusing an id across
-  two different entities will make their animations bleed together.
-  Every renderable also takes:
-  - `layer` — higher values render later, i.e. in front of lower ones.
-    Defaults to `0`; renderables on the same layer keep `render()`'s order.
-  - `scale` — `{ x, y }` multiplier on the renderable's size, anchored at
-    its `position` (or `from`, for `LINE`). Defaults to `{ x: 1, y: 1 }`.
-    A `CIRCLE` scaled unevenly draws (and hit-tests) as an ellipse.
-  - `modulate` — a CSS color string that multiplies the renderable's color
-    channel-by-channel, the same way Godot's `modulate` works — e.g.
-    `"#808080"` halves brightness, `"#ff0000"` keeps only the red channel.
-  - `children` — nested renderables, positioned relative to this one, like
-    Godot's parent/child nodes. A child's `position` is added to its
-    parent's (scaled by the parent's own `scale`), and `scale` / `modulate`
-    / `layer` all compose down the tree — a child's effective scale is the
-    parent's times its own, `modulate` multiplies the same way, and
-    `layer` adds (relative to the parent's, matching Godot's default: a
-    deeply-nested child can still end up drawn in front of an unrelated
-    top-level renderable if its accumulated layer says so). A child is a
-    full `Renderable`, so it can have its own `id` / `isClickable` / even
-    its own `children`. `screenSpace: true` makes a renderable (and its
-    whole subtree) ignore the camera below and stay fixed to the screen —
-    for UI/HUD that shouldn't pan or zoom with the game world.
-- **Camera** — pass `camera: (state) => ({ x, y, zoom })` to `runEngine` to
-  pan/zoom every world-space renderable (anything without
-  `screenSpace: true`) as a group, the same way a `GROUP` parent works for
-  its children — `{ x, y }` is the world position mapped to canvas
-  `(0, 0)`, and `zoom` scales everything around that same point. It's a
-  function of state, so the camera can follow something or react to a
-  zoom level you're tracking yourself.
-- **Events** — your `nextState` function receives one `GameEvent` per call:
-  `TIME` (frame tick with `delta`), `CLICK`, `HOVER_IN`, `HOVER_OUT`, or
-  `MOUSE_MOVE`. The mouse-carrying ones include both `mouse` (raw canvas
-  pixels — use for `screenSpace`/UI logic) and `worldMouse` (that same
-  position run through the camera's inverse transform — use to
-  place/locate world-space things, e.g. build a turret where the player
-  clicked). With no `camera` set, `worldMouse` always equals `mouse`.
-- **Keyboard** — `nextState` also receives a `keyboard` map keyed by
-  `KeyCode`-style keys (e.g. `"KeyW"`, `"ArrowLeft"`, `"Space"`), each with
-  `isPressed` / `isJustPressed` / `isJustReleased`.
-- **Sprites** — pass a `resources` map of `{ src, size, slices }` to
-  `runEngine` to load spritesheets, then reference them by id with a
-  `SPRITE` renderable's `resourceId` and `frame`. Set `flipX: true` to
-  mirror a sprite horizontally — useful when the art is drawn facing one
-  direction but needs to move the other way. Add an `animations` map to a
-  resource — `{ frames: number[], frameDuration, loop }` each — to play
-  one with `ANIMATED_SPRITE` instead of managing `frame` by hand.
-- **Sound effects** — pass a `sounds` map of `{ src }` to `runEngine`, then
-  call the `playSound(id)` function `nextState` receives to play one, e.g.
-  `playSound("collect")` when a cookie is clicked. Calling it again while
-  a sound is still playing overlaps a new copy instead of cutting the
-  first one off.
-- **Music** — pass a `music` map of `{ src }` to `runEngine`, then use the
-  `playMusic(id)` / `pauseMusic()` functions `nextState` receives to
-  control a looping background track. Unlike `playSound`, only one track
-  plays at a time and it keeps running in the background across frames
-  instead of firing once; `pauseMusic()` leaves it where it stopped, so
-  calling `playMusic(id)` again resumes it instead of starting over.
-- **Canvas** — pass `canvas: { width, height, backgroundColor }` to
-  `runEngine` to size and color the canvas from code. All three are
-  optional; anything you don't set falls back to the canvas element's
-  existing HTML/CSS.
-- **Mechanics** — `nextState` can also be an array of small
-  `NextStateFunction`s instead of one big function. Each one is run in
-  order for every event, and can return:
-  - a new state, to update to
-  - `undefined` (or no `return` at all) — no change, but the rest of the
-    list still runs, so a guard can just be `if (...) return;`
-  - `STOP` (imported from `yuuna-engine`) — no change, and the rest of
-    the list is skipped for this event, so a shared rule (like "nothing
-    happens once the game is over") only needs to be written once
-
-  ```ts
-  import { runEngine, STOP, type NextStateFunction } from "yuuna-engine";
-
-  const freezeOnGameOver: NextStateFunction<GameState> = ({ state }) => {
-    if (state.lives <= 0) return STOP;
-  };
-
-  const moveEnemies: NextStateFunction<GameState> = ({ state, event }) => {
-    if (event.tag === "TIME") {
-      return { ...state, enemies: move(state.enemies, event.delta) };
-    }
-  };
-
-  runEngine<GameState>({
-    initialState,
-    render,
-    nextState: [freezeOnGameOver, moveEnemies /* ... */],
-  });
-  ```
+  `CIRCLE`, `TEXT`, `SPRITE`, `ANIMATED_SPRITE`, `LINE`, and `GROUP`. Give
+  one an `id` plus `isClickable`/`isHoverable` to make it interactive.
+- **Events** — `nextState` receives one `GameEvent` per call: `TIME`,
+  `CLICK`, `HOVER_IN`, `HOVER_OUT`, `MOUSE_MOVE`, `MUSIC_END`, or a
+  `CUSTOM` event of a type you define yourself, for reporting things like
+  an async `fetch()` resolving back into your state machine.
+- **Keyboard, camera, sprites & animation, sound effects & music,
+  canvas config, and mechanics pipelines** all follow the same idea:
+  small, focused props and functions `runEngine`/`nextState` take, that
+  compose with everything above instead of replacing it.
+
+This README stays intentionally thin — the full concept-by-concept
+reference, with every option and example, lives on the
+[wiki](https://github.com/lucy-dot-exe/yuuna/wiki). The
+[playground](https://lucy-dot-exe.github.io/yuuna/#playground) also has a
+small, focused example for most of these you can run and edit directly.
+
+## Templates
+
+Prefer a working starting point over typing the quick start out by
+hand? Grab one from [`templates/`](templates):
+
+- **[blank](templates/blank)** — a single `index.html`, zero install —
+  open it in a browser and it runs.
+- **[npm](templates/npm)** — TypeScript + a dev server with hot reload
+  (via Vite), for a real local project.
+
+```sh
+npx degit lucy-dot-exe/yuuna/templates/blank my-game
+# or: npx degit lucy-dot-exe/yuuna/templates/npm my-game
+```
+
+[`degit`](https://github.com/Rich-Harris/degit) copies the folder without
+its git history — no cloning or forking the whole engine repo needed.
+Each template's own README has more on running it once copied.
 
 ## Development
 

package/lib/engine/types.d.ts

@@ -145,10 +145,18 @@ export type MouseMoveEvent = {
         y: number;
     };
 };
-export type GameEvent = TimeEvent | ClickEvent | HoverInEvent | HoverOutEvent | MouseMoveEvent;
-export type NextStateProps<State> = {
+export type MusicEndEvent = {
+    tag: "MUSIC_END";
+    id: string;
+};
+export type GameEvent = TimeEvent | ClickEvent | HoverInEvent | HoverOutEvent | MouseMoveEvent | MusicEndEvent;
+export type CustomGameEvent<Custom> = {
+    tag: "CUSTOM";
+    event: Custom;
+};
+export type NextStateProps<State, Custom = never> = {
     state: State;
-    event: GameEvent;
+    event: GameEvent | CustomGameEvent<Custom>;
     keyboard: Record<KeyboardKeys, {
         isPressed: boolean;
         isJustPressed: boolean;
@@ -157,16 +165,18 @@ export type NextStateProps<State> = {
     playSound: (id: string) => void;
     playMusic: (id: string) => void;
     pauseMusic: () => void;
+    resumeMusic: () => void;
+    setMusicVolume: (volume: number) => void;
 };
 export declare const STOP: "Yuuna.STOP";
-export type NextStateFunction<State> = (props: NextStateProps<State>) => State | typeof STOP | undefined;
-export type RunEngineProps<State> = {
+export type NextStateFunction<State, Custom = never> = (props: NextStateProps<State, Custom>) => State | typeof STOP | undefined;
+export type RunEngineProps<State, Custom = never> = {
     initialState: State;
     render: (state: State) => {
         cursor?: "default" | "pointer";
         renderables: Renderable[];
     };
-    nextState: NextStateFunction<State> | NextStateFunction<State>[];
+    nextState: NextStateFunction<State, Custom> | NextStateFunction<State, Custom>[];
     resources?: Record<string, {
         src: string;
         size: {
@@ -188,6 +198,7 @@ export type RunEngineProps<State> = {
     }>;
     music?: Record<string, {
         src: string;
+        loop?: boolean;
     }>;
     canvas?: {
         width?: number;
@@ -200,7 +211,9 @@ export type RunEngineProps<State> = {
         zoom: number;
     };
 };
-export type RunEngineFunction = <State>(props: RunEngineProps<State>) => Promise<void>;
+export type RunEngineFunction = <State, Custom = never>(props: RunEngineProps<State, Custom>) => Promise<{
+    sendEvent: (event: Custom) => void;
+}>;
 export declare const keyboardKeys: readonly ["ControlLeft", "ControlRight", "AltLeft", "AltRight", "CapsLock", "End", "Delete", "Tab", "Space", "Enter", "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Numpad0", "Numpad1", "Numpad2", "Numpad3", "Numpad4", "Numpad5", "Numpad6", "Numpad7", "Numpad8", "Numpad9", "Digit0", "Digit1", "Digit2", "Digit3", "Digit4", "Digit5", "Digit6", "Digit7", "Digit8", "Digit9", "KeyA", "KeyB", "KeyC", "KeyD", "KeyE", "KeyF", "KeyG", "KeyH", "KeyI", "KeyJ", "KeyK", "KeyL", "KeyM", "KeyN", "KeyO", "KeyP", "KeyQ", "KeyR", "KeyS", "KeyT", "KeyU", "KeyV", "KeyW", "KeyX", "KeyY", "KeyZ"];
 export type KeyboardKeys = (typeof keyboardKeys)[number];
 export type KeyboardState = Record<KeyboardKeys, boolean>;

package/lib/index.cjs

@@ -147,6 +147,14 @@ const runEngine = async (props) => {
     // leaking to the rest of the page (e.g. arrow keys scrolling the window).
     canvas.tabIndex = 0;
     let state = props.initialState;
+    const events = [];
+    // Lets a caller report something that happened outside the render loop
+    // (e.g. a fetch().then() callback) back into it — the event is queued
+    // here and delivered to nextState as a CustomGameEvent on the next tick,
+    // the same as any built-in event.
+    const sendEvent = (event) => {
+        events.push({ tag: "CUSTOM", event });
+    };
     const resources = props.resources ?? {};
     const resourceById = await iterateRecordAsync(resources, async ({ value }) => new Promise((resolve) => {
         const image = new Image();
@@ -184,11 +192,24 @@ const runEngine = async (props) => {
     };
     const music = props.music ?? {};
     const musicById = await iterateRecordAsync(music, ({ value }) => loadAudio(value.src));
+    // Registered once per track at load time — fires only for a track
+    // whose `loop` is false, since a looping <audio> never reaches "ended"
+    // (the browser restarts it before the event would fire).
+    for (const id of getKeys(musicById)) {
+        musicById[id].addEventListener("ended", () => {
+            events.push({ tag: "MUSIC_END", id });
+        });
+    }
     // Unlike sounds, music reuses the same element instead of cloning it —
     // there's only ever one track playing, and reusing it is what lets
     // pauseMusic()/playMusic() resume from where playback left off instead
     // of starting over.
     let currentMusic = null;
+    // Volume is a property of each HTMLAudioElement, not global — tracked
+    // separately here and (re)applied on every playMusic() so switching
+    // tracks keeps the volume the game last set instead of resetting to
+    // each element's default of 1.
+    let musicVolume = 1;
     const playMusic = (id) => {
         const audio = musicById[id];
         if (audio === undefined) {
@@ -197,18 +218,28 @@ const runEngine = async (props) => {
         if (currentMusic !== null && currentMusic !== audio) {
             currentMusic.pause();
         }
-        audio.loop = true;
+        audio.loop = music[id]?.loop ?? true;
+        audio.volume = musicVolume;
         audio.play();
         currentMusic = audio;
     };
     const pauseMusic = () => {
         currentMusic?.pause();
     };
+    const resumeMusic = () => {
+        currentMusic?.play();
+    };
+    const setMusicVolume = (volume) => {
+        musicVolume = Math.min(1, Math.max(0, volume));
+        if (currentMusic !== null) {
+            currentMusic.volume = musicVolume;
+        }
+    };
     // A newer runEngine() call started while this one was still loading
     // resources (e.g. a spritesheet) — abandon this run instead of setting
     // up a second, orphaned render loop alongside the newer one.
     if (runId !== latestRunId) {
-        return;
+        return { sendEvent };
     }
     context.imageSmoothingEnabled = false;
     // An offscreen 1x1 canvas used only to resolve a CSS color string (a
@@ -498,7 +529,6 @@ const runEngine = async (props) => {
     const nextStateFns = Array.isArray(props.nextState) ? props.nextState : [props.nextState];
     let lastFrame = Date.now();
     let hoveredId = null;
-    const events = [];
     canvas.addEventListener("click", (ev) => {
         const mouse = getCanvasPosition(ev);
         if (hoveredId === null)
@@ -628,7 +658,16 @@ const runEngine = async (props) => {
                 };
             });
             for (const nextState of nextStateFns) {
-                const result = nextState({ state, event, keyboard, playSound, playMusic, pauseMusic });
+                const result = nextState({
+                    state,
+                    event,
+                    keyboard,
+                    playSound,
+                    playMusic,
+                    pauseMusic,
+                    resumeMusic,
+                    setMusicVolume,
+                });
                 // STOP stops the rest of the list from running for this event,
                 // instead of every later mechanic needing to repeat the same
                 // guard. undefined just means this mechanic made no change, so
@@ -747,6 +786,7 @@ const runEngine = async (props) => {
     resetCanvas = () => {
         clearInterval(intervalId);
     };
+    return { sendEvent };
 };
 
 exports.STOP = STOP;

package/lib/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.d.ts

@@ -1,4 +1,4 @@
 import { runEngine } from "./engine/runEngine";
 import { STOP } from "./engine/types";
 export { runEngine, STOP };
-export type { NextStateFunction, NextStateProps, Renderable, GameEvent } from "./engine/types";
+export type { NextStateFunction, NextStateProps, Renderable, GameEvent, CustomGameEvent, } from "./engine/types";

package/lib/index.js

@@ -145,6 +145,14 @@ const runEngine = async (props) => {
     // leaking to the rest of the page (e.g. arrow keys scrolling the window).
     canvas.tabIndex = 0;
     let state = props.initialState;
+    const events = [];
+    // Lets a caller report something that happened outside the render loop
+    // (e.g. a fetch().then() callback) back into it — the event is queued
+    // here and delivered to nextState as a CustomGameEvent on the next tick,
+    // the same as any built-in event.
+    const sendEvent = (event) => {
+        events.push({ tag: "CUSTOM", event });
+    };
     const resources = props.resources ?? {};
     const resourceById = await iterateRecordAsync(resources, async ({ value }) => new Promise((resolve) => {
         const image = new Image();
@@ -182,11 +190,24 @@ const runEngine = async (props) => {
     };
     const music = props.music ?? {};
     const musicById = await iterateRecordAsync(music, ({ value }) => loadAudio(value.src));
+    // Registered once per track at load time — fires only for a track
+    // whose `loop` is false, since a looping <audio> never reaches "ended"
+    // (the browser restarts it before the event would fire).
+    for (const id of getKeys(musicById)) {
+        musicById[id].addEventListener("ended", () => {
+            events.push({ tag: "MUSIC_END", id });
+        });
+    }
     // Unlike sounds, music reuses the same element instead of cloning it —
     // there's only ever one track playing, and reusing it is what lets
     // pauseMusic()/playMusic() resume from where playback left off instead
     // of starting over.
     let currentMusic = null;
+    // Volume is a property of each HTMLAudioElement, not global — tracked
+    // separately here and (re)applied on every playMusic() so switching
+    // tracks keeps the volume the game last set instead of resetting to
+    // each element's default of 1.
+    let musicVolume = 1;
     const playMusic = (id) => {
         const audio = musicById[id];
         if (audio === undefined) {
@@ -195,18 +216,28 @@ const runEngine = async (props) => {
         if (currentMusic !== null && currentMusic !== audio) {
             currentMusic.pause();
         }
-        audio.loop = true;
+        audio.loop = music[id]?.loop ?? true;
+        audio.volume = musicVolume;
         audio.play();
         currentMusic = audio;
     };
     const pauseMusic = () => {
         currentMusic?.pause();
     };
+    const resumeMusic = () => {
+        currentMusic?.play();
+    };
+    const setMusicVolume = (volume) => {
+        musicVolume = Math.min(1, Math.max(0, volume));
+        if (currentMusic !== null) {
+            currentMusic.volume = musicVolume;
+        }
+    };
     // A newer runEngine() call started while this one was still loading
     // resources (e.g. a spritesheet) — abandon this run instead of setting
     // up a second, orphaned render loop alongside the newer one.
     if (runId !== latestRunId) {
-        return;
+        return { sendEvent };
     }
     context.imageSmoothingEnabled = false;
     // An offscreen 1x1 canvas used only to resolve a CSS color string (a
@@ -496,7 +527,6 @@ const runEngine = async (props) => {
     const nextStateFns = Array.isArray(props.nextState) ? props.nextState : [props.nextState];
     let lastFrame = Date.now();
     let hoveredId = null;
-    const events = [];
     canvas.addEventListener("click", (ev) => {
         const mouse = getCanvasPosition(ev);
         if (hoveredId === null)
@@ -626,7 +656,16 @@ const runEngine = async (props) => {
                 };
             });
             for (const nextState of nextStateFns) {
-                const result = nextState({ state, event, keyboard, playSound, playMusic, pauseMusic });
+                const result = nextState({
+                    state,
+                    event,
+                    keyboard,
+                    playSound,
+                    playMusic,
+                    pauseMusic,
+                    resumeMusic,
+                    setMusicVolume,
+                });
                 // STOP stops the rest of the list from running for this event,
                 // instead of every later mechanic needing to repeat the same
                 // guard. undefined just means this mechanic made no change, so
@@ -745,6 +784,7 @@ const runEngine = async (props) => {
     resetCanvas = () => {
         clearInterval(intervalId);
     };
+    return { sendEvent };
 };
 
 export { STOP, runEngine };

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuuna-engine",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A lightweight, state-machine-based TypeScript game engine for quick prototypes. Runs directly in the browser.",
   "type": "module",
   "main": "./lib/index.cjs",