automatick 0.0.2 → 0.0.3

package/dist/worker/createSimWorker.js

@@ -1,124 +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,
-          // Worker host owns its own setTimeout-driven loop; rAF wouldn't exist here anyway.
-          autoFrame: false,
-        });
-        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

@@ -31,6 +31,9 @@ type MainToWorkerMessage<Params> = {
 } | {
     kind: 'resetWith';
     patch?: Partial<Params>;
+} | {
+    kind: 'setConfig';
+    patch: Partial<WorkerConfig>;
 } | {
     kind: 'destroy';
 };
@@ -44,8 +47,6 @@ type WorkerToMainMessage<Data, Params> = {
         message: string;
         stack?: string;
     };
-} | {
-    kind: 'ready';
 };
 /** Worker-specific configuration passed at init time. */
 type WorkerConfig = {

package/dist/worker/protocol.d.ts

@@ -31,6 +31,9 @@ type MainToWorkerMessage<Params> = {
 } | {
     kind: 'resetWith';
     patch?: Partial<Params>;
+} | {
+    kind: 'setConfig';
+    patch: Partial<WorkerConfig>;
 } | {
     kind: 'destroy';
 };
@@ -44,8 +47,6 @@ type WorkerToMainMessage<Data, Params> = {
         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,6 +43,7 @@ function createWorkerRunner(worker, config) {
     status: "idle",
     stepDurationMs: 0
   };
+  const perfBuffer = [];
   function send(msg) {
     worker.postMessage(serializeMainMessage(msg));
   }
@@ -50,19 +52,25 @@ 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":
         currentSnapshot = { ...currentSnapshot, status: "stopped" };
         emit();
         break;
-      case "ready":
-        break;
     }
   };
   worker.onerror = () => {
@@ -84,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,5 +1,7 @@
+import { TickPerformance } from '../engine.cjs';
 import { State } from '../state.cjs';
 import { WorkerConfig } from './protocol.cjs';
+import '../sim.cjs';
 
 /**
  * Main-thread side of the worker runner.
@@ -22,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,5 +1,7 @@
+import { TickPerformance } from '../engine.js';
 import { State } from '../state.js';
 import { WorkerConfig } from './protocol.js';
+import '../sim.js';
 
 /**
  * Main-thread side of the worker runner.
@@ -22,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.js

@@ -1,70 +1,6 @@
-// src/worker/serialize.ts
-function deserializeWorkerMessage(raw) {
-  return raw;
-}
-function serializeMainMessage(msg) {
-  return msg;
-}
-
-// src/worker/workerRunner.ts
-function createWorkerRunner(worker, config) {
-  const listeners = /* @__PURE__ */ new Set();
-  let currentSnapshot = {
-    data: void 0,
-    params: config.initialParams,
-    tick: 0,
-    status: "idle",
-    stepDurationMs: 0
-  };
-  function send(msg) {
-    worker.postMessage(serializeMainMessage(msg));
-  }
-  function emit() {
-    for (const l of listeners) {
-      l(currentSnapshot);
-    }
-  }
-  worker.onmessage = (event) => {
-    const msg = deserializeWorkerMessage(event.data);
-    switch (msg.kind) {
-      case "snapshot":
-        currentSnapshot = msg.snapshot;
-        emit();
-        break;
-      case "error":
-        currentSnapshot = { ...currentSnapshot, status: "stopped" };
-        emit();
-        break;
-      case "ready":
-        break;
-    }
-  };
-  worker.onerror = () => {
-    currentSnapshot = { ...currentSnapshot, status: "stopped" };
-    emit();
-  };
-  return {
-    getSnapshot: () => currentSnapshot,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    play: () => send({ kind: "play" }),
-    pause: () => send({ kind: "pause" }),
-    stop: () => send({ kind: "stop" }),
-    seek: (tick) => send({ kind: "seek", tick }),
-    advance: (count = 1) => send({ kind: "advance", count }),
-    setParams: (patch) => send({ kind: "setParams", patch }),
-    resetWith: (patch) => send({ kind: "resetWith", patch }),
-    destroy() {
-      listeners.clear();
-      send({ kind: "destroy" });
-      worker.terminate();
-    }
-  };
-}
+import {
+  createWorkerRunner
+} from "../chunk-LMHH7YPE.js";
 export {
   createWorkerRunner
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automatick",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "State-machine engine for tick-based simulations in React",
   "author": "jckr",
   "license": "MIT",
@@ -29,7 +29,7 @@
     }
   },
   "scripts": {
-    "build": "tsup src/engine.ts src/sim.ts src/state.ts src/worker/workerRunner.ts src/worker/createSimWorker.ts src/worker/protocol.ts src/react/Simulation.tsx src/react/hooks.ts src/react/useSimulationCanvas.ts src/react/PerformanceOverlay.tsx src/react/SimulationContext.tsx src/react/EngineContext.tsx src/react/SimulationControls.tsx src/react/controlPrimitives.tsx src/react/stableCallback.ts --format esm,cjs --dts --clean --external react --external react-dom --external react/jsx-runtime",
+    "build": "tsup src/engine.ts src/sim.ts src/state.ts src/worker/workerRunner.ts src/worker/createSimWorker.ts src/worker/protocol.ts src/react/Simulation.tsx src/react/hooks.ts src/react/useSimulationCanvas.ts src/react/PerformanceOverlay.tsx src/react/SimulationContext.tsx src/react/EngineContext.tsx src/react/SimulationControls.tsx src/react/controlPrimitives.tsx src/react/stableCallback.ts --format esm,cjs --dts --clean --external react --external react-dom --external react/jsx-runtime && tsup src/engine.ts src/sim.ts --format esm --no-splitting --no-dts --outDir dist/standalone",
     "test": "vitest run"
   },
   "exports": {