@sparkjsdev/spark 2.2.0 → 2.3.0

package/dist/types/defines.d.ts

@@ -15,8 +15,6 @@ export declare const SPLAT_TEX_MIN_HEIGHT = 1;
 export declare const SPLAT_TEX_WIDTH_MASK: number;
 export declare const SPLAT_TEX_HEIGHT_MASK: number;
 export declare const SPLAT_TEX_DEPTH_MASK: number;
-export declare const WASM_SPLAT_SORT = true;
-export declare const USE_COMPILED_PARSER_FUNCTION = true;
 export declare enum SplatFileType {
     PLY = "ply",
     SPZ = "spz",
@@ -27,61 +25,61 @@ export declare enum SplatFileType {
     RAD = "rad"
 }
 export type SplatEncoding = {
-    rgbMin?: number;
-    rgbMax?: number;
-    lnScaleMin?: number;
-    lnScaleMax?: number;
-    sh1Max?: number;
-    sh2Max?: number;
-    sh3Max?: number;
-    lodOpacity?: boolean;
+    rgbMin: number;
+    rgbMax: number;
+    lnScaleMin: number;
+    lnScaleMax: number;
+    sh1Max: number;
+    sh2Max: number;
+    sh3Max: number;
+    lodOpacity: boolean;
 };
 export declare const DEFAULT_SPLAT_ENCODING: SplatEncoding;
 export type RadMeta = {
-    version: number;
-    type: string;
-    count: number;
-    maxSh?: number;
-    lodTree?: boolean;
-    chunkSize?: number;
-    chunks: {
-        offset: number;
-        bytes: number;
-        base?: number;
-        count?: number;
-        filename?: string;
+    readonly version: number;
+    readonly type: string;
+    readonly count: number;
+    readonly maxSh?: number;
+    readonly lodTree?: boolean;
+    readonly chunkSize?: number;
+    readonly chunks: {
+        readonly offset: number;
+        readonly bytes: number;
+        readonly base?: number;
+        readonly count?: number;
+        readonly filename?: string;
     }[];
-    splatEncoding?: SplatEncoding;
+    readonly splatEncoding?: SplatEncoding;
 };
 export type PackedExtra = {
-    sh1?: Uint32Array;
-    sh2?: Uint32Array;
-    sh3?: Uint32Array;
-    sh1Codes?: Uint32Array;
-    sh2Codes?: Uint32Array;
-    sh3Codes?: Uint32Array;
-    lodTree?: Uint32Array;
-    radMeta?: RadMeta;
+    readonly sh1?: Uint32Array;
+    readonly sh2?: Uint32Array;
+    readonly sh3?: Uint32Array;
+    readonly sh1Codes?: Uint32Array;
+    readonly sh2Codes?: Uint32Array;
+    readonly sh3Codes?: Uint32Array;
+    readonly lodTree?: Uint32Array;
+    readonly radMeta?: RadMeta;
 };
 export type PackedResult = {
-    numSplats: number;
-    packedArray: Uint32Array;
-    extra: PackedExtra;
-    splatEncoding: SplatEncoding;
+    readonly numSplats: number;
+    readonly packedArray: Uint32Array;
+    readonly extra: PackedExtra;
+    readonly splatEncoding: SplatEncoding;
 };
 export type ExtExtra = {
-    sh1?: Uint32Array;
-    sh2?: Uint32Array;
-    sh3a?: Uint32Array;
-    sh3b?: Uint32Array;
-    sh1Codes?: Uint32Array;
-    sh2Codes?: Uint32Array;
-    sh3Codes?: [Uint32Array, Uint32Array];
-    lodTree?: Uint32Array;
-    radMeta?: RadMeta;
+    readonly sh1?: Uint32Array;
+    readonly sh2?: Uint32Array;
+    readonly sh3a?: Uint32Array;
+    readonly sh3b?: Uint32Array;
+    readonly sh1Codes?: Uint32Array;
+    readonly sh2Codes?: Uint32Array;
+    readonly sh3Codes?: [Uint32Array, Uint32Array];
+    readonly lodTree?: Uint32Array;
+    readonly radMeta?: RadMeta;
 };
 export type ExtResult = {
-    numSplats: number;
-    extArrays: [Uint32Array, Uint32Array];
-    extra: ExtExtra;
+    readonly numSplats: number;
+    readonly extArrays: [Uint32Array, Uint32Array];
+    readonly extra: ExtExtra;
 };

package/dist/types/dyno/base.d.ts

@@ -1,6 +1,6 @@
-import { IUniform } from 'three';
-import { DynoType } from './types';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import type { IUniform } from "three";
+import type { DynoType } from "./types";
+import { type DynoVal, DynoValue, type HasDynoOut } from "./value";
 export declare class Compilation {
     globals: Set<string>;
     statements: string[];

package/dist/types/dyno/convert.d.ts

@@ -1,6 +1,6 @@
-import { UnaryOp } from './base';
-import { SimpleTypes } from './types';
-import { DynoVal } from './value';
+import { UnaryOp } from "./base";
+import { type SimpleTypes } from "./types";
+import type { DynoVal } from "./value";
 export declare const bool: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"bool">;
 export declare const int: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"int">;
 export declare const uint: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"uint">;

package/dist/types/dyno/logic.d.ts

@@ -1,6 +1,6 @@
-import { BinaryOp, TrinaryOp, UnaryOp } from './base';
-import { AllIntTypes, BoolTypes, IntTypes, ScalarTypes, SimpleTypes, UintTypes, ValueTypes } from './types';
-import { DynoVal } from './value';
+import { BinaryOp, TrinaryOp, UnaryOp } from "./base";
+import { type AllIntTypes, type BoolTypes, type IntTypes, type ScalarTypes, type SimpleTypes, type UintTypes, type ValueTypes } from "./types";
+import { type DynoVal } from "./value";
 export declare const and: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;
 export declare const or: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;
 export declare const xor: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;

package/dist/types/dyno/math.d.ts

@@ -1,7 +1,7 @@
-import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from './base';
-import { AddOutput, ClampOutput, DivOutput, IModOutput, IsInfOutput, IsNanOutput, MaxOutput, MinOutput, MixOutput, ModOutput, MulOutput, SmoothstepOutput, StepOutput, SubOutput } from './mathTypes';
-import { AllIntTypes, AllSignedTypes, AllValueTypes, BoolTypes, FloatTypes, SignedTypes, ValueTypes } from './types';
-import { DynoVal } from './value';
+import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from "./base";
+import { type AddOutput, type ClampOutput, type DivOutput, type IModOutput, type IsInfOutput, type IsNanOutput, type MaxOutput, type MinOutput, type MixOutput, type ModOutput, type MulOutput, type SmoothstepOutput, type StepOutput, type SubOutput } from "./mathTypes";
+import type { AllIntTypes, AllSignedTypes, AllValueTypes, BoolTypes, FloatTypes, SignedTypes, ValueTypes } from "./types";
+import { type DynoVal } from "./value";
 export declare const add: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<AddOutput<A, B>>;
 export declare const sub: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<SubOutput<A, B>>;
 export declare const mul: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<MulOutput<A, B>>;

package/dist/types/dyno/mathTypes.d.ts

@@ -1,4 +1,4 @@
-import { AllFloatTypes, AllIntTypes, AllSignedTypes, AllValueTypes, BaseType, BoolTypes, FloatTypes, IntTypes, SignedTypes, UintTypes, ValueTypes } from './types';
+import { type AllFloatTypes, type AllIntTypes, type AllSignedTypes, type AllValueTypes, type BaseType, type BoolTypes, type FloatTypes, type IntTypes, type SignedTypes, type UintTypes, type ValueTypes } from "./types";
 export type AddOutput<A extends AllValueTypes, B extends AllValueTypes> = BaseType & (A extends B ? A : A extends "int" ? B extends IntTypes ? B : never : B extends "int" ? A extends IntTypes ? A : never : A extends "uint" ? B extends UintTypes ? B : never : B extends "uint" ? A extends UintTypes ? A : never : A extends "float" ? B extends AllFloatTypes ? B : never : B extends "float" ? A extends AllFloatTypes ? A : never : never);
 export type SubOutput<A extends AllValueTypes, B extends AllValueTypes> = AddOutput<A, B>;
 export type MulOutput<A extends AllValueTypes, B extends AllValueTypes> = BaseType & (A extends "int" ? B extends IntTypes ? B : never : B extends "int" ? A extends IntTypes ? A : never : A extends "uint" ? B extends UintTypes ? B : never : B extends "uint" ? A extends UintTypes ? A : never : A extends "float" ? B extends AllFloatTypes ? B : never : B extends "float" ? A extends AllFloatTypes ? A : never : A extends IntTypes ? B extends A ? A : never : B extends IntTypes ? A extends B ? A : never : A extends UintTypes ? B extends A ? A : never : B extends UintTypes ? A extends B ? A : never : A extends "vec2" ? B extends "vec2" | "mat2" | "mat2x2" ? "vec2" : B extends "mat3x2" ? "vec3" : B extends "mat4x2" ? "vec4" : never : A extends "vec3" ? B extends "mat2x3" ? "vec2" : B extends "vec3" | "mat3" | "mat3x3" ? "vec3" : B extends "mat4x3" ? "vec4" : never : A extends "vec4" ? B extends "mat2x4" ? "vec2" : B extends "mat3x4" ? "vec3" : B extends "vec4" | "mat4" | "mat4x4" ? "vec4" : never : B extends "vec2" ? A extends "mat2" | "mat2x2" ? "vec2" : A extends "mat2x3" ? "vec3" : A extends "mat2x4" ? "vec4" : never : B extends "vec3" ? A extends "mat3x2" ? "vec2" : A extends "mat3" | "mat3x3" ? "vec3" : A extends "mat3x4" ? "vec4" : never : B extends "vec4" ? A extends "mat4x2" ? "vec2" : A extends "mat4x3" ? "vec3" : A extends "mat4" | "mat4x4" ? "vec4" : never : A extends "mat2" | "mat2x2" ? B extends "mat2" | "mat2x2" ? "mat2" : B extends "mat3x2" ? "mat3x2" : B extends "mat4x2" ? "mat4x2" : never : A extends "mat2x3" ? B extends "mat2" | "mat2x2" ? "mat2x3" : B extends "mat3x2" ? "mat3" : B extends "mat4x2" ? "mat4x3" : never : A extends "mat2x4" ? B extends "mat2" | "mat2x2" ? "mat2x4" : B extends "mat3x2" ? "mat3x4" : B extends "mat4x2" ? "mat4" : never : A extends "mat3x2" ? B extends "mat2x3" ? "mat2" : B extends "mat3" | "mat3x3" ? "mat3x2" : B extends "mat4x3" ? "mat4x2" : never : A extends "mat3" | "mat3x3" ? B extends "mat2x3" ? "mat2x3" : B extends "mat3" | "mat3x3" ? "mat3" : B extends "mat4x3" ? "mat4x3" : never : A extends "mat3x4" ? B extends "mat2x3" ? "mat2x4" : B extends "mat3" | "mat3x3" ? "mat3x4" : B extends "mat4x3" ? "mat4" : never : A extends "mat4x2" ? B extends "mat2x4" ? "mat2" : B extends "mat3x4" ? "mat3x2" : B extends "mat4" | "mat4x4" ? "mat4x2" : never : A extends "mat4x3" ? B extends "mat2x4" ? "mat2x3" : B extends "mat3x4" ? "mat3" : B extends "mat4" | "mat4x4" ? "mat4x3" : never : A extends "mat4" | "mat4x4" ? B extends "mat2x4" ? "mat2x4" : B extends "mat3x4" ? "mat3x4" : B extends "mat4" | "mat4x4" ? "mat4" : never : never);

package/dist/types/dyno/output.d.ts

@@ -1,6 +1,6 @@
-import { Dyno } from './base';
-import { CovSplat, Gsplat } from './splats';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import { Dyno } from "./base";
+import { CovSplat, Gsplat } from "./splats";
+import { type DynoVal, type DynoValue, type HasDynoOut } from "./value";
 export declare const outputPackedSplat: (gsplat: DynoVal<typeof Gsplat>, rgbMinMaxLnScaleMinMax: DynoVal<"vec4">) => OutputPackedSplat;
 export declare const outputCovSplat: (covsplat: DynoVal<typeof CovSplat>, rgbMinMaxLnScaleMinMax: DynoVal<"vec4">) => OutputCovSplat;
 export declare const outputExtendedSplat: (gsplat: DynoVal<typeof Gsplat>) => OutputExtendedSplat;

package/dist/types/dyno/program.d.ts

@@ -1,5 +1,5 @@
-import { Dyno, IOTypes } from './base';
 import * as THREE from "three";
+import { type Dyno, type IOTypes } from "./base";
 export declare class DynoProgram {
     graph: Dyno<IOTypes, IOTypes>;
     template: DynoProgramTemplate;

package/dist/types/dyno/splats.d.ts

@@ -1,5 +1,5 @@
-import { Dyno, UnaryOp } from './base';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import { Dyno, UnaryOp } from "./base";
+import { type DynoVal, type DynoValue, type HasDynoOut } from "./value";
 export declare const Gsplat: {
     type: "Gsplat";
 };

package/dist/types/dyno/texture.d.ts

@@ -1,6 +1,6 @@
-import { Dyno } from './base';
-import { AllSamplerTypes, IsamplerTypes, NormalSamplerTypes, Sampler2DArrayTypes, Sampler2DTypes, Sampler3DTypes, SamplerCubeTypes, SamplerShadowTypes, SamplerTypes, UsamplerTypes } from './types';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import { Dyno } from "./base";
+import type { AllSamplerTypes, IsamplerTypes, NormalSamplerTypes, Sampler2DArrayTypes, Sampler2DTypes, Sampler3DTypes, SamplerCubeTypes, SamplerShadowTypes, SamplerTypes, UsamplerTypes } from "./types";
+import { type DynoVal, type DynoValue, type HasDynoOut } from "./value";
 export declare const textureSize: <T extends AllSamplerTypes>(texture: DynoVal<T>, lod?: DynoVal<"int">) => DynoVal<TextureSizeType<T>>;
 export declare const texture: <T extends AllSamplerTypes>(texture: DynoVal<T>, coord: DynoVal<TextureCoordType<T>>, bias?: DynoVal<"float">) => DynoVal<TextureReturnType<T>>;
 export declare const texelFetch: <T extends NormalSamplerTypes>(texture: DynoVal<T>, coord: DynoVal<TextureSizeType<T>>, lod?: DynoVal<"int">) => DynoVal<TextureReturnType<T>>;

package/dist/types/dyno/transform.d.ts

@@ -1,5 +1,5 @@
-import { Dyno } from './base';
-import { DynoVal } from './value';
+import { Dyno } from "./base";
+import type { DynoVal } from "./value";
 export declare const transformPos: (position: DynoVal<"vec3">, { scale, scales, rotate, translate, }: {
     scale?: DynoVal<"float">;
     scales?: DynoVal<"vec3">;

package/dist/types/dyno/trig.d.ts

@@ -1,6 +1,6 @@
-import { BinaryOp, UnaryOp } from './base';
-import { FloatTypes } from './types';
-import { DynoVal } from './value';
+import { BinaryOp, UnaryOp } from "./base";
+import type { FloatTypes } from "./types";
+import type { DynoVal } from "./value";
 export declare const radians: <A extends FloatTypes>(degrees: DynoVal<A>) => DynoVal<A>;
 export declare const degrees: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;
 export declare const sin: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;

package/dist/types/dyno/uniforms.d.ts

@@ -1,6 +1,6 @@
-import { Dyno } from './base';
-import { DynoJsType, DynoType } from './types';
-import { DynoValue, HasDynoOut } from './value';
+import { Dyno } from "./base";
+import type { DynoJsType, DynoType } from "./types";
+import { type DynoValue, type HasDynoOut } from "./value";
 export declare const uniform: <V extends DynoJsType<DynoType>>(key: string, type: DynoType, value: V) => DynoUniform<DynoType, string, V>;
 export declare const dynoBool: (value?: boolean, key?: string) => DynoBool<string>;
 export declare const dynoUint: (value?: number, key?: string) => DynoUint<string>;

package/dist/types/dyno/util.d.ts

@@ -1,6 +1,6 @@
-import { Dyno, DynoBlock } from './base';
-import { ValueTypes } from './types';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import { Dyno, DynoBlock } from "./base";
+import { type ValueTypes } from "./types";
+import { type DynoVal, type DynoValue, type HasDynoOut } from "./value";
 export declare const remapIndex: (index: DynoVal<"int">, from: DynoVal<"int">, to: DynoVal<"int">) => DynoVal<"int">;
 export declare const pcgMix: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uint">;
 export declare const pcgNext: (state: DynoVal<"uint">) => DynoVal<"uint">;

package/dist/types/dyno/value.d.ts

@@ -1,5 +1,5 @@
-import { Dyno, IOTypes } from './base';
-import { DynoJsType, DynoType, SimpleTypes } from './types';
+import type { Dyno, IOTypes } from "./base";
+import { type DynoJsType, type DynoType, type SimpleTypes } from "./types";
 export type DynoVal<T extends DynoType> = DynoValue<T> | HasDynoOut<T>;
 export declare function valType<T extends DynoType>(val: DynoVal<T>): T;
 export interface HasDynoOut<T extends DynoType> {

package/dist/types/dyno/vecmat.d.ts

@@ -1,6 +1,6 @@
-import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from './base';
-import { FloatTypes, IntTypes, MatFloatTypes, SquareMatTypes, UintTypes, VectorElementType, VectorTypes } from './types';
-import { DynoVal, DynoValue, HasDynoOut } from './value';
+import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from "./base";
+import { type FloatTypes, type IntTypes, type MatFloatTypes, type SquareMatTypes, type UintTypes, type VectorElementType, type VectorTypes } from "./types";
+import { type DynoVal, type DynoValue, type HasDynoOut } from "./value";
 export declare const length: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>) => DynoVal<"float">;
 export declare const distance: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<"float">;
 export declare const dot: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<"float">;

package/dist/types/dyno.d.ts

@@ -1,16 +1,16 @@
-export * from './dyno/types';
-export * from './dyno/base';
-export * from './dyno/value';
-export * from './dyno/output';
-export * from './dyno/uniforms';
-export * from './dyno/program';
-export * from './dyno/math';
-export * from './dyno/logic';
-export * from './dyno/util';
-export * from './dyno/splats';
-export * from './dyno/transform';
-export * from './dyno/control';
-export * from './dyno/convert';
-export * from './dyno/texture';
-export * from './dyno/trig';
-export * from './dyno/vecmat';
+export * from "./dyno/types";
+export * from "./dyno/base";
+export * from "./dyno/value";
+export * from "./dyno/output";
+export * from "./dyno/uniforms";
+export * from "./dyno/program";
+export * from "./dyno/math";
+export * from "./dyno/logic";
+export * from "./dyno/util";
+export * from "./dyno/splats";
+export * from "./dyno/transform";
+export * from "./dyno/control";
+export * from "./dyno/convert";
+export * from "./dyno/texture";
+export * from "./dyno/trig";
+export * from "./dyno/vecmat";

package/dist/types/generators/snow.d.ts

@@ -1,5 +1,5 @@
-import { SplatGenerator } from '../SplatGenerator';
 import * as THREE from "three";
+import { SplatGenerator } from "../SplatGenerator";
 export declare const DEFAULT_SNOW: {
     box: THREE.Box3;
     density: number;
@@ -48,18 +48,18 @@ export declare function snowBox({ box, minY, numSplats, density, anisoScale, min
     }) => void;
 }): {
     snow: SplatGenerator;
-    min: import('../dyno').DynoVec3<THREE.Vector3, string>;
-    max: import('../dyno').DynoVec3<THREE.Vector3, string>;
-    minY: import('../dyno').DynoFloat<string>;
-    color1: import('../dyno').DynoVec3<THREE.Color, string>;
-    color2: import('../dyno').DynoVec3<THREE.Color, string>;
-    opacity: import('../dyno').DynoFloat<string>;
-    fallVelocity: import('../dyno').DynoFloat<string>;
-    wanderVariance: import('../dyno').DynoFloat<string>;
-    wanderScale: import('../dyno').DynoFloat<string>;
-    fallDirection: import('../dyno').DynoVec3<THREE.Vector3, string>;
-    minScale: import('../dyno').DynoFloat<string>;
-    maxScale: import('../dyno').DynoFloat<string>;
-    anisoScale: import('../dyno').DynoVec3<THREE.Vector3, string>;
+    min: import("../dyno").DynoVec3<THREE.Vector3, string>;
+    max: import("../dyno").DynoVec3<THREE.Vector3, string>;
+    minY: import("../dyno").DynoFloat<string>;
+    color1: import("../dyno").DynoVec3<THREE.Color, string>;
+    color2: import("../dyno").DynoVec3<THREE.Color, string>;
+    opacity: import("../dyno").DynoFloat<string>;
+    fallVelocity: import("../dyno").DynoFloat<string>;
+    wanderVariance: import("../dyno").DynoFloat<string>;
+    wanderScale: import("../dyno").DynoFloat<string>;
+    fallDirection: import("../dyno").DynoVec3<THREE.Vector3, string>;
+    minScale: import("../dyno").DynoFloat<string>;
+    maxScale: import("../dyno").DynoFloat<string>;
+    anisoScale: import("../dyno").DynoVec3<THREE.Vector3, string>;
 };
 export type SNOW_RESULT_TYPE = ReturnType<typeof snowBox>;

package/dist/types/generators/static.d.ts

@@ -1,5 +1,5 @@
-import { SplatGenerator } from '../SplatGenerator';
 import * as THREE from "three";
+import { SplatGenerator } from "../SplatGenerator";
 export declare function staticBox({ box, cells, dotScale, color, opacity, }: {
     box: THREE.Box3;
     cells: THREE.Vector3;

package/dist/types/generators.d.ts

@@ -1,2 +1,2 @@
-export * from './generators/static';
-export * from './generators/snow';
+export * from "./generators/static";
+export * from "./generators/snow";

package/dist/types/hands.d.ts

@@ -1,32 +1,32 @@
-import { Object3D, Quaternion, Vector3, WebXRManager } from 'three';
-import { SplatMesh } from './SplatMesh';
-export declare enum JointEnum {
-    w = "wrist",
-    t0 = "thumb-metacarpal",
-    t1 = "thumb-phalanx-proximal",
-    t2 = "thumb-phalanx-distal",
-    t3 = "thumb-tip",
-    i0 = "index-finger-metacarpal",
-    i1 = "index-finger-phalanx-proximal",
-    i2 = "index-finger-phalanx-intermediate",
-    i3 = "index-finger-phalanx-distal",
-    i4 = "index-finger-tip",
-    m0 = "middle-finger-metacarpal",
-    m1 = "middle-finger-phalanx-proximal",
-    m2 = "middle-finger-phalanx-intermediate",
-    m3 = "middle-finger-phalanx-distal",
-    m4 = "middle-finger-tip",
-    r0 = "ring-finger-metacarpal",
-    r1 = "ring-finger-phalanx-proximal",
-    r2 = "ring-finger-phalanx-intermediate",
-    r3 = "ring-finger-phalanx-distal",
-    r4 = "ring-finger-tip",
-    p0 = "pinky-finger-metacarpal",
-    p1 = "pinky-finger-phalanx-proximal",
-    p2 = "pinky-finger-phalanx-intermediate",
-    p3 = "pinky-finger-phalanx-distal",
-    p4 = "pinky-finger-tip"
-}
+import { type Object3D, Quaternion, Vector3, type WebXRManager } from "three";
+import { SplatMesh } from "./SplatMesh";
+export declare const JointEnum: {
+    readonly w: "wrist";
+    readonly t0: "thumb-metacarpal";
+    readonly t1: "thumb-phalanx-proximal";
+    readonly t2: "thumb-phalanx-distal";
+    readonly t3: "thumb-tip";
+    readonly i0: "index-finger-metacarpal";
+    readonly i1: "index-finger-phalanx-proximal";
+    readonly i2: "index-finger-phalanx-intermediate";
+    readonly i3: "index-finger-phalanx-distal";
+    readonly i4: "index-finger-tip";
+    readonly m0: "middle-finger-metacarpal";
+    readonly m1: "middle-finger-phalanx-proximal";
+    readonly m2: "middle-finger-phalanx-intermediate";
+    readonly m3: "middle-finger-phalanx-distal";
+    readonly m4: "middle-finger-tip";
+    readonly r0: "ring-finger-metacarpal";
+    readonly r1: "ring-finger-phalanx-proximal";
+    readonly r2: "ring-finger-phalanx-intermediate";
+    readonly r3: "ring-finger-phalanx-distal";
+    readonly r4: "ring-finger-tip";
+    readonly p0: "pinky-finger-metacarpal";
+    readonly p1: "pinky-finger-phalanx-proximal";
+    readonly p2: "pinky-finger-phalanx-intermediate";
+    readonly p3: "pinky-finger-phalanx-distal";
+    readonly p4: "pinky-finger-tip";
+};
 export type JointId = keyof typeof JointEnum;
 export declare const JOINT_IDS: JointId[];
 export declare const NUM_JOINTS: number;

package/dist/types/hooks.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Called at each hook point with its name and optional context. Return a
+ * promise to pause Spark at that point until it settles; return undefined to
+ * continue without inserting an await.
+ */
+export type SparkHook = (name: string, context?: Record<string, unknown>) => void | Promise<void>;
+/**
+ * True only when built with SPARK_ENABLE_HOOKS=1. Gates every hook point.
+ * Read as a direct `import.meta.env.<KEY>` so Vite replaces it with a literal
+ * at build time and the hook code is compiled out of normal builds.
+ */
+export declare const SPARK_ENABLE_HOOKS: boolean;
+export declare function setSparkHook(newHook?: SparkHook): void;
+export declare function sparkHook(name: string, context?: Record<string, unknown>): void | Promise<void> | undefined;

package/dist/types/index.d.ts

@@ -1,25 +1,25 @@
-export { SparkRenderer, type SparkRendererOptions, } from './SparkRenderer';
-export { SplatAccumulator, type GeneratorMapping } from './SplatAccumulator';
-export * as dyno from './dyno';
-export { RgbaArray, readRgbaArray } from './RgbaArray';
-export { SplatLoader, getSplatFileType, } from './SplatLoader';
-export { transcodeSpz, writeSpz } from './spz';
-export { PackedSplats, type PackedSplatsOptions } from './PackedSplats';
-export { ExtSplats, type ExtSplatsOptions } from './ExtSplats';
-export * from './SplatPager';
-export { SplatGenerator, type GsplatGenerator, SplatModifier, type GsplatModifier, SplatTransformer, } from './SplatGenerator';
-export { Readback, type Rgba8Readback, type ReadbackBuffer } from './Readback';
-export { SplatMesh, type SplatMeshOptions, type SplatMeshContext, } from './SplatMesh';
-export { SplatSkinning, type SplatSkinningOptions, SplatSkinningMode, } from './SplatSkinning';
-export { SplatEdit, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from './SplatEdit';
-export { constructGrid, constructAxes, constructSpherePoints, imageSplats, textSplats, } from './splatConstructors';
-export * as generators from './generators';
-export * as modifiers from './modifiers';
-export * from './SparkXr';
-export { type JointId, JointEnum, JOINT_IDS, NUM_JOINTS, JOINT_INDEX, JOINT_RADIUS, JOINT_SEGMENTS, JOINT_SEGMENT_STEPS, JOINT_TIPS, FINGER_TIPS, Hand, HANDS, type Joint, type HandJoints, type HandsJoints, XrHands, HandMovement, } from './hands';
-export { SparkControls, FpsMovement, PointerControls } from './controls';
-export { isMobile, isAndroid, isOculus, isQuest2, isIos, isVisionPro, flipPixels, pixelsToPngUrl, toHalf, fromHalf, floatToUint8, floatToSint8, Uint8ToFloat, Sint8ToFloat, setPackedSplat, unpackSplat, } from './utils';
-export * as utils from './utils';
-export { LN_SCALE_MIN, LN_SCALE_MAX, SplatFileType } from './defines';
-export * as defines from './defines';
-export { SparkPortals, type SparkPortalsOptions, type PortalPair, DISK_PORTAL_FRAGMENT_SHADER, } from './SparkPortals';
+export { SparkRenderer, type SparkRendererOptions, } from "./SparkRenderer";
+export { SplatAccumulator, type GeneratorMapping } from "./SplatAccumulator";
+export * as dyno from "./dyno";
+export { RgbaArray, readRgbaArray } from "./RgbaArray";
+export { SplatLoader, getSplatFileType, } from "./SplatLoader";
+export { transcodeSpz, writeSpz, type SpzWriteVersion, type WriteSpzOptions, type TranscodeSpzFileInput, type TranscodeSpzInput, } from "./spz";
+export { PackedSplats, type PackedSplatsOptions } from "./PackedSplats";
+export { ExtSplats, type ExtSplatsOptions } from "./ExtSplats";
+export * from "./SplatPager";
+export { SplatGenerator, type GsplatGenerator, SplatModifier, type GsplatModifier, SplatTransformer, } from "./SplatGenerator";
+export { Readback, type Rgba8Readback, type ReadbackBuffer } from "./Readback";
+export { SplatMesh, type SplatMeshOptions, type SplatMeshContext, } from "./SplatMesh";
+export { SplatSkinning, type SplatSkinningOptions, SplatSkinningMode, } from "./SplatSkinning";
+export { SplatEdit, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from "./SplatEdit";
+export { constructGrid, constructAxes, constructSpherePoints, imageSplats, textSplats, } from "./splatConstructors";
+export * as generators from "./generators";
+export * as modifiers from "./modifiers";
+export * from "./SparkXr";
+export { type JointId, JointEnum, JOINT_IDS, NUM_JOINTS, JOINT_INDEX, JOINT_RADIUS, JOINT_SEGMENTS, JOINT_SEGMENT_STEPS, JOINT_TIPS, FINGER_TIPS, Hand, HANDS, type Joint, type HandJoints, type HandsJoints, XrHands, HandMovement, } from "./hands";
+export { SparkControls, FpsMovement, PointerControls } from "./controls";
+export { isMobile, isAndroid, isOculus, isQuest2, isIos, isVisionPro, flipPixels, pixelsToPngUrl, toHalf, fromHalf, floatToUint8, floatToSint8, Uint8ToFloat, Sint8ToFloat, setPackedSplat, unpackSplat, } from "./utils";
+export * as utils from "./utils";
+export { LN_SCALE_MIN, LN_SCALE_MAX, SplatFileType } from "./defines";
+export * as defines from "./defines";
+export { SparkPortals, type SparkPortalsOptions, type PortalPair, DISK_PORTAL_FRAGMENT_SHADER, } from "./SparkPortals";

package/dist/types/modifiers/depthColor.d.ts

@@ -1,7 +1,7 @@
-import { SplatTransformer } from '../SplatGenerator';
-import { SplatMesh } from '../SplatMesh';
-import { DynoVal } from '../dyno';
-export declare function makeDepthColorModifier(splatToView: SplatTransformer, minDepth: DynoVal<"float">, maxDepth: DynoVal<"float">, reverse: DynoVal<"bool">): import('../dyno').DynoBlock<{
+import type { SplatTransformer } from "../SplatGenerator";
+import type { SplatMesh } from "../SplatMesh";
+import { type DynoVal } from "../dyno";
+export declare function makeDepthColorModifier(splatToView: SplatTransformer, minDepth: DynoVal<"float">, maxDepth: DynoVal<"float">, reverse: DynoVal<"bool">): import("../dyno").DynoBlock<{
     gsplat: {
         type: "Gsplat";
     };
@@ -11,7 +11,7 @@ export declare function makeDepthColorModifier(splatToView: SplatTransformer, mi
     };
 }>;
 export declare function setDepthColor(splats: SplatMesh, minDepth: number, maxDepth: number, reverse?: boolean): {
-    minDepth: import('../dyno').DynoConst<"float">;
-    maxDepth: import('../dyno').DynoConst<"float">;
-    reverse: import('../dyno').DynoConst<"bool">;
+    minDepth: import("../dyno").DynoConst<"float">;
+    maxDepth: import("../dyno").DynoConst<"float">;
+    reverse: import("../dyno").DynoConst<"bool">;
 };

package/dist/types/modifiers/normalColor.d.ts

@@ -1,6 +1,6 @@
-import { SplatTransformer } from '../SplatGenerator';
-import { SplatMesh } from '../SplatMesh';
-export declare function makeNormalColorModifier(splatToView: SplatTransformer): import('../dyno').DynoBlock<{
+import type { SplatTransformer } from "../SplatGenerator";
+import type { SplatMesh } from "../SplatMesh";
+export declare function makeNormalColorModifier(splatToView: SplatTransformer): import("../dyno").DynoBlock<{
     gsplat: {
         type: "Gsplat";
     };

package/dist/types/modifiers.d.ts

@@ -1,2 +1,2 @@
-export * from './modifiers/normalColor';
-export * from './modifiers/depthColor';
+export * from "./modifiers/normalColor";
+export * from "./modifiers/depthColor";

package/dist/types/splatConstructors.d.ts

@@ -1,6 +1,6 @@
-import { PackedSplats } from './PackedSplats';
-import { SplatMesh } from './SplatMesh';
 import * as THREE from "three";
+import { PackedSplats } from "./PackedSplats";
+import { SplatMesh } from "./SplatMesh";
 export declare function constructGrid({ splats, extents, stepSize, pointRadius, pointShadowScale, opacity, color, }: {
     splats: PackedSplats;
     extents: THREE.Box3;

package/dist/types/spz.d.ts

@@ -1,9 +1,40 @@
-import { PackedSplats } from './PackedSplats';
-import { TranscodeSpzInput } from './SplatLoader';
+import { ExtSplats } from "./ExtSplats";
+import { PackedSplats } from "./PackedSplats";
+import type { SplatFileType } from "./defines";
+export type SpzWriteVersion = 2 | 3;
+export type TranscodeSpzFileInput = {
+    fileBytes: Uint8Array;
+    fileType?: SplatFileType;
+    pathOrUrl?: string;
+    transform?: {
+        translate?: number[];
+        quaternion?: number[];
+        scale?: number;
+    };
+};
+export type TranscodeSpzInput = {
+    inputs: TranscodeSpzFileInput[];
+    maxSh?: number;
+    clipXyz?: {
+        min: number[];
+        max: number[];
+    };
+    fractionalBits?: number;
+    opacityThreshold?: number;
+    version?: SpzWriteVersion;
+};
 export declare function transcodeSpz(input: TranscodeSpzInput): Promise<{
     fileBytes: any;
     clippedCount: number;
 }>;
-export declare function writeSpz(packedSplats: PackedSplats, maxSh?: number, fractionalBits?: number): {
-    fileBytes: Uint8Array<ArrayBufferLike>;
+export type WriteSpzOptions = {
+    maxSh?: number;
+    fractionalBits?: number;
+    version?: SpzWriteVersion;
 };
+export declare function writeSpz(splats: PackedSplats | ExtSplats, maxSh?: number, fractionalBits?: number): Promise<{
+    fileBytes: Uint8Array;
+}>;
+export declare function writeSpz(splats: PackedSplats | ExtSplats, options?: WriteSpzOptions): Promise<{
+    fileBytes: Uint8Array;
+}>;