@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,10 @@
+MingriAgency TRPG Engine
+Copyright (c) 2026 Lex
+
+Portions extracted and adapted from MingriAgencyCOC,
+Copyright (c) 2025 Lex, licensed under the MIT License.
+Source: https://github.com/bardway/mingriAgency_COC
+The complete source attribution and extraction mapping are maintained in
+docs/architecture and docs/guidance in the Engine repository.
+
+Third-party dependencies retain their own licenses and copyright notices.

package/NOTICE.md

@@ -0,0 +1 @@
+Source: mingriAgency_COC current local checkout, web/src/features/session-display. Source remains read-only. Product rules, resources, deployments and account data are excluded. Distributed under the repository MIT license. Third-party dependencies retain their own licenses.

package/README.md

@@ -1,3 +1,26 @@
-# Temporary Holding Version
+# @bardway/trpg-pixi
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+PixiJS 舞台、场景、动画、媒体和战斗 HUD 渲染。
+
+初始版本 `0.1.0`，提供 ESM JavaScript 和 TypeScript 声明。
+
+## 安装
+
+```sh
+npm install --save-exact @bardway/trpg-pixi@0.1.0
+```
+
+需要 `pixi.js@8.19.0` 和浏览器渲染环境。宿主提供主题、布局、素材与已裁定的公开状态，并按生命周期释放 renderer。
+
+## 公开入口
+
+- `@bardway/trpg-pixi`
+- `@bardway/trpg-pixi/recipes`
+
+## 平台依赖
+
+- `pixi.js@8.19.0`
+
+完整配置、示例和平台限制见[使用说明](https://github.com/bardway/mingriAgency_TRPGEngine/blob/main/docs/guidance/package-usage.md)。
+
+MIT。保留随包分发的 LICENSE、NOTICE 和第三方许可。

package/dist/AnimationMilestones.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Renderer-independent action milestones. Renderers may draw different
+ * primitives, but they must advance observable battle feedback in this order.
+ */
+export declare const ANIMATION_MILESTONES: readonly ["start", "impact", "feedback", "resource", "return", "done"];
+export type AnimationMilestone = (typeof ANIMATION_MILESTONES)[number];
+export interface AnimationMilestoneEvent {
+    actionId: string;
+    milestone: AnimationMilestone;
+}
+export type AnimationMilestoneListener = (event: AnimationMilestoneEvent) => void;
+/**
+ * The abort check lives at the emission boundary. This prevents a killed
+ * renderer timeline from reporting stale feedback after a snapshot reset or
+ * session switch.
+ */
+export declare const emitAnimationMilestone: (listener: AnimationMilestoneListener | undefined, actionId: string, milestone: AnimationMilestone, signal: AbortSignal) => boolean;

package/dist/BattleActionMotionMath.d.ts

@@ -0,0 +1,24 @@
+export interface BattleFxPoint {
+    x: number;
+    y: number;
+}
+/** Avalanche the event key so adjacent hit IDs do not produce adjacent angles. */
+export declare const battleFxRandom: (key: string) => number;
+export declare const resolveBladeSlashAngle: (id: string, hitIndex: number, offsetDegrees: number) => number;
+export declare const resolveMeleeApproachPoint: (from: BattleFxPoint, target: BattleFxPoint, standOff: number) => BattleFxPoint;
+export interface BattlePassByPath {
+    end: BattleFxPoint;
+    crossingProgress: number;
+    dodgeProgress: number;
+    fadeProgress: number;
+    tailLength: number;
+}
+/** Tangent to the visible token circle; fading starts only after the entire tail clears it. */
+export declare const resolveBattlePassByPath: (from: BattleFxPoint, target: BattleFxPoint, options: {
+    radius: number;
+    clearance: number;
+    behind: number;
+    tailLength: number;
+    side: -1 | 1;
+    dodge: boolean;
+}) => BattlePassByPath;

package/dist/BattleActionPresentationRecipes.d.ts

@@ -0,0 +1,11 @@
+import type { BattlePresentationPlan } from './BattlePresentationRecipe.js';
+import { BattlePresentationRecipeRegistry } from './BattlePresentationRecipe.js';
+export type BattleActionPresentationRecipeId = 'shoot' | 'throw' | 'electric' | 'melee' | 'swing' | 'whip' | 'blade' | 'charge' | 'explosion' | 'recovery' | 'resource' | 'status' | 'fallback';
+export interface BattleActionPresentationRecipeInput {
+    actionType: string;
+    createPlan(recipeId: BattleActionPresentationRecipeId): BattlePresentationPlan;
+}
+export declare const createBattleActionPresentationRecipeRegistry: (bindings: readonly {
+    id: BattleActionPresentationRecipeId;
+    actionTypes: readonly string[];
+}[]) => BattlePresentationRecipeRegistry<BattleActionPresentationRecipeInput>;

package/dist/BattleFxLibrary.d.ts

@@ -0,0 +1,16 @@
+import type { Graphics } from 'pixi.js';
+export interface BattleFxColors {
+    recover: string;
+    electric: string;
+    damage: string;
+    cinematic: string;
+}
+export declare const BATTLE_FX_PRIMITIVES: readonly ["cameraFocus", "cameraShake", "tracer", "muzzleFlash", "electricArc", "lungeMotion", "motionTrail", "dodgeOffset", "knockback", "impactFlash", "bloodBurst", "explosionBurst", "resourceFloat", "healAura", "tokenShake", "tokenShatter", "statusStamp", "insanityGlitch", "speedLines", "focusVignette"];
+export type BattleFxPrimitive = (typeof BATTLE_FX_PRIMITIVES)[number];
+/** Graphics graybox renderer. Formal textures can replace this renderer without changing planners. */
+export declare class BattleFxLibrary {
+    private readonly GraphicsConstructor;
+    private readonly colors;
+    constructor(GraphicsConstructor: typeof Graphics, colors: BattleFxColors);
+    create(kind: BattleFxPrimitive): Graphics;
+}

package/dist/BattlePresentationEngine.d.ts

@@ -0,0 +1,26 @@
+import type { Graphics } from 'pixi.js';
+import { BattleFxLibrary, type BattleFxColors } from './BattleFxLibrary.js';
+import { BattlePresentationPoseRegistry } from './BattlePresentationPoseRegistry.js';
+import { BattleSequenceScheduler, type BattleSequenceTask } from './BattleSequenceScheduler.js';
+import { type BattlePresentationPlan, type BattlePresentationTask } from './BattlePresentationRecipe.js';
+export declare class BattlePresentationEngine {
+    readonly poses: BattlePresentationPoseRegistry;
+    readonly scheduler: BattleSequenceScheduler;
+    readonly fx: BattleFxLibrary;
+    private abortController;
+    private readonly sidecars;
+    private readonly cameraBarriers;
+    private readonly activeClaimedTasks;
+    constructor(GraphicsConstructor: typeof Graphics, colors: BattleFxColors);
+    run(tasks: BattleSequenceTask[], onMilestone: Parameters<BattleSequenceScheduler['run']>[2], externalSignal?: AbortSignal): Promise<void>;
+    runPlan(plan: BattlePresentationPlan, onMilestone: (milestone: Exclude<import('./BattleSequenceScheduler.js').BattleSequenceMilestone, 'done'>) => void, externalSignal?: AbortSignal): Promise<void>;
+    startSidecar(task: BattlePresentationTask, externalSignal?: AbortSignal): Promise<void>;
+    waitForCameraBarriers(): Promise<void>;
+    reset(): void;
+    destroy(): void;
+    get activeSidecarCount(): number;
+    private toSequenceTask;
+    private runClaimedTask;
+    private tasksConflict;
+    private createLinkedSignal;
+}

package/dist/BattlePresentationPoseRegistry.d.ts

@@ -0,0 +1,25 @@
+export interface BattlePresentationPose {
+    x: number;
+    y: number;
+    rotation: number;
+    scale: number;
+    alpha: number;
+}
+export declare class BattlePresentationPoseRegistry {
+    private readonly entries;
+    syncAuthoritative(tokenId: string, point: {
+        x: number;
+        y: number;
+    }): void;
+    beginPresentation(tokenId: string): void;
+    setPose(tokenId: string, pose: Partial<BattlePresentationPose>): void;
+    reconcile(tokenId: string): void;
+    resolve(tokenId: string): BattlePresentationPose & {
+        authoritativeX: number;
+        authoritativeY: number;
+    };
+    isLocked(tokenId: string): boolean;
+    reset(): void;
+    deleteMissing(tokenIds: ReadonlySet<string>): void;
+    private require;
+}

package/dist/BattlePresentationRecipe.d.ts

@@ -0,0 +1,48 @@
+import type { BattleSequenceMilestone } from './BattleSequenceScheduler.js';
+export type BattlePresentationPhase = 'approach' | 'impact' | 'feedback' | 'resource' | 'return';
+export type BattlePresentationTaskMode = 'blocking' | 'sidecar' | 'camera-barrier';
+export type BattlePresentationClaim = {
+    type: 'token-position';
+    tokenId: string;
+} | {
+    type: 'token-visual';
+    tokenId: string;
+} | {
+    type: 'map';
+    id?: string;
+} | {
+    type: 'roster';
+    tokenId?: string;
+} | {
+    type: 'camera';
+    id?: string;
+} | {
+    type: 'screen';
+    id?: string;
+};
+export interface BattlePresentationTask {
+    id: string;
+    phase: BattlePresentationPhase;
+    mode: BattlePresentationTaskMode;
+    reads?: readonly BattlePresentationClaim[];
+    writes?: readonly BattlePresentationClaim[];
+    run(signal: AbortSignal): Promise<void>;
+}
+export interface BattlePresentationPlan {
+    id: string;
+    tasks: readonly BattlePresentationTask[];
+}
+export interface BattlePresentationRecipe<TInput, TServices = undefined> {
+    id: string;
+    matches(input: TInput): boolean;
+    build(input: TInput, services: TServices): BattlePresentationPlan;
+}
+export declare const BATTLE_PRESENTATION_PHASES: readonly BattlePresentationPhase[];
+export declare const battlePresentationPhaseMilestone: (phase: BattlePresentationPhase) => Exclude<BattleSequenceMilestone, "done">;
+export declare const serializeBattlePresentationClaim: (claim: BattlePresentationClaim) => string;
+export declare class BattlePresentationRecipeRegistry<TInput, TServices = undefined> {
+    private readonly recipes;
+    register(recipe: BattlePresentationRecipe<TInput, TServices>): void;
+    resolve(input: TInput): BattlePresentationRecipe<TInput, TServices> | null;
+    get registeredIds(): readonly string[];
+}

package/dist/BattleSequenceScheduler.d.ts

@@ -0,0 +1,11 @@
+export type BattleSequenceMilestone = 'start' | 'impact' | 'feedback' | 'resource' | 'return' | 'done';
+export interface BattleSequenceTask {
+    id: string;
+    reads?: string[];
+    writes?: string[];
+    run(signal: AbortSignal, emit: (milestone: BattleSequenceMilestone) => void): Promise<void>;
+}
+export declare const planBattleSequenceBatches: (tasks: BattleSequenceTask[]) => BattleSequenceTask[][];
+export declare class BattleSequenceScheduler {
+    run(tasks: BattleSequenceTask[], signal: AbortSignal, onMilestone: (taskId: string, milestone: BattleSequenceMilestone) => void): Promise<void>;
+}

package/dist/DisplayEventQueue.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeLogger } from '@bardway/trpg-media';
+export interface DisplayQueueItem {
+    id: string;
+    kind: string;
+    blocking: boolean;
+    run: (signal: AbortSignal) => Promise<void>;
+}
+export type DisplayQueueRunResult = 'completed' | 'aborted';
+export interface DisplayEventQueue {
+    enqueue(item: DisplayQueueItem): Promise<DisplayQueueRunResult>;
+    clear(reason: string): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    getState(): DisplayEventQueueState;
+}
+export interface DisplayEventQueueState {
+    pending: number;
+    activeBlocking: number;
+    activeNonBlocking: number;
+    paused: boolean;
+    destroyed: boolean;
+}
+export declare const createDisplayEventQueue: (logger: RuntimeLogger) => DisplayEventQueue;

package/dist/PixiAnimationActivity.d.ts

@@ -0,0 +1,7 @@
+import type { Ticker } from 'pixi.js';
+export interface PixiAnimationActivity {
+    acquire(reason: string): () => void;
+    clear(): void;
+    setPaused(paused: boolean): void;
+}
+export declare const createPixiAnimationActivity: (ticker: Ticker) => PixiAnimationActivity;

package/dist/PixiAnimationDirector.d.ts

@@ -0,0 +1,21 @@
+import { gsap } from 'gsap';
+import type { StoryTimelineClock } from './story/StoryTimelineClock.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+export type PixiTweenTarget = Parameters<typeof gsap.to>[0];
+export type PixiTweenVars = Parameters<typeof gsap.to>[1];
+export type PixiManagedTweenVars = PixiTweenVars & {
+    /** Keep a short, explicit duration when reduced-motion mode would otherwise make it instant. */
+    reducedMotionDuration?: number;
+};
+export interface PixiAnimationDirector {
+    tween(target: PixiTweenTarget, vars: PixiManagedTweenVars, signal: AbortSignal): Promise<void>;
+    sequence(tasks: Array<() => Promise<void>>, signal: AbortSignal): Promise<void>;
+    loop(target: PixiTweenTarget, vars: PixiTweenVars): () => void;
+    setReducedMotion(reducedMotion: boolean): void;
+    setPlaybackRate(rate: number): void;
+    pause(): void;
+    resume(): void;
+    clear(): void;
+    destroy(): void;
+}
+export declare const createPixiAnimationDirector: (clock: StoryTimelineClock, activity?: PixiAnimationActivity) => PixiAnimationDirector;

package/dist/PixiApplicationFactory.d.ts

@@ -0,0 +1,17 @@
+import type { Application } from 'pixi.js';
+export { PIXI_LOGICAL_STAGE } from './PixiStageMetrics.js';
+export declare const STAGE_RENDER_QUALITIES: {
+    readonly performance: 1;
+    readonly balanced: 1.25;
+    readonly quality: 1.5;
+    readonly ultra: 2;
+};
+export type StageRenderQuality = keyof typeof STAGE_RENDER_QUALITIES;
+export declare const resolveStageRenderQuality: (value: unknown) => StageRenderQuality;
+/** Resolves the device pixel ratio without exceeding the selected render-quality ceiling. */
+export declare const resolveDisplayResolution: (quality: unknown, devicePixelRatio?: unknown) => number;
+export type PixiApplicationConstructor = new () => Application;
+export declare const createPixiApplication: (ApplicationConstructor: PixiApplicationConstructor, quality?: unknown, stage?: {
+    width: number;
+    height: number;
+}) => Promise<Application>;

package/dist/PixiAssetManager.d.ts

@@ -0,0 +1,70 @@
+import type { Texture } from 'pixi.js';
+interface PixiAssetLoadOptions {
+    readonly strategy: 'retry';
+    readonly retryCount: number;
+    readonly retryDelay: number;
+}
+interface PixiAssetsApi {
+    load: (asset: PixiAssetDescriptor, options?: PixiAssetLoadOptions) => Promise<Texture>;
+    unload: (aliases: string[]) => Promise<void> | void;
+}
+interface PixiAssetDescriptor {
+    alias: string;
+    src: string;
+    parser?: 'video';
+    data?: {
+        autoPlay: false;
+        loop: true;
+        muted: true;
+        playsinline: true;
+        preload: true;
+        updateFPS: 0;
+        crossorigin: true;
+        mime: 'video/webm';
+    };
+}
+interface PixiVideoAssetDependencies {
+    readonly fetchVideo?: typeof fetch;
+    readonly createObjectURL?: typeof URL.createObjectURL;
+    readonly revokeObjectURL?: typeof URL.revokeObjectURL;
+    readonly retryDelayMs?: number;
+    readonly resolveUrl?: (url: string) => string;
+}
+export type PixiAssetScope = 'stage-critical' | 'stage-ui' | 'battle-common' | `scene:${string}` | `battle-map:${string}` | `effect:${string}` | `cinematic:${string}` | `hud-clue:${string}` | `runtime:${string}`;
+/**
+ * Renderer-local asset ownership on top of Pixi Assets' global cache.
+ * A scope may request the same alias many times; it is loaded once and released
+ * only after its final scope is released.
+ */
+export declare class PixiAssetManager {
+    private readonly assets;
+    private readonly videoDependencies;
+    private readonly records;
+    private readonly aliasesByScope;
+    private readonly sharedOwnership;
+    private readonly pendingSourceUnloads;
+    private readonly ownUnloads;
+    private readonly waitingScopeLoads;
+    private readonly videoBytes;
+    private videoDownloads;
+    private videoGeneration;
+    private disposed;
+    constructor(assets: PixiAssetsApi, videoDependencies?: PixiVideoAssetDependencies);
+    loadTexture(alias: string, src: string, scope?: PixiAssetScope | string, signal?: AbortSignal): Promise<Texture>;
+    loadVideoTexture(alias: string, src: string, scope: PixiAssetScope | string, signal?: AbortSignal): Promise<Texture>;
+    preloadVideoBytes(src: string, signal?: AbortSignal): Promise<void>;
+    releaseVideoTexture(alias: string): Promise<void>;
+    clearVideoCache(): void;
+    private loadVideoBlob;
+    private loadAsset;
+    releaseScope(scope: PixiAssetScope | string): Promise<void>;
+    releaseAll(): Promise<void>;
+    private waitForSourceUnload;
+    private createRecord;
+    private retain;
+    private releaseOwnership;
+    private releaseAlias;
+    private unloadOrphanedRecords;
+    private revokeVideoSource;
+}
+export {};

package/dist/PixiBattleActionRecipes.d.ts

@@ -0,0 +1,75 @@
+export declare const PIXI_BATTLE_ACTION_TIMING: {
+    readonly shootMs: 100;
+    readonly electricEnterMs: 40;
+    readonly electricHoldMs: 80;
+    readonly electricExitMs: 120;
+    readonly electricScreenFlashMs: 120;
+    readonly muzzleFlashMs: 100;
+    readonly meleeLineMs: 300;
+    readonly meleeScale: 1.08;
+    readonly meleeReturnMs: 250;
+    readonly dodgeShiftPx: 26;
+    readonly dodgeDelayMs: 160;
+    readonly targetShakeMs: 100;
+    readonly explosionProjectileMs: 500;
+    readonly explosionFireRingMs: 180;
+    readonly chargeImpactHoldMs: 20;
+    readonly explosionShakeMs: 200;
+    readonly damageFloatMs: 1600;
+    readonly healFloatMs: 2000;
+    readonly resourceStaggerMs: 200;
+    readonly rosterFeedbackMs: 500;
+    readonly rosterSameResourceStaggerMs: 60;
+    readonly statusMs: 1100;
+};
+export declare const resolveDodgeOffset: (attacker: {
+    x: number;
+    y: number;
+}, target: {
+    x: number;
+    y: number;
+}, direction: -1 | 1) => {
+    x: number;
+    y: number;
+};
+export declare const resolveAwayDodgeOffset: (attacker: {
+    x: number;
+    y: number;
+}, target: {
+    x: number;
+    y: number;
+}, seed: number, distance: number) => {
+    x: number;
+    y: number;
+};
+export declare const resolveParticipantBoundsCenter: (points: readonly {
+    x: number;
+    y: number;
+}[]) => {
+    x: number;
+    y: number;
+} | null;
+export declare const resolveExplosionCoverage: (points: readonly {
+    x: number;
+    y: number;
+}[], tokenRadius: number) => {
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+} | null;
+export declare const resolveExplosionArcPoint: (from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}, progress: number) => {
+    x: number;
+    y: number;
+    rotation: number;
+    height: number;
+};
+export declare const resolveResourceFloatDuration: (text: string) => number;
+export declare const resolveTransientStatus: <T extends string>(priority: readonly T[], active: ReadonlySet<T>) => T | null;

package/dist/PixiBattleCinematicSurface.d.ts

@@ -0,0 +1,23 @@
+import { type ComboSlashRegion } from './PixiSessionLayout.js';
+export interface BattlePictureLayout {
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+    entryX: number;
+    driftX: number;
+    exitX: number;
+}
+/** Shared screen-space geometry and cadence for retained battle cinematics. */
+export declare class PixiBattleCinematicSurface {
+    static resolveBattlePictureLayout(source: {
+        width: number;
+        height: number;
+    }, direction: -1 | 1, bounds?: {
+        maxWidth: number;
+        maxHeight: number;
+        allowUpscale?: boolean;
+    }): BattlePictureLayout;
+    static resolveComboRegions(participantCount: number): ComboSlashRegion[];
+    static resolveComboHoldMs(totalMs: number): number;
+}

package/dist/PixiBattleEntryTransition.d.ts

@@ -0,0 +1,87 @@
+import type { BlurFilter, Container, Graphics, Particle, ParticleContainer, Rectangle, Texture } from 'pixi.js';
+import type { BattleViewportGridLayout } from './PixiSessionLayout.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Particle: typeof Particle;
+    ParticleContainer: typeof ParticleContainer;
+    Rectangle: typeof Rectangle;
+    Texture: typeof Texture;
+}
+export interface BattleEntryGridStyle {
+    readonly lineWidth: number;
+    readonly lineAlpha: number;
+    readonly lineColor: string;
+    readonly cellFillAlpha: number;
+    readonly cellEdgeAlpha: number;
+    readonly cellEdgeWidth: number;
+    readonly cellEdgeGlowAlpha: number;
+    readonly cellEdgeGlowWidth: number;
+    readonly cellEdgeGlowBlurStrength: number;
+}
+export interface BattleEntryCell {
+    readonly col: number;
+    readonly row: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly order: number;
+}
+export declare const createBattleEntryCells: (layout: BattleViewportGridLayout, seed: string) => BattleEntryCell[];
+export declare const createStableBattleEntryOrder: (ids: readonly string[], seed: string) => string[];
+export declare const resolveBattleEntryHandoffAlpha: (progress: number, targetAlpha: number) => {
+    veilAlpha: number;
+    cellAlpha: number;
+};
+export declare const resolveBattleEntryCellPulse: (progress: number, peakProgress: number) => {
+    fill: number;
+    edge: number;
+};
+/** Assigns ordered cells to accelerating reveal waves sized 1, 2, 3, 4, ... */
+export declare const createBattleEntryRevealBatchIndices: (cellCount: number) => number[];
+export interface BattleRosterProgressEntry {
+    readonly root: {
+        alpha: number;
+        readonly position: {
+            set: (x: number, y: number) => void;
+        };
+    };
+    readonly targetX: number;
+    readonly targetY: number;
+}
+export declare const applyBattleRosterEntryProgress: (entries: readonly BattleRosterProgressEntry[], progress: number, offsetX: number, entryDuration: number, maxStagger: number) => void;
+/** Owns all temporary visual nodes used by a single battle-entry transition. */
+export declare class PixiBattleEntryTransition {
+    readonly node: Container;
+    readonly whiteVeil: Graphics;
+    readonly verticalLines: Graphics;
+    readonly horizontalLines: Graphics;
+    readonly cells: readonly BattleEntryCell[];
+    readonly particles: readonly Particle[];
+    readonly edgeParticles: readonly Particle[];
+    readonly edgeGlowParticles: readonly Particle[];
+    readonly revealBatchIndices: readonly number[];
+    private readonly particleContainer;
+    private readonly edgeParticleContainer;
+    private readonly edgeGlowParticleContainer;
+    private readonly edgeGlowLayer;
+    private readonly edgeGlowBlur;
+    private readonly gridStyle;
+    private destroyed;
+    constructor(constructors: Constructors, layout: BattleViewportGridLayout | null, seed: string, gridStyle: BattleEntryGridStyle, colors: {
+        mask: string;
+    }, stage?: {
+        width: number;
+        height: number;
+    });
+    get temporaryObjectCount(): number;
+    setHandoffProgress(progress: number): void;
+    setRevealProgress(progress: number, totalDuration: number, fadeDuration: number, gridFadeStartProgress: number, glowPeakProgress: number, glowIntensityScale?: number): void;
+    hideGridLines(): void;
+    destroy(): void;
+    private createCellEdgeParticles;
+    private createParticleContainer;
+}
+export {};