@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-KMCAYNUM.js

@@ -0,0 +1,331 @@
+import {
+  CancellationError
+} from "./chunk-6KMVP6AU.js";
+
+// src/runtime/ExecutionContext.ts
+var GeneratedExecutionContext = class _GeneratedExecutionContext {
+  variables = /* @__PURE__ */ new Map();
+  executions = /* @__PURE__ */ new Map();
+  executionCounter = 0;
+  nodeExecutionCounts = /* @__PURE__ */ new Map();
+  isAsync;
+  // inline: development only
+  flowWeaverDebugger;
+  // inline: end
+  pullExecutors = /* @__PURE__ */ new Map();
+  nodeExecutionIndices = /* @__PURE__ */ new Map();
+  runtime;
+  scopeInvocationCounts = /* @__PURE__ */ new Map();
+  nestedInvocationCounts = /* @__PURE__ */ new Map();
+  branchStack;
+  allowAncestorDurableVariables = true;
+  /** `isAsync` is the workflow's async mode; `runtime` is the execution-scoped runtime. */
+  constructor(isAsync = true, runtime) {
+    this.isAsync = isAsync;
+    this.flowWeaverDebugger = runtime.services.debugger;
+    this.runtime = runtime;
+    this.branchStack = [...runtime.branches];
+  }
+  registerPullExecutor(id, executor) {
+    this.pullExecutors.set(id, executor);
+  }
+  /** Record one execution of a node; each node counts its own executions from 0. */
+  addExecution(id, parentIndex, scopeName) {
+    const index = this.nodeExecutionCounts.get(id) ?? 0;
+    this.nodeExecutionCounts.set(id, index + 1);
+    this.executionCounter++;
+    this.executions.set(this.getExecutionKey(id, index), {
+      id,
+      index,
+      parentIndex,
+      scopeName
+    });
+    this.nodeExecutionIndices.set(id, index);
+    return index;
+  }
+  setVariable(address, value) {
+    const key = this.getVariableKey(address);
+    this.variables.set(key, value);
+    if (typeof value !== "function" && address.durable !== false) {
+      this.runtime.durable.setVariable(this.executionAddress(address), address.portName, value);
+    }
+    if (this.flowWeaverDebugger) {
+      const actualValue = typeof value === "function" ? value() : value;
+      this.sendVariableSetEvent({
+        identifier: {
+          nodeTypeName: address.nodeTypeName || "unknown",
+          id: address.id,
+          portName: address.portName,
+          executionIndex: address.executionIndex,
+          key: "default",
+          ...address.scope && { scope: address.scope },
+          ...address.side && { side: address.side }
+        },
+        value: actualValue
+      });
+    }
+    return this.isAsync ? Promise.resolve() : void 0;
+  }
+  getVariable(address) {
+    const executor = this.pullExecutors.get(address.id);
+    if (executor) {
+      if (!this.hasVariable(address)) {
+        const result = executor();
+        if (result instanceof Promise) {
+          return result.then(() => {
+            const trackedIndex2 = this.nodeExecutionIndices.get(address.id);
+            const finalAddress2 = trackedIndex2 !== void 0 ? { ...address, executionIndex: trackedIndex2 } : address;
+            return this.retrieveVariable(finalAddress2);
+          });
+        }
+        const trackedIndex = this.nodeExecutionIndices.get(address.id);
+        const finalAddress = trackedIndex !== void 0 ? { ...address, executionIndex: trackedIndex } : address;
+        return this.retrieveVariable(finalAddress);
+      }
+    }
+    return this.retrieveVariable(address);
+  }
+  retrieveVariable(address) {
+    const key = this.getVariableKey(address);
+    let value = this.variables.get(key);
+    if (!this.variables.has(key)) {
+      value = this.runtime.durable.getVariable(
+        this.executionAddress(address),
+        address.portName,
+        this.allowAncestorDurableVariables
+      );
+      if (value === void 0) {
+        throw new Error(`Variable not found: ${address.id}.${address.portName}[${address.executionIndex}]`);
+      }
+      this.variables.set(key, value);
+    }
+    if (typeof value === "function") {
+      const result = value();
+      if (result instanceof Promise) {
+        return result;
+      }
+      return this.isAsync ? Promise.resolve(result) : result;
+    }
+    return this.isAsync ? Promise.resolve(value) : value;
+  }
+  hasVariable(address) {
+    const key = this.getVariableKey(address);
+    return this.variables.has(key) || this.runtime.durable.getVariable(
+      this.executionAddress(address),
+      address.portName,
+      this.allowAncestorDurableVariables
+    ) !== void 0;
+  }
+  executionAddress(address) {
+    const runtime = this.getRuntime();
+    return runtime.durable.address(runtime, address.id, address.nodeTypeName ?? address.id, address.executionIndex);
+  }
+  shouldExecute(nodeId, nodeType, executionIndex) {
+    const runtime = this.getRuntime();
+    return runtime.durable.shouldExecute(runtime.durable.address(runtime, nodeId, nodeType, executionIndex));
+  }
+  commitNode(nodeId, nodeType, executionIndex) {
+    const runtime = this.getRuntime();
+    runtime.durable.commitNode(runtime.durable.address(runtime, nodeId, nodeType, executionIndex));
+  }
+  /** The first thing a gated body does: name its workflow and graph to the engine. */
+  bindWorkflow(workflowId, graphFingerprint) {
+    this.runtime.durable.bind(this.runtime, workflowId, graphFingerprint);
+  }
+  resolveGate(kind, nodeId, nodeType, executionIndex, payload) {
+    const runtime = this.getRuntime();
+    return runtime.durable.resolveGate(runtime, { kind, nodeId, nodeType, executionIndex, payload });
+  }
+  executeEffect(nodeId, nodeType, executionIndex, execute) {
+    const runtime = this.getRuntime();
+    return runtime.durable.executeEffect(runtime, { nodeId, nodeType, executionIndex }, execute);
+  }
+  createNestedRuntime(workflowId, callerNodeId, callerExecutionIndex) {
+    const invocation = this.nestedInvocationCounts.get(callerNodeId) ?? 0;
+    this.nestedInvocationCounts.set(callerNodeId, invocation + 1);
+    const parentRuntime = this.getRuntime();
+    return {
+      ...parentRuntime,
+      frames: [...parentRuntime.frames, { workflowId, invocation, callerNodeId, callerExecutionIndex }],
+      scopes: parentRuntime.scopes
+    };
+  }
+  enterBranch(nodeId, executionIndex, arm) {
+    const frameDepth = this.runtime.frames.length - 1;
+    const workflowId = this.runtime.frames[frameDepth].workflowId;
+    this.branchStack.push({ workflowId, frameDepth, nodeId, executionIndex, arm });
+  }
+  exitBranch() {
+    this.branchStack.pop();
+  }
+  getRuntime() {
+    return { ...this.runtime, branches: [...this.branchStack] };
+  }
+  /**
+   * Fork the mutable bookkeeping for one lane of a parallel group. Durable
+   * state stays execution-scoped and shared through `runtime`, while the
+   * branch and scope address stacks are copied so concurrent lanes cannot
+   * corrupt one another's continuation addresses.
+   */
+  forkParallel() {
+    const parallelContext = new _GeneratedExecutionContext(this.isAsync, this.getRuntime());
+    parallelContext.variables = new Map(this.variables);
+    parallelContext.executions = new Map(this.executions);
+    parallelContext.executionCounter = this.executionCounter;
+    parallelContext.pullExecutors = new Map(this.pullExecutors);
+    parallelContext.nodeExecutionIndices = new Map(this.nodeExecutionIndices);
+    parallelContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);
+    parallelContext.scopeInvocationCounts = new Map(this.scopeInvocationCounts);
+    parallelContext.nestedInvocationCounts = new Map(this.nestedInvocationCounts);
+    parallelContext.allowAncestorDurableVariables = this.allowAncestorDurableVariables;
+    return parallelContext;
+  }
+  mergeParallel(parallelContext) {
+    this.mergeScope(parallelContext);
+    parallelContext.nodeExecutionIndices.forEach((index, id) => {
+      this.nodeExecutionIndices.set(id, index);
+    });
+    parallelContext.scopeInvocationCounts.forEach((count, key) => {
+      this.scopeInvocationCounts.set(key, Math.max(this.scopeInvocationCounts.get(key) ?? 0, count));
+    });
+    parallelContext.nestedInvocationCounts.forEach((count, key) => {
+      this.nestedInvocationCounts.set(key, Math.max(this.nestedInvocationCounts.get(key) ?? 0, count));
+    });
+  }
+  getExecution(id, index) {
+    return this.executions.get(this.getExecutionKey(id, index));
+  }
+  /**
+   * Create the execution context for one invocation of a scope (a loop body,
+   * a per-port function). Each call is the next invocation of that scope key.
+   * A clean scope (a per-port scope) starts with no variables and cannot read
+   * its ancestors' durable variables; any other (a node-level scope) inherits
+   * the parent's variables. `isAsyncOverride` is the scope's own async mode,
+   * when it differs from the parent's.
+   */
+  createScope(_parentNodeName, _parentIndex, _scopeName, cleanScope = false, isAsyncOverride) {
+    const effectiveIsAsync = isAsyncOverride !== void 0 ? isAsyncOverride : this.isAsync;
+    const scopeKey = `${_parentNodeName}:${_parentIndex}:${_scopeName}`;
+    const scopeInvocation = this.scopeInvocationCounts.get(scopeKey) ?? 0;
+    this.scopeInvocationCounts.set(scopeKey, scopeInvocation + 1);
+    const parentRuntime = this.getRuntime();
+    const scopedRuntime = {
+      ...parentRuntime,
+      scopes: [
+        ...parentRuntime.scopes,
+        {
+          parentNodeId: _parentNodeName,
+          parentExecutionIndex: _parentIndex,
+          scopeName: _scopeName,
+          invocation: scopeInvocation,
+          loopIteration: scopeInvocation
+        }
+      ]
+    };
+    const scopedContext = new _GeneratedExecutionContext(effectiveIsAsync, scopedRuntime);
+    scopedContext.variables = cleanScope ? /* @__PURE__ */ new Map() : new Map(this.variables);
+    scopedContext.allowAncestorDurableVariables = this.allowAncestorDurableVariables && !cleanScope;
+    scopedContext.executions = new Map(this.executions);
+    scopedContext.executionCounter = this.executionCounter;
+    scopedContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);
+    return scopedContext;
+  }
+  /** Merge a scope's variables, executions and counters back into this context. */
+  mergeScope(scopedContext) {
+    scopedContext.executions.forEach((info, key) => {
+      this.executions.set(key, info);
+    });
+    scopedContext.variables.forEach((value, key) => {
+      this.variables.set(key, value);
+    });
+    this.executionCounter = Math.max(this.executionCounter, scopedContext.executionCounter);
+    scopedContext.nodeExecutionCounts.forEach((count, id) => {
+      this.nodeExecutionCounts.set(id, Math.max(this.nodeExecutionCounts.get(id) ?? 0, count));
+    });
+  }
+  getVariableKey(address) {
+    return `${address.id}:${address.portName}:${address.executionIndex}`;
+  }
+  getExecutionKey(id, index) {
+    return `${id}:${index}`;
+  }
+  getExecutionCount() {
+    return this.executionCounter;
+  }
+  reset() {
+    this.variables.clear();
+    this.executions.clear();
+    this.executionCounter = 0;
+    this.nodeExecutionCounts.clear();
+  }
+  isAborted() {
+    return this.runtime.abortSignal?.aborted ?? false;
+  }
+  /** Return the parent-owned signal without transferring ownership. */
+  getAbortSignal() {
+    return this.runtime.abortSignal;
+  }
+  /** Throw a CancellationError, naming `nodeId` when given, if the run was aborted. */
+  checkAborted(nodeId) {
+    if (this.runtime.abortSignal?.aborted) {
+      throw new CancellationError(
+        `Workflow execution cancelled${nodeId ? ` at ${nodeId}` : ""}`,
+        this.executionCounter,
+        nodeId
+      );
+    }
+  }
+  // inline: development only, a no-op stub in production
+  /** Awaited by generated code, so a debugger can hold a node at a breakpoint. */
+  async sendStatusChangedEvent(args) {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "STATUS_CHANGED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation
+      });
+    }
+  }
+  async sendLogErrorEvent(args) {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "LOG_ERROR",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation
+      });
+    }
+  }
+  async sendWorkflowCompletedEvent(args) {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "WORKFLOW_COMPLETED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation
+      });
+    }
+  }
+  // inline: end
+  // inline: development only
+  async sendVariableSetEvent(args) {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "VARIABLE_SET",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation
+      });
+    }
+  }
+  /** Return live debugger-visible variables without invoking lazy values. */
+  inspectVariables() {
+    const vars = {};
+    for (const [key, value] of this.variables) {
+      vars[key] = typeof value === "function" ? "[lazy value]" : value;
+    }
+    return vars;
+  }
+  // inline: end
+};
+
+export {
+  GeneratedExecutionContext
+};