@moku-labs/game 0.7.1 → 0.9.0

package/dist/{types-BMEn0tSC.d.mts → types-B0v5VVa3.d.mts}

@@ -2741,7 +2741,7 @@ declare function to<const TargetName extends string, Payload, Output>(target: Ta
  */
 declare function slot(name: string): SlotNode;
 declare namespace types_d_exports$3 {
-  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$3 as Config, Contribution, DefineNode, Deps$3 as Deps, Descriptor, Edges, EmitterIdOf, EnterCallback, Events$3 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeaturesApi, FlowCtx, FlowDefinition, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, InboxApi, JournalEntry, KernelSlice$3 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, OutcomeTags, Position, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$3 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
+  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$3 as Config, Contribution, DefineNode, Deps$3 as Deps, Descriptor, Edges, EmitterIdOf, EnterCallback, Events$3 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeaturesApi, FlowCtx, FlowDefinition, FlowEntry, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, InboxApi, JournalEntry, KernelSlice$3 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, NodeTable, OutcomeTags, Position, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$3 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
 }
 /**
  * flow plugin events.
@@ -3983,8 +3983,8 @@ type ComponentHandle<Value extends object> = {
  */
 type Narrowed<Value extends object, Patch> = Omit<ComponentType<Value>, never> & ((patch?: Patch) => ComponentValue<Value>);
 /**
- * A resource type made by `resource()`: one mutable object per world, created from a deep clone
- * of the defaults on first read.
+ * A resource type made by `resource()`: one mutable object per world, made on first read from a
+ * deep clone of the plain defaults, or by one call of the factory default.
  *
  * @example
  * ```ts
@@ -3993,8 +3993,8 @@ type Narrowed<Value extends object, Patch> = Omit<ComponentType<Value>, never> &
  * ```
  */
 type ResourceType<Value extends object> = {
-  readonly resourceName: string;
-  readonly defaults: Readonly<Value>;
+  readonly resourceName: string; /** The frozen plain defaults, or the factory a world calls once on first read. */
+  readonly defaults: Readonly<Value> | (() => Value);
 };
 /**
  * A query term marked as written by `mut()`. Its only effect is change detection.
@@ -4061,7 +4061,8 @@ type QueryTuple<Terms extends readonly QueryTerm[]> = [Entity, ...QueryValues<Te
 /**
  * What a system receives next to its entities: the world, the mutable resources, the frozen model
  * snapshot of the frame and the frame's `Time`. A system may read pure game rules; it never
- * writes the model.
+ * writes the model. A system plays animations through `res(AnimPlayer)`, the resource `anim`
+ * writes when it starts.
  *
  * @example
  * ```ts
@@ -4524,8 +4525,8 @@ type EcsApi = {
    */
   query<const Terms extends readonly QueryTerm[]>(...terms: Terms): Iterable<QueryTuple<Terms>>;
   /**
-   * Returns the one mutable value of a resource, created from a deep clone of its defaults on
-   * first read.
+   * Returns the one mutable value of a resource, made on first read: a deep clone of its plain
+   * defaults, or what its factory default returns, called once per world.
    *
    * @param resourceType - The resource type.
    * @returns The mutable resource value.
@@ -7180,4 +7181,4 @@ type FlowRest = {
   checkpoint: boolean;
 };
 //#endregion
-export { Ease as $, SaveDoc as $t, Config$2 as A, JournalEntry as At, ComponentValue as B, State$4 as Bt, Captured as C, to as Ct, Point as D, DefineNode as Dt, FilterSlot as E, Bookmark as Et, AnyComponentType as F, GuideOptions as Ft, Narrowed as G, Events$4 as Gt, EntitySnapshot as H, types_d_exports$4 as Ht, AnyComponentValue as I, Hint as It, ResourceType as J, State$5 as Jt, Owner as K, Json as Kt, ComponentHandle as L, Answer as Lt, State$2 as M, SceneIdOf as Mt, types_d_exports$2 as N, TypeTag as Nt, ViewportSize as O, FlowGraph as Ot, AnyComponent as P, Descriptor as Pt, DescriptionNode as Q, ProviderCall as Qt, ComponentSchema as R, Api$4 as Rt, types_d_exports$1 as S, slot as St, DebugSwitches as T, FeatureDescription as Tt, FrameDiff as U, Api$5 as Ut, Entity as V, Time as Vt, Mut as W, Config$5 as Wt, TagType as X, Patch as Xt, SystemDefinition as Y, types_d_exports$5 as Yt, ChangeHook as Z, PlayerStateProvider as Zt, PixiModule as _, Events$6 as _n, State$3 as _t, DefineBundles as a, Api$6 as an, ProjectionMotion as at, State$1 as b, defineFlow as bt, LoadReason as c, PauseReason as cn, TrackSegment as ct, Tier as d, Api$7 as dn, BundlesOf as dt, SaveUnreadableError as en, LayerSort as et, Usage as f, Config$7 as fn, Config$3 as ft, PixiFilter as g, Config$8 as gn, Position as gt, Config$1 as h, types_d_exports$7 as hn, GameTypes as ht, Config as i, RngState as in, NumericFields as it, Explained as j, RouteStep as jt, Api$2 as k, FlowState as kt, Manifest as l, State$6 as ln, ViewHandle as lt, Api$1 as m, State$7 as mn, FeaturePlugin as mt, BundleMap as n, StoreApi as nn, Motion as nt, Events as o, Config$6 as on, ProjectionSpec as ot, types_d_exports as p, FakeClock as pn, EmitterIdOf as pt, QueryTerm as q, Root as qt, BundleSpec as r, RngApi as rn, MotionHandle as rt, LoadBundles as s, Events$5 as sn, TrackOptions as st, Api as t, Snapshot as tn, LayerSpec as tt, State as u, types_d_exports$6 as un, Api$3 as ut, PixiSprite as v, Require as vn, TextStylesOf as vt, RenderStats as w, type as wt, Under as x, exit as xt, PixiTexture as y, types_d_exports$3 as yt, ComponentType as z, Config$4 as zt };
+export { Ease as $, PlayerStateProvider as $t, Config$2 as A, FlowState as At, ComponentValue as B, Api$4 as Bt, Captured as C, to as Ct, Point as D, Bookmark as Dt, FilterSlot as E, AnyFlow as Et, AnyComponentType as F, TypeTag as Ft, Narrowed as G, Api$5 as Gt, EntitySnapshot as H, State$4 as Ht, AnyComponentValue as I, Descriptor as It, ResourceType as J, Json as Jt, Owner as K, Config$5 as Kt, ComponentHandle as L, GuideOptions as Lt, State$2 as M, NodeTable as Mt, types_d_exports$2 as N, RouteStep as Nt, ViewportSize as O, DefineNode as Ot, AnyComponent as P, SceneIdOf as Pt, DescriptionNode as Q, Patch as Qt, ComponentSchema as R, Hint as Rt, types_d_exports$1 as S, slot as St, DebugSwitches as T, FeatureDescription as Tt, FrameDiff as U, Time as Ut, Entity as V, Config$4 as Vt, Mut as W, types_d_exports$4 as Wt, TagType as X, State$5 as Xt, SystemDefinition as Y, Root as Yt, ChangeHook as Z, types_d_exports$5 as Zt, PixiModule as _, State$7 as _n, State$3 as _t, DefineBundles as a, RngApi as an, ProjectionMotion as at, State$1 as b, Events$6 as bn, defineFlow as bt, LoadReason as c, Config$6 as cn, TrackSegment as ct, Tier as d, State$6 as dn, BundlesOf as dt, ProviderCall as en, LayerSort as et, Usage as f, types_d_exports$6 as fn, Config$3 as ft, PixiFilter as g, FakeClock as gn, Position as gt, Config$1 as h, Config$7 as hn, GameTypes as ht, Config as i, StoreApi as in, NumericFields as it, Explained as j, JournalEntry as jt, Api$2 as k, FlowGraph as kt, Manifest as l, Events$5 as ln, ViewHandle as lt, Api$1 as m, ClockSource as mn, FeaturePlugin as mt, BundleMap as n, SaveUnreadableError as nn, Motion as nt, Events as o, RngState as on, ProjectionSpec as ot, types_d_exports as p, Api$7 as pn, EmitterIdOf as pt, QueryTerm as q, Events$4 as qt, BundleSpec as r, Snapshot as rn, MotionHandle as rt, LoadBundles as s, Api$6 as sn, TrackOptions as st, Api as t, SaveDoc as tn, LayerSpec as tt, State as u, PauseReason as un, Api$3 as ut, PixiSprite as v, types_d_exports$7 as vn, TextStylesOf as vt, RenderStats as w, type as wt, Under as x, Require as xn, exit as xt, PixiTexture as y, Config$8 as yn, types_d_exports$3 as yt, ComponentType as z, Answer as zt };

package/dist/{types-ClF8say0.d.mts → types-CQueODzo.d.mts}

@@ -1,5 +1,5 @@
-import { D as Point, E as FilterSlot, L as ComponentHandle, V as Entity, _ as PixiModule, _n as Events$1, g as PixiFilter, k as Api$1, m as Api$2, o as Events, t as Api$3, ut as Api, v as PixiSprite, vn as Require, y as PixiTexture, z as ComponentType } from "./types-BMEn0tSC.mjs";
-import { b as AnimApi } from "./types-CXyipKhE.mjs";
+import { D as Point, E as FilterSlot, L as ComponentHandle, V as Entity, _ as PixiModule, bn as Events$1, g as PixiFilter, k as Api$1, m as Api$2, o as Events, t as Api$3, ut as Api, v as PixiSprite, xn as Require, y as PixiTexture, z as ComponentType } from "./types-B0v5VVa3.mjs";
+import { b as AnimApi } from "./types-VZVWwqCg.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{types-CYYKjvLn.d.mts → types-DUMoYPYe.d.mts}

@@ -1,184 +1,7 @@
-import { At as JournalEntry, Kt as Json, Lt as Answer, Rt as Api, in as RngState, jt as RouteStep, kt as FlowState, tn as Snapshot, ut as Api$1 } from "./types-BMEn0tSC.mjs";
+import { Jt as Json, rn as Snapshot } from "./types-B0v5VVa3.mjs";
+import { t as HeadlessApp } from "./headless-SCQXJxQf.mjs";
 import { Log } from "@moku-labs/common/browser";
 
-//#region src/plugins/flow/headless.d.ts
-/**
- * The part of an app the headless helpers use. Structural on purpose: any app created with the
- * default plugins fits.
- *
- * @example
- * ```ts
- * const app: HeadlessApp = createApp({ pluginConfigs: { flow: { mainFlow } } });
- * ```
- */
-type HeadlessApp = {
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  time: Api;
-  flow: Api$1;
-};
-/**
- * A game played without a screen: answers go through the gate, effects resolve instantly.
- *
- * @example
- * ```ts
- * // A test of the dice game: two rolls, no screen, no waiting.
- * const game = await createHeadless(app);
- * const state = await game.walk([{ at: "home", intent: "roll" }, { at: "home", intent: "roll" }]);
- *
- * state.path; // "home"
- * await game.stop();
- * ```
- */
-type HeadlessGame = {
-  /**
-   * Walks a route through the running loop.
-   *
-   * @param route - The player's answers and substituted sub-flow results, in order.
-   * @returns The state the walk ended in.
-   * @throws {Error} When a step is never reached, or the loop failed fatally.
-   * @example
-   * ```ts
-   * // Open the board and tap the generator twice. Every node's logic runs for real.
-   * const tap = { at: "board/awaitIntent", intent: "tap", payload: { generatorId: "sawmill" } };
-   * const state = await game.walk([{ at: "home", intent: "play" }, tap, tap]);
-   *
-   * state.path; // "board/awaitIntent"
-   * ```
-   */
-  walk(route: readonly RouteStep[]): Promise<FlowState>;
-  /**
-   * Gives one answer to the gate, the way a tap does.
-   *
-   * @param answer - Intent and optional payload.
-   * @returns Whether the gate took it.
-   * @example
-   * ```ts
-   * // One tap without a route. The test then waits for the loop by itself.
-   * game.answer({ intent: "play" }); // true: "home" rests and lists "play"
-   * ```
-   */
-  answer(answer: Answer): boolean;
-  /**
-   * Reads where the graph stands.
-   *
-   * @returns Whether it runs, the path, the stack, what it waits for and the mode.
-   * @example
-   * ```ts
-   * // Right after createHeadless: the graph rests at its first rest node.
-   * game.state().path; // "home"
-   * game.state().pending; // { gate: ["play"] }
-   * ```
-   */
-  state(): FlowState;
-  /**
-   * Reads the edges taken since the last checkpoint.
-   *
-   * @returns A copy of the journal.
-   * @example
-   * ```ts
-   * // After a merge onto an empty cell: the last edge says why the move was refused.
-   * const last = game.history().at(-1);
-   * // last?.path: "board/merge", last?.outcome: "rejected", last?.payload: { reason: "empty" }
-   * ```
-   */
-  history(): readonly JournalEntry[];
-  /**
-   * Stops the app, then re-throws a fatal error of the loop.
-   *
-   * @throws {Error} When the loop failed fatally.
-   * @example
-   * ```ts
-   * // The last line of a headless test. A fatal error of the loop fails the test here.
-   * await game.stop();
-   * ```
-   */
-  stop(): Promise<void>;
-};
-/**
- * A reproducible run: a starting state, an optional checkpoint and the route played from it.
- *
- * @example
- * ```ts
- * const repro: Repro = { player: { coins: 0 }, checkpoint: "home", route: [{ at: "home", intent: "play" }] };
- * ```
- */
-type Repro = {
-  player: Json;
-  session?: Json;
-  rng?: RngState;
-  checkpoint?: string;
-  route: RouteStep[];
-};
-/**
- * What a repro run ends with: the path where the loop rests and the committed state.
- *
- * @example
- * ```ts
- * const result: ReproResult = { path: ["home"], player: { coins: 3 }, session: { visits: 1 } };
- * ```
- */
-type ReproResult = {
-  path: string[];
-  player: Json;
-  session: Json;
-};
-/**
- * Starts an app headless: sets flow mode `"fast"`, awaits `app.start()`, starts `flow.run()`
- * unless the app's own `onStart` already did, and waits until the loop rests for the first time.
- * `game.state().path` therefore names the first rest node of the graph as soon as the call
- * resolves. A fatal error of the loop rejects this call, and a later one is re-thrown by `walk`
- * and by `stop`, so a headless test never loses it.
- *
- * @param app - An app that is not started yet.
- * @returns The game: walk it, answer it, read it, stop it.
- * @throws {Error} When the loop failed fatally before it reached its first rest node.
- * @example
- * ```ts
- * // A test starts the merge game without a screen. The call resolves at the first rest node.
- * const game = await createHeadless(app);
- *
- * game.state().path; // "home": the transit node "boot" was played out
- * game.state().mode; // "fast"
- * await game.stop();
- * ```
- */
-declare function createHeadless(app: HeadlessApp): Promise<HeadlessGame>;
-/**
- * Plays a repro: starts the app headless, restores the bookmark built from its state and
- * checkpoint, then walks its route. The app keeps running, so the caller can read more than the
- * result and stops it itself.
- *
- * @param app - An app that is not started yet.
- * @param repro - Starting state, optional checkpoint and the route.
- * @returns The path the run ended at, and the committed state.
- * @example
- * ```ts
- * // A bug report on the dice game: "reset keeps my coins". Replay it from the "home" checkpoint.
- * const reset = { at: "home", intent: "reset" };
- * const result = await runRepro(app, { player: { coins: 7 }, checkpoint: "home", route: [reset] });
- *
- * result.player; // { coins: 0 }; result.path is ["home"]
- * await app.stop(); // the app keeps running after the run
- * ```
- */
-declare function runRepro(app: HeadlessApp, repro: Repro): Promise<ReproResult>;
-/**
- * Steps the frame loop by hand: `count` calls of `app.time.step(deltaMs)`. A headless game has no
- * frame source, so this is the only thing that moves the frame phases.
- *
- * @param app - A started app.
- * @param count - Number of frames.
- * @param deltaMs - Milliseconds per frame.
- * @example
- * ```ts
- * // A headless game has no frame source: the test moves the six frame phases by hand.
- * stepFrames(app, 2, 16);
- * app.time.snapshot(); // frame: 2, delta: 16, elapsed: 32
- * ```
- */
-declare function stepFrames(app: HeadlessApp, count: number, deltaMs: number): void;
-//#endregion
 //#region src/plugins/flow/doors/types.d.ts
 /**
  * The kinds an input field can take. `json` is any JSON value the command checks itself.
@@ -276,7 +99,7 @@ type Effect = "read" | "route" | "cosmetic" | "cheat" | "raw";
  * ```ts
  * // A game's .dev module: the coins a panel shows, re-read on every commit.
  * const coins = defineSource({
- *   id: "timber.coins",
+ *   id: "mini.coins",
  *   title: "Coins",
  *   input: {},
  *   changes: "commit",
@@ -300,7 +123,7 @@ type Source<S extends InputSchema, O, App = HeadlessApp> = {
  * ```ts
  * // A game's .dev module: jump to a level through the graph, the session stays clean.
  * const jumpToLevel = defineCommand({
- *   id: "timber.jumpToLevel",
+ *   id: "mini.jumpToLevel",
  *   title: "Go to level",
  *   input: { level: "number" },
  *   effect: "route",
@@ -389,4 +212,4 @@ type ControlApp = HeadlessApp & {
   readonly log: Log.LogApi;
 };
 //#endregion
-export { stepFrames as _, InputOf as a, Source as c, HeadlessApp as d, HeadlessGame as f, runRepro as g, createHeadless as h, InputArguments as i, WatchApp as l, ReproResult as m, Command as n, InputSchema as o, Repro as p, ControlApp as r, Ran as s, CheatEntry as t, WatchInput as u };
+export { InputOf as a, Source as c, InputArguments as i, WatchApp as l, Command as n, InputSchema as o, ControlApp as r, Ran as s, CheatEntry as t, WatchInput as u };

package/dist/{types-CXyipKhE.d.mts → types-VZVWwqCg.d.mts}

@@ -1,5 +1,5 @@
-import { $ as Ease, Gt as Events$3, I as AnyComponentValue, K as Owner, Kt as Json, L as ComponentHandle, Nt as TypeTag, P as AnyComponent, Pt as Descriptor, Rt as Api, Ut as Api$5, V as Entity, _n as Events$2, ct as TrackSegment, et as LayerSort, it as NumericFields, k as Api$2, m as Api$3, o as Events$5, rt as MotionHandle, sn as Events$4, st as TrackOptions, t as Api$4, tt as LayerSpec, ut as Api$1, vn as Require, z as ComponentType } from "./types-BMEn0tSC.mjs";
-import { D as TextApi, H as InputApi, I as I18nApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-BaUUcIaN.mjs";
+import { $ as Ease, Bt as Api, Ft as TypeTag, Gt as Api$5, I as AnyComponentValue, It as Descriptor, Jt as Json, K as Owner, L as ComponentHandle, P as AnyComponent, V as Entity, bn as Events$2, ct as TrackSegment, et as LayerSort, it as NumericFields, k as Api$2, ln as Events$4, m as Api$3, o as Events$5, qt as Events$3, rt as MotionHandle, st as TrackOptions, t as Api$4, tt as LayerSpec, ut as Api$1, xn as Require, z as ComponentType } from "./types-B0v5VVa3.mjs";
+import { D as TextApi, H as InputApi, I as I18nApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-xXfyk56Q.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -632,7 +632,7 @@ type RunningTimeline = {
   ended: boolean;
 };
 declare namespace types_d_exports$3 {
-  export { AnimApi, AnimCtx, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$3 as Config, Cursor, Deps$3 as Deps, ErasedFields, Events$1 as Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$3 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$3 as State, Step, StepMotion, Target, TimelineRuntime, Track };
+  export { AnimApi, AnimCtx, AnimPlayerValue, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$3 as Config, Cursor, Deps$3 as Deps, ErasedFields, Events$1 as Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$3 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$3 as State, Step, StepMotion, Target, TimelineRuntime, Track };
 }
 /**
  * What a step and a slot are pointed at: the projection key of a live view or of an element a
@@ -1056,6 +1056,44 @@ type AnimApi = {
    */
   replace(definition: AnyAnimationDefinition): void;
 };
+/**
+ * What a system may do with anim, read with `res(AnimPlayer)`: play. A system that needs more
+ * than play is a plugin. Play on a change, never on every frame: keep the handle in a resource, or
+ * take away the tag that asked for the play.
+ *
+ * @example
+ * ```ts
+ * // A fresh item pops once: the system plays, then takes the Fresh tag away.
+ * const popIn = system({ name: "popIn", phase: "input", query: [Fresh], run: (items, { world, res }) => {
+ *   for (const [entity] of items) {
+ *     res(AnimPlayer).play(pop, { thing: entity });
+ *     world.untag(entity, Fresh);
+ *   }
+ * } });
+ * ```
+ */
+type AnimPlayerValue = {
+  /**
+   * Plays an animation from a system, the way `app.anim.play` does. The registered animation of
+   * `animation.id` wins when a feature brought one, so a hot swap reaches the system. Played from
+   * phase `input`, the tree moves in `animate` of the same frame; from a later phase it moves
+   * from the next frame.
+   *
+   * @param animation - What `defineAnimation` returned.
+   * @param slots - One target, or a list of targets, per declared slot.
+   * @returns The handle: `cancel()`, `finish()`, `active()`, `done`, `marks()`.
+   * @throws {Error} Before `anim` started: `[game] AnimPlayer is not ready: anim has not started.`
+   * @example
+   * ```ts
+   * const lift = defineAnimation("look.hover", { slots: { thing: type<Target>() },
+   *   build: ({ thing }) => tween(thing, Transform, { scale: 1.1 }, { ms: 100 }) });
+   * // Inside a system of phase "input": entity 1048576 is the item under the pointer.
+   * const handle = res(AnimPlayer).play(lift, { thing: 1_048_576 });
+   * handle.active(); // true until the lift lands 100 ms later, then false
+   * ```
+   */
+  play<Tags extends SlotTags>(animation: AnimationDefinition<Tags>, slots: SlotValues<Tags>): PlayHandle;
+};
 /**
  * Resolved dependency APIs. `renderer` is not among them: `anim` writes its `Sprite` and reads
  * its `Transform` through the component objects, which are plain data, composes the root pose
@@ -1995,4 +2033,4 @@ type MusicRequest = {
   fadeMs: number;
 };
 //#endregion
-export { HAPTIC_KINDS as A, sfx as B, MotionKeyframe as C, HapticKind as D, types_d_exports$3 as E, mark as F, use as G, spawned as H, parallel as I, wait as K, play as L, external as M, frames as N, SfxDescriptor as O, haptic as P, sequence as R, FramesValue as S, Target as T, stagger as U, spawn as V, tween as W, State$2 as _, SoundEntry as a, AnimApi as b, AnySceneProjection as c, SceneDefinition as d, SceneSpec as f, Config$2 as g, types_d_exports$1 as h, MusicOptions as i, defineAnimation as j, Step as k, DefineScene as l, State$1 as m, Config as n, State as o, ScenesApi as p, MusicDescriptor as r, types_d_exports as s, AudioApi as t, LayerMap as u, UiApi as v, State$3 as w, Config$3 as x, types_d_exports$2 as y, set as z };
+export { Step as A, set as B, FramesValue as C, types_d_exports$3 as D, Target as E, haptic as F, tween as G, spawn as H, mark as I, use as K, parallel as L, defineAnimation as M, external as N, HapticKind as O, frames as P, play as R, Config$3 as S, State$3 as T, spawned as U, sfx as V, stagger as W, State$2 as _, SoundEntry as a, AnimApi as b, AnySceneProjection as c, SceneDefinition as d, SceneSpec as f, Config$2 as g, types_d_exports$1 as h, MusicOptions as i, HAPTIC_KINDS as j, SfxDescriptor as k, DefineScene as l, State$1 as m, Config as n, State as o, ScenesApi as p, wait as q, MusicDescriptor as r, types_d_exports as s, AudioApi as t, LayerMap as u, UiApi as v, MotionKeyframe as w, AnimPlayerValue as x, types_d_exports$2 as y, sequence as z };

package/dist/{types-BaUUcIaN.d.mts → types-xXfyk56Q.d.mts}

@@ -1,4 +1,4 @@
-import { B as ComponentValue, D as Point$2, F as AnyComponentType, I as AnyComponentValue, It as Hint, Kt as Json, O as ViewportSize, P as AnyComponent, Pt as Descriptor, Rt as Api, V as Entity, Z as ChangeHook, at as ProjectionMotion, dn as Api$5, it as NumericFields, k as Api$2, lt as ViewHandle, m as Api$3, nt as Motion, o as Events$1, rt as MotionHandle, t as Api$4, ut as Api$1, vn as Require, z as ComponentType } from "./types-BMEn0tSC.mjs";
+import { B as ComponentValue, Bt as Api, D as Point$2, F as AnyComponentType, I as AnyComponentValue, It as Descriptor, Jt as Json, O as ViewportSize, P as AnyComponent, Rt as Hint, V as Entity, Z as ChangeHook, at as ProjectionMotion, it as NumericFields, k as Api$2, lt as ViewHandle, m as Api$3, nt as Motion, o as Events$1, pn as Api$5, rt as MotionHandle, t as Api$4, ut as Api$1, xn as Require, z as ComponentType } from "./types-B0v5VVa3.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{visual-DUvvPPCt.mjs → visual-dMW8iqAE.mjs}

@@ -60,22 +60,26 @@ function tag(name) {
 	return tagType;
 }
 /**
-* Declares a resource: one mutable object per world, created from a deep clone of the defaults
-* on first read.
+* Declares a resource: one mutable object per world, made on first read. Plain defaults are
+* deep-cloned. A factory is called instead, once per world, so the value may hold a function or a
+* `Map`.
 *
 * @param name - Storage name, unique per world.
-* @param defaults - The value a fresh world starts with.
+* @param defaults - The value a fresh world starts with, or the factory that makes it.
 * @returns The resource type.
 * @example
 * ```ts
 * const Pointer = resource("Pointer", { x: 0, y: 0, down: false });
 * Pointer.defaults; // { x: 0, y: 0, down: false }
+*
+* // A resource that holds a Map: a factory, called once per world on first read.
+* const Looks = resource("boardLooks", () => ({ shown: new Map<Entity, { look: string }>() }));
 * ```
 */
 function resource(name, defaults) {
 	return {
 		resourceName: name,
-		defaults: Object.freeze({ ...defaults })
+		defaults: typeof defaults === "function" ? defaults : Object.freeze({ ...defaults })
 	};
 }
 /**