@lovo/matter 0.1.0

package/dist/index.js

@@ -0,0 +1,512 @@
+// src/runtime/createRenderer.ts
+import { WebGPURenderer } from "three/webgpu";
+import { Color } from "three";
+async function createRenderer(canvas, opts = {}) {
+  const {
+    antialias = true,
+    forceWebGL = false,
+    clearColor = 0,
+    clearAlpha = 0,
+    maxDPR = 2
+  } = opts;
+  const three = new WebGPURenderer({
+    canvas,
+    antialias,
+    forceWebGL
+  });
+  await three.init();
+  three.setPixelRatio(Math.min(window.devicePixelRatio, maxDPR));
+  const resolvedClearColor = clearColor instanceof Color ? clearColor : new Color(clearColor);
+  three.setClearColor(resolvedClearColor, clearAlpha);
+  const resize = () => {
+    const w = canvas.clientWidth;
+    const h = canvas.clientHeight;
+    if (canvas.width !== w * three.getPixelRatio() || canvas.height !== h * three.getPixelRatio()) {
+      three.setSize(w, h, false);
+    }
+  };
+  resize();
+  const backend = forceWebGL || three.backend?.isWebGLBackend ? "webgl2" : "webgpu";
+  return {
+    three,
+    backend,
+    dispose: () => three.dispose(),
+    resize
+  };
+}
+
+// src/runtime/MatterScheduler.ts
+var MatterScheduler = class {
+  clients = /* @__PURE__ */ new Set();
+  rafId = null;
+  running = false;
+  paused = false;
+  idle = false;
+  flushPending = false;
+  startedAt = 0;
+  lastTickAt = 0;
+  /** Activate the scheduler. The rAF loop starts on the first client added. */
+  start() {
+    this.running = true;
+    this.paused = false;
+    this.maybeQueue();
+  }
+  /** Halt the rAF loop entirely. Use dispose() for permanent teardown. */
+  stop() {
+    this.running = false;
+    this.cancel();
+  }
+  /** Temporarily skip ticks without losing client registrations. */
+  pause() {
+    this.paused = true;
+  }
+  /** Resume after pause(). */
+  resume() {
+    this.paused = false;
+    if (this.running) this.maybeQueue();
+  }
+  /** Register a client to be called every frame. */
+  add(client) {
+    this.clients.add(client);
+    if (this.running) this.maybeQueue();
+  }
+  /** Unregister a client. */
+  remove(client) {
+    this.clients.delete(client);
+  }
+  /** Permanent teardown: stop the loop and drop all clients. */
+  dispose() {
+    this.stop();
+    this.clients.clear();
+  }
+  /**
+   * Mark the scheduler idle. The next tick still fires (a final flush so
+   * uniform changes that triggered the idle state are rendered), then the
+   * rAF loop halts. Use `requestRender()` or `setIdle(false)` to wake.
+   */
+  setIdle(idle) {
+    if (this.idle === idle) return;
+    this.idle = idle;
+    if (idle) {
+      this.flushPending = true;
+      this.maybeQueue();
+    } else {
+      this.flushPending = false;
+      this.maybeQueue();
+    }
+  }
+  /** Force a single tick while idle. Useful for prop-change invalidation. */
+  requestRender() {
+    if (!this.idle) return;
+    this.flushPending = true;
+    this.maybeQueue();
+  }
+  maybeQueue() {
+    if (this.rafId !== null) return;
+    if (!this.running) return;
+    if (this.clients.size === 0) return;
+    if (this.idle && !this.flushPending) return;
+    this.rafId = requestAnimationFrame(this.frame);
+  }
+  cancel() {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+  }
+  frame = (now) => {
+    this.rafId = null;
+    if (!this.running || this.paused) return;
+    if (this.startedAt === 0) {
+      this.startedAt = now;
+      this.lastTickAt = now;
+    }
+    const delta = (now - this.lastTickAt) / 1e3;
+    const elapsed = (now - this.startedAt) / 1e3;
+    this.lastTickAt = now;
+    const tick = { delta, elapsed, now };
+    for (const client of this.clients) {
+      client(tick);
+    }
+    this.flushPending = false;
+    this.maybeQueue();
+  };
+};
+
+// src/inputs/CursorInput.ts
+var CursorInput = class {
+  value;
+  target;
+  targetDirty = false;
+  smoothing;
+  listeners = /* @__PURE__ */ new Set();
+  eventTarget;
+  element;
+  handleMouseMove;
+  disposed = false;
+  constructor(opts = {}) {
+    const { smoothing = 0.1, initial = [0.5, 0.5], target, element } = opts;
+    this.smoothing = clamp01(smoothing);
+    this.value = [initial[0], initial[1]];
+    this.target = [initial[0], initial[1]];
+    this.eventTarget = target ?? (typeof window !== "undefined" ? window : new EventTarget());
+    this.element = element;
+    this.handleMouseMove = (e) => {
+      const me = e;
+      if (this.element) {
+        const r = this.element.getBoundingClientRect();
+        const w = r.width || 1;
+        const h = r.height || 1;
+        this.target = [(me.clientX - r.left) / w, (me.clientY - r.top) / h];
+      } else {
+        const w = typeof window !== "undefined" && window.innerWidth || 1;
+        const h = typeof window !== "undefined" && window.innerHeight || 1;
+        this.target = [me.clientX / w, me.clientY / h];
+      }
+      this.targetDirty = true;
+    };
+    this.eventTarget.addEventListener("mousemove", this.handleMouseMove);
+  }
+  /** Current smoothed position. Implements MatterSignal protocol. */
+  get() {
+    return this.value;
+  }
+  /** Subscribe to change events. Returns an unsubscribe function. */
+  on(_event, cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  /**
+   * Advance the smoothing one tick. Called by the host scheduler; not
+   * typically called directly except in tests.
+   */
+  tick(delta) {
+    if (this.disposed) return;
+    const factor = this.smoothing === 0 ? 1 : 1 - Math.pow(this.smoothing, delta * 60);
+    const prev0 = this.value[0];
+    const prev1 = this.value[1];
+    const next0 = lerp(prev0, this.target[0], factor);
+    const next1 = lerp(prev1, this.target[1], factor);
+    const moved = next0 !== prev0 || next1 !== prev1;
+    if (moved || this.targetDirty) {
+      this.value = [next0, next1];
+      this.targetDirty = false;
+      const snapshot = [next0, next1];
+      for (const listener of this.listeners) listener(snapshot);
+    }
+  }
+  /** Tear down listeners. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.eventTarget.removeEventListener("mousemove", this.handleMouseMove);
+    this.listeners.clear();
+  }
+};
+var clamp01 = (n) => Math.max(0, Math.min(1, n));
+var lerp = (a, b, t) => a + (b - a) * t;
+
+// src/primitives/colorRamp.ts
+import { mix, vec3 } from "three/tsl";
+function colorRamp(t, stops) {
+  if (stops.length === 0) return vec3(0, 0, 0);
+  if (stops.length === 1) return stops[0].color;
+  let result = stops[0].color;
+  for (let i = 1; i < stops.length; i++) {
+    const prev = stops[i - 1];
+    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);
+    result = mix(result, next.color, localT);
+  }
+  return result;
+}
+
+// src/primitives/noise.ts
+import { mx_noise_float } from "three/tsl";
+function noise(p) {
+  return mx_noise_float(p);
+}
+
+// src/primitives/fbm.ts
+function fbm(p, opts = {}) {
+  const octaves = opts.octaves ?? 4;
+  const lacunarity = opts.lacunarity ?? 2;
+  const gain = opts.gain ?? 0.5;
+  let sum = noise(p);
+  let amp = 1;
+  let freq = 1;
+  let total = amp;
+  for (let i = 1; i < octaves; i++) {
+    freq *= lacunarity;
+    amp *= gain;
+    total += amp;
+    const pAtFreq = p.mul(freq);
+    const layer = noise(pAtFreq).mul(amp);
+    sum = sum.add(layer);
+  }
+  return sum.div(total);
+}
+
+// src/primitives/voronoi.ts
+import { mx_worley_noise_float } from "three/tsl";
+function voronoi(p) {
+  return mx_worley_noise_float(p);
+}
+
+// src/primitives/quantize.ts
+function quantize(t, steps) {
+  if (steps <= 1) {
+    return t.mul(0);
+  }
+  const denom = steps - 1;
+  return t.mul(denom).add(0.5).floor().div(denom);
+}
+
+// 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);
+}
+
+// src/primitives/displace.ts
+function displace(p, by) {
+  return p.add(by);
+}
+
+// src/primitives/cursorRipple.ts
+import { sin as sin2, length as length3, smoothstep as smoothstep2 } 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";
+import { time as _builtinTime } from "three/tsl";
+
+// src/runtime/reducedMotion.ts
+import { uniform } from "three/tsl";
+var state = {
+  policy: "auto",
+  watchers: /* @__PURE__ */ new Set()
+};
+function setReducedMotionPolicy(policy) {
+  if (state.policy === policy) return;
+  state.policy = policy;
+  for (const w of state.watchers) w.recompute();
+}
+function getReducedMotionPolicy() {
+  return state.policy;
+}
+var computeScale = (mqlMatches) => {
+  switch (state.policy) {
+    case "off":
+      return 1;
+    case "slow":
+      return 0.3;
+    case "paused":
+      return 0;
+    case "auto":
+      return mqlMatches ? 0.3 : 1;
+  }
+};
+function createReducedMotionWatcher() {
+  if (typeof matchMedia !== "function") {
+    return {
+      scale: () => computeScale(false),
+      subscribe: (cb) => {
+        void cb;
+        return () => {
+        };
+      },
+      /** SSR watcher does not emit policy-change notifications. */
+      dispose: () => {
+      }
+    };
+  }
+  const mql = matchMedia("(prefers-reduced-motion: reduce)");
+  const subs = /* @__PURE__ */ new Set();
+  let last = computeScale(mql.matches);
+  const onChange = () => {
+    const next = computeScale(mql.matches);
+    if (next !== last) {
+      last = next;
+      for (const cb of subs) cb(next);
+    }
+  };
+  mql.addEventListener("change", onChange);
+  const watcher = {
+    scale: () => last,
+    subscribe(cb) {
+      subs.add(cb);
+      return () => subs.delete(cb);
+    },
+    recompute() {
+      const next = computeScale(mql.matches);
+      if (next !== last) {
+        last = next;
+        for (const cb of subs) cb(next);
+      }
+    },
+    dispose() {
+      mql.removeEventListener("change", onChange);
+      subs.clear();
+      state.watchers.delete(watcher);
+    }
+  };
+  state.watchers.add(watcher);
+  return watcher;
+}
+var globalScaleUniform = null;
+var globalWatcher = null;
+function getReducedMotionTimeScale() {
+  if (globalScaleUniform === null) {
+    globalWatcher = createReducedMotionWatcher();
+    globalScaleUniform = uniform(globalWatcher.scale());
+    globalWatcher.subscribe((s) => {
+      if (globalScaleUniform === null) return;
+      globalScaleUniform.value = s;
+    });
+  }
+  return globalScaleUniform;
+}
+
+// src/primitives/tsl-reexports.ts
+var time = _builtinTime.mul(
+  getReducedMotionTimeScale()
+);
+
+// src/primitives/cursorRipple.ts
+function cursorRipple(p, center, opts = {}) {
+  const reach = opts.reach ?? 0.4;
+  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);
+  return wave.mul(amplitude).mul(decay);
+}
+
+// src/runtime/visibility.ts
+function createVisibilityWatcher() {
+  if (typeof document === "undefined") {
+    return {
+      isVisible: () => true,
+      subscribe: () => () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const subs = /* @__PURE__ */ new Set();
+  const onChange = () => {
+    const v = document.visibilityState === "visible";
+    for (const cb of subs) cb(v);
+  };
+  document.addEventListener("visibilitychange", onChange);
+  return {
+    isVisible: () => document.visibilityState === "visible",
+    subscribe(cb) {
+      subs.add(cb);
+      return () => subs.delete(cb);
+    },
+    dispose() {
+      document.removeEventListener("visibilitychange", onChange);
+      subs.clear();
+    }
+  };
+}
+
+// src/runtime/intersection.ts
+function createIntersectionWatcher(canvas) {
+  if (typeof IntersectionObserver === "undefined") {
+    return {
+      isInView: () => true,
+      subscribe: () => () => {
+      },
+      dispose: () => {
+      }
+    };
+  }
+  const subs = /* @__PURE__ */ new Set();
+  let inView = true;
+  const obs = new IntersectionObserver(
+    (entries) => {
+      const next = entries.some((e) => e.isIntersecting);
+      if (next === inView) return;
+      inView = next;
+      for (const cb of subs) cb(inView);
+    },
+    { threshold: 0 }
+  );
+  obs.observe(canvas);
+  return {
+    isInView: () => inView,
+    subscribe(cb) {
+      subs.add(cb);
+      return () => subs.delete(cb);
+    },
+    dispose() {
+      obs.disconnect();
+      subs.clear();
+    }
+  };
+}
+export {
+  CursorInput,
+  MatterScheduler,
+  colorRamp,
+  cos,
+  createIntersectionWatcher,
+  createReducedMotionWatcher,
+  createRenderer,
+  createVisibilityWatcher,
+  cursorRipple,
+  displace,
+  dot,
+  fbm,
+  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

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime/createRenderer.ts","../src/runtime/MatterScheduler.ts","../src/inputs/CursorInput.ts","../src/primitives/colorRamp.ts","../src/primitives/noise.ts","../src/primitives/fbm.ts","../src/primitives/voronoi.ts","../src/primitives/quantize.ts","../src/primitives/sdfCircle.ts","../src/primitives/displace.ts","../src/primitives/cursorRipple.ts","../src/primitives/tsl-reexports.ts","../src/runtime/reducedMotion.ts","../src/runtime/visibility.ts","../src/runtime/intersection.ts"],"sourcesContent":["import { WebGPURenderer } from 'three/webgpu'\nimport { Color } from 'three'\n\nexport type MatterBackend = 'webgpu' | 'webgl2'\n\nexport interface CreateRendererOptions {\n  /** Anti-alias the framebuffer. Default: true. */\n  antialias?: boolean\n  /** Force WebGL2 even if WebGPU is available (useful for testing fallback). Default: false. */\n  forceWebGL?: boolean\n  /** Clear color (hex, CSS string, or THREE.Color). Default: transparent. */\n  clearColor?: number | string | Color\n  /** Clear alpha (0–1). Default: 0 (transparent). */\n  clearAlpha?: number\n  /** Cap on devicePixelRatio. Default: 2. Pass Infinity to disable. */\n  maxDPR?: number\n}\n\nexport interface MatterRenderer {\n  /** The underlying Three.js WebGPURenderer (which may be running on a WebGL2 backend). */\n  three: WebGPURenderer\n  /** Which backend the renderer initialized with. */\n  backend: MatterBackend\n  /** Tear down the renderer and release GPU resources. */\n  dispose: () => void\n  /** Resize the renderer to the canvas's current client dimensions. */\n  resize: () => void\n}\n\n/**\n * Create a Matter renderer wrapping THREE.WebGPURenderer.\n *\n * Tries WebGPU first; falls back to WebGL2 automatically if WebGPU is\n * unavailable on the host. The returned object exposes the underlying\n * three renderer plus a small wrapper for resize and disposal.\n */\nexport async function createRenderer(\n  canvas: HTMLCanvasElement,\n  opts: CreateRendererOptions = {},\n): Promise<MatterRenderer> {\n  const {\n    antialias = true,\n    forceWebGL = false,\n    clearColor = 0x000000,\n    clearAlpha = 0,\n    maxDPR = 2,\n  } = opts\n\n  const three = new WebGPURenderer({\n    canvas,\n    antialias,\n    forceWebGL,\n  })\n\n  await three.init()\n\n  three.setPixelRatio(Math.min(window.devicePixelRatio, maxDPR))\n  const resolvedClearColor =\n    clearColor instanceof Color ? clearColor : new Color(clearColor as number | string)\n  three.setClearColor(resolvedClearColor, clearAlpha)\n\n  const resize = () => {\n    const w = canvas.clientWidth\n    const h = canvas.clientHeight\n    if (canvas.width !== w * three.getPixelRatio() || canvas.height !== h * three.getPixelRatio()) {\n      three.setSize(w, h, false)\n    }\n  }\n  resize()\n\n  // Detect backend after init. The exact API may differ between three versions;\n  // probe the renderer's backend symbol if present, fall back to a property check.\n  const backend: MatterBackend =\n    forceWebGL || (three as unknown as { backend?: { isWebGLBackend?: boolean } }).backend?.isWebGLBackend\n      ? 'webgl2'\n      : 'webgpu'\n\n  return {\n    three,\n    backend,\n    dispose: () => three.dispose(),\n    resize,\n  }\n}\n","export interface SchedulerTick {\n  /** Seconds since the previous tick. 0 on the first call. */\n  delta: number\n  /** Total seconds since the scheduler started its current run. */\n  elapsed: number\n  /** The raw `performance.now()` timestamp the rAF callback received. */\n  now: number\n}\n\nexport type SchedulerClient = (tick: SchedulerTick) => void\n\n/**\n * Batches `requestAnimationFrame` calls across all clients registered with\n * a single scheduler. One scheduler is created per <MatterScene>; clients\n * are typically a Three.js renderer's render call.\n */\nexport class MatterScheduler {\n  private readonly clients = new Set<SchedulerClient>()\n  private rafId: number | null = null\n  private running = false\n  private paused = false\n  private idle = false\n  private flushPending = false\n  private startedAt = 0\n  private lastTickAt = 0\n\n  /** Activate the scheduler. The rAF loop starts on the first client added. */\n  start(): void {\n    this.running = true\n    this.paused = false\n    this.maybeQueue()\n  }\n\n  /** Halt the rAF loop entirely. Use dispose() for permanent teardown. */\n  stop(): void {\n    this.running = false\n    this.cancel()\n  }\n\n  /** Temporarily skip ticks without losing client registrations. */\n  pause(): void {\n    this.paused = true\n  }\n\n  /** Resume after pause(). */\n  resume(): void {\n    this.paused = false\n    if (this.running) this.maybeQueue()\n  }\n\n  /** Register a client to be called every frame. */\n  add(client: SchedulerClient): void {\n    this.clients.add(client)\n    if (this.running) this.maybeQueue()\n  }\n\n  /** Unregister a client. */\n  remove(client: SchedulerClient): void {\n    this.clients.delete(client)\n  }\n\n  /** Permanent teardown: stop the loop and drop all clients. */\n  dispose(): void {\n    this.stop()\n    this.clients.clear()\n  }\n\n  /**\n   * Mark the scheduler idle. The next tick still fires (a final flush so\n   * uniform changes that triggered the idle state are rendered), then the\n   * rAF loop halts. Use `requestRender()` or `setIdle(false)` to wake.\n   */\n  setIdle(idle: boolean): void {\n    if (this.idle === idle) return\n    this.idle = idle\n    if (idle) {\n      this.flushPending = true\n      this.maybeQueue()\n    } else {\n      this.flushPending = false\n      this.maybeQueue()\n    }\n  }\n\n  /** Force a single tick while idle. Useful for prop-change invalidation. */\n  requestRender(): void {\n    if (!this.idle) return\n    this.flushPending = true\n    this.maybeQueue()\n  }\n\n  private maybeQueue(): void {\n    if (this.rafId !== null) return\n    if (!this.running) return\n    if (this.clients.size === 0) return\n    if (this.idle && !this.flushPending) return\n    this.rafId = requestAnimationFrame(this.frame)\n  }\n\n  private cancel(): void {\n    if (this.rafId !== null) {\n      cancelAnimationFrame(this.rafId)\n      this.rafId = null\n    }\n  }\n\n  private readonly frame = (now: number): void => {\n    this.rafId = null\n    if (!this.running || this.paused) return\n\n    if (this.startedAt === 0) {\n      this.startedAt = now\n      this.lastTickAt = now\n    }\n    const delta = (now - this.lastTickAt) / 1000\n    const elapsed = (now - this.startedAt) / 1000\n    this.lastTickAt = now\n\n    const tick: SchedulerTick = { delta, elapsed, now }\n    for (const client of this.clients) {\n      client(tick)\n    }\n\n    this.flushPending = false\n    this.maybeQueue()\n  }\n}\n","export type Vec2 = readonly [number, number]\n\nexport interface CursorInputOptions {\n  /**\n   * Smoothing factor: 0 = no smoothing (snap to target instantly).\n   * 1 = max smoothing (essentially never reaches target).\n   * Sensible default: 0.1.\n   *\n   * Implementation: per-frame, value moves toward target by `(1 - smoothing) * delta * 60`,\n   * roughly meaning \"at smoothing=0.1, ~90% of the gap is closed in 1 second at 60fps.\"\n   */\n  smoothing?: number\n  /** Starting position. Default: [0.5, 0.5] (center). */\n  initial?: Vec2\n  /** Listen on this target. Default: window. */\n  target?: EventTarget\n  /**\n   * Element to normalize cursor coordinates against. Default: window viewport.\n   *\n   * When set, cursor x/y are in [0,1] across the element's bounding rect, with\n   * extrapolation outside (negative when left/above, >1 when right/below). This\n   * matches what shader UV space expects: a cursor at the canvas's top-left\n   * corner reads as (0, 0); at bottom-right as (1, 1); regardless of where the\n   * canvas sits in the viewport. Without this, components inside a partial-\n   * viewport scene (e.g. a 70vh hero section) see a cursor offset that scales\n   * with the canvas's vertical position on the page.\n   */\n  element?: { getBoundingClientRect(): { left: number; top: number; width: number; height: number } }\n}\n\ntype ChangeListener = (value: Vec2) => void\n\n/**\n * Smoothed pointer tracker emitting a normalized (0..1) Vec2 position.\n * Implements the MatterSignal protocol (`get()` + `on('change', cb)`)\n * so it composes with Motion's `useTransform` and similar tools.\n */\nexport class CursorInput {\n  private value: [number, number]\n  private target: [number, number]\n  private targetDirty = false\n  private readonly smoothing: number\n  private readonly listeners = new Set<ChangeListener>()\n  private readonly eventTarget: EventTarget\n  private readonly element: CursorInputOptions['element']\n  private readonly handleMouseMove: (e: Event) => void\n  private disposed = false\n\n  constructor(opts: CursorInputOptions = {}) {\n    const { smoothing = 0.1, initial = [0.5, 0.5], target, element } = opts\n    this.smoothing = clamp01(smoothing)\n    this.value = [initial[0], initial[1]]\n    this.target = [initial[0], initial[1]]\n    this.eventTarget = target ?? (typeof window !== 'undefined' ? window : new EventTarget())\n    this.element = element\n\n    this.handleMouseMove = (e: Event) => {\n      const me = e as MouseEvent\n      if (this.element) {\n        // Normalize to 0..1 across the element's bounding rect. Reading the\n        // rect on every move is fine — `getBoundingClientRect` is cheap and\n        // mousemove is already throttled to ~60Hz by the browser. The benefit\n        // is tracking the element's position even if it moved/scrolled since\n        // the last frame.\n        const r = this.element.getBoundingClientRect()\n        const w = r.width || 1\n        const h = r.height || 1\n        this.target = [(me.clientX - r.left) / w, (me.clientY - r.top) / h]\n      } else {\n        // Fallback: viewport-normalized. Used when no element is supplied —\n        // mostly the standalone-API case for users not consuming through\n        // <MatterScene>'s context.\n        const w = (typeof window !== 'undefined' && window.innerWidth) || 1\n        const h = (typeof window !== 'undefined' && window.innerHeight) || 1\n        this.target = [me.clientX / w, me.clientY / h]\n      }\n      this.targetDirty = true\n    }\n\n    this.eventTarget.addEventListener('mousemove', this.handleMouseMove)\n  }\n\n  /** Current smoothed position. Implements MatterSignal protocol. */\n  get(): Vec2 {\n    return this.value\n  }\n\n  /** Subscribe to change events. Returns an unsubscribe function. */\n  on(_event: 'change', cb: ChangeListener): () => void {\n    this.listeners.add(cb)\n    return () => this.listeners.delete(cb)\n  }\n\n  /**\n   * Advance the smoothing one tick. Called by the host scheduler; not\n   * typically called directly except in tests.\n   */\n  tick(delta: number): void {\n    if (this.disposed) return\n    const factor = this.smoothing === 0 ? 1 : 1 - Math.pow(this.smoothing, delta * 60)\n    const prev0 = this.value[0]\n    const prev1 = this.value[1]\n    const next0 = lerp(prev0, this.target[0], factor)\n    const next1 = lerp(prev1, this.target[1], factor)\n    const moved = next0 !== prev0 || next1 !== prev1\n    if (moved || this.targetDirty) {\n      this.value = [next0, next1]\n      this.targetDirty = false\n      const snapshot: Vec2 = [next0, next1]\n      for (const listener of this.listeners) listener(snapshot)\n    }\n  }\n\n  /** Tear down listeners. */\n  dispose(): void {\n    if (this.disposed) return\n    this.disposed = true\n    this.eventTarget.removeEventListener('mousemove', this.handleMouseMove)\n    this.listeners.clear()\n  }\n}\n\nconst clamp01 = (n: number) => Math.max(0, Math.min(1, n))\nconst lerp = (a: number, b: number, t: number) => a + (b - a) * t\n","import { mix, vec3 } from 'three/tsl'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\nexport type TSLNode = Node | ShaderNodeObject<Node>\n\nexport interface ColorRampStop {\n  /** Color expressed as a TSL node (typically `vec3(r,g,b)`). */\n  color: TSLNode\n  /** Position 0..1 along the ramp. */\n  position: number\n}\n\n/**\n * Multi-stop color interpolation. Given a t in [0..1] and N color stops at\n * fixed positions, returns the smoothly-interpolated color.\n *\n * Falls back to the first/last stop's color outside the bracketing positions.\n */\nexport function colorRamp(t: TSLNode, stops: ColorRampStop[]): TSLNode {\n  if (stops.length === 0) return vec3(0, 0, 0)\n  if (stops.length === 1) return stops[0]!.color\n\n  // Build a chain of nested mixes, one per adjacent pair of stops.\n  // For three stops at positions 0, 0.5, 1:\n  //   inner = mix(stop0, stop1, smoothstep(0, 0.5, t))\n  //   outer = mix(inner, stop2, smoothstep(0.5, 1, t))\n  let result: TSLNode = stops[0]!.color\n  for (let i = 1; i < stops.length; i++) {\n    const prev = stops[i - 1]!\n    const next = stops[i]!\n    const span = next.position - prev.position\n    if (span <= 0) continue\n    // Localize t into the [prev..next] range.\n    const tNode = t as ShaderNodeObject<Node>\n    const localT = tNode.sub(prev.position).div(span).clamp(0, 1)\n    result = mix(result, next.color, localT)\n  }\n  return result\n}\n","// packages/matter/src/primitives/noise.ts\nimport { mx_noise_float } from 'three/tsl'\nimport type { TSLNode } from './colorRamp.js'\n\n/**\n * 2D simplex noise sampled at a point. Returns a scalar TSL node in\n * approximately [-1, 1] (MaterialX's mx_noise_float is roughly that range).\n *\n * @param p — Vec2 TSL node (typically `uv()` or a scaled/offset uv).\n *\n * Built on top of three's `mx_noise_float`; we wrap it so consumers have a\n * stable import path through `@lovo/matter` and we can swap the\n * implementation if a different noise primitive proves better in practice.\n */\nexport function noise(p: TSLNode): TSLNode {\n  return mx_noise_float(p) as unknown as TSLNode\n}\n","// packages/matter/src/primitives/fbm.ts\nimport { noise } from './noise.js'\nimport type { TSLNode } from './colorRamp.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\nexport interface FBMOptions {\n  /** Number of octaves to sum. JS-side number — fixed at TSL build time, not a uniform. Default: 4. */\n  octaves?: number\n  /** Per-octave frequency multiplier. JS-side number. Default: 2. */\n  lacunarity?: number\n  /** Per-octave amplitude multiplier. JS-side number. Default: 0.5. */\n  gain?: number\n}\n\n/**\n * Fractal Brownian Motion — sum of N octaves of 2D simplex noise.\n *\n * `octaves`, `lacunarity`, and `gain` are JavaScript numbers (NOT TSL\n * uniforms) because the loop must be unrolled at TSL-build time — TSL has\n * no dynamic-length loop primitive that maps cleanly to all backends.\n * Animatable parameters that *do* survive on the GPU are the input UV\n * (which the caller can scale/translate per frame) and `time`.\n *\n * @param p — Vec2 TSL node (UV-space position).\n * @returns scalar TSL node, roughly [-1..1] but normalized closer to\n *          [-0.5..0.5] when amplitude sums approach 1 with the default gain.\n */\nexport function fbm(p: TSLNode, opts: FBMOptions = {}): TSLNode {\n  const octaves = opts.octaves ?? 4\n  const lacunarity = opts.lacunarity ?? 2\n  const gain = opts.gain ?? 0.5\n\n  let sum: TSLNode = noise(p)\n  let amp = 1\n  let freq = 1\n  let total = amp\n  for (let i = 1; i < octaves; i++) {\n    freq *= lacunarity\n    amp *= gain\n    total += amp\n    // Multiply UV by the per-octave frequency before sampling.\n    // (`p as ShaderNodeObject` so we can call `.mul`; #12 doesn't apply\n    //  here because `p` is built from `uv()`/`vec2()`, not from a uniform.)\n    const pAtFreq = (p as ShaderNodeObject<Node>).mul(freq)\n    const layer = (noise(pAtFreq) as ShaderNodeObject<Node>).mul(amp)\n    sum = (sum as ShaderNodeObject<Node>).add(layer)\n  }\n  // Normalize to approximate [-1..1] regardless of octave count / gain.\n  return (sum as ShaderNodeObject<Node>).div(total)\n}\n","// packages/matter/src/primitives/voronoi.ts\nimport { mx_worley_noise_float } from 'three/tsl'\nimport type { TSLNode } from './colorRamp.js'\n\n/**\n * 2D voronoi (Worley) noise — distance to the nearest jittered cell point,\n * normalized roughly to [0, 1]. Higher values = farther from any cell point\n * (cell interiors); lower values = near a cell boundary.\n *\n * Built on three's `mx_worley_noise_float`. Combine with `colorRamp` for\n * a multi-color cellular pattern; threshold via `step`/`smoothstep` for\n * hard cell shapes.\n *\n * @param p — Vec2 TSL node, typically `uv() * scale`.\n */\nexport function voronoi(p: TSLNode): TSLNode {\n  return mx_worley_noise_float(p) as unknown as TSLNode\n}\n","// packages/matter/src/primitives/quantize.ts\nimport type { TSLNode } from './colorRamp.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\n/**\n * Quantize a scalar TSL node to `steps` discrete levels.\n *\n *   quantize(t, 4) → values in {0, 0.25, 0.5, 0.75, 1.0}\n *\n * `steps` is a JS-side number (loop-equivalent at TSL build time, baked in).\n * If you need an animatable step count, rebuild the TSL fragment.\n */\nexport function quantize(t: TSLNode, steps: number): TSLNode {\n  if (steps <= 1) {\n    // Edge case: single step → constant 0. Return as-is wrapped in mul(0).\n    return (t as ShaderNodeObject<Node>).mul(0)\n  }\n  const denom = steps - 1\n  // floor(t * (steps-1) + 0.5) / (steps-1)\n  // Using floor(x + 0.5) instead of round() for TSL portability.\n  return (t as ShaderNodeObject<Node>)\n    .mul(denom)\n    .add(0.5)\n    .floor()\n    .div(denom)\n}\n","import { length } from 'three/tsl'\nimport type { TSLNode } from './colorRamp.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\n/**\n * Signed distance field for a circle centered at the origin.\n *\n *   sdfCircle(p, r) = length(p) - r\n *\n * Negative inside the circle, zero on the boundary, positive outside.\n * Combine with `smoothstep(-edge, +edge, sdf)` to render a soft-edged disk.\n *\n * @param p — Vec2 TSL node (typically a UV-space offset from the center).\n * @param radius — JS-side scalar OR a scalar TSL node.\n */\nexport function sdfCircle(p: TSLNode, radius: TSLNode | number): TSLNode {\n  const lp = length(p) as ShaderNodeObject<Node>\n  if (typeof radius === 'number') {\n    return lp.sub(radius)\n  }\n  return lp.sub(radius as ShaderNodeObject<Node>)\n}\n","import type { TSLNode } from './colorRamp.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\n/**\n * Naive vector addition: returns `p + by`.\n *\n *   displace(p, by) = p + by\n *\n * Thin wrapper that names the spatial intent of shifting a sample point.\n *\n * **SDF caveat:** when using this to translate an SDF render, pass the\n * NEGATED translation — `sdfCircle(displace(p, v.mul(-1)), r)` renders the\n * disk at position `+v` because SDF translation evaluates as\n * `length(p - center) - r`. Adding `+v` to the sample point shifts the\n * rendered shape in the OPPOSITE direction.\n *\n * @param p — Vec2 TSL node (the position being displaced).\n * @param by — Vec2 TSL node (the displacement vector).\n */\nexport function displace(p: TSLNode, by: TSLNode): TSLNode {\n  return (p as ShaderNodeObject<Node>).add(by as ShaderNodeObject<Node>)\n}\n","import { sin, length, smoothstep } from 'three/tsl'\nimport { time } from './tsl-reexports.js'\nimport type { TSLNode } from './colorRamp.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\nexport interface CursorRippleOptions {\n  /** Decay radius (UV space). Beyond this, the ripple is ~0. Default: 0.4. */\n  reach?: number\n  /** Wavelength controls the ripple spacing. Default: 30. Larger = wider rings. */\n  frequency?: number\n  /** Time multiplier on the wave phase. Default: 6. Larger = faster oscillation. */\n  speed?: number\n  /** Output amplitude. Default: 0.5. Final result is in roughly [-amplitude, +amplitude]. */\n  amplitude?: number\n}\n\n/**\n * A radial ripple emanating from `center`. Returns a scalar TSL node in\n * roughly [-amplitude, +amplitude] that decays to ~0 outside `reach`.\n *\n *   ripple = sin(d*frequency - time*speed) * amplitude * smoothstep(reach, 0, d)\n *\n * Compose into a wave field by adding it to the underlying base wave.\n *\n * Note: `frequency` / `speed` / `reach` / `amplitude` are JS-side numbers\n * (baked into the TSL fragment at material-build time). The animatable\n * cursor position is the only live uniform consumed.\n *\n * @param p — Vec2 TSL node (typically `uv()`).\n * @param center — Vec2 TSL node (cursor uniform, in UV space).\n */\nexport function cursorRipple(\n  p: TSLNode,\n  center: TSLNode,\n  opts: CursorRippleOptions = {},\n): TSLNode {\n  const reach = opts.reach ?? 0.4\n  const frequency = opts.frequency ?? 30\n  const speed = opts.speed ?? 6\n  const amplitude = opts.amplitude ?? 0.5\n\n  // d = length(p - center). Build the chain rooted in `p` (uv()-derived) and\n  // pass `center` (a uniform in real callers) as the SUBTRACTION ARGUMENT —\n  // never as the receiver. Per gotcha #12, chaining `.sub(...).mul(...)` off\n  // a raw `uniform()` receiver silently produces wrong GPU values.\n  const d = length(\n    (p as ShaderNodeObject<Node>).sub(center as ShaderNodeObject<Node>),\n  ) as ShaderNodeObject<Node>\n  // `time` is the engine-gated TSL node (re-exported from tsl-reexports.ts);\n  // chains rooted in `time` automatically respect `prefers-reduced-motion` and\n  // the runtime override set via `setReducedMotionPolicy`.\n  const wave = sin(d.mul(frequency).sub(time.mul(speed))) as ShaderNodeObject<Node>\n  const decay = smoothstep(reach, 0, d as never) as ShaderNodeObject<Node>\n  return wave.mul(amplitude).mul(decay)\n}\n","// Stable surface for TSL primitives matter consumers reach for constantly.\n// Re-exporting through @lovo/matter means user code has one import path\n// and we can absorb three.js TSL renames without breaking downstream code.\n\nexport {\n  uniform,\n  vec2,\n  vec3,\n  vec4,\n  mix,\n  smoothstep,\n  mod,\n  sin,\n  cos,\n  length,\n  dot,\n  normalize,\n  uv,\n  max,\n  min,\n} from 'three/tsl'\n\nimport { time as _builtinTime } from 'three/tsl'\nimport { getReducedMotionTimeScale } from '../runtime/reducedMotion.js'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\n/**\n * Engine-gated `time`: equals the TSL built-in `time` multiplied by the\n * reduced-motion scale uniform. Components consuming `time` from `@lovo/matter`\n * automatically respect `prefers-reduced-motion` and the policy override set\n * via `setReducedMotionPolicy`.\n *\n * If you want raw uncapped time (e.g. for a debug overlay), import\n * `time` from `three/tsl` directly.\n */\nexport const time: ShaderNodeObject<Node> = (_builtinTime as ShaderNodeObject<Node>).mul(\n  getReducedMotionTimeScale(),\n) as ShaderNodeObject<Node>\n","import { uniform } from 'three/tsl'\nimport type { ShaderNodeObject } from 'three/tsl'\nimport type { Node } from 'three/webgpu'\n\nexport type ReducedMotionPolicy = 'auto' | 'off' | 'slow' | 'paused'\n\n/**\n * Public surface exposed to package consumers. `recompute` is intentionally\n * absent — it is engine-internal and should not be callable from outside.\n */\nexport interface ReducedMotionWatcher {\n  /** Current time scale: 0, 0.3, or 1. */\n  scale(): number\n  /** Subscribe to scale changes. Returns unsubscribe. */\n  subscribe(cb: (scale: number) => void): () => void\n  /** Tear down media-query listener. */\n  dispose(): void\n}\n\n/**\n * Engine-internal extension of the public watcher. Only `setReducedMotionPolicy`\n * calls `recompute`; it is never part of the consumer-visible type.\n */\ninterface InternalWatcher extends ReducedMotionWatcher {\n  recompute(): void\n}\n\ninterface PolicyState {\n  policy: ReducedMotionPolicy\n  watchers: Set<InternalWatcher>\n}\n\nconst state: PolicyState = {\n  policy: 'auto',\n  watchers: new Set(),\n}\n\n/**\n * Override Matter's default behavior of honoring `prefers-reduced-motion`.\n * - 'auto'   — follow the OS media query (default)\n * - 'off'    — full speed regardless of OS setting\n * - 'slow'   — 30% speed regardless of OS setting\n * - 'paused' — 0 (animation effectively frozen) regardless of OS setting\n */\nexport function setReducedMotionPolicy(policy: ReducedMotionPolicy): void {\n  if (state.policy === policy) return\n  state.policy = policy\n  for (const w of state.watchers) w.recompute()\n}\n\nexport function getReducedMotionPolicy(): ReducedMotionPolicy {\n  return state.policy\n}\n\nconst computeScale = (mqlMatches: boolean): number => {\n  switch (state.policy) {\n    case 'off':\n      return 1\n    case 'slow':\n      return 0.3\n    case 'paused':\n      return 0\n    case 'auto':\n      return mqlMatches ? 0.3 : 1\n  }\n}\n\n/**\n * Create a watcher that tracks `prefers-reduced-motion: reduce` and the\n * global Matter policy override. Strict-mode-safe — callers create+dispose\n * one per mount cycle.\n */\nexport function createReducedMotionWatcher(): ReducedMotionWatcher {\n  // SSR safety: bail to the no-op watcher if matchMedia is missing.\n  // SSR watcher: scale() respects policy override but does not emit\n  // subscription events (the engine has no way to notify SSR-created\n  // watchers because they are not added to state.watchers — but in\n  // practice CLAUDE.md gotcha #10 requires `ssr: false` for any component\n  // that touches the matter engine).\n  if (typeof matchMedia !== 'function') {\n    return {\n      scale: () => computeScale(false),\n      subscribe: (cb) => {\n        // No-op: SSR watchers are not in state.watchers and will never\n        // receive policy-change notifications.\n        void cb\n        return () => {}\n      },\n      /** SSR watcher does not emit policy-change notifications. */\n      dispose: () => {},\n    }\n  }\n\n  const mql = matchMedia('(prefers-reduced-motion: reduce)')\n  const subs = new Set<(s: number) => void>()\n  let last = computeScale(mql.matches)\n\n  const onChange = () => {\n    const next = computeScale(mql.matches)\n    if (next !== last) {\n      last = next\n      for (const cb of subs) cb(next)\n    }\n  }\n\n  mql.addEventListener('change', onChange)\n\n  const watcher: InternalWatcher = {\n    scale: () => last,\n    subscribe(cb) {\n      subs.add(cb)\n      return () => subs.delete(cb)\n    },\n    recompute() {\n      const next = computeScale(mql.matches)\n      if (next !== last) {\n        last = next\n        for (const cb of subs) cb(next)\n      }\n    },\n    dispose() {\n      mql.removeEventListener('change', onChange)\n      subs.clear()\n      state.watchers.delete(watcher)\n    },\n  }\n  state.watchers.add(watcher)\n  return watcher\n}\n\nlet globalScaleUniform: ShaderNodeObject<Node> | null = null\nlet globalWatcher: ReducedMotionWatcher | null = null\n\n/**\n * Returns the engine-shared TSL uniform that `time` is multiplied by. Lazily\n * initialized on first read; reused across all materials. Mutating `.value`\n * imperatively when policy changes is safe — TSL re-reads the uniform every\n * frame.\n */\nexport function getReducedMotionTimeScale(): ShaderNodeObject<Node> {\n  if (globalScaleUniform === null) {\n    globalWatcher = createReducedMotionWatcher()\n    globalScaleUniform = uniform(globalWatcher.scale()) as unknown as ShaderNodeObject<Node>\n    globalWatcher.subscribe((s) => {\n      if (globalScaleUniform === null) return\n      ;(globalScaleUniform as unknown as { value: number }).value = s\n    })\n  }\n  return globalScaleUniform\n}\n\n// Keep a typed reference for tests that may want to re-init between tests.\nexport const __resetReducedMotionForTests = () => {\n  globalWatcher?.dispose()\n  globalWatcher = null\n  globalScaleUniform = null\n}\n","export interface VisibilityWatcher {\n  isVisible(): boolean\n  /** Subscribe to changes. Receives the new visibility state. Returns unsubscribe. */\n  subscribe(cb: (visible: boolean) => void): () => void\n  dispose(): void\n}\n\n/**\n * Watch `document.visibilityState`. Strict-mode-safe — callers create+dispose\n * one per mount cycle.\n *\n * SSR: if `document` is unavailable, returns a no-op watcher whose\n * `isVisible()` always returns `true` and whose `subscribe` does nothing.\n */\nexport function createVisibilityWatcher(): VisibilityWatcher {\n  if (typeof document === 'undefined') {\n    return {\n      isVisible: () => true,\n      subscribe: () => () => {},\n      dispose: () => {},\n    }\n  }\n\n  const subs = new Set<(v: boolean) => void>()\n  const onChange = () => {\n    const v = document.visibilityState === 'visible'\n    for (const cb of subs) cb(v)\n  }\n  document.addEventListener('visibilitychange', onChange)\n\n  return {\n    isVisible: () => document.visibilityState === 'visible',\n    subscribe(cb) {\n      subs.add(cb)\n      return () => subs.delete(cb)\n    },\n    dispose() {\n      document.removeEventListener('visibilitychange', onChange)\n      subs.clear()\n    },\n  }\n}\n","export interface IntersectionWatcher {\n  isInView(): boolean\n  /** Subscribe to changes. Receives the new in-view state. Returns unsubscribe. */\n  subscribe(cb: (inView: boolean) => void): () => void\n  dispose(): void\n}\n\n/**\n * Watch a canvas's viewport intersection. Pauses tied to this watcher should\n * be resumed when the canvas is *any* fraction visible. Strict-mode-safe.\n *\n * SSR: if `IntersectionObserver` is unavailable, returns a no-op watcher whose\n * `isInView()` always returns `true` and whose `subscribe` does nothing.\n */\nexport function createIntersectionWatcher(canvas: HTMLCanvasElement): IntersectionWatcher {\n  if (typeof IntersectionObserver === 'undefined') {\n    return {\n      isInView: () => true,\n      subscribe: () => () => {},\n      dispose: () => {},\n    }\n  }\n\n  const subs = new Set<(v: boolean) => void>()\n  let inView = true\n  const obs = new IntersectionObserver(\n    (entries) => {\n      const next = entries.some((e) => e.isIntersecting)\n      if (next === inView) return\n      inView = next\n      for (const cb of subs) cb(inView)\n    },\n    { threshold: 0 },\n  )\n  obs.observe(canvas)\n\n  return {\n    isInView: () => inView,\n    subscribe(cb) {\n      subs.add(cb)\n      return () => subs.delete(cb)\n    },\n    dispose() {\n      obs.disconnect()\n      subs.clear()\n    },\n  }\n}\n"],"mappings":"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","names":["sin","length","smoothstep","uniform","vec3","mix","length","length","sin","smoothstep"]}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@lovo/matter",
+  "version": "0.1.0",
+  "description": "Engine for Matter — TSL primitives, renderer, scheduler. Framework-agnostic.",
+  "license": "MIT",
+  "keywords": [
+    "shader",
+    "shaders",
+    "webgpu",
+    "tsl",
+    "three.js",
+    "react",
+    "components",
+    "gradient",
+    "background"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovo-hq/matter.git",
+    "directory": "packages/matter"
+  },
+  "homepage": "https://github.com/lovo-hq/matter#readme",
+  "bugs": {
+    "url": "https://github.com/lovo-hq/matter/issues"
+  },
+  "author": "lovo-hq",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "three": "^0.170.0"
+  },
+  "devDependencies": {
+    "@types/three": "^0.170.0",
+    "happy-dom": "^15.0.0",
+    "three": "^0.170.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0",
+    "@matter/eslint-config": "0.0.0",
+    "@matter/tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist .turbo *.tsbuildinfo"
+  }
+}