@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiStorySurface.d.ts

@@ -0,0 +1,285 @@
+export interface StoryMediaContent {
+    key: string;
+    kind: 'portrait' | 'card' | 'image';
+    sourceId: string;
+    title: string;
+    imageUrl: string;
+    videoUrl?: string;
+}
+export interface GalleryEntry {
+    id: string;
+    kind: 'portrait' | 'card';
+    sourceType?: 'portrait' | 'card';
+    sourceId?: string;
+    title: string;
+    imageUrl: string;
+    thumbUrl?: string;
+    enterRotationDeg: number;
+    stackRotationDeg: number;
+}
+export interface GalleryDisplayState {
+    current: GalleryEntry | null;
+    phase: 'enter' | 'display' | 'exit' | 'idle';
+    stackedImages: GalleryEntry[];
+}
+export interface StorySurfaceLayout {
+    media: PixiLayoutRect;
+    leftPanel: PixiLayoutRect;
+    rightPanel: PixiLayoutRect;
+    revealCard: PixiLayoutRect;
+    thumbnailGrid: {
+        capacity: number;
+        padding: number;
+        gapX: number;
+        leftScale: number;
+        rightScale: number;
+        columns: number;
+        rows: number;
+        aspectRatio: number;
+    };
+}
+export interface StorySurfacePorts {
+    logger: RuntimeLogger;
+    stage: {
+        width: number;
+        height: number;
+    };
+    layout: StorySurfaceLayout;
+    displayDurationMs: (scene: string) => number;
+    colors: {
+        mask: string;
+        transition: string;
+    };
+    photo: {
+        thumbnailInset: number;
+        revealFramePadding: number;
+        shadow: string;
+        shadowWarm: string;
+        paper: string;
+        paperEdge: string;
+        thumbnailBorder: string;
+        thumbnailBorderWidth: number;
+        thumbnailBorderAlpha: number;
+        revealBorderWidth: number;
+    };
+    media: {
+        backdrop: {
+            blurStrength: number;
+            alpha: number;
+        };
+        frame: {
+            shadowOffsetFar: {
+                x: number;
+                y: number;
+            };
+            shadowOffsetNear: {
+                x: number;
+                y: number;
+            };
+            borderColor: string;
+            borderWidth: number;
+            borderAlpha: number;
+        };
+    };
+}
+import type { PreparedStoryContentTransition } from './story/StoryContentSurface.js';
+import type { BlurFilter, Container, Filter, Graphics, Rectangle, Sprite, Text, Texture } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import { type PixiLayoutRect } from './PixiSessionLayout.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+import type { PixiVideoRuntime } from './PixiVideoRuntime.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Container: typeof Container;
+    Filter?: typeof Filter;
+    Graphics: typeof Graphics;
+    Rectangle?: typeof Rectangle;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+}
+export interface PixiStoryPresentationContent {
+    readonly key: string;
+    readonly imageUrl: string;
+    readonly videoUrl?: string;
+    readonly kind?: StoryMediaContent['kind'];
+    readonly sourceId?: string;
+    readonly title?: string;
+}
+export type PixiStorySurfaceMode = 'story' | 'battle' | 'hidden';
+export interface PixiStoryPresentationTargets {
+    currentContent?: Container | null;
+    readonly contentRoot: Container;
+    readonly overlayRoot: Container;
+    readonly backdropSprite: Sprite;
+    readonly backdropBlur: BlurFilter;
+    readonly shadowBlur: BlurFilter;
+}
+export declare class PixiStorySurface {
+    private readonly scene;
+    private readonly assets;
+    private readonly constructors;
+    private readonly animation;
+    private readonly requestRender;
+    private readonly ports;
+    private tuning?;
+    private readonly mediaBreath?;
+    private readonly setStoryEntranceActive;
+    private readonly videoRuntime?;
+    private disposed;
+    private readonly resourceScope;
+    readonly node: Container;
+    private readonly mainVisualShakeLayer;
+    readonly mainImageAnchor: Container;
+    readonly mainImageOverlay: Container;
+    readonly leftPanelNode: Container;
+    readonly rightPanelNode: Container;
+    readonly mainBackdrop: Sprite;
+    private readonly mainBackdropMask;
+    private readonly mainBackdropBlur;
+    private readonly mainMediaShadow;
+    private readonly mainMediaShadowBlur;
+    private readonly mainMediaShadowFilterArea;
+    private readonly cardCutBackLayer;
+    private readonly cardCutFrontLayer;
+    private readonly cardCut;
+    private readonly mainImageContentLayer;
+    private readonly presentationTargets;
+    readonly leftPanelMask: Graphics;
+    readonly rightPanelMask: Graphics;
+    private readonly reveal;
+    private readonly revealShade;
+    private readonly revealCard;
+    private readonly revealShadow;
+    private readonly revealShadowBlur;
+    private readonly revealShadowFilterArea;
+    private readonly revealContent;
+    private readonly archiveMotionFilter;
+    private readonly archiveMotionFilterArea;
+    private readonly archiveMotionFrame;
+    private readonly revealFrame;
+    private readonly revealMask;
+    private readonly clueThumbnails;
+    private readonly peopleThumbnails;
+    private mainPhoto;
+    private pendingMainPhoto;
+    private mainImage;
+    private mainPosterTexture;
+    private mainPreparedTransition;
+    private revealPreparedTransition;
+    private mainImageContent;
+    private mainImageKey;
+    private mainImageReadyKey;
+    private mainImageLoadingKey;
+    private renderedImageRect;
+    private readonly mainImageReadyWaiters;
+    private revealImage;
+    private revealKind;
+    private revealKey;
+    private revealExitingKey;
+    private archiveHandoffComplete;
+    private lifecycleVersion;
+    private mainVersion;
+    private revealVersion;
+    private mainImageAbort;
+    private reducedMotion;
+    private revealAttempt;
+    private revealAbort;
+    private mode;
+    private readonly mediaBreathBindings;
+    private lastClueState;
+    private readonly publishedEntryWaiters;
+    private readonly reservedPublishedSources;
+    private readonly manualArchivedEntries;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, constructors: Constructors, animation: PixiAnimationDirector, requestRender: () => void, ports: StorySurfacePorts, tuning?: SessionTuningResolver | undefined, mediaBreath?: PixiMediaBreathRuntime | undefined, setStoryEntranceActive?: (active: boolean) => void, videoRuntime?: PixiVideoRuntime | undefined);
+    sync(content: StoryMediaContent | PixiStoryPresentationContent | string | null, clueState: GalleryDisplayState, mode: PixiStorySurfaceMode): void;
+    resetTransitionPose(): void;
+    setEarthquakeTransform(x: number, y: number, rotation: number, scale: number): void;
+    isPlayerShareReserved(sourceType: 'portrait' | 'card', sourceId: string): boolean;
+    preparePreludeStoryBase(content: StoryMediaContent | PixiStoryPresentationContent | string | null): void;
+    preparePreludeStoryHandoff(): void;
+    restorePreludeStoryTransition(visible: boolean): void;
+    getMainBackdropTargetAlpha(): number;
+    getRenderedImageRect(): PixiLayoutRect | null;
+    getPresentationTargets(): PixiStoryPresentationTargets;
+    prepareContentTransition(content: StoryMediaContent | PixiStoryPresentationContent, signal: AbortSignal): Promise<PreparedStoryContentTransition | null>;
+    private preparePublishedContentTransition;
+    setPresentationContent(content: StoryMediaContent | PixiStoryPresentationContent | string | null, options?: {
+        animate?: boolean;
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    primePresentationVideo(content: StoryMediaContent | PixiStoryPresentationContent, signal: AbortSignal): Promise<boolean>;
+    waitForMainImageReady(imageUrl: string | null, signal: AbortSignal): Promise<boolean>;
+    waitForPresentationContentReady(content: StoryMediaContent | PixiStoryPresentationContent | string | null, signal: AbortSignal | null): Promise<boolean>;
+    setReducedMotion(reducedMotion: boolean): void;
+    reset(): void;
+    destroy(): void;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    private syncMainImage;
+    private cancelMainImageTransition;
+    private cancelRevealTransition;
+    private commitMainImage;
+    private startMainPhotoVideoUpgrade;
+    private upgradeMainPhotoToVideo;
+    private ownsMainPhotoVideo;
+    private activateMainPhotoVideo;
+    private restoreMainPhotoPoster;
+    private settleMainImageReadyWaiters;
+    private syncRail;
+    private syncArchiveRails;
+    private hideReservedArchiveThumbnails;
+    private contentSourceKey;
+    private reservePublishedSource;
+    private releasePublishedSource;
+    private entrySourceKey;
+    private entryMatchesContent;
+    private findPublishedEntry;
+    private waitForPublishedEntry;
+    private settlePublishedEntryWaiters;
+    private resolveArchivedEntries;
+    private createThumbnailNode;
+    private syncThumbnailGeometry;
+    private syncThumbnailImage;
+    private invalidateThumbnailLoads;
+    private commitThumbnailTexture;
+    private applyThumbnailImageGeometry;
+    private playReveal;
+    private animateRevealCardEntrance;
+    private archiveReveal;
+    private applyArchiveMotionFrame;
+    private syncArchiveMotionFilterArea;
+    private resolveArchivePlacement;
+    private completeArchiveThumbnail;
+    private resolveRevealDuration;
+    private resolveArchiveDuration;
+    private resolveMainImageCutOptions;
+    private resolveMainImageRect;
+    private createMainPhotoNode;
+    private syncMainPhotoGeometry;
+    private normalizeMainPhotoNode;
+    private destroyMainPhotoNode;
+    private attachMediaBreath;
+    private destroyMediaSprite;
+    private syncMainBackdrop;
+    private syncMainImageGeometry;
+    private syncLayout;
+    private syncRevealCardGeometry;
+    private restoreRevealCardPose;
+    private resolveTuningNumber;
+}
+export interface StoryThumbnailGridLayout {
+    columns: number;
+    rows: number;
+    gapX: number;
+    gapY: number;
+    thumbnailWidth: number;
+    thumbnailHeight: number;
+    capacity: number;
+    rects: PixiLayoutRect[];
+}
+export type StoryThumbnailFlow = 'top-down-left-to-right' | 'top-down-right-to-left';
+export declare const resolveStoryThumbnailGrid: (panel: PixiLayoutRect, count: number, flow: StoryThumbnailFlow | undefined, itemScale: number | undefined, options: StorySurfaceLayout["thumbnailGrid"]) => StoryThumbnailGridLayout;
+export {};

package/dist/PixiStoryWorkspaceSurface.d.ts

@@ -0,0 +1,64 @@
+import type { BlurFilter, Container, Graphics, Rectangle, Sprite, Texture } from 'pixi.js';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { SessionDisplayCaseWorkspaceTextures } from './PixiSessionSkin.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Rectangle: typeof Rectangle;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+}
+/** Stable Story shell with retained side panels and legacy case-workspace tuning keys. */
+export declare class PixiStoryWorkspaceSurface {
+    private readonly constructors;
+    private readonly textures;
+    private readonly requestRender;
+    private readonly ports;
+    private tuning?;
+    readonly node: Container;
+    readonly leftPanelGroup: Container;
+    readonly rightPanelGroup: Container;
+    private readonly shellShadow;
+    private readonly shellShadowMask;
+    private readonly shellShadowBlur;
+    private readonly shell;
+    private readonly leftPanelShadow;
+    private readonly rightPanelShadow;
+    private readonly panelShadowBlur;
+    private readonly leftPanel;
+    private readonly rightPanel;
+    private storyCluePanel;
+    private storyPeoplePanel;
+    private transition;
+    constructor(scene: PixiSceneGraph, constructors: Constructors, textures: SessionDisplayCaseWorkspaceTextures, requestRender: () => void, ports: {
+        layout: {
+            shell: PixiLayoutRect;
+            leftPanelFrame: PixiLayoutRect;
+            rightPanelFrame: PixiLayoutRect;
+        };
+        hudTop: number;
+        shadowColor: string;
+        maskColor: string;
+        stage: {
+            width: number;
+            height: number;
+        };
+    }, tuning?: SessionTuningResolver | undefined);
+    attachStoryPanels(cluePanel: Container, clueMask: Graphics, peoplePanel: Container, peopleMask: Graphics): void;
+    sync(): void;
+    setVisible(visible: boolean): void;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    preparePreludeStoryBase(): void;
+    preparePreludeStoryHandoff(): void;
+    restorePreludeStoryTransition(visible: boolean): void;
+    destroy(): void;
+    private syncLayout;
+    private restoreStaticStoryPose;
+    getMotionNumber(key: string, fallback: number): number;
+    getMotionString(key: string, fallback: string): string;
+    private motionNumber;
+    private visualNumber;
+}
+export {};

package/dist/PixiSummaryBoardSurface.d.ts

@@ -0,0 +1,112 @@
+import type { Container, Graphics, Sprite, Text, Texture } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { TokenAvatarCrop } from './PixiMapWorldUtils.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+export interface SummaryBoardParticipant {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    avatarCrop?: TokenAvatarCrop;
+}
+export interface SummaryBoardRankingEntry extends SummaryBoardParticipant {
+    value: string;
+}
+export interface SummaryBoardData {
+    owner: string;
+    primaryValue: string;
+    secondaryValue: string;
+    ranking: readonly SummaryBoardRankingEntry[];
+    participants: readonly SummaryBoardParticipant[];
+}
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { TextStyleOptions } from 'pixi.js';
+import type { SessionTuningResolver } from '@bardway/trpg-media/tuning';
+interface Constructors {
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Sprite?: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+}
+interface LayoutRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SummaryBoardPorts {
+    scope: string;
+    logger: RuntimeLogger;
+    boardSize: {
+        width: number;
+        height: number;
+    };
+    rankCapacity: number;
+    participantCapacity: number;
+    participantColumns: number;
+    layout: {
+        board: LayoutRect;
+        primaryValue: LayoutRect;
+        secondaryValue: LayoutRect;
+        rankingArea: LayoutRect;
+        participantArea: LayoutRect;
+        rankingAvatarSize: number;
+        participantAvatarSize: number;
+        rankingRowGap: number;
+        participantRowGap: number;
+        statFontSize: number;
+        rankingNameFontSize: number;
+        rankingValueFontSize: number;
+        participantNameFontSize: number;
+    };
+    typography: {
+        damage: TextStyleOptions;
+        data: TextStyleOptions;
+        caption: TextStyleOptions;
+        sectionTitle: TextStyleOptions;
+    };
+    colors: {
+        panel: string;
+        border: string;
+        mask: string;
+        primaryValue: string;
+        secondaryValue: string;
+        primaryText: string;
+        secondaryText: string;
+        rankColors: readonly string[];
+        avatarFallback: string;
+        avatarBorder: string;
+        avatarGlyph: string;
+    };
+}
+export declare class PixiSummaryBoardSurface {
+    private readonly constructors;
+    private readonly ports;
+    private readonly assets?;
+    private readonly requestRender?;
+    readonly node: Container;
+    private readonly boardRoot;
+    private readonly primaryValue;
+    private readonly secondaryValue;
+    private readonly rankingRows;
+    private readonly participantRows;
+    private avatarScope;
+    private tuning;
+    constructor(scene: PixiSceneGraph, constructors: Constructors, ports: SummaryBoardPorts, assets?: PixiAssetManager | undefined, boardTexture?: Texture | null, tuning?: SessionTuningResolver, requestRender?: (() => void) | undefined);
+    sync(summary: SummaryBoardData): void;
+    updateTuning(tuning: SessionTuningResolver): void;
+    setVisible(visible: boolean): void;
+    destroy(): void;
+    private createRow;
+    private syncLayout;
+    private syncRankingLayout;
+    private syncParticipantLayout;
+    private syncRankingRow;
+    private syncParticipantRow;
+    private syncAvatar;
+    private resizeAvatar;
+    private drawAvatarPlaceholder;
+    private clearAvatar;
+    private resolveRankingAvatarSize;
+    private resolveParticipantAvatarSize;
+}
+export {};

package/dist/PixiSystemHudSurface.d.ts

@@ -0,0 +1,73 @@
+import type { Container, Graphics, Sprite, Texture, Ticker } from 'pixi.js';
+export type HudConnectionState = 'live' | 'offline' | 'connecting' | 'degraded';
+type SessionDisplayScene = string;
+import type { DisplayAudioState } from '@bardway/trpg-media';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+export interface SystemHudPorts {
+    layout: {
+        iconSize: number;
+        gap: number;
+        padding: number;
+    };
+    rectForScene(scene: string): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    colors: {
+        panel: string;
+        border: string;
+        text: string;
+        live: string;
+        offline: string;
+        connecting: string;
+    };
+}
+export interface SystemHudTextures {
+    networkBars?: Texture | null;
+    speaker?: Texture | null;
+    speakerOff?: Texture | null;
+}
+interface PixiSystemHudConstructors {
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+}
+export interface PixiSystemHudState {
+    scene: SessionDisplayScene;
+    connectionState: HudConnectionState;
+    audioState: DisplayAudioState;
+    onEnableAudio: () => void;
+}
+export declare class PixiSystemHudSurface {
+    private readonly ticker;
+    private readonly activity;
+    private readonly requestRender;
+    private readonly ports;
+    private readonly node;
+    private readonly groupFrame;
+    private readonly connectionSlot;
+    private readonly audioSlot;
+    private readonly connectionIcon;
+    private readonly speakerIcon;
+    private readonly speakerOffIcon;
+    private onEnableAudio;
+    private stopPulse;
+    private pulseDirection;
+    constructor(scene: PixiSceneGraph, constructors: PixiSystemHudConstructors, ticker: Ticker, activity: PixiAnimationActivity, requestRender: () => void, ports: SystemHudPorts, textures: SystemHudTextures);
+    sync(state: PixiSystemHudState): void;
+    activateAudio(): void;
+    updateTuning(): void;
+    reset(): void;
+    destroy(): void;
+    private createSprite;
+    private syncLayout;
+    private createConnectionFallback;
+    private createSpeakerFallback;
+    private drawConnection;
+    private drawAudio;
+    private syncPulse;
+}
+export {};

package/dist/PixiTeamCheckCinematic.d.ts

@@ -0,0 +1,34 @@
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+export interface TeamCheckLampLayout {
+    x: number;
+    y: number;
+    size: number;
+}
+export interface TeamCheckLampRowOptions {
+    centerX: number;
+    width: number;
+    y: number;
+    minSize: number;
+    maxSize: number;
+    maxGap: number;
+}
+export declare class PixiTeamCheckCinematic {
+    static readonly panel: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: 960;
+        readonly height: number;
+        readonly radius: 5;
+    };
+    static readonly enterMs = 460;
+    static readonly lampMs = 280;
+    static readonly successInMs = 140;
+    static readonly successOutMs = 380;
+    static readonly failureStepMs = 60;
+    static readonly failureOutMs = 260;
+    static resolveFrameRect(source: {
+        width: number;
+        height: number;
+    }, panel?: PixiLayoutRect): PixiLayoutRect;
+    static resolveLampLayout(totalLights: number, options?: TeamCheckLampRowOptions): TeamCheckLampLayout[];
+}

package/dist/PixiTextTransitionEffect.d.ts

@@ -0,0 +1,54 @@
+import { Container, Text, type Renderer } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+/** Host-owned visual limits and timing. No content or identity policy is embedded. */
+export interface PixiTextTransitionSettings {
+    readonly durationMs: number;
+    readonly holdMs: number;
+    readonly incomingStartMs: number;
+    readonly incomingDurationMs: number;
+    readonly reducedMotionMs: number;
+    readonly maxTextureWidth: number;
+    readonly maxTextureHeight: number;
+    readonly maxParticles: number;
+    readonly grainSize: number;
+    readonly driftX: number;
+    readonly driftY: number;
+    readonly dustColor: string;
+    readonly edgeSoftness: number;
+}
+export interface PixiTextTransitionTarget {
+    readonly id: string;
+    readonly text: Text;
+    readonly overlay: Container;
+    readonly isCurrent: () => boolean;
+    readonly reserveWidth?: (fromText: string, toText: string) => () => void;
+}
+export interface PreparedPixiTextTransition {
+    play(signal: AbortSignal, onStarted?: () => void): Promise<void>;
+    cancel(): void;
+}
+export interface PixiTextTransitionEffectOptions {
+    readonly settings: PixiTextTransitionSettings;
+    readonly renderer: Pick<Renderer, 'generateTexture'>;
+    readonly director: PixiAnimationDirector;
+    readonly requestRender: () => void;
+    readonly activity?: PixiAnimationActivity;
+}
+export declare const TEXT_TRANSITION_FRAGMENT = "\nprecision highp float;\nin vec2 vTextureCoord;\nout vec4 finalColor;\nuniform sampler2D uTexture;\nuniform vec4 uInputSize;\nuniform float uProgress;\nuniform float uSeed;\nuniform float uGrain;\nuniform float uSoftness;\nfloat noise(vec2 cell) {\n  return fract(sin(dot(cell, vec2(127.1, 311.7)) + uSeed) * 43758.5453);\n}\nvoid main() {\n  vec4 source = texture(uTexture, vTextureCoord);\n  vec2 cell = floor(vTextureCoord * uInputSize.xy / uGrain);\n  float threshold = 0.08 + noise(cell) * 0.84;\n  float keep = 1.0 - smoothstep(threshold - uSoftness, threshold + uSoftness, uProgress);\n  finalColor = source * keep;\n}";
+/** Shared clock, two small glyph snapshots, bounded glyph-derived sand; no GPU readback or RAF. */
+export declare class PixiTextTransitionEffect {
+    private readonly options;
+    private readonly runs;
+    private reducedMotion;
+    private destroyed;
+    private readonly settings;
+    constructor(options: PixiTextTransitionEffectOptions);
+    setReducedMotion(reducedMotion: boolean): void;
+    prepare(targets: readonly PixiTextTransitionTarget[], fromText: string, toText: string, seed: string): PreparedPixiTextTransition | null;
+    reset(): void;
+    destroy(): void;
+    private createSurface;
+    private updateSurface;
+    private releaseSurface;
+}