@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiBattleFieldSurface.d.ts

@@ -0,0 +1,125 @@
+export type FieldVisualId = 'heavyRain' | 'fire' | 'thunderstorm' | 'earthquake' | 'arcaneVeil' | 'denseFog' | 'dark';
+import type { BlurFilter, Container, Graphics, Particle, ParticleContainer, Rectangle, Texture, Ticker } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiShaderRuntime } from './PixiShaderRuntime.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Container: new (options?: {
+        label?: string;
+    }) => Container;
+    Graphics: new (options?: {
+        label?: string;
+    }) => Graphics;
+    Particle: new (options: ConstructorParameters<typeof Particle>[0]) => Particle;
+    ParticleContainer: new (options: ConstructorParameters<typeof ParticleContainer>[0]) => ParticleContainer;
+    Rectangle: typeof Rectangle;
+    Texture: typeof Texture;
+}
+export interface PixiBattleFieldSurfaceOptions {
+    readonly stage: {
+        width: number;
+        height: number;
+    };
+    readonly intensity: number;
+    readonly colors: {
+        rainOverlay: string;
+        rainColor: string;
+        lightningOverlay: string;
+        lightningColor: string;
+        emberColor: string;
+        ashColor: string;
+    };
+    readonly scene: PixiSceneGraph;
+    readonly shaderRuntime: PixiShaderRuntime;
+    readonly director: PixiAnimationDirector;
+    readonly ticker: Ticker;
+    readonly activity: PixiAnimationActivity;
+    readonly constructors: Constructors;
+    readonly getTuning: () => SessionTuningResolver | undefined;
+    readonly requestRender: () => void;
+    readonly setRosterShake: (x: number, y: number, rotation: number, scale: number) => void;
+    readonly setStoryShake: (transforms: readonly [
+        StoryShakeTransform,
+        StoryShakeTransform,
+        StoryShakeTransform,
+        StoryShakeTransform
+    ]) => void;
+}
+export interface StoryShakeTransform {
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+    readonly scale: number;
+}
+export declare class PixiBattleFieldSurface {
+    private readonly options;
+    private profile;
+    setProfile(profile: 'story' | 'battle'): void;
+    diagnostics(): string;
+    private active;
+    private exitingField;
+    private exitPromise;
+    private readonly releasedFields;
+    private readonly persistentTransition;
+    private suspended;
+    private motionSuspended;
+    private paused;
+    private reducedMotion;
+    private elapsedMs;
+    private lightningStep;
+    private lightningAtMs;
+    private lightningVisibleUntilMs;
+    private lightningFadeDurationMs;
+    private lightningSecondFlashAtMs;
+    private lightningSecondFlashUntilMs;
+    private rainGustStep;
+    private rainGustStartsAtMs;
+    private rainGustEndsAtMs;
+    private rainGustAddedSpeed;
+    private rainNextGustAtMs;
+    private rainAngleFromRad;
+    private rainAngleToRad;
+    private rainCurrentAngleRad;
+    private rainCurrentAddedSpeed;
+    private rainCurrentGustRatio;
+    private releaseActivity;
+    private generation;
+    constructor(options: PixiBattleFieldSurfaceOptions);
+    replace(effectId: FieldVisualId | null, signal: AbortSignal, onMounted?: () => void): Promise<void>;
+    /** Snapshot restore has no outgoing fade or effect entrance. Called only at the scene commit. */
+    hydrate(effectId: FieldVisualId | null): void;
+    private replaceEffect;
+    setPaused(paused: boolean): void;
+    setSuspended(suspended: boolean): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    reset(): void;
+    destroy(): void;
+    refreshTuning(): void;
+    private createActive;
+    private createRain;
+    private createEmbers;
+    private createAsh;
+    private createRisingParticles;
+    private addParticleContainer;
+    private startTicker;
+    private stopTicker;
+    private tick;
+    private tickRain;
+    private updateRainBlur;
+    private resetRainBlur;
+    private updateRainWind;
+    private tickRising;
+    private tickThunder;
+    private beginLightning;
+    private tickEarthquake;
+    private resetEarthquakeTransform;
+    private createOverlay;
+    private releaseActive;
+    private releaseField;
+    private destroyActive;
+    private number;
+}
+export {};

package/dist/PixiBattleFxResources.d.ts

@@ -0,0 +1,154 @@
+import type { BlurFilter, Container, Graphics, Mesh, MeshGeometry, Shader, Sprite, UniformGroup } from 'pixi.js';
+import { PixiBattleWhipResources } from './PixiBattleWhipResources.js';
+import { PixiBattleLightningResources, type PixiBattleLightningHandle } from './PixiBattleLightningResources.js';
+export type { PixiBattleLightningHandle } from './PixiBattleLightningResources.js';
+type PixiMesh = Mesh<MeshGeometry, Shader>;
+export interface PixiBattleFxCapabilities {
+    writeColor?: (value: string, out: Float32Array) => void;
+    BlurFilter?: typeof import('pixi.js').BlurFilter;
+    Filter?: typeof import('pixi.js').Filter;
+    Container?: typeof import('pixi.js').Container;
+    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;
+    Sprite?: typeof import('pixi.js').Sprite;
+    Texture?: {
+        WHITE: import('pixi.js').Texture;
+    };
+    generateTexture?: (target: Container) => import('pixi.js').Texture;
+}
+export type PixiBattleTrailMode = 'shoot' | 'melee' | 'electric' | 'charge' | 'support';
+export interface SpeedLineUniforms {
+    uFxColor: Float32Array;
+    uTime: number;
+    uCycleA: number;
+    uCycleB: number;
+    uCycleC: number;
+    uSeed: number;
+    uDensity: number;
+    uMinLength: number;
+    uMaxLength: number;
+    uMotionBlur: number;
+    uThicknessScale: number;
+}
+export interface PixiBattleFxHandle {
+    readonly mesh: PixiMesh;
+    readonly geometry: MeshGeometry;
+    readonly shader: Shader;
+    readonly kind: 'trail' | 'burst' | 'speed-lines';
+    readonly uniforms: UniformGroup;
+    released: boolean;
+}
+/** Owns the small retained Mesh pool used by battle action FX. */
+export declare class PixiBattleFxResourceOwner {
+    private readonly capabilities;
+    private readonly availableTrails;
+    private readonly availableBursts;
+    private readonly availableSpeedLines;
+    private readonly active;
+    private readonly owned;
+    private readonly availableDebris;
+    private readonly activeDebris;
+    private readonly ownedDebris;
+    private readonly availableSnapshots;
+    private readonly activeSnapshots;
+    private readonly ownedSnapshots;
+    private readonly snapshotTextures;
+    private readonly availableBlurFilters;
+    private readonly activeBlurFilters;
+    private readonly ownedBlurFilters;
+    private readonly irregularContexts;
+    private readonly availableIrregularDebris;
+    private readonly activeIrregularDebris;
+    private readonly ownedIrregularDebris;
+    private readonly availableScreenFlashes;
+    private readonly activeScreenFlashes;
+    private readonly ownedScreenFlashes;
+    private readonly availableActionGraphics;
+    private readonly activeActionGraphics;
+    private readonly ownedActionGraphics;
+    readonly whips: PixiBattleWhipResources;
+    readonly lightning: PixiBattleLightningResources;
+    constructor(capabilities?: PixiBattleFxCapabilities);
+    acquireTrail(parent: Container, from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, options: {
+        color: string;
+        mode: PixiBattleTrailMode;
+        seed: number;
+        width: number;
+        softness: number;
+        initialLengthRatio?: number;
+        tailBlurStrength?: number;
+    }): PixiBattleFxHandle | null;
+    acquireSpeedLines(parent: Container, color: string, cycles: readonly [number, number, number], options?: {
+        seed?: number;
+        density?: number;
+        minLength?: number;
+        maxLength?: number;
+        motionBlur?: number;
+        thicknessScale?: number;
+    }): PixiBattleFxHandle | null;
+    getSpeedLineUniforms(handle: PixiBattleFxHandle): SpeedLineUniforms;
+    acquireLightning(parent: Container, from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, options: Parameters<PixiBattleLightningResources['acquire']>[3]): PixiBattleLightningHandle | null;
+    releaseLightning(handle: PixiBattleLightningHandle | null, generation?: number | undefined): void;
+    acquireIrregularDebris(parent: Container, center: {
+        x: number;
+        y: number;
+    }, options: {
+        color: string;
+        templateIndex: number;
+        size: number;
+    }): Graphics | null;
+    releaseIrregularDebris(node: Graphics | null): void;
+    acquireBurst(parent: Container, center: {
+        x: number;
+        y: number;
+    }, options: {
+        color: string;
+        radius: number;
+        seed: number;
+        ring: number;
+    }): PixiBattleFxHandle | null;
+    release(handle: PixiBattleFxHandle | null): void;
+    acquireDebris(parent: Container, center: {
+        x: number;
+        y: number;
+    }, options: {
+        color: string;
+        angle: number;
+        length: number;
+        thickness: number;
+    }): Sprite | null;
+    releaseDebris(debris: Sprite | null): void;
+    acquireTokenSnapshot(parent: Container, key: string, target: Container): Sprite | null;
+    releaseTokenSnapshot(snapshot: Sprite | null): void;
+    acquireBlurFilter(strength: number): BlurFilter | null;
+    releaseBlurFilter(filter: BlurFilter | null): void;
+    acquireScreenFlash(parent: Container, color: number): Graphics | null;
+    releaseScreenFlash(flash: Graphics | null): void;
+    acquireActionGraphic(parent: Container): Graphics | null;
+    releaseActionGraphic(graphic: Graphics | null): void;
+    reset(): void;
+    destroy(): void;
+    get activeCount(): number;
+    private activate;
+    private createTrail;
+    private createSpeedLines;
+    private ensureIrregularContexts;
+    private createBurst;
+    private createUniformGroup;
+    private createHandle;
+}

package/dist/PixiBattleGrid.d.ts

@@ -0,0 +1,13 @@
+import type { Graphics } from 'pixi.js';
+import type { BattleViewportGridLayout } from './PixiSessionLayout.js';
+type GridGraphics = Pick<Graphics, 'rect' | 'fill'>;
+export interface BattleGridStyle {
+    overlayColor: string;
+    overlayAlpha: number;
+    lineColor: string;
+    lineAlpha: number;
+    lineWidth: number;
+}
+/** Draws the single formal battle grid geometry used by both the World and entry transition. */
+export declare const drawBattleGrid: <T extends GridGraphics>(grid: T, layout: BattleViewportGridLayout, style: BattleGridStyle) => T;
+export {};

package/dist/PixiBattleHudPorts.d.ts

@@ -0,0 +1,192 @@
+import type { Texture } from 'pixi.js';
+import type { TokenAvatarCrop } from './PixiMapWorldUtils.js';
+import type { createPixiTypography } from './PixiTypography.js';
+import type { BattleTypographyTuning, OBJECTIVE_LAYOUT, OBJECTIVE_PROGRESS_STYLE } from './PixiBattleVisualLayout.js';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+type Widen<T> = T extends number ? number : T extends string ? string : T extends readonly (infer V)[] ? readonly Widen<V>[] : T extends object ? {
+    readonly [K in keyof T]: Widen<T[K]>;
+} : T;
+export interface HudRosterView {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    avatarCrop?: TokenAvatarCrop;
+    order: string | number;
+    gray: boolean;
+    tint: string;
+    meter?: {
+        label: string;
+        ratio: number;
+        color: string;
+    };
+    statuses: readonly string[];
+    visualState: {
+        distorted?: boolean;
+        stained?: boolean;
+        tilted?: boolean;
+    };
+}
+export interface HudObjectiveView {
+    id: string;
+    name: string;
+    progress: number;
+    progressLabel: string;
+}
+export interface HudIconView {
+    id: string;
+}
+export interface BattleHudSyncInput {
+    scopeKey: string;
+    hydrate?: boolean;
+    title: string;
+    roundLabel: string;
+    roster: readonly HudRosterView[];
+    objectives: readonly HudObjectiveView[];
+    icons: readonly HudIconView[];
+    currentActorTokenId: string | null;
+    visible: boolean;
+    animateLifecycle?: boolean;
+}
+export interface HudStatusStyle {
+    label: string;
+    surface: string;
+    inset: string;
+    border: string;
+    text: string;
+}
+export interface HudResourceFeedbackStyle {
+    lane: number;
+    negative: string;
+    positive: string;
+    shakeOnDecrease: boolean;
+}
+export interface HudVisualStyle {
+    disabled: string;
+    disabledBorder: string;
+    disabledSurface: string;
+    disabledText: string;
+    distortionTearGap: string;
+    assetUi: Record<'objectiveFill' | 'objectiveFillHighlight' | 'objectiveFillShadow' | 'objectiveMarker' | 'objectivePercent' | 'objectiveTick' | 'objectiveTitle' | 'objectiveTrack' | 'objectiveTrackBorder' | 'rosterActive' | 'rosterName' | 'rosterOrder', string>;
+    metal: {
+        shadow: string;
+    };
+    roster: {
+        resourceHighlight: string;
+        resourceTrack: string;
+    };
+    rosterStatus: {
+        distortionIntensity: number;
+        stainOpacity: number;
+        stainStrength: number;
+        tiltDegrees: number;
+    };
+    statusPill: {
+        surface: string;
+        inset: string;
+        border: string;
+        text: string;
+    };
+    teamCheckStatus: {
+        blurStrength: number;
+        cycleDurationMs: number;
+        driftAmplitude: number;
+        gap: number;
+        glowColor: string;
+        glowIntensity: number;
+        iconHeight: number;
+        silhouetteScale: number;
+        plumes: readonly {
+            x: number;
+            y: number;
+            radiusX: number;
+            radiusY: number;
+            alpha: number;
+        }[];
+    };
+}
+export interface HudUnitCardLayout {
+    source: {
+        width: number;
+        height: number;
+    };
+    rowGap: number;
+    maxVisibleRows: number;
+    avatar: PixiLayoutRect;
+    name: {
+        fontSize: number;
+        rightPadding: number;
+    };
+    activeOutline: {
+        inset: number;
+        width: number;
+    };
+}
+export interface HudTypographyLayout {
+    round: {
+        fontSize: number;
+    };
+    roster: {
+        order: BattleTypographyTuning['roster']['order'];
+        name: BattleTypographyTuning['roster']['name'];
+        resource: BattleTypographyTuning['roster']['hp'];
+        status: BattleTypographyTuning['roster']['status'];
+    };
+    objective: BattleTypographyTuning['objective'];
+}
+export interface BattleHudPorts {
+    defaultAvatarUrl: string;
+    typography: ReturnType<typeof createPixiTypography>;
+    colors: {
+        panel: string;
+        border: string;
+        mask: string;
+        transition: string;
+    };
+    style: HudVisualStyle;
+    statuses: Readonly<Record<string, HudStatusStyle>>;
+    resources: Readonly<Record<string, HudResourceFeedbackStyle>>;
+    layout: {
+        header: PixiLayoutRect;
+        headerRoundCell: PixiLayoutRect;
+        headerMapName: PixiLayoutRect;
+        headerTeamChecks: PixiLayoutRect;
+        roster: PixiLayoutRect;
+        objective: PixiLayoutRect;
+        typography: HudTypographyLayout;
+        unitCard: {
+            maxVisibleRows: number;
+            rowGap: number;
+            resourceBar: PixiLayoutRect;
+        };
+    };
+    unitCardLayout: HudUnitCardLayout;
+    objectiveLayout: Widen<typeof OBJECTIVE_LAYOUT>;
+    objectiveProgressStyle: Widen<typeof OBJECTIVE_PROGRESS_STYLE>;
+    textures: {
+        unitCard: Texture | null;
+        objective: Texture | null;
+        teamCheckIcon: Texture | null;
+    };
+    partyTextures: {
+        dossierCard: Texture | null;
+        dossierBlood: Texture | null;
+    };
+}
+export declare function resolveHudStatusVisibility<T>(statuses: readonly T[], availableWidth: number, getWidth: (status: T) => number, overflowWidth: number, gap?: number): {
+    visible: readonly T[];
+    hiddenCount: number;
+};
+export declare function resolveHudObjectiveCardWidth(count: number, laneWidth: number, maxWidth?: number, gap?: number): number;
+export declare function validateBattleHudInput(input: BattleHudSyncInput, ports: Pick<BattleHudPorts, 'statuses'>): void;
+/** Retains the source fitting algorithm while making row capacity a host choice. */
+export declare function resolveHudRosterCardLayout(availableWidth: number, availableHeight: number, textureWidth: number, textureHeight: number, options: {
+    maxVisibleRows: number;
+    rowGap: number;
+}): {
+    scale: number;
+    width: number;
+    height: number;
+    gap: number;
+    pitch: number;
+};
+export {};

package/dist/PixiBattleHudSurface.d.ts

@@ -0,0 +1,159 @@
+import { type BattleHudSyncInput, type BattleHudPorts } from './PixiBattleHudPorts.js';
+import type { BlurFilter, ColorMatrixFilter, Container, Filter, Graphics, Mesh, MeshGeometry, Rectangle, Shader, Sprite, Text, Texture, Ticker, UniformGroup } from 'pixi.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    ColorMatrixFilter: typeof ColorMatrixFilter;
+    Container: typeof Container;
+    Filter: typeof Filter;
+    Graphics: typeof Graphics;
+    Mesh: typeof Mesh;
+    MeshGeometry: typeof MeshGeometry;
+    Rectangle: typeof Rectangle;
+    Shader: typeof Shader;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+    UniformGroup: typeof UniformGroup;
+}
+export type BattleRosterResource = string;
+export interface BattleRosterResourceFeedback {
+    tokenId: string;
+    resource: BattleRosterResource;
+    value: number;
+    hitIndex?: number;
+    emphasis?: boolean;
+}
+export interface BattleRosterEntryNode {
+    readonly id: string;
+    readonly root: Container;
+    readonly targetX: number;
+    readonly targetY: number;
+}
+export declare class PixiBattleHudSurface {
+    private readonly ports;
+    private readonly assets;
+    private readonly constructors;
+    private readonly ticker;
+    private readonly activity;
+    private readonly requestRender;
+    private readonly battleTextures;
+    private readonly partyTextures;
+    private readonly animation?;
+    readonly node: Container;
+    private readonly headerFrame;
+    private readonly roundFrame;
+    private readonly mapName;
+    private readonly round;
+    private readonly teamChecksRoot;
+    private readonly teamCheckFogRoot;
+    private readonly teamCheckIconRoot;
+    private readonly teamCheckFogBlur;
+    private readonly teamCheckFogFilterArea;
+    private readonly currentActorShadowBlur;
+    private currentActorShadowBlurStrength;
+    private readonly teamCheckNodes;
+    private readonly rosterHeader;
+    private readonly rosterCount;
+    private readonly rosterMask;
+    private readonly rosterContent;
+    private readonly rosterNodes;
+    private readonly currentActorCardGlow;
+    private readonly objectiveRoot;
+    private readonly objectiveMask;
+    private readonly objectiveNodes;
+    private stopObjectiveGlowAnimation;
+    private visible;
+    private reducedMotion;
+    private activeRosterId;
+    private activeRosterCanPulse;
+    private returningRosterId;
+    private rosterPulsePhase;
+    private rosterEntryElapsedMs;
+    private rosterReturnElapsedMs;
+    private stopRosterPulse;
+    private battleEntryActive;
+    private stopRosterNameMarquee;
+    private rosterNameScrollPhase;
+    private teamCheckFogElapsedMs;
+    private stopTeamCheckFog;
+    private lastInput;
+    private tuning;
+    private uiHighlightMultiplier;
+    private readonly releaseUiHighlight;
+    private readonly feedbackControllers;
+    constructor(ports: BattleHudPorts, scene: import('./PixiSceneGraph.js').PixiSceneGraph, assets: PixiAssetManager, constructors: Constructors, ticker: Ticker, activity: PixiAnimationActivity, requestRender: () => void, battleTextures: BattleHudPorts['textures'], tuning?: SessionTuningResolver, partyTextures?: BattleHudPorts['partyTextures'], animation?: PixiAnimationDirector | undefined, mediaBreath?: PixiMediaBreathRuntime);
+    sync(input: BattleHudSyncInput): void;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    setEarthquakeTransform(x: number, y: number, rotation: number, scale: number): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    playResourceFeedback(feedback: readonly BattleRosterResourceFeedback[], signal: AbortSignal): Promise<void>;
+    prepareBattleEntry(seed: string, offsetX: number): readonly BattleRosterEntryNode[];
+    finishBattleEntry(): void;
+    cancelBattleEntry(): void;
+    reset(): void;
+    destroy(): void;
+    private syncLayout;
+    private syncRoster;
+    private syncRosterNode;
+    private createRosterNode;
+    private playRosterResourceValue;
+    private playRosterDamageShake;
+    private syncRosterName;
+    private syncRosterNameMarquee;
+    private syncRosterHpBar;
+    private syncAvatar;
+    private syncStatusPills;
+    private ensureStatusPill;
+    private createStatusPill;
+    private drawStatusPill;
+    private syncObjectives;
+    private drawObjectiveProgress;
+    private createObjectiveNode;
+    private playObjectiveGlow;
+    private configureObjectiveGlow;
+    private playObjectiveEntrance;
+    private settleObjectiveLifecycle;
+    private startObjectiveExit;
+    private restartObjectiveExit;
+    private destroyObjectiveNode;
+    private syncObjectiveGlowAnimation;
+    private syncTeamChecks;
+    private createTeamCheckNode;
+    private syncRosterGray;
+    private syncRosterStatusEffects;
+    private syncRosterCurrentActorVisuals;
+    private positionCurrentActorShadow;
+    private resolveCurrentActorNumber;
+    private applyCurrentRosterFrame;
+    private applyReturningRosterFrame;
+    private seedFor;
+    private resolveUnitCardMaxVisibleRows;
+    private resolveUnitCardRowGap;
+    private resolveDeadCardBrightness;
+    private resolveTeamCheckIconHeight;
+    private resolveTeamCheckIconGap;
+    private resolveTeamCheckGlowColor;
+    private resolveTeamCheckGlowIntensity;
+    private resolveTeamCheckFogSpeed;
+    private playTeamCheckEntrance;
+    private settleTeamCheckLifecycle;
+    private startTeamCheckExit;
+    private restartTeamCheckExit;
+    private resolveTuningNumber;
+    private resolveFiniteTuningNumber;
+    private resolveTuningColor;
+    private destroyTeamCheckNode;
+    private clearTeamCheckNodes;
+    private syncTeamCheckFogAnimation;
+    private stopTeamCheckFogAnimation;
+    private readonly updateTeamCheckFog;
+    private applyTeamCheckFogFrame;
+    private clearNodes;
+    private restoreBattleEntryPose;
+    private syncRosterPulse;
+}
+export {};

package/dist/PixiBattleLightningResources.d.ts

@@ -0,0 +1,57 @@
+import type { Container, Mesh, MeshGeometry, Shader, UniformGroup } from 'pixi.js';
+import type { PixiBattleFxCapabilities } from './PixiBattleFxResources.js';
+import type { BattleFxPoint } from './BattleActionMotionMath.js';
+export interface PixiBattleLightningHandle {
+    readonly root: Mesh<MeshGeometry, Shader>;
+    readonly geometry: MeshGeometry;
+    readonly shader: Shader;
+    readonly uniforms: UniformGroup<{
+        uColorFx: {
+            value: Float32Array;
+            type: 'vec3<f32>';
+        };
+        uCoreRatio: {
+            value: number;
+            type: 'f32';
+        };
+        uInnerGlowRatio: {
+            value: number;
+            type: 'f32';
+        };
+        uOuterGlowAlpha: {
+            value: number;
+            type: 'f32';
+        };
+    }>;
+    readonly points: Float32Array;
+    readonly positions: Float32Array;
+    from: BattleFxPoint;
+    to: BattleFxPoint;
+    width: number;
+    seed: number;
+    frame: number;
+    generation: number;
+    released: boolean;
+}
+/** One retained strip shades both the narrow core and soft halo in a single pass. */
+export declare class PixiBattleLightningResources {
+    private readonly capabilities;
+    private readonly available;
+    private readonly active;
+    private readonly owned;
+    constructor(capabilities: PixiBattleFxCapabilities);
+    acquire(parent: Container, from: BattleFxPoint, to: BattleFxPoint, options: {
+        color: string;
+        seed: number;
+        width: number;
+        blurStrength: number;
+        outerGlowRadius?: number;
+        outerGlowAlpha?: number;
+    }): PixiBattleLightningHandle | null;
+    update(handle: PixiBattleLightningHandle, frame: number, generation?: number): void;
+    release(handle: PixiBattleLightningHandle | null, generation?: number | undefined): void;
+    reset(): void;
+    destroy(): void;
+    get activeCount(): number;
+    private create;
+}