@loopingai/core 0.5.1 → 0.7.0

package/dist/subtasks/scheduler.js

@@ -1,47 +0,0 @@
-/**
- * Non-terminal statuses — nodes Phase 2 still owes an outcome for.
- *
- * `running` counts as active on purpose. `executeSubtask` accepts a row that is
- * `pending` **or** `running`: the latter is its ambiguous-retry path, where a
- * previous attempt crashed mid-execution and the managed child's fingerprint
- * cache may still hold the terminal result that makes the retry free. So a row
- * stranded `running` is re-runnable, and treating it as inert would deadlock its
- * dependents instead of recovering them.
- */
-const ACTIVE = new Set([
-    "pending",
-    "running"
-]);
-/**
- * Select the next wave of dependency-ready Subtasks.
- *
- * A node is ready when it is still active and **every** dependency completed
- * successfully — `completed` specifically, not merely terminal: a dependent must
- * never run on a failed prerequisite's absent output.
- *
- * Ready ids come back in `ordinal` order. The Workflow builds durable step names
- * from them (`execute:<id>`), and step names are a cache key, so the traversal
- * that produces them has to be deterministic.
- *
- * **On `stuck`:** one "active nodes, none ready" check is the whole safety net. A
- * cycle, a self-dependency, and a dangling dependency id all manifest identically
- * here — every node in a cycle waits on a non-completed peer, a self-dependency
- * waits on its own non-completed self, and an unknown id resolves to `undefined`,
- * which is not `completed`. None of them are reachable: `createDecomposition`
- * validates the DAG before it persists a single row. So this is a loud assertion
- * for a corrupted DAG, not a control path — which is exactly why it is one check
- * and not three detectors that can never fire.
- */
-export function selectWave(nodes) {
-    const statusById = new Map(nodes.map((n) => [n.id, n.status]));
-    const active = nodes.filter((n) => ACTIVE.has(n.status));
-    if (active.length === 0)
-        return { kind: "done" };
-    const ready = active
-        .filter((n) => n.dependsOn.every((d) => statusById.get(d) === "completed"))
-        .sort((a, b) => a.ordinal - b.ordinal)
-        .map((n) => n.id);
-    if (ready.length === 0)
-        return { kind: "stuck", active: active.map((n) => n.id) };
-    return { kind: "ready", ids: ready };
-}