automatick 0.0.2 → 0.0.3

package/dist/react/Simulation.js

@@ -1,9 +1,15 @@
 import {
   useStableCallback
 } from "../chunk-SK5SHIWY.js";
+import {
+  createSimWorker
+} from "../chunk-VPS3ZXWI.js";
+import {
+  createWorkerRunner
+} from "../chunk-LMHH7YPE.js";
 import {
   createEngine
-} from "../chunk-UU5V7HGM.js";
+} from "../chunk-A375T3UD.js";
 import "../chunk-IKR53C2U.js";
 import {
   EngineContext
@@ -16,14 +22,29 @@ import {
 import React from "react";
 import { jsx } from "react/jsx-runtime";
 function LocalSimulation(props) {
-  const { sim, params: paramsProp, children, autoplay } = props;
+  const {
+    init,
+    step,
+    shouldStop,
+    defaultParams,
+    params: paramsProp,
+    children,
+    autoplay
+  } = props;
   const engineRef = React.useRef(null);
   if (!engineRef.current) {
-    const initialParams = paramsProp ? { ...sim.defaultParams, ...paramsProp } : sim.defaultParams;
+    let initialParams;
+    if (defaultParams && paramsProp) {
+      initialParams = { ...defaultParams, ...paramsProp };
+    } else if (defaultParams) {
+      initialParams = defaultParams;
+    } else if (paramsProp) {
+      initialParams = paramsProp;
+    }
     engineRef.current = createEngine({
-      init: sim.init,
-      step: sim.step,
-      shouldStop: sim.shouldStop,
+      init,
+      step,
+      shouldStop,
       initialParams,
       maxTime: props.maxTime,
       delayMs: props.delayMs,
@@ -65,119 +86,70 @@ function LocalSimulation(props) {
   }, [engine]);
   return /* @__PURE__ */ jsx(SimulationProvider, { snapshot, backend: engine, children });
 }
+function engineUrl() {
+  return new URL("../standalone/engine.js", import.meta.url).href;
+}
 function WorkerSimulation(props) {
   const { children, autoplay } = props;
-  const [backend, setBackend] = React.useState(
+  const [runner, setRunner] = React.useState(
     null
   );
   const [snapshot, setSnapshot] = React.useState(
     null
   );
-  const propsRef = React.useRef(props);
-  propsRef.current = props;
   React.useEffect(() => {
-    let cancelled = false;
-    let runner = null;
-    (async () => {
-      const mod = await propsRef.current.worker();
-      const simModule = mod.default;
-      if (cancelled) return;
-      const p = propsRef.current;
-      const initialParams = p.params ? { ...simModule.defaultParams, ...p.params } : simModule.defaultParams;
-      const engine = createEngine({
-        init: simModule.init,
-        step: simModule.step,
-        shouldStop: simModule.shouldStop,
-        initialParams,
-        maxTime: p.maxTime,
-        autoFrame: false
-      });
-      if (cancelled) {
-        engine.destroy();
-        return;
-      }
-      const delayMs = p.delayMs ?? 0;
-      const ticksPerFrame = p.ticksPerFrame ?? 1;
-      let loopTimer = null;
-      function stopLoop() {
-        if (loopTimer !== null) {
-          clearTimeout(loopTimer);
-          loopTimer = null;
-        }
-      }
-      function tickLoop() {
-        if (engine.getStatus() !== "playing") return;
-        for (let i = 0; i < ticksPerFrame; i++) {
-          engine.advance(1);
-          const s = engine.getStatus();
-          if (s === "stopped") return;
-          if (s !== "paused") break;
-        }
-        if (engine.getStatus() === "paused") {
-          engine.play();
-        }
-        loopTimer = setTimeout(tickLoop, delayMs);
+    const moduleUrl = props.worker.toString();
+    const initialParams = props.params ?? {};
+    const worker = createSimWorker({
+      moduleUrl,
+      engineUrl: engineUrl(),
+      initialParams,
+      config: {
+        maxTime: props.maxTime,
+        delayMs: props.delayMs,
+        ticksPerFrame: props.ticksPerFrame,
+        snapshotIntervalMs: props.snapshotIntervalMs
       }
-      runner = {
-        getSnapshot: () => engine.getSnapshot(),
-        subscribe: (listener) => engine.subscribe(listener),
-        play: () => {
-          engine.play();
-          stopLoop();
-          loopTimer = setTimeout(tickLoop, 0);
-        },
-        pause: () => {
-          stopLoop();
-          engine.pause();
-        },
-        stop: () => {
-          stopLoop();
-          engine.stop();
-        },
-        seek: (tick) => {
-          stopLoop();
-          engine.seek(tick);
-        },
-        advance: (count) => engine.advance(count),
-        setParams: (patch) => engine.setParams(patch),
-        resetWith: (patch) => {
-          stopLoop();
-          engine.resetWith(patch);
-        },
-        destroy: () => {
-          stopLoop();
-          engine.destroy();
-        },
-        recordDrawTime: (tick, ms) => engine.recordDrawTime(tick, ms),
-        getPerformance: () => engine.getPerformance()
-      };
-      if (!cancelled) {
-        setBackend(runner);
-        setSnapshot(engine.getSnapshot());
+    });
+    const r = createWorkerRunner(worker, {
+      initialParams,
+      config: {
+        maxTime: props.maxTime,
+        delayMs: props.delayMs,
+        ticksPerFrame: props.ticksPerFrame,
+        snapshotIntervalMs: props.snapshotIntervalMs
       }
-    })();
+    });
+    const unsub = r.subscribe((next) => setSnapshot(next));
+    setRunner(r);
     return () => {
-      cancelled = true;
-      runner?.destroy();
+      unsub();
+      r.destroy();
     };
   }, []);
   React.useEffect(() => {
-    if (!backend) return;
-    return backend.subscribe((next) => setSnapshot(next));
-  }, [backend]);
-  React.useEffect(() => {
-    if (autoplay && backend) backend.play();
-  }, [backend, autoplay]);
+    if (autoplay && runner) runner.play();
+  }, [runner, autoplay]);
   const isFirstRender = React.useRef(true);
   React.useEffect(() => {
     if (isFirstRender.current) {
       isFirstRender.current = false;
       return;
     }
-    if (props.params && backend) backend.setParams(props.params);
-  }, [backend, props.params]);
-  if (!snapshot || !backend) return null;
-  return /* @__PURE__ */ jsx(SimulationProvider, { snapshot, backend, children });
+    if (props.params && runner) runner.setParams(props.params);
+  }, [runner, props.params]);
+  React.useEffect(() => {
+    if (!runner) return;
+    if (props.delayMs === void 0 && props.ticksPerFrame === void 0 && props.snapshotIntervalMs === void 0)
+      return;
+    runner.setConfig({
+      delayMs: props.delayMs,
+      ticksPerFrame: props.ticksPerFrame,
+      snapshotIntervalMs: props.snapshotIntervalMs
+    });
+  }, [runner, props.delayMs, props.ticksPerFrame, props.snapshotIntervalMs]);
+  if (!snapshot || !runner || snapshot.data === void 0) return null;
+  return /* @__PURE__ */ jsx(SimulationProvider, { snapshot, backend: runner, children });
 }
 function SimulationProvider({
   snapshot,
@@ -236,6 +208,19 @@ function Simulation(props) {
   if ("worker" in props && props.worker != null) {
     return /* @__PURE__ */ jsx(WorkerSimulation, { ...props });
   }
+  if ("sim" in props && props.sim != null) {
+    const { sim, ...rest } = props;
+    return /* @__PURE__ */ jsx(
+      LocalSimulation,
+      {
+        ...rest,
+        init: sim.init,
+        step: sim.step,
+        shouldStop: sim.shouldStop,
+        defaultParams: sim.defaultParams
+      }
+    );
+  }
   return /* @__PURE__ */ jsx(LocalSimulation, { ...props });
 }
 export {

package/dist/sim.d.cts

@@ -17,7 +17,7 @@ type SimInit<Data, Params> = ((params: Params) => Data) | Data;
  */
 declare function isInitFn<Data, Params>(init: SimInit<Data, Params>): init is (params: Params) => Data;
 /** A simulation module: the pure business logic that automatick drives. */
-type SimModule<Data, Params> = {
+type SimModule<Data, Params = Record<string, never>> = {
     /**
      * Initial simulation state — value or `(params) => Data`. When a value is
      * passed, the engine takes a fresh `structuredClone` on every (re)init so
@@ -28,8 +28,12 @@ type SimModule<Data, Params> = {
     step: (state: State<Data, Params>) => Data;
     /** Optional termination predicate. Checked after each step. If it returns true, the simulation stops. */
     shouldStop?: (data: Data, params: Params) => boolean;
-    /** Default parameter values. Used at engine creation if no params override is provided. */
-    defaultParams: Params;
+    /**
+     * Default parameter values. Optional — sims without tweakable params can
+     * omit this. When omitted, `Params` defaults to `Record<string, never>` and
+     * the engine seeds an empty params object.
+     */
+    defaultParams?: Params;
 };
 /**
  * Define a simulation module with full type inference.
@@ -47,7 +51,7 @@ type SimModule<Data, Params> = {
  * });
  * ```
  */
-declare function defineSim<Data, Params>(sim: SimModule<Data, Params>): SimModule<Data, Params>;
+declare function defineSim<Data, Params = Record<string, never>>(sim: SimModule<Data, Params>): SimModule<Data, Params>;
 /** Extract the Data type from a SimModule. */
 type SimData<M> = M extends SimModule<infer D, infer _P> ? D : never;
 /** Extract the Params type from a SimModule. */

package/dist/sim.d.ts

@@ -17,7 +17,7 @@ type SimInit<Data, Params> = ((params: Params) => Data) | Data;
  */
 declare function isInitFn<Data, Params>(init: SimInit<Data, Params>): init is (params: Params) => Data;
 /** A simulation module: the pure business logic that automatick drives. */
-type SimModule<Data, Params> = {
+type SimModule<Data, Params = Record<string, never>> = {
     /**
      * Initial simulation state — value or `(params) => Data`. When a value is
      * passed, the engine takes a fresh `structuredClone` on every (re)init so
@@ -28,8 +28,12 @@ type SimModule<Data, Params> = {
     step: (state: State<Data, Params>) => Data;
     /** Optional termination predicate. Checked after each step. If it returns true, the simulation stops. */
     shouldStop?: (data: Data, params: Params) => boolean;
-    /** Default parameter values. Used at engine creation if no params override is provided. */
-    defaultParams: Params;
+    /**
+     * Default parameter values. Optional — sims without tweakable params can
+     * omit this. When omitted, `Params` defaults to `Record<string, never>` and
+     * the engine seeds an empty params object.
+     */
+    defaultParams?: Params;
 };
 /**
  * Define a simulation module with full type inference.
@@ -47,7 +51,7 @@ type SimModule<Data, Params> = {
  * });
  * ```
  */
-declare function defineSim<Data, Params>(sim: SimModule<Data, Params>): SimModule<Data, Params>;
+declare function defineSim<Data, Params = Record<string, never>>(sim: SimModule<Data, Params>): SimModule<Data, Params>;
 /** Extract the Data type from a SimModule. */
 type SimData<M> = M extends SimModule<infer D, infer _P> ? D : never;
 /** Extract the Params type from a SimModule. */

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/worker/createSimWorker.cjs

@@ -72,16 +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;
       }
@@ -113,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; }
@@ -129,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);
     }