rn-gamekit 0.1.0

package/lib/typescript/src/core/session/types.d.ts

@@ -0,0 +1,104 @@
+import type { InputMap, SceneMap } from '../../definition/types.js';
+import type { SceneSnapshot } from '../../scene/types.js';
+import type { Viewport } from '../../viewport2d/types.js';
+import type { InputController } from '../input/types.js';
+/** Recursively readonly view of renderer snapshot data. */
+export type DeepReadonly<T> = T extends (...arguments_: never[]) => unknown ? T : T extends readonly (infer TItem)[] ? readonly DeepReadonly<TItem>[] : T extends object ? {
+    readonly [TKey in keyof T]: DeepReadonly<T[TKey]>;
+} : T;
+/** Lifecycle states of a headless game session. */
+export type GameSessionStatus = 'idle' | 'running' | 'paused' | 'disposed';
+/** One renderer-neutral simulation commit produced by a game session. */
+export interface CommitFrameBase<TSnapshot> {
+    /** Snapshot immediately before the latest simulation update. */
+    readonly previous: DeepReadonly<TSnapshot>;
+    /** Snapshot produced by the latest simulation update. */
+    readonly current: DeepReadonly<TSnapshot>;
+    /** Number of completed global simulation updates. */
+    readonly tick: number;
+    /** Deterministic elapsed global simulation time in seconds. */
+    readonly elapsedSeconds: number;
+    /** Monotonic commit counter; increments on every simulation commit. */
+    readonly revision: number;
+    /** True when this commit is a transition hard cut (previous === current). */
+    readonly hardCut: boolean;
+    /** Fixed simulation step duration in milliseconds (UI alpha clock input). */
+    readonly stepMs: number;
+}
+/**
+ * A simulation commit discriminated by its scene name.
+ *
+ * Narrowing on `frame.scene` narrows both `previous` and `current` to the
+ * snapshot type of that scene. A transition commits a hard cut where both
+ * snapshots come from the new scene; frames never interpolate between two
+ * scene types.
+ */
+export type CommitFrame<TScenes extends SceneMap> = {
+    [TName in keyof TScenes]: CommitFrameBase<SceneSnapshot<TScenes[TName]>> & {
+        readonly scene: TName;
+    };
+}[keyof TScenes];
+/** A commit frame plus a presentation fraction computed on demand. */
+export type GameRenderFrame<TScenes extends SceneMap> = CommitFrame<TScenes> & {
+    /** Live fixed-step fraction at call time; renderers use the UI clock. */
+    readonly alpha: number;
+};
+/** An idempotently removable render-frame subscription. */
+export interface GameSubscription {
+    /** Stop future notifications. Safe to call repeatedly. */
+    remove(): void;
+}
+/** A closure-backed, headless running instance of one game definition. */
+export interface GameSession<TScenes extends SceneMap = SceneMap, TInput extends InputMap = InputMap> {
+    /** Current lifecycle status. */
+    readonly status: GameSessionStatus;
+    /** The active scene name, updated by transitions and restarts. */
+    readonly scene: keyof TScenes;
+    /** The authored viewport configuration of this game. */
+    readonly viewport: Viewport;
+    /** Semantic input controller constrained to declared action names. */
+    readonly input: InputController<Extract<keyof TInput, string>>;
+    /** Start an idle session or resume a paused session. */
+    start(): void;
+    /** Pause simulation and discard suspended wall time. */
+    pause(): void;
+    /**
+     * Transition to a declared scene.
+     *
+     * While running, the transition commits at the next fixed-step boundary.
+     * While idle or paused, it commits synchronously and publishes the new
+     * frame. Setting the current scene is an idempotent no-op.
+     */
+    setScene(name: keyof TScenes): void;
+    /** Recreate the active scene with fresh state. */
+    restartScene(): void;
+    /** Permanently stop the session and release the active scene. */
+    dispose(): void;
+    /**
+     * Read the latest immutable simulation commit with a live presentation
+     * fraction.
+     *
+     * Freshness contract: `alpha` is computed on demand from the session's
+     * accumulated timing fraction at call time and is only meaningful for
+     * headless inspection. Rendering uses the UI-owned alpha clock; the
+     * envelope fields never change between commits.
+     */
+    getRenderFrame(): GameRenderFrame<TScenes>;
+    /** Observe simulation commits at commit frequency (never per display frame). */
+    addCommitListener(listener: (frame: CommitFrame<TScenes>) => void): GameSubscription;
+}
+/** Error thrown when live work is requested from a disposed session. */
+export declare class GameSessionDisposedError extends Error {
+    readonly name = "GameSessionDisposedError";
+    constructor();
+}
+/**
+ * Error thrown for lifecycle violations: conflicting transition requests,
+ * transition controllers used outside their update, unknown runtime scene
+ * names, and pending transition conflicts.
+ */
+export declare class GameSessionLifecycleError extends Error {
+    readonly name = "GameSessionLifecycleError";
+    constructor(message: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/core/session/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/session/types.ts"],"names":[],"mappings":"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"}

package/lib/typescript/src/definition/defineGame.d.ts

@@ -0,0 +1,66 @@
+import type { AssetGroupMap } from '../assets/types.js';
+import type { GameDefinition, InputMap, SceneMap } from './types.js';
+type SceneActions<TScene> = TScene extends {
+    readonly __actionType?: infer TAction;
+} ? Exclude<TAction, undefined> : never;
+type SceneTransitions<TScene> = TScene extends {
+    readonly __transitionType?: infer TTransition;
+} ? Exclude<TTransition, undefined> : never;
+type UndeclaredSceneActions<TScenes extends SceneMap, TInput extends InputMap> = Exclude<SceneActions<TScenes[keyof TScenes]>, Extract<keyof TInput, string>>;
+type UndeclaredSceneTransitions<TScenes extends SceneMap> = Exclude<SceneTransitions<TScenes[keyof TScenes]>, keyof TScenes>;
+type ValidateSceneActions<TScenes extends SceneMap, TInput extends InputMap> = UndeclaredSceneActions<TScenes, TInput> extends never ? unknown : {
+    readonly __undeclaredSceneActions: UndeclaredSceneActions<TScenes, TInput>;
+};
+type ValidateSceneTransitions<TScenes extends SceneMap> = UndeclaredSceneTransitions<TScenes> extends never ? unknown : {
+    readonly __undeclaredSceneTransitions: UndeclaredSceneTransitions<TScenes>;
+};
+/**
+ * Declare a game.
+ *
+ * `defineGame` is the entry point of the provisional GameKit API. It
+ * validates the definition at the type level — scene names are inferred so
+ * `initialScene` must be one of the keys of `scenes`, every scene action must
+ * exist in the game input map, and every declared transition target must be a
+ * declared scene — and preserves and returns the supplied definition.
+ *
+ * This function creates no runtime state: it does not start a scheduler,
+ * allocate a session, load assets, or register input. Pass the definition to
+ * `createGameSession` to create a live instance. The shape is provisional
+ * until reference games validate it.
+ *
+ * @example
+ * ```ts
+ * const game = defineGame({
+ *   viewport: {
+ *     logicalSize: { width: 390, height: 844 },
+ *     mode: 'fit',
+ *   },
+ *   assets: [],
+ *   input: { primary: { type: 'pointer' } },
+ *   scenes: {
+ *     ready: defineScene({
+ *       actions: ['primary'],
+ *       transitions: ['play'],
+ *       create: () => ({ ready: true }),
+ *       update: ({ state, input, transition }) => {
+ *         if (input.pointer('primary').pressed) {
+ *           transition.setScene('play');
+ *         }
+ *         return state;
+ *       },
+ *       snapshot: ({ state }) => state,
+ *     }),
+ *     play: defineScene({
+ *       actions: [],
+ *       create: () => ({ x: 0 }),
+ *       update: ({ state }) => ({ x: state.x + 1 }),
+ *       snapshot: ({ state }) => ({ x: state.x }),
+ *     }),
+ *   },
+ *   initialScene: 'ready',
+ * });
+ * ```
+ */
+export declare function defineGame<const TScenes extends SceneMap, const TInput extends InputMap = InputMap, const TInitialScene extends keyof TScenes = keyof TScenes, const TAssets extends AssetGroupMap = AssetGroupMap>(definition: GameDefinition<TScenes, TInput, TInitialScene, TAssets> & ValidateSceneActions<TScenes, TInput> & ValidateSceneTransitions<TScenes>): GameDefinition<TScenes, TInput, TInitialScene, TAssets>;
+export {};
+//# sourceMappingURL=defineGame.d.ts.map

package/lib/typescript/src/definition/defineGame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineGame.d.ts","sourceRoot":"","sources":["../../../../src/definition/defineGame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAS,CAAC;AAElE,KAAK,YAAY,CAAC,MAAM,IAAI,MAAM,SAAS;IAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,GAChF,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,GAC3B,KAAK,CAAC;AAEV,KAAK,gBAAgB,CAAC,MAAM,IAAI,MAAM,SAAS;IAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,WAAW,CAAA;CAAE,GAC5F,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,GAC/B,KAAK,CAAC;AAEV,KAAK,sBAAsB,CAAC,OAAO,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ,IAAI,OAAO,CACtF,YAAY,CAAC,OAAO,CAAC,MAAM,OAAO,CAAC,CAAC,EACpC,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,CAC9B,CAAC;AAEF,KAAK,0BAA0B,CAAC,OAAO,SAAS,QAAQ,IAAI,OAAO,CACjE,gBAAgB,CAAC,OAAO,CAAC,MAAM,OAAO,CAAC,CAAC,EACxC,MAAM,OAAO,CACd,CAAC;AAEF,KAAK,oBAAoB,CAAC,OAAO,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ,IACzE,sBAAsB,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,KAAK,GACjD,OAAO,GACP;IAAE,QAAQ,CAAC,wBAAwB,EAAE,sBAAsB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AAErF,KAAK,wBAAwB,CAAC,OAAO,SAAS,QAAQ,IACpD,0BAA0B,CAAC,OAAO,CAAC,SAAS,KAAK,GAC7C,OAAO,GACP;IAAE,QAAQ,CAAC,4BAA4B,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,UAAU,CACxB,KAAK,CAAC,OAAO,SAAS,QAAQ,EAC9B,KAAK,CAAC,MAAM,SAAS,QAAQ,GAAG,QAAQ,EACxC,KAAK,CAAC,aAAa,SAAS,MAAM,OAAO,GAAG,MAAM,OAAO,EACzD,KAAK,CAAC,OAAO,SAAS,aAAa,GAAG,aAAa,EAEnD,UAAU,EAAE,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,GACjE,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,GACrC,wBAAwB,CAAC,OAAO,CAAC,GAClC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,CAMzD"}

package/lib/typescript/src/definition/types.d.ts

@@ -0,0 +1,56 @@
+import type { AssetGroupMap, GameAssetManifest } from '../assets/types.js';
+import type { Viewport } from '../viewport2d/types.js';
+/** The button action supported by the runtime. */
+export interface ButtonInputAction {
+    /** Discriminant for a digital button action. */
+    readonly type: 'button';
+    /** Optional human-readable description for diagnostics and tooling. */
+    readonly description?: string;
+}
+/** A single primary pointer action driven by touch or a mouse pointer. */
+export interface PointerInputAction {
+    /** Discriminant for a pointer action. */
+    readonly type: 'pointer';
+    /** Optional human-readable description for diagnostics and tooling. */
+    readonly description?: string;
+}
+/** A named semantic input action. */
+export type InputAction = ButtonInputAction | PointerInputAction;
+/** The collection of semantic input actions declared by a game. */
+export type InputMap = Readonly<Record<string, InputAction>>;
+/**
+ * Structural marker shared by all definitions created with `defineScene`.
+ *
+ * It lets `defineGame` retain each scene's inferred state, snapshot, action,
+ * and transition types without erasing them into a universal world or
+ * renderer shape.
+ */
+export interface SceneDefinitionMarker {
+    /** Internal scene-definition discriminator. */
+    readonly kind: 'gamekit.scene';
+    /** @internal Type witness for actions consumed by this scene. */
+    readonly __actionType?: string;
+    /** @internal Type witness for transition targets declared by this scene. */
+    readonly __transitionType?: string;
+}
+/** The collection of functional scenes declared by a game. */
+export type SceneMap = Readonly<Record<string, SceneDefinitionMarker>>;
+/**
+ * A complete static game definition produced by `defineGame`.
+ *
+ * Creating a definition allocates no runtime state. Pass it to
+ * `createGameSession` when a live headless session is required.
+ */
+export interface GameDefinition<TScenes extends SceneMap = SceneMap, TInput extends InputMap = InputMap, TInitialScene extends keyof TScenes = keyof TScenes, TAssets extends AssetGroupMap = AssetGroupMap> {
+    /** The viewport configuration of the game. */
+    readonly viewport: Viewport;
+    /** Typed asset manifest; optional for shape-only games. */
+    readonly assets?: GameAssetManifest<TAssets>;
+    /** Semantic input actions declared by the game. */
+    readonly input: TInput;
+    /** Functional scenes keyed by stable scene name. */
+    readonly scenes: TScenes;
+    /** The scene created first when a session starts. */
+    readonly initialScene: TInitialScene;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/definition/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/definition/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAqB,CAAC;AAEpD,kDAAkD;AAClD,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,uEAAuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAEjE,mEAAmE;AACnE,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,8DAA8D;AAC9D,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAC7B,OAAO,SAAS,QAAQ,GAAG,QAAQ,EACnC,MAAM,SAAS,QAAQ,GAAG,QAAQ,EAClC,aAAa,SAAS,MAAM,OAAO,GAAG,MAAM,OAAO,EACnD,OAAO,SAAS,aAAa,GAAG,aAAa;IAE7C,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC7C,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,qDAAqD;IACrD,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;CACtC"}

package/lib/typescript/src/geometry/types.d.ts

@@ -0,0 +1,8 @@
+/** A plain 2D point in logical/world or surface coordinate space. */
+export interface Point2D {
+    /** Horizontal coordinate. */
+    readonly x: number;
+    /** Vertical coordinate. */
+    readonly y: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/geometry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/geometry/types.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,MAAM,WAAW,OAAO;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,18 @@
+export { createGameSession } from './core/session/createGameSession.js';
+export { GameSessionDisposedError, GameSessionLifecycleError } from './core/session/types.js';
+export type { ButtonState, InputController, InputFrame, PointerState, } from './core/input/types.js';
+export type { DeepReadonly, CommitFrame, GameRenderFrame, GameSession, GameSessionStatus, GameSubscription, } from './core/session/types.js';
+export { advanceSpriteAnimation, pauseSpriteAnimation, playSpriteAnimation, resetSpriteAnimation, resumeSpriteAnimation, setSpriteAnimationSpeed, startSpriteAnimation, } from './sprites/spriteAnimationState.js';
+export { sampleSpriteClipFrame, sampleSpriteClipFrameName, spriteClipDurationMs, } from './sprites/sampleSpriteClip.js';
+export type { SpriteAnimationState, SpriteClipNames } from './sprites/spriteAnimationState.js';
+export { defineAssets, image, spriteSheet } from './assets/defineAssets.js';
+export { GameAssetError } from './assets/errors.js';
+export type { AssetDescriptor, AssetGroup, AssetGroupMap, AssetSourceHandle, BrandedAssetDescriptor, GameAssetLease, GameAssetManifest, ImageDescriptor, LoadedAssets, LoadedImage, LoadedSpriteSheet, ManifestOf, SpriteAnimationMode, SpriteClip, SpriteFrameRect, SpriteSheetDescriptor, } from './assets/types.js';
+export { defineGame } from './definition/defineGame.js';
+export type { ButtonInputAction, GameDefinition, InputAction, InputMap, PointerInputAction, SceneDefinitionMarker, SceneMap, } from './definition/types.js';
+export type { Point2D } from './geometry/types.js';
+export { defineScene } from './scene/defineScene.js';
+export type { SceneDefinition, SceneSnapshot, SceneSnapshotContext, SceneTransitionController, SceneUpdate, } from './scene/types.js';
+export { containsSurfacePoint, resolveViewport2D, surfaceToWorld, worldToSurface, } from './viewport2d/index.js';
+export type { LogicalSize, Rect, ResolvedViewport2D, SurfaceSize, Viewport, ViewportMode, } from './viewport2d/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAkC,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,yBAAsB,CAAC;AAC3F,YAAY,EACV,WAAW,EACX,eAAe,EACf,UAAU,EACV,YAAY,GACb,MAAM,uBAAoB,CAAC;AAC5B,YAAY,EACV,YAAY,EACZ,WAAW,EACX,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAsB,CAAC;AAC9B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,mCAAgC,CAAC;AACxC,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,+BAA4B,CAAC;AACpC,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mCAAgC,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,0BAAuB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAiB,CAAC;AACjD,YAAY,EACV,eAAe,EACf,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,qBAAqB,GACtB,MAAM,mBAAgB,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,4BAAyB,CAAC;AACrD,YAAY,EACV,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,QAAQ,EACR,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,GACT,MAAM,uBAAoB,CAAC;AAC5B,YAAY,EAAE,OAAO,EAAE,MAAM,qBAAkB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAqB,CAAC;AAClD,YAAY,EACV,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,yBAAyB,EACzB,WAAW,GACZ,MAAM,kBAAe,CAAC;AACvB,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,cAAc,GACf,MAAM,uBAAc,CAAC;AACtB,YAAY,EACV,WAAW,EACX,IAAI,EACJ,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,YAAY,GACb,MAAM,uBAAc,CAAC"}

package/lib/typescript/src/react/GamePointerInput.d.ts

@@ -0,0 +1,37 @@
+import type { InputMap, PointerInputAction, SceneMap } from '../definition/types.js';
+import type { GameSession } from '../core/session/types.js';
+import type { GamePointerInstrumentation } from './instrumentation.js';
+/** Declared pointer action names of an input map. */
+type PointerActionName<TInput extends InputMap> = {
+    [TName in Extract<keyof TInput, string>]: TInput[TName] extends PointerInputAction ? TName : never;
+}[Extract<keyof TInput, string>];
+/** Props for the pointer input adapter that covers the game surface. */
+export interface GamePointerInputProps<TScenes extends SceneMap, TInput extends InputMap> {
+    /** The session whose input buffer receives pointer events. */
+    readonly game: GameSession<TScenes, TInput>;
+    /** A declared pointer action on the game. */
+    readonly action: PointerActionName<TInput>;
+    /** Optional measurement callbacks for the Performance Lab (F1). */
+    readonly instrumentation?: GamePointerInstrumentation;
+}
+/**
+ * Bind one primary pointer to a declared pointer action.
+ *
+ * Gesture Handler is an implementation detail: the manual gesture activates
+ * explicitly on touch down, mirrors the letterbox containment check on the UI
+ * runtime (failing the gesture before activation), forwards plain touch data
+ * through a coalescer that crosses runtimes at most once per fixed step
+ * (latest dirty position only; edges never throttled or dropped), and ends
+ * explicitly when the last touch lifts. Ownership and edge sampling stay
+ * authoritative in the session input buffer, which re-validates every
+ * forwarded event on the JS side.
+ *
+ * All separately registered touch-handler worklets share one explicit
+ * coalescer SharedValue; closure-local mutation is not used because each
+ * handler can receive its own serialized closure copy. The binding is stable
+ * across ordinary React renders and is recreated only when its semantic
+ * session, action, or viewport owner changes.
+ */
+export declare function GamePointerInput<TScenes extends SceneMap, TInput extends InputMap>({ game, action, instrumentation, }: GamePointerInputProps<TScenes, TInput>): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=GamePointerInput.d.ts.map

package/lib/typescript/src/react/GamePointerInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GamePointerInput.d.ts","sourceRoot":"","sources":["../../../../src/react/GamePointerInput.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,wBAAqB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAAuB,CAAC;AAUzD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAmB,CAAC;AAWpE,qDAAqD;AACrD,KAAK,iBAAiB,CAAC,MAAM,SAAS,QAAQ,IAAI;KAC/C,KAAK,IAAI,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,kBAAkB,GAAG,KAAK,GAAG,KAAK;CACnG,CAAC,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAQjC,wEAAwE;AACxE,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ;IACtF,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC3C,mEAAmE;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,0BAA0B,CAAC;CACvD;AAwED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ,EAAE,EAClF,IAAI,EACJ,MAAM,EACN,eAAe,GAChB,EAAE,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,+BA2UxC"}

package/lib/typescript/src/react/GameView.d.ts

@@ -0,0 +1,61 @@
+import { type ComponentType, type ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import { type SharedValue } from 'react-native-reanimated';
+import type { InputMap, SceneMap } from '../definition/types.js';
+import type { AssetGroupMap, LoadedAssets } from '../assets/types.js';
+import type { CommitFrame, GameSession } from '../core/session/types.js';
+import type { ResolvedViewport2D } from '../viewport2d/index.js';
+import type { GameViewInstrumentation } from './instrumentation.js';
+import { type ViewportBinding } from './viewportBinding.js';
+/** Stable imperative values supplied to a Skia renderer component. */
+export interface GameRendererProps<TScenes extends SceneMap, TAssets extends AssetGroupMap = AssetGroupMap> {
+    /** Latest simulation commit, updated at commit frequency only. */
+    readonly frame: SharedValue<CommitFrame<TScenes>>;
+    /**
+     * UI-owned presentation fraction: advances on the UI runtime and resets
+     * to zero on every new commit. Never extrapolates past 1.
+     */
+    readonly alpha: SharedValue<number>;
+    /** Latest resolved viewport shared with the input adapter. */
+    readonly viewport: SharedValue<ResolvedViewport2D | undefined>;
+    /** The stable loaded asset lease (T7.5); shape-only renderers omit it. */
+    readonly assets?: LoadedAssets<TAssets>;
+}
+/** Props for the Skia-backed GameKit view. */
+export interface GameViewProps<TScenes extends SceneMap, TInput extends InputMap, TAssets extends AssetGroupMap = AssetGroupMap> {
+    /** Externally owned headless game session. */
+    readonly game: GameSession<TScenes, TInput>;
+    /**
+     * Explicit presentation key (RF6): remounts the per-session presentation
+     * when the session changes. The fallback is a stable per-session identity
+     * allocated from a WeakMap (T8.6) — never object stringification, which
+     * maps every session to the same value.
+     */
+    readonly presentationKey?: string | number;
+    /** The stable loaded asset lease; shape-only games omit it. */
+    readonly assets?: LoadedAssets<TAssets>;
+    /** Stable Skia renderer component for the session's scene snapshots. */
+    readonly renderer: ComponentType<GameRendererProps<TScenes, TAssets>>;
+    /** Optional measurement callbacks for the Performance Lab (F1). */
+    readonly instrumentation?: GameViewInstrumentation;
+    /** Static React HUD and controls mounted above the canvas. */
+    readonly children?: ReactNode;
+    /** Optional style for the mounted surface. */
+    readonly style?: StyleProp<ViewStyle>;
+}
+/**
+ * Context supplying the resolved viewport to pointer input children.
+ *
+ * `GamePointerInput` consumes the binding for JS-side conversion and the
+ * shared value for the UI-side containment mirror, so drawing and hit
+ * testing always use the same resolved viewport instance for a layout
+ * revision.
+ */
+export interface GameViewport {
+    readonly binding: ViewportBinding;
+    /** Resolved viewport shared value (layout-only updates). */
+    readonly viewport: SharedValue<ResolvedViewport2D | undefined>;
+}
+export declare const GameViewportContext: import("react").Context<GameViewport | null>;
+export declare function GameView<TScenes extends SceneMap, TInput extends InputMap, TAssets extends AssetGroupMap = AssetGroupMap>({ game, presentationKey, assets, renderer: Renderer, children, style, instrumentation, }: GameViewProps<TScenes, TInput, TAssets>): import("react").JSX.Element;
+//# sourceMappingURL=GameView.d.ts.map

package/lib/typescript/src/react/GameView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GameView.d.ts","sourceRoot":"","sources":["../../../../src/react/GameView.tsx"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,EAAoC,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG7F,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,wBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,0BAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAe,CAAC;AAIxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAmB,CAAC;AACjE,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,sBAAmB,CAAC;AAE7E,sEAAsE;AACtE,MAAM,WAAW,iBAAiB,CAChC,OAAO,SAAS,QAAQ,EACxB,OAAO,SAAS,aAAa,GAAG,aAAa;IAE7C,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC;IAC/D,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;CACzC;AAED,8CAA8C;AAC9C,MAAM,WAAW,aAAa,CAC5B,OAAO,SAAS,QAAQ,EACxB,MAAM,SAAS,QAAQ,EACvB,OAAO,SAAS,aAAa,GAAG,aAAa;IAE7C,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IACxC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IACtE,mEAAmE;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,uBAAuB,CAAC;IACnD,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC;CAChE;AAED,eAAO,MAAM,mBAAmB,8CAA2C,CAAC;AAsJ5E,wBAAgB,QAAQ,CACtB,OAAO,SAAS,QAAQ,EACxB,MAAM,SAAS,QAAQ,EACvB,OAAO,SAAS,aAAa,GAAG,aAAa,EAC7C,EACA,IAAI,EACJ,eAAe,EACf,MAAM,EACN,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EACR,KAAK,EACL,eAAe,GAChB,EAAE,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,+BA2DzC"}

package/lib/typescript/src/react/alphaClock.d.ts

@@ -0,0 +1,29 @@
+/**
+ * UI-owned alpha clock (T5).
+ *
+ * Pure, worklet-safe presentation clock: `alpha` advances from UI frame
+ * deltas against the simulation step duration and resets to zero whenever a
+ * newer commit arrives. It never extrapolates past the current snapshot
+ * (clamped at 1, then held) and ignores stale or duplicate commits so a
+ * delayed write cannot reset presentation backward.
+ *
+ * The `epoch` guards session replacement: a new GameView binding carries a
+ * fresh epoch, so a replacement session whose revision restarts at zero is
+ * still accepted, while a delayed write from an old epoch is ignored.
+ */
+export interface AlphaClockCommit {
+    /** Monotonic binding epoch; new epoch accepts any revision. */
+    readonly epoch: number;
+    /** Session commit revision; new revisions reset the clock. */
+    readonly revision: number;
+    /** Fixed simulation step duration in milliseconds. */
+    readonly stepMs: number;
+}
+export interface AlphaClockState {
+    readonly epoch: number;
+    readonly revision: number;
+    readonly alpha: number;
+}
+/** Advance the clock by one UI frame; returns the next alpha state. */
+export declare function advanceAlpha(previous: AlphaClockState, commit: AlphaClockCommit, frameDeltaMs: number): AlphaClockState;
+//# sourceMappingURL=alphaClock.d.ts.map

package/lib/typescript/src/react/alphaClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphaClock.d.ts","sourceRoot":"","sources":["../../../../src/react/alphaClock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,MAAM,GACnB,eAAe,CAwBjB"}

package/lib/typescript/src/react/assets/createGameAssetStore.d.ts

@@ -0,0 +1,33 @@
+import type { AssetGroupMap, GameAssetLease } from '../../assets/types.js';
+/** Opaque decoded-image handle (Skia's SkImage satisfies this structurally). */
+export interface NativeImageHandle {
+    /** Decoded width in pixels. */
+    width(): number;
+    /** Decoded height in pixels. */
+    height(): number;
+    /** Release the native handle; exactly once per resource. */
+    dispose(): void;
+}
+/** Injected source resolution and decode pipelines. */
+export interface AssetPipelines {
+    /** Resolve a static module handle to a canonical local URI. */
+    readonly resolve: (source: number) => Promise<string>;
+    /** Decode a canonical local URI into an image handle. */
+    readonly decode: (uri: string) => Promise<NativeImageHandle>;
+}
+/** Acquisition options for `acquire`. */
+export interface AcquireOptions {
+    /** Logical groups to load; an empty set resolves immediately. */
+    readonly groups: readonly string[];
+    /** Detach the caller; late results are ignored, never resurrected. */
+    readonly signal?: AbortSignal;
+    /** Monotonic progress in [0, 1], one update per completed logical asset. */
+    readonly onProgress?: (progress: number) => void;
+}
+export declare function createGameAssetStoreCore<TManifest extends AssetGroupMap>(manifest: TManifest, pipelines: AssetPipelines): {
+    readonly acquire: (options: AcquireOptions) => Promise<GameAssetLease<TManifest>>;
+    readonly dispose: () => void;
+    readonly isDisposed: () => boolean;
+};
+export type GameAssetStore = ReturnType<typeof createGameAssetStoreCore>;
+//# sourceMappingURL=createGameAssetStore.d.ts.map

package/lib/typescript/src/react/assets/createGameAssetStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGameAssetStore.d.ts","sourceRoot":"","sources":["../../../../../src/react/assets/createGameAssetStore.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACV,aAAa,EAEb,cAAc,EAOf,MAAM,uBAAoB,CAAC;AAI5B,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,KAAK,IAAI,MAAM,CAAC;IAChB,gCAAgC;IAChC,MAAM,IAAI,MAAM,CAAC;IACjB,4DAA4D;IAC5D,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtD,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC9D;AAED,yCAAyC;AACzC,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAmED,wBAAgB,wBAAwB,CAAC,SAAS,SAAS,aAAa,EACtE,QAAQ,EAAE,SAAS,EACnB,SAAS,EAAE,cAAc,GACxB;IACD,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;IAClF,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC;CACpC,CA+TA;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/lib/typescript/src/react/assets/decodeSkiaImage.d.ts

@@ -0,0 +1,12 @@
+import type { AssetGroupMap } from '../../assets/types.js';
+/**
+ * Create the explicit asset-store owner for a manifest using the default
+ * Expo/Skia pipelines. Callers dispose the lease then the store in
+ * `finally`.
+ */
+export declare function createGameAssetStore<TManifest extends AssetGroupMap>(manifest: TManifest): {
+    readonly acquire: (options: import("./createGameAssetStore.js").AcquireOptions) => Promise<import("../../index.js").GameAssetLease<TManifest>>;
+    readonly dispose: () => void;
+    readonly isDisposed: () => boolean;
+};
+//# sourceMappingURL=decodeSkiaImage.d.ts.map

package/lib/typescript/src/react/assets/decodeSkiaImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeSkiaImage.d.ts","sourceRoot":"","sources":["../../../../../src/react/assets/decodeSkiaImage.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAoB,CAAC;AAiCxD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,SAAS,aAAa,EAClE,QAAQ,EAAE,SAAS;;;;EAOpB"}

package/lib/typescript/src/react/assets/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Asset store errors (T7.4).
+ *
+ * The store adds no error codes of its own: every failure is a structured
+ * `GameAssetError` with a stable code and field path.
+ */
+export { GameAssetError } from '../../assets/errors.js';
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/src/react/assets/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/react/assets/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAqB,CAAC"}

package/lib/typescript/src/react/assets/useGameAssets.d.ts

@@ -0,0 +1,35 @@
+import { GameAssetError } from '../../assets/errors.js';
+import type { AssetGroupMap, GameAssetLease, LoadedAssets } from '../../assets/types.js';
+import type { AcquireOptions } from './createGameAssetStore.js';
+/** The store surface the hook needs, kept generic over the manifest. */
+export interface HookStore<TManifest extends AssetGroupMap> {
+    readonly acquire: (options: AcquireOptions) => Promise<GameAssetLease<TManifest>>;
+    readonly dispose: () => void;
+}
+/** The discriminated loading state machine. Every state carries the
+ * normalized request key (RF7) so a rendered request that differs from the
+ * state's request can never expose a stale lease. */
+export type GameAssetsState<TManifest extends AssetGroupMap> = {
+    readonly status: 'loading';
+    readonly progress: number;
+    readonly retry: () => void;
+    readonly requestKey: string;
+} | {
+    readonly status: 'error';
+    readonly error: GameAssetError;
+    readonly retry: () => void;
+    readonly requestKey: string;
+} | {
+    readonly status: 'ready';
+    readonly assets: LoadedAssets<TManifest>;
+    readonly requestKey: string;
+};
+/** Deduplicate and sort groups so equivalent reordered/duplicated arrays
+ * map to one key and one acquisition (R6). */
+export declare function dedupeGroups(groups: readonly string[]): readonly string[];
+/** Order-independent group key: equivalent arrays map to one key. */
+export declare function stableGroupsKey(groups: readonly string[]): string;
+export declare function useGameAssets<TManifest extends AssetGroupMap>(manifest: TManifest, options: {
+    readonly groups: readonly (Extract<keyof TManifest, string>)[];
+}, storeFactory?: (manifest: TManifest) => HookStore<TManifest>): GameAssetsState<TManifest>;
+//# sourceMappingURL=useGameAssets.d.ts.map

package/lib/typescript/src/react/assets/useGameAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGameAssets.d.ts","sourceRoot":"","sources":["../../../../../src/react/assets/useGameAssets.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAAwB,CAAC;AAE7D,wEAAwE;AACxE,MAAM,WAAW,SAAS,CAAC,SAAS,SAAS,aAAa;IACxD,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;IAClF,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAiBD;;qDAEqD;AACrD,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,aAAa,IACvD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAClH;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACrH;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAExG;8CAC8C;AAC9C,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAEzE;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEjE;AAED,wBAAgB,aAAa,CAAC,SAAS,SAAS,aAAa,EAC3D,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,MAAM,SAAS,EAAE,MAAM,CAAC,CAAC,EAAE,CAAA;CAAE,EAC3E,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,SAAS,CAAC,SAAS,CAAC,GAC3D,eAAe,CAAC,SAAS,CAAC,CAoG5B"}

package/lib/typescript/src/react/bindAppLifecycle.d.ts

@@ -0,0 +1,32 @@
+import type { GameSessionStatus } from '../core/session/types.js';
+/** Minimal AppState-like source used to keep this seam platform-neutral. */
+export interface AppLifecycleSource {
+    /** The current app state, read synchronously at bind time. */
+    readonly currentState: string | null | undefined;
+    addEventListener(state: 'change', listener: (next: string) => void): {
+        remove(): void;
+    };
+}
+/** Session operations the lifecycle binding may drive. */
+export interface AppLifecycleSession {
+    /** Read the current session status. */
+    getStatus(): GameSessionStatus;
+    /** Pause simulation and discard suspended wall time. */
+    pause(): void;
+    /** Resume a paused session. */
+    resume(): void;
+}
+/**
+ * Pause a running session when the app becomes inactive or backgrounded and
+ * resume it on foreground only when this binding performed that pause.
+ *
+ * Platform-neutral: the React adapter supplies React Native's `AppState`.
+ * The initial `currentState` is synchronized at bind time, so an app that
+ * mounts while already backgrounded never leaves a session running
+ * invisibly. Manual pauses that precede backgrounding are never claimed, and
+ * a session that another actor resumed (or disposed) meanwhile is not
+ * resumed again. Cleanup clears the binding flag so a late foreground event
+ * cannot restart an unmounted game.
+ */
+export declare function bindAppLifecycle(source: AppLifecycleSource, session: AppLifecycleSession): () => void;
+//# sourceMappingURL=bindAppLifecycle.d.ts.map

package/lib/typescript/src/react/bindAppLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindAppLifecycle.d.ts","sourceRoot":"","sources":["../../../../src/react/bindAppLifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAAuB,CAAC;AAE/D,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,gBAAgB,CACd,KAAK,EAAE,QAAQ,EACf,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/B;QAAE,MAAM,IAAI,IAAI,CAAA;KAAE,CAAC;CACvB;AAED,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IAClC,uCAAuC;IACvC,SAAS,IAAI,iBAAiB,CAAC;IAC/B,wDAAwD;IACxD,KAAK,IAAI,IAAI,CAAC;IACd,+BAA+B;IAC/B,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,mBAAmB,GAC3B,MAAM,IAAI,CAyCZ"}

package/lib/typescript/src/react/bindGameSession.d.ts

@@ -0,0 +1,14 @@
+import type { InputMap, SceneMap } from '../definition/types.js';
+import type { CommitFrame, GameSession } from '../core/session/types.js';
+/**
+ * Bind a live session to an imperative presentation sink.
+ *
+ * This platform-neutral lifecycle seam keeps the React adapter testable
+ * without loading React Native or Skia in the headless test runner. The sink
+ * receives commit frames only (simulation frequency), never per-display
+ * frames, and a stale write can never replace a newer commit: revisions are
+ * strictly increasing per session, and the initial envelope is presented
+ * through the same guard.
+ */
+export declare function bindGameSession<TScenes extends SceneMap, TInput extends InputMap>(game: GameSession<TScenes, TInput>, present: (frame: CommitFrame<TScenes>) => void): () => void;
+//# sourceMappingURL=bindGameSession.d.ts.map

package/lib/typescript/src/react/bindGameSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindGameSession.d.ts","sourceRoot":"","sources":["../../../../src/react/bindGameSession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,wBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,0BAAuB,CAAC;AAEtE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ,EAC/E,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EAClC,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,GAC7C,MAAM,IAAI,CAwBZ"}