cursedbelt 1.0.0 → 2.3.0

package/src/core/namespace/memoryStore.ts

@@ -1,77 +0,0 @@
-import type { Namespace, NamespaceCreateInput, NamespaceStore, NamespaceUpdateInput } from './types';
-import { nextHue, normalizeNamespaceLabel } from './helpers';
-
-/**
- * Zero-config in-memory {@link NamespaceStore}: a single per-boot `Map`, so a
- * host that wires nothing up still gets a working (non-persistent) namespace
- * list — the same role `createMemoryCategoryStore` plays. Swap in a
- * persistent store (f's `createSqliteNamespaceStore`) for real data.
- *
- * Deliberately not annotated `: NamespaceStore` — the interface allows async
- * returns, which would force callers (and these tests) to `await` values that
- * are always synchronous here. Structural typing keeps it assignable wherever
- * a `NamespaceStore` is expected.
- */
-export function createMemoryNamespaceStore(
-  idFactory: () => string = () => crypto.randomUUID(),
-  now: () => number = () => Date.now(),
-) {
-  const byId = new Map<string, Namespace>();
-
-  const requireNamespace = (id: string): Namespace => {
-    const ns = byId.get(id);
-    if (!ns) throw new Error(`no namespace with id ${id}`);
-    return ns;
-  };
-
-  const nextOrd = (): number => {
-    let max = -1;
-    for (const ns of byId.values()) {
-      if (ns.ord > max) max = ns.ord;
-    }
-    return max + 1;
-  };
-
-  return {
-    list(): Namespace[] {
-      return [...byId.values()].sort((a, b) => {
-        if (a.archived !== b.archived) return a.archived ? 1 : -1;
-        return a.ord - b.ord;
-      });
-    },
-
-    create(input: NamespaceCreateInput): Namespace {
-      const existing = [...byId.values()];
-      const timestamp = now();
-      const namespace: Namespace = {
-        id: idFactory(),
-        label: normalizeNamespaceLabel(input.label),
-        hue: input.hue ?? nextHue(existing),
-        ord: nextOrd(),
-        archived: false,
-        createdAt: timestamp,
-        updatedAt: timestamp,
-      };
-      byId.set(namespace.id, namespace);
-      return namespace;
-    },
-
-    update(id: string, input: NamespaceUpdateInput): Namespace {
-      const ns = requireNamespace(id);
-      const updated: Namespace = {
-        ...ns,
-        label: input.label !== undefined ? normalizeNamespaceLabel(input.label) : ns.label,
-        hue: input.hue ?? ns.hue,
-        ord: input.ord ?? ns.ord,
-        archived: input.archived ?? ns.archived,
-        updatedAt: now(),
-      };
-      byId.set(id, updated);
-      return updated;
-    },
-
-    remove(id: string): void {
-      byId.delete(id);
-    },
-  };
-}

package/src/core/namespace/namespace.spec.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { createMemoryNamespaceStore, nextHue, normalizeNamespaceLabel, type Namespace } from './index';
-
-const ns = (id: string, ord: number, archived = false, hue = 0): Namespace => ({
-  id,
-  label: id,
-  hue,
-  ord,
-  archived,
-  createdAt: 0,
-  updatedAt: 0,
-});
-
-describe('createMemoryNamespaceStore', () => {
-  it('lists in ord order', () => {
-    let n = 0;
-    const store = createMemoryNamespaceStore(() => `id${++n}`);
-    const b = store.create({ label: 'B' });
-    const a = store.create({ label: 'A' });
-    store.update(a.id, { ord: 0 });
-    store.update(b.id, { ord: 1 });
-    expect(store.list().map((x) => x.id)).toEqual([a.id, b.id]);
-  });
-
-  it('sorts archived namespaces after non-archived ones regardless of ord', () => {
-    let n = 0;
-    const store = createMemoryNamespaceStore(() => `id${++n}`);
-    const a = store.create({ label: 'A' });
-    const b = store.create({ label: 'B' });
-    store.update(a.id, { archived: true, ord: 0 });
-    store.update(b.id, { ord: 5 });
-    expect(store.list().map((x) => x.id)).toEqual([b.id, a.id]);
-  });
-
-  it('creates with auto-incrementing ord and an assigned hue', () => {
-    const store = createMemoryNamespaceStore();
-    const a = store.create({ label: 'A' });
-    const b = store.create({ label: 'B' });
-    expect(a.ord).toBe(0);
-    expect(b.ord).toBe(1);
-    expect(a.hue).toBeGreaterThanOrEqual(0);
-    expect(a.hue).toBeLessThan(360);
-  });
-
-  it('normalizes labels on create and update', () => {
-    const store = createMemoryNamespaceStore();
-    const a = store.create({ label: '  Multi   Word  ' });
-    expect(a.label).toBe('Multi Word');
-    const updated = store.update(a.id, { label: '  Renamed  ' });
-    expect(updated.label).toBe('Renamed');
-  });
-
-  it('rejects a blank label', () => {
-    const store = createMemoryNamespaceStore();
-    expect(() => store.create({ label: '   ' })).toThrow();
-  });
-
-  it('updates only the provided fields', () => {
-    const store = createMemoryNamespaceStore();
-    const a = store.create({ label: 'A', hue: 10 });
-    const updated = store.update(a.id, { archived: true });
-    expect(updated.label).toBe('A');
-    expect(updated.hue).toBe(10);
-    expect(updated.archived).toBe(true);
-  });
-
-  it('removes a namespace', () => {
-    const store = createMemoryNamespaceStore();
-    const a = store.create({ label: 'A' });
-    store.remove(a.id);
-    expect(store.list()).toEqual([]);
-  });
-
-  it('throws when updating an unknown id', () => {
-    const store = createMemoryNamespaceStore();
-    expect(() => store.update('ghost', { label: 'X' })).toThrow();
-  });
-});
-
-describe('nextHue', () => {
-  it('spreads hues across the wheel and avoids exact collisions', () => {
-    const existing: Namespace[] = [];
-    const hues: number[] = [];
-    for (let i = 0; i < 8; i++) {
-      const hue = nextHue(existing);
-      hues.push(hue);
-      existing.push(ns(`n${i}`, i, false, hue));
-    }
-    expect(new Set(hues).size).toBe(hues.length);
-    for (const hue of hues) {
-      expect(hue).toBeGreaterThanOrEqual(0);
-      expect(hue).toBeLessThan(360);
-    }
-  });
-
-  it('steps past an already-used hue instead of colliding', () => {
-    // With one existing namespace, the golden-angle step lands on hue 138 —
-    // occupy it so the collision-avoidance nudge is exercised.
-    const existing = [ns('a', 0, false, 138)];
-    expect(nextHue(existing)).toBe(139);
-  });
-});
-
-describe('normalizeNamespaceLabel', () => {
-  it('trims and collapses whitespace', () => {
-    expect(normalizeNamespaceLabel('  a   b  ')).toBe('a b');
-  });
-
-  it('caps at 40 characters', () => {
-    expect(normalizeNamespaceLabel('x'.repeat(50)).length).toBe(40);
-  });
-
-  it('rejects empty and blank labels', () => {
-    expect(() => normalizeNamespaceLabel('')).toThrow();
-    expect(() => normalizeNamespaceLabel('   ')).toThrow();
-  });
-});

package/src/core/namespace/types.ts

@@ -1,53 +0,0 @@
-// `cursedbelt/namespace` — a reusable, flat namespace/workspace model shared
-// across content plugins (notes today; aliases/… later, see ns-03). React-free
-// and storage-agnostic: the pure `Namespace` data + a host-injected
-// `NamespaceStore` contract, mirroring `cursedbelt/category`'s split between a
-// pure contract and a host-backed (SQLite) implementation. Importing this
-// module on a server never pulls React.
-
-/** A single namespace (colorway-tagged workspace). Namespaces are flat — no
- * parent/child nesting, unlike `Category`. `hue` (0–359) is the colorway seed
- * the UI derives all tints from. `ord` sorts non-archived namespaces
- * ascending; archived namespaces always sort after non-archived ones. */
-export interface Namespace {
-  id: string;
-  label: string;
-  hue: number;
-  ord: number;
-  archived: boolean;
-  createdAt: number;
-  updatedAt: number;
-}
-
-/** Fields a caller supplies when creating a namespace — the store assigns
- * `id`, timestamps, and a default `hue`/`ord` when omitted. */
-export interface NamespaceCreateInput {
-  label: string;
-  hue?: number;
-}
-
-/** Fields a caller supplies when updating a namespace — all optional, only
- * the provided fields change. */
-export interface NamespaceUpdateInput {
-  label?: string;
-  hue?: number;
-  ord?: number;
-  archived?: boolean;
-}
-
-/**
- * Storage-agnostic namespace store. The host injects a real implementation
- * (f backs it with SQLite, per-role); {@link createMemoryNamespaceStore} is
- * the zero-config in-memory default.
- *
- * `remove` is a hard delete and is only legal when the caller has already
- * verified no rows reference the namespace — callers should archive instead
- * in the common case. A host-backed store enforces this by throwing when
- * references still exist.
- */
-export interface NamespaceStore {
-  list(): Namespace[] | Promise<Namespace[]>;
-  create(input: NamespaceCreateInput): Namespace | Promise<Namespace>;
-  update(id: string, input: NamespaceUpdateInput): Namespace | Promise<Namespace>;
-  remove(id: string): void | Promise<void>;
-}

package/src/game/core/DisposeRegistry.spec.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { DisposeRegistry } from './DisposeRegistry';
-
-describe('DisposeRegistry', () => {
-  test('runs cleanups in reverse (LIFO) order and clears the list', () => {
-    const registry = new DisposeRegistry();
-    const order: number[] = [];
-    registry.add(() => order.push(1));
-    registry.add(() => order.push(2));
-    registry.add(() => order.push(3));
-
-    expect(registry.size).toBe(3);
-    registry.disposeAll();
-
-    expect(order).toEqual([3, 2, 1]);
-    expect(registry.size).toBe(0);
-    expect(registry.isDisposed).toBe(true);
-  });
-
-  test('a throwing cleanup does not strand the others', () => {
-    const registry = new DisposeRegistry();
-    const ran: string[] = [];
-    registry.add(() => ran.push('a'));
-    registry.add(() => {
-      throw new Error('boom');
-    });
-    registry.add(() => ran.push('c'));
-
-    expect(() => registry.disposeAll()).not.toThrow();
-    // 'c' (last added) runs first, then the thrower is swallowed, then 'a'.
-    expect(ran).toEqual(['c', 'a']);
-  });
-
-  test('disposeAll is idempotent', () => {
-    const registry = new DisposeRegistry();
-    let count = 0;
-    registry.add(() => count++);
-    registry.disposeAll();
-    registry.disposeAll();
-    expect(count).toBe(1);
-  });
-
-  test('adding after disposal runs the cleanup immediately (no leak)', () => {
-    const registry = new DisposeRegistry();
-    registry.disposeAll();
-    let ran = false;
-    registry.add(() => {
-      ran = true;
-    });
-    expect(ran).toBe(true);
-    expect(registry.size).toBe(0);
-  });
-});

package/src/game/core/DisposeRegistry.ts

@@ -1,70 +0,0 @@
-/**
- * A LIFO cleanup registry for game-engine resources (event listeners, rAF ids,
- * WebGL contexts, audio nodes, timers). The single source of truth that replaces
- * the per-game `DisposeRegistry` copies the apps each hand-rolled.
- *
- * A factory registers every resource it allocates with {@link DisposeRegistry.add};
- * on unmount the host hook calls {@link DisposeRegistry.disposeAll}, which runs every
- * cleanup in reverse registration order — the same ordering React uses for nested
- * effect cleanups, so resources tear down in the opposite order they were built.
- *
- * @example
- * ```ts
- * const registry = new DisposeRegistry();
- * const id = requestAnimationFrame(loop);
- * registry.add(() => cancelAnimationFrame(id));
- * canvas.addEventListener('pointermove', onMove);
- * registry.add(() => canvas.removeEventListener('pointermove', onMove));
- * // later, on unmount:
- * registry.disposeAll(); // cancels rAF, removes the listener — in reverse order
- * ```
- */
-export class DisposeRegistry {
-  private cleanups: Array<() => void> = [];
-  private disposed = false;
-
-  /**
-   * Register a cleanup. If the registry has already been disposed (e.g. an async
-   * factory resolved after unmount and registered a late listener), the cleanup runs
-   * immediately so the resource can never leak.
-   */
-  add(fn: () => void): void {
-    if (this.disposed) {
-      runSafely(fn);
-      return;
-    }
-    this.cleanups.push(fn);
-  }
-
-  /** Number of pending cleanups (handy for tests / leak assertions). */
-  get size(): number {
-    return this.cleanups.length;
-  }
-
-  /** Whether {@link disposeAll} has run. */
-  get isDisposed(): boolean {
-    return this.disposed;
-  }
-
-  /**
-   * Run every registered cleanup in reverse (LIFO) order, swallowing individual
-   * errors so one failing cleanup can't strand the rest. Idempotent: the list is
-   * cleared and the registry is permanently marked disposed.
-   */
-  disposeAll(): void {
-    this.disposed = true;
-    // Reverse order: the last resource allocated is the first torn down.
-    for (let i = this.cleanups.length - 1; i >= 0; i--) {
-      runSafely(this.cleanups[i]);
-    }
-    this.cleanups = [];
-  }
-}
-
-function runSafely(fn: () => void): void {
-  try {
-    fn();
-  } catch (error) {
-    console.error('DisposeRegistry: a cleanup threw and was swallowed', error);
-  }
-}

package/src/game/core/drawBudget.spec.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { drawBudget } from './drawBudget';
-
-describe('drawBudget', () => {
-  test('starts at full quality', () => {
-    const b = drawBudget({ targetFps: 60 });
-    expect(b.level).toBe(1);
-    expect(b.fps).toBe(60);
-  });
-
-  test('30 consecutive slow frames drop level below 0.5', () => {
-    const b = drawBudget({ targetFps: 60, windowSize: 30 });
-    for (let i = 0; i < 30; i++) b.record(50); // 50ms ≫ 16.67ms budget
-    expect(b.level).toBeLessThan(0.5);
-    expect(b.fps).toBeCloseTo(20, 0); // 1000 / 50ms
-  });
-
-  test('frames within budget hold full quality', () => {
-    const b = drawBudget({ targetFps: 60, windowSize: 30 });
-    for (let i = 0; i < 30; i++) b.record(16); // just under the 16.67ms budget
-    expect(b.level).toBe(1);
-  });
-
-  test('recovers to full quality once frames are fast again', () => {
-    const b = drawBudget({ targetFps: 60, windowSize: 30 });
-    for (let i = 0; i < 10; i++) b.record(50); // crater the level
-    expect(b.level).toBeLessThan(0.2);
-    for (let i = 0; i < 300; i++) b.record(5); // sustained comfortable frames
-    expect(b.level).toBe(1);
-  });
-
-  test('recovery is slower than the drop (hysteresis)', () => {
-    const drop = drawBudget({ targetFps: 60 });
-    drop.record(50); // one very slow frame
-    const afterOneSlow = drop.level;
-
-    const rise = drawBudget({ targetFps: 60 });
-    rise.record(5); // one fast frame (already at 1, so no change)
-    const afterOneFast = rise.level;
-
-    // A single slow frame moves level much more than a single fast frame.
-    expect(1 - afterOneSlow).toBeGreaterThan(1 - afterOneFast);
-  });
-
-  test('ignores NaN / negative frame times', () => {
-    const b = drawBudget({ targetFps: 60 });
-    b.record(Number.NaN);
-    b.record(-10);
-    expect(b.level).toBe(1);
-  });
-});

package/src/game/core/drawBudget.ts

@@ -1,75 +0,0 @@
-export interface DrawBudgetOptions {
-  /** Frame-time budget target in frames per second (default `60`). */
-  targetFps?: number;
-  /** Rolling-average window in frames (default `30`). Larger = smoother, slower to react. */
-  windowSize?: number;
-}
-
-export interface DrawBudget {
-  /** Feed the wall-clock frame time (ms) each frame; updates `level` and `fps`. */
-  record: (frameMs: number) => void;
-  /**
-   * Adaptive quality in `[0, 1]`: `1` = full quality, `0` = minimal. Games multiply
-   * expensive feature counts (shadow res, particle count, draw distance) by this.
-   * Drops quickly when behind, recovers slowly when there's headroom (hysteresis,
-   * so one stray slow frame doesn't crater quality).
-   */
-  readonly level: number;
-  /** Current rolling-average frames per second. */
-  readonly fps: number;
-}
-
-// Drop ~this fraction of `level` per frame, per multiple of target frame time over
-// budget. Recover this much per frame when comfortable. Asymmetric on purpose —
-// shed load fast, restore it gently — so quality doesn't oscillate.
-const DROP_COEFFICIENT = 0.05;
-const RECOVER_PER_FRAME = 0.01;
-
-/**
- * Adaptive draw-quality governor. Tracks a rolling average of frame times and exposes
- * a `level` games use to scale render cost so a struggling device stays responsive.
- * Replaces the duplicated per-game copies.
- */
-export function drawBudget(opts: DrawBudgetOptions = {}): DrawBudget {
-  const { targetFps = 60, windowSize = 30 } = opts;
-  const targetMs = 1000 / targetFps;
-
-  const samples: number[] = [];
-  let sum = 0;
-  let avgMs = targetMs;
-  let level = 1;
-
-  return {
-    record(frameMs: number) {
-      if (!Number.isFinite(frameMs) || frameMs < 0) return;
-
-      samples.push(frameMs);
-      sum += frameMs;
-      if (samples.length > windowSize) sum -= samples.shift() as number;
-      avgMs = sum / samples.length;
-
-      // headroom > 0 → comfortably under budget; < 0 → behind.
-      const headroom = targetMs - avgMs;
-      if (headroom < 0) {
-        // How many target-frames behind we are scales the drop; far behind drops fast.
-        level += (headroom / targetMs) * DROP_COEFFICIENT;
-      } else {
-        level += RECOVER_PER_FRAME;
-      }
-      level = clamp01(level);
-    },
-    get level() {
-      return level;
-    },
-    get fps() {
-      if (samples.length === 0) return targetFps; // nothing recorded yet → report the target
-      return avgMs > 0 ? 1000 / avgMs : targetFps;
-    },
-  };
-}
-
-function clamp01(value: number): number {
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}

package/src/game/core/fixedTimestep.spec.ts

@@ -1,91 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { createFixedTimestep } from './fixedTimestep';
-
-describe('createFixedTimestep', () => {
-  test('a 100ms frame at 60hz runs 6 updates and 1 render', () => {
-    let updates = 0;
-    let renders = 0;
-    const ts = createFixedTimestep({
-      hz: 60,
-      maxCatchup: 10, // raise above the default-5 guard so the full backlog is observed
-      onUpdate: () => updates++,
-      onRender: () => renders++,
-    });
-
-    ts.step(100); // 100 / (1000/60) = 6.0 → 6 updates
-
-    expect(updates).toBe(6);
-    expect(renders).toBe(1);
-  });
-
-  test('onUpdate receives the fixed dt in seconds', () => {
-    const dts: number[] = [];
-    const ts = createFixedTimestep({
-      hz: 50,
-      onUpdate: (dt) => dts.push(dt),
-      onRender: () => {},
-    });
-    ts.step(40); // 40 / 20ms = 2 updates, each dt = 0.02s
-    expect(dts).toEqual([0.02, 0.02]);
-  });
-
-  test('accumulates fractional frames across steps (5 frames)', () => {
-    let updates = 0;
-    let renders = 0;
-    // 90hz step = 11.111ms. A run of 5×8ms frames (40ms total) → 3 whole steps,
-    // with the leftover carried frame-to-frame rather than dropped.
-    const ts = createFixedTimestep({
-      hz: 90,
-      onUpdate: () => updates++,
-      onRender: () => renders++,
-    });
-    for (let i = 0; i < 5; i++) ts.step(8);
-    expect(renders).toBe(5); // one render per frame, always
-    expect(updates).toBe(3); // 40ms / 11.111ms = 3 whole simulation steps
-  });
-
-  test('onRender alpha reflects leftover accumulator', () => {
-    let alpha = -1;
-    const ts = createFixedTimestep({ hz: 100, onUpdate: () => {}, onRender: (a) => (alpha = a) });
-    ts.step(15); // step = 10ms → 1 update, 5ms left → alpha = 0.5
-    expect(alpha).toBeCloseTo(0.5, 5);
-  });
-
-  test('clamps the spiral of death at maxCatchup and drops the backlog', () => {
-    let updates = 0;
-    const ts = createFixedTimestep({
-      hz: 60,
-      maxCatchup: 5,
-      onUpdate: () => updates++,
-      onRender: () => {},
-    });
-    ts.step(5000); // a 5s backgrounded gap would be ~300 steps; clamp to 5
-    expect(updates).toBe(5);
-
-    // Backlog was dropped, so the next normal frame produces exactly one update.
-    updates = 0;
-    ts.step(17);
-    expect(updates).toBe(1);
-  });
-
-  test('ignores NaN / negative deltas', () => {
-    let updates = 0;
-    const ts = createFixedTimestep({ hz: 60, onUpdate: () => updates++, onRender: () => {} });
-    ts.step(Number.NaN);
-    ts.step(-100);
-    expect(updates).toBe(0);
-  });
-
-  test('reset clears the accumulator', () => {
-    let updates = 0;
-    const ts = createFixedTimestep({ hz: 60, onUpdate: () => updates++, onRender: () => {} });
-    ts.step(10); // 10ms < 16.667 → 0 updates, 10ms banked
-    ts.reset();
-    ts.step(10); // bank cleared → still under one step → 0 updates
-    expect(updates).toBe(0);
-  });
-
-  test('throws on a non-positive hz', () => {
-    expect(() => createFixedTimestep({ hz: 0, onUpdate: () => {}, onRender: () => {} })).toThrow();
-  });
-});

package/src/game/core/fixedTimestep.ts

@@ -1,79 +0,0 @@
-export interface FixedTimestepOptions {
-  /** Update rate in Hz (e.g. 60 → a fixed 1/60 s simulation step). */
-  hz: number;
-  /**
-   * Called zero or more times per frame with the fixed timestep in **seconds**
-   * (e.g. `1/60 ≈ 0.0167`). Drive all simulation/physics from this `dt` so behavior
-   * is frame-rate independent.
-   */
-  onUpdate: (dt: number) => void;
-  /**
-   * Called exactly once per frame with the interpolation factor `alpha` in `[0, 1)`
-   * — the fraction of a step the accumulator is into the next update. Render the
-   * visual state as `lerp(prev, current, alpha)` for smooth motion between updates.
-   */
-  onRender: (alpha: number) => void;
-  /**
-   * Maximum simulation steps per frame (default `5`). The "spiral of death" guard:
-   * without it, a tab backgrounded for 5 s would try to simulate hundreds of steps
-   * in one frame and lock the thread. When the cap is hit the leftover backlog is
-   * dropped (time is sacrificed to keep the frame responsive).
-   */
-  maxCatchup?: number;
-}
-
-export interface FixedTimestep {
-  /** Advance by the wall-clock delta since the previous frame, in **milliseconds**. */
-  step: (deltaMs: number) => void;
-  /** Clear the accumulator — call after a pause/resume so the gap isn't simulated. */
-  reset: () => void;
-}
-
-/**
- * Creates a fixed-timestep accumulator: the canonical decoupling of a fixed-rate
- * simulation from a variable-rate render. Call {@link FixedTimestep.step} once per
- * animation frame with the wall-clock delta; it invokes `onUpdate(dt)` zero or more
- * times with the fixed `dt`, then `onRender(alpha)` once with the interpolation
- * factor. Replaces the verbatim copies the apps each carried per game.
- */
-export function createFixedTimestep(opts: FixedTimestepOptions): FixedTimestep {
-  const { hz, onUpdate, onRender, maxCatchup = 5 } = opts;
-  if (!(hz > 0)) throw new Error(`createFixedTimestep: hz must be > 0 (got ${hz})`);
-
-  const stepMs = 1000 / hz;
-  const stepSeconds = stepMs / 1000;
-  // Repeated `accumulator -= stepMs` accrues float error, so an exact integer multiple
-  // (e.g. 100ms at 60hz = 6 steps) can fall a rounding-bit short of the final step.
-  // A tiny epsilon recovers the mathematically-correct count without ever firing a
-  // spurious step (a real sub-step delta is never within 1e-9 ms of the boundary).
-  const threshold = stepMs - 1e-9;
-  let accumulator = 0;
-
-  return {
-    step(deltaMs: number) {
-      // Guard against NaN, negatives, and the huge delta after a backgrounded tab.
-      if (!Number.isFinite(deltaMs) || deltaMs < 0) deltaMs = 0;
-      accumulator += deltaMs;
-
-      let steps = 0;
-      while (accumulator >= threshold && steps < maxCatchup) {
-        onUpdate(stepSeconds);
-        accumulator -= stepMs;
-        steps++;
-      }
-
-      // Hit the catch-up cap with backlog remaining → drop it (spiral-of-death guard).
-      if (steps >= maxCatchup && accumulator >= threshold) {
-        accumulator = 0;
-      } else if (accumulator < 0) {
-        // Epsilon stepping can leave a sub-femtosecond negative residue; floor it.
-        accumulator = 0;
-      }
-
-      onRender(accumulator / stepMs);
-    },
-    reset() {
-      accumulator = 0;
-    },
-  };
-}

package/src/game/core/index.ts

@@ -1,16 +0,0 @@
-// cursedbelt/game core — engine-agnostic, zero React, browser-safe to import from a
-// Bun server test. The React host hook lives in `cursedbelt/game/react`.
-export { DisposeRegistry } from './DisposeRegistry';
-export type { DrawBudget, DrawBudgetOptions } from './drawBudget';
-export { drawBudget } from './drawBudget';
-export type { FixedTimestep, FixedTimestepOptions } from './fixedTimestep';
-export { createFixedTimestep } from './fixedTimestep';
-export type {
-  GamepadSnapshot,
-  InputCollector,
-  InputCollectorOptions,
-  InputSnapshot,
-  PointerSnapshot,
-} from './inputCollector';
-export { createInputCollector, deadzone } from './inputCollector';
-export { resizeCanvasToDisplaySize } from './resizeCanvas';