fyflow-orchestration 0.8.0 → 0.9.0

package/dist/browser/index.js

@@ -143,7 +143,7 @@ import {
   violatedRules,
   witness,
   workersOf
-} from "./chunks/chunk-EUU44PHD.js";
+} from "./chunks/chunk-3U4UZC34.js";
 
 // src/definition/assist.ts
 var TYPES = ["object", "array", "string", "number", "integer", "boolean", "null"];

package/dist/browser/scheduler/index.js

@@ -1,4 +1,5 @@
 import {
+  Accumulator,
   BUILT_IN_NODE_TYPES,
   ConfigRefused,
   Driver,
@@ -22,10 +23,9 @@ import {
   resolveRegistry,
   resumeRefusal,
   retryPolicyProblem,
-  step,
   validateDefinition,
   workersOf
-} from "../chunks/chunk-EUU44PHD.js";
+} from "../chunks/chunk-3U4UZC34.js";
 
 // src/scheduler/bootstrap.ts
 import { WorkerManager } from "fyflow-scheduler";
@@ -281,14 +281,50 @@ function createRuntime(document, code = {}, options = {}) {
     const done = new Promise((resolve) => {
       settle = resolve;
     });
-    let state = emptyState();
+    const acc = Accumulator.load(emptyState());
+    let cached = null;
+    const frozen = /* @__PURE__ */ new WeakSet();
     let settled = false;
     let seed = from === null ? null : from.events;
+    const own = (input) => {
+      if (input.kind !== "outcome" && input.kind !== "resolution") return input;
+      const r = input.record;
+      return typeof r.result === "object" && r.result !== null ? { kind: input.kind, record: structuredClone(r) } : input;
+    };
+    const take = (input) => {
+      if (acc.apply(own(input))) cached = null;
+    };
+    const catchUp = () => {
+      if (seed === null) return;
+      for (const stored of seed) take(stored);
+      seed = null;
+    };
+    const freezeDeep = (root) => {
+      const stack = [root];
+      while (stack.length > 0) {
+        const v = stack.pop();
+        if (typeof v !== "object" || v === null || frozen.has(v)) continue;
+        frozen.add(v);
+        if (ArrayBuffer.isView(v)) continue;
+        if (v instanceof Map) for (const [k, x] of v) stack.push(k, x);
+        else if (v instanceof Set) for (const x of v) stack.push(x);
+        for (const k of Reflect.ownKeys(v)) {
+          const d = Object.getOwnPropertyDescriptor(v, k);
+          if (d !== void 0 && "value" in d) stack.push(d.value);
+        }
+        Object.freeze(v);
+      }
+      return root;
+    };
+    const current = () => {
+      catchUp();
+      return cached ??= freezeDeep(acc.materialise());
+    };
     const settleIfTerminal = () => {
-      if (settled || !isTerminal(state)) return;
+      if (settled || !isTerminal({ outcome: acc.outcomeNow() })) return;
       settled = true;
-      if (state.outcome === "interrupted" && stopping.size > 0) {
-        const at = state;
+      const at = current();
+      if (at.outcome === "interrupted" && stopping.size > 0) {
         const fin = () => {
           settle(at);
           router.release(runId);
@@ -296,7 +332,7 @@ function createRuntime(document, code = {}, options = {}) {
         void Promise.allSettled([...stopping]).then(fin);
         return;
       }
-      settle(state);
+      settle(at);
       router.release(runId);
     };
     const view = router.forRun(runId);
@@ -333,11 +369,8 @@ function createRuntime(document, code = {}, options = {}) {
       // of a run from its first, and it is the well-formed wrong answer the first time a driver's
       // sequence does not start at this callback's first call.
       onFoldInput: (input, seq) => {
-        if (seed !== null) {
-          for (const stored of seed) state = step(state, stored);
-          seed = null;
-        }
-        state = step(state, input);
+        catchUp();
+        take(input);
         queueMicrotask(settleIfTerminal);
         startOptions.onFoldInput?.(input, seq);
       },
@@ -361,7 +394,22 @@ function createRuntime(document, code = {}, options = {}) {
       router.release(runId);
       throw e;
     }
-    return { driver, done, header: driver.checkpoint().header, stop: (stopOptions) => driver.stop(stopOptions) };
+    return {
+      driver,
+      done,
+      header: driver.checkpoint().header,
+      stop: (stopOptions) => driver.stop(stopOptions),
+      state: current,
+      outcome: () => {
+        catchUp();
+        return acc.outcomeNow();
+      },
+      node: (taskId) => {
+        catchUp();
+        const entry = acc.entry(taskId);
+        return entry === void 0 ? null : freezeDeep(entry);
+      }
+    };
   }
 }
 function settlementRouter(scheduler) {