fyflow-scheduler 0.1.0

package/dist/node/index.js

@@ -0,0 +1,2380 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// worker:C:\Users\matij\Documents\dev\fyflow-scheduler-public\core\workerWrapper.node.ts
+var workerWrapper_node_exports = {};
+__export(workerWrapper_node_exports, {
+  default: () => workerWrapper_node_default
+});
+var url, workerWrapper_node_default;
+var init_workerWrapper_node = __esm({
+  "worker:C:\\Users\\matij\\Documents\\dev\\fyflow-scheduler-public\\core\\workerWrapper.node.ts"() {
+    url = "data:text/javascript;base64,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";
+    workerWrapper_node_default = new URL(url);
+  }
+});
+
+// core/FyflowScheduler.ts
+var FyflowTask = class {
+  id;
+  workerType;
+  payload;
+  optional;
+  retryPolicy;
+  /** Retry attempts used so far, counted against `retryPolicy.maxRetries`. */
+  attempts = 0;
+  /**
+   * `pending` -> `running` -> `done` | `failed`.
+   *
+   * A non-optional task that fails with no retries left ends in `user_action`,
+   * signalling that something outside the scheduler has to intervene.
+   */
+  state = "pending";
+  result;
+  error;
+  // Error message if task failed
+  resolve;
+  reject;
+  workerGroups;
+  handleRejection;
+  // If true (default), silently handle rejections for fire-and-forget
+  startTime;
+  // Timestamp when task started execution
+  endTime;
+  // Timestamp when task completed
+  /**
+   * Worker-measured execution time in ms (high resolution), set on completion.
+   * Unlike `endTime - startTime` this excludes time spent waiting for a worker
+   * slot. Cleared when a task is requeued or retried.
+   */
+  executionTime;
+  /**
+   * Bucket this task belongs to for keyed resource groups. Read by the default
+   * `keyFrom` of {@link KeyedRateLimitGroup}; a group given its own `keyFrom`
+   * can derive the key from the payload instead.
+   */
+  limitKey;
+  _resourcesPreAllocated;
+  // Flag to track if resources are pre-allocated
+  /**
+   * Keys resolved at dispatch, per keyed group id. Held so release uses the
+   * same bucket acquisition used, even if the payload changed meanwhile.
+   */
+  _resourceKeys;
+  /**
+   * Set while this attempt is being settled, so the same outcome arriving from
+   * both the pool's `task.failed` event and the task promise settles once.
+   * Cleared on every dispatch, so each attempt gets its own settle.
+   */
+  _settling;
+  // Private fields for resource management
+  _scheduler;
+  // Reference to scheduler for descendant tracking
+  /**
+   * @param config.id Unique task id. Reusing an id overwrites the earlier entry.
+   * @param config.workerType Key into the scheduler's `workerPools`. An unknown
+   *   value makes `addTask` throw.
+   * @param config.payload Passed verbatim to the worker's `run()`.
+   * @param config.optional Default `false`. An optional task that fails
+   *   resolves `null` instead of rejecting.
+   * @param config.retryPolicy `{ maxRetries, backoffMs }`. Omitted means no retries.
+   * @param config.workerGroups Resource groups for this task, *in addition* to
+   *   the groups its WorkerManager declares.
+   * @param config.handleRejection Default `true`. Attaches a silent catch so a
+   *   fire-and-forget failure does not surface as an unhandled rejection;
+   *   `task.failed` is still emitted.
+   * @param config.limitKey Bucket for keyed resource groups, e.g. the endpoint
+   *   or tenant this task belongs to. Required when the task belongs to a
+   *   keyed group that has no custom `keyFrom`.
+   */
+  constructor({ id, workerType, payload, optional = false, retryPolicy, workerGroups = [], handleRejection = true, limitKey }) {
+    this.id = id;
+    this.limitKey = limitKey;
+    this.workerType = workerType;
+    this.payload = payload;
+    this.optional = optional;
+    this.retryPolicy = retryPolicy;
+    this.workerGroups = workerGroups;
+    this.handleRejection = handleRejection;
+  }
+  /**
+   * Promise for this task alone, resolving with its result and rejecting if it
+   * fails. Prefer `addTask(task, { createPromise: true })`, which wires this up
+   * for you. Use `onCompleteDescendants()` to also wait for spawned tasks.
+   */
+  onCompletePromise() {
+    return new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+  /**
+   * Wait for this task AND every task spawned from it (children, grandchildren, ...)
+   * to reach a terminal state.
+   *
+   * Descendants come from runtime spawning via `context.spawnTask()` - this is
+   * lineage, not a scheduling dependency, and does not affect dispatch order.
+   *
+   * Resolves with this task's result once the whole workflow has settled. A failed
+   * descendant does not reject - descendant failures surface via `task.failed`
+   * events - but this task failing rejects, matching `onCompletePromise()`.
+   *
+   * Must be called after the task has been added to a scheduler.
+   */
+  onCompleteDescendants() {
+    return new Promise((resolve, reject) => {
+      if (!this._scheduler) {
+        reject(new Error("Task must be added to a scheduler before tracking descendants"));
+        return;
+      }
+      this._scheduler._trackDescendants(this, resolve, reject);
+    });
+  }
+};
+var FyflowScheduler = class _FyflowScheduler extends EventTarget {
+  tasks = /* @__PURE__ */ new Map();
+  readyQueuesByWorker = /* @__PURE__ */ new Map();
+  // Per-worker-type queues for O(1) dispatch
+  blockedQueues = /* @__PURE__ */ new Map();
+  // Grouped by blocking group IDs for faster lookup
+  workerPools;
+  groups;
+  stats = { queued: 0, running: 0, done: 0, failed: 0 };
+  retryTimer = null;
+  // Active onCompleteDescendants() waits, keyed by tracker id so one task can be
+  // awaited more than once. Empty unless onCompleteDescendants() is used.
+  descendantTrackers = /* @__PURE__ */ new Map();
+  nextTrackerId = 0;
+  // Spawn lineage: parent task id -> ids of tasks spawned from it. Populated only
+  // when workers spawn tasks; carries no scheduling meaning.
+  spawnedChildren = /* @__PURE__ */ new Map();
+  // Terminal task ids in completion order, used only when maxCompletedTasks is
+  // set. A Set preserves insertion order, so the oldest entry is its first.
+  completedTaskIds = /* @__PURE__ */ new Set();
+  options;
+  // Track ALL event listeners for cleanup
+  allListeners = /* @__PURE__ */ new Map();
+  constructor(workerPools, groups = {}, options = {}) {
+    super();
+    this.workerPools = workerPools;
+    this.groups = groups;
+    this.options = {
+      periodicRetryIntervalMs: 50,
+      // Default to 50ms - optimal balance of speed and efficiency
+      ...options
+    };
+    for (const workerType of Object.keys(workerPools)) {
+      this.readyQueuesByWorker.set(workerType, []);
+    }
+    this._setupWorkerPoolListeners();
+    this._setupGroupEventListeners();
+  }
+  /** Every resource group a task must acquire: its own plus its pool's. */
+  _groupsForTask(task, pool) {
+    const ids = [.../* @__PURE__ */ new Set([...task.workerGroups || [], ...pool?.groups || []])];
+    return ids.map((id) => ({ id, group: this.groups[id] })).filter((entry) => entry.group);
+  }
+  /**
+   * Blocked queues are per group, and per (group, key) for keyed groups, so a
+   * saturated key never stalls tasks belonging to a different one.
+   */
+  _blockedQueueId(groupId, key) {
+    return key === void 0 ? groupId : `${groupId}\0${key}`;
+  }
+  /**
+   * Resolve the bucket for every keyed group this task belongs to.
+   *
+   * @throws if a keyed group cannot derive a key. A keyless task would
+   *   otherwise silently share a bucket with every other keyless task, or skip
+   *   the limit entirely - both discovered only once something is throttled.
+   */
+  _resolveResourceKeys(task, pool) {
+    const keys = {};
+    for (const { id, group } of this._groupsForTask(task, pool)) {
+      if (!group.keyed) continue;
+      const key = group.keyFor?.(task);
+      if (key === void 0) {
+        throw new Error(
+          `Missing limit key for group "${id}" on task "${task.id}". Set task.limitKey, or give the group a keyFrom that derives one.`
+        );
+      }
+      keys[id] = key;
+    }
+    return keys;
+  }
+  // Any task waiting on a resource group. Blocked tasks are subtracted from
+  // stats.queued when they leave the ready queue, so they are invisible to the
+  // stats alone.
+  _hasBlockedTasks() {
+    for (const queue of this.blockedQueues.values()) {
+      if (queue.length > 0) return true;
+    }
+    return false;
+  }
+  _checkCompletion() {
+    const hasBlockedTasks = this._hasBlockedTasks();
+    if (this.stats.queued === 0 && this.stats.running === 0 && !hasBlockedTasks && this.stats.done > 0) {
+      this._clearPeriodicRetry();
+      this.dispatchEvent(new CustomEvent("scheduler.completed", { detail: this.stats }));
+    } else if (hasBlockedTasks && this.stats.queued === 0 && this.stats.running === 0) {
+      this._schedulePeriodicRetry();
+    } else if (this.stats.queued > 0 && this.stats.running === 0) {
+      this._retryBlockedTasks();
+      this._schedulePeriodicRetry();
+    }
+  }
+  /**
+   * Queue a task and start dispatching.
+   *
+   * Fire-and-forget by default: returns `undefined` unless
+   * `{ createPromise: true }` is passed, in which case it returns a promise
+   * that resolves with the task's result or rejects if it fails.
+   *
+   * @throws if `task.workerType` is not a key in the scheduler's `workerPools`.
+   */
+  addTask(task, options) {
+    const workerQueue = this.readyQueuesByWorker.get(task.workerType);
+    if (!workerQueue) {
+      throw new Error(`Unknown worker type: ${task.workerType}`);
+    }
+    this._resolveResourceKeys(task, this.workerPools[task.workerType]);
+    task._scheduler = this;
+    this.tasks.set(task.id, task);
+    workerQueue.push(task);
+    this.stats.queued++;
+    this._dispatchLoop();
+    if (options?.createPromise) {
+      const promise = task.onCompletePromise();
+      if (task.handleRejection) {
+        promise.catch(() => {
+        });
+      }
+      return promise;
+    }
+  }
+  /**
+   * Queue many tasks with a single dispatch pass - use this for bulk additions
+   * (>1000 tasks) instead of calling `addTask` in a loop, which would run the
+   * dispatch loop once per task.
+   *
+   * Like `addTask`, returns nothing unless `{ createPromise: true }` is passed;
+   * with it, returns one promise per task in the same order:
+   *
+   * ```typescript
+   * const results = await Promise.all(
+   *   scheduler.addTasks(tasks, { createPromise: true }) as Promise<any>[]
+   * );
+   * ```
+   *
+   * @throws if any task's `workerType` is not a key in the scheduler's
+   *   `workerPools`. The batch is validated up front, so a rejected call
+   *   queues nothing at all.
+   */
+  addTasks(tasks, options) {
+    for (const task of tasks) {
+      if (!this.readyQueuesByWorker.has(task.workerType)) {
+        throw new Error(`Unknown worker type: ${task.workerType}`);
+      }
+      this._resolveResourceKeys(task, this.workerPools[task.workerType]);
+    }
+    const promises = [];
+    for (const task of tasks) {
+      task._scheduler = this;
+      this.tasks.set(task.id, task);
+      this.readyQueuesByWorker.get(task.workerType).push(task);
+      this.stats.queued++;
+      if (options?.createPromise) {
+        const promise = task.onCompletePromise();
+        if (task.handleRejection) {
+          promise.catch(() => {
+          });
+        }
+        promises.push(promise);
+      }
+    }
+    this._dispatchLoop();
+    if (options?.createPromise) {
+      return promises;
+    }
+  }
+  // _onParentComplete(parent: FyflowTask) {
+  //   // No dependency tracking - just trigger dispatch loop
+  //   this._dispatchLoop();
+  // }
+  _dispatchLoop() {
+    let tasksProcessed = 0;
+    let keyedSkips = 0;
+    const maxTasksPerLoop = 1e3;
+    for (const [workerType, queue] of this.readyQueuesByWorker) {
+      if (queue.length === 0) continue;
+      const pool = this.workerPools[workerType];
+      if (!pool) continue;
+      while (queue.length > 0 && tasksProcessed < maxTasksPerLoop) {
+        const task = queue[0];
+        const canDispatchResult = this._canDispatchTask(task, pool);
+        if (canDispatchResult === true) {
+          queue.shift();
+          this._dispatchTask(task, pool);
+          tasksProcessed++;
+        } else if (canDispatchResult === "blocked" || canDispatchResult === "blocked-keyed") {
+          queue.shift();
+          this.stats.queued = Math.max(0, this.stats.queued - 1);
+          if (canDispatchResult === "blocked-keyed" && keyedSkips < maxTasksPerLoop) {
+            keyedSkips++;
+            continue;
+          }
+          break;
+        } else {
+          this._schedulePeriodicRetry();
+          break;
+        }
+      }
+    }
+    const hasReadyTasks = Array.from(this.readyQueuesByWorker.values()).some((q) => q.length > 0);
+    const hasBlockedTasks = Array.from(this.blockedQueues.values()).some((q) => q.length > 0);
+    const hasQueuedInStats = this.stats.queued > 0;
+    if (!hasReadyTasks && !hasBlockedTasks && !hasQueuedInStats) {
+      this._clearPeriodicRetry();
+    }
+  }
+  // Helper: Check resource availability and block if needed
+  _checkAndBlockResources(task, pool) {
+    const taskGroupIds = task.workerGroups || [];
+    const workerGroupIds = pool.groups || [];
+    if (taskGroupIds.length === 0 && workerGroupIds.length === 0) {
+      return true;
+    }
+    const entries = this._groupsForTask(task, pool);
+    const keys = task._resourceKeys ?? this._resolveResourceKeys(task, pool);
+    task._resourceKeys = keys;
+    for (const { id, group } of entries) {
+      const key = group.keyed ? keys[id] : void 0;
+      if (!group.canRun(key)) {
+        const blockedOnKey = Boolean(group.keyed);
+        const queueId = this._blockedQueueId(id, key);
+        if (!this.blockedQueues.has(queueId)) {
+          this.blockedQueues.set(queueId, []);
+        }
+        const blockedQueue = this.blockedQueues.get(queueId);
+        if (!blockedQueue.includes(task)) {
+          blockedQueue.push(task);
+        }
+        this._schedulePeriodicRetry();
+        return blockedOnKey ? "blocked-keyed" : "blocked";
+      }
+    }
+    return true;
+  }
+  // NEW: Non-optimistic mode helper methods
+  _canDispatchTask(task, pool) {
+    const availableThreads = pool.threads.filter(
+      (t) => t.canAcceptTask && t.canAcceptTask()
+    ).length;
+    if (availableThreads > 0) {
+      const resourceResult = this._checkAndBlockResources(task, pool);
+      if (resourceResult !== true) {
+        return resourceResult;
+      }
+      return true;
+    }
+    const initializingCount = pool.initializingThreads ? pool.initializingThreads.size : 0;
+    const canCreateThread = pool.threads.length + initializingCount < pool.maxThreads;
+    if (canCreateThread) {
+      const resourceResult = this._checkAndBlockResources(task, pool);
+      if (resourceResult !== true) {
+        return resourceResult;
+      }
+      return true;
+    }
+    return false;
+  }
+  _dispatchTask(task, pool) {
+    const entries = this._groupsForTask(task, pool);
+    const keys = task._resourceKeys ?? this._resolveResourceKeys(task, pool);
+    task._resourceKeys = keys;
+    entries.forEach(({ id, group }) => group.onStart(group.keyed ? keys[id] : void 0));
+    task._resourcesPreAllocated = true;
+    task._settling = false;
+    task.state = "running";
+    task.startTime = Date.now();
+    this.stats.queued = Math.max(0, this.stats.queued - 1);
+    this.stats.running++;
+    pool.enqueueNoQueue(task.id, task.payload).then((result) => {
+      this._onTaskComplete(task, result, pool);
+    }).catch((error) => {
+      if (error.message === "Worker at maximum concurrent task capacity") {
+        task.state = "pending";
+        task.startTime = void 0;
+        task.executionTime = void 0;
+        this.stats.running = Math.max(0, this.stats.running - 1);
+        this.stats.queued++;
+        this._releaseResourcesForTask(task, pool);
+        const workerQueue = this.readyQueuesByWorker.get(task.workerType);
+        if (workerQueue) {
+          workerQueue.push(task);
+        }
+        setTimeout(() => this._dispatchLoop(), 10);
+      } else {
+        this._onTaskFailed(task, error, pool);
+      }
+    });
+  }
+  _releaseResourcesForTask(task, pool) {
+    if (!task._resourcesPreAllocated) return;
+    const entries = this._groupsForTask(task, pool);
+    const keys = task._resourceKeys ?? {};
+    for (const { id, group } of entries) {
+      group.onFinish(group.keyed ? keys[id] : void 0);
+    }
+    task._resourcesPreAllocated = void 0;
+    task._resourceKeys = void 0;
+    for (const { id, group } of entries) {
+      this._retryBlockedTasksForGroup(id, group.keyed ? keys[id] : void 0);
+    }
+  }
+  /**
+   * The one place a task settles.
+   *
+   * An outcome can reach the scheduler twice - as the pool's `task.failed`
+   * event and as the settling of the pool's task promise - and each of those
+   * is the ONLY path in some situation, so neither can be dropped:
+   *
+   * - an ordinary task throw reaches both
+   * - a worker that dies with `requeueFailedTasks: false` reaches only the event
+   * - a worker that cannot be constructed reaches only the promise
+   *
+   * They used to be two near-duplicate implementations, so a single failure
+   * emitted `task.failed` twice, counted `stats.failed` twice, raced the
+   * terminal state between `user_action` and `failed`, and - because only the
+   * promise path released resources - leaked a resource group slot whenever
+   * only the event path ran.
+   */
+  _settleTask(task, pool, outcome) {
+    if (task._settling) return;
+    task._settling = true;
+    this._releaseResourcesForTask(task, pool);
+    if ("requeue" in outcome) {
+      task.state = "pending";
+      task.startTime = void 0;
+      task.executionTime = void 0;
+      task._resourcesPreAllocated = void 0;
+      task._resourceKeys = void 0;
+      this.stats.running = Math.max(0, this.stats.running - 1);
+      this.stats.queued++;
+      const requeueTarget = this.readyQueuesByWorker.get(task.workerType);
+      if (requeueTarget) requeueTarget.push(task);
+      this._dispatchLoop();
+      return;
+    }
+    if (outcome.ok) {
+      task.state = "done";
+      task.endTime = Date.now();
+      task.result = outcome.result;
+      this.stats.running = Math.max(0, this.stats.running - 1);
+      this.stats.done++;
+      task.resolve?.(outcome.result);
+      this.dispatchEvent(new CustomEvent("task.completed", { detail: task }));
+      this._settleDescendantTrackers(task.id);
+      this._recordTerminalTask(task.id);
+      this._checkCompletion();
+      this._dispatchLoop();
+      return;
+    }
+    const error = outcome.error;
+    if (task.attempts < (task.retryPolicy?.maxRetries || 0)) {
+      task.attempts++;
+      task.state = "pending";
+      task.startTime = void 0;
+      task.executionTime = void 0;
+      task._resourcesPreAllocated = void 0;
+      task._resourceKeys = void 0;
+      this.stats.running = Math.max(0, this.stats.running - 1);
+      this.stats.queued++;
+      const workerQueue = this.readyQueuesByWorker.get(task.workerType);
+      if (workerQueue) workerQueue.push(task);
+      setTimeout(() => this._dispatchLoop(), task.retryPolicy?.backoffMs || 0);
+      return;
+    }
+    task.error = error instanceof Error ? error.message : String(error ?? "Task failed");
+    task.endTime = Date.now();
+    this.stats.running = Math.max(0, this.stats.running - 1);
+    this.stats.failed++;
+    if (task.optional) {
+      task.state = "failed";
+      task.resolve?.(null);
+    } else {
+      task.state = "user_action";
+      task.reject?.(error instanceof Error ? error : new Error(task.error));
+    }
+    this.dispatchEvent(new CustomEvent("task.failed", { detail: task }));
+    if (!task.optional) {
+      this.dispatchEvent(new CustomEvent("task.user_action", { detail: task }));
+    }
+    this._settleDescendantTrackers(task.id);
+    this._recordTerminalTask(task.id);
+    this._checkCompletion();
+    this._dispatchLoop();
+  }
+  _onTaskComplete(task, result, pool) {
+    this._settleTask(task, pool, { ok: true, result });
+  }
+  _onTaskFailed(task, error, pool) {
+    this._settleTask(task, pool, { ok: false, error });
+  }
+  _retryBlockedTasks() {
+    const hasReadyTasks = Array.from(this.readyQueuesByWorker.values()).some((q) => q.length > 0);
+    if (hasReadyTasks) {
+      this._dispatchLoop();
+    }
+    for (const [groupId, group] of Object.entries(this.groups)) {
+      if (!group || !group.canRun()) continue;
+      if (group.keyed) {
+        for (const key of this._blockedKeysFor(groupId)) {
+          this._retryBlockedTasksForGroup(groupId, key);
+        }
+      } else {
+        this._retryBlockedTasksForGroup(groupId);
+      }
+    }
+  }
+  /** Keys that currently have tasks blocked on this group. */
+  _blockedKeysFor(groupId) {
+    const prefix = `${groupId}\0`;
+    const keys = [];
+    for (const [queueId, queue] of this.blockedQueues) {
+      if (queue.length > 0 && queueId.startsWith(prefix)) {
+        keys.push(queueId.slice(prefix.length));
+      }
+    }
+    return keys;
+  }
+  _retryBlockedTasksForGroup(groupId, key) {
+    const queueId = this._blockedQueueId(groupId, key);
+    const blockedTasks = this.blockedQueues.get(queueId);
+    if (!blockedTasks || blockedTasks.length === 0) return;
+    const group = this.groups[groupId];
+    if (!group || !group.canRun(key)) return;
+    const tasksToRetry = [];
+    const stillBlocked = [];
+    while (blockedTasks.length > 0 && group.canRun(key)) {
+      const task = blockedTasks.shift();
+      const pool = this.workerPools[task.workerType];
+      if (!pool) continue;
+      const entries = this._groupsForTask(task, pool);
+      const keys = task._resourceKeys ?? {};
+      const runnable = entries.every(
+        ({ id, group: g }) => g.canRun(g.keyed ? keys[id] : void 0)
+      );
+      if (!runnable) {
+        stillBlocked.push(task);
+        continue;
+      }
+      for (const { id, group: g } of entries) {
+        const otherQueueId = this._blockedQueueId(id, g.keyed ? keys[id] : void 0);
+        if (otherQueueId === queueId) continue;
+        const otherQueue = this.blockedQueues.get(otherQueueId);
+        if (otherQueue) {
+          const index = otherQueue.indexOf(task);
+          if (index !== -1) otherQueue.splice(index, 1);
+        }
+      }
+      tasksToRetry.push(task);
+    }
+    if (stillBlocked.length > 0) blockedTasks.unshift(...stillBlocked);
+    if (tasksToRetry.length > 0) {
+      for (const task of tasksToRetry) {
+        const workerQueue = this.readyQueuesByWorker.get(task.workerType);
+        if (workerQueue) {
+          workerQueue.unshift(task);
+          this.stats.queued++;
+        }
+      }
+      this._dispatchLoop();
+    }
+  }
+  _schedulePeriodicRetry() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+    }
+    const hasReadyTasks = Array.from(this.readyQueuesByWorker.values()).some((q) => q.length > 0);
+    const hasBlockedTasks = Array.from(this.blockedQueues.values()).some((queue) => queue.length > 0);
+    if (hasReadyTasks || hasBlockedTasks) {
+      this.retryTimer = setTimeout(() => {
+        this._retryBlockedTasks();
+        this._schedulePeriodicRetry();
+      }, this.options.periodicRetryIntervalMs);
+    }
+  }
+  _clearPeriodicRetry() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  // Helper to track internal listeners for cleanup
+  // Override addEventListener to track ALL listeners for cleanup
+  // TODO: likely unneccesary, verify
+  // override addEventListener(event: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void {
+  //   super.addEventListener(event, listener, options);
+  //   this._trackListener(this, event, listener as Function);
+  // }
+  _addInternalListener(target, event, listener) {
+    this._trackListener(target, event, listener);
+    target.addEventListener(event, listener);
+  }
+  _trackListener(target, event, listener) {
+    if (!this.allListeners.has(target)) {
+      this.allListeners.set(target, []);
+    }
+    this.allListeners.get(target).push({ event, listener });
+  }
+  // Remove all event listeners (both internal and external)
+  _removeAllListeners() {
+    for (const [target, listeners] of this.allListeners) {
+      for (const { event, listener } of listeners) {
+        try {
+          target.removeEventListener(event, listener);
+        } catch {
+        }
+      }
+    }
+    this.allListeners.clear();
+  }
+  _setupGroupEventListeners() {
+  }
+  _setupWorkerPoolListeners() {
+    Object.values(this.workerPools).forEach((pool) => {
+      const taskStartedListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (task) {
+          this.dispatchEvent(new CustomEvent("task.running", { detail: task }));
+        }
+      };
+      this._addInternalListener(pool, "task.started", taskStartedListener);
+      const taskProgressListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (task) {
+          const eventDetail = {
+            ...task,
+            progress: e.detail.progress,
+            message: e.detail.message,
+            details: e.detail.details,
+            workerId: e.detail.workerId,
+            workerType: e.detail.workerType,
+            timestamp: e.detail.timestamp
+          };
+          this.dispatchEvent(new CustomEvent("task.progress", { detail: eventDetail }));
+        }
+      };
+      this._addInternalListener(pool, "task.progress", taskProgressListener);
+      const taskSpawnListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (task) {
+          const eventDetail = {
+            parentTask: task,
+            spawnConfig: e.detail.spawnConfig,
+            workerId: e.detail.workerId,
+            workerType: e.detail.workerType,
+            timestamp: e.detail.timestamp
+          };
+          this.dispatchEvent(new CustomEvent("task.spawn_request", { detail: eventDetail }));
+          const spawnConfig = e.detail.spawnConfig;
+          const childTask = new FyflowTask({
+            id: spawnConfig.id,
+            workerType: spawnConfig.workerType,
+            payload: spawnConfig.payload,
+            optional: spawnConfig.optional || false,
+            retryPolicy: spawnConfig.retryPolicy,
+            workerGroups: spawnConfig.workerGroups || []
+          });
+          try {
+            this.addTask(childTask);
+          } catch (error) {
+            this.dispatchEvent(new CustomEvent("task.spawn_failed", {
+              detail: {
+                parentTask: task,
+                spawnConfig,
+                error,
+                workerId: e.detail.workerId,
+                workerType: e.detail.workerType,
+                timestamp: Date.now()
+              }
+            }));
+            return;
+          }
+          this._recordSpawn(task.id, childTask.id);
+          this._addSpawnedTaskToTrackers(task.id, childTask);
+        }
+      };
+      this._addInternalListener(pool, "task.spawn_request", taskSpawnListener);
+      const taskRequeueListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (!task || task.state !== "running") return;
+        this._settleTask(task, this.workerPools[task.workerType], { requeue: true });
+      };
+      this._addInternalListener(pool, "task.requeue_required", taskRequeueListener);
+      const taskCompletedListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (task) {
+          if (e.detail.executionTime !== void 0) {
+            task.executionTime = e.detail.executionTime;
+          }
+        }
+      };
+      this._addInternalListener(pool, "task.completed", taskCompletedListener);
+      const taskFailedListener = (e) => {
+        const task = this.tasks.get(e.detail.taskId);
+        if (!task) return;
+        this._settleTask(task, pool, { ok: false, error: e.detail.error });
+      };
+      this._addInternalListener(pool, "task.failed", taskFailedListener);
+    });
+  }
+  // --- Descendant tracking -------------------------------------------------
+  // Descendants are tasks created at runtime via context.spawnTask(). This is
+  // lineage only: it never influences dispatch order or readiness.
+  static TERMINAL_STATES = /* @__PURE__ */ new Set(["done", "failed", "user_action"]);
+  _isTerminal(state) {
+    return _FyflowScheduler.TERMINAL_STATES.has(state);
+  }
+  // Record that childId was spawned from parentId
+  _recordSpawn(parentId, childId) {
+    let children = this.spawnedChildren.get(parentId);
+    if (!children) {
+      children = /* @__PURE__ */ new Set();
+      this.spawnedChildren.set(parentId, children);
+    }
+    children.add(childId);
+  }
+  _trackDescendants(task, resolve, reject) {
+    const pendingDescendants = /* @__PURE__ */ new Set();
+    this._collectPendingDescendants(task.id, pendingDescendants, /* @__PURE__ */ new Set());
+    if (pendingDescendants.size === 0) {
+      this._settleTracker({ rootId: task.id, rootTask: task, resolve, reject, pendingDescendants });
+      return;
+    }
+    this.descendantTrackers.set(this.nextTrackerId++, {
+      rootId: task.id,
+      rootTask: task,
+      resolve,
+      reject,
+      pendingDescendants
+    });
+  }
+  _collectPendingDescendants(taskId, pending, visited) {
+    if (visited.has(taskId)) return;
+    visited.add(taskId);
+    const task = this.tasks.get(taskId);
+    if (task && !this._isTerminal(task.state)) {
+      pending.add(taskId);
+    }
+    const children = this.spawnedChildren.get(taskId);
+    if (children) {
+      for (const childId of children) {
+        this._collectPendingDescendants(childId, pending, visited);
+      }
+    }
+  }
+  // Called when a task reaches a terminal state (done, failed or user_action).
+  // Does nothing unless maxCompletedTasks is configured.
+  _recordTerminalTask(taskId) {
+    const limit = this.options.maxCompletedTasks;
+    if (limit === void 0) return;
+    this.completedTaskIds.add(taskId);
+    while (this.completedTaskIds.size > limit) {
+      const oldest = this.completedTaskIds.values().next().value;
+      if (oldest === void 0) break;
+      this.completedTaskIds.delete(oldest);
+      this.tasks.delete(oldest);
+      this.spawnedChildren.delete(oldest);
+    }
+  }
+  // Called when a task reaches a terminal state (done, failed or user_action)
+  _settleDescendantTrackers(taskId) {
+    if (this.descendantTrackers.size === 0) return;
+    for (const [trackerId, tracker] of this.descendantTrackers) {
+      if (!tracker.pendingDescendants.delete(taskId)) continue;
+      if (tracker.pendingDescendants.size > 0) continue;
+      this.descendantTrackers.delete(trackerId);
+      this._settleTracker(tracker);
+    }
+  }
+  _settleTracker(tracker) {
+    const rootTask = tracker.rootTask;
+    if (rootTask.state === "failed" || rootTask.state === "user_action") {
+      tracker.reject(new Error(rootTask.error || `Task ${tracker.rootId} failed`));
+      return;
+    }
+    tracker.resolve(rootTask.result ?? null);
+  }
+  _addSpawnedTaskToTrackers(parentTaskId, spawnedTask) {
+    if (this.descendantTrackers.size === 0) return;
+    for (const tracker of this.descendantTrackers.values()) {
+      if (tracker.rootId === parentTaskId || tracker.pendingDescendants.has(parentTaskId)) {
+        if (!this._isTerminal(spawnedTask.state)) {
+          tracker.pendingDescendants.add(spawnedTask.id);
+        }
+      }
+    }
+  }
+  // Shutdown the scheduler and cleanup all resources
+  /**
+   * Get current metrics for all resource groups
+   *
+   * Returns real-time utilization and availability for monitoring
+   *
+   * @returns Record of group ID to metrics
+   */
+  getResourceMetrics() {
+    const metrics = {};
+    for (const [id, group] of Object.entries(this.groups)) {
+      if (group && typeof group.getMetrics === "function") {
+        metrics[id] = group.getMetrics();
+      }
+    }
+    return metrics;
+  }
+  /**
+   * Get lifetime stats for resource groups
+   *
+   * Returns aggregated statistics for strict groups (acquisition times, rejections, etc.)
+   *
+   * @returns Record of group ID to stats (only strict groups provide stats)
+   */
+  getResourceStats() {
+    const stats = {};
+    for (const [id, group] of Object.entries(this.groups)) {
+      if (group && typeof group.getStats === "function") {
+        stats[id] = group.getStats();
+      }
+    }
+    return stats;
+  }
+  /**
+   * Wait for running tasks, then terminate every worker pool, drop all
+   * listeners and clear internal state.
+   *
+   * Always call this when finished - live workers and the periodic retry timer
+   * will otherwise keep the process alive. Pending `onCompleteDescendants()`
+   * waits reject.
+   */
+  async shutdown() {
+    this._clearPeriodicRetry();
+    this._removeAllListeners();
+    const drainDeadline = Date.now() + 5e3;
+    while (this.stats.running > 0 && Date.now() < drainDeadline) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    if (this.stats.running > 0) {
+      console.warn(
+        `\u26A0\uFE0F Shutdown proceeding with ${this.stats.running} task(s) still marked running - they were dispatched to a pool that could not complete them`
+      );
+    }
+    this.readyQueuesByWorker.forEach((q) => q.length = 0);
+    this.blockedQueues.clear();
+    const workerManagerPromises = Object.values(this.workerPools).map(async (pool) => {
+      if (pool && typeof pool.shutdown === "function") {
+        try {
+          await pool.shutdown();
+        } catch (error) {
+          console.warn(`\u26A0\uFE0F Error shutting down worker pool:`, error);
+        }
+      }
+    });
+    let i = 0;
+    for (const workerManagerPromise of workerManagerPromises) {
+      await workerManagerPromise;
+      i++;
+    }
+    for (const tracker of this.descendantTrackers.values()) {
+      tracker.reject(new Error("Scheduler shut down before all descendants completed"));
+    }
+    this.tasks.clear();
+    this.descendantTrackers.clear();
+    this.spawnedChildren.clear();
+    this.completedTaskIds.clear();
+    this.stats = { queued: 0, running: 0, done: 0, failed: 0 };
+  }
+};
+
+// groups/concurrentLimitGroup.ts
+var ConcurrentLimitGroup = class extends EventTarget {
+  id;
+  type = "concurrent";
+  limit;
+  running = 0;
+  stats = {
+    totalAcquired: 0,
+    totalReleased: 0
+  };
+  constructor(limit, id) {
+    super();
+    this.limit = limit;
+    this.id = id || `concurrent-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  canRun() {
+    return this.running < this.limit;
+  }
+  getMetrics() {
+    return {
+      limit: this.limit,
+      running: this.running,
+      available: Math.max(0, this.limit - this.running),
+      utilization: this.running / this.limit
+    };
+  }
+  getStats() {
+    return {
+      totalAcquired: this.stats.totalAcquired,
+      totalReleased: this.stats.totalReleased
+    };
+  }
+  onStart() {
+    this.running++;
+    this.stats.totalAcquired++;
+    if (this.running >= this.limit) {
+      this.dispatchEvent(new CustomEvent("capacity-exhausted", {
+        detail: { running: this.running, limit: this.limit, groupId: this.id }
+      }));
+    }
+  }
+  onFinish() {
+    const wasAtLimit = this.running >= this.limit;
+    this.running = Math.max(0, this.running - 1);
+    this.stats.totalReleased++;
+    if (wasAtLimit && this.canRun()) {
+      this.dispatchEvent(new CustomEvent("slot-released", {
+        detail: {
+          groupType: "concurrent-limit",
+          groupId: this.id,
+          running: this.running,
+          limit: this.limit,
+          available: this.limit - this.running
+        }
+      }));
+    }
+  }
+};
+
+// groups/rateLimitGroup.ts
+var RateLimitGroup = class extends EventTarget {
+  id;
+  type = "rate-limit";
+  windows;
+  requestCounts = /* @__PURE__ */ new Map();
+  // windowIndex -> [timestamp, count][]
+  runningStartTimes = [];
+  // Track start times of currently running tasks
+  running = 0;
+  stats = {
+    totalAcquired: 0,
+    totalReleased: 0
+  };
+  constructor(windows, id) {
+    super();
+    this.windows = windows;
+    this.id = id || `ratelimit-${Math.random().toString(36).substr(2, 9)}`;
+    this.windows.forEach((_, index) => {
+      this.requestCounts.set(index.toString(), []);
+    });
+  }
+  /**
+   * Check if a new request can be accepted based on all rate limit windows
+   */
+  canRun() {
+    const now = Date.now();
+    for (let i = 0; i < this.windows.length; i++) {
+      const window = this.windows[i];
+      const windowKey = i.toString();
+      const requests = this.requestCounts.get(windowKey);
+      const windowStart = now - window.windowMs;
+      const validCompletedRequests = requests.filter(([timestamp]) => timestamp >= windowStart);
+      this.requestCounts.set(windowKey, validCompletedRequests);
+      const validRunningRequests = this.runningStartTimes.filter((startTime) => startTime >= windowStart);
+      const totalRequestsInWindow = validCompletedRequests.length + validRunningRequests.length;
+      if (totalRequestsInWindow >= window.limit) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getMetrics() {
+    const mostRestrictiveWindow = this.windows.reduce((min, w) => w.limit < min.limit ? w : min, this.windows[0]);
+    return {
+      limit: mostRestrictiveWindow.limit,
+      running: this.running,
+      available: Math.max(0, mostRestrictiveWindow.limit - this.running),
+      utilization: this.running / mostRestrictiveWindow.limit
+    };
+  }
+  getStats() {
+    return {
+      totalAcquired: this.stats.totalAcquired,
+      totalReleased: this.stats.totalReleased
+    };
+  }
+  /**
+   * Called when a task starts - tracks running count and reserves slot in rate limit
+   */
+  onStart() {
+    const now = Date.now();
+    this.running++;
+    this.runningStartTimes.push(now);
+    this.stats.totalAcquired++;
+  }
+  /**
+   * Called when a task finishes - records completion in rate limit windows and removes from running
+   */
+  onFinish() {
+    const now = Date.now();
+    this.running = Math.max(0, this.running - 1);
+    this.stats.totalReleased++;
+    if (this.runningStartTimes.length > 0) {
+      this.runningStartTimes.shift();
+    }
+    this.windows.forEach((_, index) => {
+      const windowKey = index.toString();
+      const requests = this.requestCounts.get(windowKey);
+      requests.push([now, 1]);
+    });
+  }
+  /**
+   * Get current status for monitoring
+   */
+  getStatus() {
+    const now = Date.now();
+    const windowStatus = this.windows.map((window, index) => {
+      const windowKey = index.toString();
+      const requests = this.requestCounts.get(windowKey);
+      const windowStart = now - window.windowMs;
+      const completedInWindow = requests.filter(([timestamp]) => timestamp >= windowStart).length;
+      const runningInWindow = this.runningStartTimes.filter((startTime) => startTime >= windowStart).length;
+      const currentCount = completedInWindow + runningInWindow;
+      return {
+        limit: window.limit,
+        windowMs: window.windowMs,
+        current: currentCount,
+        completed: completedInWindow,
+        running: runningInWindow,
+        remaining: Math.max(0, window.limit - currentCount),
+        resetTime: windowStart + window.windowMs
+      };
+    });
+    return {
+      running: this.running,
+      windows: windowStatus,
+      canAcceptNew: this.canRun()
+    };
+  }
+  /**
+   * Clear all rate limit history (useful for testing or reset)
+   */
+  reset() {
+    this.requestCounts.clear();
+    this.windows.forEach((_, index) => {
+      this.requestCounts.set(index.toString(), []);
+    });
+    this.runningStartTimes = [];
+    this.running = 0;
+  }
+  /**
+   * Helper to create common rate limit configurations
+   */
+  static createWindows(configs) {
+    return configs.map((config) => ({
+      limit: config.limit,
+      windowMs: config.seconds * 1e3
+    }));
+  }
+};
+
+// groups/keyedRateLimitGroup.ts
+var KeyedRateLimitGroup = class extends EventTarget {
+  id;
+  type = "keyed-rate-limit";
+  keyed = true;
+  windows;
+  keyFrom;
+  idleKeyTtlMs;
+  keys = /* @__PURE__ */ new Map();
+  stats = {
+    totalAcquired: 0,
+    totalReleased: 0
+  };
+  constructor(windows, options = {}) {
+    super();
+    if (!windows.length) throw new Error("KeyedRateLimitGroup requires at least one window");
+    this.windows = windows;
+    this.id = options.id || `keyed-ratelimit-${Math.random().toString(36).substr(2, 9)}`;
+    this.keyFrom = options.keyFrom ?? ((task) => task.limitKey);
+    this.idleKeyTtlMs = options.idleKeyTtlMs ?? Math.max(...windows.map((w) => w.windowMs)) * 2;
+  }
+  /** Bucket this task belongs to. The scheduler throws if this returns nothing. */
+  keyFor(task) {
+    const key = this.keyFrom(task);
+    return key === void 0 || key === null || key === "" ? void 0 : String(key);
+  }
+  /**
+   * Whether one more task may start.
+   *
+   * With a key, checks that key's bucket. Without one - which is how the
+   * scheduler pre-filters before walking blocked queues - reports whether any
+   * known key has capacity, treating an unknown key as free.
+   */
+  canRun(key) {
+    this._evictIdleKeys();
+    if (key === void 0) {
+      if (this.keys.size === 0) return true;
+      for (const k of this.keys.keys()) {
+        if (this._keyCanRun(k)) return true;
+      }
+      return false;
+    }
+    return this._keyCanRun(key);
+  }
+  onStart(key) {
+    const state = this._stateFor(key ?? "");
+    const now = Date.now();
+    state.running++;
+    state.runningStartTimes.push(now);
+    state.lastActivity = now;
+    this.stats.totalAcquired++;
+    if (!this._keyCanRun(key ?? "")) {
+      this.dispatchEvent(new CustomEvent("capacity-exhausted", {
+        detail: { groupId: this.id, key: key ?? "" }
+      }));
+    }
+  }
+  onFinish(key) {
+    const resolved = key ?? "";
+    const state = this.keys.get(resolved);
+    if (!state) return;
+    const now = Date.now();
+    state.running = Math.max(0, state.running - 1);
+    state.lastActivity = now;
+    this.stats.totalReleased++;
+    if (state.runningStartTimes.length > 0) state.runningStartTimes.shift();
+    this.windows.forEach((_, index) => state.completed[index].push(now));
+    this.dispatchEvent(new CustomEvent("slot-released", {
+      detail: { groupId: this.id, key: resolved }
+    }));
+  }
+  /**
+   * Aggregate view across keys. `limit` is the per-key limit of the most
+   * restrictive window, `running` is summed over every key. Use
+   * {@link KeyedRateLimitGroup.getKeyMetrics} for one bucket.
+   */
+  getMetrics() {
+    this._evictIdleKeys();
+    const limit = this._tightestLimit();
+    let running = 0;
+    for (const state of this.keys.values()) running += state.running;
+    const capacity = limit * Math.max(1, this.keys.size);
+    return {
+      limit,
+      running,
+      available: Math.max(0, capacity - running),
+      utilization: capacity > 0 ? running / capacity : 0,
+      activeKeys: this.keys.size
+    };
+  }
+  /** Per-bucket view. Returns zeroes for a key that has not been used. */
+  getKeyMetrics(key) {
+    const limit = this._tightestLimit();
+    const state = this.keys.get(key);
+    const running = state?.running ?? 0;
+    return {
+      limit,
+      running,
+      available: Math.max(0, limit - running),
+      utilization: limit > 0 ? running / limit : 0
+    };
+  }
+  /** Keys currently holding state, busiest first. */
+  getActiveKeys() {
+    this._evictIdleKeys();
+    return [...this.keys.entries()].sort((a, b) => b[1].running - a[1].running).map(([key]) => key);
+  }
+  getStats() {
+    return {
+      totalAcquired: this.stats.totalAcquired,
+      totalReleased: this.stats.totalReleased
+    };
+  }
+  _tightestLimit() {
+    return this.windows.reduce((min, w) => Math.min(min, w.limit), this.windows[0].limit);
+  }
+  _stateFor(key) {
+    let state = this.keys.get(key);
+    if (!state) {
+      state = {
+        completed: this.windows.map(() => []),
+        runningStartTimes: [],
+        running: 0,
+        lastActivity: Date.now()
+      };
+      this.keys.set(key, state);
+    }
+    return state;
+  }
+  _keyCanRun(key) {
+    const state = this.keys.get(key);
+    if (!state) return true;
+    const now = Date.now();
+    for (let i = 0; i < this.windows.length; i++) {
+      const window = this.windows[i];
+      const windowStart = now - window.windowMs;
+      const completed = state.completed[i].filter((ts) => ts >= windowStart);
+      state.completed[i] = completed;
+      const running = state.runningStartTimes.filter((ts) => ts >= windowStart).length;
+      if (completed.length + running >= window.limit) return false;
+    }
+    return true;
+  }
+  /**
+   * Drop keys that hold no running tasks and have been quiet longer than
+   * `idleKeyTtlMs`. Their windows can no longer constrain anything, so the state
+   * is pure memory. Swept lazily rather than on a timer, so an idle group costs
+   * nothing.
+   */
+  _evictIdleKeys() {
+    if (this.keys.size === 0) return;
+    const cutoff = Date.now() - this.idleKeyTtlMs;
+    for (const [key, state] of this.keys) {
+      if (state.running === 0 && state.lastActivity < cutoff) {
+        this.keys.delete(key);
+      }
+    }
+  }
+};
+
+// core/threadWrapper.ts
+import { Worker } from "node:worker_threads";
+
+// core/workerWrapperUrl.bundled.ts
+var url2;
+async function getWorkerUrl() {
+  if (url2) return url2;
+  url2 = (await Promise.resolve().then(() => (init_workerWrapper_node(), workerWrapper_node_exports))).default;
+  return url2;
+}
+
+// core/workerInterface.ts
+var WorkerTerminationError = class extends Error {
+  metadata;
+  constructor(message, metadata = {}) {
+    super(message);
+    this.name = "WorkerTerminationError";
+    this.metadata = metadata;
+  }
+};
+var BaseWorker = class {
+  config;
+  workerContext;
+  constructor(config = {}, workerContext) {
+    this.config = config;
+    this.workerContext = workerContext;
+  }
+};
+
+// core/threadWrapper.ts
+var ThreadWrapper = class extends EventTarget {
+  worker = null;
+  runningTasks = 0;
+  maxConcurrentTasks;
+  idleTimeout;
+  callbacks = /* @__PURE__ */ new Map();
+  taskStartTimes = /* @__PURE__ */ new Map();
+  // Track task execution start times
+  runningTaskData = /* @__PURE__ */ new Map();
+  // Track task data for requeuing
+  lastActivityTime = Date.now();
+  config;
+  id;
+  initialized = false;
+  originalScriptUrl;
+  initializing = false;
+  // Internal task queue to prevent worker message queue flooding
+  taskQueue = [];
+  // WorkerInstanceState implementation
+  state = "initializing";
+  lastError;
+  // Stats for WorkerStatus
+  tasksCompleted = 0;
+  errorCount = 0;
+  createdAt = Date.now();
+  initStartTime = 0;
+  teardownStartTime = 0;
+  // Pending termination request for post-task handling
+  pendingTerminationRequest = null;
+  //DENO SPECIFIC USE OF WORKER, node uses worker_threads
+  constructor(scriptUrl, idleTimeout = 5e3, maxConcurrentTasks = 1, config = {}) {
+    super();
+    this.originalScriptUrl = (scriptUrl || "").toString();
+    this.idleTimeout = idleTimeout;
+    this.maxConcurrentTasks = maxConcurrentTasks;
+    this.config = config;
+    this.id = `thread-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  canAcceptTask() {
+    const totalTasks = this.runningTasks + this.taskQueue.length;
+    return totalTasks < this.maxConcurrentTasks && !this.initializing && this.state !== "failed" && this.state !== "terminated";
+  }
+  // WorkerInstanceExtensions implementation
+  getRunningTaskIds() {
+    const runningTaskIds = Array.from(this.callbacks.keys());
+    const queuedTaskIds = this.taskQueue.map((task) => task.taskId);
+    return [...runningTaskIds, ...queuedTaskIds];
+  }
+  getRunningTasks() {
+    const runningTasks = Array.from(this.runningTaskData.values());
+    const queuedTasks = this.taskQueue.map((task) => ({ id: task.taskId, payload: task.payload }));
+    return [...runningTasks, ...queuedTasks];
+  }
+  // terminateWithError implementation - throws error for clean task completion
+  createTerminateWithError() {
+    return (error, metadata = {}) => {
+      this.pendingTerminationRequest = {
+        error,
+        metadata: {
+          failureType: "runtime",
+          canRestart: metadata.canRestart,
+          restartDelay: metadata.restartDelay,
+          ...metadata
+        },
+        timestamp: Date.now()
+      };
+      throw new WorkerTerminationError(error.message, metadata);
+    };
+  }
+  // Handle termination request after task completion
+  _handleTerminationRequest(metadata) {
+    this.state = "failed";
+    this.lastError = {
+      timestamp: Date.now(),
+      message: "Worker termination requested",
+      metadata
+    };
+    this.errorCount++;
+    this.dispatchEvent(new CustomEvent("worker.failed", {
+      detail: {
+        workerId: this.id,
+        error: new Error("Worker termination requested"),
+        metadata: {
+          failureType: "self_termination",
+          ...metadata
+        },
+        timestamp: Date.now()
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("worker.termination_requested", {
+      detail: {
+        workerId: this.id,
+        metadata,
+        timestamp: Date.now()
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("worker.self_terminated", {
+      detail: {
+        workerId: this.id,
+        metadata,
+        timestamp: Date.now()
+      }
+    }));
+  }
+  // Set up detection for unexpected worker process exits
+  _setupUnexpectedExitDetection() {
+    if (!this.worker) return;
+    this.worker.onerror = (error) => {
+      this._handleUnexpectedExit("error", error);
+    };
+    if ("onclose" in this.worker) {
+      this.worker.onclose = () => {
+        this._handleUnexpectedExit("close", new Error("Worker process closed unexpectedly"));
+      };
+    }
+    this.worker.onmessageerror = (error) => {
+      this._handleUnexpectedExit("messageerror", error);
+    };
+  }
+  // Handle unexpected worker exit/error
+  _handleUnexpectedExit(type, error) {
+    if (this.state === "terminated" || this.state === "failed") {
+      return;
+    }
+    this.state = "failed";
+    this.lastError = {
+      timestamp: Date.now(),
+      message: `Worker ${type}: ${error.message || error}`,
+      metadata: { failureType: "unexpected_exit", exitType: type }
+    };
+    this.errorCount++;
+    this.dispatchEvent(new CustomEvent("worker.failed", {
+      detail: {
+        workerId: this.id,
+        error: new Error(`Worker ${type}: ${error.message || error}`),
+        metadata: {
+          failureType: "unexpected_exit",
+          exitType: type,
+          canRestart: true,
+          // Unexpected exits can typically be restarted
+          restartDelay: 1e3
+        },
+        timestamp: Date.now()
+      }
+    }));
+    this.worker = null;
+    this.initialized = false;
+    this.runningTasks = 0;
+    this.callbacks.clear();
+    this.taskStartTimes.clear();
+    this.runningTaskData.clear();
+  }
+  // Create BaseWorkerContext for worker constructor
+  createBaseWorkerContext() {
+    return {
+      workerId: this.id,
+      terminateWithError: this.createTerminateWithError()
+    };
+  }
+  get idle() {
+    return this.runningTasks === 0 && this.taskQueue.length === 0;
+  }
+  updateActivity() {
+    this.lastActivityTime = Date.now();
+  }
+  async _ensureInitialized() {
+    if (this.initialized) return;
+    this.initializing = true;
+    const workerWrapperURL = await getWorkerUrl();
+    this.worker = new Worker(workerWrapperURL, { type: "module" });
+    this._setupUnexpectedExitDetection();
+    this.worker.onmessage = (e) => {
+      const message = e.data ? e.data : e;
+      const { type, taskId, data } = message;
+      switch (type) {
+        case "init":
+          this.initialized = true;
+          this.dispatchEvent(new CustomEvent("worker.initialization.completed", {
+            detail: {
+              workerId: this.id,
+              workerType: "thread",
+              timestamp: Date.now(),
+              duration: this.initStartTime ? performance.now() - this.initStartTime : 0
+            }
+          }));
+          return;
+        // Setup runs inside the worker thread, which reports its timing back so
+        // threaded workers emit the same setup events inline workers do
+        case "setup_started":
+          this.dispatchEvent(new CustomEvent("worker.setup.started", {
+            detail: { workerId: this.id, workerType: "thread", timestamp: Date.now() }
+          }));
+          return;
+        case "setup_completed":
+          this.dispatchEvent(new CustomEvent("worker.setup.completed", {
+            detail: {
+              workerId: this.id,
+              workerType: "thread",
+              timestamp: Date.now(),
+              duration: data?.duration ?? 0
+            }
+          }));
+          return;
+        case "teardown":
+          this.dispatchEvent(new CustomEvent("worker.teardown.completed", {
+            detail: {
+              workerId: this.id,
+              workerType: "thread",
+              timestamp: Date.now(),
+              duration: this.teardownStartTime ? performance.now() - this.teardownStartTime : 0
+            }
+          }));
+          return;
+        case "progress":
+          if (taskId) {
+            this.dispatchEvent(new CustomEvent("task.progress", {
+              detail: {
+                taskId,
+                workerId: this.id,
+                workerType: "thread",
+                progress: data.progress,
+                message: data.message,
+                details: data.details,
+                timestamp: Date.now()
+              }
+            }));
+          }
+          return;
+        case "spawn_task":
+          if (taskId) {
+            this.dispatchEvent(new CustomEvent("task.spawn_request", {
+              detail: {
+                taskId,
+                workerId: this.id,
+                workerType: "thread",
+                spawnConfig: data,
+                timestamp: Date.now()
+              }
+            }));
+          }
+          return;
+        case "result":
+        case "error": {
+          if (data.isWorkerTerminationRequest) {
+            this._handleTerminationRequest(data.metadata);
+            if (taskId !== "worker_termination_request") {
+              const cb2 = this.callbacks.get(taskId);
+              if (cb2) {
+                this.callbacks.delete(taskId);
+                cb2.reject(new Error(data.message));
+              }
+            }
+            return;
+          }
+          if (taskId === "init") {
+            this.initializing = false;
+            const initError = new Error(data?.message || String(data));
+            this.dispatchEvent(new CustomEvent("worker.initialization.failed", {
+              detail: {
+                workerId: this.id,
+                workerType: "thread",
+                timestamp: Date.now(),
+                error: initError
+              }
+            }));
+            this.dispatchEvent(new CustomEvent("worker.failed", {
+              detail: {
+                workerId: this.id,
+                error: initError,
+                metadata: { failureType: "initialization", stage: "constructor" },
+                timestamp: Date.now()
+              }
+            }));
+            return;
+          }
+          const cb = this.callbacks.get(taskId);
+          if (!cb) return;
+          const startTime = this.taskStartTimes.get(taskId);
+          const executionTime = startTime ? performance.now() - startTime : 0;
+          this.callbacks.delete(taskId);
+          this.taskStartTimes.delete(taskId);
+          this.runningTaskData.delete(taskId);
+          this.runningTasks--;
+          this.tasksCompleted++;
+          if (this.state !== "failed" && this.state !== "terminated") {
+            this.state = this.runningTasks > 0 ? "busy" : "healthy";
+          }
+          if (type === "error") {
+            this.dispatchEvent(new CustomEvent("task.failed", {
+              detail: { taskId, workerId: this.id, workerType: "thread", error: data, timestamp: Date.now(), executionTime }
+            }));
+            cb.reject(new Error(data.message || data));
+          } else {
+            this.dispatchEvent(new CustomEvent("task.completed", {
+              detail: { taskId, workerId: this.id, workerType: "thread", result: data, timestamp: Date.now(), executionTime }
+            }));
+            cb.resolve(data);
+          }
+          this._processTaskQueue();
+          this.updateActivity();
+          return;
+        }
+        default:
+          console.warn(`Unknown message type from worker: ${type}`);
+      }
+    };
+    if ("on" in this.worker) {
+      this.worker.on("message", (message) => {
+        this?.worker?.onmessage?.({ data: message });
+      });
+    }
+    this.initStartTime = performance.now();
+    this.dispatchEvent(new CustomEvent("worker.initialization.started", {
+      detail: { workerId: this.id, workerType: "thread", timestamp: Date.now() }
+    }));
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.initializing = false;
+        this.removeEventListener("worker.initialization.completed", onInit);
+        const error = new Error("Worker initialization timeout");
+        this.dispatchEvent(new CustomEvent("worker.initialization.failed", {
+          detail: { workerId: this.id, workerType: "thread", timestamp: Date.now(), error }
+        }));
+        reject(error);
+      }, 3e4);
+      const onInit = () => {
+        clearTimeout(timeout);
+        this.initializing = false;
+        this.removeEventListener("worker.initialization.completed", onInit);
+        this.removeEventListener("worker.initialization.failed", onInitFailed);
+        resolve();
+      };
+      const onInitFailed = (e) => {
+        clearTimeout(timeout);
+        this.initializing = false;
+        this.removeEventListener("worker.initialization.completed", onInit);
+        this.removeEventListener("worker.initialization.failed", onInitFailed);
+        reject(e.detail?.error ?? new Error("Worker initialization failed"));
+      };
+      this.addEventListener("worker.initialization.completed", onInit);
+      this.addEventListener("worker.initialization.failed", onInitFailed);
+      const absoluteWorkerUrl = this.originalScriptUrl.startsWith("http") || this.originalScriptUrl.startsWith("file:") ? this.originalScriptUrl : new URL(this.originalScriptUrl, import.meta.url).href;
+      this.worker?.postMessage({
+        taskId: "init",
+        action: "init",
+        config: this.config,
+        workerUrl: absoluteWorkerUrl,
+        workerId: this.id
+      });
+    });
+  }
+  async runTask(taskId, payload) {
+    if (!this.canAcceptTask()) {
+      throw new Error("Worker at maximum concurrent task capacity");
+    }
+    return new Promise((resolve, reject) => {
+      this.taskQueue.push({ taskId, payload, resolve, reject });
+      this._ensureInitialized().then(() => {
+        this.updateActivity();
+        this._processTaskQueue();
+      }).catch((error) => {
+        const index = this.taskQueue.findIndex((t) => t.taskId === taskId);
+        if (index !== -1) this.taskQueue.splice(index, 1);
+        reject(error);
+      });
+    });
+  }
+  _processTaskQueue() {
+    while (this.taskQueue.length > 0 && this.runningTasks < this.maxConcurrentTasks && this.initialized) {
+      const task = this.taskQueue.shift();
+      this.runningTasks++;
+      this.dispatchEvent(new CustomEvent("task.started", {
+        detail: { taskId: task.taskId, workerId: this.id, workerType: "thread", timestamp: Date.now() }
+      }));
+      this.callbacks.set(task.taskId, { resolve: task.resolve, reject: task.reject });
+      this.taskStartTimes.set(task.taskId, performance.now());
+      this.runningTaskData.set(task.taskId, { id: task.taskId, payload: task.payload });
+      this.worker?.postMessage({ taskId: task.taskId, payload: task.payload, action: "run" });
+    }
+  }
+  async terminate() {
+    if (this.initialized) {
+      this.teardownStartTime = performance.now();
+      this.dispatchEvent(new CustomEvent("worker.teardown.started", {
+        detail: { workerId: this.id, workerType: "thread", timestamp: Date.now() }
+      }));
+      try {
+        this.worker?.postMessage({ taskId: "teardown", action: "teardown" });
+        await new Promise((resolve) => {
+          const timeout = setTimeout(resolve, 1e3);
+          const onTeardown = () => {
+            clearTimeout(timeout);
+            this.removeEventListener("worker.teardown.completed", onTeardown);
+            resolve();
+          };
+          this.addEventListener("worker.teardown.completed", onTeardown);
+        });
+      } catch (error) {
+        this.dispatchEvent(new CustomEvent("worker.teardown.failed", {
+          detail: { workerId: this.id, workerType: "thread", timestamp: Date.now(), error }
+        }));
+      }
+    }
+    this.worker?.terminate();
+    this.worker = null;
+    this.runningTasks = 0;
+    this.callbacks.clear();
+    this.initialized = false;
+  }
+};
+
+// core/inlineWrapper.ts
+var InlineWrapper = class extends EventTarget {
+  runningTasks = 0;
+  maxConcurrentTasks;
+  runningTaskIds = /* @__PURE__ */ new Set();
+  runningTaskData = /* @__PURE__ */ new Map();
+  idleTimeout;
+  lastActivityTime = Date.now();
+  workerModule = null;
+  workerInstance = null;
+  scriptUrl;
+  config;
+  id;
+  initializing = false;
+  // WorkerInstanceState implementation
+  state = "initializing";
+  lastError;
+  // Stats for WorkerStatus
+  tasksCompleted = 0;
+  errorCount = 0;
+  createdAt = Date.now();
+  constructor(scriptUrl, idleTimeout = 5e3, maxConcurrentTasks = 1, config = {}) {
+    super();
+    this.scriptUrl = scriptUrl;
+    this.idleTimeout = idleTimeout;
+    this.maxConcurrentTasks = maxConcurrentTasks;
+    this.config = config;
+    this.id = `inline-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  canAcceptTask() {
+    return this.runningTasks < this.maxConcurrentTasks && !this.initializing && this.state !== "failed" && this.state !== "terminated";
+  }
+  // WorkerInstanceExtensions implementation
+  getRunningTaskIds() {
+    return Array.from(this.runningTaskIds);
+  }
+  getRunningTasks() {
+    return Array.from(this.runningTaskData.values());
+  }
+  // terminateWithError implementation - throws error for clean task completion
+  createTerminateWithError() {
+    return (error, metadata = {}) => {
+      throw new WorkerTerminationError(error.message, metadata);
+    };
+  }
+  // Handle termination request after task completion
+  _handleTerminationRequest(metadata) {
+    this.state = "failed";
+    this.lastError = {
+      timestamp: Date.now(),
+      message: "Worker termination requested",
+      metadata
+    };
+    this.errorCount++;
+    this.dispatchEvent(new CustomEvent("worker.failed", {
+      detail: {
+        workerId: this.id,
+        error: new Error("Worker termination requested"),
+        metadata: {
+          failureType: "self_termination",
+          ...metadata
+        },
+        timestamp: Date.now()
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("worker.termination_requested", {
+      detail: {
+        workerId: this.id,
+        metadata,
+        timestamp: Date.now()
+      }
+    }));
+    this.dispatchEvent(new CustomEvent("worker.self_terminated", {
+      detail: {
+        workerId: this.id,
+        metadata,
+        timestamp: Date.now()
+      }
+    }));
+  }
+  // Create BaseWorkerContext for worker constructor
+  createBaseWorkerContext() {
+    return {
+      workerId: this.id,
+      terminateWithError: this.createTerminateWithError()
+    };
+  }
+  get idle() {
+    return this.runningTasks === 0;
+  }
+  updateActivity() {
+    this.lastActivityTime = Date.now();
+  }
+  async _loadWorkerModule() {
+    if (!this.workerModule) {
+      this.workerModule = await import(this.scriptUrl);
+    }
+    return this.workerModule;
+  }
+  async _createWorkerInstance() {
+    if (this.workerInstance) {
+      return this.workerInstance;
+    }
+    this.initializing = true;
+    let instance = null;
+    try {
+      const module = await this._loadWorkerModule();
+      if (!module.default || typeof module.default !== "function" || !module.default.prototype) {
+        throw new Error(`Worker script ${this.scriptUrl} must export a default class`);
+      }
+      const initStartTime = performance.now();
+      this.dispatchEvent(new CustomEvent("worker.initialization.started", {
+        detail: { workerId: this.id, workerType: "inline", timestamp: Date.now() }
+      }));
+      const baseWorkerContext = this.createBaseWorkerContext();
+      instance = new module.default(this.config, baseWorkerContext);
+      if (instance.setup) {
+        this.dispatchEvent(new CustomEvent("worker.setup.started", {
+          detail: { workerId: this.id, workerType: "inline", timestamp: Date.now() }
+        }));
+        const setupStartTime = performance.now();
+        await instance.setup();
+        this.dispatchEvent(new CustomEvent("worker.setup.completed", {
+          detail: {
+            workerId: this.id,
+            workerType: "inline",
+            timestamp: Date.now(),
+            duration: performance.now() - setupStartTime
+          }
+        }));
+      }
+      this.dispatchEvent(new CustomEvent("worker.initialization.completed", {
+        detail: {
+          workerId: this.id,
+          workerType: "inline",
+          timestamp: Date.now(),
+          duration: performance.now() - initStartTime
+        }
+      }));
+      this.workerInstance = instance;
+      this.initializing = false;
+      return instance;
+    } catch (error) {
+      if (instance?.teardown) {
+        try {
+          await instance.teardown();
+        } catch (teardownError) {
+          console.warn("Teardown failed during initialization cleanup:", teardownError);
+        }
+      }
+      this.state = "failed";
+      this.lastError = {
+        timestamp: Date.now(),
+        message: error instanceof Error ? error.message : String(error),
+        metadata: { stage: instance ? "setup" : "constructor" }
+      };
+      this.errorCount++;
+      this.dispatchEvent(new CustomEvent("worker.initialization.failed", {
+        detail: {
+          workerId: this.id,
+          workerType: "inline",
+          timestamp: Date.now(),
+          error,
+          stage: instance ? "setup" : "constructor"
+        }
+      }));
+      this.dispatchEvent(new CustomEvent("worker.failed", {
+        detail: {
+          workerId: this.id,
+          error,
+          metadata: {
+            failureType: "initialization",
+            stage: instance ? "setup" : "constructor"
+          },
+          timestamp: Date.now()
+        }
+      }));
+      this.initializing = false;
+      throw error;
+    }
+  }
+  async runTask(taskId, payload) {
+    if (!this.canAcceptTask()) {
+      throw new Error("Worker at maximum concurrent task capacity");
+    }
+    this.updateActivity();
+    this.runningTasks++;
+    this.runningTaskIds.add(taskId);
+    this.runningTaskData.set(taskId, { id: taskId, payload });
+    this.dispatchEvent(new CustomEvent("task.started", {
+      detail: { taskId, workerId: this.id, workerType: "inline", timestamp: Date.now() }
+    }));
+    let fullExecutionStart;
+    try {
+      const workerInstance = await this._createWorkerInstance();
+      fullExecutionStart = performance.now();
+      const context = {
+        // Worker-level context (inherited from BaseWorkerContext)
+        workerId: this.id,
+        terminateWithError: this.createTerminateWithError(),
+        // Task-level context
+        taskId,
+        sendProgress: (progress, message, details) => {
+          this.dispatchEvent(new CustomEvent("task.progress", {
+            detail: {
+              taskId,
+              workerId: this.id,
+              workerType: "inline",
+              progress,
+              message,
+              details,
+              timestamp: Date.now()
+            }
+          }));
+        },
+        spawnTask: (config) => {
+          this.dispatchEvent(new CustomEvent("task.spawn_request", {
+            detail: {
+              taskId,
+              workerId: this.id,
+              workerType: "inline",
+              spawnConfig: config,
+              timestamp: Date.now()
+            }
+          }));
+        }
+      };
+      const result = await workerInstance.run(payload, context);
+      const fullExecutionTime = performance.now() - fullExecutionStart;
+      this.dispatchEvent(new CustomEvent("task.completed", {
+        detail: {
+          taskId,
+          workerId: this.id,
+          workerType: "inline",
+          result,
+          timestamp: Date.now(),
+          executionTime: fullExecutionTime
+          // Full task execution time including coordination
+        }
+      }));
+      return result;
+    } catch (error) {
+      const fullExecutionTime = 0;
+      if (error instanceof WorkerTerminationError) {
+        this.dispatchEvent(new CustomEvent("task.failed", {
+          detail: { taskId, workerId: this.id, workerType: "inline", error, timestamp: Date.now(), executionTime: fullExecutionTime }
+        }));
+        this._handleTerminationRequest(error.metadata);
+        throw error;
+      } else {
+        this.dispatchEvent(new CustomEvent("task.failed", {
+          detail: { taskId, workerId: this.id, workerType: "inline", error, timestamp: Date.now(), executionTime: fullExecutionTime }
+        }));
+        throw error;
+      }
+    } finally {
+      this.runningTasks--;
+      this.runningTaskIds.delete(taskId);
+      this.runningTaskData.delete(taskId);
+      this.tasksCompleted++;
+      if (this.state !== "failed" && this.state !== "terminated") {
+        this.state = this.runningTasks > 0 ? "busy" : "healthy";
+      }
+      this.updateActivity();
+    }
+  }
+  async terminate() {
+    await this._destroyWorkerInstance();
+    this.workerModule = null;
+    this.runningTasks = 0;
+    this.runningTaskIds.clear();
+  }
+  async _destroyWorkerInstance() {
+    if (this.workerInstance?.teardown) {
+      try {
+        this.dispatchEvent(new CustomEvent("worker.teardown.started", {
+          detail: { workerId: this.id, workerType: "inline", timestamp: Date.now() }
+        }));
+        const teardownStartTime = performance.now();
+        await this.workerInstance.teardown();
+        this.dispatchEvent(new CustomEvent("worker.teardown.completed", {
+          detail: {
+            workerId: this.id,
+            workerType: "inline",
+            timestamp: Date.now(),
+            duration: performance.now() - teardownStartTime
+          }
+        }));
+      } catch (teardownError) {
+        this.dispatchEvent(new CustomEvent("worker.teardown.failed", {
+          detail: { workerId: this.id, workerType: "inline", timestamp: Date.now(), error: teardownError }
+        }));
+        console.warn(`Worker ${this.id} teardown failed:`, teardownError);
+      }
+    }
+    this.workerInstance = null;
+  }
+};
+
+// core/workerManager.ts
+var WorkerManager = class extends EventTarget {
+  threads = [];
+  maxThreads;
+  maxConcurrentTasks;
+  scriptUrl;
+  idleTimeout;
+  inline;
+  config;
+  groups;
+  requeueFailedTasks;
+  maxWorkerRestarts;
+  // Track restart count for entire pool (simpler and more logical)
+  poolRestartCount = 0;
+  // Set for the duration of shutdown, so worker failures during teardown are not
+  // mistaken for crashes worth restarting
+  shuttingDown = false;
+  // Track ALL event listeners for cleanup
+  allListeners = /* @__PURE__ */ new Map();
+  // Track initializing threads
+  initializingThreads = /* @__PURE__ */ new Set();
+  // Centralized idle management
+  idleCheckTimer = null;
+  IDLE_CHECK_INTERVAL = 5e3;
+  // Check every 5 seconds
+  constructor(scriptUrl, options = {}) {
+    super();
+    this.scriptUrl = scriptUrl;
+    this.maxThreads = options.maxThreads ?? 2;
+    this.maxConcurrentTasks = options.maxConcurrentTasks ?? 1;
+    this.idleTimeout = options.idleTimeout ?? 5e3;
+    this.inline = options.inline ?? false;
+    this.config = options.config ?? {};
+    this.groups = options.groups ?? [];
+    this.requeueFailedTasks = options.requeueFailedTasks ?? true;
+    this.maxWorkerRestarts = options.maxWorkerRestarts ?? 3;
+    this._setupWorkerFailureHandling();
+  }
+  // Direct execution without internal queueing
+  async enqueueNoQueue(taskId, payload) {
+    let targetThread = this.threads.find(
+      (t) => t.canAcceptTask && t.canAcceptTask()
+    );
+    if (!targetThread && this.threads.length + this.initializingThreads.size < this.maxThreads) {
+      const newThread = this.inline ? new InlineWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, this.config) : new ThreadWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, this.config);
+      this.initializingThreads.add(newThread);
+      this._setupWorkerEventListeners(newThread);
+      this.threads.push(newThread);
+      this.startIdleTimer();
+      if (this.inline) {
+        this.initializingThreads.delete(newThread);
+        targetThread = newThread;
+      } else {
+        await new Promise((resolve) => {
+          const checkInit = () => {
+            if (newThread.canAcceptTask && newThread.canAcceptTask()) {
+              this.initializingThreads.delete(newThread);
+              resolve();
+            } else {
+              setTimeout(checkInit, 10);
+            }
+          };
+          checkInit();
+        });
+        targetThread = newThread;
+      }
+    }
+    if (!targetThread) {
+      throw new Error(`No worker thread available (${this.threads.length}/${this.maxThreads})`);
+    }
+    return targetThread.runTask(taskId, payload);
+  }
+  _createPredictiveThread() {
+    const thread = this.inline ? new InlineWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, this.config) : new ThreadWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, this.config);
+    this._setupWorkerEventListeners(thread);
+    this.threads.push(thread);
+    this.startIdleTimer();
+    return thread;
+  }
+  // Override addEventListener to track ALL listeners for cleanup
+  //TODO: likely unneccesary, verify
+  addEventListener(event, listener, options) {
+    super.addEventListener(event, listener, options);
+    this._trackListener(this, event, listener);
+  }
+  // Helper to track listeners for cleanup
+  _addInternalListener(target, event, listener) {
+    this._trackListener(target, event, listener);
+    target.addEventListener(event, listener);
+  }
+  _trackListener(target, event, listener) {
+    if (!this.allListeners.has(target)) {
+      this.allListeners.set(target, []);
+    }
+    this.allListeners.get(target).push({ event, listener });
+  }
+  // Remove ALL event listeners (both internal and external)
+  _removeAllListeners() {
+    for (const [target, listeners] of this.allListeners) {
+      for (const { event, listener } of listeners) {
+        try {
+          target.removeEventListener(event, listener);
+        } catch {
+        }
+      }
+    }
+    this.allListeners.clear();
+  }
+  _setupWorkerEventListeners(worker) {
+    const listeners = [
+      { event: "task.started", handler: (e) => this.dispatchEvent(new CustomEvent("task.started", { detail: e.detail })) },
+      { event: "task.completed", handler: (e) => this.dispatchEvent(new CustomEvent("task.completed", { detail: e.detail })) },
+      { event: "task.failed", handler: (e) => this.dispatchEvent(new CustomEvent("task.failed", { detail: e.detail })) },
+      { event: "task.progress", handler: (e) => this.dispatchEvent(new CustomEvent("task.progress", { detail: e.detail })) },
+      { event: "task.spawn_request", handler: (e) => this.dispatchEvent(new CustomEvent("task.spawn_request", { detail: e.detail })) },
+      { event: "worker.failed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.failed", { detail: e.detail })) },
+      // Lifecycle events - forwarded so pool owners can observe worker startup
+      // cost, setup failures and teardown problems. Both wrapper types emit the
+      // same set with the same payload shape.
+      { event: "worker.initialization.started", handler: (e) => this.dispatchEvent(new CustomEvent("worker.initialization.started", { detail: e.detail })) },
+      { event: "worker.initialization.completed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.initialization.completed", { detail: e.detail })) },
+      { event: "worker.initialization.failed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.initialization.failed", { detail: e.detail })) },
+      { event: "worker.setup.started", handler: (e) => this.dispatchEvent(new CustomEvent("worker.setup.started", { detail: e.detail })) },
+      { event: "worker.setup.completed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.setup.completed", { detail: e.detail })) },
+      { event: "worker.teardown.started", handler: (e) => this.dispatchEvent(new CustomEvent("worker.teardown.started", { detail: e.detail })) },
+      { event: "worker.teardown.completed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.teardown.completed", { detail: e.detail })) },
+      { event: "worker.teardown.failed", handler: (e) => this.dispatchEvent(new CustomEvent("worker.teardown.failed", { detail: e.detail })) },
+      { event: "worker.self_terminated", handler: (e) => this.dispatchEvent(new CustomEvent("worker.self_terminated", { detail: e.detail })) },
+      { event: "worker.termination_requested", handler: (e) => this._handleWorkerTerminationRequest(e) }
+    ];
+    for (const { event, handler } of listeners) {
+      this._addInternalListener(worker, event, handler);
+    }
+  }
+  // Handle worker termination requests (new event-driven approach)
+  _handleWorkerTerminationRequest(e) {
+    const { workerId, metadata } = e.detail;
+    const failureEvent = {
+      detail: {
+        workerId,
+        error: new Error("Worker termination requested"),
+        metadata: {
+          failureType: "runtime",
+          ...metadata
+        },
+        timestamp: Date.now()
+      }
+    };
+    this._handleWorkerFailure(failureEvent);
+  }
+  // Worker failure handling setup (as specified in task)
+  _setupWorkerFailureHandling() {
+    const failureListener = (e) => this._handleWorkerFailure(e);
+    this._addInternalListener(this, "worker.failed", failureListener);
+  }
+  // Unified worker failure handling (as specified in task)
+  _handleWorkerFailure(e) {
+    if (this.shuttingDown) return;
+    const { workerId, error, metadata } = e.detail;
+    const { canRestart, restartDelay } = metadata || {};
+    const failedWorker = this.threads.find((w) => w.id === workerId);
+    if (!failedWorker) return;
+    const runningTaskIds = failedWorker.getRunningTaskIds();
+    runningTaskIds.forEach((taskId) => {
+      if (this.requeueFailedTasks && canRestart !== false) {
+        this.dispatchEvent(new CustomEvent("task.requeue_required", {
+          detail: { taskId, originalError: error, workerId }
+        }));
+      } else {
+        this.dispatchEvent(new CustomEvent("task.failed", {
+          detail: {
+            taskId,
+            workerId,
+            error: new Error(`Worker failed: ${error.message}`),
+            timestamp: Date.now()
+          }
+        }));
+      }
+    });
+    this._markWorkerAsFailed(workerId, error, metadata);
+    this._releaseWorkerGroupResources(workerId);
+    if (canRestart !== false) {
+      if (this.poolRestartCount < this.maxWorkerRestarts) {
+        this.poolRestartCount++;
+        const delay = restartDelay || 5e3;
+        setTimeout(() => {
+          this._removeAndReplaceWorker(workerId);
+        }, delay);
+      } else {
+        this.dispatchEvent(new CustomEvent("worker.restart_limit_exceeded", {
+          detail: {
+            workerId,
+            poolRestartCount: this.poolRestartCount,
+            maxRestarts: this.maxWorkerRestarts
+          }
+        }));
+      }
+    }
+  }
+  // Resource allocation implementation methods (as specified in task)
+  _markWorkerAsFailed(workerId, error, metadata) {
+    const worker = this.threads.find((w) => w.id === workerId);
+    if (worker) {
+      const alreadyTerminated = worker.state === "terminated";
+      worker.state = "failed";
+      worker.lastError = { timestamp: Date.now(), message: error.message, metadata };
+      if (!alreadyTerminated) {
+        worker.terminate().catch(() => {
+        });
+      }
+    }
+  }
+  _releaseWorkerGroupResources(workerId) {
+    const worker = this.threads.find((w) => w.id === workerId);
+    if (worker) {
+    }
+  }
+  _removeAndReplaceWorker(workerId) {
+    const workerIndex = this.threads.findIndex((w) => w.id === workerId);
+    if (workerIndex !== -1) {
+      this.threads.splice(workerIndex, 1);
+      if (this.threads.length < this.maxThreads) {
+        this._createPredictiveThread();
+      }
+    }
+  }
+  // Worker Status Inspection APIs (as specified in task)
+  /** Ids of the workers that currently exist in this pool (created lazily). */
+  getWorkerIds() {
+    return this.threads.map((w) => w.id);
+  }
+  /**
+   * Health and activity of one worker, or `null` if no such worker exists.
+   * Useful for building supervision on top of `worker.failed`.
+   */
+  getWorkerStatus(workerId) {
+    const worker = this.threads.find((w) => w.id === workerId);
+    if (!worker) return null;
+    return {
+      id: worker.id,
+      state: worker.state || "healthy",
+      tasksCompleted: worker.tasksCompleted || 0,
+      errorCount: worker.errorCount || 0,
+      uptime: Date.now() - (worker.createdAt || Date.now()),
+      currentTasks: worker.getRunningTaskIds(),
+      lastError: worker.lastError,
+      resourcesHeld: this.groups || []
+      // Groups this worker is assigned to
+    };
+  }
+  /** `getWorkerStatus` for every live worker, keyed by worker id. */
+  getAllWorkerStatuses() {
+    const statuses = /* @__PURE__ */ new Map();
+    this.threads.forEach((worker) => {
+      const status = this.getWorkerStatus(worker.id);
+      if (status) {
+        statuses.set(worker.id, status);
+      }
+    });
+    return statuses;
+  }
+  // Worker Management APIs (as specified in task)
+  /**
+   * Terminate a worker and create a replacement, optionally merging `newConfig`
+   * over the pool's `config`. The replacement gets a new id.
+   *
+   * @returns false if no worker with that id exists.
+   */
+  async restartWorker(workerId, newConfig) {
+    const workerIndex = this.threads.findIndex((w) => w.id === workerId);
+    if (workerIndex === -1) return false;
+    const oldWorker = this.threads[workerIndex];
+    await oldWorker.terminate();
+    this.threads.splice(workerIndex, 1);
+    const config = { ...this.config, ...newConfig || {} };
+    const newWorker = this.inline ? new InlineWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, config) : new ThreadWrapper(this.scriptUrl, this.idleTimeout, this.maxConcurrentTasks, config);
+    this._setupWorkerEventListeners(newWorker);
+    this.threads.push(newWorker);
+    this.startIdleTimer();
+    return true;
+  }
+  /** Alias for {@link WorkerManager.restartWorker}. */
+  async replaceWorker(workerId, newConfig) {
+    return await this.restartWorker(workerId, newConfig);
+  }
+  /**
+   * Merge `config` into a live worker's config object.
+   *
+   * Note this mutates the config a worker instance already holds - a worker that
+   * copied values in its constructor will not see the change. Use
+   * {@link WorkerManager.restartWorker} when the worker must be rebuilt.
+   *
+   * @returns false if no worker with that id exists.
+   */
+  async updateWorkerConfig(workerId, config) {
+    const worker = this.threads.find((w) => w.id === workerId);
+    if (!worker) return false;
+    worker.config = { ...worker.config, ...config };
+    return true;
+  }
+  // Centralized idle management methods
+  startIdleTimer() {
+    if (this.idleCheckTimer || this.threads.length === 0) return;
+    this.idleCheckTimer = setInterval(() => {
+      this.checkIdleWorkers();
+    }, this.IDLE_CHECK_INTERVAL);
+  }
+  stopIdleTimer() {
+    if (this.idleCheckTimer) {
+      clearInterval(this.idleCheckTimer);
+      this.idleCheckTimer = null;
+    }
+  }
+  checkIdleWorkers() {
+    const now = Date.now();
+    const workersToTerminate = [];
+    for (const worker of this.threads) {
+      if (worker.idleTimeout > 0 && worker.idle && now - worker.lastActivityTime > worker.idleTimeout) {
+        workersToTerminate.push(worker);
+      }
+    }
+    for (const worker of workersToTerminate) {
+      this._removeIdleWorker(worker).catch((error) => {
+        console.warn(`Failed to remove idle worker ${worker.id}:`, error);
+      });
+    }
+    if (this.threads.length === 0) {
+      this.stopIdleTimer();
+    }
+  }
+  async _removeIdleWorker(worker) {
+    const workerIndex = this.threads.findIndex((w) => w.id === worker.id);
+    if (workerIndex === -1) return;
+    this.threads.splice(workerIndex, 1);
+    try {
+      await worker.terminate();
+    } catch (error) {
+      console.warn(`Failed to terminate idle worker ${worker.id}:`, error);
+    }
+  }
+  // Shutdown all workers and cleanup resources
+  /** Terminate every worker in the pool and drop its listeners. */
+  async shutdown() {
+    this.shuttingDown = true;
+    this.stopIdleTimer();
+    const shutdownPromises = this.threads.map(async (worker) => {
+      try {
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            console.warn(`\u26A0\uFE0F Timeout terminating worker ${worker.id}`);
+            reject(new Error("Failed to terminate worker"));
+          }, 1e3);
+          const terminatePromise = worker.terminate();
+          terminatePromise.then(() => {
+            clearTimeout(timeout);
+            resolve();
+          }).catch((error) => {
+            clearTimeout(timeout);
+            reject(error);
+          });
+        });
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F Error terminating worker ${worker.id}:`, error);
+        return Promise.resolve();
+      }
+    });
+    await Promise.all(shutdownPromises);
+    this.threads = [];
+    this._removeAllListeners();
+  }
+};
+export {
+  BaseWorker,
+  ConcurrentLimitGroup,
+  FyflowScheduler,
+  FyflowTask,
+  InlineWrapper,
+  KeyedRateLimitGroup,
+  RateLimitGroup,
+  ThreadWrapper,
+  WorkerManager,
+  WorkerTerminationError
+};