@zylem/behaviors 0.2.0

package/dist/jumper-3d.d.ts

@@ -0,0 +1,164 @@
+import { J as JumpConfig3D, b as JumpInput3D, a as JumpContext3D, c as JumpState3D } from './components--hjBMTnz.js';
+export { V as Vec3Like, d as createJumpConfig3D, e as createJumpInput3D, f as createJumpState3D } from './components--hjBMTnz.js';
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import 'typescript-fsm';
+
+/**
+ * Jumper 3D Behavior — Pure Jump Physics
+ *
+ * A stateless tick function that receives configuration, input, context, and
+ * state, then applies jump physics through the context's velocity helpers.
+ *
+ * Vertical velocity (Y) is owned exclusively by this behavior.
+ * Horizontal velocity (X/Z) is only touched when airborne planar control
+ * is configured; otherwise the movement controller owns X/Z.
+ */
+
+declare class Jumper3DBehavior {
+    /**
+     * Advance the jump system by one frame.
+     *
+     * Call order within a frame:
+     *   1. Movement controller writes X/Z via transformStore.dirty.velocityX/Z.
+     *   2. `tick()` writes Y via ctx.setVerticalVelocity().
+     *      (Optionally writes X/Z when airborne planar control is active.)
+     */
+    tick(config: JumpConfig3D, input: JumpInput3D, ctx: JumpContext3D, state: JumpState3D): JumperTickResult;
+}
+/** Events emitted by a single tick (used by FSM). */
+declare enum JumperTickEvent {
+    None = "none",
+    Jump = "jump",
+    Fall = "fall",
+    Land = "land"
+}
+interface JumperTickResult {
+    event: JumperTickEvent;
+}
+
+/**
+ * Jumper 3D Finite State Machine
+ *
+ * Three high-level states driven by events emitted from the behavior tick:
+ *   Grounded  ──Jump──▶  Jumping
+ *   Grounded  ──Fall──▶  Falling   (walked off a ledge)
+ *   Jumping   ──Fall──▶  Falling   (apex / descending)
+ *   Jumping   ──Jump──▶  Jumping   (multi-jump)
+ *   Jumping   ──Land──▶  Grounded  (rare — very short hop)
+ *   Falling   ──Land──▶  Grounded
+ *   Falling   ──Jump──▶  Jumping   (air-jump while falling)
+ */
+
+declare enum Jumper3DState {
+    Grounded = "grounded",
+    Jumping = "jumping",
+    Falling = "falling"
+}
+declare enum Jumper3DEvent {
+    Jump = "jump",
+    Fall = "fall",
+    Land = "land"
+}
+interface Jumper3DFSMContext {
+    state: JumpState3D;
+}
+declare class Jumper3DFSM {
+    private ctx;
+    machine: SyncStateMachine<Jumper3DState, Jumper3DEvent, never>;
+    constructor(ctx: Jumper3DFSMContext);
+    getState(): Jumper3DState;
+    dispatch(event: Jumper3DEvent): void;
+    isJumping(): boolean;
+    isFalling(): boolean;
+    isGrounded(): boolean;
+    getJumpsUsed(): number;
+    /**
+     * Translate a tick event into an FSM dispatch.
+     * Also handles the implicit Grounded→Falling transition when the entity
+     * is no longer grounded but no explicit event was emitted (e.g. walked
+     * off a ledge without jumping).
+     */
+    applyTickEvent(tickEvent: string, isGrounded: boolean): void;
+}
+
+interface Jumper3DBehaviorOptions {
+    /** Desired peak height in world units (default: 2.5) */
+    jumpHeight?: number;
+    /** Gravity magnitude applied by the behavior (default: 20) */
+    gravity?: number;
+    /** Terminal fall speed (optional) */
+    maxFallSpeed?: number;
+    /** Max concurrent jumps, 1 = single, 2 = double, etc. (default: 1) */
+    maxJumps?: number;
+    /** Reset jump counter on ground (default: true) */
+    resetJumpsOnGround?: boolean;
+    /** Reset jump counter on wall contact (default: undefined) */
+    resetJumpsOnWall?: boolean;
+    /** Coyote time in ms (default: 100) */
+    coyoteTimeMs?: number;
+    /** Jump buffer in ms (default: 80) */
+    jumpBufferMs?: number;
+    /** Min cooldown between jumps in ms (optional) */
+    minTimeBetweenJumpsMs?: number;
+    /** Variable jump height config (optional) */
+    variableJump?: JumpConfig3D['variableJump'];
+    /** Planar control config (optional) */
+    planar?: JumpConfig3D['planar'];
+    /** Fall tuning (optional) */
+    fall?: JumpConfig3D['fall'];
+    /** Ground-detection ray length (default: 1.0) */
+    groundRayLength?: number;
+    /** Max support distance that counts as grounded and can snap to ground */
+    snapToGroundDistance?: number;
+    /** Enable debug visualization for ground probe rays (default: false) */
+    debugGroundProbe?: boolean;
+}
+interface Jumper3DEntity {
+    uuid: string;
+    body: any;
+    transformStore: any;
+    jumper: JumpConfig3D;
+    $jumper: JumpInput3D;
+    jumperState: JumpState3D;
+}
+/**
+ * Jumper3D — composable 3D jump behavior.
+ *
+ * Provides height-based jumping, multi-jump, coyote time, jump buffering,
+ * variable jump height, configurable fall gravity, and optional air control.
+ *
+ * Designed to compose with any movement controller (e.g. FirstPersonController)
+ * — the controller writes X/Z velocity and Jumper3D writes Y velocity.
+ *
+ * @example
+ * ```typescript
+ * import { Jumper3D } from "@zylem/game-lib/behavior";
+ *
+ * const jumper = player.use(Jumper3D, {
+ *   jumpHeight: 2.5,
+ *   gravity: 20,
+ *   maxJumps: 2,
+ *   coyoteTimeMs: 100,
+ *   jumpBufferMs: 80,
+ *   variableJump: { enabled: true, cutGravityMultiplier: 3 },
+ *   fall: { fallGravityMultiplier: 1.5 },
+ * });
+ *
+ * player.onUpdate(({ inputs }) => {
+ *   player.$jumper.jumpPressed = inputs.p1.buttons.A.pressed;
+ *   player.$jumper.jumpHeld = inputs.p1.buttons.A.held > 0;
+ *   player.$jumper.jumpReleased = inputs.p1.buttons.A.released;
+ *
+ *   const state = jumper.getState();  // Grounded | Jumping | Falling
+ * });
+ * ```
+ */
+declare const Jumper3D: BehaviorDescriptor<Jumper3DBehaviorOptions, {
+    getState: () => Jumper3DState;
+    isJumping: () => boolean;
+    getJumpsUsed: () => number;
+    getJumpsRemaining: () => number;
+}, Jumper3DEntity>;
+
+export { JumpConfig3D, JumpContext3D, JumpInput3D, JumpState3D, Jumper3D, Jumper3DBehavior, type Jumper3DBehaviorOptions, type Jumper3DEntity, Jumper3DEvent, Jumper3DFSM, Jumper3DState, JumperTickEvent, type JumperTickResult };

package/dist/jumper-3d.js

@@ -0,0 +1,29 @@
+import {
+  Jumper3D,
+  Jumper3DBehavior,
+  Jumper3DEvent,
+  Jumper3DFSM,
+  Jumper3DState,
+  JumperTickEvent
+} from "./chunk-F3KRX2V4.js";
+import {
+  createJumpConfig3D,
+  createJumpInput3D,
+  createJumpState3D
+} from "./chunk-DYLH6K7B.js";
+import "./chunk-SVLNF434.js";
+import "./chunk-RTVRUNYR.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  Jumper3D,
+  Jumper3DBehavior,
+  Jumper3DEvent,
+  Jumper3DFSM,
+  Jumper3DState,
+  JumperTickEvent,
+  createJumpConfig3D,
+  createJumpInput3D,
+  createJumpState3D
+};
+//# sourceMappingURL=jumper-3d.js.map

package/dist/jumper-3d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/moveable-BCRpjAQb.d.ts

@@ -0,0 +1,176 @@
+import { Vector3 } from 'three';
+import { RigidBody, Vector } from '@dimforge/rapier3d-compat';
+
+type VelocityIntentMode = 'replace' | 'add';
+interface VelocityIntent {
+    x?: number;
+    y?: number;
+    z?: number;
+    mode: VelocityIntentMode;
+    priority?: number;
+}
+/**
+ * Transform state managed by Valtio for batched physics updates.
+ *
+ * This store accumulates transformation intents during the frame,
+ * then applies them all at once after onUpdate() callbacks complete.
+ *
+ * Design decisions:
+ * - Position: Accumulated deltas (additive)
+ * - Rotation: Last value wins (replacement)
+ * - Velocity: Accumulated deltas (additive)
+ * - Angular velocity: Accumulated deltas (additive)
+ */
+interface TransformState {
+    /** Position deltas to be applied (accumulated) */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Rotation quaternion (last value wins) */
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    /** Linear velocity (accumulated) */
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Angular velocity (accumulated) */
+    angularVelocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Per-source velocity intents composed once per frame */
+    velocityChannels: Record<string, VelocityIntent>;
+    /** Dirty flags to track what needs to be applied */
+    dirty: {
+        position: boolean;
+        rotation: boolean;
+        /** @deprecated Use per-axis velocityX/Y/Z flags for new code */
+        velocity: boolean;
+        velocityX: boolean;
+        velocityY: boolean;
+        velocityZ: boolean;
+        velocityChannels: boolean;
+        angularVelocity: boolean;
+    };
+}
+/**
+ * Create a new transform store with optional initial values.
+ * The store is a Valtio proxy, making it reactive for debugging/visualization.
+ *
+ * @param initial Optional initial state values
+ * @returns Reactive transform state
+ */
+declare function createTransformStore(initial?: Partial<TransformState>): TransformState;
+/**
+ * Reset a transform store to its initial clean state.
+ * Called after applying changes to prepare for the next frame.
+ *
+ * @param store The transform store to reset
+ */
+declare function resetTransformStore(store: TransformState): void;
+
+interface EntityWithBody {
+    body: RigidBody | null;
+    transformStore?: TransformState;
+}
+/**
+ * Move an entity along the X axis, preserving other velocities.
+ */
+declare function moveX(entity: EntityWithBody, delta: number): void;
+/**
+ * Move an entity along the Y axis, preserving other velocities.
+ */
+declare function moveY(entity: EntityWithBody, delta: number): void;
+/**
+ * Move an entity along the Z axis, preserving other velocities.
+ */
+declare function moveZ(entity: EntityWithBody, delta: number): void;
+/**
+ * Move an entity along the X and Y axis, preserving Z velocity.
+ */
+declare function moveXY(entity: EntityWithBody, deltaX: number, deltaY: number): void;
+/**
+ * Move an entity along the X and Z axis, preserving Y velocity.
+ */
+declare function moveXZ(entity: EntityWithBody, deltaX: number, deltaZ: number): void;
+/**
+ * Move entity based on a vector, adding to existing velocities.
+ */
+declare function move(entity: EntityWithBody, vector: Vector3): void;
+/**
+ * Reset entity velocity
+ */
+declare function resetVelocity(entity: EntityWithBody): void;
+/**
+ * Move entity forward in 2D space, preserving Z velocity
+ */
+declare function moveForwardXY(entity: EntityWithBody, delta: number, rotation2DAngle: number): void;
+/**
+ * Get entity position
+ */
+declare function getPosition(entity: EntityWithBody): Vector | null;
+/**
+ * Get entity velocity
+ */
+declare function getVelocity(entity: EntityWithBody): Vector | null;
+/**
+ * Set entity position
+ */
+declare function setPosition(entity: EntityWithBody, x: number, y: number, z: number): void;
+/**
+ * Set entity X position
+ */
+declare function setPositionX(entity: EntityWithBody, x: number): void;
+/**
+ * Set entity Y position
+ */
+declare function setPositionY(entity: EntityWithBody, y: number): void;
+/**
+ * Set entity Z position
+ */
+declare function setPositionZ(entity: EntityWithBody, z: number): void;
+/**
+ * Wrap entity around 2D bounds
+ */
+declare function wrapAroundXY(entity: EntityWithBody, boundsX: number, boundsY: number): void;
+/**
+ * Wrap entity around 3D bounds
+ */
+declare function wrapAround3D(entity: EntityWithBody, boundsX: number, boundsY: number, boundsZ: number): void;
+/**
+ * Enhanced moveable entity with bound methods
+ */
+interface MoveableEntity extends EntityWithBody {
+    moveX(delta: number): void;
+    moveY(delta: number): void;
+    moveZ(delta: number): void;
+    moveXY(deltaX: number, deltaY: number): void;
+    moveXZ(deltaX: number, deltaZ: number): void;
+    move(vector: Vector3): void;
+    resetVelocity(): void;
+    moveForwardXY(delta: number, rotation2DAngle: number): void;
+    getPosition(): Vector | null;
+    getVelocity(): Vector | null;
+    setPosition(x: number, y: number, z: number): void;
+    setPositionX(x: number): void;
+    setPositionY(y: number): void;
+    setPositionZ(z: number): void;
+    wrapAroundXY(boundsX: number, boundsY: number): void;
+    wrapAround3D(boundsX: number, boundsY: number, boundsZ: number): void;
+}
+/**
+ * Enhance an entity with additive movement methods.
+ * Automatically creates a transform store if one doesn't exist.
+ */
+declare function makeMoveable<T extends EntityWithBody>(entity: T): T & MoveableEntity;
+
+export { type EntityWithBody as E, type MoveableEntity as M, type TransformState as T, type VelocityIntent as V, type VelocityIntentMode as a, getVelocity as b, createTransformStore as c, move as d, moveForwardXY as e, moveX as f, getPosition as g, moveXY as h, moveXZ as i, moveY as j, moveZ as k, resetVelocity as l, makeMoveable as m, setPositionX as n, setPositionY as o, setPositionZ as p, wrapAroundXY as q, resetTransformStore as r, setPosition as s, wrapAround3D as w };

package/dist/particle-emitter/presets.d.ts

@@ -0,0 +1,46 @@
+import { j as arcane, q as holy, l as corrupted, t as nature, I as voidMagic, w as psychic, A as spark, i as arc, F as surge, x as pulse, E as storm, H as vapor, y as smoke, p as haze, v as plume, r as miasma, s as mist, D as spray, C as splash, m as drizzle, G as torrent, B as spark$1, n as ember, o as flamelet, k as blaze, z as smolder } from '../spark-DDlIg1nM.js';
+import 'three';
+import 'three.quarks';
+
+declare const magicPresets: {
+    readonly arcane: typeof arcane;
+    readonly holy: typeof holy;
+    readonly corrupted: typeof corrupted;
+    readonly nature: typeof nature;
+    readonly void: typeof voidMagic;
+    readonly psychic: typeof psychic;
+};
+
+declare const electricityPresets: {
+    readonly spark: typeof spark;
+    readonly arc: typeof arc;
+    readonly surge: typeof surge;
+    readonly pulse: typeof pulse;
+    readonly storm: typeof storm;
+};
+
+declare const gasPresets: {
+    readonly vapor: typeof vapor;
+    readonly smoke: typeof smoke;
+    readonly haze: typeof haze;
+    readonly plume: typeof plume;
+    readonly miasma: typeof miasma;
+};
+
+declare const waterPresets: {
+    readonly mist: typeof mist;
+    readonly spray: typeof spray;
+    readonly splash: typeof splash;
+    readonly drizzle: typeof drizzle;
+    readonly torrent: typeof torrent;
+};
+
+declare const firePresets: {
+    readonly spark: typeof spark$1;
+    readonly ember: typeof ember;
+    readonly flamelet: typeof flamelet;
+    readonly blaze: typeof blaze;
+    readonly smolder: typeof smolder;
+};
+
+export { electricityPresets, firePresets, gasPresets, magicPresets, waterPresets };

package/dist/particle-emitter/presets.js

@@ -0,0 +1,15 @@
+import {
+  electricityPresets,
+  firePresets,
+  gasPresets,
+  magicPresets,
+  waterPresets
+} from "../chunk-GYURWCIQ.js";
+export {
+  electricityPresets,
+  firePresets,
+  gasPresets,
+  magicPresets,
+  waterPresets
+};
+//# sourceMappingURL=presets.js.map

package/dist/particle-emitter/presets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/particle-emitter.d.ts

@@ -0,0 +1,78 @@
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { i as Vec3Input } from './vector-Bm65-FOG.js';
+import { ParticleSystem } from 'three.quarks';
+import { h as ParticlePresetMaterialOptions, P as ParticleEffectDefinition, B as spark, n as ember, o as flamelet, k as blaze, z as smolder, s as mist, D as spray, C as splash, m as drizzle, G as torrent, H as vapor, y as smoke, p as haze, v as plume, r as miasma, A as spark$1, i as arc, F as surge, x as pulse, E as storm, j as arcane, q as holy, l as corrupted, t as nature, I as voidMagic, w as psychic } from './spark-DDlIg1nM.js';
+export { a as ParticleMagicAgency, b as ParticleMagicAlignment, c as ParticleMagicModifierInput, d as ParticleMagicModifierOptions, e as ParticleMagicOrder, f as ParticleMagicRealityEffect, g as ParticleMagicTemperament, S as SemanticParticlePresetOptions, u as particleEffect } from './spark-DDlIg1nM.js';
+import { ColorRepresentation } from 'three';
+import '@dimforge/rapier3d-compat';
+
+interface BurstParticlePresetOptions extends ParticlePresetMaterialOptions {
+    color?: ColorRepresentation;
+    count?: number;
+    duration?: number;
+    life?: number | readonly [number, number];
+    size?: number | readonly [number, number];
+    speed?: number | readonly [number, number];
+    worldSpace?: boolean;
+}
+declare const particlePresets: {
+    readonly burst: (options?: BurstParticlePresetOptions) => ParticleEffectDefinition;
+    readonly smoke: (options?: BurstParticlePresetOptions) => ParticleEffectDefinition;
+    readonly fire: {
+        readonly spark: typeof spark;
+        readonly ember: typeof ember;
+        readonly flamelet: typeof flamelet;
+        readonly blaze: typeof blaze;
+        readonly smolder: typeof smolder;
+    };
+    readonly water: {
+        readonly mist: typeof mist;
+        readonly spray: typeof spray;
+        readonly splash: typeof splash;
+        readonly drizzle: typeof drizzle;
+        readonly torrent: typeof torrent;
+    };
+    readonly gas: {
+        readonly vapor: typeof vapor;
+        readonly smoke: typeof smoke;
+        readonly haze: typeof haze;
+        readonly plume: typeof plume;
+        readonly miasma: typeof miasma;
+    };
+    readonly electricity: {
+        readonly spark: typeof spark$1;
+        readonly arc: typeof arc;
+        readonly surge: typeof surge;
+        readonly pulse: typeof pulse;
+        readonly storm: typeof storm;
+    };
+    readonly magic: {
+        readonly arcane: typeof arcane;
+        readonly holy: typeof holy;
+        readonly corrupted: typeof corrupted;
+        readonly nature: typeof nature;
+        readonly void: typeof voidMagic;
+        readonly psychic: typeof psychic;
+    };
+};
+
+interface ParticleEmitterBehaviorOptions {
+    effect: ParticleEffectDefinition;
+    autoplay: boolean;
+    localOffset?: Vec3Input;
+    followPosition: boolean;
+    followRotation: boolean;
+    autoDestroy: boolean;
+}
+interface ParticleEmitterHandle {
+    play(): void;
+    stop(): void;
+    pause(): void;
+    restart(): void;
+    burst(): void;
+    isPlaying(): boolean;
+    getSystem(): ParticleSystem | null;
+}
+declare const ParticleEmitterBehavior: BehaviorDescriptor<ParticleEmitterBehaviorOptions, ParticleEmitterHandle, unknown>;
+
+export { type BurstParticlePresetOptions, ParticleEffectDefinition, ParticleEmitterBehavior, type ParticleEmitterBehaviorOptions, type ParticleEmitterHandle, ParticlePresetMaterialOptions, particlePresets };

package/dist/particle-emitter.js

@@ -0,0 +1,15 @@
+import {
+  ParticleEmitterBehavior,
+  particlePresets
+} from "./chunk-POZER3MQ.js";
+import {
+  particleEffect
+} from "./chunk-GYURWCIQ.js";
+import "./chunk-WWVD5DR5.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  ParticleEmitterBehavior,
+  particleEffect,
+  particlePresets
+};
+//# sourceMappingURL=particle-emitter.js.map

package/dist/particle-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/payload-BQzu-oY_.d.ts

@@ -0,0 +1,89 @@
+import { DestructibleMesh, FractureOptions } from '@dgreenheck/three-pinata';
+import { BufferGeometry, Vector3, Quaternion } from 'three';
+
+/**
+ * Serializable payloads for destructible Voronoi prebake in a Web Worker.
+ */
+
+interface PlainBufferGeometryPayload {
+    attributes: Record<string, {
+        array: ArrayBuffer;
+        itemSize: number;
+        normalized?: boolean;
+    }>;
+}
+type PlainFractureOptions = {
+    fractureMethod: 'voronoi' | 'simple';
+    fragmentCount: number;
+    fracturePlanes: {
+        x: boolean;
+        y: boolean;
+        z: boolean;
+    };
+    textureScale: [number, number];
+    textureOffset: [number, number];
+    seed?: number;
+    voronoiOptions?: {
+        mode: '3D' | '2.5D';
+        seedPoints?: [number, number, number][];
+        impactPoint?: [number, number, number];
+        impactRadius?: number;
+        projectionAxis?: 'x' | 'y' | 'z' | 'auto' | null;
+        projectionNormal?: [number, number, number];
+        useApproximation: boolean;
+        approximationNeighborCount: number;
+    };
+};
+type PlainWorkerFragmentPayload = {
+    attributes: PlainBufferGeometryPayload['attributes'];
+    position: [number, number, number];
+    quaternion: [number, number, number, number];
+    scale: [number, number, number];
+};
+type PrebakeWorkerRequest = {
+    geometry: PlainBufferGeometryPayload;
+    options: PlainFractureOptions;
+};
+type PrebakeWorkerResponse = {
+    fragments: PlainWorkerFragmentPayload[];
+};
+interface DestructiblePrebakeWorkerAPI {
+    prebake(request: PrebakeWorkerRequest): Promise<PrebakeWorkerResponse>;
+}
+/**
+ * Copies a buffer geometry into detached ArrayBuffers suitable for postMessage transfer.
+ */
+declare function bufferGeometryToPlain(geometry: BufferGeometry): {
+    payload: PlainBufferGeometryPayload;
+    transferables: ArrayBuffer[];
+};
+/**
+ * Rebuilds a BufferGeometry from a plain payload (e.g. in a worker).
+ */
+declare function plainToBufferGeometry(payload: PlainBufferGeometryPayload): BufferGeometry;
+/**
+ * Serializes {@link FractureOptions} for structured clone / worker transfer.
+ */
+declare function pinataFractureOptionsToPlain(options: FractureOptions): PlainFractureOptions;
+/**
+ * Reconstructs {@link FractureOptions} from a plain payload.
+ */
+declare function plainFractureOptionsToPinata(plain: PlainFractureOptions): FractureOptions;
+/**
+ * Converts worker response fragments into template parts for the main-thread cache.
+ */
+declare function plainWorkerResultToTemplateParts(response: PrebakeWorkerResponse): Array<{
+    geometry: BufferGeometry;
+    position: Vector3;
+    quaternion: Quaternion;
+    scale: Vector3;
+}>;
+/**
+ * Serializes fracture fragments for Comlink.transfer (used in the worker).
+ */
+declare function destructibleFragmentsToPlainResponse(fragments: readonly DestructibleMesh[]): {
+    response: PrebakeWorkerResponse;
+    transferables: ArrayBuffer[];
+};
+
+export { type DestructiblePrebakeWorkerAPI as D, type PlainBufferGeometryPayload as P, type PlainFractureOptions as a, type PlainWorkerFragmentPayload as b, type PrebakeWorkerRequest as c, type PrebakeWorkerResponse as d, bufferGeometryToPlain as e, destructibleFragmentsToPlainResponse as f, plainFractureOptionsToPinata as g, plainToBufferGeometry as h, plainWorkerResultToTemplateParts as i, pinataFractureOptionsToPlain as p };