@lovo/matter 0.1.0 → 0.3.0

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import { WebGPURenderer, Node } from 'three/webgpu';
 import { Color } from 'three';
 import { ShaderNodeObject } from 'three/tsl';
-export { cos, dot, length, max, min, mix, mod, normalize, sin, smoothstep, uniform, uv, vec2, vec3, vec4 } from 'three/tsl';
 
 type MatterBackend = 'webgpu' | 'webgl2';
 interface CreateRendererOptions {
@@ -150,6 +149,17 @@ declare class CursorInput {
     dispose(): void;
 }
 
+/**
+ * Canonical TSL-node *input* shape used throughout `@lovo/matter`.
+ *
+ * Stays as the broad `Node | ShaderNodeObject<Node>` union so callers can
+ * pass uniform-typed nodes (e.g. `ShaderNodeObject<UniformNode<Vector2>>`)
+ * without casting at the call site — those are subtypes of `Node` but NOT
+ * subtypes of `ShaderNodeObject<Node>` due to invariant generic parameters.
+ *
+ * Wrappers should return the narrower `ShaderNodeObject<Node>` so the
+ * **output** is always chainable without casts.
+ */
 type TSLNode = Node | ShaderNodeObject<Node>;
 interface ColorRampStop {
     /** Color expressed as a TSL node (typically `vec3(r,g,b)`). */
@@ -163,7 +173,7 @@ interface ColorRampStop {
  *
  * Falls back to the first/last stop's color outside the bracketing positions.
  */
-declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): TSLNode;
+declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): ShaderNodeObject<Node>;
 
 /**
  * 2D simplex noise sampled at a point. Returns a scalar TSL node in
@@ -174,8 +184,11 @@ declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): TSLNode;
  * Built on top of three's `mx_noise_float`; we wrap it so consumers have a
  * stable import path through `@lovo/matter` and we can swap the
  * implementation if a different noise primitive proves better in practice.
+ *
+ * Returns `ShaderNodeObject<Node>` (chainable) rather than the broader
+ * `TSLNode` union, so callers can `.add(...)`/`.mul(...)` without casting.
  */
-declare function noise(p: TSLNode): TSLNode;
+declare function noise(p: TSLNode): ShaderNodeObject<Node>;
 
 interface FBMOptions {
     /** Number of octaves to sum. JS-side number — fixed at TSL build time, not a uniform. Default: 4. */
@@ -188,17 +201,27 @@ interface FBMOptions {
 /**
  * Fractal Brownian Motion — sum of N octaves of 2D simplex noise.
  *
+ * Each octave samples noise at a higher frequency (× `lacunarity`) and lower
+ * amplitude (× `gain`) than the previous one, AND at a translated coordinate
+ * so the octaves sample uncorrelated regions of noise space. Without the
+ * per-octave translation, octaves at related frequencies tend to pile up
+ * peaks and troughs at the same input coordinates, producing visibly muddy
+ * "spotty" output. With it, the octaves look like independent noise patterns
+ * layered together — Inigo Quilez's classic FBM technique.
+ *
  * `octaves`, `lacunarity`, and `gain` are JavaScript numbers (NOT TSL
  * uniforms) because the loop must be unrolled at TSL-build time — TSL has
  * no dynamic-length loop primitive that maps cleanly to all backends.
  * Animatable parameters that *do* survive on the GPU are the input UV
  * (which the caller can scale/translate per frame) and `time`.
  *
- * @param p — Vec2 TSL node (UV-space position).
- * @returns scalar TSL node, roughly [-1..1] but normalized closer to
- *          [-0.5..0.5] when amplitude sums approach 1 with the default gain.
+ * Returns `ShaderNodeObject<Node>` (chainable) for cast-free call sites.
+ *
+ * @param p — Vec2 or Vec3 TSL node (UV-space position).
+ * @returns scalar TSL node, normalized to roughly [-1..1] regardless of
+ *          octave count thanks to the amplitude-sum division at the end.
  */
-declare function fbm(p: TSLNode, opts?: FBMOptions): TSLNode;
+declare function fbm(p: TSLNode, opts?: FBMOptions): ShaderNodeObject<Node>;
 
 /**
  * 2D voronoi (Worley) noise — distance to the nearest jittered cell point,
@@ -209,9 +232,11 @@ declare function fbm(p: TSLNode, opts?: FBMOptions): TSLNode;
  * a multi-color cellular pattern; threshold via `step`/`smoothstep` for
  * hard cell shapes.
  *
+ * Returns `ShaderNodeObject<Node>` (chainable) for cast-free call sites.
+ *
  * @param p — Vec2 TSL node, typically `uv() * scale`.
  */
-declare function voronoi(p: TSLNode): TSLNode;
+declare function voronoi(p: TSLNode): ShaderNodeObject<Node>;
 
 /**
  * Quantize a scalar TSL node to `steps` discrete levels.
@@ -221,7 +246,7 @@ declare function voronoi(p: TSLNode): TSLNode;
  * `steps` is a JS-side number (loop-equivalent at TSL build time, baked in).
  * If you need an animatable step count, rebuild the TSL fragment.
  */
-declare function quantize(t: TSLNode, steps: number): TSLNode;
+declare function quantize(t: ShaderNodeObject<Node>, steps: number): ShaderNodeObject<Node>;
 
 /**
  * Signed distance field for a circle centered at the origin.
@@ -234,7 +259,7 @@ declare function quantize(t: TSLNode, steps: number): TSLNode;
  * @param p — Vec2 TSL node (typically a UV-space offset from the center).
  * @param radius — JS-side scalar OR a scalar TSL node.
  */
-declare function sdfCircle(p: TSLNode, radius: TSLNode | number): TSLNode;
+declare function sdfCircle(p: TSLNode, radius: TSLNode | number): ShaderNodeObject<Node>;
 
 /**
  * Naive vector addition: returns `p + by`.
@@ -252,7 +277,7 @@ declare function sdfCircle(p: TSLNode, radius: TSLNode | number): TSLNode;
  * @param p — Vec2 TSL node (the position being displaced).
  * @param by — Vec2 TSL node (the displacement vector).
  */
-declare function displace(p: TSLNode, by: TSLNode): TSLNode;
+declare function displace(p: TSLNode, by: TSLNode): ShaderNodeObject<Node>;
 
 interface CursorRippleOptions {
     /** Decay radius (UV space). Beyond this, the ripple is ~0. Default: 0.4. */
@@ -279,18 +304,42 @@ interface CursorRippleOptions {
  * @param p — Vec2 TSL node (typically `uv()`).
  * @param center — Vec2 TSL node (cursor uniform, in UV space).
  */
-declare function cursorRipple(p: TSLNode, center: TSLNode, opts?: CursorRippleOptions): TSLNode;
+declare function cursorRipple(p: TSLNode, center: TSLNode, opts?: CursorRippleOptions): ShaderNodeObject<Node>;
+
+declare const time: ShaderNodeObject<Node>;
 
 /**
- * Engine-gated `time`: equals the TSL built-in `time` multiplied by the
- * reduced-motion scale uniform. Components consuming `time` from `@lovo/matter`
- * automatically respect `prefers-reduced-motion` and the policy override set
- * via `setReducedMotionPolicy`.
+ * Hash-based film grain — chaotic, uncorrelated per-pixel noise sampled
+ * from `uvNode`. The output is *centered* around zero so it acts as a
+ * brightness-preserving texture overlay (half the pixels brighten by up
+ * to `intensity`, half darken, mean unchanged). ADD the result to a color.
+ *
+ *   filmGrain(uv, k)        → static grain
+ *   filmGrain(uv, k, time)  → twinkling grain. Pass a quantized time node
+ *                             (e.g. `time.mul(speed).mul(60).floor()`) so
+ *                             the grain re-randomizes at a controllable
+ *                             "shutter rate" instead of every frame.
+ *
+ * Recipe:
  *
- * If you want raw uncapped time (e.g. for a debug overlay), import
- * `time` from `three/tsl` directly.
+ *   base = vec2(uv·c1, uv·c2) + timeOffset
+ *   hash = fract(sin(base) * 43758.5453)
+ *   out  = (length(hash) - 0.765) * intensity
+ *
+ * `c1 = (2127.1, 81.17)` and `c2 = (1269.5, 283.37)` are arbitrary
+ * near-prime constants that produce visually-uncorrelated noise. `0.765`
+ * is the empirical mean of `length(vec2(u, v))` for uniform u, v ∈ [0, 1),
+ * computed once so we don't have to subtract it at runtime per pixel.
+ *
+ * For a film-stock look (darkens as grain rises — silver-emulsion
+ * physics) subtract the result from the color instead of adding.
+ *
+ * @param uvNode      vec2 TSL node, typically `uv()`.
+ * @param intensity   number or TSL node in [0, 1]; scales the grain.
+ * @param timeOffset  optional number or TSL node added to each sample
+ *                    before hashing. `0` (default) → static grain.
  */
-declare const time: ShaderNodeObject<Node>;
+declare function filmGrain(uvNode: ShaderNodeObject<Node>, intensity: ShaderNodeObject<Node> | number, timeOffset?: ShaderNodeObject<Node> | number): ShaderNodeObject<Node>;
 
 type ReducedMotionPolicy = 'auto' | 'off' | 'slow' | 'paused';
 /**
@@ -358,4 +407,4 @@ interface IntersectionWatcher {
  */
 declare function createIntersectionWatcher(canvas: HTMLCanvasElement): IntersectionWatcher;
 
-export { type ColorRampStop, type CreateRendererOptions, CursorInput, type CursorInputOptions, type CursorRippleOptions, type FBMOptions, type IntersectionWatcher, type MatterBackend, type MatterRenderer, MatterScheduler, type ReducedMotionPolicy, type ReducedMotionWatcher, type SchedulerClient, type SchedulerTick, type TSLNode, type Vec2, type VisibilityWatcher, colorRamp, createIntersectionWatcher, createReducedMotionWatcher, createRenderer, createVisibilityWatcher, cursorRipple, displace, fbm, getReducedMotionPolicy, getReducedMotionTimeScale, noise, quantize, sdfCircle, setReducedMotionPolicy, time, voronoi };
+export { type ColorRampStop, type CreateRendererOptions, CursorInput, type CursorInputOptions, type CursorRippleOptions, type FBMOptions, type IntersectionWatcher, type MatterBackend, type MatterRenderer, MatterScheduler, type ReducedMotionPolicy, type ReducedMotionWatcher, type SchedulerClient, type SchedulerTick, type TSLNode, type Vec2, type VisibilityWatcher, colorRamp, createIntersectionWatcher, createReducedMotionWatcher, createRenderer, createVisibilityWatcher, cursorRipple, displace, fbm, filmGrain, getReducedMotionPolicy, getReducedMotionTimeScale, noise, quantize, sdfCircle, setReducedMotionPolicy, time, voronoi };

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { WebGPURenderer, Node } from 'three/webgpu';
 import { Color } from 'three';
 import { ShaderNodeObject } from 'three/tsl';
-export { cos, dot, length, max, min, mix, mod, normalize, sin, smoothstep, uniform, uv, vec2, vec3, vec4 } from 'three/tsl';
 
 type MatterBackend = 'webgpu' | 'webgl2';
 interface CreateRendererOptions {
@@ -150,6 +149,17 @@ declare class CursorInput {
     dispose(): void;
 }
 
+/**
+ * Canonical TSL-node *input* shape used throughout `@lovo/matter`.
+ *
+ * Stays as the broad `Node | ShaderNodeObject<Node>` union so callers can
+ * pass uniform-typed nodes (e.g. `ShaderNodeObject<UniformNode<Vector2>>`)
+ * without casting at the call site — those are subtypes of `Node` but NOT
+ * subtypes of `ShaderNodeObject<Node>` due to invariant generic parameters.
+ *
+ * Wrappers should return the narrower `ShaderNodeObject<Node>` so the
+ * **output** is always chainable without casts.
+ */
 type TSLNode = Node | ShaderNodeObject<Node>;
 interface ColorRampStop {
     /** Color expressed as a TSL node (typically `vec3(r,g,b)`). */
@@ -163,7 +173,7 @@ interface ColorRampStop {
  *
  * Falls back to the first/last stop's color outside the bracketing positions.
  */
-declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): TSLNode;
+declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): ShaderNodeObject<Node>;
 
 /**
  * 2D simplex noise sampled at a point. Returns a scalar TSL node in
@@ -174,8 +184,11 @@ declare function colorRamp(t: TSLNode, stops: ColorRampStop[]): TSLNode;
  * Built on top of three's `mx_noise_float`; we wrap it so consumers have a
  * stable import path through `@lovo/matter` and we can swap the
  * implementation if a different noise primitive proves better in practice.
+ *
+ * Returns `ShaderNodeObject<Node>` (chainable) rather than the broader
+ * `TSLNode` union, so callers can `.add(...)`/`.mul(...)` without casting.
  */
-declare function noise(p: TSLNode): TSLNode;
+declare function noise(p: TSLNode): ShaderNodeObject<Node>;
 
 interface FBMOptions {
     /** Number of octaves to sum. JS-side number — fixed at TSL build time, not a uniform. Default: 4. */
@@ -188,17 +201,27 @@ interface FBMOptions {
 /**
  * Fractal Brownian Motion — sum of N octaves of 2D simplex noise.
  *
+ * Each octave samples noise at a higher frequency (× `lacunarity`) and lower
+ * amplitude (× `gain`) than the previous one, AND at a translated coordinate
+ * so the octaves sample uncorrelated regions of noise space. Without the
+ * per-octave translation, octaves at related frequencies tend to pile up
+ * peaks and troughs at the same input coordinates, producing visibly muddy
+ * "spotty" output. With it, the octaves look like independent noise patterns
+ * layered together — Inigo Quilez's classic FBM technique.
+ *
  * `octaves`, `lacunarity`, and `gain` are JavaScript numbers (NOT TSL
  * uniforms) because the loop must be unrolled at TSL-build time — TSL has
  * no dynamic-length loop primitive that maps cleanly to all backends.
  * Animatable parameters that *do* survive on the GPU are the input UV
  * (which the caller can scale/translate per frame) and `time`.
  *
- * @param p — Vec2 TSL node (UV-space position).
- * @returns scalar TSL node, roughly [-1..1] but normalized closer to
- *          [-0.5..0.5] when amplitude sums approach 1 with the default gain.
+ * Returns `ShaderNodeObject<Node>` (chainable) for cast-free call sites.
+ *
+ * @param p — Vec2 or Vec3 TSL node (UV-space position).
+ * @returns scalar TSL node, normalized to roughly [-1..1] regardless of
+ *          octave count thanks to the amplitude-sum division at the end.
  */
-declare function fbm(p: TSLNode, opts?: FBMOptions): TSLNode;
+declare function fbm(p: TSLNode, opts?: FBMOptions): ShaderNodeObject<Node>;
 
 /**
  * 2D voronoi (Worley) noise — distance to the nearest jittered cell point,
@@ -209,9 +232,11 @@ declare function fbm(p: TSLNode, opts?: FBMOptions): TSLNode;
  * a multi-color cellular pattern; threshold via `step`/`smoothstep` for
  * hard cell shapes.
  *
+ * Returns `ShaderNodeObject<Node>` (chainable) for cast-free call sites.
+ *
  * @param p — Vec2 TSL node, typically `uv() * scale`.
  */
-declare function voronoi(p: TSLNode): TSLNode;
+declare function voronoi(p: TSLNode): ShaderNodeObject<Node>;
 
 /**
  * Quantize a scalar TSL node to `steps` discrete levels.
@@ -221,7 +246,7 @@ declare function voronoi(p: TSLNode): TSLNode;
  * `steps` is a JS-side number (loop-equivalent at TSL build time, baked in).
  * If you need an animatable step count, rebuild the TSL fragment.
  */
-declare function quantize(t: TSLNode, steps: number): TSLNode;
+declare function quantize(t: ShaderNodeObject<Node>, steps: number): ShaderNodeObject<Node>;
 
 /**
  * Signed distance field for a circle centered at the origin.
@@ -234,7 +259,7 @@ declare function quantize(t: TSLNode, steps: number): TSLNode;
  * @param p — Vec2 TSL node (typically a UV-space offset from the center).
  * @param radius — JS-side scalar OR a scalar TSL node.
  */
-declare function sdfCircle(p: TSLNode, radius: TSLNode | number): TSLNode;
+declare function sdfCircle(p: TSLNode, radius: TSLNode | number): ShaderNodeObject<Node>;
 
 /**
  * Naive vector addition: returns `p + by`.
@@ -252,7 +277,7 @@ declare function sdfCircle(p: TSLNode, radius: TSLNode | number): TSLNode;
  * @param p — Vec2 TSL node (the position being displaced).
  * @param by — Vec2 TSL node (the displacement vector).
  */
-declare function displace(p: TSLNode, by: TSLNode): TSLNode;
+declare function displace(p: TSLNode, by: TSLNode): ShaderNodeObject<Node>;
 
 interface CursorRippleOptions {
     /** Decay radius (UV space). Beyond this, the ripple is ~0. Default: 0.4. */
@@ -279,18 +304,42 @@ interface CursorRippleOptions {
  * @param p — Vec2 TSL node (typically `uv()`).
  * @param center — Vec2 TSL node (cursor uniform, in UV space).
  */
-declare function cursorRipple(p: TSLNode, center: TSLNode, opts?: CursorRippleOptions): TSLNode;
+declare function cursorRipple(p: TSLNode, center: TSLNode, opts?: CursorRippleOptions): ShaderNodeObject<Node>;
+
+declare const time: ShaderNodeObject<Node>;
 
 /**
- * Engine-gated `time`: equals the TSL built-in `time` multiplied by the
- * reduced-motion scale uniform. Components consuming `time` from `@lovo/matter`
- * automatically respect `prefers-reduced-motion` and the policy override set
- * via `setReducedMotionPolicy`.
+ * Hash-based film grain — chaotic, uncorrelated per-pixel noise sampled
+ * from `uvNode`. The output is *centered* around zero so it acts as a
+ * brightness-preserving texture overlay (half the pixels brighten by up
+ * to `intensity`, half darken, mean unchanged). ADD the result to a color.
+ *
+ *   filmGrain(uv, k)        → static grain
+ *   filmGrain(uv, k, time)  → twinkling grain. Pass a quantized time node
+ *                             (e.g. `time.mul(speed).mul(60).floor()`) so
+ *                             the grain re-randomizes at a controllable
+ *                             "shutter rate" instead of every frame.
+ *
+ * Recipe:
  *
- * If you want raw uncapped time (e.g. for a debug overlay), import
- * `time` from `three/tsl` directly.
+ *   base = vec2(uv·c1, uv·c2) + timeOffset
+ *   hash = fract(sin(base) * 43758.5453)
+ *   out  = (length(hash) - 0.765) * intensity
+ *
+ * `c1 = (2127.1, 81.17)` and `c2 = (1269.5, 283.37)` are arbitrary
+ * near-prime constants that produce visually-uncorrelated noise. `0.765`
+ * is the empirical mean of `length(vec2(u, v))` for uniform u, v ∈ [0, 1),
+ * computed once so we don't have to subtract it at runtime per pixel.
+ *
+ * For a film-stock look (darkens as grain rises — silver-emulsion
+ * physics) subtract the result from the color instead of adding.
+ *
+ * @param uvNode      vec2 TSL node, typically `uv()`.
+ * @param intensity   number or TSL node in [0, 1]; scales the grain.
+ * @param timeOffset  optional number or TSL node added to each sample
+ *                    before hashing. `0` (default) → static grain.
  */
-declare const time: ShaderNodeObject<Node>;
+declare function filmGrain(uvNode: ShaderNodeObject<Node>, intensity: ShaderNodeObject<Node> | number, timeOffset?: ShaderNodeObject<Node> | number): ShaderNodeObject<Node>;
 
 type ReducedMotionPolicy = 'auto' | 'off' | 'slow' | 'paused';
 /**
@@ -358,4 +407,4 @@ interface IntersectionWatcher {
  */
 declare function createIntersectionWatcher(canvas: HTMLCanvasElement): IntersectionWatcher;
 
-export { type ColorRampStop, type CreateRendererOptions, CursorInput, type CursorInputOptions, type CursorRippleOptions, type FBMOptions, type IntersectionWatcher, type MatterBackend, type MatterRenderer, MatterScheduler, type ReducedMotionPolicy, type ReducedMotionWatcher, type SchedulerClient, type SchedulerTick, type TSLNode, type Vec2, type VisibilityWatcher, colorRamp, createIntersectionWatcher, createReducedMotionWatcher, createRenderer, createVisibilityWatcher, cursorRipple, displace, fbm, getReducedMotionPolicy, getReducedMotionTimeScale, noise, quantize, sdfCircle, setReducedMotionPolicy, time, voronoi };
+export { type ColorRampStop, type CreateRendererOptions, CursorInput, type CursorInputOptions, type CursorRippleOptions, type FBMOptions, type IntersectionWatcher, type MatterBackend, type MatterRenderer, MatterScheduler, type ReducedMotionPolicy, type ReducedMotionWatcher, type SchedulerClient, type SchedulerTick, type TSLNode, type Vec2, type VisibilityWatcher, colorRamp, createIntersectionWatcher, createReducedMotionWatcher, createRenderer, createVisibilityWatcher, cursorRipple, displace, fbm, filmGrain, getReducedMotionPolicy, getReducedMotionTimeScale, noise, quantize, sdfCircle, setReducedMotionPolicy, time, voronoi };

package/dist/index.js

@@ -208,6 +208,7 @@ var lerp = (a, b, t) => a + (b - a) * t;
 
 // src/primitives/colorRamp.ts
 import { mix, vec3 } from "three/tsl";
+import { clamp, div, sub } from "three/tsl";
 function colorRamp(t, stops) {
   if (stops.length === 0) return vec3(0, 0, 0);
   if (stops.length === 1) return stops[0].color;
@@ -217,8 +218,7 @@ function colorRamp(t, stops) {
     const next = stops[i];
     const span = next.position - prev.position;
     if (span <= 0) continue;
-    const tNode = t;
-    const localT = tNode.sub(prev.position).div(span).clamp(0, 1);
+    const localT = clamp(div(sub(t, prev.position), span), 0, 1);
     result = mix(result, next.color, localT);
   }
   return result;
@@ -231,6 +231,7 @@ function noise(p) {
 }
 
 // src/primitives/fbm.ts
+import { add, mul } from "three/tsl";
 function fbm(p, opts = {}) {
   const octaves = opts.octaves ?? 4;
   const lacunarity = opts.lacunarity ?? 2;
@@ -243,7 +244,7 @@ function fbm(p, opts = {}) {
     freq *= lacunarity;
     amp *= gain;
     total += amp;
-    const pAtFreq = p.mul(freq);
+    const pAtFreq = add(mul(p, freq), i * 100);
     const layer = noise(pAtFreq).mul(amp);
     sum = sum.add(layer);
   }
@@ -268,39 +269,19 @@ function quantize(t, steps) {
 // src/primitives/sdfCircle.ts
 import { length } from "three/tsl";
 function sdfCircle(p, radius) {
-  const lp = length(p);
-  if (typeof radius === "number") {
-    return lp.sub(radius);
-  }
-  return lp.sub(radius);
+  return length(p).sub(radius);
 }
 
 // src/primitives/displace.ts
+import { add as add2 } from "three/tsl";
 function displace(p, by) {
-  return p.add(by);
+  return add2(p, by);
 }
 
 // src/primitives/cursorRipple.ts
-import { sin as sin2, length as length3, smoothstep as smoothstep2 } from "three/tsl";
+import { sin, length as length2, smoothstep, sub as sub2 } from "three/tsl";
 
-// src/primitives/tsl-reexports.ts
-import {
-  uniform as uniform2,
-  vec2,
-  vec3 as vec32,
-  vec4,
-  mix as mix2,
-  smoothstep,
-  mod,
-  sin,
-  cos,
-  length as length2,
-  dot,
-  normalize,
-  uv,
-  max,
-  min
-} from "three/tsl";
+// src/primitives/time.ts
 import { time as _builtinTime } from "three/tsl";
 
 // src/runtime/reducedMotion.ts
@@ -390,10 +371,8 @@ function getReducedMotionTimeScale() {
   return globalScaleUniform;
 }
 
-// src/primitives/tsl-reexports.ts
-var time = _builtinTime.mul(
-  getReducedMotionTimeScale()
-);
+// src/primitives/time.ts
+var time = _builtinTime.mul(getReducedMotionTimeScale());
 
 // src/primitives/cursorRipple.ts
 function cursorRipple(p, center, opts = {}) {
@@ -401,14 +380,22 @@ function cursorRipple(p, center, opts = {}) {
   const frequency = opts.frequency ?? 30;
   const speed = opts.speed ?? 6;
   const amplitude = opts.amplitude ?? 0.5;
-  const d = length3(
-    p.sub(center)
-  );
-  const wave = sin2(d.mul(frequency).sub(time.mul(speed)));
-  const decay = smoothstep2(reach, 0, d);
+  const d = length2(sub2(p, center));
+  const wave = sin(d.mul(frequency).sub(time.mul(speed)));
+  const decay = smoothstep(reach, 0, d);
   return wave.mul(amplitude).mul(decay);
 }
 
+// src/primitives/filmGrain.ts
+import { vec2, sin as sin2, fract, length as length3 } from "three/tsl";
+function filmGrain(uvNode, intensity, timeOffset = 0) {
+  const HASH_C1 = vec2(2127.1, 81.17);
+  const HASH_C2 = vec2(1269.5, 283.37);
+  const base = vec2(uvNode.dot(HASH_C1).add(timeOffset), uvNode.dot(HASH_C2).add(timeOffset));
+  const hash = fract(sin2(base).mul(43758.5453));
+  return length3(hash).sub(0.765).mul(intensity);
+}
+
 // src/runtime/visibility.ts
 function createVisibilityWatcher() {
   if (typeof document === "undefined") {
@@ -478,35 +465,21 @@ export {
   CursorInput,
   MatterScheduler,
   colorRamp,
-  cos,
   createIntersectionWatcher,
   createReducedMotionWatcher,
   createRenderer,
   createVisibilityWatcher,
   cursorRipple,
   displace,
-  dot,
   fbm,
+  filmGrain,
   getReducedMotionPolicy,
   getReducedMotionTimeScale,
-  length2 as length,
-  max,
-  min,
-  mix2 as mix,
-  mod,
   noise,
-  normalize,
   quantize,
   sdfCircle,
   setReducedMotionPolicy,
-  sin,
-  smoothstep,
   time,
-  uniform2 as uniform,
-  uv,
-  vec2,
-  vec32 as vec3,
-  vec4,
   voronoi
 };
 //# sourceMappingURL=index.js.map