@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-6KMVP6AU.js

@@ -0,0 +1,20 @@
+// src/runtime/CancellationError.ts
+var CancellationError = class _CancellationError extends Error {
+  constructor(message = "Workflow execution cancelled", executionIndex = 0, nodeId, timestamp = Date.now()) {
+    super(message);
+    this.executionIndex = executionIndex;
+    this.nodeId = nodeId;
+    this.timestamp = timestamp;
+    this.name = "CancellationError";
+  }
+  executionIndex;
+  nodeId;
+  timestamp;
+  static isCancellationError(error) {
+    return error instanceof _CancellationError || error instanceof Error && error.name === "CancellationError";
+  }
+};
+
+export {
+  CancellationError
+};

package/dist/chunks/chunk-6PNJORFL.js

@@ -0,0 +1,128 @@
+import {
+  DurableSourceProof,
+  applyDurableSourceProof,
+  compileWorkflow
+} from "./chunk-F3RTZV2A.js";
+import {
+  getAvailableWorkflows
+} from "./chunk-YSPBPZDV.js";
+import {
+  EXECUTABLE_WORKFLOW_METADATA_EXPORT,
+  EXECUTABLE_WORKFLOW_MODULE_FORMAT
+} from "./chunk-QJDAVSNY.js";
+import {
+  graphIdentity
+} from "./chunk-TAIUWKZB.js";
+import {
+  parseWorkflow,
+  parseWorkflowSourceAtPath
+} from "./chunk-INDEVYEC.js";
+import {
+  validateDurableClosure
+} from "./chunk-KU3CLJI2.js";
+import {
+  GENERATOR_ABI
+} from "./chunk-O2U2LO57.js";
+
+// src/compiler/executable-artifact.ts
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import * as ts from "typescript";
+async function compileExecutableWorkflowArtifact(request) {
+  if (request.workflowName.trim().length === 0) {
+    throw new Error("workflowName must be non-empty");
+  }
+  const workflows = getAvailableWorkflows(request.source);
+  if (!workflows.some((workflow) => workflow.functionName === request.workflowName)) {
+    throw new Error(`Workflow ${request.workflowName} is not declared by the artifact source`);
+  }
+  const directory = await mkdtemp(join(tmpdir(), "flow-weaver-artifact-"));
+  const filePath = join(directory, "workflow.ts");
+  try {
+    const durableSourceProof = request.durableValidationSource === void 0 ? void 0 : DurableSourceProof.create(
+      await parseWorkflowSourceAtPath(
+        request.durableValidationSource.sourcePath,
+        request.durableValidationSource.source,
+        {
+          workflowName: request.workflowName,
+          ...request.externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...request.externalNodeTypes] },
+          ...request.durableValidationSource.resolveImport === void 0 ? {} : { sourceImportResolver: request.durableValidationSource.resolveImport },
+          ...request.durableValidationSource.loadSource === void 0 ? {} : { sourceOverrideLoader: request.durableValidationSource.loadSource }
+        }
+      ),
+      request.durableValidationSource.source
+    );
+    await writeFile(filePath, request.source, { encoding: "utf8", mode: 384 });
+    const metadata = await createExecutableWorkflowMetadata(
+      filePath,
+      request.workflowName,
+      request.externalNodeTypes,
+      durableSourceProof,
+      request.source
+    );
+    for (const workflow of workflows) {
+      await compileWorkflow(filePath, {
+        write: true,
+        inPlace: true,
+        parse: {
+          workflowName: workflow.functionName,
+          ...request.externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...request.externalNodeTypes] }
+        },
+        // The deployed artifact keeps step instrumentation. A runtime may
+        // choose not to subscribe, but it must be able to report steps.
+        generate: { production: false },
+        ...durableSourceProof === void 0 ? {} : {
+          durableSourceProof,
+          durableFlattenedSource: request.source
+        }
+      });
+    }
+    const generated = await readFile(filePath, "utf8");
+    const transpiled = ts.transpileModule(generated, {
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ESNext,
+        esModuleInterop: true
+      }
+    }).outputText;
+    const metadataExport = `
+export const ${EXECUTABLE_WORKFLOW_METADATA_EXPORT} = Object.freeze(${JSON.stringify(metadata)});
+`;
+    return Object.freeze({
+      formatVersion: 1,
+      workflowName: request.workflowName,
+      code: `${transpiled}${metadataExport}`
+    });
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+async function createExecutableWorkflowMetadata(filePath, workflowName, externalNodeTypes, durableSourceProof, flattenedSource) {
+  const parsed = await parseWorkflow(filePath, {
+    workflowName,
+    projectDir: dirname(filePath),
+    ...externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...externalNodeTypes] }
+  });
+  if (parsed.errors.length > 0) {
+    throw new Error(`Cannot emit executable artifact metadata: ${parsed.errors.join("; ")}`);
+  }
+  if (durableSourceProof !== void 0) {
+    applyDurableSourceProof(durableSourceProof, parsed, flattenedSource);
+  }
+  validateDurableClosure(parsed.ast, parsed.allWorkflows);
+  const { graphFingerprint, continuationGraph, capabilities } = graphIdentity(parsed.ast, parsed.allWorkflows);
+  return Object.freeze({
+    formatVersion: EXECUTABLE_WORKFLOW_MODULE_FORMAT,
+    generatorAbi: GENERATOR_ABI,
+    workflowName,
+    workflowNames: parsed.allWorkflows.map((workflow) => workflow.functionName).sort(),
+    graphFingerprint,
+    continuationGraph,
+    capabilities
+  });
+}
+
+export {
+  compileExecutableWorkflowArtifact
+};