automatick 0.0.1

package/dist/engine.cjs

@@ -0,0 +1,231 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  SimulationEngine: () => SimulationEngine,
+  createEngine: () => createEngine
+});
+module.exports = __toCommonJS(engine_exports);
+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 = [];
+  constructor(config) {
+    this.initFn = config.init;
+    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 };
+    this.data = this.initFn(this.params);
+  }
+  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() {
+    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
+      });
+      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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SimulationEngine,
+  createEngine
+});

package/dist/engine.d.cts

@@ -0,0 +1,72 @@
+import { StepArgs } from './sim.cjs';
+
+type SimulationStatus = 'idle' | 'playing' | 'paused' | 'stopped';
+type TickPerformance = {
+    tick: number;
+    stepMs: number;
+    drawMs?: number;
+};
+type EngineConfig<Data, Params> = {
+    init: (params: Params) => Data;
+    step: (args: StepArgs<Data, Params>) => Data;
+    shouldStop?: (data: Data, params: Params) => boolean;
+    initialParams: Params;
+    maxTime?: number;
+    delayMs?: number;
+    ticksPerFrame?: number;
+};
+type EngineSnapshot<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+    status: SimulationStatus;
+    stepDurationMs: number;
+};
+declare class SimulationEngine<Data, Params> {
+    private data;
+    private params;
+    private tick;
+    private status;
+    private lastUpdateMs;
+    private lastStepMs;
+    private readonly initFn;
+    private readonly stepFn;
+    private readonly shouldStopFn?;
+    private readonly maxTime?;
+    private delayMs;
+    private ticksPerFrame;
+    private readonly listeners;
+    private readonly historyListeners;
+    private readonly perfBuffer;
+    constructor(config: EngineConfig<Data, Params>);
+    getSnapshot(): EngineSnapshot<Data, Params>;
+    getStatus(): SimulationStatus;
+    getPerformance(): readonly TickPerformance[];
+    setDelayMs(ms: number): void;
+    setTicksPerFrame(n: number): void;
+    recordDrawTime(tick: number, ms: number): void;
+    subscribe(listener: (snapshot: EngineSnapshot<Data, Params>) => void): () => void;
+    subscribeHistory(listener: (entry: {
+        tick: number;
+        data: Data;
+    }) => void): () => void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    seek(targetTick: number): void;
+    advance(count?: number): void;
+    setParams(patch: Partial<Params>): void;
+    resetWith(patch?: Partial<Params>): void;
+    handleAnimationFrame(nowMs: number): void;
+    destroy(): void;
+    /**
+     * Run step up to `count` ticks. Returns true if all ticks completed
+     * without termination, false if stopped early.
+     */
+    private advanceTicks;
+    private emit;
+    private emitHistory;
+}
+declare function createEngine<Data, Params>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
+
+export { type EngineConfig, type EngineSnapshot, SimulationEngine, type SimulationStatus, type TickPerformance, createEngine };

package/dist/engine.d.ts

@@ -0,0 +1,72 @@
+import { StepArgs } from './sim.js';
+
+type SimulationStatus = 'idle' | 'playing' | 'paused' | 'stopped';
+type TickPerformance = {
+    tick: number;
+    stepMs: number;
+    drawMs?: number;
+};
+type EngineConfig<Data, Params> = {
+    init: (params: Params) => Data;
+    step: (args: StepArgs<Data, Params>) => Data;
+    shouldStop?: (data: Data, params: Params) => boolean;
+    initialParams: Params;
+    maxTime?: number;
+    delayMs?: number;
+    ticksPerFrame?: number;
+};
+type EngineSnapshot<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+    status: SimulationStatus;
+    stepDurationMs: number;
+};
+declare class SimulationEngine<Data, Params> {
+    private data;
+    private params;
+    private tick;
+    private status;
+    private lastUpdateMs;
+    private lastStepMs;
+    private readonly initFn;
+    private readonly stepFn;
+    private readonly shouldStopFn?;
+    private readonly maxTime?;
+    private delayMs;
+    private ticksPerFrame;
+    private readonly listeners;
+    private readonly historyListeners;
+    private readonly perfBuffer;
+    constructor(config: EngineConfig<Data, Params>);
+    getSnapshot(): EngineSnapshot<Data, Params>;
+    getStatus(): SimulationStatus;
+    getPerformance(): readonly TickPerformance[];
+    setDelayMs(ms: number): void;
+    setTicksPerFrame(n: number): void;
+    recordDrawTime(tick: number, ms: number): void;
+    subscribe(listener: (snapshot: EngineSnapshot<Data, Params>) => void): () => void;
+    subscribeHistory(listener: (entry: {
+        tick: number;
+        data: Data;
+    }) => void): () => void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    seek(targetTick: number): void;
+    advance(count?: number): void;
+    setParams(patch: Partial<Params>): void;
+    resetWith(patch?: Partial<Params>): void;
+    handleAnimationFrame(nowMs: number): void;
+    destroy(): void;
+    /**
+     * Run step up to `count` ticks. Returns true if all ticks completed
+     * without termination, false if stopped early.
+     */
+    private advanceTicks;
+    private emit;
+    private emitHistory;
+}
+declare function createEngine<Data, Params>(config: EngineConfig<Data, Params>): SimulationEngine<Data, Params>;
+
+export { type EngineConfig, type EngineSnapshot, SimulationEngine, type SimulationStatus, type TickPerformance, createEngine };

package/dist/engine.js

@@ -0,0 +1,8 @@
+import {
+  SimulationEngine,
+  createEngine
+} from "./chunk-YNLOTPDY.js";
+export {
+  SimulationEngine,
+  createEngine
+};

package/dist/react/EngineContext.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/EngineContext.tsx
+var EngineContext_exports = {};
+__export(EngineContext_exports, {
+  EngineContext: () => EngineContext
+});
+module.exports = __toCommonJS(EngineContext_exports);
+var import_react = __toESM(require("react"), 1);
+var EngineContext = import_react.default.createContext(
+  null
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EngineContext
+});

package/dist/react/EngineContext.d.cts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { EngineSnapshot, TickPerformance } from '../engine.cjs';
+import '../sim.cjs';
+
+/**
+ * Internal context that exposes the engine's subscribe function directly.
+ * Used by useSimulationCanvas to bypass React's render cycle for canvas updates,
+ * and to record draw timing back to the engine's performance buffer.
+ */
+type EngineContextValue = {
+    subscribe: (listener: (snapshot: EngineSnapshot<unknown, unknown>) => void) => () => void;
+    getSnapshot: () => EngineSnapshot<unknown, unknown>;
+    recordDrawTime: (tick: number, ms: number) => void;
+    getPerformance: () => readonly TickPerformance[];
+};
+declare const EngineContext: React.Context<EngineContextValue | null>;
+
+export { EngineContext, type EngineContextValue };

package/dist/react/EngineContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { EngineSnapshot, TickPerformance } from '../engine.js';
+import '../sim.js';
+
+/**
+ * Internal context that exposes the engine's subscribe function directly.
+ * Used by useSimulationCanvas to bypass React's render cycle for canvas updates,
+ * and to record draw timing back to the engine's performance buffer.
+ */
+type EngineContextValue = {
+    subscribe: (listener: (snapshot: EngineSnapshot<unknown, unknown>) => void) => () => void;
+    getSnapshot: () => EngineSnapshot<unknown, unknown>;
+    recordDrawTime: (tick: number, ms: number) => void;
+    getPerformance: () => readonly TickPerformance[];
+};
+declare const EngineContext: React.Context<EngineContextValue | null>;
+
+export { EngineContext, type EngineContextValue };

package/dist/react/EngineContext.js

@@ -0,0 +1,6 @@
+import {
+  EngineContext
+} from "../chunk-OA6FGXTP.js";
+export {
+  EngineContext
+};