@moku-labs/game 0.15.30 → 0.15.32

package/dist/app/page.d.mts

@@ -1,4 +1,4 @@
-import { m as StartedPage, r as GameConfig, t as AnyGameApp, u as PageOptions } from "../types-BWRJcZ3n.mjs";
+import { m as StartedPage, r as GameConfig, t as AnyGameApp, u as PageOptions } from "../types-DmU_qlvA.mjs";
 
 //#region src/app/page.d.ts
 /**

package/dist/app/page.mjs

@@ -1,6 +1,7 @@
 import { r as systemSource, t as memory } from "../memory-CWlqhS7l.mjs";
 import { t as applyTo } from "../drafts-BawpSaVp.mjs";
 import { i as isControl } from "../dev-BNndV-hU.mjs";
+import { n as fakeClock, t as VISUAL_CLOCK } from "../fake-hnJcJeYf.mjs";
 import { n as read, r as watch, t as sources } from "../sources-DM5Zcl4o.mjs";
 import { t as resolveConfig } from "../config-B87aFTW-.mjs";
 //#region src/app/save.ts
@@ -211,6 +212,20 @@ function toError(thrown) {
 	return thrown instanceof Error ? thrown : new Error(String(thrown));
 }
 /**
+* The clock of the page: the device clock; on a dev page a visual test's pixel leg opened, the fake
+* clock its headless leg runs on, standing at the same moment (F86). The leg puts the moment on the
+* page before it loads, so the app never sees the device time.
+*
+* @returns The clock source of the page.
+*/
+function pageClock() {
+	if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) {
+		const moment = Reflect.get(globalThis, VISUAL_CLOCK);
+		if (typeof moment === "number") return fakeClock(moment);
+	}
+	return systemSource();
+}
+/**
 * Picks the start of the page from `?player=`: the named scenario's player and session, at the
 * device time. An unknown name is reported, and the page starts from the starting player.
 *
@@ -382,7 +397,7 @@ async function startPage(game, config, options = {}) {
 	const settings = resolveConfig(config);
 	const query = new URLSearchParams(location.search);
 	const { report, attach } = lateReporter();
-	const clock = systemSource();
+	const clock = pageClock();
 	const start = scenarioStart(query.get("player"), options.scenarios ?? {}, clock.now(), report);
 	const shell = options.system === void 0 ? void 0 : await options.system(settings, report);
 	const namespace = settings.native?.identifier ?? "moku-game";

package/dist/app/system.d.mts

@@ -1,6 +1,6 @@
 import { Mr as PlayerStateProvider } from "../types-D27I4Q7b.mjs";
-import { ht as PlatformProvider } from "../index-B2GejbLf.mjs";
-import { _ as SystemShellFactory, g as SystemName, h as SystemModules } from "../types-BWRJcZ3n.mjs";
+import { ht as PlatformProvider } from "../index-DMeqKGSu.mjs";
+import { _ as SystemShellFactory, g as SystemName, h as SystemModules } from "../types-DmU_qlvA.mjs";
 import { Back, Haptics, KeepAwake, Lifecycle, Store } from "@moku-labs/system";
 
 //#region src/app/system.d.ts

package/dist/app.d.mts

@@ -1,6 +1,6 @@
 import { Dr as Json } from "./types-D27I4Q7b.mjs";
 import { U as StringTable } from "./types-BAp9HdR4.mjs";
-import { a as GameHandle, c as MemoryProvider, d as SaveKind, f as Scenario, g as SystemName, i as GameDefinition, l as PageAgent, n as GameApp, o as GamePluginConfigs, p as ScreenSeams, r as GameConfig, s as HeadlessSeams, v as WithGameState } from "./types-BWRJcZ3n.mjs";
+import { a as GameHandle, c as MemoryProvider, d as SaveKind, f as Scenario, g as SystemName, i as GameDefinition, l as PageAgent, n as GameApp, o as GamePluginConfigs, p as ScreenSeams, r as GameConfig, s as HeadlessSeams, v as WithGameState } from "./types-DmU_qlvA.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/app/define.d.ts

package/dist/app.mjs

@@ -1,6 +1,6 @@
-import { Ft as audioPlugin, H as platformPlugin, i as screen, m as flattenFeatures, t as createApp, wt as effectsPlugin } from "./src-B4JjsuEy.mjs";
+import { Ft as audioPlugin, H as platformPlugin, i as screen, m as flattenFeatures, t as createApp, wt as effectsPlugin } from "./src-5qdNjLKN.mjs";
 import { t as memory } from "./memory-CWlqhS7l.mjs";
-import { n as isFakeClock, t as fakeClock } from "./fake-6mazmHK3.mjs";
+import { n as fakeClock, r as isFakeClock } from "./fake-hnJcJeYf.mjs";
 //#region src/app/define.ts
 /**
 * The moment the default fake clock starts at, in epoch milliseconds. A test stamps times from it.

package/dist/{commands-BUfZJUx6.d.mts → commands-C8N_rpwt.d.mts}

@@ -1,5 +1,5 @@
 import { $r as Time, D as DebugSwitches, Ir as Snapshot, Rr as StoreApi, Vr as Api, Y as Api$1, Yr as FrameRate, ar as FlowState, nn as Api$2, nr as Bookmark, ot as Captured, w as ScenesApi } from "./types-D27I4Q7b.mjs";
-import { P as AnimApi, a as AudioApi, h as EffectsApi, r as UiApi } from "./types-DjQkfbfZ.mjs";
+import { P as AnimApi, a as AudioApi, h as EffectsApi, r as UiApi } from "./types-DHamyZq1.mjs";
 import { N as InputApi } from "./types-BAp9HdR4.mjs";
 import { t as HeadlessApp } from "./headless-f31cEZ7f.mjs";
 import { n as Command, r as ControlApp } from "./types-CgE5L_7f.mjs";
@@ -122,7 +122,7 @@ declare const commands: Readonly<{
     readonly renderer: Api$1;
   }>;
   reducedMotion: Command<{
-    on: "boolean";
+    readonly on: "boolean";
   }, boolean, HeadlessApp & {
     readonly log: import("@moku-labs/common/browser").LogApi;
   } & {
@@ -165,8 +165,8 @@ declare const commands: Readonly<{
     readonly input: InputApi;
   }>;
   filter: Command<{
-    readonly kind: "string";
     readonly on: "boolean";
+    readonly kind: "string";
   }, readonly string[], HeadlessApp & {
     readonly log: import("@moku-labs/common/browser").LogApi;
   } & {

package/dist/control.d.mts

@@ -1,6 +1,6 @@
 import { t as HeadlessApp } from "./headless-f31cEZ7f.mjs";
 import { i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-CgE5L_7f.mjs";
-import { t as commands } from "./commands-BUfZJUx6.mjs";
+import { t as commands } from "./commands-C8N_rpwt.mjs";
 import { t as defineCommand } from "./define-CE1uxbe9.mjs";
 
 //#region src/plugins/flow/doors/dev.d.ts

package/dist/control.mjs

@@ -1,4 +1,4 @@
 import { n as controlRefused, t as controlReadOnly } from "./dev-BNndV-hU.mjs";
 import { s as defineCommand } from "./session-DuZfGZWk.mjs";
-import { n as commands, t as run } from "./run-DyL8rl2P.mjs";
+import { n as commands, t as run } from "./run-BnriyKUu.mjs";
 export { commands, controlReadOnly, controlRefused, defineCommand, run };

package/dist/{fake-6mazmHK3.mjs → fake-hnJcJeYf.mjs}

@@ -101,5 +101,11 @@ function fakeClock(start = 0) {
 function isFakeClock(source) {
 	return fakeClocks.has(source);
 }
+/**
+* The global a visual test's pixel leg sets on the dev page before it loads (F86): the moment of
+* the fake clock its headless leg runs on. The page of a dev build then runs on `fakeClock` at
+* that moment, so both legs see the same `clock.now()`. Not in the root.
+*/
+const VISUAL_CLOCK = "__mokuVisualClock";
 //#endregion
-export { isFakeClock as n, fakeClock as t };
+export { fakeClock as n, isFakeClock as r, VISUAL_CLOCK as t };

package/dist/{index-B2GejbLf.d.mts → index-DMeqKGSu.d.mts}

@@ -1,5 +1,5 @@
 import { $n as FeaturePlugin, An as NumericFields, B as ShapeValue, Bn as EmitterIdOf, C as SceneSpec, Cn as TagType, Dr as Json, Dt as PassKind, En as Ease, F as NineSliceValue, Gn as TextStylesOf, Gr as State$4, Hn as HudKeysOf, Hr as Config$4, Jr as Config$8, K as TransformValue, L as OverlayValue, Ln as Api$2, Mn as ProjectionSpec, N as HudPartValue, Nn as ReducedMotion, Or as Root, Qn as FeatureDescription, Qr as ThermalReading, Rn as BundlesOf, Rr as StoreApi, S as SceneDefinition, Sn as SystemFor, Sr as State$2, T as State$7, Tn as DescriptionNode, Tr as Config$5, U as SpriteOptions, Ur as Events, Vn as GameTypes, Vr as Api$3, W as SpriteValue, Wn as State$3, Wr as PauseReason, X as Config$6, Xr as RateChange, Y as Api$4, Zr as State$8, _ as AnySceneProjection, _n as Mut, _r as Answer, _t as FrameRing, a as Config$1, an as State$9, bn as ResourceType, br as Config$2, c as LoadBundles, dr as Descriptor, dt as ViewportSize, er as FeatureTree, f as ReadyBundles, fn as ComponentType, fr as Effect, gt as FrameRecord, hr as Hint, i as BundleSpec, jn as ProjectionMotion, jr as Patch, kr as State$5, l as LoadReason, lr as SceneIdOf, m as Tier, mr as GuideOptions, ni as Events$1, nn as Api$6, o as DefineBundles, p as State$1, pn as ComponentValue, pr as EffectOptions, q as sprite, qn as defineFlow, qr as Api$5, r as BundleMap, ri as Require, rn as Config$9, rr as DefineNode, rt as State$6, t as Api, ti as Config$10, u as LoadResult, un as ComponentHandle, v as Config$7, vn as Narrowed, vr as Api$1, w as ScenesApi, x as LayerMap, xn as SystemDefinition, y as DefineScene, yn as QueryTerm, zn as Config$3, zr as RngApi } from "./types-D27I4Q7b.mjs";
-import { A as GlowValue, B as Target, C as BlurValue, D as FilterComponent, F as AnimPlayerValue, H as HapticKind, I as Config$11, K as defineAnimation, L as FramesValue, M as OutlineValue, N as UniformDeclaration, O as FilterSpec, P as AnimApi, Q as play, R as MotionKeyframe, S as AlphaValue, T as DisplacementValue, U as SfxDescriptor, W as Step, _ as State$12, a as AudioApi, b as EmitterDefinition, c as MusicDescriptor, d as State$11, f as VolumesFor, h as EffectsApi, j as NoiseValue, k as FilterValueOf, l as MusicOptions, lt as OverlayApi, m as Config$13, n as State$13, r as UiApi, s as Config$12, t as Config$14, w as ColorMatrixValue, x as EmitterValue, y as EmitterConfig, z as State$10 } from "./types-DjQkfbfZ.mjs";
+import { A as GlowValue, B as Target, C as BlurValue, D as FilterComponent, F as AnimPlayerValue, H as HapticKind, I as Config$11, K as defineAnimation, L as FramesValue, M as OutlineValue, N as UniformDeclaration, O as FilterSpec, P as AnimApi, Q as play, R as MotionKeyframe, S as AlphaValue, T as DisplacementValue, U as SfxDescriptor, W as Step, _ as State$12, a as AudioApi, b as EmitterDefinition, c as MusicDescriptor, d as State$11, f as VolumesFor, h as EffectsApi, j as NoiseValue, k as FilterValueOf, l as MusicOptions, lt as OverlayApi, m as Config$13, n as State$13, r as UiApi, s as Config$12, t as Config$14, w as ColorMatrixValue, x as EmitterValue, y as EmitterConfig, z as State$10 } from "./types-DHamyZq1.mjs";
 import { B as Message, C as State$16, D as TextStyleInput, G as TypedTr, H as State$14, I as Argument, J as ResolvedStyle, L as Config$15, M as Config$16, N as InputApi, O as TextStyles, P as State$15, R as I18nApi, S as Point, T as TextBind, V as Part, W as TextKey, Y as Style, Z as WhenFlags, b as Config$17, g as IntrinsicElementsFor, h as defineTokens, j as defineComponent, k as TextValue, q as IsFlags, s as PopupComponent, v as BindField, w as TextApi, x as CountdownValue, y as BindOptions, z as IntlKit } from "./types-BAp9HdR4.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { $t as ShaderWhat, Ar as types_d_exports$10, At as PerfChange, Bt as PerfLongFrameLine, Cr as types_d_exports$3, Ct as PERF_CAUSES, Dt as PassKind, E as types_d_exports$13, Et as PROBLEM_RULES, Fr as SaveUnreadableError, Ft as PerfEventLine, G as Transform, Gt as PerfStartupLine, H as SpriteBlend, Ht as PerfMeasured, I as Overlay, It as PerfEventName, J as AdaptiveScale, Jn as exit, Jt as PoolTrimDetail, Kn as types_d_exports$6, Kr as types_d_exports$9, Kt as PerfTelemetryLine, L as OverlayValue, Lt as PerfGapLine, M as HudPart, Mt as PerfCollectorLine, N as HudPartValue, Nt as PerfCounts, Ot as PassRecord, P as NineSlice, Pt as PerfDisplay, Qt as ShaderEventDetail, R as Parent, Rt as PerfHeaderLine, St as OverlayWhat, Tn as DescriptionNode, Tt as PERF_LOG_VERSION, Ut as PerfSampleLine, V as Sprite, Vt as PerfMarkLine, Wt as PerfSpikeLine, Xn as to, Xt as ProblemRule, Yn as slot, Yt as ProblemEventDetail, Z as MonitorConfig, Zn as type, Zt as SHADER_WHATS, _t as FrameRing, at as types_d_exports$12, bt as MonitorSections, ei as types_d_exports$15, en as WarmDetail, g as types_d_exports$1, gt as FrameRecord, ht as FrameReadout, j as Display, jt as PerfChangeEntry, kt as PerfCause, mt as FrameReadResult, nt as PoolTrim, on as types_d_exports$17, pt as FrameColumns, q as sprite, qt as PerfThermalLine, st as MonitorCounts, tn as DEMAND_REASONS, vt as LongFrameEntry, wt as PERF_GAP_BUCKETS, xt as OverlayEventDetail, yt as MONITOR_SECTIONS, z as Shape, zt as PerfLogLine } from "./types-D27I4Q7b.mjs";
-import { $ as sequence, E as FilterArea, G as HAPTIC_KINDS, H as HapticKind, J as frames, K as defineAnimation, Q as play, V as types_d_exports, X as mark, Y as haptic, Z as parallel, at as stopSfx, ct as wait, et as set, i as types_d_exports$16, it as stagger, nt as spawn, ot as tween, p as types_d_exports$2, q as external, rt as spawned, st as use, tt as sfx, ut as types_d_exports$4, v as types_d_exports$5 } from "./types-DjQkfbfZ.mjs";
+import { $ as sequence, E as FilterArea, G as HAPTIC_KINDS, H as HapticKind, J as frames, K as defineAnimation, Q as play, V as types_d_exports, X as mark, Y as haptic, Z as parallel, at as stopSfx, ct as wait, et as set, i as types_d_exports$16, it as stagger, nt as spawn, ot as tween, p as types_d_exports$2, q as external, rt as spawned, st as use, tt as sfx, ut as types_d_exports$4, v as types_d_exports$5 } from "./types-DHamyZq1.mjs";
 import { A as types_d_exports$14, E as TextFormat, F as types_d_exports$8, K as types_d_exports$7, d as DebugTrigger, f as LocalWrite, h as defineTokens, j as defineComponent, m as popup, p as ScrollState, u as Box, x as CountdownValue, y as BindOptions } from "./types-BAp9HdR4.mjs";
-import { $ as system, A as Draggable, At as Text, B as Touchable, C as AnimPlayer, Ct as debugPlugin, D as defineBundles, Dt as animPlugin, E as defineScene, Et as assetsPlugin, F as PointerOver, G as Exiting, H as Traced, I as Pressable, J as Order, K as Layer, L as Pressed, M as Held, Mt as defineTextStyles, N as Hovered, Nt as label, O as load, Ot as projection, P as Pointer, Q as resource, R as Swipeable, S as defineMotion, St as effectsPlugin, T as Frames, Tt as audioPlugin, U as PASS_KINDS, V as Traceable, W as frameAt, X as component, Y as Tree, Z as mut, _ as defineStyle, _t as modelPlugin, a as defineEmitter, at as defineFeature, b as messageDuration, bt as i18nPlugin, c as Alpha, ct as uiPlugin, d as Displacement, dt as scenesPlugin, et as tag, f as Glow, ft as rendererPlugin, g as resolve, gt as types_d_exports$11, h as music, ht as PlatformProvider, i as screen, it as schedule, j as DropTarget, jt as bind, k as ready, kt as Countdown, l as Blur, lt as timePlugin, m as Outline, mt as BackResult, n as createPlugin, nt as guide, o as Emitter, ot as flattenFeatures, p as Noise, pt as platformPlugin, q as Now, r as defineGame, rt as hint, s as defineFilter, st as worldPlugin, t as createApp, tt as defineEffect, u as ColorMatrix, ut as textPlugin, v as tr, vt as lifecyclePlugin, w as Animation, wt as clockPlugin, x as cubicBezier, xt as flowPlugin, y as messageArgument, yt as inputPlugin, z as Tappable } from "./index-B2GejbLf.mjs";
+import { $ as system, A as Draggable, At as Text, B as Touchable, C as AnimPlayer, Ct as debugPlugin, D as defineBundles, Dt as animPlugin, E as defineScene, Et as assetsPlugin, F as PointerOver, G as Exiting, H as Traced, I as Pressable, J as Order, K as Layer, L as Pressed, M as Held, Mt as defineTextStyles, N as Hovered, Nt as label, O as load, Ot as projection, P as Pointer, Q as resource, R as Swipeable, S as defineMotion, St as effectsPlugin, T as Frames, Tt as audioPlugin, U as PASS_KINDS, V as Traceable, W as frameAt, X as component, Y as Tree, Z as mut, _ as defineStyle, _t as modelPlugin, a as defineEmitter, at as defineFeature, b as messageDuration, bt as i18nPlugin, c as Alpha, ct as uiPlugin, d as Displacement, dt as scenesPlugin, et as tag, f as Glow, ft as rendererPlugin, g as resolve, gt as types_d_exports$11, h as music, ht as PlatformProvider, i as screen, it as schedule, j as DropTarget, jt as bind, k as ready, kt as Countdown, l as Blur, lt as timePlugin, m as Outline, mt as BackResult, n as createPlugin, nt as guide, o as Emitter, ot as flattenFeatures, p as Noise, pt as platformPlugin, q as Now, r as defineGame, rt as hint, s as defineFilter, st as worldPlugin, t as createApp, tt as defineEffect, u as ColorMatrix, ut as textPlugin, v as tr, vt as lifecyclePlugin, w as Animation, wt as clockPlugin, x as cubicBezier, xt as flowPlugin, y as messageArgument, yt as inputPlugin, z as Tappable } from "./index-DMeqKGSu.mjs";
 export { type AdaptiveScale, Alpha, types_d_exports as Anim, AnimPlayer, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, type BackResult, type BindOptions, Blur, Box, types_d_exports$3 as Clock, ColorMatrix, Countdown, type CountdownValue, DEMAND_REASONS, types_d_exports$4 as Debug, DebugTrigger, type DescriptionNode, Displacement, Display, Draggable, DropTarget, types_d_exports$5 as Effects, Emitter, Exiting, type FilterArea, types_d_exports$6 as Flow, type FrameColumns, type FrameReadResult, type FrameReadout, type FrameRecord, type FrameRing, Frames, Glow, HAPTIC_KINDS, type HapticKind, Held, Hovered, HudPart, type HudPartValue, types_d_exports$7 as I18n, types_d_exports$8 as Input, Layer, types_d_exports$9 as Lifecycle, LocalWrite, type LongFrameEntry, MONITOR_SECTIONS, types_d_exports$10 as Model, type MonitorConfig, type MonitorCounts, type MonitorSections, NineSlice, Noise, Now, Order, Outline, Overlay, type OverlayEventDetail, type OverlayValue, type OverlayWhat, PASS_KINDS, PERF_CAUSES, PERF_GAP_BUCKETS, PERF_LOG_VERSION, PROBLEM_RULES, Parent, type PassKind, type PassRecord, type PerfCause, type PerfChange, type PerfChangeEntry, type PerfCollectorLine, type PerfCounts, type PerfDisplay, type PerfEventLine, type PerfEventName, type PerfGapLine, type PerfHeaderLine, type PerfLogLine, type PerfLongFrameLine, type PerfMarkLine, type PerfMeasured, type PerfSampleLine, type PerfSpikeLine, type PerfStartupLine, type PerfTelemetryLine, type PerfThermalLine, types_d_exports$11 as Platform, type PlatformProvider, Pointer, PointerOver, type PoolTrim, type PoolTrimDetail, Pressable, Pressed, type ProblemEventDetail, type ProblemRule, types_d_exports$12 as Renderer, SHADER_WHATS, SaveUnreadableError, types_d_exports$13 as Scenes, ScrollState, type ShaderEventDetail, type ShaderWhat, Shape, Sprite, type SpriteBlend, Swipeable, Tappable, Text, type TextFormat, types_d_exports$14 as TextTypes, types_d_exports$15 as Time, Touchable, Traceable, Traced, Transform, Tree, types_d_exports$16 as Ui, type WarmDetail, types_d_exports$17 as World, animPlugin, assetsPlugin, audioPlugin, bind, clockPlugin, component, createApp, createPlugin, cubicBezier, debugPlugin, defineAnimation, defineBundles, defineComponent, defineEffect, defineEmitter, defineFeature, defineFilter, defineGame, defineMotion, defineScene, defineStyle, defineTextStyles, defineTokens, effectsPlugin, exit, external, flattenFeatures, flowPlugin, frameAt, frames, guide, haptic, hint, i18nPlugin, inputPlugin, label, lifecyclePlugin, load, mark, messageArgument, messageDuration, modelPlugin, music, mut, parallel, platformPlugin, play, popup, projection, ready, rendererPlugin, resolve, resource, scenesPlugin, schedule, screen, sequence, set, sfx, slot, spawn, spawned, sprite, stagger, stopSfx, system, tag, textPlugin, timePlugin, to, tr, tween, type, uiPlugin, use, wait, worldPlugin };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as sfx, $t as flowPlugin, A as types_exports$7, At as Glow, B as defineMotion, Bt as Animation, C as types_exports$14, Ct as messageDuration, D as types_exports$10, Dt as Blur, E as types_exports$11, Et as Alpha, F as types_exports$2, Ft as audioPlugin, G as external, Gt as MONITOR_SECTIONS, H as platformPlugin, Ht as rendererPlugin, I as types_exports$1, It as scenesPlugin, J as mark, Jt as PERF_LOG_VERSION, K as frames, Kt as PERF_CAUSES, L as types_exports, Lt as assetsPlugin, M as types_exports$5, Mt as Outline, N as types_exports$4, Nt as defineFilter, O as types_exports$9, Ot as ColorMatrix, P as types_exports$3, Pt as debugPlugin, Q as set, Qt as worldPlugin, R as uiPlugin, Rt as animPlugin, S as types_exports$15, St as messageArgument, T as types_exports$12, Tt as Emitter, U as HAPTIC_KINDS, Ut as PASS_KINDS, V as textPlugin, Vt as Frames, W as defineAnimation, Wt as frameAt, X as play, Xt as SHADER_WHATS, Y as parallel, Yt as PROBLEM_RULES, Z as sequence, Zt as DEMAND_REASONS, _ as defineBundles, _t as Tappable, a as cubicBezier, an as modelPlugin, at as use, b as types_exports$17, bt as Traced, c as hint, cn as timePlugin, ct as Draggable, d as defineScene, dt as Hovered, et as spawn, f as tr, ft as Pointer, g as music, gt as Swipeable, h as defineEmitter, ht as Pressed, i as screen, in as type, it as tween, j as types_exports$6, jt as Noise, k as types_exports$8, kt as Displacement, l as schedule, ln as clockPlugin, lt as DropTarget, m as flattenFeatures, mt as Pressable, n as createPlugin, nn as slot, nt as stagger, o as defineEffect, on as SaveUnreadableError, ot as wait, p as defineFeature, pt as PointerOver, q as haptic, qt as PERF_GAP_BUCKETS, r as defineGame, rn as to, rt as stopSfx, s as guide, sn as lifecyclePlugin, st as inputPlugin, t as createApp, tn as exit, tt as spawned, u as projection, ut as Held, v as load, vt as Touchable, w as types_exports$13, wt as effectsPlugin, x as types_exports$16, xt as i18nPlugin, y as ready, yt as Traceable, z as resolve, zt as AnimPlayer } from "./src-B4JjsuEy.mjs";
+import { $ as sfx, $t as flowPlugin, A as types_exports$7, At as Glow, B as defineMotion, Bt as Animation, C as types_exports$14, Ct as messageDuration, D as types_exports$10, Dt as Blur, E as types_exports$11, Et as Alpha, F as types_exports$2, Ft as audioPlugin, G as external, Gt as MONITOR_SECTIONS, H as platformPlugin, Ht as rendererPlugin, I as types_exports$1, It as scenesPlugin, J as mark, Jt as PERF_LOG_VERSION, K as frames, Kt as PERF_CAUSES, L as types_exports, Lt as assetsPlugin, M as types_exports$5, Mt as Outline, N as types_exports$4, Nt as defineFilter, O as types_exports$9, Ot as ColorMatrix, P as types_exports$3, Pt as debugPlugin, Q as set, Qt as worldPlugin, R as uiPlugin, Rt as animPlugin, S as types_exports$15, St as messageArgument, T as types_exports$12, Tt as Emitter, U as HAPTIC_KINDS, Ut as PASS_KINDS, V as textPlugin, Vt as Frames, W as defineAnimation, Wt as frameAt, X as play, Xt as SHADER_WHATS, Y as parallel, Yt as PROBLEM_RULES, Z as sequence, Zt as DEMAND_REASONS, _ as defineBundles, _t as Tappable, a as cubicBezier, an as modelPlugin, at as use, b as types_exports$17, bt as Traced, c as hint, cn as timePlugin, ct as Draggable, d as defineScene, dt as Hovered, et as spawn, f as tr, ft as Pointer, g as music, gt as Swipeable, h as defineEmitter, ht as Pressed, i as screen, in as type, it as tween, j as types_exports$6, jt as Noise, k as types_exports$8, kt as Displacement, l as schedule, ln as clockPlugin, lt as DropTarget, m as flattenFeatures, mt as Pressable, n as createPlugin, nn as slot, nt as stagger, o as defineEffect, on as SaveUnreadableError, ot as wait, p as defineFeature, pt as PointerOver, q as haptic, qt as PERF_GAP_BUCKETS, r as defineGame, rn as to, rt as stopSfx, s as guide, sn as lifecyclePlugin, st as inputPlugin, t as createApp, tn as exit, tt as spawned, u as projection, ut as Held, v as load, vt as Touchable, w as types_exports$13, wt as effectsPlugin, x as types_exports$16, xt as i18nPlugin, y as ready, yt as Traceable, z as resolve, zt as AnimPlayer } from "./src-5qdNjLKN.mjs";
 import { $ as component, H as Shape, I as Display, J as Exiting, L as HudPart, Q as Tree, R as NineSlice, S as bind, T as label, U as Sprite, V as Parent, W as Transform, X as Now, Y as Layer, Z as Order, b as Countdown, d as LocalWrite, et as mut, g as popup, it as tag, l as DebugTrigger, nt as system, p as ScrollState, q as sprite, s as Box, tt as resource, v as defineTokens, w as defineTextStyles, x as Text, y as defineStyle, z as Overlay } from "./visual-ClVRMUAi.mjs";
 import { t as defineComponent } from "./component-DGg5DqKK.mjs";
 export { Alpha, types_exports as Anim, AnimPlayer, Animation, types_exports$1 as Assets, types_exports$2 as Audio, Blur, Box, types_exports$3 as Clock, ColorMatrix, Countdown, DEMAND_REASONS, types_exports$4 as Debug, DebugTrigger, Displacement, Display, Draggable, DropTarget, types_exports$5 as Effects, Emitter, Exiting, types_exports$6 as Flow, Frames, Glow, HAPTIC_KINDS, Held, Hovered, HudPart, types_exports$7 as I18n, types_exports$8 as Input, Layer, types_exports$9 as Lifecycle, LocalWrite, MONITOR_SECTIONS, types_exports$10 as Model, NineSlice, Noise, Now, Order, Outline, Overlay, PASS_KINDS, PERF_CAUSES, PERF_GAP_BUCKETS, PERF_LOG_VERSION, PROBLEM_RULES, Parent, types_exports$11 as Platform, Pointer, PointerOver, Pressable, Pressed, types_exports$12 as Renderer, SHADER_WHATS, SaveUnreadableError, types_exports$13 as Scenes, ScrollState, Shape, Sprite, Swipeable, Tappable, Text, types_exports$14 as TextTypes, types_exports$15 as Time, Touchable, Traceable, Traced, Transform, Tree, types_exports$16 as Ui, types_exports$17 as World, animPlugin, assetsPlugin, audioPlugin, bind, clockPlugin, component, createApp, createPlugin, cubicBezier, debugPlugin, defineAnimation, defineBundles, defineComponent, defineEffect, defineEmitter, defineFeature, defineFilter, defineGame, defineMotion, defineScene, defineStyle, defineTextStyles, defineTokens, effectsPlugin, exit, external, flattenFeatures, flowPlugin, frameAt, frames, guide, haptic, hint, i18nPlugin, inputPlugin, label, lifecyclePlugin, load, mark, messageArgument, messageDuration, modelPlugin, music, mut, parallel, platformPlugin, play, popup, projection, ready, rendererPlugin, resolve, resource, scenesPlugin, schedule, screen, sequence, set, sfx, slot, spawn, spawned, sprite, stagger, stopSfx, system, tag, textPlugin, timePlugin, to, tr, tween, type, uiPlugin, use, wait, worldPlugin };

package/dist/inspect.d.mts

@@ -1,5 +1,5 @@
 import { Ir as Snapshot, Un as Position, Y as Api$2, ct as RenderStats, dn as ComponentSchema, gn as FrameDiff, h as Usage, hn as EntitySnapshot, in as Explained, ir as FlowGraph, it as Under, nn as Api$1, or as JournalEntry, t as Api$3, wr as Api } from "./types-D27I4Q7b.mjs";
-import { a as AudioApi, g as EffectsStats, h as EffectsApi, r as UiApi, u as SoundEntry } from "./types-DjQkfbfZ.mjs";
+import { a as AudioApi, g as EffectsStats, h as EffectsApi, r as UiApi, u as SoundEntry } from "./types-DHamyZq1.mjs";
 import { c as UiNode } from "./types-BAp9HdR4.mjs";
 import { t as HeadlessApp } from "./headless-f31cEZ7f.mjs";
 import { a as InputOf, c as Source, i as InputArguments, l as WatchApp, o as InputSchema, t as CheatEntry, u as WatchInput } from "./types-CgE5L_7f.mjs";

package/dist/{run-DyL8rl2P.mjs → run-BnriyKUu.mjs}

@@ -21,7 +21,7 @@ import { a as readTarget, i as isProjectionTarget, l as inputSchema, n as isTain
 const reducedMotionCommand = defineCommand({
 	id: "game.reducedMotion",
 	title: "Reduced motion",
-	input: { on: "boolean" },
+	input: inputSchema(["on", "boolean"]),
 	effect: "cosmetic",
 	run: (app, { on }) => {
 		if ((typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) && (typeof __MOKU_GAME_AGENT__ === "undefined" || !__MOKU_GAME_AGENT__)) throw controlRefused();

package/dist/{src-B4JjsuEy.mjs → src-5qdNjLKN.mjs}

@@ -32876,36 +32876,91 @@ function spriteOf(cctx, step) {
 function startTween(cctx, step) {
 	const entity = targetOf$2(cctx, step);
 	if (entity === void 0) return void 0;
-	return cctx.rt.start(entity, step.component, tweenTargetOf(cctx, entity, step), {
+	return cctx.rt.start(entity, step.component, inSpace(cctx, entity, step, step.to), trackOptionsOf$1(cctx, entity, step));
+}
+/**
+* The options a `tween` step starts its track with. The keyframe segments and the repeat are
+* passed only when the step has them, the segment targets turned like `to` in the root space.
+*
+* @param cctx - What the cursor carries down the tree.
+* @param entity - The entity the step moves.
+* @param step - The tween step.
+* @returns The track options.
+*/
+function trackOptionsOf$1(cctx, entity, step) {
+	const options = {
 		ms: step.ms,
 		ease: step.ease,
 		delayMs: step.delayMs,
 		additive: step.additive,
 		reduced: step.reduced
-	});
+	};
+	const segments = step.segments;
+	if (segments !== void 0) options.segments = step.space === "root" ? segments.map((segment) => ({
+		...segment,
+		to: inSpace(cctx, entity, step, segment.to)
+	})) : segments;
+	if (step.repeat !== void 0) options.repeat = step.repeat;
+	return options;
 }
 /**
-* The target fields of a `tween` step for one entity: as written in the local space, turned into
-* the space of the entity's parent in the root space.
+* Target fields of a `tween` step for one entity: as written in the local space, turned into the
+* space of the entity's parent in the root space.
 *
 * @param cctx - What the cursor carries down the tree.
 * @param entity - The entity the step moves.
 * @param step - The tween step.
+* @param fields - Its `to`, the target of one of its segments, or where it lands.
 * @returns The fields the track or the write aims at.
 */
-function tweenTargetOf(cctx, entity, step) {
-	if (step.space === "root") return cctx.rt.toLocal(entity, step.component, step.to);
-	return { ...step.to };
+function inSpace(cctx, entity, step, fields) {
+	if (step.space === "root") return cctx.rt.toLocal(entity, step.component, fields);
+	return { ...fields };
+}
+/**
+* The last value each field reaches over a list of segments.
+*
+* @param segments - The segments of a step.
+* @returns One value per field any segment names.
+* @example
+* ```ts
+* lastValues([{ at: 0.5, to: { y: 10, rotation: 2 } }, { at: 1, to: { y: 0 } }]); // { y: 0, rotation: 2 }
+* ```
+*/
+function lastValues$1(segments) {
+	const values = {};
+	for (const segment of segments) Object.assign(values, segment.to);
+	return values;
+}
+/**
+* Where a `tween` step that never started lands when it is finished: its target, and for a
+* keyframe walk every field its segments name too, at the last value they give it. A step that
+* repeats forever lands on its start pose, where it already stands, and an additive walk names
+* offsets that end with it: neither writes anything.
+*
+* @param step - The tween step.
+* @returns The fields to write, or `undefined` when the step writes nothing.
+*/
+function landingOf(step) {
+	if (step.repeat === "forever") return void 0;
+	if (step.segments === void 0) return step.to;
+	if (step.additive) return void 0;
+	return {
+		...lastValues$1(step.segments),
+		...step.to
+	};
 }
 /**
-* Writes the target of a `tween` step that never started, in the space the step names.
+* Writes where a `tween` step that never started lands, in the space the step names.
 *
 * @param cctx - What the cursor carries down the tree.
 * @param step - The tween step.
 */
 function writeTween(cctx, step) {
+	const landing = landingOf(step);
+	if (landing === void 0) return;
 	const entity = targetOf$2(cctx, step);
-	if (entity !== void 0) cctx.rt.write(entity, step.component, tweenTargetOf(cctx, entity, step));
+	if (entity !== void 0) cctx.rt.write(entity, step.component, inSpace(cctx, entity, step, landing));
 }
 /**
 * Writes the patch of a `set` step.
@@ -33126,7 +33181,9 @@ function advanceCursor(cctx, cursor, deltaMs) {
 /**
 * Ends one step at its own end: a track writes its exact target, a step that never started writes
 * it at once, the marks are jumped in tree order, no effect is fired and nothing is spawned: the
-* timeline despawns its entities as it ends, so a skipped spawn would only flash.
+* timeline despawns its entities as it ends, so a skipped spawn would only flash. A track that
+* repeats forever has no end: it lands on its start pose, and one that never started writes
+* nothing.
 *
 * @param cctx - What the cursor carries down the tree.
 * @param cursor - The cursor of the step.
@@ -34447,7 +34504,8 @@ function repeatsOf(repeat) {
 * keyframe segments walks them over `ms` and books every field they name; one with `repeat`
 * walks again when a run ends. With reduced motion on, every track but a loop takes 0 ms, its
 * delay and its repeats dropped: it lands on its target at its first frame step. A track started
-* with `reduced: "keep"` keeps its length, its delay and its repeats.
+* with `reduced: "keep"` keeps its length, its delay and its repeats. A timeline's loop under
+* reduced motion does not play at all: it is born ended, writes nothing, and its step goes on.
 *
 * @param actx - Domain context of the anim plugin.
 * @param entity - The entity to animate.
@@ -34462,9 +34520,11 @@ function startTrack$1(actx, entity, component, to, options, muted, driven = fals
 	const target = targetOf$1(to, options.segments);
 	const repeats = repeatsOf(options.repeat);
 	const keep = options.reduced === "keep";
-	const instant = actx.state.reducedMotion && !keep && repeats !== Number.POSITIVE_INFINITY;
+	const cut = actx.state.reducedMotion && !keep;
+	const instant = cut && repeats !== Number.POSITIVE_INFINITY;
 	const keys = keysOf(entity, component.componentName, target);
 	const names = Object.keys(target);
+	const bornEnded = names.length === 0 || cut && driven && repeats === Number.POSITIVE_INFINITY;
 	const track = {
 		id: actx.state.nextId,
 		entity,
@@ -34488,7 +34548,7 @@ function startTrack$1(actx, entity, component, to, options, muted, driven = fals
 		additive: options.additive === true,
 		driven,
 		bornFrame: actx.state.frame,
-		ended: names.length === 0,
+		ended: bornEnded,
 		segments: options.segments,
 		repeatsLeft: instant ? 0 : repeats,
 		held: false,
@@ -34593,7 +34653,7 @@ function advanceTrack(actx, track, deltaMs) {
 	const run = clock[1] ?? 0;
 	const fraction = track.ms <= 0 ? 1 : Math.min(run / track.ms, 1);
 	const final = fraction >= 1 && (track.repeatsLeft === 0 || track.ms <= 0);
-	if (!final && !track.driven && track.repeatsLeft === Number.POSITIVE_INFINITY && actx.state.loopsHeld?.(track.entity, track.reveals) === true) return 0;
+	if (isHeldLoop(actx, track, final)) return 0;
 	clock[1] = fraction;
 	writeFields(actx, track, final);
 	if (!final) return 0;
@@ -34601,15 +34661,29 @@ function advanceTrack(actx, track, deltaMs) {
 	return Math.max(0, run - track.ms);
 }
 /**
-* Writes the exact target of a track and ends it. Muted fields are left alone here too.
+* Tells whether an endless loop writes nothing this frame because the player cannot see it.
+*
+* @param actx - Domain context of the anim plugin.
+* @param track - The track that advances.
+* @param final - Whether this step lands the track.
+* @returns True when the loop is held.
+*/
+function isHeldLoop(actx, track, final) {
+	return !final && track.repeatsLeft === Number.POSITIVE_INFINITY && actx.state.loopsHeld?.(track.entity, track.reveals) === true;
+}
+/**
+* Writes the exact target of a track and ends it. Muted fields are left alone here too. A
+* timeline's loop has no end to land on: it lands on its first key, the pose its walk starts
+* from, which is where a cut or a fast walk leaves it (F75).
 *
 * @param actx - Domain context of the anim plugin.
 * @param track - The track to finish.
 */
 function finishTrack(actx, track) {
 	if (track.ended) return;
-	track.clock[1] = 1;
-	writeFields(actx, track, true);
+	const final = !track.driven || track.repeatsLeft !== Number.POSITIVE_INFINITY;
+	track.clock[1] = final ? 1 : 0;
+	writeFields(actx, track, final);
 	endTrack(actx, track);
 }
 /**
@@ -49843,6 +49917,102 @@ function createHandlers$1(ctx) {
 	} };
 }
 //#endregion
+//#region src/plugins/anim/timeline/checks.ts
+/**
+* Checks the keyframe segments of a `tween` step: at least one, every `at` in 0..1, each after the
+* one before, and the last at 1, because `to` is where the walk lands.
+*
+* @param component - Name of the component the step drives, for the error.
+* @param segments - The segments the author gave.
+* @throws {Error} When the list is empty, an `at` is out of range or out of order, or the last
+*   segment ends before 1.
+* @example
+* ```ts
+* checkSegments("Transform", [{ at: 0.5 }, { at: 1 }]); // returns; [{ at: 0.5 }] throws
+* ```
+*/
+function checkSegments(component, segments) {
+	if (segments.length === 0) throw new Error(`[game] A tween of ${component} has no segments.\n  Give it at least one segment, the last one at 1.`);
+	let previous = Number.NEGATIVE_INFINITY;
+	for (const { at } of segments) {
+		if (Number.isNaN(at) || at < 0 || at > 1) throw new Error(`[game] A tween of ${component} has a segment at ${at}.\n  Keep every at between 0 and 1.`);
+		if (at <= previous) throw new Error(`[game] A tween of ${component} has its segments out of order at ${at}.\n  Sort the segments by at, each one after the one before.`);
+		previous = at;
+	}
+	if (previous !== 1) throw new Error(`[game] A tween of ${component} ends its last segment at ${previous}.\n  End the last segment at 1: to is where the walk lands.`);
+}
+/**
+* Checks the space of a keyframe walk: an additive one names offsets, and the root space would
+* turn each offset as if it were a root position, so a chest under a slot at root y 500 would jump
+* by about 500 at its first segment. An additive walk stays in the local space.
+*
+* @param component - Name of the component the step drives, for the error.
+* @param additive - Whether the walk adds offsets.
+* @param space - The space the step names.
+* @throws {Error} When an additive walk names the root space.
+* @example
+* ```ts
+* checkWalkSpace("Transform", true, "local"); // returns; (…, true, "root") throws
+* ```
+*/
+function checkWalkSpace(component, additive, space) {
+	if (!additive || space === "local") return;
+	throw new Error(`[game] An additive tween of ${component} walks segments in the root space.\n  Use space "local" for an additive walk.`);
+}
+/**
+* Checks the repeat of a `tween` step: a whole number of extra runs, 0 or more, or `"forever"`.
+*
+* @param component - Name of the component the step drives, for the error.
+* @param repeat - The repeat the author gave.
+* @throws {Error} When the repeat is negative, not whole or not a number.
+* @example
+* ```ts
+* checkRepeat("Transform", "forever"); // returns; checkRepeat("Transform", 1.5) throws
+* ```
+*/
+function checkRepeat(component, repeat) {
+	if (repeat === "forever" || Number.isInteger(repeat) && repeat >= 0) return;
+	throw new Error(`[game] A tween of ${component} has repeat ${repeat}.\n  Give repeat a whole number of extra runs, 0 or more, or "forever".`);
+}
+/**
+* Tells whether a step never ends by itself: a `tween` that repeats forever, a `parallel` or a
+* `sequence` that holds one, and a `use` of one. Only a cancel or a finish ends it.
+*
+* @param step - The step to look into.
+* @returns True when the step never ends by itself.
+* @example
+* ```ts
+* neverEnds(wait(100)); // false
+* neverEnds(tween(1_048_576, Transform, { y: 0 }, { ms: 2400, repeat: "forever" })); // true
+* ```
+*/
+function neverEnds(step) {
+	switch (step.kind) {
+		case "tween": return step.repeat === "forever";
+		case "sequence":
+		case "parallel": return step.steps.some((child) => neverEnds(child));
+		case "use": return neverEnds(step.step);
+		default: return false;
+	}
+}
+/**
+* Checks the children of a `sequence`: a child that never ends may only be the last one, since
+* the children after it would never play. A `parallel` takes one anywhere.
+*
+* @param steps - The children, in order.
+* @throws {Error} When a child that never ends has another child after it.
+* @example
+* ```ts
+* checkSequence([wait(100), mark("landed")]); // returns; a forever tween before the mark throws
+* ```
+*/
+function checkSequence(steps) {
+	for (let index = 0; index < steps.length - 1; index++) {
+		const step = steps[index];
+		if (step !== void 0 && neverEnds(step)) throw new Error(`[game] Step ${index + 1} of a sequence never ends, so the steps after it would never play.\n  Put the forever step last, or run it in a parallel.`);
+	}
+}
+//#endregion
 //#region src/plugins/anim/timeline/steps.ts
 /**
 * Every haptic tick `haptic(kind)` takes, in one frozen list: the three impacts, the selection
@@ -49943,10 +50113,13 @@ function slotsJson(slots) {
 }
 /**
 * Runs the steps one after another. The remainder past a step's end reaches the next step in the
-* same frame, so the tree takes exactly the sum of its durations.
+* same frame, so the tree takes exactly the sum of its durations. A step that never ends (a
+* `tween` with `repeat: "forever"`, or a `parallel`, `sequence` or `use` that holds one) may only
+* come last: the steps after it would never play.
 *
 * @param steps - The steps, in order.
 * @returns The sequence step.
+* @throws {Error} When a step that never ends has another step after it.
 * @example
 * ```ts
 * sequence(wait(100), mark("done"));
@@ -49954,6 +50127,7 @@ function slotsJson(slots) {
 * ```
 */
 function sequence(...steps) {
+	checkSequence(steps);
 	return Object.freeze({
 		kind: "sequence",
 		steps: Object.freeze([...steps])
@@ -50026,6 +50200,28 @@ function mark(name) {
 	});
 }
 /**
+* Copies one keyframe segment into frozen plain data: its `at`, its ease when it names one and
+* its numeric target fields.
+*
+* @param segment - The segment the author gave.
+* @param segment.at - Where it ends, as a fraction of the track's `ms`.
+* @param segment.ease - Its curve; the step's `ease` when left out.
+* @param segment.to - The fields it reaches.
+* @returns A frozen copy.
+* @example
+* ```ts
+* frozenSegment({ at: 1, to: { y: 0, texture: "a" } }); // { at: 1, to: { y: 0 } }
+* ```
+*/
+function frozenSegment(segment) {
+	const frozen = {
+		at: segment.at,
+		to: Object.freeze(numbersOf(segment.to))
+	};
+	if (segment.ease !== void 0) frozen.ease = segment.ease;
+	return Object.freeze(frozen);
+}
+/**
 * Moves the numeric fields of one component of one target to an exact target value. The component
 * is any handle `world.ecs` takes, so the kit's `Sprite` and `NineSlice` of `defineGame` pass as
 * they are.
@@ -50033,10 +50229,12 @@ function mark(name) {
 * By default the fields are local: they are written into the target's own `Transform`. With
 * `space: "root"` the `x`, `y`, `rotation` and `scale` of a `Transform` are a root pose, the space
 * `at()` answers in, and are turned into the space of the target's `Parent` when the track starts.
-* That aims a hosted view, such as a board item inside the board slot, at another element. A
-* field the step does not name stays where it is, so under a turned parent name `x` and `y`
-* together. A target without a parent, and a component other than `Transform`, move as in the
-* local space.
+* That aims a hosted view at another element: an order's board item inside the scaled board slot
+* flies onto the order card with `{ x: at(card).x, y: at(card).y, scale: at(card).scale }` in the
+* root space, covers the card at the card's size, and its `Transform` stays slot-local. A field
+* the step does not name stays where it is, so under a turned parent name `x` and `y` together. A
+* target without a parent, and a component other than `Transform`, move as in the local space. An
+* additive walk names offsets, so it stays in the local space.
 *
 * @param target - The projection key or the entity to animate.
 * @param component - The component to animate.
@@ -50049,30 +50247,34 @@ function mark(name) {
 * @param options.space - `"root"` reads the `Transform` fields as a root pose; `"local"` when
 *   omitted.
 * @param options.reduced - `"keep"` plays the track at its length under reduced motion, a fade
-*   for one; `"cut"` (the default) lands it at once.
-* @returns The tween step.
-* @example
-* ```ts
-* // An order is delivered: the board item flies out of the scaled board slot onto the order card.
-* const deliverFly = defineAnimation("orders.deliverFly", {
-*   slots: { item: type<Target>(), card: type<Target>() },
-*   build: ({ item, card }, { at }) =>
-*     tween(item, Transform, { x: at(card).x, y: at(card).y, scale: at(card).scale }, {
-*       ms: 400, ease: "inCubic", space: "root"
-*     })
-* });
-* app.anim.play(deliverFly, {
-*   item: { projection: "board.items", key: "i1" },
-*   card: { projection: "hud", key: "card0" }
-* });
-* // 400 ms later the item covers the card at the card's size; its Transform stays slot-local
+*   for one; `"cut"` (the default) lands it at once, and a `"forever"` track does not play.
+* @param options.segments - Keyframe segments `{ at, ease?, to }` walked one after another over
+*   `ms` on one clock; a field a segment does not name holds, `to` is where the last one ends. An
+*   additive walk names offsets. The same as `TweenOptions` of `ViewHandle.tween`.
+* @param options.repeat - How many more times the walk runs, or `"forever"`: the step never ends
+*   by itself, so it comes last in a `sequence`.
+* @returns The tween step; `segments` and `repeat` are in it only when given.
+* @throws {Error} When the segments are empty, an `at` is outside 0..1 or out of order, the last
+*   segment ends before 1, an additive walk names the root space, or the repeat is not a whole
+*   number of 0 or more.
+* @example
+* ```ts
+* // A ready chest (entity 1048576) hops 14 up and back every 2.4 s, as offsets over its pose.
+* const chestBounce = defineAnimation("board.chestBounce", { slots: { chest: type<Target>() },
+*   build: ({ chest }) => tween(chest, Transform, { y: 0, scale: 0 }, { ms: 2400, additive: true,
+*     repeat: "forever", segments: [{ at: 0.08, ease: "out", to: { y: -14, scale: 0.06 } },
+*       { at: 0.22, ease: "in", to: { y: 0, scale: 0 } }, { at: 1, to: { y: 0, scale: 0 } }] }) });
+* const bounce = res(AnimPlayer).play(chestBounce, { chest: 1_048_576 });
+* // 192 ms later the chest stands 14 higher, its scale 0.06 larger; it bounces until cancelled
+* bounce.cancel(); // it stands on its own pose again
 * ```
 */
 function tween(target, component, to, options) {
-	return Object.freeze({
+	const erased = asComponent(component);
+	const step = {
 		kind: "tween",
 		target,
-		component: asComponent(component),
+		component: erased,
 		to: Object.freeze(numbersOf(to)),
 		ms: options.ms,
 		ease: options.ease ?? "out",
@@ -50080,7 +50282,17 @@ function tween(target, component, to, options) {
 		additive: options.additive === true,
 		space: options.space ?? "local",
 		reduced: options.reduced ?? "cut"
-	});
+	};
+	if (options.segments !== void 0) {
+		checkSegments(erased.componentName, options.segments);
+		checkWalkSpace(erased.componentName, step.additive, step.space);
+		step.segments = Object.freeze(options.segments.map((segment) => frozenSegment(segment)));
+	}
+	if (options.repeat !== void 0) {
+		checkRepeat(erased.componentName, options.repeat);
+		step.repeat = options.repeat;
+	}
+	return Object.freeze(step);
 }
 /**
 * Writes a component patch at once. Any field may be written, not only the numeric ones. The

package/dist/testing.d.mts

@@ -1,6 +1,6 @@
 import { $n as FeaturePlugin, Dr as Json, dr as Descriptor, gr as NodeFx, hr as Hint, sr as NodeTable, tr as AnyFlow, xr as FakeClock, yr as ClockSource } from "./types-D27I4Q7b.mjs";
-import { t as createApp } from "./index-B2GejbLf.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-BWRJcZ3n.mjs";
+import { t as createApp } from "./index-DMeqKGSu.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-DmU_qlvA.mjs";
 import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-f31cEZ7f.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 

package/dist/testing.mjs

@@ -1,6 +1,6 @@
-import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-B4JjsuEy.mjs";
+import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-5qdNjLKN.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
-import { t as fakeClock } from "./fake-6mazmHK3.mjs";
+import { n as fakeClock } from "./fake-hnJcJeYf.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-Bxxl_mQX.mjs";
 //#region src/testing/fake-fx.ts
 /** The node path a refused `fx.start` names when the test gives none. */

package/dist/{types-DjQkfbfZ.d.mts → types-DHamyZq1.d.mts}

@@ -207,10 +207,13 @@ type StepMotion = MotionHandle & {
 declare const HAPTIC_KINDS: readonly ["light", "medium", "heavy", "selection", "success", "warning", "error"];
 /**
  * Runs the steps one after another. The remainder past a step's end reaches the next step in the
- * same frame, so the tree takes exactly the sum of its durations.
+ * same frame, so the tree takes exactly the sum of its durations. A step that never ends (a
+ * `tween` with `repeat: "forever"`, or a `parallel`, `sequence` or `use` that holds one) may only
+ * come last: the steps after it would never play.
  *
  * @param steps - The steps, in order.
  * @returns The sequence step.
+ * @throws {Error} When a step that never ends has another step after it.
  * @example
  * ```ts
  * sequence(wait(100), mark("done"));
@@ -275,10 +278,12 @@ declare function mark(name: string): Step;
  * By default the fields are local: they are written into the target's own `Transform`. With
  * `space: "root"` the `x`, `y`, `rotation` and `scale` of a `Transform` are a root pose, the space
  * `at()` answers in, and are turned into the space of the target's `Parent` when the track starts.
- * That aims a hosted view, such as a board item inside the board slot, at another element. A
- * field the step does not name stays where it is, so under a turned parent name `x` and `y`
- * together. A target without a parent, and a component other than `Transform`, move as in the
- * local space.
+ * That aims a hosted view at another element: an order's board item inside the scaled board slot
+ * flies onto the order card with `{ x: at(card).x, y: at(card).y, scale: at(card).scale }` in the
+ * root space, covers the card at the card's size, and its `Transform` stays slot-local. A field
+ * the step does not name stays where it is, so under a turned parent name `x` and `y` together. A
+ * target without a parent, and a component other than `Transform`, move as in the local space. An
+ * additive walk names offsets, so it stays in the local space.
  *
  * @param target - The projection key or the entity to animate.
  * @param component - The component to animate.
@@ -291,23 +296,26 @@ declare function mark(name: string): Step;
  * @param options.space - `"root"` reads the `Transform` fields as a root pose; `"local"` when
  *   omitted.
  * @param options.reduced - `"keep"` plays the track at its length under reduced motion, a fade
- *   for one; `"cut"` (the default) lands it at once.
- * @returns The tween step.
- * @example
- * ```ts
- * // An order is delivered: the board item flies out of the scaled board slot onto the order card.
- * const deliverFly = defineAnimation("orders.deliverFly", {
- *   slots: { item: type<Target>(), card: type<Target>() },
- *   build: ({ item, card }, { at }) =>
- *     tween(item, Transform, { x: at(card).x, y: at(card).y, scale: at(card).scale }, {
- *       ms: 400, ease: "inCubic", space: "root"
- *     })
- * });
- * app.anim.play(deliverFly, {
- *   item: { projection: "board.items", key: "i1" },
- *   card: { projection: "hud", key: "card0" }
- * });
- * // 400 ms later the item covers the card at the card's size; its Transform stays slot-local
+ *   for one; `"cut"` (the default) lands it at once, and a `"forever"` track does not play.
+ * @param options.segments - Keyframe segments `{ at, ease?, to }` walked one after another over
+ *   `ms` on one clock; a field a segment does not name holds, `to` is where the last one ends. An
+ *   additive walk names offsets. The same as `TweenOptions` of `ViewHandle.tween`.
+ * @param options.repeat - How many more times the walk runs, or `"forever"`: the step never ends
+ *   by itself, so it comes last in a `sequence`.
+ * @returns The tween step; `segments` and `repeat` are in it only when given.
+ * @throws {Error} When the segments are empty, an `at` is outside 0..1 or out of order, the last
+ *   segment ends before 1, an additive walk names the root space, or the repeat is not a whole
+ *   number of 0 or more.
+ * @example
+ * ```ts
+ * // A ready chest (entity 1048576) hops 14 up and back every 2.4 s, as offsets over its pose.
+ * const chestBounce = defineAnimation("board.chestBounce", { slots: { chest: type<Target>() },
+ *   build: ({ chest }) => tween(chest, Transform, { y: 0, scale: 0 }, { ms: 2400, additive: true,
+ *     repeat: "forever", segments: [{ at: 0.08, ease: "out", to: { y: -14, scale: 0.06 } },
+ *       { at: 0.22, ease: "in", to: { y: 0, scale: 0 } }, { at: 1, to: { y: 0, scale: 0 } }] }) });
+ * const bounce = res(AnimPlayer).play(chestBounce, { chest: 1_048_576 });
+ * // 192 ms later the chest stands 14 higher, its scale 0.06 larger; it bounces until cancelled
+ * bounce.cancel(); // it stands on its own pose again
  * ```
  */
 declare function tween<Value extends object>(target: Target, component: ComponentHandle<Value>, to: Partial<NumericFields<Value>>, options: {
@@ -317,6 +325,12 @@ declare function tween<Value extends object>(target: Target, component: Componen
   additive?: boolean;
   space?: "local" | "root";
   reduced?: ReducedMotion;
+  segments?: readonly {
+    at: number;
+    ease?: Ease;
+    to: Partial<NumericFields<Value>>;
+  }[];
+  repeat?: number | "forever";
 }): Step;
 /**
  * Writes a component patch at once. Any field may be written, not only the numeric ones. The
@@ -658,6 +672,16 @@ type Step = {
   readonly additive: boolean; /** `"root"`: the `Transform` fields are a root pose, turned local when the track starts. */
   readonly space: "local" | "root"; /** `"keep"`: reduced motion plays the track as written; `"cut"` lands it at once. */
   readonly reduced: ReducedMotion;
+  /**
+   * The keyframe segments the track walks over `ms`, frozen; only on a step built with them.
+   * In the root space each segment's target is turned local when the track starts, like `to`.
+   */
+  readonly segments?: readonly TrackSegment[];
+  /**
+   * The runs after the first one, or `"forever"` for a step that never ends by itself; only on
+   * a step built with it.
+   */
+  readonly repeat?: number | "forever";
 } | {
   readonly kind: "set";
   readonly target: Target;

package/dist/{types-BWRJcZ3n.d.mts → types-DmU_qlvA.d.mts}

@@ -1,7 +1,7 @@
 import { $ as PixiModule, $n as FeaturePlugin, Dr as Json, Lr as SnapshotOf, Mr as PlayerStateProvider, Nr as ProviderCall, Pr as SaveDoc, Tr as Config, X as Config$2, a as Config$3, d as Manifest, lt as Orientation, n as AssetsIo, tr as AnyFlow, ur as TypeTag, xr as FakeClock, yr as ClockSource, zn as Config$1 } from "./types-D27I4Q7b.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-DjQkfbfZ.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-DHamyZq1.mjs";
 import { R as I18nApi, U as StringTable, W as TextKey } from "./types-BAp9HdR4.mjs";
-import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-B2GejbLf.mjs";
+import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-DMeqKGSu.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{visual-f6mtELhG.d.mts → visual-DEo5Hndx.d.mts}

@@ -1,9 +1,9 @@
-import { Vr as Api$3, Y as Api, nn as Api$1, wr as Api$2 } from "./types-D27I4Q7b.mjs";
-import { P as AnimApi, r as UiApi } from "./types-DjQkfbfZ.mjs";
+import { Vr as Api$3, Y as Api, nn as Api$1, vr as Api$4, wr as Api$2 } from "./types-D27I4Q7b.mjs";
+import { P as AnimApi, r as UiApi } from "./types-DHamyZq1.mjs";
 import { N as InputApi } from "./types-BAp9HdR4.mjs";
 import { r as Repro } from "./headless-f31cEZ7f.mjs";
 import { a as InputOf, r as ControlApp } from "./types-CgE5L_7f.mjs";
-import { t as commands } from "./commands-BUfZJUx6.mjs";
+import { t as commands } from "./commands-C8N_rpwt.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */
@@ -32,7 +32,9 @@ type StepCommand = Exclude<keyof Catalogue, "bookmark" | "capture" | "debug">;
 type VisualStart = Omit<Repro, "route">;
 /**
  * One step of a visual test: a `/control` command by its short name with that command's input,
- * typed from the catalogue, or a checkpoint by its name.
+ * typed from the catalogue, or a checkpoint by its name. A checkpoint lands every motion
+ * (`anim.finishAll()`) before its snapshot; with `finish: false` it does not, and the snapshot
+ * shows the motions where they stand after the same frames in both legs (F87).
  *
  * @example
  * ```ts
@@ -40,12 +42,15 @@ type VisualStart = Omit<Repro, "route">;
  * const steps: VisualStep[] = [
  *   { tap: { key: "play" } },
  *   { answer: { intent: "deliver", payload: { orderId: "o1" } } },
- *   { checkpoint: "open" }
+ *   { checkpoint: "open" },
+ *   // The hint that fades out at the end of its animation, caught while it still shows.
+ *   { checkpoint: "hint", finish: false }
  * ];
  * ```
  */
 type VisualStep = {
   checkpoint: string;
+  finish?: boolean;
 } | { [K in StepCommand]: { [P in K]: InputOf<Catalogue[K]["input"]> } }[StepCommand];
 /**
  * A visual test as `defineVisualTest` answers it: its name, where it starts, its steps, and
@@ -84,7 +89,8 @@ type VisualApp = ControlApp & {
   readonly world: Api$1;
   readonly model: Api$2;
   readonly input: InputApi;
-  readonly lifecycle: Api$3;
+  readonly lifecycle: Api$3; /** The clock: the pixel leg puts its moment on the page, so both legs see one `clock.now()`. */
+  readonly clock: Api$4;
 };
 /**
  * The dev page the browser leg opens: its URL, the viewport width in CSS px (390 by default), the
@@ -254,7 +260,8 @@ type VisualFlags = {
 /**
  * Defines a visual test: where it starts, what `game.restore` loads, and its steps. A step is a
  * `/control` command by its short name with that command's input, or `{ checkpoint: name }`,
- * where the runner saves `state.json` and `describe.json` next to the test. `walk` runs fast: a
+ * where the runner lands every motion and saves `state.json` and `describe.json` next to the test;
+ * `{ checkpoint: name, finish: false }` keeps the motions running for the snapshot. `walk` runs fast: a
  * popup its last node opens never mounts, so the step before a checkpoint that shows a node's
  * result is `answer` or `tap`. With `webgl: true` the test also runs in the WebGL leg
  * (`--webgl`), whose pictures go to `screen.webgl.webp`: set it on a screen with a custom filter.

package/dist/visual.d.mts

@@ -1,2 +1,2 @@
-import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-f6mtELhG.mjs";
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-DEo5Hndx.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/dist/visual.mjs

@@ -1,5 +1,6 @@
+import { t as VISUAL_CLOCK } from "./fake-hnJcJeYf.mjs";
 import { n as read, t as sources } from "./sources-DM5Zcl4o.mjs";
-import { n as commands, t as run } from "./run-DyL8rl2P.mjs";
+import { n as commands, t as run } from "./run-BnriyKUu.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -62,15 +63,41 @@ function stepNames() {
 	return Object.keys(commands).filter((name) => isStepCommand(name)).join(", ");
 }
 /**
-* Takes one step apart and checks its shape: exactly one key, either `checkpoint` or a step
-* command with an input object. The checkpoint name is checked by the caller.
+* Takes a checkpoint step apart: its name, a string, and `finish`, a boolean when it is there; no
+* other key.
+*
+* @param at - The test and the step, for the message.
+* @param fields - The step.
+* @returns The checkpoint.
+* @throws {Error} When the name is not a string, `finish` not a boolean, or another key is there.
+* @example
+* ```ts
+* checkpointEntry('[game] Visual test "fade", step 2', { checkpoint: "glow", finish: false }); // { kind: "checkpoint", name: "glow", finish: false }
+* ```
+*/
+function checkpointEntry(at, fields) {
+	const { checkpoint: name, finish = true, ...others } = fields;
+	if (Object.keys(others).length > 0) throw new Error(`${at} is not one command.\n  A checkpoint takes its name and finish, like { checkpoint: "name", finish: false }.`);
+	if (typeof name !== "string") throw new TypeError(`${at}: the checkpoint name is not a string.\n  Write the checkpoint as { checkpoint: "name" }.`);
+	if (typeof finish !== "boolean") throw new TypeError(`${at}: finish of the checkpoint "${name}" is not a boolean.\n  Write finish: false to keep the motions running, or leave it out.`);
+	return {
+		kind: "checkpoint",
+		name,
+		finish
+	};
+}
+/**
+* Takes one step apart and checks its shape: a checkpoint (its name, and `finish` when it is
+* there), or exactly one step command with an input object. The checkpoint name is checked by the
+* caller.
 *
 * @param test - The test name, for the message.
 * @param step - The step.
 * @param index - Its index in the steps, from 0.
 * @returns The checkpoint or the command with its input.
 * @throws {Error} When the step holds no key or more than one, names something that is not a
-*   step, gives a command no input object, or a checkpoint no string.
+*   step, gives a command no input object, or a checkpoint no string name or a `finish` that is
+*   not a boolean.
 * @example
 * ```ts
 * stepEntry("reward-popup", { tap: { key: "play" } }, 0); // { kind: "command", name: "tap", input: { key: "play" } }
@@ -80,15 +107,9 @@ function stepEntry(test, step, index) {
 	const fields = step;
 	const [name, ...others] = Object.keys(fields);
 	const at = `[game] Visual test "${test}", step ${index + 1}`;
+	if (Object.hasOwn(fields, "checkpoint")) return checkpointEntry(at, fields);
 	if (name === void 0 || others.length > 0) throw new Error(`${at} is not one command.\n  Write one command by its short name, or { checkpoint: "name" }.`);
 	const value = fields[name];
-	if (name === "checkpoint") {
-		if (typeof value === "string") return {
-			kind: "checkpoint",
-			name: value
-		};
-		throw new Error(`${at}: the checkpoint name is not a string.\n  Write the checkpoint as { checkpoint: "name" }.`);
-	}
 	if (!isStepCommand(name)) throw new Error(`${at} names "${name}", which is not a step.\n  Use a checkpoint or one of: ${stepNames()}.`);
 	if (!isInputObject(value)) throw new Error(`${at} (${name}) has no input object.\n  Pass the input of the command, like { tap: { key: "play" } }.`);
 	return {
@@ -173,7 +194,8 @@ function checkVisualTest(name, steps) {
 /**
 * Defines a visual test: where it starts, what `game.restore` loads, and its steps. A step is a
 * `/control` command by its short name with that command's input, or `{ checkpoint: name }`,
-* where the runner saves `state.json` and `describe.json` next to the test. `walk` runs fast: a
+* where the runner lands every motion and saves `state.json` and `describe.json` next to the test;
+* `{ checkpoint: name, finish: false }` keeps the motions running for the snapshot. `walk` runs fast: a
 * popup its last node opens never mounts, so the step before a checkpoint that shows a node's
 * result is `answer` or `tap`. With `webgl: true` the test also runs in the WebGL leg
 * (`--webgl`), whose pictures go to `screen.webgl.webp`: set it on a screen with a custom filter.
@@ -773,17 +795,19 @@ async function settleAt(play, where) {
 	if (play.loop.error !== void 0) throw play.loop.error;
 }
 /**
-* Plays a checkpoint: settle, land every track and loop, two frames, then read and compare.
+* Plays a checkpoint: settle, land every track and loop unless it says `finish: false`, two
+* frames, then read and compare.
 *
 * @param play - The test being played.
-* @param name - The checkpoint name.
+* @param entry - The checkpoint: its name, and whether it lands the motions.
 * @param where - The step, for the message.
 * @returns The outcome of the checkpoint; `pixels` is skipped in this leg.
 */
-async function checkpoint$1(play, name, where) {
+async function checkpoint$1(play, entry, where) {
 	const { app, test, run: options } = play;
+	const { name } = entry;
 	await settleAt(play, where);
-	app.anim.finishAll();
+	if (entry.finish) app.anim.finishAll();
 	await frames(app, REST_FRAMES);
 	const file = (kind) => baselineFile(options.dir, test.name, name, kind);
 	const state = await checkBaseline(file("state.json"), stableJson(stateOf(app)), options.update);
@@ -819,7 +843,7 @@ async function playSteps$1(play, checkpoints) {
 		const entry = stepEntry(test.name, step, index);
 		const where = `step ${index + 1} (${entry.kind === "checkpoint" ? "checkpoint" : entry.name})`;
 		if (entry.kind === "checkpoint") {
-			checkpoints.push(await checkpoint$1(play, entry.name, where));
+			checkpoints.push(await checkpoint$1(play, entry, where));
 			continue;
 		}
 		await failing(test.name, where, () => runStep(app, entry.name, entry.input));
@@ -1234,13 +1258,16 @@ async function pageStep(argument) {
 	}
 }
 /**
-* Plays a checkpoint in the page: settle, land every track and loop, two stepped frames, then the
+* Plays a checkpoint in the page: settle, land every track and loop unless the step says
+* `finish: false` (F87), two stepped frames, then the
 * picture of the whole canvas as lossless WebP and the state through the doors. The game is
 * paused, so the picture is the stage after the last stepped frame. With the frame check on, a
 * missed frame or mark logged in the meantime fails the checkpoint.
 *
-* @param argument - The test and the step, and the most frames to settle.
+* @param argument - The test and the step, the most frames to settle, and whether to land the
+*   motions.
 * @param argument.settleFrames - The most frames to settle.
+* @param argument.finish - True to land every motion before the picture.
 * @returns The state and the picture, or why the checkpoint failed.
 */
 async function pageCheckpoint(argument) {
@@ -1252,7 +1279,7 @@ async function pageCheckpoint(argument) {
 			ok: false,
 			error: unsettled
 		};
-		game.anim.finishAll();
+		if (argument.finish) game.anim.finishAll();
 		await pageTick(handles);
 		await pageTick(handles);
 		const captured = await game.renderer.capture();
@@ -1497,6 +1524,17 @@ function pageScript() {
 }
 //#endregion
 //#region src/visual/leg-browser.ts
+/**
+* @file visual — the browser leg: Chrome with WebGPU on a Mac, driven by Playwright. It loads
+* `playwright-core` with a dynamic import only here, opens the dev page once per test, waits until
+* the page has loaded what it asked for, turns on the renderer's check of skipped frames
+* (`debug.verifyFrames`), pauses the game and steps it to the start time, plays the
+* test inside the page through `globalThis.game` and `globalThis.doors` on stepped frames, and at
+* each checkpoint checks the page's state against `state.json` and its picture against
+* `screen.webp`. The WebGL leg opens the page with `?renderer=webgl` and keeps its pictures in
+* `screen.webgl.webp`. The pixels are compared in the page (`page-script.ts`); the files are written by
+* `files.ts`. A failure of the page itself fails the leg; a failure of a step ends its test only.
+*/
 /** The Chrome flags of `.planning/e2e/run.mjs`: WebGPU on Metal, on any GPU. */
 const WEBGPU_FLAGS = [
 	"--enable-unsafe-webgpu",
@@ -1636,6 +1674,20 @@ async function launchChrome(chromium, browser) {
 	throw new Error(`[game] No Chrome launched: ${own.reason}.\n  Install Playwright's Chromium (bunx playwright-core install chromium), set page.browser, or run with --no-pixels.`);
 }
 /**
+* The init script that puts the moment of the headless leg's clock on the page before it loads
+* (F86): a dev page then runs its app on a fake clock standing there, as the headless leg does.
+*
+* @param moment - The moment, epoch milliseconds.
+* @returns The script.
+* @example
+* ```ts
+* clockScript(1_000_000); // 'globalThis["__mokuVisualClock"] = 1000000;'
+* ```
+*/
+function clockScript(moment) {
+	return `globalThis[${JSON.stringify(VISUAL_CLOCK)}] = ${JSON.stringify(moment)};`;
+}
+/**
 * Sizes the page: `page.width` CSS px wide (390), as tall as the inert frame of the game is at
 * that width, so the reference frame of the page equals the one of the headless leg; a phone
 * with touch at `page.deviceScaleFactor` (2). Builds one app of the setup, never started, to read
@@ -1762,14 +1814,16 @@ async function startPage(page, url, run) {
 * @param context - The browser context.
 * @param url - The URL of the page the leg opens.
 * @param run - The run options, for `settleFrames` and `renderer`.
+* @param moment - The moment the headless leg's clock stands at, for the page's clock (F86).
 * @returns The open page.
 * @throws {Error} When the page does not open, never exposes `game` and `doors`, does not start,
 *   draws with another backend or never stops loading. The page is closed then.
 */
-async function openPage(context, url, run) {
+async function openPage(context, url, run, moment) {
 	const page = await context.newPage();
 	try {
 		await page.addInitScript({ content: pageScript() });
+		await page.addInitScript({ content: clockScript(moment) });
 		await page.goto(url).catch((error) => {
 			throw new Error(`[game] The page at ${url} did not open: ${firstLine(error)}.\n  Serve the dev page (moku-game dev), or run with --no-pixels.`);
 		});
@@ -1825,17 +1879,19 @@ async function checkScreen(play, file, where, screen) {
 * headless leg wrote, the picture against the baseline of the leg's backend.
 *
 * @param play - The test being played.
-* @param name - The checkpoint name.
+* @param entry - The checkpoint: its name, and whether it lands the motions.
 * @param where - The step, for the message.
 * @returns What the browser leg found there.
 * @throws {Error} When the page did not settle, gave no picture, or broke.
 */
-async function checkpoint(play, name, where) {
+async function checkpoint(play, entry, where) {
 	const { test, run } = play;
+	const { name } = entry;
 	const shot = await callPage(play.page, pageCheckpoint, {
 		test: test.name,
 		where,
-		settleFrames: run.settleFrames
+		settleFrames: run.settleFrames,
+		finish: entry.finish
 	});
 	if (shot.screen === void 0) throw new Error(`[game] Visual test "${test.name}", ${where}: the page gave no picture.\n  Serve a dev build with ${BACKEND[run.renderer]}: renderer.capture() answers only there.`);
 	const file = (kind) => baselineFile(run.dir, test.name, name, kind);
@@ -1882,7 +1938,7 @@ async function playSteps(play, found) {
 		const entry = stepEntry(test.name, step, index);
 		const where = `step ${index + 1} (${entry.kind === "checkpoint" ? "checkpoint" : entry.name})`;
 		if (entry.kind === "checkpoint") {
-			found.set(entry.name, await checkpoint(play, entry.name, where));
+			found.set(entry.name, await checkpoint(play, entry, where));
 			continue;
 		}
 		await callPage(play.page, pageStep, {
@@ -1901,13 +1957,15 @@ async function playSteps(play, found) {
 * @param play - The test and the run options; the page is opened here.
 * @param play.test - The test.
 * @param play.run - The run options.
-* @param url - The URL of the page the leg opens.
+* @param target - The page the leg opens: its URL, and the moment of the headless leg's clock.
+* @param target.url - The URL.
+* @param target.moment - The moment, epoch milliseconds.
 * @param headless - The result of the test in the headless leg.
 * @returns The result of the test with its pixel fields.
 * @throws {Error} When the page fails to open: that fails the leg.
 */
-async function browserTest(context, play, url, headless) {
-	const page = await openPage(context, url, play.run);
+async function browserTest(context, play, target, headless) {
+	const page = await openPage(context, target.url, play.run, target.moment);
 	const found = /* @__PURE__ */ new Map();
 	let failed;
 	try {
@@ -1954,7 +2012,10 @@ async function runBrowserLeg(setup, tests, run, headless, load = loadChromium) {
 	if (page === void 0) throw new Error("[game] The pixel leg needs the dev page.\n  Pass page: { url } in the setup, or run with --no-pixels.");
 	const chromium = await load();
 	const options = pageSize(setup, page);
-	const url = rendererUrl(page.url, run.renderer);
+	const target = {
+		url: rendererUrl(page.url, run.renderer),
+		moment: setup.app().clock.now()
+	};
 	const browser = await launchChrome(chromium, page.browser);
 	try {
 		const context = await browser.newContext(options);
@@ -1967,7 +2028,7 @@ async function runBrowserLeg(setup, tests, run, headless, load = loadChromium) {
 			results.push(before.error === void 0 ? await browserTest(context, {
 				test,
 				run
-			}, url, before) : before);
+			}, target, before) : before);
 		}
 		return results;
 	} finally {

package/llms.txt

@@ -12,7 +12,7 @@ Facts: Bun only. ESM only. `"sideEffects"` lists the root entry `./dist/index.mj
 - `@moku-labs/game/app/system` (the browser, the native shell): `systemShellOf`, `fromSystem`, `storeSave`, `createSystemApp`, the type `SystemModules`, over the optional peer `@moku-labs/system`. The one entry that names it, in types only: the page hands it the loaders.
 - `@moku-labs/game/cli` (node and bun only): `runCli`, the bin `moku-game`, `preparePage`, the editor's dev page, `watchKeys`, the watch that keeps `generated/` fresh next to it, and `watchEngine`, the watch that tells when the installed engine changed.
 - `@moku-labs/game/testing`: headless play, repro runs, isolated feature tests (`isolate`, `stub`), fake clock, the `fx` of a node for a unit test (`fakeFx`), in-memory save provider. No `node:` import.
-- `@moku-labs/game/visual` (node and bun only): the visual tests `defineVisualTest`, `runVisualTests`, `parseVisualArgv`. The bin runs them: `moku-game visual`.
+- `@moku-labs/game/visual` (node and bun only): the visual tests `defineVisualTest`, `runVisualTests`, `parseVisualArgv`. The bin runs them: `moku-game visual`. A step is a `/control` command or `{ checkpoint: name, finish?: boolean }`: a checkpoint lands every motion before its snapshot, `finish: false` keeps them running (same frames in both legs). Both legs run on one clock: the pixel leg's dev page runs on a fake clock at the headless app's `clock.now()` (`startMoment`), standing still like the headless one.
 - `@moku-labs/game/assets` (node and bun only): the asset key scanner, the production packer and the string compiler. The package bin `moku-game-assets` runs it.
 - `@moku-labs/game/inspect`: the read door of the editor, safe in a production build. See "Doors for the editor".
 - `@moku-labs/game/control`: the write door of the editor, dev builds only. See "Doors for the editor".
@@ -557,6 +557,7 @@ A screen is a projection whose `view` returns JSX. The game's `tsconfig.json` se
 - Keys that come from data: `I18n.TextKey<Strings>` is the keys of the generated `Strings` without parameters (nothing new is generated). A data table types its keys `TextKey` or builds them with the kit's `key("board.hint.red")`; the kit's `tr` never takes a plain `string`. A key read back from a save is checked where the app is (an effect handler, app or page code, loading a save) with one `isKey(value)`: `defineGameApp({ ..., strings: type<Strings>() })` types the game's `app.i18n`, so a true `app.i18n.isKey(value)` narrows the value to `TextKey`; `ctx.require(i18nPlugin).isKey(value)` in a plugin narrows to `string`. `app.i18n.isKey(value)` answers true for a key of the loaded tables of the current locale or the fallback, and for the `<feature>.` prefix of a sub-feature whose strings are not loaded yet; a key that takes parameters answers true too.
 - Text: `Text` component, `label({ text, style, at, anchor? })` for board text in a projection view, `defineTextStyles({ "hud.digits": { font, size, fill, bold?, italic?, stroke?, strokeWidth?, letterSpacing?, align?, wrap? (a width, "none" or "box": wrap at the laid-out width of its ui element), digits? } })` under the feature's `textStyles` key. Tags inside a string: `<b>`, `<i>`, `<color=#rrggbb>`, `<icon=key>`, `\<`, `\n`. Built-in styles `body` and `digits` from config `fonts: { body: "ui.font-body", digits: "ui.font-digits" }`. `app.text.measure(content, style, width?)` gives the same numbers in a browser and in Bun. `app.text.replaceStyles(styles)` is the dev hot swap of a saved `defineTextStyles` value.
 - Animation is data: `defineAnimation(id, { slots: { name: type<Anim.Target>() }, build: (slots, { at }) => Step })`. Steps: `sequence(...)`, `parallel(...)`, `stagger(items, ms, item => Step)`, `tween(target, Component, to, { ms, ease?, delayMs?, additive?, space?, reduced? })`, `set(target, Component, patch)`, `wait(ms)`, `mark(name)`, `frames(target, { keys, fps, loop? })`, `sfx(key, { bus? })`, `haptic(kind)`, `use(animation, slots, tools?)`, `spawn` (a temporary entity, flying coins, that the timeline despawns when it ends; see the anim README). `Frames({ keys, fps, loop, playing })` is a component that walks a sprite through its textures for the entity's whole life. A target is `{ projection, key }` or an entity. A timeline resolves each `{ projection, key }` target once, when it starts: every step writes the view that held the key then, also after a commit removed it and while its exit plays, until it despawns; a view spawned again under the same key is not followed, and a key nothing held at the start is looked up at its step. `reduced: "keep"` (on a `tween` step, `transition` and `loop` of `defineMotion`, `TweenOptions`, `RestOptions`) plays a track as written under reduced motion, a fade for one; the default `"cut"` lands it at once or holds a loop on its first key. A node plays it with `await fx(play(animation, slots))`; in fast mode it finishes at once. `defineMotion({ states, transition?, on: { enter?, exit?, change? }, when? })` builds the enter, exit and change hooks for a projection or the `motion` prop of a tag; `when: "change"` plays enter and exit only for a commit, so an element that comes or goes with its screen stands at rest and leaves without a motion (default `"always"`). Events `anim:mark` `{ animation, mark }` and `anim:finished` `{ animation }`. `app.anim.replace(definition)` is the dev hot swap: the next `play` builds the new tree. A system cannot `require` a plugin, so it plays through the resource `AnimPlayer`: `res(AnimPlayer).play(animation, slots)` returns the same handle as `app.anim.play`, and the registered animation of `animation.id` wins, so a hot swap reaches the system. Play on a change, never every frame; from phase `input` the tree moves in `animate` of the same frame. Before `anim` starts it throws `[game] AnimPlayer is not ready: anim has not started.` Config `maxTracks: 2000`.
+- A `tween` step takes `segments` and `repeat` as `ViewHandle.tween` does: `tween(chest, Transform, { y: 0, scale: 0 }, { ms: 2400, additive: true, repeat: "forever", segments: [{ at: 0.08, ease: "out", to: { y: -14, scale: 0.06 } }, { at: 1, to: { y: 0, scale: 0 } }] })`. Segments walk over `ms` on one clock, `to` is where the last one ends, an additive walk names offsets; a number counts the extra runs. A definition error throws for empty segments, an `at` outside 0..1 or out of order, a last segment before 1, a bad repeat, and a `sequence` step after one that never ends. A forever step ends only by cancel or finish (a finish and a fast world land it on its start pose), does not play under reduced motion `"cut"`, writes nothing while its view is unseen, and lets the clock idle; a system plays it once through `AnimPlayer` and keeps the handle.
 - Audio is opt-in: `plugins: [...screen, audioPlugin]`. `fx(sfx("orders.complete"))` resolves when the sound started. `await fx(music("board.theme"))` cross-fades; `music(null)` fades out; a scene's `music` key switches the track on `scenes:changed`. Buses `master`, `music`, `sfx`. Volumes come from the committed player: config `volumes: player => (player as Player).settings.audio`, applied on every `model:committed`. `app.audio`: `setVolume(bus, value)`, `volume(bus)`, `mute(bus, on)`, `muted(bus)`, `unlocked()`, `journal()` (the last started sounds, empty unless config `journal` is above 0). Config: `buses: { master: 1, music: 0.6, sfx: 1 }`, `musicFadeMs: 600`, `volumes`, `context`, `journal: 0`, `music: "decode" | "stream"` default `"decode"` (gapless buffer; `"stream"` is an `<audio>` element, less memory, a gap at every loop), `session: "ambient" | "playback" | "auto"` default `"ambient"` (iOS only: ambient mixes with other apps and obeys the silent switch). The context is asked to run at start: where the shell lets audio play (a native webview with the gesture requirement off) `unlocked()` is true with no touch; a browser that wants a gesture unlocks on the first `pointerdown` or `touchend`. Without `audio` every `sfx` and `music` effect resolves `undefined` at once, so the same node runs in a game with no sound. Named sounds: `sfx(key, { bus?, id?, fadeMs? })` with an `id` plays through its own gain, and the next sound with the same `id` fades the old one out over `fadeMs`, else config `sfxFadeMs` (default `120`, real milliseconds); `fx.start(stopSfx(id, { fadeMs? }))` and `app.audio.stop(id, { fadeMs? })` fade it out and end it (`fadeMs: 0` cuts it); an `id` nothing plays under changes nothing, and a sound of that `id` still decoding never starts. Without `id` an `sfx` plays to its end as before.
 - `app.ui`: `tree()` the live screen as plain data (a text node carries `content`, the words it draws after `tr()` and `bind`; a text field carries `value`), `find(key)` the entity of a keyed element, `fill(key, value)` types into the text field with that `key`, `scroll(key, to)` puts the `scroll` with that `key` at `to` from its start at once, inside `0..max`, its fling or glide stopped (`false` and `ui:scroll-without-scroll` for no live `scroll`, `false` and `ui:scroll-before-solve` for a `scroll` its first solve has not placed yet), `lint()` tap targets under `tapTargetPt` (default `44`), text that overflows in some locale, absolute elements without `reason`. Config: `tapTargetPt: 44`, `breakpoints: { tall: 2, wide: 1.5 }`. `ui` emits only the dev global event `ui:hot-swap`, see "Hot swap".
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.15.30",
+  "version": "0.15.32",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": [