@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiTokenPersistentStatus.d.ts

@@ -0,0 +1,101 @@
+import type { Container } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+declare const BATTLE_PERSISTENT_STATUSES: readonly ["burning", "poisoned", "bleeding"];
+export type TokenPersistentStatus = (typeof BATTLE_PERSISTENT_STATUSES)[number];
+export interface TokenPersistentStatusConstructors {
+    Container: typeof import('pixi.js').Container;
+    Sprite: typeof import('pixi.js').Sprite;
+    Graphics?: typeof import('pixi.js').Graphics;
+    Mesh?: typeof import('pixi.js').Mesh;
+    MeshGeometry?: typeof import('pixi.js').MeshGeometry;
+    Shader?: typeof import('pixi.js').Shader;
+    UniformGroup?: typeof import('pixi.js').UniformGroup;
+}
+export interface TokenPersistentStatusInput {
+    flags: Readonly<Partial<Record<TokenPersistentStatus, boolean>>>;
+    suppressed?: boolean;
+    diameter: number;
+    reducedMotion: boolean;
+    animate?: boolean;
+    director?: PixiAnimationDirector;
+}
+export declare const TOKEN_BURNING_FRAGMENT = "\nprecision highp float;\nvarying vec2 vUV;\nvarying float vWorldAlpha;\nuniform float uTime;\nuniform float uSeed;\nuniform float uAlpha;\nuniform vec3 uPrimary;\nuniform vec3 uSecondary;\nuniform vec4 uTokenClip;\nfloat hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7)) + uSeed * 71.0) * 43758.5453); }\nfloat noise(vec2 p) {\n  vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash(i), hash(i + vec2(1.0, 0.0)), f.x),\n             mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0)), f.x), f.y);\n}\nfloat fbm(vec2 p) { return noise(p) * 0.62 + noise(p * 2.03) * 0.27 + noise(p * 4.11) * 0.11; }\nfloat quadEdge(vec2 uv) {\n  return smoothstep(0.0, 0.09, uv.x) * smoothstep(0.0, 0.09, 1.0 - uv.x)\n       * smoothstep(0.0, 0.09, uv.y) * smoothstep(0.0, 0.09, 1.0 - uv.y);\n}\nfloat tokenAperture(vec2 uv) {\n  vec2 tokenLocal = (uv * 2.0 - 1.0) * uTokenClip.xy + uTokenClip.zw;\n  return 1.0 - smoothstep(0.94, 1.0, length(tokenLocal));\n}\n\nvoid main(void) {\n  vec2 p = vec2(vUV.x * 2.0 - 1.0, 1.0 - vUV.y);\n  float flow = fbm(vec2(p.x * 3.4, p.y * 4.5 - uTime * 1.8));\n  float tongue = p.x + (flow - 0.5) * (0.23 + p.y * 0.46);\n  float width = mix(0.78, 0.035, p.y);\n  float body = 1.0 - smoothstep(width * 0.4, width + 0.1, abs(tongue));\n  float tip = 1.0 - smoothstep(0.38 + flow * 0.38, 0.96, p.y);\n  float alpha = body * tip * quadEdge(vUV) * tokenAperture(vUV) * uAlpha * vWorldAlpha;\n  vec3 color = mix(uPrimary, uSecondary, body * (1.0 - p.y) * 0.75);\n  gl_FragColor = vec4(color * alpha, alpha);\n}\n";
+export declare const TOKEN_POISONED_FRAGMENT = "\nprecision highp float;\nvarying vec2 vUV;\nvarying float vWorldAlpha;\nuniform float uTime;\nuniform float uSeed;\nuniform float uAlpha;\nuniform vec3 uPrimary;\nuniform vec3 uSecondary;\nuniform vec4 uTokenClip;\nfloat hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7)) + uSeed * 71.0) * 43758.5453); }\nfloat noise(vec2 p) {\n  vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash(i), hash(i + vec2(1.0, 0.0)), f.x),\n             mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0)), f.x), f.y);\n}\nfloat fbm(vec2 p) { return noise(p) * 0.62 + noise(p * 2.03) * 0.27 + noise(p * 4.11) * 0.11; }\nfloat quadEdge(vec2 uv) {\n  return smoothstep(0.0, 0.09, uv.x) * smoothstep(0.0, 0.09, 1.0 - uv.x)\n       * smoothstep(0.0, 0.09, uv.y) * smoothstep(0.0, 0.09, 1.0 - uv.y);\n}\nfloat tokenAperture(vec2 uv) {\n  vec2 tokenLocal = (uv * 2.0 - 1.0) * uTokenClip.xy + uTokenClip.zw;\n  return 1.0 - smoothstep(0.94, 1.0, length(tokenLocal));\n}\n\nvoid main(void) {\n  vec2 p = vUV * 2.0 - 1.0;\n  float drift = fbm(p * 2.3 + vec2(uTime * 0.32, -uTime * 0.22));\n  float wisps = fbm(p * 4.0 - vec2(uTime * 0.18, uTime * 0.36));\n  float cloud = smoothstep(0.23, 0.72, drift * 0.7 + wisps * 0.3);\n  float envelope = 1.0 - smoothstep(0.3, 1.0, length(p * vec2(0.9, 0.8)));\n  float alpha = cloud * envelope * quadEdge(vUV) * tokenAperture(vUV) * uAlpha * vWorldAlpha;\n  vec3 color = mix(uPrimary, uSecondary, wisps * 0.6);\n  gl_FragColor = vec4(color * alpha, alpha);\n}\n";
+export interface NumericSettings {
+    iconXRatio: number;
+    iconYRatio: number;
+    effectXRatio: number;
+    effectYRatio: number;
+    effectWidthRatio: number;
+    effectHeightRatio: number;
+    effectAlpha: number;
+    particleSizeRatio: number;
+    particleSpreadRatio: number;
+    particleTravelRatio: number;
+    particleAlpha: number;
+    periodMs: number;
+    speed: number;
+    iconPulseRatio: number;
+    particlePeriodMs: number;
+}
+export interface StatusSettings extends NumericSettings {
+    color: string;
+    secondaryColor: string;
+    iconTint: string;
+}
+/** Retained local status surfaces. The owning World supplies the only animation clock. */
+export declare class PixiTokenPersistentStatus {
+    private readonly constructors;
+    private readonly assets;
+    private readonly ports;
+    private tuning?;
+    private readonly requestRender?;
+    private readonly onActivityChange?;
+    readonly root: Container;
+    private readonly nodes;
+    private readonly scope;
+    private readonly phase;
+    private input;
+    private elapsedMs;
+    private destroyed;
+    private iconLayer;
+    private iconMask;
+    private iconMaskDiameter;
+    private iconSizeRatio;
+    private iconAlpha;
+    private reducedMotionAlpha;
+    constructor(id: string, constructors: TokenPersistentStatusConstructors, assets: Pick<PixiAssetManager, 'loadTexture' | 'releaseScope'>, ports: {
+        style: Record<TokenPersistentStatus, StatusSettings> & {
+            persistent: {
+                iconSizeRatio: number;
+                iconAlpha: number;
+                reducedMotionAlpha: number;
+                fadeInDurationMs: number;
+                fadeOutDurationMs: number;
+            };
+        };
+        iconUrl: (status: TokenPersistentStatus) => string;
+        logger: RuntimeLogger;
+    }, tuning?: SessionTuningResolver | undefined, requestRender?: (() => void) | undefined, onActivityChange?: (() => void) | undefined);
+    sync(input: TokenPersistentStatusInput): void;
+    hasAmbientMotion(): boolean;
+    update(elapsedMs: number): void;
+    updateTuning(tuning: SessionTuningResolver): void;
+    destroy(): void;
+    private createStatus;
+    private createMesh;
+    private loadSprites;
+    private setVisibility;
+    private layout;
+    private ensureIconMask;
+    private ensureIconLayer;
+    private syncIconPresentation;
+    private readCommonSettings;
+    private readSettings;
+    private number;
+    private color;
+}
+export {};

package/dist/PixiTokenWorld.d.ts

@@ -0,0 +1,170 @@
+import type { Container, TextStyleOptions } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { TokenAvatarCrop } from './PixiMapWorldUtils.js';
+import type { BattleViewportGridLayout } from './PixiSessionLayout.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { SessionTuningResolver } from '@bardway/trpg-media/tuning';
+export interface TokenWorldInput {
+    id: string;
+    gridPosition: {
+        col: number;
+        row: number;
+    };
+    label?: string;
+    avatarUrl?: string;
+    avatarCrop?: TokenAvatarCrop;
+    avatarOverrideUrl?: string;
+    bodyColor: string;
+}
+export interface TokenFocusTransitionOptions {
+    director: PixiAnimationDirector;
+    signal: AbortSignal;
+    duration: number;
+}
+export interface TokenWorldDependencies {
+    Container: typeof import('pixi.js').Container;
+    Graphics: typeof import('pixi.js').Graphics;
+    Sprite: typeof import('pixi.js').Sprite;
+    Text?: typeof import('pixi.js').Text;
+    BlurFilter?: typeof import('pixi.js').BlurFilter;
+    ColorMatrixFilter?: typeof import('pixi.js').ColorMatrixFilter;
+    Rectangle?: typeof import('pixi.js').Rectangle;
+    director: PixiAnimationDirector;
+    requestRender(): void;
+    logger: RuntimeLogger;
+    maskColor: string;
+    exitSmokeColor: string;
+    vignetteColor: string;
+    labelStyle: TextStyleOptions;
+    updateDecoration?(node: Container, label: Container, input: TokenWorldInput): void;
+}
+/** Retained neutral world extracted from PixiBattleWorld's node, avatar, motion, focus and lease mechanisms. */
+export declare class PixiTokenWorld {
+    private readonly scene;
+    private readonly assets;
+    private readonly dependencies;
+    private readonly tuning?;
+    private readonly tokenNodes;
+    private readonly tokenAvatarLayers;
+    private readonly tokenLabelNodes;
+    private readonly tokenBodies;
+    private readonly tokenNames;
+    private readonly tokenAvatarKeys;
+    private readonly tokenAvatarVersions;
+    private readonly tokenAvatarMaskSizes;
+    private readonly tokenAvatarNodes;
+    private readonly tokenAvatarMasks;
+    private readonly tokenFallbackNodes;
+    private readonly presentationHolds;
+    private readonly pendingDeathTransitions;
+    private readonly settledActionPositions;
+    private readonly lifecycle;
+    private readonly poses;
+    private readonly ownedMotionBlurFilters;
+    private readonly availableMotionBlurFilters;
+    private layout;
+    private activeResourceScope;
+    private owner;
+    private generation;
+    private readonly focusVignette;
+    private focusedTokenIds;
+    private unfocusedTokenAlpha;
+    private labelsSuppressed;
+    private reducedMotion;
+    private destroyed;
+    private lifetime;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, dependencies: TokenWorldDependencies, tuning?: SessionTuningResolver | undefined);
+    sync(input: {
+        owner: string;
+        revision: number;
+        layout: BattleViewportGridLayout;
+        tokens: readonly TokenWorldInput[];
+        hydrate?: boolean;
+        animateMoves?: boolean;
+    }): void;
+    gridToPoint(position: {
+        col: number;
+        row: number;
+    }): {
+        x: number;
+        y: number;
+    } | null;
+    setReducedMotion(value: boolean): void;
+    isReducedMotionEnabled(): boolean;
+    reset(): void;
+    destroy(): void;
+    private destroyTokenNode;
+    private resolveTuningNumber;
+    playTokenMotion(tokenId: string, from: {
+        col: number;
+        row: number;
+    }, to: {
+        col: number;
+        row: number;
+    }, director: PixiAnimationDirector, signal: AbortSignal, options?: {
+        duration?: number;
+        motionBlurStrength?: number;
+        settleAtDestination?: boolean;
+        startFromCurrent?: boolean;
+        holdPresentation?: boolean;
+        ease?: string;
+        rampMotionBlur?: boolean;
+        onProgress?: (progress: number, point: {
+            x: number;
+            y: number;
+        }) => void;
+    }): Promise<void>;
+    playTokenNudge(tokenId: string, offset: {
+        x: number;
+        y: number;
+    }, director: PixiAnimationDirector, signal: AbortSignal, durations?: {
+        out?: number;
+        hold?: number;
+        back?: number;
+        motionBlurStrength?: number;
+    }): Promise<void>;
+    playTokenDodgeExchange(attackerId: string, targetId: string, attackerOffset: {
+        x: number;
+        y: number;
+    }, targetOffset: {
+        x: number;
+        y: number;
+    }, director: PixiAnimationDirector, signal: AbortSignal, options?: {
+        attackerBlurStrength?: number;
+    }): Promise<void>;
+    playCoverTransition(tokenId: string, texture: import('pixi.js').Texture, director: PixiAnimationDirector, signal: AbortSignal, options: {
+        coverHold: number;
+        entryShake: number;
+        grayDuration: number;
+        skullScale: number;
+        entryScale: number;
+    }): Promise<void>;
+    getPresentationNode(tokenId: string): Container | null;
+    getPresentationLabelNode(tokenId: string): Container | null;
+    beginTokenPresentation(tokenId: string): void;
+    holdTokenPresentation(tokenId: string): () => void;
+    finishTokenPresentation(tokenId: string): void;
+    setFocusTokens(tokenIds: readonly string[], transition?: TokenFocusTransitionOptions): Promise<void>;
+    clearFocusTokens(transition?: TokenFocusTransitionOptions): Promise<void>;
+    getCellSize(): {
+        width: number;
+        height: number;
+    } | null;
+    private resolveFocusedAlpha;
+    private acquireMotionBlur;
+    private releaseMotionBlur;
+    private createTokenNode;
+    private playTokenEnter;
+    private playTokenExit;
+    private playSnapshotMovement;
+    private finishLifecyclePose;
+    private ensureTokenAvatarLayer;
+    private syncTokenAvatar;
+    private resizeTokenAvatar;
+    private removeTokenAvatar;
+    private getCellCenter;
+    private reconcilePresentationNode;
+    private beginMotionLease;
+}

package/dist/PixiTypography.d.ts

@@ -0,0 +1,96 @@
+import type { PixiStageTheme } from './PixiStageTheme.js';
+export declare const createPixiTypography: (pixiStageTheme: PixiStageTheme, fonts: {
+    body: string;
+    data: string;
+    display: string;
+}) => {
+    readonly displayTitle: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 48;
+        readonly fontWeight: "700";
+    };
+    readonly sceneTitle: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 36;
+        readonly fontWeight: "700";
+    };
+    readonly sectionTitle: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 30;
+        readonly fontWeight: "700";
+    };
+    readonly hudPrimary: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 20;
+        readonly fontWeight: "700";
+        readonly letterSpacing: 3;
+    };
+    readonly battleRound: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 29;
+        readonly fontWeight: "700";
+        readonly letterSpacing: 0;
+    };
+    readonly battleOrder: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 30;
+        readonly fontWeight: "700";
+        readonly letterSpacing: 0;
+    };
+    readonly battleToken: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 29;
+        readonly fontWeight: "700";
+        readonly letterSpacing: 0;
+    };
+    readonly hudSecondary: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 24;
+        readonly fontWeight: "600";
+    };
+    readonly caption: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 20;
+        readonly fontWeight: "500";
+    };
+    readonly data: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 22;
+        readonly fontWeight: "600";
+    };
+    readonly damage: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 40;
+        readonly fontWeight: "700";
+    };
+    readonly resourceDelta: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 28;
+        readonly fontWeight: "700";
+    };
+    readonly modalTitle: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 48;
+        readonly fontWeight: "700";
+    };
+    readonly clueTitle: {
+        readonly fill: string;
+        readonly fontFamily: string;
+        readonly fontSize: 30;
+        readonly fontWeight: "700";
+    };
+};
+export type PixiTypographyToken = keyof ReturnType<typeof createPixiTypography>;

package/dist/PixiVideoRuntime.d.ts

@@ -0,0 +1,61 @@
+import type { Texture, Ticker } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAssetManager, PixiAssetScope } from './PixiAssetManager.js';
+export interface PixiVideoBinding {
+    readonly texture: Texture;
+    activate(restart?: boolean): Promise<boolean>;
+    playOnce(): Promise<boolean>;
+    deactivate(reset?: boolean): void;
+    release(): void;
+}
+export interface PixiVideoRuntimeDiagnostics {
+    bindings: number;
+    activeBindings: number;
+    textureUpdates: number;
+}
+export declare class PixiVideoRuntime {
+    private readonly ticker;
+    private readonly activity;
+    private readonly assets;
+    private readonly requestRender;
+    private readonly logger;
+    private readonly bindings;
+    private releaseActivity;
+    private elapsedSinceUpdateMs;
+    private textureUpdates;
+    private paused;
+    private reducedMotion;
+    private contextLost;
+    private destroyed;
+    private bindingSequence;
+    constructor(ticker: Ticker, activity: PixiAnimationActivity, assets: PixiAssetManager, requestRender: () => void, logger: RuntimeLogger);
+    loadBinding(input: {
+        alias: string;
+        videoUrl: string;
+        scope: PixiAssetScope | string;
+        signal?: AbortSignal;
+        muted?: boolean;
+        onPlaybackFailure?: () => void;
+    }): Promise<PixiVideoBinding>;
+    setPaused(paused: boolean): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    handleContextLost(): void;
+    handleContextRestored(): void;
+    reset(): void;
+    diagnostics(): PixiVideoRuntimeDiagnostics;
+    destroy(): void;
+    private readonly update;
+    private playOnce;
+    private finishPlayback;
+    private activate;
+    private play;
+    private deactivate;
+    private release;
+    private interruptPlayback;
+    private releaseVideoTexture;
+    private seekToStart;
+    private failPlayback;
+    private resumeActiveBindings;
+    private syncActivity;
+}

package/dist/PixiViewportController.d.ts

@@ -0,0 +1,25 @@
+import type { Application, Container } from 'pixi.js';
+export interface PixiViewport {
+    width: number;
+    height: number;
+}
+export declare const resolvePixiStageViewport: ({ width, height }: PixiViewport, stage?: PixiViewport) => {
+    scale: number;
+    x: number;
+    y: number;
+};
+export declare class PixiViewportController {
+    private readonly app;
+    private readonly root;
+    private readonly onResize?;
+    private readonly stage;
+    private readonly observer;
+    private pendingViewport;
+    private resizeQueued;
+    private destroyed;
+    constructor(app: Application, root: Container, host: HTMLElement, onResize?: ((viewport: PixiViewport) => void) | undefined, stage?: PixiViewport);
+    resize(viewport: PixiViewport): void;
+    destroy(): void;
+    private queueResize;
+    private isValidViewport;
+}

package/dist/ResultEffectTuning.d.ts

@@ -0,0 +1,57 @@
+export type VisualResultEffect = 'noiseEdge' | 'lightEdge' | 'pulseEdge' | 'radialBurst' | 'imageBurst';
+export interface ResultEffectTuning {
+    readonly layout: {
+        readonly fallbackCenterX: number;
+        readonly fallbackCenterY: number;
+        readonly fallbackSpacingPx: number;
+        readonly imageBurst: {
+            readonly diameterPx: number;
+            readonly offsetX: number;
+            readonly offsetY: number;
+        };
+    };
+    readonly visual: {
+        readonly edge: Readonly<Record<'noiseEdge' | 'lightEdge' | 'pulseEdge', {
+            readonly color: string;
+            readonly intensity: number;
+            readonly edgeDepthPx: number;
+            readonly softnessPx: number;
+        }>>;
+        readonly noiseEdge: {
+            readonly noiseScale: number;
+            readonly distortion: number;
+        };
+        readonly pulseEdge: {
+            readonly breathAmplitude: number;
+        };
+        readonly imageBurst: {
+            readonly peakAlpha: number;
+        };
+        readonly radialBurst: {
+            readonly color: string;
+            readonly coreRadiusPx: number;
+            readonly haloRadiusPx: number;
+            readonly rayCount: number;
+            readonly intensity: number;
+        };
+    };
+    readonly motion: {
+        readonly edge: Readonly<Record<'noiseEdge' | 'lightEdge' | 'pulseEdge', {
+            readonly enterMs: number;
+            readonly holdMs: number;
+            readonly exitMs: number;
+            readonly driftSpeed: number;
+        }>>;
+        readonly imageBurst: {
+            readonly revealMs: number;
+            readonly expandMs: number;
+            readonly endScale: number;
+        };
+        readonly radialBurst: {
+            readonly enterMs: number;
+            readonly holdMs: number;
+            readonly exitMs: number;
+            readonly rotationSpeed: number;
+        };
+    };
+}

package/dist/RetainedStageSurface.d.ts

@@ -0,0 +1,50 @@
+import type { Container } from 'pixi.js';
+import type { DisplayEntity, DisplaySnapshot, PresentationEvent } from '@bardway/trpg-display';
+import type { PixiDisplayContext, PixiDisplaySurface } from './PixiDisplayRenderer.js';
+import type { PixiStageTheme } from './PixiStageTheme.js';
+export interface RetainedStageSurfaceOptions {
+    readonly theme: PixiStageTheme;
+    readonly fonts: {
+        body: string;
+        data: string;
+        display: string;
+    };
+    readonly resourceColor: (entity: DisplayEntity, resourceId: string) => string;
+    readonly play: (event: PresentationEvent, context: PixiDisplayContext, signal: AbortSignal) => Promise<void>;
+    readonly layout?: {
+        cardWidth: number;
+        cardGap: number;
+        rosterHeight: number;
+        avatarSize: number;
+        resourceHeight: number;
+    };
+}
+/**
+ * Neutral composition of the extracted retained portrait/meter/media primitives.
+ * Scene kind, titles, resources, statuses and action ordering are supplied by the host.
+ * Product Prelude/Story/Battle/Ending artwork and rule conditions stay outside the package.
+ */
+export declare class RetainedStageSurface implements PixiDisplaySurface {
+    private readonly context;
+    private readonly options;
+    readonly node: Container;
+    private readonly title;
+    private readonly image;
+    private readonly cards;
+    private readonly typography;
+    private readonly layout;
+    private generation;
+    private scope;
+    private video;
+    private reducedMotion;
+    private destroyed;
+    constructor(context: PixiDisplayContext, options: RetainedStageSurfaceOptions);
+    applySnapshot(snapshot: DisplaySnapshot, signal: AbortSignal): Promise<void>;
+    play(event: PresentationEvent, signal: AbortSignal): Promise<void>;
+    setReducedMotion(reduced: boolean): void;
+    reset(): void;
+    destroy(): void;
+    private createCard;
+    private syncCard;
+    private removeCard;
+}

package/dist/SessionFieldEffectRuntime.d.ts

@@ -0,0 +1,45 @@
+/** Neutral input replacing the source's product snapshot/story/battle wrappers. */
+export interface FieldEffectState<TEffect extends string, TProfile extends string> {
+    owner: string;
+    profile: TProfile;
+    effectId: TEffect | null;
+    hydrate?: boolean;
+}
+export interface FieldEffectSurface<TEffect extends string, TProfile extends string> {
+    setProfile(profile: TProfile): void;
+    replace(effect: TEffect | null, signal: AbortSignal, onCommitted: () => void): Promise<void>;
+    hydrate(effect: TEffect | null): void;
+    setPaused(paused: boolean): void;
+    setSuspended(suspended: boolean): void;
+    reset(): void;
+    destroy(): void;
+}
+export interface FieldEffectAudio<TEffect extends string> {
+    play(effect: TEffect): void;
+    pause(): void;
+    resume(effect: TEffect): void;
+    stop(): void;
+}
+/** Retains source owner/request isolation, silent hydration and audio suspension. */
+export declare class SessionFieldEffectRuntime<TEffect extends string, TProfile extends string> {
+    private readonly surface;
+    private readonly getAudio;
+    private readonly onChanged?;
+    private desired;
+    private mounted;
+    private controller;
+    private version;
+    private paused;
+    private suspended;
+    private audioEffect;
+    private destroyed;
+    constructor(surface: FieldEffectSurface<TEffect, TProfile>, getAudio: () => FieldEffectAudio<TEffect> | null, onChanged?: ((effect: TEffect | null) => void) | undefined);
+    sync(state: FieldEffectState<TEffect, TProfile>, externalSignal?: AbortSignal): Promise<void>;
+    getEffectId(): TEffect | null;
+    setPaused(paused: boolean): void;
+    setGlobalSuspended(suspended: boolean): void;
+    syncAudio(): void;
+    reset(): void;
+    destroy(): void;
+    private syncSuspension;
+}

package/dist/SessionSceneHistory.d.ts

@@ -0,0 +1,10 @@
+/** Retains the last eligible scene; the host chooses transient scene kinds and the initial scene. */
+export declare class SessionSceneHistory<TScene extends string> {
+    private readonly initial;
+    private readonly transientScenes;
+    private previous;
+    constructor(initial: TScene, transientScenes: ReadonlySet<TScene>);
+    record(scene: TScene): void;
+    getPreviousScene(): TScene;
+    reset(): void;
+}

package/dist/SessionSceneRegistry.d.ts

@@ -0,0 +1,31 @@
+type SessionDisplayScene = string;
+export type SceneDefinitionTarget = {
+    kind: 'visualVariant';
+    semanticScene: SessionDisplayScene;
+    visualVariant: string;
+} | {
+    kind: 'semanticSceneDraft';
+    requestedSceneId: string;
+};
+export interface SessionSceneDescriptor {
+    id: string;
+    semanticScene: SessionDisplayScene;
+    structure: 'locked';
+    editorSlots: readonly string[];
+    requiredBindings: readonly string[];
+    transitions: readonly string[];
+}
+export interface SessionVisualVariantDescriptor {
+    id: string;
+    target: Extract<SceneDefinitionTarget, {
+        kind: 'visualVariant';
+    }>;
+    source: 'core' | 'composed';
+    requiredBindings: readonly string[];
+}
+export declare const createSessionSceneRegistry: (scenes: readonly SessionSceneDescriptor[]) => {
+    all: () => readonly SessionSceneDescriptor[];
+    get: (scene: SessionDisplayScene) => SessionSceneDescriptor;
+    canEnterProductionFlow: (target: SceneDefinitionTarget) => boolean;
+};
+export {};