automatick 0.0.2 → 0.0.3

package/dist/react/Simulation.cjs

@@ -73,7 +73,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);
@@ -274,6 +274,221 @@ function createEngine(config) {
   return new SimulationEngine(config);
 }
 
+// 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;
+}
+
+// src/worker/serialize.ts
+function deserializeWorkerMessage(raw) {
+  return raw;
+}
+function serializeMainMessage(msg) {
+  return msg;
+}
+
+// src/worker/workerRunner.ts
+var PERF_BUFFER_SIZE2 = 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_SIZE2) 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();
+    }
+  };
+}
+
 // src/react/SimulationContext.tsx
 var import_react = __toESM(require("react"), 1);
 var SimulationContext = import_react.default.createContext(null);
@@ -296,15 +511,31 @@ function useStableCallback(fn) {
 
 // src/react/Simulation.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
+var import_meta = {};
 function LocalSimulation(props) {
-  const { sim, params: paramsProp, children, autoplay } = props;
+  const {
+    init,
+    step,
+    shouldStop,
+    defaultParams,
+    params: paramsProp,
+    children,
+    autoplay
+  } = props;
   const engineRef = import_react4.default.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,
@@ -346,119 +577,70 @@ function LocalSimulation(props) {
   }, [engine]);
   return /* @__PURE__ */ (0, import_jsx_runtime.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] = import_react4.default.useState(
+  const [runner, setRunner] = import_react4.default.useState(
     null
   );
   const [snapshot, setSnapshot] = import_react4.default.useState(
     null
   );
-  const propsRef = import_react4.default.useRef(props);
-  propsRef.current = props;
   import_react4.default.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();
     };
   }, []);
   import_react4.default.useEffect(() => {
-    if (!backend) return;
-    return backend.subscribe((next) => setSnapshot(next));
-  }, [backend]);
-  import_react4.default.useEffect(() => {
-    if (autoplay && backend) backend.play();
-  }, [backend, autoplay]);
+    if (autoplay && runner) runner.play();
+  }, [runner, autoplay]);
   const isFirstRender = import_react4.default.useRef(true);
   import_react4.default.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__ */ (0, import_jsx_runtime.jsx)(SimulationProvider, { snapshot, backend, children });
+    if (props.params && runner) runner.setParams(props.params);
+  }, [runner, props.params]);
+  import_react4.default.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__ */ (0, import_jsx_runtime.jsx)(SimulationProvider, { snapshot, backend: runner, children });
 }
 function SimulationProvider({
   snapshot,
@@ -517,6 +699,19 @@ function Simulation(props) {
   if ("worker" in props && props.worker != null) {
     return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WorkerSimulation, { ...props });
   }
+  if ("sim" in props && props.sim != null) {
+    const { sim, ...rest } = props;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      LocalSimulation,
+      {
+        ...rest,
+        init: sim.init,
+        step: sim.step,
+        shouldStop: sim.shouldStop,
+        defaultParams: sim.defaultParams
+      }
+    );
+  }
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocalSimulation, { ...props });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/react/Simulation.d.cts

@@ -1,11 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
-import { SimModule } from '../sim.cjs';
-import '../state.cjs';
+import { SimModule, SimInit } from '../sim.cjs';
+import { State } from '../state.cjs';
 
-type SimulationPropsLocal<Data, Params> = {
-    sim: SimModule<Data, Params>;
-    worker?: never;
+/** Common simulation-level props shared by all three modes. */
+type SimulationPropsCommon<Params> = {
     params?: Partial<Params>;
     maxTime?: number;
     delayMs?: number;
@@ -13,20 +12,40 @@ type SimulationPropsLocal<Data, Params> = {
     autoplay?: boolean;
     children?: React.ReactNode;
 };
-type SimulationPropsWorker<Data, Params> = {
+type SimulationPropsLocal<Data, Params> = SimulationPropsCommon<Params> & {
+    sim: SimModule<Data, Params>;
+    worker?: never;
+    init?: never;
+    step?: never;
+    shouldStop?: never;
+    defaultParams?: never;
+};
+type SimulationPropsWorker<_Data, Params> = SimulationPropsCommon<Params> & {
     sim?: never;
-    worker: () => Promise<{
-        default: SimModule<Data, Params>;
-    }>;
-    params?: Partial<Params>;
-    maxTime?: number;
-    delayMs?: number;
-    ticksPerFrame?: number;
+    /**
+     * URL of the sim module the worker should `import()` inside its own context.
+     * Vite idiom: `new URL('./sim.ts', import.meta.url)`. Plain strings are
+     * resolved the same way.
+     *
+     * Data/Params can't be inferred from a URL, so worker-mode call sites
+     * specify them via the `<Simulation<Data, Params>>` generic parameters.
+     */
+    worker: URL | string;
+    init?: never;
+    step?: never;
+    shouldStop?: never;
+    defaultParams?: never;
     snapshotIntervalMs?: number;
-    autoplay?: boolean;
-    children?: React.ReactNode;
 };
-type SimulationProps<Data, Params> = SimulationPropsLocal<Data, Params> | SimulationPropsWorker<Data, Params>;
-declare function Simulation<Data, Params>(props: SimulationProps<Data, Params>): react_jsx_runtime.JSX.Element;
+type SimulationPropsInline<Data, Params> = SimulationPropsCommon<Params> & {
+    sim?: never;
+    worker?: never;
+    init: SimInit<Data, Params>;
+    step: (state: State<Data, Params>) => Data;
+    shouldStop?: (data: Data, params: Params) => boolean;
+    defaultParams?: Params;
+};
+type SimulationProps<Data, Params = Record<string, never>> = SimulationPropsLocal<Data, Params> | SimulationPropsWorker<Data, Params> | SimulationPropsInline<Data, Params>;
+declare function Simulation<Data, Params = Record<string, never>>(props: SimulationProps<Data, Params>): react_jsx_runtime.JSX.Element;
 
 export { Simulation, type SimulationProps };

package/dist/react/Simulation.d.ts

@@ -1,11 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
-import { SimModule } from '../sim.js';
-import '../state.js';
+import { SimModule, SimInit } from '../sim.js';
+import { State } from '../state.js';
 
-type SimulationPropsLocal<Data, Params> = {
-    sim: SimModule<Data, Params>;
-    worker?: never;
+/** Common simulation-level props shared by all three modes. */
+type SimulationPropsCommon<Params> = {
     params?: Partial<Params>;
     maxTime?: number;
     delayMs?: number;
@@ -13,20 +12,40 @@ type SimulationPropsLocal<Data, Params> = {
     autoplay?: boolean;
     children?: React.ReactNode;
 };
-type SimulationPropsWorker<Data, Params> = {
+type SimulationPropsLocal<Data, Params> = SimulationPropsCommon<Params> & {
+    sim: SimModule<Data, Params>;
+    worker?: never;
+    init?: never;
+    step?: never;
+    shouldStop?: never;
+    defaultParams?: never;
+};
+type SimulationPropsWorker<_Data, Params> = SimulationPropsCommon<Params> & {
     sim?: never;
-    worker: () => Promise<{
-        default: SimModule<Data, Params>;
-    }>;
-    params?: Partial<Params>;
-    maxTime?: number;
-    delayMs?: number;
-    ticksPerFrame?: number;
+    /**
+     * URL of the sim module the worker should `import()` inside its own context.
+     * Vite idiom: `new URL('./sim.ts', import.meta.url)`. Plain strings are
+     * resolved the same way.
+     *
+     * Data/Params can't be inferred from a URL, so worker-mode call sites
+     * specify them via the `<Simulation<Data, Params>>` generic parameters.
+     */
+    worker: URL | string;
+    init?: never;
+    step?: never;
+    shouldStop?: never;
+    defaultParams?: never;
     snapshotIntervalMs?: number;
-    autoplay?: boolean;
-    children?: React.ReactNode;
 };
-type SimulationProps<Data, Params> = SimulationPropsLocal<Data, Params> | SimulationPropsWorker<Data, Params>;
-declare function Simulation<Data, Params>(props: SimulationProps<Data, Params>): react_jsx_runtime.JSX.Element;
+type SimulationPropsInline<Data, Params> = SimulationPropsCommon<Params> & {
+    sim?: never;
+    worker?: never;
+    init: SimInit<Data, Params>;
+    step: (state: State<Data, Params>) => Data;
+    shouldStop?: (data: Data, params: Params) => boolean;
+    defaultParams?: Params;
+};
+type SimulationProps<Data, Params = Record<string, never>> = SimulationPropsLocal<Data, Params> | SimulationPropsWorker<Data, Params> | SimulationPropsInline<Data, Params>;
+declare function Simulation<Data, Params = Record<string, never>>(props: SimulationProps<Data, Params>): react_jsx_runtime.JSX.Element;
 
 export { Simulation, type SimulationProps };