@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/chunks/chunk-OOQG7UPP.js

@@ -0,0 +1,457 @@
+import {
+  ENGINE_VERSION,
+  assertAcceptedContinuation,
+  canonicalWireValue,
+  cloneAndFreezeWireValue,
+  createContinuationEnvelope,
+  durableGateId,
+  executionAddressKey,
+  operationKey,
+  sha256Hex,
+  validateWireValue
+} from "./chunk-O2U2LO57.js";
+
+// src/runtime/durable-execution.ts
+function acceptGateResolution(resolution) {
+  if (resolution === void 0) return void 0;
+  validateWireValue(resolution);
+  const keys = Object.keys(resolution).sort();
+  if (keys.length !== 2 || keys[0] !== "gateId" || keys[1] !== "value" || !/^[0-9a-f]{64}$/.test(resolution.gateId)) {
+    throw new Error("resolution must contain exactly a canonical gateId and wire value");
+  }
+  return cloneAndFreezeWireValue(resolution);
+}
+function mockedGateAnswer(mocks, boundary) {
+  if (!mocks) return void 0;
+  const { nodeId, nodeType } = boundary;
+  const pick = (section, key) => {
+    if (!section) return void 0;
+    if (key !== void 0 && section[`${nodeId}:${key}`] !== void 0) return section[`${nodeId}:${key}`];
+    if (section[`${nodeId}:*`] !== void 0) return section[`${nodeId}:*`];
+    return key !== void 0 ? section[key] : void 0;
+  };
+  const firstInput = () => {
+    const p = boundary.payload;
+    const v = p?.arguments?.[0]?.value;
+    return v === void 0 || v === null ? void 0 : String(v);
+  };
+  let data = mocks.gates?.[nodeId];
+  if (data === void 0 && nodeType === "waitForAgent") {
+    const v = pick(mocks.agents, firstInput());
+    if (v !== void 0) data = { agentResult: v };
+  }
+  if (data === void 0 && nodeType === "waitForEvent") {
+    const v = pick(mocks.events, firstInput());
+    if (v !== void 0) data = { eventData: v };
+  }
+  if (data === void 0 && nodeType === "sleep" && mocks.fast === true) {
+    data = { wokeAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  if (data === void 0 || typeof data !== "object") return void 0;
+  const value = { onSuccess: true, onFailure: false, ...data };
+  validateWireValue(value);
+  return value;
+}
+var DurableGateYield = class extends Error {
+  constructor(gate, state, receipts, continuation) {
+    super(`Workflow yielded at ${gate.kind} gate "${gate.id}"`);
+    this.gate = gate;
+    this.state = state;
+    this.receipts = receipts;
+    this.continuation = continuation;
+    this.name = "DurableGateYield";
+  }
+  gate;
+  state;
+  receipts;
+  continuation;
+  code = "FLOW_WEAVER_DURABLE_GATE_YIELD";
+};
+var AmbiguousEffectError = class extends Error {
+  constructor(operationKey2, address) {
+    super(`Effect "${operationKey2}" has an ambiguous commit state`);
+    this.operationKey = operationKey2;
+    this.address = address;
+    this.name = "AmbiguousEffectError";
+  }
+  operationKey;
+  address;
+  code = "FLOW_WEAVER_AMBIGUOUS_EFFECT";
+};
+function durableAddressKey(address) {
+  return executionAddressKey(address);
+}
+function durableVariableKey(address, portName) {
+  return `${executionAddressKey(address)}\0${portName}`;
+}
+function cloneExecutionAddress(address) {
+  return {
+    frames: address.frames.map((frame) => ({ ...frame })),
+    scopes: address.scopes.map((scope) => ({ ...scope })),
+    branches: address.branches.map((branch) => ({ ...branch })),
+    nodeId: address.nodeId,
+    nodeType: address.nodeType,
+    executionIndex: address.executionIndex
+  };
+}
+function isCanonicalPrefix(candidate, current) {
+  return candidate.length <= current.length && canonicalWireValue(candidate) === canonicalWireValue(current.slice(0, candidate.length));
+}
+function isCanonicalEqual(left, right) {
+  return left.length === right.length && canonicalWireValue(left) === canonicalWireValue(right);
+}
+function requireEffectRecovery(value, key, address) {
+  try {
+    validateWireValue(value);
+  } catch {
+    throw new AmbiguousEffectError(key, address);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  const record = value;
+  const kind = record.kind;
+  if ((kind === "not-committed" || kind === "repeatable" || kind === "ambiguous") && Object.keys(record).length === 1) {
+    return { kind };
+  }
+  if (kind === "committed" && Object.keys(record).length === 3 && Object.prototype.hasOwnProperty.call(record, "receipt") && Object.prototype.hasOwnProperty.call(record, "result")) {
+    return {
+      kind,
+      receipt: record.receipt,
+      result: record.result
+    };
+  }
+  throw new AmbiguousEffectError(key, address);
+}
+function requireEffectExecution(value, key, address) {
+  try {
+    validateWireValue(value);
+  } catch {
+    throw new AmbiguousEffectError(key, address);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  const record = value;
+  if (Object.keys(record).length !== 2 || !Object.prototype.hasOwnProperty.call(record, "result") || !Object.prototype.hasOwnProperty.call(record, "receipt")) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  return {
+    result: record.result,
+    receipt: record.receipt
+  };
+}
+var DurableExecution = class {
+  constructor(runId, workflowId, continuation, resolution, bundleDigest) {
+    this.runId = runId;
+    this.workflowId = workflowId;
+    if (continuation !== void 0) {
+      assertAcceptedContinuation(continuation);
+      if (continuation.runId !== runId) {
+        throw new Error("accepted continuation belongs to another run");
+      }
+      if (continuation.workflowId !== workflowId) {
+        throw new Error("accepted continuation belongs to another workflow");
+      }
+    }
+    if (bundleDigest !== void 0 && !/^sha256:[0-9a-f]{64}$/.test(bundleDigest)) {
+      throw new Error("bundleDigest must use canonical sha256:<64hex> form");
+    }
+    this.givenBundleDigest = bundleDigest;
+    this.resumeEnvelope = continuation;
+    this.resolution = acceptGateResolution(resolution);
+    for (const address of continuation?.state.completed ?? []) {
+      this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));
+    }
+    for (const variable of continuation?.state.variables ?? []) {
+      this.variables.set(durableVariableKey(variable.address, variable.portName), {
+        address: cloneExecutionAddress(variable.address),
+        portName: variable.portName,
+        value: variable.value
+      });
+    }
+    for (const receipt of continuation?.receipts ?? []) {
+      this.receipts.set(durableAddressKey(receipt.address), {
+        address: cloneExecutionAddress(receipt.address),
+        operationKey: receipt.operationKey,
+        receipt: receipt.receipt
+      });
+    }
+  }
+  runId;
+  workflowId;
+  completed = /* @__PURE__ */ new Map();
+  variables = /* @__PURE__ */ new Map();
+  receipts = /* @__PURE__ */ new Map();
+  resumeEnvelope;
+  resolution;
+  givenBundleDigest;
+  graphFingerprint;
+  resolutionConsumed = false;
+  address(runtime, nodeId, nodeType, executionIndex) {
+    return {
+      frames: runtime.frames.map((frame) => ({ ...frame })),
+      scopes: runtime.scopes.map((scope) => ({ ...scope })),
+      branches: runtime.branches.map((branch) => ({ ...branch })),
+      nodeId,
+      nodeType,
+      executionIndex
+    };
+  }
+  /**
+   * The artifact identity this run executes under: the one the coordinator
+   * gave, or one derived from the graph identity the body declared. Known
+   * only after `bind`.
+   */
+  bundleDigest() {
+    if (this.givenBundleDigest !== void 0) return this.givenBundleDigest;
+    if (this.graphFingerprint === void 0) return void 0;
+    return `sha256:${sha256Hex(`flow-weaver-inline\0${this.workflowId}\0${this.graphFingerprint}\0${ENGINE_VERSION}`)}`;
+  }
+  bind(runtime, workflowId, graphFingerprint) {
+    if (runtime.frames.length !== 1) return;
+    if (workflowId !== this.workflowId) {
+      throw new Error(`runtime was created for workflow "${this.workflowId}" but "${workflowId}" is running on it`);
+    }
+    this.graphFingerprint = graphFingerprint;
+    if (this.resumeEnvelope === void 0) return;
+    if (this.resumeEnvelope.graphFingerprint !== graphFingerprint) {
+      const error = new Error("continuation belongs to another workflow graph");
+      error.name = "ContinuationMismatchError";
+      throw error;
+    }
+    const bundleDigest = this.bundleDigest();
+    if (bundleDigest !== void 0 && this.resumeEnvelope.bundleDigest !== bundleDigest) {
+      const error = new Error("continuation belongs to another bundle");
+      error.name = "ContinuationMismatchError";
+      throw error;
+    }
+  }
+  shouldExecute(address) {
+    return !this.completed.has(durableAddressKey(address));
+  }
+  commitNode(address) {
+    this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));
+  }
+  setVariable(address, portName, value) {
+    this.variables.set(durableVariableKey(address, portName), {
+      address: cloneExecutionAddress(address),
+      portName,
+      value
+    });
+  }
+  getVariable(address, portName, allowAncestorLookup = true) {
+    const exact = this.variables.get(durableVariableKey(address, portName));
+    if (exact !== void 0) return exact.value;
+    if (!allowAncestorLookup) return void 0;
+    const candidates = [...this.variables.values()].filter(
+      (variable) => variable.portName === portName && variable.address.nodeId === address.nodeId && variable.address.nodeType === address.nodeType && variable.address.executionIndex === address.executionIndex && isCanonicalPrefix(variable.address.frames, address.frames) && isCanonicalPrefix(variable.address.scopes, address.scopes) && isCanonicalPrefix(variable.address.branches, address.branches)
+    ).sort(
+      (left, right) => right.address.frames.length + right.address.scopes.length + right.address.branches.length - (left.address.frames.length + left.address.scopes.length + left.address.branches.length)
+    );
+    const specificity = (candidate) => candidate.address.frames.length + candidate.address.scopes.length + candidate.address.branches.length;
+    if (candidates.length > 1 && specificity(candidates[0]) === specificity(candidates[1])) {
+      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);
+    }
+    if (candidates[0] !== void 0) return candidates[0].value;
+    const converged = [...this.variables.values()].filter(
+      (variable) => variable.portName === portName && variable.address.nodeId === address.nodeId && variable.address.nodeType === address.nodeType && variable.address.executionIndex === address.executionIndex && isCanonicalEqual(variable.address.frames, address.frames) && isCanonicalEqual(variable.address.scopes, address.scopes) && isCanonicalPrefix(address.branches, variable.address.branches)
+    );
+    if (converged.length > 1) {
+      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);
+    }
+    return converged[0]?.value;
+  }
+  resolveGate(runtime, boundary) {
+    validateWireValue(boundary.payload);
+    const mocked = mockedGateAnswer(runtime.services.mocks, boundary);
+    if (mocked !== void 0) return mocked;
+    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);
+    const id = durableGateId(this.runId, boundary.kind, address);
+    if (this.resumeEnvelope !== void 0 && !this.resolutionConsumed) {
+      if (durableAddressKey(this.resumeEnvelope.location) !== durableAddressKey(address) || this.resumeEnvelope.gateId !== id || this.resumeEnvelope.gateKind !== boundary.kind || this.resolution === void 0 || this.resolution.gateId !== id) {
+        const error = new Error("Gate resolution is stale, reordered, or does not match the resume boundary");
+        error.name = "StaleGateError";
+        throw error;
+      }
+      validateWireValue(this.resolution.value);
+      this.resolutionConsumed = true;
+      return this.resolution.value;
+    }
+    if (this.resumeEnvelope !== void 0 && durableAddressKey(this.resumeEnvelope.location) === durableAddressKey(address)) {
+      const error = new Error("The consumed resume gate was re-entered");
+      error.name = "StaleGateError";
+      throw error;
+    }
+    const gate = {
+      id,
+      kind: boundary.kind,
+      address,
+      payload: boundary.payload
+    };
+    const state = this.snapshot(address);
+    const receipts = [...this.receipts.values()];
+    const bundleDigest = this.bundleDigest();
+    const continuation = this.graphFingerprint === void 0 || bundleDigest === void 0 ? void 0 : createContinuationEnvelope({
+      runId: this.runId,
+      gateId: id,
+      gateKind: boundary.kind,
+      workflowId: this.workflowId,
+      bundleDigest,
+      graphFingerprint: this.graphFingerprint,
+      location: address,
+      state,
+      receipts
+    });
+    throw new DurableGateYield(gate, state, receipts, continuation);
+  }
+  async executeEffect(runtime, boundary, execute) {
+    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);
+    const key = operationKey(this.runId, address);
+    const committed = this.receipts.get(durableAddressKey(address));
+    if (committed !== void 0) {
+      throw new Error(`Committed effect "${key}" reached its execution body`);
+    }
+    let recovery;
+    try {
+      recovery = await runtime.services.effectAdapter?.recover(key, address);
+    } catch {
+      throw new AmbiguousEffectError(key, address);
+    }
+    if (recovery === void 0) {
+      throw new AmbiguousEffectError(key, address);
+    }
+    recovery = requireEffectRecovery(recovery, key, address);
+    if (recovery.kind === "ambiguous") throw new AmbiguousEffectError(key, address);
+    if (recovery.kind === "committed") {
+      this.receipts.set(durableAddressKey(address), {
+        address: cloneExecutionAddress(address),
+        operationKey: key,
+        receipt: recovery.receipt
+      });
+      return recovery.result;
+    }
+    let executed;
+    try {
+      executed = requireEffectExecution(await execute(key), key, address);
+    } catch (error) {
+      let afterFailure;
+      try {
+        afterFailure = await runtime.services.effectAdapter?.recover(key, address) ?? { kind: "ambiguous" };
+      } catch {
+        throw new AmbiguousEffectError(key, address);
+      }
+      afterFailure = requireEffectRecovery(afterFailure, key, address);
+      if (afterFailure.kind === "committed") {
+        this.receipts.set(durableAddressKey(address), {
+          address: cloneExecutionAddress(address),
+          operationKey: key,
+          receipt: afterFailure.receipt
+        });
+        return afterFailure.result;
+      }
+      if (afterFailure.kind === "ambiguous") {
+        throw new AmbiguousEffectError(key, address);
+      }
+      throw error;
+    }
+    if (runtime.services.effectAdapter?.commit !== void 0) {
+      try {
+        await runtime.services.effectAdapter.commit(key, address, executed);
+      } catch {
+        let committed2;
+        try {
+          committed2 = requireEffectRecovery(
+            await runtime.services.effectAdapter.recover(key, address),
+            key,
+            address
+          );
+        } catch {
+          throw new AmbiguousEffectError(key, address);
+        }
+        if (committed2.kind !== "committed" || canonicalWireValue(committed2.receipt) !== canonicalWireValue(executed.receipt) || canonicalWireValue(committed2.result) !== canonicalWireValue(executed.result)) throw new AmbiguousEffectError(key, address);
+        this.receipts.set(durableAddressKey(address), {
+          address: cloneExecutionAddress(address),
+          operationKey: key,
+          receipt: committed2.receipt
+        });
+        return committed2.result;
+      }
+    }
+    this.receipts.set(durableAddressKey(address), {
+      address: cloneExecutionAddress(address),
+      operationKey: key,
+      receipt: executed.receipt
+    });
+    return executed.result;
+  }
+  snapshot(nextBoundary) {
+    const completedKeys = new Set(this.completed.keys());
+    return {
+      completed: [...this.completed.values()].map(cloneExecutionAddress),
+      variables: [...this.variables.values()].filter((variable) => completedKeys.has(durableAddressKey(variable.address))).map((variable) => {
+        try {
+          validateWireValue(variable.value);
+        } catch (error) {
+          throw new Error(
+            `Continuation variable ${variable.address.nodeId}.${variable.portName} is not a wire value: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        return {
+          address: cloneExecutionAddress(variable.address),
+          portName: variable.portName,
+          value: variable.value
+        };
+      }),
+      nextBoundary: cloneExecutionAddress(nextBoundary)
+    };
+  }
+  assertResumeResolutionConsumed() {
+    if (this.resumeEnvelope !== void 0 && !this.resolutionConsumed) {
+      const error = new Error("Resumed execution completed or yielded without consuming its exact gate resolution");
+      error.name = "UnconsumedGateResolutionError";
+      throw error;
+    }
+  }
+};
+function createWorkflowRuntime(options) {
+  if (options.runId.trim().length === 0) {
+    throw new Error("runId must be a non-empty coordinator-owned identity");
+  }
+  const rootFrame = {
+    workflowId: options.workflowId,
+    invocation: 0
+  };
+  return {
+    runId: options.runId,
+    abortSignal: options.abortSignal,
+    services: options.services ?? {},
+    durable: new DurableExecution(
+      options.runId,
+      options.workflowId,
+      options.continuation,
+      options.resolution,
+      options.bundleDigest
+    ),
+    frames: [rootFrame],
+    scopes: [],
+    branches: []
+  };
+}
+function isDurableGateYield(error) {
+  return error instanceof DurableGateYield || typeof error === "object" && error !== null && error.code === "FLOW_WEAVER_DURABLE_GATE_YIELD";
+}
+function isAmbiguousEffectError(error) {
+  return error instanceof AmbiguousEffectError || typeof error === "object" && error !== null && error.code === "FLOW_WEAVER_AMBIGUOUS_EFFECT";
+}
+
+export {
+  acceptGateResolution,
+  DurableGateYield,
+  AmbiguousEffectError,
+  requireEffectRecovery,
+  DurableExecution,
+  createWorkflowRuntime,
+  isDurableGateYield,
+  isAmbiguousEffectError
+};

package/dist/chunks/chunk-OZQAW5ZG.js

@@ -0,0 +1,112 @@
+// src/console/schema.ts
+import * as fs from "node:fs";
+import { Project } from "ts-morph";
+var MAX_DEPTH = 4;
+var project;
+var loaded = /* @__PURE__ */ new Map();
+function source(file) {
+  project ??= new Project({ compilerOptions: { strict: true, skipLibCheck: true }, skipAddingFilesFromTsConfig: true });
+  const mtime = fs.statSync(file).mtimeMs;
+  const existing = project.getSourceFile(file);
+  if (existing && loaded.get(file) === mtime) return existing;
+  if (existing) existing.refreshFromFileSystemSync();
+  const sf = existing ?? project.addSourceFileAtPath(file);
+  loaded.set(file, mtime);
+  return sf;
+}
+function toSchema(t, depth = 0) {
+  if (depth > MAX_DEPTH) return { type: "any", text: t.getText() };
+  if (t.isBoolean()) return { type: "boolean" };
+  if (t.isUnion()) {
+    const parts = t.getUnionTypes();
+    const real = parts.filter((p) => !p.isNull() && !p.isUndefined());
+    const optional = real.length !== parts.length;
+    if (real.length && real.every((p) => p.isBooleanLiteral())) return { type: "boolean", optional };
+    if (real.length && real.every((p) => p.isStringLiteral() || p.isNumberLiteral()))
+      return { type: "enum", values: real.map((p) => p.getLiteralValue()), optional };
+    if (real.length === 1) return { ...toSchema(real[0], depth), optional };
+    return { type: "any", text: t.getText(), optional };
+  }
+  if (t.isString()) return { type: "string" };
+  if (t.isNumber()) return { type: "number" };
+  if (t.isStringLiteral() || t.isNumberLiteral()) return { type: "enum", values: [t.getLiteralValue()] };
+  if (t.isArray()) return { type: "array", items: toSchema(t.getArrayElementTypeOrThrow(), depth + 1), text: t.getText() };
+  if (t.isObject()) {
+    const props = t.getProperties();
+    if (!props.length || t.getStringIndexType()) return { type: "object", text: t.getText() };
+    const fields = {};
+    for (const p of props) {
+      const decl = p.getDeclarations()[0];
+      const s = decl ? toSchema(p.getTypeAtLocation(decl), depth + 1) : { type: "any" };
+      fields[p.getName()] = { ...s, optional: s.optional || p.isOptional() };
+    }
+    return { type: "object", fields, text: t.getText() };
+  }
+  return { type: "any", text: t.getText() };
+}
+function gateOutputSchemas(ast, gateId, fallbackFile) {
+  const typeOf = (id) => {
+    const inst = ast.instances.find((i) => i.id === id);
+    return inst ? ast.nodeTypes.find((n) => n.name === inst.nodeType) ?? ast.nodeTypes.find((n) => n.functionName === inst.nodeType) : void 0;
+  };
+  const nt = typeOf(gateId);
+  const nodeFile = nt?.sourceLocation?.file ?? fallbackFile;
+  if (nt?.functionText) {
+    const own = nodeOutputSchema(nodeFile, nt.functionName);
+    if (own && Object.keys(own).length) return own;
+  }
+  const control = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+  const out = {};
+  for (const conn of ast.connections) {
+    if (conn.from.node !== gateId || control.has(conn.from.port)) continue;
+    const targetType = typeOf(conn.to.node);
+    if (!targetType?.functionText) continue;
+    const schema = nodeInputSchema(targetType.sourceLocation?.file ?? fallbackFile, targetType.functionName, conn.to.port);
+    if (schema) out[conn.from.port] = schema;
+  }
+  return Object.keys(out).length ? out : null;
+}
+function workflowParamsSchema(file, fnName) {
+  try {
+    const params = source(file).getFunction(fnName)?.getParameters()[1]?.getType();
+    if (!params) return null;
+    const s = toSchema(params);
+    return s.type === "object" && s.fields ? s.fields : null;
+  } catch {
+    return null;
+  }
+}
+function nodeInputSchema(file, fnName, paramName) {
+  try {
+    const fn = source(file).getFunction(fnName);
+    if (!fn) return null;
+    const params = fn.getParameters();
+    const param = params.find((p) => p.getName() === paramName);
+    if (!param) return null;
+    const s = toSchema(param.getType());
+    return { ...s, optional: s.optional || param.hasQuestionToken() };
+  } catch {
+    return null;
+  }
+}
+function nodeOutputSchema(file, fnName) {
+  try {
+    const fn = source(file).getFunction(fnName);
+    if (!fn) return null;
+    let ret = fn.getReturnType();
+    if (ret.getSymbol()?.getName() === "Promise") ret = ret.getTypeArguments()[0];
+    const s = toSchema(ret);
+    if (s.type !== "object" || !s.fields) return null;
+    const { onSuccess: _s, onFailure: _f, ...data } = s.fields;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  gateOutputSchemas,
+  workflowParamsSchema,
+  nodeInputSchema,
+  nodeOutputSchema
+};