automatick 0.0.2 → 0.0.3

package/dist/{chunk-UU5V7HGM.js → chunk-A375T3UD.js}

@@ -35,7 +35,7 @@ var SimulationEngine = class {
     this.maxTime = config.maxTime;
     this.delayMs = config.delayMs ?? 0;
     this.ticksPerFrame = config.ticksPerFrame ?? 1;
-    this.params = { ...config.initialParams };
+    this.params = config.initialParams ? { ...config.initialParams } : {};
     this.data = this.initFn(this.params);
     if (config.render) {
       this.listeners.add(config.render);

package/dist/chunk-LMHH7YPE.js

@@ -0,0 +1,89 @@
+// src/worker/serialize.ts
+function deserializeWorkerMessage(raw) {
+  return raw;
+}
+function serializeMainMessage(msg) {
+  return msg;
+}
+
+// src/worker/workerRunner.ts
+var PERF_BUFFER_SIZE = 120;
+function createWorkerRunner(worker, config) {
+  const listeners = /* @__PURE__ */ new Set();
+  let currentSnapshot = {
+    data: void 0,
+    params: config.initialParams,
+    tick: 0,
+    status: "idle",
+    stepDurationMs: 0
+  };
+  const perfBuffer = [];
+  function send(msg) {
+    worker.postMessage(serializeMainMessage(msg));
+  }
+  function emit() {
+    for (const l of listeners) {
+      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;
+    }
+  };
+  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 }),
+    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" });
+      worker.terminate();
+    }
+  };
+}
+
+export {
+  createWorkerRunner
+};

package/dist/chunk-VPS3ZXWI.js

@@ -0,0 +1,132 @@
+// 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;
+        // 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,
+          maxTime: msg.config.maxTime,
+          // Worker host owns its own setTimeout-driven loop; rAF wouldn't exist here anyway.
+          autoFrame: false,
+        });
+        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 '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; }
+        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 === "snapshot" || 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;
+}
+
+export {
+  createSimWorker
+};

package/dist/engine.cjs

@@ -63,7 +63,7 @@ var SimulationEngine = class {
     this.maxTime = config.maxTime;
     this.delayMs = config.delayMs ?? 0;
     this.ticksPerFrame = config.ticksPerFrame ?? 1;
-    this.params = { ...config.initialParams };
+    this.params = config.initialParams ? { ...config.initialParams } : {};
     this.data = this.initFn(this.params);
     if (config.render) {
       this.listeners.add(config.render);

package/dist/engine.d.cts

@@ -6,7 +6,7 @@ type TickPerformance = {
     stepMs: number;
     drawMs?: number;
 };
-type EngineConfig<Data, Params> = {
+type EngineConfig<Data, Params = Record<string, never>> = {
     /**
      * Initial simulation state — value or `(params) => Data`. See `SimInit`.
      * When a value is passed, the engine `structuredClone`s it on each (re)init.
@@ -14,7 +14,11 @@ type EngineConfig<Data, Params> = {
     init: SimInit<Data, Params>;
     step: (state: State<Data, Params>) => Data;
     shouldStop?: (data: Data, params: Params) => boolean;
-    initialParams: Params;
+    /**
+     * Initial param values. Optional — when omitted, the engine seeds an empty
+     * params object and `Params` defaults to `Record<string, never>`.
+     */
+    initialParams?: Params;
     maxTime?: number;
     delayMs?: number;
     ticksPerFrame?: number;
@@ -40,7 +44,7 @@ type EngineConfig<Data, Params> = {
      */
     autoFrame?: boolean;
 };
-declare class SimulationEngine<Data, Params> {
+declare class SimulationEngine<Data, Params = Record<string, never>> {
     private data;
     private params;
     private tick;
@@ -87,6 +91,6 @@ declare class SimulationEngine<Data, Params> {
     private emit;
     private emitHistory;
 }
-declare function createEngine<Data, Params>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
+declare function createEngine<Data, Params = Record<string, never>>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
 
 export { type EngineConfig, SimulationEngine, SimulationStatus, State, type TickPerformance, createEngine };

package/dist/engine.d.ts

@@ -6,7 +6,7 @@ type TickPerformance = {
     stepMs: number;
     drawMs?: number;
 };
-type EngineConfig<Data, Params> = {
+type EngineConfig<Data, Params = Record<string, never>> = {
     /**
      * Initial simulation state — value or `(params) => Data`. See `SimInit`.
      * When a value is passed, the engine `structuredClone`s it on each (re)init.
@@ -14,7 +14,11 @@ type EngineConfig<Data, Params> = {
     init: SimInit<Data, Params>;
     step: (state: State<Data, Params>) => Data;
     shouldStop?: (data: Data, params: Params) => boolean;
-    initialParams: Params;
+    /**
+     * Initial param values. Optional — when omitted, the engine seeds an empty
+     * params object and `Params` defaults to `Record<string, never>`.
+     */
+    initialParams?: Params;
     maxTime?: number;
     delayMs?: number;
     ticksPerFrame?: number;
@@ -40,7 +44,7 @@ type EngineConfig<Data, Params> = {
      */
     autoFrame?: boolean;
 };
-declare class SimulationEngine<Data, Params> {
+declare class SimulationEngine<Data, Params = Record<string, never>> {
     private data;
     private params;
     private tick;
@@ -87,6 +91,6 @@ declare class SimulationEngine<Data, Params> {
     private emit;
     private emitHistory;
 }
-declare function createEngine<Data, Params>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
+declare function createEngine<Data, Params = Record<string, never>>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
 
 export { type EngineConfig, SimulationEngine, SimulationStatus, State, type TickPerformance, createEngine };

package/dist/engine.js

@@ -1,7 +1,7 @@
 import {
   SimulationEngine,
   createEngine
-} from "./chunk-UU5V7HGM.js";
+} from "./chunk-A375T3UD.js";
 import "./chunk-IKR53C2U.js";
 export {
   SimulationEngine,