sparcoon 0.7.3 → 0.9.1

package/dist/instancedParticle/FXInstancedParticle.js

@@ -1,64 +1,95 @@
-import { Mesh, InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute, InstancedBufferAttribute, StreamDrawUsage } from 'three';
-import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
-
-class FXInstancedParticle extends Mesh {
-    constructor(varyings, expectedCapacity, _private_capacityStep, material) {
+import { InstancedBufferAttribute, InstancedBufferGeometry, Mesh, StreamDrawUsage } from "three";
+import { FX_AGE, FX_CORE_LIFECYCLE, FX_CORE_POSITION, FX_LIFETIME, FX_POSITION_X, FX_POSITION_Y, FX_POSITION_Z, } from "../coreLayout.js";
+/**
+ * @internal Instanced mesh backing one {@link FXEmitter}: a base primitive drawn once per particle,
+ * plus packed per-particle state. Each field (core `position`/`lifecycle` and each user attribute)
+ * is one `InstancedBufferAttribute` in {@link propertyBuffers}, exposed as `a_<name>`. All buffers
+ * share one particle index and stay dense: births append, deaths compact survivors down, capacity
+ * grows in `capacityStep` blocks - each just iterates every buffer in lockstep.
+ */
+export class FXInstancedParticle extends Mesh {
+    constructor(varyings, expectedCapacity, capacityStep, material, baseGeometry) {
         const instancedGeometry = new InstancedBufferGeometry();
-        const indices = new Uint16Array([0, 2, 1, 2, 3, 1]);
-        instancedGeometry.setIndex(new BufferAttribute(indices, 1));
-        const positions = new Float32Array([-0.5, 0.5, 0, 0.5, 0.5, 0, -0.5, -0.5, 0, 0.5, -0.5, 0]);
-        instancedGeometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
-        const uvs = new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]);
-        instancedGeometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+        // Copy the base geometry's position/uv/normal + index onto the instanced geometry so the
+        // geometry-agnostic vertex epilogue transforms real mesh vertices. `baseGeometry` is caller-
+        // owned (a primitive or a custom mesh asset, possibly shared across emitters) - never disposed
+        // here.
+        const baseIndex = baseGeometry.getIndex();
+        if (baseIndex !== null) {
+            instancedGeometry.setIndex(baseIndex);
+        }
+        instancedGeometry.setAttribute("position", baseGeometry.getAttribute("position"));
+        instancedGeometry.setAttribute("uv", baseGeometry.getAttribute("uv"));
+        instancedGeometry.setAttribute("normal", baseGeometry.getAttribute("normal"));
         super(instancedGeometry, material);
-        this._private_capacityStep = _private_capacityStep;
+        this.capacityStep = capacityStep;
         this.propertyBuffers = {};
-        this._private_sortingIndices = new Int32Array(0);
-        this._private_sortingSquaredDistances = new Float64Array(0);
-        this._private_sortingTemporaryBuffer = new Float32Array(0);
+        this.bufferVersionInternal = 0;
+        this.sortingIndices = new Int32Array(0);
+        this.sortingSquaredDistances = new Float64Array(0);
+        this.sortingTemporaryBuffer = new Float32Array(0);
         this.frustumCulled = false;
-        this._private_instancedGeometry = instancedGeometry;
-        this._private_instancedGeometry.instanceCount = 0;
-        this._private_particleMaterial = material;
-        this._private_capacity = Math.max(Math.ceil(expectedCapacity / this._private_capacityStep) * this._private_capacityStep, this._private_capacityStep);
+        this.instancedGeometry = instancedGeometry;
+        this.instancedGeometry.instanceCount = 0;
+        this.capacity = Math.max(Math.ceil(expectedCapacity / this.capacityStep) * this.capacityStep, this.capacityStep);
         for (const name in varyings) {
             const { bufferSize } = varyings[name];
-            const attribute = new InstancedBufferAttribute(new Float32Array(this._private_capacity * bufferSize), bufferSize);
+            const attribute = new InstancedBufferAttribute(new Float32Array(this.capacity * bufferSize), bufferSize);
             attribute.setUsage(StreamDrawUsage);
-            this._private_instancedGeometry.setAttribute(`a_${name}`, attribute);
+            this.instancedGeometry.setAttribute(`a_${name}`, attribute);
             this.propertyBuffers[name] = attribute;
         }
     }
     get instanceCount() {
-        return this._private_instancedGeometry.instanceCount;
+        return this.instancedGeometry.instanceCount;
     }
     get instanceCapacity() {
-        return this._private_capacity;
+        return this.capacity;
+    }
+    // Bumped on every backing-array reallocation (capacity growth), so the emitter can cache its
+    // per-tick name -> Float32Array record and rebuild only when this moves.
+    get bufferVersion() {
+        return this.bufferVersionInternal;
     }
     createInstances(count) {
-        const currentInstanceCount = this._private_instancedGeometry.instanceCount;
-        this._private_ensureCapacity(currentInstanceCount + count);
-        this._private_instancedGeometry.instanceCount += count;
+        const currentInstanceCount = this.instancedGeometry.instanceCount;
+        this.ensureCapacity(currentInstanceCount + count);
+        // Rows freed by `removeDeadParticles` (copy-down, no zeroing) still hold the previous occupant's
+        // state - most dangerously a stale `age >= lifetime`, which no spawn graph can reset (the spawn
+        // target has no `age` slot). Zero the claimed range so births start clean; flag each buffer so
+        // the cleared rows reach the GPU even for buffers the spawn kernel does not itself write.
+        const rangeBegin = currentInstanceCount;
+        const rangeEnd = currentInstanceCount + count;
+        for (const attribute of Object.values(this.propertyBuffers)) {
+            const { array, itemSize } = attribute;
+            array.fill(0, rangeBegin * itemSize, rangeEnd * itemSize);
+            attribute.needsUpdate = true;
+        }
+        this.instancedGeometry.instanceCount += count;
     }
     removeDeadParticles() {
-        const builtinBuffer = this.propertyBuffers.builtin;
-        if (builtinBuffer === undefined) {
+        // Cull against core `lifecycle` (vec2 [age, lifetime]); alive while `age < lifetime`. Rides the
+        // same copy-down as every other property buffer.
+        const lifecycleBuffer = this.propertyBuffers[FX_CORE_LIFECYCLE];
+        if (lifecycleBuffer === undefined) {
             return;
         }
-        const { array: builtinArray, itemSize: builtinItemSize } = builtinBuffer;
-        const { instanceCount } = this._private_instancedGeometry;
+        const { array: lifecycleArray, itemSize: lifecycleItemSize } = lifecycleBuffer;
+        const { instanceCount } = this.instancedGeometry;
+        // Materialized once per call, not per survivor: a `for...in` inside the copy-down loop would
+        // re-enumerate keys for every moved particle.
+        const attributes = Object.values(this.propertyBuffers);
         let writeIndex = 0;
         let didCompact = false;
         for (let readIndex = 0; readIndex < instanceCount; readIndex++) {
-            const offset = readIndex * builtinItemSize;
-            if (builtinArray[offset + BUILTIN_OFFSET_AGE] < builtinArray[offset + BUILTIN_OFFSET_LIFETIME]) {
+            const offset = readIndex * lifecycleItemSize;
+            if (lifecycleArray[offset + FX_AGE] < lifecycleArray[offset + FX_LIFETIME]) {
                 if (writeIndex !== readIndex) {
-                    for (const name in this.propertyBuffers) {
-                        const attribute = this.propertyBuffers[name];
+                    for (const attribute of attributes) {
                         const { itemSize: dataItemSize, array: dataArray } = attribute;
-                        const srcOffset = readIndex * dataItemSize;
-                        const dstOffset = writeIndex * dataItemSize;
-                        dataArray.copyWithin(dstOffset, srcOffset, srcOffset + dataItemSize);
+                        const sourceOffset = readIndex * dataItemSize;
+                        const destinationOffset = writeIndex * dataItemSize;
+                        dataArray.copyWithin(destinationOffset, sourceOffset, sourceOffset + dataItemSize);
                     }
                     didCompact = true;
                 }
@@ -66,36 +97,60 @@ class FXInstancedParticle extends Mesh {
             }
         }
         if (didCompact) {
-            for (const name in this.propertyBuffers) {
-                this.propertyBuffers[name].needsUpdate = true;
+            for (const attribute of attributes) {
+                attribute.needsUpdate = true;
             }
         }
-        this._private_instancedGeometry.instanceCount = writeIndex;
+        this.instancedGeometry.instanceCount = writeIndex;
     }
-    sortByDistance(cameraWorldPosition) {
-        const { instanceCount } = this._private_instancedGeometry;
+    /**
+     * Reorders every per-particle buffer back-to-front for correct alpha blending. Distances are
+     * world-space (each center transformed by `meshWorldMatrix`), matching the shader's own
+     * `p_cameraDistance` - correct under any transform, including non-uniform scale and shear.
+     */
+    sortByDistance(cameraWorldPosition, meshWorldMatrix) {
+        const { instanceCount } = this.instancedGeometry;
         if (instanceCount < 2) {
             return;
         }
-        const builtinBuffer = this.propertyBuffers.builtin;
-        if (builtinBuffer === undefined) {
+        const positionBuffer = this.propertyBuffers[FX_CORE_POSITION];
+        if (positionBuffer === undefined) {
             return;
         }
-        if (this._private_sortingIndices.length < instanceCount) {
-            this._private_sortingIndices = new Int32Array(this._private_capacity);
-            this._private_sortingSquaredDistances = new Float64Array(this._private_capacity);
+        if (this.sortingIndices.length < instanceCount) {
+            this.sortingIndices = new Int32Array(this.capacity);
+            this.sortingSquaredDistances = new Float64Array(this.capacity);
         }
-        const { array: builtinArray, itemSize: builtinItemSize } = builtinBuffer;
+        const { array: positionArray, itemSize: positionItemSize } = positionBuffer;
+        // Column-major elements, indexed directly to avoid a per-particle Vector3.
+        const elements = meshWorldMatrix.elements;
         for (let particleIndex = 0; particleIndex < instanceCount; particleIndex++) {
-            this._private_sortingIndices[particleIndex] = particleIndex;
-            const itemOffset = particleIndex * builtinItemSize;
-            const dx = builtinArray[itemOffset + BUILTIN_OFFSET_POSITION_X] - cameraWorldPosition.x;
-            const dy = builtinArray[itemOffset + BUILTIN_OFFSET_POSITION_Y] - cameraWorldPosition.y;
-            const dz = builtinArray[itemOffset + BUILTIN_OFFSET_POSITION_Z] - cameraWorldPosition.z;
-            this._private_sortingSquaredDistances[particleIndex] = dx * dx + dy * dy + dz * dz;
+            this.sortingIndices[particleIndex] = particleIndex;
+            const itemOffset = particleIndex * positionItemSize;
+            const positionX = positionArray[itemOffset + FX_POSITION_X];
+            const positionY = positionArray[itemOffset + FX_POSITION_Y];
+            const positionZ = positionArray[itemOffset + FX_POSITION_Z];
+            // meshWorldMatrix * vec4(center, 1.0) - bottom row is (0,0,0,1), so no w divide.
+            const deltaX = elements[0] * positionX +
+                elements[4] * positionY +
+                elements[8] * positionZ +
+                elements[12] -
+                cameraWorldPosition.x;
+            const deltaY = elements[1] * positionX +
+                elements[5] * positionY +
+                elements[9] * positionZ +
+                elements[13] -
+                cameraWorldPosition.y;
+            const deltaZ = elements[2] * positionX +
+                elements[6] * positionY +
+                elements[10] * positionZ +
+                elements[14] -
+                cameraWorldPosition.z;
+            this.sortingSquaredDistances[particleIndex] =
+                deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ;
         }
-        const sortingSquaredDistances = this._private_sortingSquaredDistances;
-        const sortingIndices = this._private_sortingIndices.subarray(0, instanceCount);
+        const sortingSquaredDistances = this.sortingSquaredDistances;
+        const sortingIndices = this.sortingIndices.subarray(0, instanceCount);
         sortingIndices.sort((indexA, indexB) => sortingSquaredDistances[indexB] - sortingSquaredDistances[indexA]);
         let maximumItemSize = 0;
         for (const name in this.propertyBuffers) {
@@ -104,8 +159,8 @@ class FXInstancedParticle extends Mesh {
             }
         }
         const requiredTemporaryBufferSize = instanceCount * maximumItemSize;
-        if (this._private_sortingTemporaryBuffer.length < requiredTemporaryBufferSize) {
-            this._private_sortingTemporaryBuffer = new Float32Array(this._private_capacity * maximumItemSize);
+        if (this.sortingTemporaryBuffer.length < requiredTemporaryBufferSize) {
+            this.sortingTemporaryBuffer = new Float32Array(this.capacity * maximumItemSize);
         }
         for (const name in this.propertyBuffers) {
             const attribute = this.propertyBuffers[name];
@@ -115,28 +170,38 @@ class FXInstancedParticle extends Mesh {
                 const sourceOffset = originalIndex * itemSize;
                 const destinationOffset = newIndex * itemSize;
                 for (let componentIndex = 0; componentIndex < itemSize; componentIndex++) {
-                    this._private_sortingTemporaryBuffer[destinationOffset + componentIndex] =
+                    this.sortingTemporaryBuffer[destinationOffset + componentIndex] =
                         array[sourceOffset + componentIndex];
                 }
             }
             for (let i = 0; i < instanceCount * itemSize; i++) {
-                array[i] = this._private_sortingTemporaryBuffer[i];
+                array[i] = this.sortingTemporaryBuffer[i];
             }
             attribute.needsUpdate = true;
         }
     }
     drop() {
-        this._private_instancedGeometry.instanceCount = 0;
+        this.instancedGeometry.instanceCount = 0;
     }
+    // Disposes the instanced geometry and the currently mounted material - not the constructor one,
+    // which a live material hot-swap may have replaced and disposed.
     destroy() {
-        this._private_instancedGeometry.dispose();
-        this._private_particleMaterial.dispose();
+        // position/uv/normal + index were borrowed by reference from the caller-owned base geometry
+        // (constructor) - possibly shared with other live consumers of the same custom mesh asset.
+        // Detach them first so dispose()'s GPU-buffer cascade only touches the `a_<name>` buffers this
+        // instance actually owns, not a shared consumer's GPU cache.
+        this.instancedGeometry.deleteAttribute("position");
+        this.instancedGeometry.deleteAttribute("uv");
+        this.instancedGeometry.deleteAttribute("normal");
+        this.instancedGeometry.setIndex(null);
+        this.instancedGeometry.dispose();
+        this.material?.dispose();
     }
-    _private_ensureCapacity(requiredCapacity) {
-        if (requiredCapacity <= this._private_capacity) {
+    ensureCapacity(requiredCapacity) {
+        if (requiredCapacity <= this.capacity) {
             return;
         }
-        const newCapacity = Math.ceil(requiredCapacity / this._private_capacityStep) * this._private_capacityStep;
+        const newCapacity = Math.ceil(requiredCapacity / this.capacityStep) * this.capacityStep;
         for (const name in this.propertyBuffers) {
             const oldAttribute = this.propertyBuffers[name];
             const { itemSize, array, usage } = oldAttribute;
@@ -144,27 +209,22 @@ class FXInstancedParticle extends Mesh {
             newArray.set(array);
             const newAttribute = new InstancedBufferAttribute(newArray, itemSize);
             newAttribute.setUsage(usage);
-            this._private_instancedGeometry.setAttribute(`a_${name}`, newAttribute);
+            this.instancedGeometry.setAttribute(`a_${name}`, newAttribute);
             this.propertyBuffers[name] = newAttribute;
-            // Detach old typed array to help GC release GPU-side memory sooner.
-            // Three.js does not expose dispose() on BufferAttribute directly,
-            // but clearing the array reference prevents the old data from lingering.
-            oldAttribute.array = null;
+            // Dropping the CPU array does NOT free the GPU buffer: three's WebGLAttributes holds it in a
+            // WeakMap keyed by the (now-replaced) BufferAttribute and only deletes it when that wrapper is
+            // GC'd (no dispose() on BufferAttribute across r157-179). Best-effort, not deterministic.
+            oldAttribute.array = undefined;
         }
-        this._private_capacity = newCapacity;
-        // Force the renderer to recalculate _maxInstanceCount on the next
-        // setupVertexAttributes pass. The new InstancedBufferAttributes will
-        // trigger a VAO rebind, at which point _maxInstanceCount is recomputed
-        // from the current attribute sizes.
-        //
-        // _maxInstanceCount is an internal renderer cache field set by
-        // WebGLBindingStates.js. It was never promoted to a public API in the
-        // r157-r180 range. Deleting it is the standard workaround used across
-        // the Three.js ecosystem (see #19706, #26363, #27205).
-        //
+        this.capacity = newCapacity;
+        this.bufferVersionInternal++;
+        this.invalidateInstanceCap();
+    }
+    // Force the renderer to recompute `_maxInstanceCount` on the next setupVertexAttributes pass. It
+    // is an internal WebGLBindingStates cache, never promoted to public API across r157-r180; deleting
+    // it is the standard ecosystem workaround (three #19706, #26363, #27205).
+    invalidateInstanceCap() {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        delete this._private_instancedGeometry._maxInstanceCount;
+        delete this.instancedGeometry._maxInstanceCount;
     }
 }
-
-export { FXInstancedParticle };

package/dist/instancedParticle/glTypeInfo.d.ts

@@ -0,0 +1,5 @@
+export interface GLTypeInfo {
+    glslTypeName: string;
+    bufferSize: number;
+    instantiable: boolean;
+}

package/dist/instancedParticle/glTypeInfo.js

@@ -0,0 +1,3 @@
+// GLTypeInfo (GLSL type name + float stride + instantiability). The emitter and material
+// adapters size the per-particle buffers off these strides.
+export {};

package/dist/instancedParticle/primitiveGeometry.d.ts

@@ -0,0 +1,10 @@
+import type { BufferGeometry } from "three";
+import type { FXGeometrySource } from "../artifact/FXArtifact.js";
+/**
+ * Resolves an artifact's {@link FXGeometrySource} to a concrete `BufferGeometry`: a
+ * built-in primitive is built fresh; a `"custom"` slot is looked up by name in `customGeometries`
+ * (app-supplied, e.g. from the exported module's `assets` or the editor's own live content
+ * library) - falling back to the `"plane"` primitive when the name is unbound, the same graceful
+ * degradation an unbound external texture slot gets.
+ */
+export declare function resolveGeometrySource(source: FXGeometrySource | undefined, customGeometries: Readonly<Record<string, BufferGeometry>>): BufferGeometry;

package/dist/instancedParticle/primitiveGeometry.js

@@ -0,0 +1,30 @@
+import { BoxGeometry, PlaneGeometry, SphereGeometry } from "three";
+/**
+ * @internal Base (non-instanced) mesh a {@link FXInstancedParticle} instances once per particle.
+ * Carries standard `position`/`uv`/`normal` + index so the geometry-agnostic vertex epilogue can
+ * transform real mesh vertices. `"plane"` is the unit XY quad (+Z normal) used for billboards.
+ * The result is transient - the caller copies its attributes and discards it.
+ */
+export function buildPrimitiveGeometry(primitive) {
+    switch (primitive) {
+        case "plane":
+            return new PlaneGeometry(1, 1);
+        case "box":
+            return new BoxGeometry(1, 1, 1);
+        case "sphere":
+            return new SphereGeometry(0.5, 24, 16);
+    }
+}
+/**
+ * Resolves an artifact's {@link FXGeometrySource} to a concrete `BufferGeometry`: a
+ * built-in primitive is built fresh; a `"custom"` slot is looked up by name in `customGeometries`
+ * (app-supplied, e.g. from the exported module's `assets` or the editor's own live content
+ * library) - falling back to the `"plane"` primitive when the name is unbound, the same graceful
+ * degradation an unbound external texture slot gets.
+ */
+export function resolveGeometrySource(source, customGeometries) {
+    if (source === undefined || source.type === "primitive") {
+        return buildPrimitiveGeometry(source?.primitive ?? "plane");
+    }
+    return customGeometries[source.external] ?? buildPrimitiveGeometry("plane");
+}

package/dist/miscellaneous/asserts.d.ts

@@ -1,21 +1,4 @@
-/**
- * Validates value is finite number within safe range.
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is not finite or exceeds safe range
- */
 export declare function assertValidNumber(value: number, subject: string): void;
-/**
- * Validates value is positive (>= EPSILON).
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is invalid or below EPSILON
- */
 export declare function assertValidPositiveNumber(value: number, subject: string): void;
-/**
- * Validates value is non-negative (>= 0).
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is invalid or negative
- */
 export declare function assertValidNonNegativeNumber(value: number, subject: string): void;
+export declare function assertValidPositiveInteger(value: number, subject: string): void;

package/dist/miscellaneous/asserts.js

@@ -1,13 +1,10 @@
-import { EPSILON } from './math.js';
-
-/**
- * Validates value is finite number within safe range.
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is not finite or exceeds safe range
- */
-function assertValidNumber(value, subject) {
-    if (process.env.NODE_ENV !== "production") {
+import { EPSILON } from "./math.js";
+// `typeof process` short-circuits before `process.env`, so the published ESM never throws a
+// ReferenceError under import maps / a CDN (no bundler `process` shim). Bundlers still inline
+// `process.env.NODE_ENV`, so DEV validation drops out of production builds.
+const DEV = typeof process === "undefined" || process.env.NODE_ENV !== "production";
+export function assertValidNumber(value, subject) {
+    if (DEV) {
         if (!Number.isFinite(value)) {
             throw new Error(`${subject}: value must be a finite number`);
         }
@@ -16,33 +13,29 @@ function assertValidNumber(value, subject) {
         }
     }
 }
-/**
- * Validates value is positive (>= EPSILON).
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is invalid or below EPSILON
- */
-function assertValidPositiveNumber(value, subject) {
-    if (process.env.NODE_ENV !== "production") {
+export function assertValidPositiveNumber(value, subject) {
+    if (DEV) {
         assertValidNumber(value, subject);
         if (value < EPSILON) {
             throw new Error(`${subject}: value must be greater than or equal to ${EPSILON}`);
         }
     }
 }
-/**
- * Validates value is non-negative (>= 0).
- * @param value Number to validate
- * @param subject Value name for error messages
- * @throws If value is invalid or negative
- */
-function assertValidNonNegativeNumber(value, subject) {
-    if (process.env.NODE_ENV !== "production") {
+export function assertValidNonNegativeNumber(value, subject) {
+    if (DEV) {
         assertValidNumber(value, subject);
         if (value < 0) {
             throw new Error(`${subject}: value must be greater than or equal to 0`);
         }
     }
 }
-
-export { assertValidNonNegativeNumber, assertValidNumber, assertValidPositiveNumber };
+// Guards counts/capacities that reach `instanceCount` or a `Float32Array` length, where a
+// fractional value would draw a truncated instance count or throw a `RangeError`.
+export function assertValidPositiveInteger(value, subject) {
+    if (DEV) {
+        assertValidPositiveNumber(value, subject);
+        if (!Number.isInteger(value)) {
+            throw new Error(`${subject}: value must be an integer`);
+        }
+    }
+}

package/dist/miscellaneous/fxMath.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CPU-side twins of the compiler's math/noise builtins (`fxMix`, `fxSnoise3`, ...). A behavior
+ * kernel's authored `spawn`/`update` body calls these by name - the editor's compiler prints those
+ * exact calls - so every exported name here is a frozen contract with already-compiled kernels,
+ * like the `a_`/`p_` buffer prefixes. Never rename one without updating the compiler side in
+ * lockstep.
+ */
+export declare function fxFract(x: number): number;
+export declare function fxMod(a: number, b: number): number;
+export declare function fxMix(a: number, b: number, t: number): number;
+export declare function fxSmoothstep(edge0: number, edge1: number, x: number): number;
+export declare function fxHash(n: number): number;
+/** Cheap deterministic 1D value-noise (smoothed hash interpolation), range [-1, 1]. */
+export declare function fxValueNoise(x: number): number;
+/** Fractal Brownian motion over {@link fxValueNoise} (gain 0.5, lacunarity 2). */
+export declare function fxFbm(x: number, octaves: number): number;
+/** Linearly samples a curve LUT at `t` in [0, 1] (clamped), interpolating between entries. */
+export declare function fxSampleLut(lut: ArrayLike<number>, t: number): number;
+/**
+ * Ashima/Gustavson "webgl-noise" simplex noise, 2D - the CPU twin of the compiler's GLSL `snoise`
+ * helper. Component arguments (rather than a vector) so it mirrors how the scalarized JS backend calls
+ * it; the arithmetic tracks the GLSL version op-for-op. Output is roughly `[-1, 1]`.
+ */
+export declare function fxSnoise2(vx: number, vy: number): number;
+/** 3D twin of {@link fxSnoise2}, mirroring the GLSL `snoise(vec3)` overload op-for-op. */
+export declare function fxSnoise3(vx: number, vy: number, vz: number): number;