flingit 0.0.62 → 0.0.65

package/node_modules/determined/README.md

@@ -0,0 +1,317 @@
+# determined
+
+A deterministic simulation testing (DST) framework for TypeScript. It provides controlled scheduling of concurrent tasks, reproducible entropy, and concurrency primitives — all designed so that bugs found during simulation can be replayed exactly.
+
+## Overview
+
+In production, concurrent tasks run with real async scheduling, real randomness, and real concurrency primitives. During testing, `determined` replaces all of these with deterministic equivalents controlled by an entropy source. This means:
+
+- **Every scheduling decision** (which task runs next) is driven by entropy, not the JS event loop.
+- **Failpoints** can be injected probabilistically to test error paths.
+- **Failures are reproducible**: record the entropy, replay it, get the exact same execution.
+
+## Installation
+
+```bash
+npm install determined
+```
+
+Works with both ESM and CommonJS:
+
+```typescript
+// ESM
+import { SimulationImpl, noSimulation, Mutex, ConditionVariable } from "determined";
+
+// CJS
+const { SimulationImpl, noSimulation, Mutex, ConditionVariable } = require("determined");
+```
+
+## Modules
+
+### simulation.ts
+
+The core of the framework. Defines the `SimulationTask` interface and two implementations of the `Simulation` runner.
+
+#### `SimulationTask`
+
+The interface every task function receives. It extends `Logger` and `EntropySource` and provides:
+
+- **`checkpoint(...log)`** — A yield point. The task suspends and the scheduler picks which task to resume next. Use this at every point where you want the simulation to explore different interleavings.
+- **`failpoint(...log)`** — Like checkpoint, but may also inject a simulated failure (an `ApplicationFailure`) based on `failureProbability`. If the failpoint passes, it acts as a scheduling point. When `failureProbability` is 0, no entropy is consumed for the fail decision (important for replay determinism).
+- **`blockpoint(...log)`** — Marks the task as blocked (waiting on an external condition like a mutex or condition variable). Unlike checkpoint, blocked tasks are excluded from scheduling until something unblocks them. If all tasks are blocked, the simulation detects deadlock.
+- **`abortSimulation(error)`** — Immediately aborts the entire simulation run with the given error.
+- **`random(reason)`** — Returns a random number in [0, 1) from the simulation's entropy source.
+- **`log(...)`** / **`error(...)`** — Logging, routed through the simulation's logger.
+
+#### `SimulationImpl`
+
+The deterministic simulation runner. Constructed with:
+
+```typescript
+new SimulationImpl(logger: Logger, entropy: EntropySource, failureProbability: number)
+```
+
+Call `runTasks(specs)` with an array of `TaskSpec` objects. Each spec has a `name` and an async function `f` that receives a `SimulationTask`. All tasks start at an implicit `checkpoint("START")`, and the scheduler picks which one runs first.
+
+Returns `Result<T[], Error>` — either the array of results (in spec order) or the first error that occurred.
+
+**Scheduling algorithm**: When all running tasks have reached a checkpoint or blockpoint, the scheduler picks one of the checkpointed tasks using `sample()` (entropy-driven). Blocked tasks are excluded. If no tasks are checkpointed and all are blocked, a deadlock error is raised.
+
+#### `NoSimulationTask` / `noSimulation`
+
+Production-mode implementations where `checkpoint()` and `failpoint()` resolve immediately, `blockpoint()` is a no-op, and `random()` uses `Math.random()`. The `noSimulation` singleton runs all tasks concurrently via `Promise.all`.
+
+### entropy.ts
+
+Pluggable entropy for deterministic randomness.
+
+#### `EntropySource`
+
+```typescript
+interface EntropySource {
+    random(reason: string): number; // returns [0, 1)
+}
+```
+
+The `reason` parameter is a human-readable label used for recording and replay diagnostics.
+
+#### Implementations
+
+- **`SimpleEntropySource`** — Wraps `Math.random()`. Used in production.
+- **`RecordingEntropySource`** — Wraps another source, records every `(name, value)` pair. Use during test runs to capture entropy for later replay.
+- **`ReplayingEntropySource`** — Replays a recorded sequence. Throws on name mismatch (detects divergence from the recorded run) or exhaustion. Use to reproduce failures.
+
+#### `sample(entropy, name, items)`
+
+Picks a random element from an array using the entropy source. Returns `undefined` for empty arrays. For single-element arrays, returns the element without consuming entropy (important for replay: avoids spurious entropy consumption when the choice is forced).
+
+### errors.ts
+
+#### `ApplicationFailure`
+
+Extends `Error` with:
+
+- **`type?: ErrorType`** — A branded string for categorizing errors.
+- **`nonRetryable: boolean`** — Defaults to `false`. When `true`, indicates the error should not be retried.
+
+Used by failpoints to distinguish simulated failures from real bugs.
+
+#### `isApplicationFailure(error)`
+
+Type guard for `ApplicationFailure`.
+
+### mutex.ts
+
+An async mutex for use inside simulated tasks.
+
+```typescript
+const mutex = new Mutex("my-lock");
+
+// In a task:
+await mutex.lock(task, "critical section");
+try {
+    // ... exclusive access ...
+} finally {
+    mutex.unlock(task, "critical section");
+}
+```
+
+- **`lock(task, reason)`** — If unlocked, acquires immediately. If locked, calls `blockpoint` (marking the task as blocked) and enqueues. When the lock is released, the first waiter is woken via `checkpoint`.
+- **`unlock(task, reason)`** — Releases the lock. If waiters are queued, passes the lock to the first one (FIFO).
+- **`isLocked`** — Read-only property.
+
+### condition-variable.ts
+
+A condition variable for signaling between simulated tasks. Unlike classical condition variables, this is not paired with a mutex — it's a simple waiter list.
+
+```typescript
+const cv = new ConditionVariable("data-ready");
+
+// Waiting task:
+await cv.wait(task, "new data");
+
+// Notifying task:
+cv.notifyAll(task, "data arrived");
+```
+
+- **`wait(task, reason)`** — Calls `blockpoint` (task is blocked), then parks. The task resumes via `checkpoint` when `notifyAll` is called.
+- **`notifyAll(task, reason)`** — Wakes all waiting tasks. Does nothing if no waiters. Notifications are **not sticky** — if `notifyAll` is called before `wait`, the notification is lost and the waiter will block forever (deadlock).
+
+## Usage Example
+
+The sync engine uses `determined` to test concurrent sync and mutation operations. Here's a condensed version showing the key patterns:
+
+### Writing code that works with both simulation and production
+
+The `Simulation` interface abstracts over `SimulationImpl` (testing) and `noSimulation` (production). Your code takes a `SimulationTask` and uses its methods to yield control:
+
+```typescript
+import {
+    type Simulation, type SimulationTask,
+    ConditionVariable, Mutex, sample, isApplicationFailure,
+} from "determined";
+
+const mutex = new Mutex("db-lock");
+
+async function writer(task: SimulationTask, data: string[]) {
+    await mutex.lock(task, "write");
+    try {
+        // failpoint: may inject a simulated failure here during testing
+        await task.failpoint("before write");
+        data.push("written");
+        // checkpoint: allows the scheduler to switch to another task
+        await task.checkpoint("after write");
+    } finally {
+        mutex.unlock(task, "write");
+    }
+}
+
+async function reader(task: SimulationTask, data: string[]) {
+    await mutex.lock(task, "read");
+    try {
+        task.log("current data:", data);
+    } finally {
+        mutex.unlock(task, "read");
+    }
+}
+```
+
+Use a `ConditionVariable` to signal between tasks:
+
+```typescript
+async function producer(task: SimulationTask, cv: ConditionVariable, done: { value: boolean }) {
+    await task.checkpoint("producing");
+    done.value = true;
+    cv.notifyAll(task, "data ready");
+}
+
+async function consumer(task: SimulationTask, cv: ConditionVariable, done: { value: boolean }) {
+    if (!done.value) {
+        await cv.wait(task, "waiting for data");
+    }
+    task.log("consumed");
+}
+```
+
+Use `sample()` and `task.random()` for any random decisions, so they're captured in the entropy trace:
+
+```typescript
+async function pickAction(task: SimulationTask) {
+    const actions = ["insert", "update", "delete"] as const;
+    const action = sample(task, "pick action", actions);
+    // ...
+}
+```
+
+### Running a simulation
+
+```typescript
+import {
+    SimulationImpl, RecordingEntropySource, ReplayingEntropySource,
+    SimpleEntropySource, type Logger,
+} from "determined";
+
+// A logger that captures output
+class ConsoleLogger implements Logger {
+    log(...args: readonly unknown[]) { console.log(...args); }
+    error(...args: readonly unknown[]) { console.error(...args); }
+}
+
+// Run with recording
+const recording = new RecordingEntropySource(new SimpleEntropySource());
+const sim = new SimulationImpl(new ConsoleLogger(), recording, 0.05);
+
+const result = await sim.runTasks([
+    { name: "writer", f: (task) => writer(task, data) },
+    { name: "reader", f: (task) => reader(task, data) },
+]);
+
+if (result.isErr()) {
+    // Save entropy for replay
+    const record = { config: { /* options */ }, record: recording.getRecords() };
+    await fs.writeFile("failure.json", JSON.stringify(record));
+}
+```
+
+### Replaying a failure
+
+```typescript
+const file = JSON.parse(await fs.readFile("failure.json", "utf-8"));
+const replay = new ReplayingEntropySource(file.record);
+const sim = new SimulationImpl(new ConsoleLogger(), replay, 0.05);
+
+// Produces the exact same scheduling decisions and failpoint outcomes
+const result = await sim.runTasks([
+    { name: "writer", f: (task) => writer(task, data) },
+    { name: "reader", f: (task) => reader(task, data) },
+]);
+```
+
+### Running in production (no simulation)
+
+```typescript
+import { noSimulation } from "determined";
+
+// Tasks run concurrently via Promise.all, checkpoints are no-ops
+const result = await noSimulation.runTasks([
+    { name: "writer", f: (task) => writer(task, data) },
+    { name: "reader", f: (task) => reader(task, data) },
+]);
+```
+
+### Iterating over many random interleavings
+
+The playground pattern: run thousands of iterations with different random entropy, automatically saving failures for replay:
+
+```typescript
+for (let i = 0; i < 1000; i++) {
+    const entropy = new RecordingEntropySource(new SimpleEntropySource());
+    const sim = new SimulationImpl(logger, entropy, failureProbability);
+
+    const result = await runMyTest(sim);
+
+    if (result.isErr()) {
+        // Save for later replay
+        await fs.writeFile(
+            `failure-${i}.json`,
+            JSON.stringify({ config: options, record: entropy.getRecords() }),
+        );
+    }
+
+    // Verify replay produces the same result
+    const replayEntropy = new ReplayingEntropySource(entropy.getRecords());
+    const replaySim = new SimulationImpl(logger, replayEntropy, failureProbability);
+    const replayResult = await runMyTest(replaySim);
+    assert(result.isOk() === replayResult.isOk(), "Replay must match original");
+}
+```
+
+## Recording and Replaying Failures
+
+The typical workflow:
+
+1. **Run with recording**: Use `RecordingEntropySource` wrapping a `SimpleEntropySource`.
+2. **On failure**: Save `recording.getRecords()` to a JSON file.
+3. **Replay**: Load the records and pass them to `ReplayingEntropySource`. The simulation will make the exact same scheduling decisions, hit the exact same failpoints, and reproduce the failure.
+
+The `ReplayingEntropySource` validates that each entropy request matches the recorded name. A mismatch means the code has changed in a way that alters the entropy consumption pattern, and it throws a descriptive error with position and both names.
+
+## Commands
+
+```bash
+# Run all tests
+npm test
+
+# Run a single test file
+node --experimental-strip-types --test simulation.test.ts
+
+# Type check
+npm run typecheck
+```
+
+## Design Notes
+
+- All concurrency is cooperative, not preemptive. Tasks only yield control at explicit `checkpoint`, `failpoint`, or `blockpoint` calls.
+- The simulation runs in a single JS event loop turn between scheduling decisions. There is no actual parallelism.
+- `SimulationImpl` should be treated as single-use per `runTasks` call. After a failed run (error or deadlock), the instance is permanently poisoned (`abortedWithError` is never reset) and subsequent `runTasks` calls will immediately fail.
+- The `sample()` function's "no entropy for single item" optimization is critical for replay correctness — it ensures the entropy consumption sequence doesn't depend on transient pool sizes.

package/node_modules/determined/dist/index.cjs

@@ -0,0 +1,370 @@
+"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);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApplicationFailure: () => ApplicationFailure,
+  ConditionVariable: () => ConditionVariable,
+  Mutex: () => Mutex,
+  NoSimulationTask: () => NoSimulationTask,
+  RecordingEntropySource: () => RecordingEntropySource,
+  ReplayingEntropySource: () => ReplayingEntropySource,
+  SimpleEntropySource: () => SimpleEntropySource,
+  SimulationImpl: () => SimulationImpl,
+  isApplicationFailure: () => isApplicationFailure,
+  makeErrorType: () => makeErrorType,
+  noSimulation: () => noSimulation,
+  sample: () => sample
+});
+module.exports = __toCommonJS(index_exports);
+
+// simulation.ts
+var import_ts_necessities2 = require("@glideapps/ts-necessities");
+
+// entropy.ts
+var SimpleEntropySource = class {
+  random() {
+    return Math.random();
+  }
+};
+var RecordingEntropySource = class {
+  underlying;
+  records = [];
+  constructor(underlying) {
+    this.underlying = underlying;
+  }
+  random(name) {
+    const value = this.underlying.random(name);
+    this.records.push({ name, value });
+    return value;
+  }
+  getRecords() {
+    return this.records;
+  }
+};
+var ReplayingEntropySource = class {
+  records;
+  position = 0;
+  constructor(records) {
+    this.records = records.slice();
+  }
+  random(name) {
+    const record = this.records[this.position];
+    if (record === void 0) {
+      throw new Error(`No more entropy records available when requesting "${name}"`);
+    }
+    if (record.name !== name) {
+      throw new Error(
+        `Entropy record name mismatch at position ${this.position}: expected "${record.name}", got "${name}"`
+      );
+    }
+    this.position++;
+    return record.value;
+  }
+};
+function sample(entropy, name, items) {
+  if (items.length < 2) return items[0];
+  const index = Math.floor(entropy.random(name) * items.length);
+  return items[index];
+}
+
+// errors.ts
+var import_ts_necessities = require("@glideapps/ts-necessities");
+var makeErrorType = (0, import_ts_necessities.makeBrandString)();
+var ApplicationFailure = class extends Error {
+  type;
+  nonRetryable;
+  constructor(message, type, nonRetryable) {
+    super(message);
+    this.type = type;
+    this.nonRetryable = nonRetryable ?? false;
+  }
+};
+function isApplicationFailure(error) {
+  return error instanceof ApplicationFailure;
+}
+
+// simulation.ts
+var import_neverthrow = require("neverthrow");
+var NoSimulationTask = class {
+  taskName;
+  shouldLog;
+  constructor(taskName, shouldLog) {
+    this.taskName = taskName;
+    this.shouldLog = shouldLog;
+  }
+  log(...log) {
+    if (this.shouldLog) {
+      console.log(`${this.taskName}: `, ...log);
+    }
+  }
+  error(...log) {
+    console.error(`${this.taskName}: `, ...log);
+  }
+  random() {
+    return Math.random();
+  }
+  checkpoint(...log) {
+    this.log(...log);
+    return Promise.resolve();
+  }
+  failpoint(...log) {
+    this.log(...log);
+    return Promise.resolve();
+  }
+  blockpoint(...log) {
+    this.log(...log);
+  }
+  abortSimulation(e) {
+    throw (0, import_ts_necessities2.exceptionToError)(e);
+  }
+};
+var NoSimulation = class {
+  log;
+  constructor(log) {
+    this.log = log;
+  }
+  async runTasks(specs) {
+    const shouldLog = this.log;
+    try {
+      const results = await Promise.all(
+        specs.map(({ name: taskName, f }) => {
+          const task = new NoSimulationTask(taskName, shouldLog);
+          return f(task);
+        })
+      );
+      return (0, import_neverthrow.ok)(results);
+    } catch (e) {
+      return (0, import_neverthrow.err)((0, import_ts_necessities2.exceptionToError)(e));
+    }
+  }
+};
+var noSimulation = new NoSimulation(false);
+var SimulationImpl = class {
+  logger;
+  entropy;
+  failureProbability;
+  // FIXME: Should this just be a `TaskInfo[]`, since we never look at the task anyway?
+  taskInfos = /* @__PURE__ */ new Map();
+  abortedWithError;
+  constructor(logger, entropy, failureProbability) {
+    this.logger = logger;
+    this.entropy = entropy;
+    this.failureProbability = failureProbability;
+  }
+  abort(e) {
+    if (this.abortedWithError === void 0) {
+      this.abortedWithError = e;
+      this.logger.error(`Aborting simulation: ${(0, import_ts_necessities2.exceptionToString)(e)}`);
+    }
+    throw e;
+  }
+  pickTask(tasks) {
+    const task = sample(this.entropy, `Picking task out of ${tasks.map((t) => t.name).join(", ")}`, tasks);
+    (0, import_ts_necessities2.assert)(task !== void 0, "No tasks to pick from");
+    return task;
+  }
+  unlockIfNecessary() {
+    if (this.abortedWithError !== void 0) throw this.abortedWithError;
+    if (this.taskInfos.size === 0) return;
+    const entries = Array.from(this.taskInfos.entries());
+    if (entries.some(([, i]) => i.resolve === void 0)) {
+      return;
+    }
+    const checkpointEntries = entries.filter(([, i]) => i.resolve !== void 0 && i.resolve !== false);
+    (0, import_ts_necessities2.assert)(checkpointEntries.length > 0, "All tasks are blocked");
+    const info = this.pickTask(checkpointEntries.map(([, i]) => i));
+    this.logger.log(`${info.name} UNBLOCKED from ${entries.map(([, i]) => i.name).join(", ")}`);
+    const { resolve } = info;
+    (0, import_ts_necessities2.assert)(resolve !== void 0 && resolve !== false);
+    info.resolve = void 0;
+    resolve();
+  }
+  async runTasks(specs) {
+    const simulation = this;
+    const tasksAndInfos = specs.map((s) => {
+      const info = { name: s.name, resolve: void 0 };
+      const task = {
+        random(name) {
+          const r = simulation.entropy.random(`${s.name} random number: ${name}`);
+          simulation.logger.log(`${s.name} RANDOM ${name}: ${r}`);
+          return r;
+        },
+        log(...log) {
+          simulation.logger.log(`${s.name}:`, ...log);
+        },
+        error(...log) {
+          simulation.logger.error(`${s.name}:`, ...log);
+        },
+        checkpoint(...log) {
+          simulation.logger.log(`${s.name} CHECKPOINT:`, ...log);
+          (0, import_ts_necessities2.assert)(
+            simulation.taskInfos.has(task),
+            `Task ${s.name} wants to checkpoint, but doesn't exist anymore`
+          );
+          const promise = new Promise((resolve) => {
+            (0, import_ts_necessities2.assert)(info.resolve === void 0 || info.resolve === false);
+            info.resolve = resolve;
+          });
+          simulation.unlockIfNecessary();
+          return promise;
+        },
+        failpoint(...log) {
+          (0, import_ts_necessities2.assert)(
+            simulation.taskInfos.has(task),
+            `Task ${s.name} wants to failpoint, but doesn't exist anymore`
+          );
+          const shouldFail = simulation.failureProbability > 0 && simulation.entropy.random(`${s.name} failpoint: ${log.join(" ")}`) < simulation.failureProbability;
+          if (shouldFail) {
+            simulation.logger.log(`${s.name} FAILING:`, ...log);
+            return Promise.reject(
+              new ApplicationFailure(`Simulated failure at failpoint: ${log.join(" ")}`)
+            );
+          }
+          simulation.logger.log(`${s.name} FAILPOINT:`, ...log);
+          const promise = new Promise((resolve) => {
+            (0, import_ts_necessities2.assert)(
+              info.resolve === void 0 || info.resolve === false,
+              `Task ${s.name} already has a resolve`
+            );
+            info.resolve = resolve;
+          });
+          simulation.unlockIfNecessary();
+          return promise;
+        },
+        blockpoint(...log) {
+          simulation.logger.log(`${s.name} BLOCKPOINT:`, ...log);
+          (0, import_ts_necessities2.assert)(simulation.taskInfos.has(task));
+          (0, import_ts_necessities2.assert)(info.resolve === void 0, `Task ${s.name} already has a resolve`);
+          info.resolve = false;
+          simulation.unlockIfNecessary();
+        },
+        abortSimulation(e) {
+          return simulation.abort(e);
+        }
+      };
+      return [s, task, info];
+    });
+    for (const [, task, info] of tasksAndInfos) {
+      this.taskInfos.set(task, info);
+    }
+    try {
+      const results = await Promise.all(
+        tasksAndInfos.map(([s, task]) => {
+          return task.checkpoint("START").then(() => s.f(task)).catch((e) => this.abort(e)).finally(() => {
+            this.taskInfos.delete(task);
+            this.logger.log(
+              `FINISHED ${s.name}, still left ${Array.from(this.taskInfos.values()).map((i) => i.name).join(", ")}`
+            );
+            this.unlockIfNecessary();
+          });
+        })
+      );
+      return (0, import_neverthrow.ok)(results);
+    } catch (e) {
+      return (0, import_neverthrow.err)((0, import_ts_necessities2.exceptionToError)(e));
+    }
+  }
+};
+
+// mutex.ts
+var import_ts_necessities3 = require("@glideapps/ts-necessities");
+var Mutex = class {
+  /** This is `undefined` iff the mutex is unlocked.  Otherwise it's an array of resolve functions, one for each waiter. */
+  waiters;
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  get isLocked() {
+    return this.waiters !== void 0;
+  }
+  lock(task, reason) {
+    if (this.waiters === void 0) {
+      task.log(`mutex "${this.name}" locked unopposed for "${reason}"`);
+      this.waiters = [];
+      return Promise.resolve();
+    } else {
+      task.blockpoint(`mutex "${this.name}" enqueue for "${reason}", ${this.waiters.length} other waiters`);
+      const p = new Promise((resolve) => {
+        (0, import_ts_necessities3.defined)(this.waiters, "Promise init function did not run inline").push(async () => {
+          await task.checkpoint(
+            `mutex "${this.name}" acquired by waiter for "${reason}", ${(0, import_ts_necessities3.defined)(this.waiters).length} other waiters`
+          );
+          resolve();
+        });
+      });
+      return p;
+    }
+  }
+  unlock(task, reason) {
+    (0, import_ts_necessities3.assert)(this.waiters !== void 0, "Can't unlock a mutex that's not locked");
+    const resolve = this.waiters.shift();
+    if (resolve !== void 0) {
+      task.log(
+        `mutex "${this.name}" unlocked and passed to next waiter for "${reason}", ${this.waiters.length} waiters left`
+      );
+      resolve();
+    } else {
+      task.log(`mutex "${this.name}" unlocked for "${reason}"`);
+      this.waiters = void 0;
+    }
+  }
+};
+
+// condition-variable.ts
+var ConditionVariable = class {
+  waiters = [];
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  wait(task, reason) {
+    task.blockpoint(`condition "${this.name}" wait for "${reason}", ${this.waiters.length} other waiters`);
+    return new Promise((resolve) => {
+      this.waiters.push(async () => {
+        await task.checkpoint(`condition "${this.name}" woken up for "${reason}"`);
+        resolve();
+      });
+    });
+  }
+  notifyAll(task, reason) {
+    task.log(`condition "${this.name}" notifying ${this.waiters.length} for "${reason}"`);
+    for (const resolve of this.waiters) {
+      resolve();
+    }
+    this.waiters.length = 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationFailure,
+  ConditionVariable,
+  Mutex,
+  NoSimulationTask,
+  RecordingEntropySource,
+  ReplayingEntropySource,
+  SimpleEntropySource,
+  SimulationImpl,
+  isApplicationFailure,
+  makeErrorType,
+  noSimulation,
+  sample
+});