automatick 0.0.1

package/dist/react/useSimulationCanvas.cjs

@@ -0,0 +1,92 @@
+"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/useSimulationCanvas.ts
+var useSimulationCanvas_exports = {};
+__export(useSimulationCanvas_exports, {
+  useSimulationCanvas: () => useSimulationCanvas
+});
+module.exports = __toCommonJS(useSimulationCanvas_exports);
+var import_react2 = __toESM(require("react"), 1);
+
+// src/react/EngineContext.tsx
+var import_react = __toESM(require("react"), 1);
+var EngineContext = import_react.default.createContext(
+  null
+);
+
+// src/react/useSimulationCanvas.ts
+function useSimulationCanvas(draw) {
+  const engineCtx = import_react2.default.useContext(EngineContext);
+  if (!engineCtx) {
+    throw new Error(
+      "useSimulationCanvas must be used within a <Simulation>"
+    );
+  }
+  const canvasRef = import_react2.default.useRef(null);
+  const drawRef = import_react2.default.useRef(draw);
+  drawRef.current = draw;
+  import_react2.default.useEffect(() => {
+    const canvas = canvasRef.current;
+    if (canvas) {
+      const ctx = canvas.getContext("2d");
+      if (ctx) {
+        const snap = engineCtx.getSnapshot();
+        const t0 = performance.now();
+        drawRef.current(ctx, {
+          data: snap.data,
+          params: snap.params,
+          tick: snap.tick
+        });
+        engineCtx.recordDrawTime(snap.tick, performance.now() - t0);
+      }
+    }
+    const unsubscribe = engineCtx.subscribe(
+      (snap) => {
+        const canvas2 = canvasRef.current;
+        if (!canvas2) return;
+        const ctx = canvas2.getContext("2d");
+        if (!ctx) return;
+        const t0 = performance.now();
+        drawRef.current(ctx, {
+          data: snap.data,
+          params: snap.params,
+          tick: snap.tick
+        });
+        engineCtx.recordDrawTime(snap.tick, performance.now() - t0);
+      }
+    );
+    return unsubscribe;
+  }, [engineCtx]);
+  return canvasRef;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSimulationCanvas
+});

package/dist/react/useSimulationCanvas.d.cts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { SimModule } from '../sim.cjs';
+
+/**
+ * Draw callback signature for useSimulationCanvas.
+ * Called imperatively on every engine snapshot — no React re-render involved.
+ */
+type CanvasDrawFn<Data, Params> = (ctx: CanvasRenderingContext2D, snapshot: {
+    data: Data;
+    params: Params;
+    tick: number;
+}) => void;
+type InferDraw<T, FallbackParams> = T extends SimModule<infer D, infer P> ? CanvasDrawFn<D, P> : CanvasDrawFn<T, FallbackParams>;
+/**
+ * Subscribe to simulation snapshots and draw to a canvas without React re-renders.
+ *
+ * Returns a ref to attach to a `<canvas>` element. The `draw` callback is called
+ * directly from the engine's subscription — it bypasses React's state/reconciliation
+ * entirely. Draw timing is recorded automatically to the engine's performance buffer.
+ *
+ * For DOM/React rendering, use `useSimulation()` instead.
+ *
+ * @example
+ * ```tsx
+ * function BoidsCanvas() {
+ *   const canvasRef = useSimulationCanvas<typeof boidsSim>((ctx, { data, params }) => {
+ *     ctx.clearRect(0, 0, params.width, params.height);
+ *     data.forEach(boid => {
+ *       ctx.fillRect(boid.x, boid.y, 3, 3);
+ *     });
+ *   });
+ *   return <canvas ref={canvasRef} width={400} height={400} />;
+ * }
+ * ```
+ */
+declare function useSimulationCanvas<T = unknown, FallbackParams = unknown>(draw: InferDraw<T, FallbackParams>): React.RefObject<HTMLCanvasElement>;
+
+export { type CanvasDrawFn, useSimulationCanvas };

package/dist/react/useSimulationCanvas.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { SimModule } from '../sim.js';
+
+/**
+ * Draw callback signature for useSimulationCanvas.
+ * Called imperatively on every engine snapshot — no React re-render involved.
+ */
+type CanvasDrawFn<Data, Params> = (ctx: CanvasRenderingContext2D, snapshot: {
+    data: Data;
+    params: Params;
+    tick: number;
+}) => void;
+type InferDraw<T, FallbackParams> = T extends SimModule<infer D, infer P> ? CanvasDrawFn<D, P> : CanvasDrawFn<T, FallbackParams>;
+/**
+ * Subscribe to simulation snapshots and draw to a canvas without React re-renders.
+ *
+ * Returns a ref to attach to a `<canvas>` element. The `draw` callback is called
+ * directly from the engine's subscription — it bypasses React's state/reconciliation
+ * entirely. Draw timing is recorded automatically to the engine's performance buffer.
+ *
+ * For DOM/React rendering, use `useSimulation()` instead.
+ *
+ * @example
+ * ```tsx
+ * function BoidsCanvas() {
+ *   const canvasRef = useSimulationCanvas<typeof boidsSim>((ctx, { data, params }) => {
+ *     ctx.clearRect(0, 0, params.width, params.height);
+ *     data.forEach(boid => {
+ *       ctx.fillRect(boid.x, boid.y, 3, 3);
+ *     });
+ *   });
+ *   return <canvas ref={canvasRef} width={400} height={400} />;
+ * }
+ * ```
+ */
+declare function useSimulationCanvas<T = unknown, FallbackParams = unknown>(draw: InferDraw<T, FallbackParams>): React.RefObject<HTMLCanvasElement>;
+
+export { type CanvasDrawFn, useSimulationCanvas };

package/dist/react/useSimulationCanvas.js

@@ -0,0 +1,53 @@
+import {
+  EngineContext
+} from "../chunk-OA6FGXTP.js";
+
+// src/react/useSimulationCanvas.ts
+import React from "react";
+function useSimulationCanvas(draw) {
+  const engineCtx = React.useContext(EngineContext);
+  if (!engineCtx) {
+    throw new Error(
+      "useSimulationCanvas must be used within a <Simulation>"
+    );
+  }
+  const canvasRef = React.useRef(null);
+  const drawRef = React.useRef(draw);
+  drawRef.current = draw;
+  React.useEffect(() => {
+    const canvas = canvasRef.current;
+    if (canvas) {
+      const ctx = canvas.getContext("2d");
+      if (ctx) {
+        const snap = engineCtx.getSnapshot();
+        const t0 = performance.now();
+        drawRef.current(ctx, {
+          data: snap.data,
+          params: snap.params,
+          tick: snap.tick
+        });
+        engineCtx.recordDrawTime(snap.tick, performance.now() - t0);
+      }
+    }
+    const unsubscribe = engineCtx.subscribe(
+      (snap) => {
+        const canvas2 = canvasRef.current;
+        if (!canvas2) return;
+        const ctx = canvas2.getContext("2d");
+        if (!ctx) return;
+        const t0 = performance.now();
+        drawRef.current(ctx, {
+          data: snap.data,
+          params: snap.params,
+          tick: snap.tick
+        });
+        engineCtx.recordDrawTime(snap.tick, performance.now() - t0);
+      }
+    );
+    return unsubscribe;
+  }, [engineCtx]);
+  return canvasRef;
+}
+export {
+  useSimulationCanvas
+};

package/dist/sim.cjs

@@ -0,0 +1,32 @@
+"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/sim.ts
+var sim_exports = {};
+__export(sim_exports, {
+  defineSim: () => defineSim
+});
+module.exports = __toCommonJS(sim_exports);
+function defineSim(sim) {
+  return sim;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineSim
+});

package/dist/sim.d.cts

@@ -0,0 +1,40 @@
+/** Arguments passed to the `step` function on each tick. */
+type StepArgs<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+};
+/** A simulation module: the pure business logic that automatick drives. */
+type SimModule<Data, Params> = {
+    /** Create initial simulation state from params. Called on engine creation and on resetWith(). */
+    init: (params: Params) => Data;
+    /** Advance the simulation by one tick. Must be pure and synchronous. */
+    step: (args: StepArgs<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;
+};
+/**
+ * Define a simulation module with full type inference.
+ *
+ * This is an identity function — it returns its argument unchanged. Its purpose is to
+ * enable TypeScript to infer `Data` and `Params` from the `init` and `step` implementations,
+ * so the developer never needs to annotate types inside those functions.
+ *
+ * @example
+ * ```ts
+ * export default defineSim<{ count: number }, { increment: number }>({
+ *   defaultParams: { increment: 1 },
+ *   init: (params) => ({ count: 0 }),
+ *   step: ({ data, params }) => ({ count: data.count + params.increment }),
+ * });
+ * ```
+ */
+declare function defineSim<Data, Params>(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. */
+type SimParams<M> = M extends SimModule<infer _D, infer P> ? P : never;
+
+export { type SimData, type SimModule, type SimParams, type StepArgs, defineSim };

package/dist/sim.d.ts

@@ -0,0 +1,40 @@
+/** Arguments passed to the `step` function on each tick. */
+type StepArgs<Data, Params> = {
+    data: Data;
+    params: Params;
+    tick: number;
+};
+/** A simulation module: the pure business logic that automatick drives. */
+type SimModule<Data, Params> = {
+    /** Create initial simulation state from params. Called on engine creation and on resetWith(). */
+    init: (params: Params) => Data;
+    /** Advance the simulation by one tick. Must be pure and synchronous. */
+    step: (args: StepArgs<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;
+};
+/**
+ * Define a simulation module with full type inference.
+ *
+ * This is an identity function — it returns its argument unchanged. Its purpose is to
+ * enable TypeScript to infer `Data` and `Params` from the `init` and `step` implementations,
+ * so the developer never needs to annotate types inside those functions.
+ *
+ * @example
+ * ```ts
+ * export default defineSim<{ count: number }, { increment: number }>({
+ *   defaultParams: { increment: 1 },
+ *   init: (params) => ({ count: 0 }),
+ *   step: ({ data, params }) => ({ count: data.count + params.increment }),
+ * });
+ * ```
+ */
+declare function defineSim<Data, Params>(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. */
+type SimParams<M> = M extends SimModule<infer _D, infer P> ? P : never;
+
+export { type SimData, type SimModule, type SimParams, type StepArgs, defineSim };

package/dist/sim.js

@@ -0,0 +1,7 @@
+// src/sim.ts
+function defineSim(sim) {
+  return sim;
+}
+export {
+  defineSim
+};

package/dist/worker/createSimWorker.cjs

@@ -0,0 +1,147 @@
+"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/worker/createSimWorker.ts
+var createSimWorker_exports = {};
+__export(createSimWorker_exports, {
+  createSimWorker: () => createSimWorker
+});
+module.exports = __toCommonJS(createSimWorker_exports);
+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,
+        });
+        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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSimWorker
+});

package/dist/worker/createSimWorker.d.cts

@@ -0,0 +1,19 @@
+import { WorkerConfig } from './protocol.cjs';
+import '../engine.cjs';
+import '../sim.cjs';
+
+/**
+ * Creates a Web Worker that loads a sim module and runs the engine.
+ *
+ * Uses a blob URL with dynamic import() — works in Vite dev (modules served
+ * over HTTP) and in production builds (bundled chunks).
+ */
+
+declare function createSimWorker<Params>(options: {
+    moduleUrl: string;
+    engineUrl: string;
+    initialParams: Params;
+    config: WorkerConfig;
+}): Worker;
+
+export { createSimWorker };

package/dist/worker/createSimWorker.d.ts

@@ -0,0 +1,19 @@
+import { WorkerConfig } from './protocol.js';
+import '../engine.js';
+import '../sim.js';
+
+/**
+ * Creates a Web Worker that loads a sim module and runs the engine.
+ *
+ * Uses a blob URL with dynamic import() — works in Vite dev (modules served
+ * over HTTP) and in production builds (bundled chunks).
+ */
+
+declare function createSimWorker<Params>(options: {
+    moduleUrl: string;
+    engineUrl: string;
+    initialParams: Params;
+    config: WorkerConfig;
+}): Worker;
+
+export { createSimWorker };

package/dist/worker/createSimWorker.js

@@ -0,0 +1,122 @@
+// 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,
+        });
+        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;
+}
+export {
+  createSimWorker
+};

package/dist/worker/protocol.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/worker/protocol.ts
+var protocol_exports = {};
+module.exports = __toCommonJS(protocol_exports);