automatick 0.0.1 → 0.0.3

package/dist/standalone/engine.js

@@ -0,0 +1,242 @@
+// src/sim.ts
+function isInitFn(init) {
+  return typeof init === "function";
+}
+
+// src/engine.ts
+var PERF_BUFFER_SIZE = 120;
+var SimulationEngine = class {
+  data;
+  params;
+  tick = 0;
+  status = "idle";
+  lastUpdateMs = null;
+  lastStepMs = 0;
+  initFn;
+  stepFn;
+  shouldStopFn;
+  maxTime;
+  delayMs;
+  ticksPerFrame;
+  listeners = /* @__PURE__ */ new Set();
+  historyListeners = /* @__PURE__ */ new Set();
+  perfBuffer = [];
+  rafId = null;
+  rafCancel = null;
+  constructor(config) {
+    const init = config.init;
+    if (isInitFn(init)) {
+      this.initFn = init;
+    } else {
+      const seed = structuredClone(init);
+      this.initFn = () => structuredClone(seed);
+    }
+    this.stepFn = config.step;
+    this.shouldStopFn = config.shouldStop;
+    this.maxTime = config.maxTime;
+    this.delayMs = config.delayMs ?? 0;
+    this.ticksPerFrame = config.ticksPerFrame ?? 1;
+    this.params = config.initialParams ? { ...config.initialParams } : {};
+    this.data = this.initFn(this.params);
+    if (config.render) {
+      this.listeners.add(config.render);
+      config.render(this.getSnapshot());
+    }
+    const autoFrame = config.autoFrame ?? true;
+    if (autoFrame) {
+      const raf = globalThis.requestAnimationFrame;
+      const caf = globalThis.cancelAnimationFrame;
+      if (typeof raf === "function" && typeof caf === "function") {
+        const loop = (now) => {
+          this.handleAnimationFrame(now);
+          this.rafId = raf(loop);
+        };
+        this.rafCancel = caf;
+        this.rafId = raf(loop);
+      }
+    }
+  }
+  getSnapshot() {
+    return {
+      data: this.data,
+      params: this.params,
+      tick: this.tick,
+      status: this.status,
+      stepDurationMs: this.lastStepMs
+    };
+  }
+  getStatus() {
+    return this.status;
+  }
+  getPerformance() {
+    return this.perfBuffer;
+  }
+  setDelayMs(ms) {
+    this.delayMs = ms;
+  }
+  setTicksPerFrame(n) {
+    this.ticksPerFrame = n;
+  }
+  recordDrawTime(tick, ms) {
+    for (let i = this.perfBuffer.length - 1; i >= 0; i--) {
+      if (this.perfBuffer[i].tick === tick) {
+        this.perfBuffer[i].drawMs = ms;
+        return;
+      }
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  subscribeHistory(listener) {
+    this.historyListeners.add(listener);
+    return () => {
+      this.historyListeners.delete(listener);
+    };
+  }
+  play() {
+    if (this.status === "stopped") return;
+    if (this.status === "playing") return;
+    this.status = "playing";
+    this.lastUpdateMs = null;
+    this.emit();
+  }
+  pause() {
+    if (this.status !== "playing") return;
+    this.status = "paused";
+    this.emit();
+  }
+  stop() {
+    if (this.status === "idle" || this.status === "stopped") return;
+    this.status = "stopped";
+    this.emit();
+  }
+  seek(targetTick) {
+    if (this.status === "stopped") return;
+    if (targetTick <= this.tick) {
+      if (this.status !== "paused") {
+        this.status = "paused";
+        this.emit();
+      }
+      return;
+    }
+    this.status = "paused";
+    this.lastUpdateMs = null;
+    this.advanceTicks(targetTick - this.tick);
+    if (this.status === "paused") {
+      this.emit();
+    }
+  }
+  advance(count = 1) {
+    if (this.status === "stopped") return;
+    if (this.status === "playing" || this.status === "idle") {
+      this.status = "paused";
+    }
+    this.lastUpdateMs = null;
+    this.advanceTicks(count);
+    if (this.status === "paused") {
+      this.emit();
+    }
+  }
+  setParams(patch) {
+    this.params = { ...this.params, ...patch };
+    this.emit();
+  }
+  resetWith(patch) {
+    if (patch) {
+      this.params = { ...this.params, ...patch };
+    }
+    this.data = this.initFn(this.params);
+    this.tick = 0;
+    this.status = "idle";
+    this.lastUpdateMs = null;
+    this.lastStepMs = 0;
+    this.perfBuffer.length = 0;
+    this.emit();
+  }
+  handleAnimationFrame(nowMs) {
+    if (this.status !== "playing") return;
+    if (this.lastUpdateMs === null) {
+      this.lastUpdateMs = nowMs;
+      return;
+    }
+    if (this.delayMs > 0 && nowMs - this.lastUpdateMs < this.delayMs) return;
+    this.lastUpdateMs = nowMs;
+    this.advanceTicks(this.ticksPerFrame);
+    if (this.status === "playing") {
+      this.emit();
+    }
+  }
+  destroy() {
+    if (this.rafId !== null && this.rafCancel) {
+      this.rafCancel(this.rafId);
+    }
+    this.rafId = null;
+    this.rafCancel = null;
+    this.listeners.clear();
+    this.historyListeners.clear();
+  }
+  /**
+   * Run step up to `count` ticks. Returns true if all ticks completed
+   * without termination, false if stopped early.
+   */
+  advanceTicks(count) {
+    for (let i = 0; i < count; i++) {
+      if (this.maxTime !== void 0 && this.tick >= this.maxTime) {
+        this.status = "stopped";
+        this.emit();
+        return false;
+      }
+      this.tick += 1;
+      const t0 = performance.now();
+      this.data = this.stepFn({
+        data: this.data,
+        params: this.params,
+        tick: this.tick,
+        status: this.status,
+        stepDurationMs: this.lastStepMs
+      });
+      const t1 = performance.now();
+      this.lastStepMs = t1 - t0;
+      if (this.perfBuffer.length >= PERF_BUFFER_SIZE) {
+        this.perfBuffer.shift();
+      }
+      this.perfBuffer.push({ tick: this.tick, stepMs: this.lastStepMs });
+      this.emitHistory();
+      if (this.shouldStopFn?.(this.data, this.params)) {
+        this.status = "stopped";
+        this.emit();
+        return false;
+      }
+      if (this.maxTime !== void 0 && this.tick >= this.maxTime) {
+        this.status = "stopped";
+        this.emit();
+        return false;
+      }
+    }
+    return true;
+  }
+  emit() {
+    const snap = this.getSnapshot();
+    for (const l of this.listeners) {
+      l(snap);
+    }
+  }
+  emitHistory() {
+    if (this.historyListeners.size === 0) return;
+    const entry = { tick: this.tick, data: this.data };
+    for (const l of this.historyListeners) {
+      l(entry);
+    }
+  }
+};
+function createEngine(config) {
+  return new SimulationEngine(config);
+}
+export {
+  SimulationEngine,
+  createEngine
+};

package/dist/standalone/sim.js

@@ -0,0 +1,11 @@
+// src/sim.ts
+function isInitFn(init) {
+  return typeof init === "function";
+}
+function defineSim(sim) {
+  return sim;
+}
+export {
+  defineSim,
+  isInitFn
+};

package/dist/state.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/state.ts
+var state_exports = {};
+module.exports = __toCommonJS(state_exports);

package/dist/state.d.cts

@@ -0,0 +1,16 @@
+/**
+ * The unified engine state shape — passed to `step`, returned by `getSnapshot`,
+ * and delivered to the `render` callback. All three are operations on the
+ * engine's inner state, so they share one type.
+ */
+type State<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+    status: SimulationStatus;
+    /** Duration of the previous step in ms. `0` before the first step has run. */
+    stepDurationMs: number;
+};
+type SimulationStatus = 'idle' | 'playing' | 'paused' | 'stopped';
+
+export type { SimulationStatus, State };

package/dist/state.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The unified engine state shape — passed to `step`, returned by `getSnapshot`,
+ * and delivered to the `render` callback. All three are operations on the
+ * engine's inner state, so they share one type.
+ */
+type State<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+    status: SimulationStatus;
+    /** Duration of the previous step in ms. `0` before the first step has run. */
+    stepDurationMs: number;
+};
+type SimulationStatus = 'idle' | 'playing' | 'paused' | 'stopped';
+
+export type { SimulationStatus, State };

package/dist/worker/createSimWorker.cjs

@@ -72,14 +72,18 @@ self.onmessage = async (event) => {
           import(msg.engineUrl),
         ]);
         const sim = simMod.default;
+        // Merge sim.defaultParams under the patch sent from main \u2014 the main
+        // thread sees the sim module via a URL, so it can't apply defaults.
+        const initialParams = { ...(sim.defaultParams || {}), ...(msg.params || {}) };
         engine = engineMod.createEngine({
           init: sim.init,
           step: sim.step,
           shouldStop: sim.shouldStop,
-          initialParams: msg.params,
+          initialParams,
           maxTime: msg.config.maxTime,
+          // Worker host owns its own setTimeout-driven loop; rAF wouldn't exist here anyway.
+          autoFrame: false,
         });
-        postMessage({ kind: 'ready' });
         emitSnapshot();
         break;
       }
@@ -111,6 +115,11 @@ self.onmessage = async (event) => {
         if (!engine) return;
         stopLoop(); engine.resetWith(msg.patch); emitSnapshot();
         break;
+      case 'setConfig':
+        if (msg.patch.delayMs !== undefined) delayMs = msg.patch.delayMs;
+        if (msg.patch.ticksPerFrame !== undefined) ticksPerFrame = msg.patch.ticksPerFrame;
+        if (msg.patch.snapshotIntervalMs !== undefined) snapshotIntervalMs = msg.patch.snapshotIntervalMs;
+        break;
       case 'destroy':
         stopLoop();
         if (engine) { engine.destroy(); engine = null; }
@@ -127,7 +136,7 @@ function createSimWorker(options) {
   const blobUrl = URL.createObjectURL(blob);
   const worker = new Worker(blobUrl, { type: "module" });
   worker.addEventListener("message", function cleanup(event) {
-    if (event.data?.kind === "ready" || event.data?.kind === "error") {
+    if (event.data?.kind === "snapshot" || event.data?.kind === "error") {
       URL.revokeObjectURL(blobUrl);
       worker.removeEventListener("message", cleanup);
     }

package/dist/worker/createSimWorker.d.cts

@@ -1,6 +1,5 @@
 import { WorkerConfig } from './protocol.cjs';
-import '../engine.cjs';
-import '../sim.cjs';
+import '../state.cjs';
 
 /**
  * Creates a Web Worker that loads a sim module and runs the engine.

package/dist/worker/createSimWorker.d.ts

@@ -1,6 +1,5 @@
 import { WorkerConfig } from './protocol.js';
-import '../engine.js';
-import '../sim.js';
+import '../state.js';
 
 /**
  * Creates a Web Worker that loads a sim module and runs the engine.

package/dist/worker/createSimWorker.js

@@ -1,122 +1,6 @@
-// src/worker/createSimWorker.ts
-var WORKER_SCRIPT = `
-let engine = null;
-let loopTimer = null;
-let snapshotIntervalMs = 16;
-let lastSnapshotMs = 0;
-let ticksPerFrame = 1;
-let delayMs = 0;
-
-function emitSnapshot() {
-  if (!engine) return;
-  postMessage({ kind: 'snapshot', snapshot: engine.getSnapshot() });
-  lastSnapshotMs = performance.now();
-}
-
-function tickLoop() {
-  if (!engine || engine.getStatus() !== 'playing') return;
-
-  for (let i = 0; i < ticksPerFrame; i++) {
-    engine.advance(1);
-    const s = engine.getStatus();
-    if (s === 'stopped') { emitSnapshot(); return; }
-    if (s !== 'paused') break;
-  }
-
-  // advance() transitions to paused; resume playing for the next batch
-  if (engine.getStatus() === 'paused') engine.play();
-
-  if (performance.now() - lastSnapshotMs >= snapshotIntervalMs) emitSnapshot();
-  loopTimer = setTimeout(tickLoop, delayMs);
-}
-
-function stopLoop() {
-  if (loopTimer !== null) { clearTimeout(loopTimer); loopTimer = null; }
-}
-
-self.onmessage = async (event) => {
-  const msg = event.data;
-  try {
-    switch (msg.kind) {
-      case 'init': {
-        delayMs = msg.config.delayMs || 0;
-        ticksPerFrame = msg.config.ticksPerFrame || 1;
-        snapshotIntervalMs = msg.config.snapshotIntervalMs || 16;
-
-        const [simMod, engineMod] = await Promise.all([
-          import(msg.moduleUrl),
-          import(msg.engineUrl),
-        ]);
-        const sim = simMod.default;
-        engine = engineMod.createEngine({
-          init: sim.init,
-          step: sim.step,
-          shouldStop: sim.shouldStop,
-          initialParams: msg.params,
-          maxTime: msg.config.maxTime,
-        });
-        postMessage({ kind: 'ready' });
-        emitSnapshot();
-        break;
-      }
-      case 'play':
-        if (!engine) return;
-        engine.play(); emitSnapshot(); stopLoop(); loopTimer = setTimeout(tickLoop, 0);
-        break;
-      case 'pause':
-        if (!engine) return;
-        stopLoop(); engine.pause(); emitSnapshot();
-        break;
-      case 'stop':
-        if (!engine) return;
-        stopLoop(); engine.stop(); emitSnapshot();
-        break;
-      case 'seek':
-        if (!engine) return;
-        stopLoop(); engine.seek(msg.tick); emitSnapshot();
-        break;
-      case 'advance':
-        if (!engine) return;
-        engine.advance(msg.count); emitSnapshot();
-        break;
-      case 'setParams':
-        if (!engine) return;
-        engine.setParams(msg.patch); emitSnapshot();
-        break;
-      case 'resetWith':
-        if (!engine) return;
-        stopLoop(); engine.resetWith(msg.patch); emitSnapshot();
-        break;
-      case 'destroy':
-        stopLoop();
-        if (engine) { engine.destroy(); engine = null; }
-        self.close();
-        break;
-    }
-  } catch (err) {
-    postMessage({ kind: 'error', error: { message: err.message, stack: err.stack } });
-  }
-};
-`;
-function createSimWorker(options) {
-  const blob = new Blob([WORKER_SCRIPT], { type: "text/javascript" });
-  const blobUrl = URL.createObjectURL(blob);
-  const worker = new Worker(blobUrl, { type: "module" });
-  worker.addEventListener("message", function cleanup(event) {
-    if (event.data?.kind === "ready" || event.data?.kind === "error") {
-      URL.revokeObjectURL(blobUrl);
-      worker.removeEventListener("message", cleanup);
-    }
-  });
-  worker.postMessage({
-    kind: "init",
-    moduleUrl: options.moduleUrl,
-    engineUrl: options.engineUrl,
-    params: options.initialParams,
-    config: options.config
-  });
-  return worker;
-}
+import {
+  createSimWorker
+} from "../chunk-VPS3ZXWI.js";
 export {
   createSimWorker
 };

package/dist/worker/protocol.d.cts

@@ -1,5 +1,4 @@
-import { EngineSnapshot } from '../engine.cjs';
-import '../sim.cjs';
+import { State } from '../state.cjs';
 
 /**
  * Wire protocol types for main ↔ worker communication.
@@ -32,21 +31,22 @@ type MainToWorkerMessage<Params> = {
 } | {
     kind: 'resetWith';
     patch?: Partial<Params>;
+} | {
+    kind: 'setConfig';
+    patch: Partial<WorkerConfig>;
 } | {
     kind: 'destroy';
 };
 /** Messages sent from the worker to the main thread. */
 type WorkerToMainMessage<Data, Params> = {
     kind: 'snapshot';
-    snapshot: EngineSnapshot<Data, Params>;
+    snapshot: State<Data, Params>;
 } | {
     kind: 'error';
     error: {
         message: string;
         stack?: string;
     };
-} | {
-    kind: 'ready';
 };
 /** Worker-specific configuration passed at init time. */
 type WorkerConfig = {

package/dist/worker/protocol.d.ts

@@ -1,5 +1,4 @@
-import { EngineSnapshot } from '../engine.js';
-import '../sim.js';
+import { State } from '../state.js';
 
 /**
  * Wire protocol types for main ↔ worker communication.
@@ -32,21 +31,22 @@ type MainToWorkerMessage<Params> = {
 } | {
     kind: 'resetWith';
     patch?: Partial<Params>;
+} | {
+    kind: 'setConfig';
+    patch: Partial<WorkerConfig>;
 } | {
     kind: 'destroy';
 };
 /** Messages sent from the worker to the main thread. */
 type WorkerToMainMessage<Data, Params> = {
     kind: 'snapshot';
-    snapshot: EngineSnapshot<Data, Params>;
+    snapshot: State<Data, Params>;
 } | {
     kind: 'error';
     error: {
         message: string;
         stack?: string;
     };
-} | {
-    kind: 'ready';
 };
 /** Worker-specific configuration passed at init time. */
 type WorkerConfig = {

package/dist/worker/workerRunner.cjs

@@ -33,6 +33,7 @@ function serializeMainMessage(msg) {
 }
 
 // src/worker/workerRunner.ts
+var PERF_BUFFER_SIZE = 120;
 function createWorkerRunner(worker, config) {
   const listeners = /* @__PURE__ */ new Set();
   let currentSnapshot = {
@@ -42,7 +43,7 @@ function createWorkerRunner(worker, config) {
     status: "idle",
     stepDurationMs: 0
   };
-  let errorMessage = null;
+  const perfBuffer = [];
   function send(msg) {
     worker.postMessage(serializeMainMessage(msg));
   }
@@ -51,24 +52,28 @@ function createWorkerRunner(worker, config) {
       l(currentSnapshot);
     }
   }
+  function pushPerf(snapshot) {
+    if (snapshot.tick <= 0) return;
+    const last = perfBuffer[perfBuffer.length - 1];
+    if (last && last.tick === snapshot.tick) return;
+    if (perfBuffer.length >= PERF_BUFFER_SIZE) perfBuffer.shift();
+    perfBuffer.push({ tick: snapshot.tick, stepMs: snapshot.stepDurationMs });
+  }
   worker.onmessage = (event) => {
     const msg = deserializeWorkerMessage(event.data);
     switch (msg.kind) {
       case "snapshot":
         currentSnapshot = msg.snapshot;
+        pushPerf(msg.snapshot);
         emit();
         break;
       case "error":
-        errorMessage = msg.error.message;
         currentSnapshot = { ...currentSnapshot, status: "stopped" };
         emit();
         break;
-      case "ready":
-        break;
     }
   };
-  worker.onerror = (event) => {
-    errorMessage = event.message ?? "Unknown worker error";
+  worker.onerror = () => {
     currentSnapshot = { ...currentSnapshot, status: "stopped" };
     emit();
   };
@@ -87,6 +92,16 @@ function createWorkerRunner(worker, config) {
     advance: (count = 1) => send({ kind: "advance", count }),
     setParams: (patch) => send({ kind: "setParams", patch }),
     resetWith: (patch) => send({ kind: "resetWith", patch }),
+    setConfig: (patch) => send({ kind: "setConfig", patch }),
+    recordDrawTime(tick, ms) {
+      for (let i = perfBuffer.length - 1; i >= 0; i--) {
+        if (perfBuffer[i].tick === tick) {
+          perfBuffer[i].drawMs = ms;
+          return;
+        }
+      }
+    },
+    getPerformance: () => perfBuffer,
     destroy() {
       listeners.clear();
       send({ kind: "destroy" });

package/dist/worker/workerRunner.d.cts

@@ -1,4 +1,5 @@
-import { EngineSnapshot } from '../engine.cjs';
+import { TickPerformance } from '../engine.cjs';
+import { State } from '../state.cjs';
 import { WorkerConfig } from './protocol.cjs';
 import '../sim.cjs';
 
@@ -14,8 +15,8 @@ type WorkerRunnerConfig<Params> = {
     config: WorkerConfig;
 };
 type WorkerRunner<Data, Params> = {
-    getSnapshot: () => EngineSnapshot<Data, Params>;
-    subscribe: (listener: (snapshot: EngineSnapshot<Data, Params>) => void) => () => void;
+    getSnapshot: () => State<Data, Params>;
+    subscribe: (listener: (snapshot: State<Data, Params>) => void) => () => void;
     play: () => void;
     pause: () => void;
     stop: () => void;
@@ -23,6 +24,13 @@ type WorkerRunner<Data, Params> = {
     advance: (count?: number) => void;
     setParams: (patch: Partial<Params>) => void;
     resetWith: (patch?: Partial<Params>) => void;
+    setConfig: (patch: Partial<WorkerConfig>) => void;
+    /**
+     * Record a draw time for a tick. Draws happen on the main thread, so
+     * timings are tracked here — they never cross the postMessage boundary.
+     */
+    recordDrawTime: (tick: number, ms: number) => void;
+    getPerformance: () => readonly TickPerformance[];
     destroy: () => void;
 };
 declare function createWorkerRunner<Data, Params>(worker: Worker, config: WorkerRunnerConfig<Params>): WorkerRunner<Data, Params>;

package/dist/worker/workerRunner.d.ts

@@ -1,4 +1,5 @@
-import { EngineSnapshot } from '../engine.js';
+import { TickPerformance } from '../engine.js';
+import { State } from '../state.js';
 import { WorkerConfig } from './protocol.js';
 import '../sim.js';
 
@@ -14,8 +15,8 @@ type WorkerRunnerConfig<Params> = {
     config: WorkerConfig;
 };
 type WorkerRunner<Data, Params> = {
-    getSnapshot: () => EngineSnapshot<Data, Params>;
-    subscribe: (listener: (snapshot: EngineSnapshot<Data, Params>) => void) => () => void;
+    getSnapshot: () => State<Data, Params>;
+    subscribe: (listener: (snapshot: State<Data, Params>) => void) => () => void;
     play: () => void;
     pause: () => void;
     stop: () => void;
@@ -23,6 +24,13 @@ type WorkerRunner<Data, Params> = {
     advance: (count?: number) => void;
     setParams: (patch: Partial<Params>) => void;
     resetWith: (patch?: Partial<Params>) => void;
+    setConfig: (patch: Partial<WorkerConfig>) => void;
+    /**
+     * Record a draw time for a tick. Draws happen on the main thread, so
+     * timings are tracked here — they never cross the postMessage boundary.
+     */
+    recordDrawTime: (tick: number, ms: number) => void;
+    getPerformance: () => readonly TickPerformance[];
     destroy: () => void;
 };
 declare function createWorkerRunner<Data, Params>(worker: Worker, config: WorkerRunnerConfig<Params>): WorkerRunner<Data, Params>;