@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-V6DHWFQG.mjs

@@ -0,0 +1,2811 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  INLINE_ENGINE_EXPORTS,
+  bodyGenerator,
+  extractExitPorts,
+  generateInPlace,
+  generateInlineRuntime,
+  graphIdentity,
+  hasBranching,
+  stripTypeScript,
+  validateWorkflowAsync
+} from "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import {
+  VERSION
+} from "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  validateDurableClosure
+} from "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import {
+  mapToTypeScript
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./flow-weaver-chunk-N767YRAI.mjs";
+
+// node_modules/source-map/lib/base64.js
+var require_base64 = __commonJS({
+  "node_modules/source-map/lib/base64.js"(exports) {
+    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    exports.encode = function(number) {
+      if (0 <= number && number < intToCharMap.length) {
+        return intToCharMap[number];
+      }
+      throw new TypeError("Must be between 0 and 63: " + number);
+    };
+  }
+});
+
+// node_modules/source-map/lib/base64-vlq.js
+var require_base64_vlq = __commonJS({
+  "node_modules/source-map/lib/base64-vlq.js"(exports) {
+    var base64 = require_base64();
+    var VLQ_BASE_SHIFT = 5;
+    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+    var VLQ_BASE_MASK = VLQ_BASE - 1;
+    var VLQ_CONTINUATION_BIT = VLQ_BASE;
+    function toVLQSigned(aValue) {
+      return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
+    }
+    exports.encode = function base64VLQ_encode(aValue) {
+      let encoded = "";
+      let digit;
+      let vlq = toVLQSigned(aValue);
+      do {
+        digit = vlq & VLQ_BASE_MASK;
+        vlq >>>= VLQ_BASE_SHIFT;
+        if (vlq > 0) {
+          digit |= VLQ_CONTINUATION_BIT;
+        }
+        encoded += base64.encode(digit);
+      } while (vlq > 0);
+      return encoded;
+    };
+  }
+});
+
+// node_modules/source-map/lib/url.js
+var require_url = __commonJS({
+  "node_modules/source-map/lib/url.js"(exports, module) {
+    "use strict";
+    module.exports = typeof URL === "function" ? URL : __require("url").URL;
+  }
+});
+
+// node_modules/source-map/lib/util.js
+var require_util = __commonJS({
+  "node_modules/source-map/lib/util.js"(exports) {
+    var URL2 = require_url();
+    function getArg(aArgs, aName, aDefaultValue) {
+      if (aName in aArgs) {
+        return aArgs[aName];
+      } else if (arguments.length === 3) {
+        return aDefaultValue;
+      }
+      throw new Error('"' + aName + '" is a required argument.');
+    }
+    exports.getArg = getArg;
+    var supportsNullProto = (function() {
+      const obj = /* @__PURE__ */ Object.create(null);
+      return !("__proto__" in obj);
+    })();
+    function identity(s) {
+      return s;
+    }
+    function toSetString(aStr) {
+      if (isProtoString(aStr)) {
+        return "$" + aStr;
+      }
+      return aStr;
+    }
+    exports.toSetString = supportsNullProto ? identity : toSetString;
+    function fromSetString(aStr) {
+      if (isProtoString(aStr)) {
+        return aStr.slice(1);
+      }
+      return aStr;
+    }
+    exports.fromSetString = supportsNullProto ? identity : fromSetString;
+    function isProtoString(s) {
+      if (!s) {
+        return false;
+      }
+      const length = s.length;
+      if (length < 9) {
+        return false;
+      }
+      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+        return false;
+      }
+      for (let i = length - 10; i >= 0; i--) {
+        if (s.charCodeAt(i) !== 36) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function strcmp(aStr1, aStr2) {
+      if (aStr1 === aStr2) {
+        return 0;
+      }
+      if (aStr1 === null) {
+        return 1;
+      }
+      if (aStr2 === null) {
+        return -1;
+      }
+      if (aStr1 > aStr2) {
+        return 1;
+      }
+      return -1;
+    }
+    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+      let cmp = mappingA.generatedLine - mappingB.generatedLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = strcmp(mappingA.source, mappingB.source);
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+    function parseSourceMapInput(str) {
+      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+    }
+    exports.parseSourceMapInput = parseSourceMapInput;
+    var PROTOCOL = "http:";
+    var PROTOCOL_AND_HOST = `${PROTOCOL}//host`;
+    function createSafeHandler(cb) {
+      return (input) => {
+        const type = getURLType(input);
+        const base = buildSafeBase(input);
+        const url = new URL2(input, base);
+        cb(url);
+        const result = url.toString();
+        if (type === "absolute") {
+          return result;
+        } else if (type === "scheme-relative") {
+          return result.slice(PROTOCOL.length);
+        } else if (type === "path-absolute") {
+          return result.slice(PROTOCOL_AND_HOST.length);
+        }
+        return computeRelativeURL(base, result);
+      };
+    }
+    function withBase(url, base) {
+      return new URL2(url, base).toString();
+    }
+    function buildUniqueSegment(prefix, str) {
+      let id = 0;
+      do {
+        const ident = prefix + id++;
+        if (str.indexOf(ident) === -1) return ident;
+      } while (true);
+    }
+    function buildSafeBase(str) {
+      const maxDotParts = str.split("..").length - 1;
+      const segment = buildUniqueSegment("p", str);
+      let base = `${PROTOCOL_AND_HOST}/`;
+      for (let i = 0; i < maxDotParts; i++) {
+        base += `${segment}/`;
+      }
+      return base;
+    }
+    var ABSOLUTE_SCHEME = /^[A-Za-z0-9\+\-\.]+:/;
+    function getURLType(url) {
+      if (url[0] === "/") {
+        if (url[1] === "/") return "scheme-relative";
+        return "path-absolute";
+      }
+      return ABSOLUTE_SCHEME.test(url) ? "absolute" : "path-relative";
+    }
+    function computeRelativeURL(rootURL, targetURL) {
+      if (typeof rootURL === "string") rootURL = new URL2(rootURL);
+      if (typeof targetURL === "string") targetURL = new URL2(targetURL);
+      const targetParts = targetURL.pathname.split("/");
+      const rootParts = rootURL.pathname.split("/");
+      if (rootParts.length > 0 && !rootParts[rootParts.length - 1]) {
+        rootParts.pop();
+      }
+      while (targetParts.length > 0 && rootParts.length > 0 && targetParts[0] === rootParts[0]) {
+        targetParts.shift();
+        rootParts.shift();
+      }
+      const relativePath = rootParts.map(() => "..").concat(targetParts).join("/");
+      return relativePath + targetURL.search + targetURL.hash;
+    }
+    var ensureDirectory = createSafeHandler((url) => {
+      url.pathname = url.pathname.replace(/\/?$/, "/");
+    });
+    var trimFilename = createSafeHandler((url) => {
+      url.href = new URL2(".", url.toString()).toString();
+    });
+    var normalize = createSafeHandler((url) => {
+    });
+    exports.normalize = normalize;
+    function join2(aRoot, aPath) {
+      const pathType = getURLType(aPath);
+      const rootType = getURLType(aRoot);
+      aRoot = ensureDirectory(aRoot);
+      if (pathType === "absolute") {
+        return withBase(aPath, void 0);
+      }
+      if (rootType === "absolute") {
+        return withBase(aPath, aRoot);
+      }
+      if (pathType === "scheme-relative") {
+        return normalize(aPath);
+      }
+      if (rootType === "scheme-relative") {
+        return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(
+          PROTOCOL.length
+        );
+      }
+      if (pathType === "path-absolute") {
+        return normalize(aPath);
+      }
+      if (rootType === "path-absolute") {
+        return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(
+          PROTOCOL_AND_HOST.length
+        );
+      }
+      const base = buildSafeBase(aPath + aRoot);
+      const newPath = withBase(aPath, withBase(aRoot, base));
+      return computeRelativeURL(base, newPath);
+    }
+    exports.join = join2;
+    function relative(rootURL, targetURL) {
+      const result = relativeIfPossible(rootURL, targetURL);
+      return typeof result === "string" ? result : normalize(targetURL);
+    }
+    exports.relative = relative;
+    function relativeIfPossible(rootURL, targetURL) {
+      const urlType = getURLType(rootURL);
+      if (urlType !== getURLType(targetURL)) {
+        return null;
+      }
+      const base = buildSafeBase(rootURL + targetURL);
+      const root = new URL2(rootURL, base);
+      const target = new URL2(targetURL, base);
+      try {
+        new URL2("", target.toString());
+      } catch (err) {
+        return null;
+      }
+      if (target.protocol !== root.protocol || target.user !== root.user || target.password !== root.password || target.hostname !== root.hostname || target.port !== root.port) {
+        return null;
+      }
+      return computeRelativeURL(root, target);
+    }
+    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+      if (sourceRoot && getURLType(sourceURL) === "path-absolute") {
+        sourceURL = sourceURL.replace(/^\//, "");
+      }
+      let url = normalize(sourceURL || "");
+      if (sourceRoot) url = join2(sourceRoot, url);
+      if (sourceMapURL) url = join2(trimFilename(sourceMapURL), url);
+      return url;
+    }
+    exports.computeSourceURL = computeSourceURL;
+  }
+});
+
+// node_modules/source-map/lib/array-set.js
+var require_array_set = __commonJS({
+  "node_modules/source-map/lib/array-set.js"(exports) {
+    var ArraySet = class _ArraySet {
+      constructor() {
+        this._array = [];
+        this._set = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Static method for creating ArraySet instances from an existing array.
+       */
+      static fromArray(aArray, aAllowDuplicates) {
+        const set = new _ArraySet();
+        for (let i = 0, len = aArray.length; i < len; i++) {
+          set.add(aArray[i], aAllowDuplicates);
+        }
+        return set;
+      }
+      /**
+       * Return how many unique items are in this ArraySet. If duplicates have been
+       * added, than those do not count towards the size.
+       *
+       * @returns Number
+       */
+      size() {
+        return this._set.size;
+      }
+      /**
+       * Add the given string to this set.
+       *
+       * @param String aStr
+       */
+      add(aStr, aAllowDuplicates) {
+        const isDuplicate = this.has(aStr);
+        const idx = this._array.length;
+        if (!isDuplicate || aAllowDuplicates) {
+          this._array.push(aStr);
+        }
+        if (!isDuplicate) {
+          this._set.set(aStr, idx);
+        }
+      }
+      /**
+       * Is the given string a member of this set?
+       *
+       * @param String aStr
+       */
+      has(aStr) {
+        return this._set.has(aStr);
+      }
+      /**
+       * What is the index of the given string in the array?
+       *
+       * @param String aStr
+       */
+      indexOf(aStr) {
+        const idx = this._set.get(aStr);
+        if (idx >= 0) {
+          return idx;
+        }
+        throw new Error('"' + aStr + '" is not in the set.');
+      }
+      /**
+       * What is the element at the given index?
+       *
+       * @param Number aIdx
+       */
+      at(aIdx) {
+        if (aIdx >= 0 && aIdx < this._array.length) {
+          return this._array[aIdx];
+        }
+        throw new Error("No element indexed by " + aIdx);
+      }
+      /**
+       * Returns the array representation of this set (which has the proper indices
+       * indicated by indexOf). Note that this is a copy of the internal array used
+       * for storing the members so that no one can mess with internal state.
+       */
+      toArray() {
+        return this._array.slice();
+      }
+    };
+    exports.ArraySet = ArraySet;
+  }
+});
+
+// node_modules/source-map/lib/mapping-list.js
+var require_mapping_list = __commonJS({
+  "node_modules/source-map/lib/mapping-list.js"(exports) {
+    var util = require_util();
+    function generatedPositionAfter(mappingA, mappingB) {
+      const lineA = mappingA.generatedLine;
+      const lineB = mappingB.generatedLine;
+      const columnA = mappingA.generatedColumn;
+      const columnB = mappingB.generatedColumn;
+      return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+    }
+    var MappingList = class {
+      constructor() {
+        this._array = [];
+        this._sorted = true;
+        this._last = { generatedLine: -1, generatedColumn: 0 };
+      }
+      /**
+       * Iterate through internal items. This method takes the same arguments that
+       * `Array.prototype.forEach` takes.
+       *
+       * NOTE: The order of the mappings is NOT guaranteed.
+       */
+      unsortedForEach(aCallback, aThisArg) {
+        this._array.forEach(aCallback, aThisArg);
+      }
+      /**
+       * Add the given source mapping.
+       *
+       * @param Object aMapping
+       */
+      add(aMapping) {
+        if (generatedPositionAfter(this._last, aMapping)) {
+          this._last = aMapping;
+          this._array.push(aMapping);
+        } else {
+          this._sorted = false;
+          this._array.push(aMapping);
+        }
+      }
+      /**
+       * Returns the flat, sorted array of mappings. The mappings are sorted by
+       * generated position.
+       *
+       * WARNING: This method returns internal data without copying, for
+       * performance. The return value must NOT be mutated, and should be treated as
+       * an immutable borrow. If you want to take ownership, you must make your own
+       * copy.
+       */
+      toArray() {
+        if (!this._sorted) {
+          this._array.sort(util.compareByGeneratedPositionsInflated);
+          this._sorted = true;
+        }
+        return this._array;
+      }
+    };
+    exports.MappingList = MappingList;
+  }
+});
+
+// node_modules/source-map/lib/source-map-generator.js
+var require_source_map_generator = __commonJS({
+  "node_modules/source-map/lib/source-map-generator.js"(exports) {
+    var base64VLQ = require_base64_vlq();
+    var util = require_util();
+    var ArraySet = require_array_set().ArraySet;
+    var MappingList = require_mapping_list().MappingList;
+    var SourceMapGenerator2 = class _SourceMapGenerator {
+      constructor(aArgs) {
+        if (!aArgs) {
+          aArgs = {};
+        }
+        this._file = util.getArg(aArgs, "file", null);
+        this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
+        this._skipValidation = util.getArg(aArgs, "skipValidation", false);
+        this._sources = new ArraySet();
+        this._names = new ArraySet();
+        this._mappings = new MappingList();
+        this._sourcesContents = null;
+      }
+      /**
+       * Creates a new SourceMapGenerator based on a SourceMapConsumer
+       *
+       * @param aSourceMapConsumer The SourceMap.
+       */
+      static fromSourceMap(aSourceMapConsumer) {
+        const sourceRoot = aSourceMapConsumer.sourceRoot;
+        const generator = new _SourceMapGenerator({
+          file: aSourceMapConsumer.file,
+          sourceRoot
+        });
+        aSourceMapConsumer.eachMapping(function(mapping) {
+          const newMapping = {
+            generated: {
+              line: mapping.generatedLine,
+              column: mapping.generatedColumn
+            }
+          };
+          if (mapping.source != null) {
+            newMapping.source = mapping.source;
+            if (sourceRoot != null) {
+              newMapping.source = util.relative(sourceRoot, newMapping.source);
+            }
+            newMapping.original = {
+              line: mapping.originalLine,
+              column: mapping.originalColumn
+            };
+            if (mapping.name != null) {
+              newMapping.name = mapping.name;
+            }
+          }
+          generator.addMapping(newMapping);
+        });
+        aSourceMapConsumer.sources.forEach(function(sourceFile) {
+          let sourceRelative = sourceFile;
+          if (sourceRoot != null) {
+            sourceRelative = util.relative(sourceRoot, sourceFile);
+          }
+          if (!generator._sources.has(sourceRelative)) {
+            generator._sources.add(sourceRelative);
+          }
+          const content = aSourceMapConsumer.sourceContentFor(sourceFile);
+          if (content != null) {
+            generator.setSourceContent(sourceFile, content);
+          }
+        });
+        return generator;
+      }
+      /**
+       * Add a single mapping from original source line and column to the generated
+       * source's line and column for this source map being created. The mapping
+       * object should have the following properties:
+       *
+       *   - generated: An object with the generated line and column positions.
+       *   - original: An object with the original line and column positions.
+       *   - source: The original source file (relative to the sourceRoot).
+       *   - name: An optional original token name for this mapping.
+       */
+      addMapping(aArgs) {
+        const generated = util.getArg(aArgs, "generated");
+        const original = util.getArg(aArgs, "original", null);
+        let source = util.getArg(aArgs, "source", null);
+        let name = util.getArg(aArgs, "name", null);
+        if (!this._skipValidation) {
+          this._validateMapping(generated, original, source, name);
+        }
+        if (source != null) {
+          source = String(source);
+          if (!this._sources.has(source)) {
+            this._sources.add(source);
+          }
+        }
+        if (name != null) {
+          name = String(name);
+          if (!this._names.has(name)) {
+            this._names.add(name);
+          }
+        }
+        this._mappings.add({
+          generatedLine: generated.line,
+          generatedColumn: generated.column,
+          originalLine: original && original.line,
+          originalColumn: original && original.column,
+          source,
+          name
+        });
+      }
+      /**
+       * Set the source content for a source file.
+       */
+      setSourceContent(aSourceFile, aSourceContent) {
+        let source = aSourceFile;
+        if (this._sourceRoot != null) {
+          source = util.relative(this._sourceRoot, source);
+        }
+        if (aSourceContent != null) {
+          if (!this._sourcesContents) {
+            this._sourcesContents = /* @__PURE__ */ Object.create(null);
+          }
+          this._sourcesContents[util.toSetString(source)] = aSourceContent;
+        } else if (this._sourcesContents) {
+          delete this._sourcesContents[util.toSetString(source)];
+          if (Object.keys(this._sourcesContents).length === 0) {
+            this._sourcesContents = null;
+          }
+        }
+      }
+      /**
+       * Applies the mappings of a sub-source-map for a specific source file to the
+       * source map being generated. Each mapping to the supplied source file is
+       * rewritten using the supplied source map. Note: The resolution for the
+       * resulting mappings is the minimium of this map and the supplied map.
+       *
+       * @param aSourceMapConsumer The source map to be applied.
+       * @param aSourceFile Optional. The filename of the source file.
+       *        If omitted, SourceMapConsumer's file property will be used.
+       * @param aSourceMapPath Optional. The dirname of the path to the source map
+       *        to be applied. If relative, it is relative to the SourceMapConsumer.
+       *        This parameter is needed when the two source maps aren't in the same
+       *        directory, and the source map to be applied contains relative source
+       *        paths. If so, those relative source paths need to be rewritten
+       *        relative to the SourceMapGenerator.
+       */
+      applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+        let sourceFile = aSourceFile;
+        if (aSourceFile == null) {
+          if (aSourceMapConsumer.file == null) {
+            throw new Error(
+              `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
+            );
+          }
+          sourceFile = aSourceMapConsumer.file;
+        }
+        const sourceRoot = this._sourceRoot;
+        if (sourceRoot != null) {
+          sourceFile = util.relative(sourceRoot, sourceFile);
+        }
+        const newSources = this._mappings.toArray().length > 0 ? new ArraySet() : this._sources;
+        const newNames = new ArraySet();
+        this._mappings.unsortedForEach(function(mapping) {
+          if (mapping.source === sourceFile && mapping.originalLine != null) {
+            const original = aSourceMapConsumer.originalPositionFor({
+              line: mapping.originalLine,
+              column: mapping.originalColumn
+            });
+            if (original.source != null) {
+              mapping.source = original.source;
+              if (aSourceMapPath != null) {
+                mapping.source = util.join(aSourceMapPath, mapping.source);
+              }
+              if (sourceRoot != null) {
+                mapping.source = util.relative(sourceRoot, mapping.source);
+              }
+              mapping.originalLine = original.line;
+              mapping.originalColumn = original.column;
+              if (original.name != null) {
+                mapping.name = original.name;
+              }
+            }
+          }
+          const source = mapping.source;
+          if (source != null && !newSources.has(source)) {
+            newSources.add(source);
+          }
+          const name = mapping.name;
+          if (name != null && !newNames.has(name)) {
+            newNames.add(name);
+          }
+        }, this);
+        this._sources = newSources;
+        this._names = newNames;
+        aSourceMapConsumer.sources.forEach(function(srcFile) {
+          const content = aSourceMapConsumer.sourceContentFor(srcFile);
+          if (content != null) {
+            if (aSourceMapPath != null) {
+              srcFile = util.join(aSourceMapPath, srcFile);
+            }
+            if (sourceRoot != null) {
+              srcFile = util.relative(sourceRoot, srcFile);
+            }
+            this.setSourceContent(srcFile, content);
+          }
+        }, this);
+      }
+      /**
+       * A mapping can have one of the three levels of data:
+       *
+       *   1. Just the generated position.
+       *   2. The Generated position, original position, and original source.
+       *   3. Generated and original position, original source, as well as a name
+       *      token.
+       *
+       * To maintain consistency, we validate that any new mapping being added falls
+       * in to one of these categories.
+       */
+      _validateMapping(aGenerated, aOriginal, aSource, aName) {
+        if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
+          throw new Error(
+            "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."
+          );
+        }
+        if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
+        } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
+        } else {
+          throw new Error(
+            "Invalid mapping: " + JSON.stringify({
+              generated: aGenerated,
+              source: aSource,
+              original: aOriginal,
+              name: aName
+            })
+          );
+        }
+      }
+      /**
+       * Serialize the accumulated mappings in to the stream of base 64 VLQs
+       * specified by the source map format.
+       */
+      _serializeMappings() {
+        let previousGeneratedColumn = 0;
+        let previousGeneratedLine = 1;
+        let previousOriginalColumn = 0;
+        let previousOriginalLine = 0;
+        let previousName = 0;
+        let previousSource = 0;
+        let result = "";
+        let next;
+        let mapping;
+        let nameIdx;
+        let sourceIdx;
+        const mappings = this._mappings.toArray();
+        for (let i = 0, len = mappings.length; i < len; i++) {
+          mapping = mappings[i];
+          next = "";
+          if (mapping.generatedLine !== previousGeneratedLine) {
+            previousGeneratedColumn = 0;
+            while (mapping.generatedLine !== previousGeneratedLine) {
+              next += ";";
+              previousGeneratedLine++;
+            }
+          } else if (i > 0) {
+            if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+              continue;
+            }
+            next += ",";
+          }
+          next += base64VLQ.encode(
+            mapping.generatedColumn - previousGeneratedColumn
+          );
+          previousGeneratedColumn = mapping.generatedColumn;
+          if (mapping.source != null) {
+            sourceIdx = this._sources.indexOf(mapping.source);
+            next += base64VLQ.encode(sourceIdx - previousSource);
+            previousSource = sourceIdx;
+            next += base64VLQ.encode(
+              mapping.originalLine - 1 - previousOriginalLine
+            );
+            previousOriginalLine = mapping.originalLine - 1;
+            next += base64VLQ.encode(
+              mapping.originalColumn - previousOriginalColumn
+            );
+            previousOriginalColumn = mapping.originalColumn;
+            if (mapping.name != null) {
+              nameIdx = this._names.indexOf(mapping.name);
+              next += base64VLQ.encode(nameIdx - previousName);
+              previousName = nameIdx;
+            }
+          }
+          result += next;
+        }
+        return result;
+      }
+      _generateSourcesContent(aSources, aSourceRoot) {
+        return aSources.map(function(source) {
+          if (!this._sourcesContents) {
+            return null;
+          }
+          if (aSourceRoot != null) {
+            source = util.relative(aSourceRoot, source);
+          }
+          const key = util.toSetString(source);
+          return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
+        }, this);
+      }
+      /**
+       * Externalize the source map.
+       */
+      toJSON() {
+        const map = {
+          version: this._version,
+          sources: this._sources.toArray(),
+          names: this._names.toArray(),
+          mappings: this._serializeMappings()
+        };
+        if (this._file != null) {
+          map.file = this._file;
+        }
+        if (this._sourceRoot != null) {
+          map.sourceRoot = this._sourceRoot;
+        }
+        if (this._sourcesContents) {
+          map.sourcesContent = this._generateSourcesContent(
+            map.sources,
+            map.sourceRoot
+          );
+        }
+        return map;
+      }
+      /**
+       * Render the source map being generated to a string.
+       */
+      toString() {
+        return JSON.stringify(this.toJSON());
+      }
+    };
+    SourceMapGenerator2.prototype._version = 3;
+    exports.SourceMapGenerator = SourceMapGenerator2;
+  }
+});
+
+// node_modules/source-map/lib/binary-search.js
+var require_binary_search = __commonJS({
+  "node_modules/source-map/lib/binary-search.js"(exports) {
+    exports.GREATEST_LOWER_BOUND = 1;
+    exports.LEAST_UPPER_BOUND = 2;
+    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+      const mid = Math.floor((aHigh - aLow) / 2) + aLow;
+      const cmp = aCompare(aNeedle, aHaystack[mid], true);
+      if (cmp === 0) {
+        return mid;
+      } else if (cmp > 0) {
+        if (aHigh - mid > 1) {
+          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+        }
+        if (aBias === exports.LEAST_UPPER_BOUND) {
+          return aHigh < aHaystack.length ? aHigh : -1;
+        }
+        return mid;
+      }
+      if (mid - aLow > 1) {
+        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+      }
+      if (aBias == exports.LEAST_UPPER_BOUND) {
+        return mid;
+      }
+      return aLow < 0 ? -1 : aLow;
+    }
+    exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+      if (aHaystack.length === 0) {
+        return -1;
+      }
+      let index = recursiveSearch(
+        -1,
+        aHaystack.length,
+        aNeedle,
+        aHaystack,
+        aCompare,
+        aBias || exports.GREATEST_LOWER_BOUND
+      );
+      if (index < 0) {
+        return -1;
+      }
+      while (index - 1 >= 0) {
+        if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+          break;
+        }
+        --index;
+      }
+      return index;
+    };
+  }
+});
+
+// node_modules/source-map/lib/read-wasm.js
+var require_read_wasm = __commonJS({
+  "node_modules/source-map/lib/read-wasm.js"(exports, module) {
+    "use strict";
+    var fs5 = __require("fs");
+    var path3 = __require("path");
+    module.exports = function readWasm() {
+      return new Promise((resolve2, reject) => {
+        const wasmPath = path3.join(__dirname, "mappings.wasm");
+        fs5.readFile(wasmPath, null, (error, data) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve2(data.buffer);
+        });
+      });
+    };
+    module.exports.initialize = (_) => {
+      console.debug(
+        "SourceMapConsumer.initialize is a no-op when running in node.js"
+      );
+    };
+  }
+});
+
+// node_modules/source-map/lib/wasm.js
+var require_wasm = __commonJS({
+  "node_modules/source-map/lib/wasm.js"(exports, module) {
+    var readWasm = require_read_wasm();
+    function Mapping() {
+      this.generatedLine = 0;
+      this.generatedColumn = 0;
+      this.lastGeneratedColumn = null;
+      this.source = null;
+      this.originalLine = null;
+      this.originalColumn = null;
+      this.name = null;
+    }
+    var cachedWasm = null;
+    module.exports = function wasm() {
+      if (cachedWasm) {
+        return cachedWasm;
+      }
+      const callbackStack = [];
+      cachedWasm = readWasm().then((buffer) => {
+        return WebAssembly.instantiate(buffer, {
+          env: {
+            mapping_callback(generatedLine, generatedColumn, hasLastGeneratedColumn, lastGeneratedColumn, hasOriginal, source, originalLine, originalColumn, hasName, name) {
+              const mapping = new Mapping();
+              mapping.generatedLine = generatedLine + 1;
+              mapping.generatedColumn = generatedColumn;
+              if (hasLastGeneratedColumn) {
+                mapping.lastGeneratedColumn = lastGeneratedColumn - 1;
+              }
+              if (hasOriginal) {
+                mapping.source = source;
+                mapping.originalLine = originalLine + 1;
+                mapping.originalColumn = originalColumn;
+                if (hasName) {
+                  mapping.name = name;
+                }
+              }
+              callbackStack[callbackStack.length - 1](mapping);
+            },
+            start_all_generated_locations_for() {
+              console.time("all_generated_locations_for");
+            },
+            end_all_generated_locations_for() {
+              console.timeEnd("all_generated_locations_for");
+            },
+            start_compute_column_spans() {
+              console.time("compute_column_spans");
+            },
+            end_compute_column_spans() {
+              console.timeEnd("compute_column_spans");
+            },
+            start_generated_location_for() {
+              console.time("generated_location_for");
+            },
+            end_generated_location_for() {
+              console.timeEnd("generated_location_for");
+            },
+            start_original_location_for() {
+              console.time("original_location_for");
+            },
+            end_original_location_for() {
+              console.timeEnd("original_location_for");
+            },
+            start_parse_mappings() {
+              console.time("parse_mappings");
+            },
+            end_parse_mappings() {
+              console.timeEnd("parse_mappings");
+            },
+            start_sort_by_generated_location() {
+              console.time("sort_by_generated_location");
+            },
+            end_sort_by_generated_location() {
+              console.timeEnd("sort_by_generated_location");
+            },
+            start_sort_by_original_location() {
+              console.time("sort_by_original_location");
+            },
+            end_sort_by_original_location() {
+              console.timeEnd("sort_by_original_location");
+            }
+          }
+        });
+      }).then((Wasm) => {
+        return {
+          exports: Wasm.instance.exports,
+          withMappingCallback: (mappingCallback, f) => {
+            callbackStack.push(mappingCallback);
+            try {
+              f();
+            } finally {
+              callbackStack.pop();
+            }
+          }
+        };
+      }).then(null, (e) => {
+        cachedWasm = null;
+        throw e;
+      });
+      return cachedWasm;
+    };
+  }
+});
+
+// node_modules/source-map/lib/source-map-consumer.js
+var require_source_map_consumer = __commonJS({
+  "node_modules/source-map/lib/source-map-consumer.js"(exports) {
+    var util = require_util();
+    var binarySearch = require_binary_search();
+    var ArraySet = require_array_set().ArraySet;
+    var base64VLQ = require_base64_vlq();
+    var readWasm = require_read_wasm();
+    var wasm = require_wasm();
+    var INTERNAL = /* @__PURE__ */ Symbol("smcInternal");
+    var SourceMapConsumer = class _SourceMapConsumer {
+      constructor(aSourceMap, aSourceMapURL) {
+        if (aSourceMap == INTERNAL) {
+          return Promise.resolve(this);
+        }
+        return _factory(aSourceMap, aSourceMapURL);
+      }
+      static initialize(opts) {
+        readWasm.initialize(opts["lib/mappings.wasm"]);
+      }
+      static fromSourceMap(aSourceMap, aSourceMapURL) {
+        return _factoryBSM(aSourceMap, aSourceMapURL);
+      }
+      /**
+       * Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
+       * (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
+       * function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
+       * for `f` to complete, call `destroy` on the consumer, and return `f`'s return
+       * value.
+       *
+       * You must not use the consumer after `f` completes!
+       *
+       * By using `with`, you do not have to remember to manually call `destroy` on
+       * the consumer, since it will be called automatically once `f` completes.
+       *
+       * ```js
+       * const xSquared = await SourceMapConsumer.with(
+       *   myRawSourceMap,
+       *   null,
+       *   async function (consumer) {
+       *     // Use `consumer` inside here and don't worry about remembering
+       *     // to call `destroy`.
+       *
+       *     const x = await whatever(consumer);
+       *     return x * x;
+       *   }
+       * );
+       *
+       * // You may not use that `consumer` anymore out here; it has
+       * // been destroyed. But you can use `xSquared`.
+       * console.log(xSquared);
+       * ```
+       */
+      static async with(rawSourceMap, sourceMapUrl, f) {
+        const consumer = await new _SourceMapConsumer(rawSourceMap, sourceMapUrl);
+        try {
+          return await f(consumer);
+        } finally {
+          consumer.destroy();
+        }
+      }
+      /**
+       * Iterate over each mapping between an original source/line/column and a
+       * generated line/column in this source map.
+       *
+       * @param Function aCallback
+       *        The function that is called with each mapping.
+       * @param Object aContext
+       *        Optional. If specified, this object will be the value of `this` every
+       *        time that `aCallback` is called.
+       * @param aOrder
+       *        Either `SourceMapConsumer.GENERATED_ORDER` or
+       *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+       *        iterate over the mappings sorted by the generated file's line/column
+       *        order or the original's source/line/column order, respectively. Defaults to
+       *        `SourceMapConsumer.GENERATED_ORDER`.
+       */
+      eachMapping(aCallback, aContext, aOrder) {
+        throw new Error("Subclasses must implement eachMapping");
+      }
+      /**
+       * Returns all generated line and column information for the original source,
+       * line, and column provided. If no column is provided, returns all mappings
+       * corresponding to a either the line we are searching for or the next
+       * closest line that has any mappings. Otherwise, returns all mappings
+       * corresponding to the given line and either the column we are searching for
+       * or the next closest column that has any offsets.
+       *
+       * The only argument is an object with the following properties:
+       *
+       *   - source: The filename of the original source.
+       *   - line: The line number in the original source.  The line number is 1-based.
+       *   - column: Optional. the column number in the original source.
+       *    The column number is 0-based.
+       *
+       * and an array of objects is returned, each with the following properties:
+       *
+       *   - line: The line number in the generated source, or null.  The
+       *    line number is 1-based.
+       *   - column: The column number in the generated source, or null.
+       *    The column number is 0-based.
+       */
+      allGeneratedPositionsFor(aArgs) {
+        throw new Error("Subclasses must implement allGeneratedPositionsFor");
+      }
+      destroy() {
+        throw new Error("Subclasses must implement destroy");
+      }
+    };
+    SourceMapConsumer.prototype._version = 3;
+    SourceMapConsumer.GENERATED_ORDER = 1;
+    SourceMapConsumer.ORIGINAL_ORDER = 2;
+    SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+    SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+    exports.SourceMapConsumer = SourceMapConsumer;
+    var BasicSourceMapConsumer = class _BasicSourceMapConsumer extends SourceMapConsumer {
+      constructor(aSourceMap, aSourceMapURL) {
+        return super(INTERNAL).then((that) => {
+          let sourceMap = aSourceMap;
+          if (typeof aSourceMap === "string") {
+            sourceMap = util.parseSourceMapInput(aSourceMap);
+          }
+          const version = util.getArg(sourceMap, "version");
+          const sources = util.getArg(sourceMap, "sources").map(String);
+          const names = util.getArg(sourceMap, "names", []);
+          const sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
+          const sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
+          const mappings = util.getArg(sourceMap, "mappings");
+          const file = util.getArg(sourceMap, "file", null);
+          const x_google_ignoreList = util.getArg(
+            sourceMap,
+            "x_google_ignoreList",
+            null
+          );
+          if (version != that._version) {
+            throw new Error("Unsupported version: " + version);
+          }
+          that._sourceLookupCache = /* @__PURE__ */ new Map();
+          that._names = ArraySet.fromArray(names.map(String), true);
+          that._sources = ArraySet.fromArray(sources, true);
+          that._absoluteSources = ArraySet.fromArray(
+            that._sources.toArray().map(function(s) {
+              return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+            }),
+            true
+          );
+          that.sourceRoot = sourceRoot;
+          that.sourcesContent = sourcesContent;
+          that._mappings = mappings;
+          that._sourceMapURL = aSourceMapURL;
+          that.file = file;
+          that.x_google_ignoreList = x_google_ignoreList;
+          that._computedColumnSpans = false;
+          that._mappingsPtr = 0;
+          that._wasm = null;
+          return wasm().then((w) => {
+            that._wasm = w;
+            return that;
+          });
+        });
+      }
+      /**
+       * Utility function to find the index of a source.  Returns -1 if not
+       * found.
+       */
+      _findSourceIndex(aSource) {
+        const cachedIndex = this._sourceLookupCache.get(aSource);
+        if (typeof cachedIndex === "number") {
+          return cachedIndex;
+        }
+        const sourceAsMapRelative = util.computeSourceURL(
+          null,
+          aSource,
+          this._sourceMapURL
+        );
+        if (this._absoluteSources.has(sourceAsMapRelative)) {
+          const index = this._absoluteSources.indexOf(sourceAsMapRelative);
+          this._sourceLookupCache.set(aSource, index);
+          return index;
+        }
+        const sourceAsSourceRootRelative = util.computeSourceURL(
+          this.sourceRoot,
+          aSource,
+          this._sourceMapURL
+        );
+        if (this._absoluteSources.has(sourceAsSourceRootRelative)) {
+          const index = this._absoluteSources.indexOf(sourceAsSourceRootRelative);
+          this._sourceLookupCache.set(aSource, index);
+          return index;
+        }
+        return -1;
+      }
+      /**
+       * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+       *
+       * @param SourceMapGenerator aSourceMap
+       *        The source map that will be consumed.
+       * @param String aSourceMapURL
+       *        The URL at which the source map can be found (optional)
+       * @returns BasicSourceMapConsumer
+       */
+      static fromSourceMap(aSourceMap, aSourceMapURL) {
+        return new _BasicSourceMapConsumer(aSourceMap.toString());
+      }
+      get sources() {
+        return this._absoluteSources.toArray();
+      }
+      _getMappingsPtr() {
+        if (this._mappingsPtr === 0) {
+          this._parseMappings();
+        }
+        return this._mappingsPtr;
+      }
+      /**
+       * Parse the mappings in a string in to a data structure which we can easily
+       * query (the ordered arrays in the `this.__generatedMappings` and
+       * `this.__originalMappings` properties).
+       */
+      _parseMappings() {
+        const aStr = this._mappings;
+        const size = aStr.length;
+        const mappingsBufPtr = this._wasm.exports.allocate_mappings(size) >>> 0;
+        const mappingsBuf = new Uint8Array(
+          this._wasm.exports.memory.buffer,
+          mappingsBufPtr,
+          size
+        );
+        for (let i = 0; i < size; i++) {
+          mappingsBuf[i] = aStr.charCodeAt(i);
+        }
+        const mappingsPtr = this._wasm.exports.parse_mappings(mappingsBufPtr);
+        if (!mappingsPtr) {
+          const error = this._wasm.exports.get_last_error();
+          let msg = `Error parsing mappings (code ${error}): `;
+          switch (error) {
+            case 1:
+              msg += "the mappings contained a negative line, column, source index, or name index";
+              break;
+            case 2:
+              msg += "the mappings contained a number larger than 2**32";
+              break;
+            case 3:
+              msg += "reached EOF while in the middle of parsing a VLQ";
+              break;
+            case 4:
+              msg += "invalid base 64 character while parsing a VLQ";
+              break;
+            default:
+              msg += "unknown error code";
+              break;
+          }
+          throw new Error(msg);
+        }
+        this._mappingsPtr = mappingsPtr;
+      }
+      eachMapping(aCallback, aContext, aOrder) {
+        const context = aContext || null;
+        const order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+        this._wasm.withMappingCallback(
+          (mapping) => {
+            if (mapping.source !== null) {
+              mapping.source = this._absoluteSources.at(mapping.source);
+              if (mapping.name !== null) {
+                mapping.name = this._names.at(mapping.name);
+              }
+            }
+            if (this._computedColumnSpans && mapping.lastGeneratedColumn === null) {
+              mapping.lastGeneratedColumn = Infinity;
+            }
+            aCallback.call(context, mapping);
+          },
+          () => {
+            switch (order) {
+              case SourceMapConsumer.GENERATED_ORDER:
+                this._wasm.exports.by_generated_location(this._getMappingsPtr());
+                break;
+              case SourceMapConsumer.ORIGINAL_ORDER:
+                this._wasm.exports.by_original_location(this._getMappingsPtr());
+                break;
+              default:
+                throw new Error("Unknown order of iteration.");
+            }
+          }
+        );
+      }
+      allGeneratedPositionsFor(aArgs) {
+        let source = util.getArg(aArgs, "source");
+        const originalLine = util.getArg(aArgs, "line");
+        const originalColumn = aArgs.column || 0;
+        source = this._findSourceIndex(source);
+        if (source < 0) {
+          return [];
+        }
+        if (originalLine < 1) {
+          throw new Error("Line numbers must be >= 1");
+        }
+        if (originalColumn < 0) {
+          throw new Error("Column numbers must be >= 0");
+        }
+        const mappings = [];
+        this._wasm.withMappingCallback(
+          (m) => {
+            let lastColumn = m.lastGeneratedColumn;
+            if (this._computedColumnSpans && lastColumn === null) {
+              lastColumn = Infinity;
+            }
+            mappings.push({
+              line: m.generatedLine,
+              column: m.generatedColumn,
+              lastColumn
+            });
+          },
+          () => {
+            this._wasm.exports.all_generated_locations_for(
+              this._getMappingsPtr(),
+              source,
+              originalLine - 1,
+              "column" in aArgs,
+              originalColumn
+            );
+          }
+        );
+        return mappings;
+      }
+      destroy() {
+        if (this._mappingsPtr !== 0) {
+          this._wasm.exports.free_mappings(this._mappingsPtr);
+          this._mappingsPtr = 0;
+        }
+      }
+      /**
+       * Compute the last column for each generated mapping. The last column is
+       * inclusive.
+       */
+      computeColumnSpans() {
+        if (this._computedColumnSpans) {
+          return;
+        }
+        this._wasm.exports.compute_column_spans(this._getMappingsPtr());
+        this._computedColumnSpans = true;
+      }
+      /**
+       * Returns the original source, line, and column information for the generated
+       * source's line and column positions provided. The only argument is an object
+       * with the following properties:
+       *
+       *   - line: The line number in the generated source.  The line number
+       *     is 1-based.
+       *   - column: The column number in the generated source.  The column
+       *     number is 0-based.
+       *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+       *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+       *     closest element that is smaller than or greater than the one we are
+       *     searching for, respectively, if the exact element cannot be found.
+       *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+       *
+       * and an object is returned with the following properties:
+       *
+       *   - source: The original source file, or null.
+       *   - line: The line number in the original source, or null.  The
+       *     line number is 1-based.
+       *   - column: The column number in the original source, or null.  The
+       *     column number is 0-based.
+       *   - name: The original identifier, or null.
+       */
+      originalPositionFor(aArgs) {
+        const needle = {
+          generatedLine: util.getArg(aArgs, "line"),
+          generatedColumn: util.getArg(aArgs, "column")
+        };
+        if (needle.generatedLine < 1) {
+          throw new Error("Line numbers must be >= 1");
+        }
+        if (needle.generatedColumn < 0) {
+          throw new Error("Column numbers must be >= 0");
+        }
+        let bias = util.getArg(
+          aArgs,
+          "bias",
+          SourceMapConsumer.GREATEST_LOWER_BOUND
+        );
+        if (bias == null) {
+          bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
+        }
+        let mapping;
+        this._wasm.withMappingCallback(
+          (m) => mapping = m,
+          () => {
+            this._wasm.exports.original_location_for(
+              this._getMappingsPtr(),
+              needle.generatedLine - 1,
+              needle.generatedColumn,
+              bias
+            );
+          }
+        );
+        if (mapping) {
+          if (mapping.generatedLine === needle.generatedLine) {
+            let source = util.getArg(mapping, "source", null);
+            if (source !== null) {
+              source = this._absoluteSources.at(source);
+            }
+            let name = util.getArg(mapping, "name", null);
+            if (name !== null) {
+              name = this._names.at(name);
+            }
+            return {
+              source,
+              line: util.getArg(mapping, "originalLine", null),
+              column: util.getArg(mapping, "originalColumn", null),
+              name
+            };
+          }
+        }
+        return {
+          source: null,
+          line: null,
+          column: null,
+          name: null
+        };
+      }
+      /**
+       * Return true if we have the source content for every source in the source
+       * map, false otherwise.
+       */
+      hasContentsOfAllSources() {
+        if (!this.sourcesContent) {
+          return false;
+        }
+        return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
+          return sc == null;
+        });
+      }
+      /**
+       * Returns the original source content. The only argument is the url of the
+       * original source file. Returns null if no original source content is
+       * available.
+       */
+      sourceContentFor(aSource, nullOnMissing) {
+        if (!this.sourcesContent) {
+          return null;
+        }
+        const index = this._findSourceIndex(aSource);
+        if (index >= 0) {
+          return this.sourcesContent[index];
+        }
+        if (nullOnMissing) {
+          return null;
+        }
+        throw new Error('"' + aSource + '" is not in the SourceMap.');
+      }
+      /**
+       * Returns the generated line and column information for the original source,
+       * line, and column positions provided. The only argument is an object with
+       * the following properties:
+       *
+       *   - source: The filename of the original source.
+       *   - line: The line number in the original source.  The line number
+       *     is 1-based.
+       *   - column: The column number in the original source.  The column
+       *     number is 0-based.
+       *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+       *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+       *     closest element that is smaller than or greater than the one we are
+       *     searching for, respectively, if the exact element cannot be found.
+       *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+       *
+       * and an object is returned with the following properties:
+       *
+       *   - line: The line number in the generated source, or null.  The
+       *     line number is 1-based.
+       *   - column: The column number in the generated source, or null.
+       *     The column number is 0-based.
+       */
+      generatedPositionFor(aArgs) {
+        let source = util.getArg(aArgs, "source");
+        source = this._findSourceIndex(source);
+        if (source < 0) {
+          return {
+            line: null,
+            column: null,
+            lastColumn: null
+          };
+        }
+        const needle = {
+          source,
+          originalLine: util.getArg(aArgs, "line"),
+          originalColumn: util.getArg(aArgs, "column")
+        };
+        if (needle.originalLine < 1) {
+          throw new Error("Line numbers must be >= 1");
+        }
+        if (needle.originalColumn < 0) {
+          throw new Error("Column numbers must be >= 0");
+        }
+        let bias = util.getArg(
+          aArgs,
+          "bias",
+          SourceMapConsumer.GREATEST_LOWER_BOUND
+        );
+        if (bias == null) {
+          bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
+        }
+        let mapping;
+        this._wasm.withMappingCallback(
+          (m) => mapping = m,
+          () => {
+            this._wasm.exports.generated_location_for(
+              this._getMappingsPtr(),
+              needle.source,
+              needle.originalLine - 1,
+              needle.originalColumn,
+              bias
+            );
+          }
+        );
+        if (mapping) {
+          if (mapping.source === needle.source) {
+            let lastColumn = mapping.lastGeneratedColumn;
+            if (this._computedColumnSpans && lastColumn === null) {
+              lastColumn = Infinity;
+            }
+            return {
+              line: util.getArg(mapping, "generatedLine", null),
+              column: util.getArg(mapping, "generatedColumn", null),
+              lastColumn
+            };
+          }
+        }
+        return {
+          line: null,
+          column: null,
+          lastColumn: null
+        };
+      }
+    };
+    BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+    exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+    var IndexedSourceMapConsumer = class extends SourceMapConsumer {
+      constructor(aSourceMap, aSourceMapURL) {
+        return super(INTERNAL).then((that) => {
+          let sourceMap = aSourceMap;
+          if (typeof aSourceMap === "string") {
+            sourceMap = util.parseSourceMapInput(aSourceMap);
+          }
+          const version = util.getArg(sourceMap, "version");
+          const sections = util.getArg(sourceMap, "sections");
+          if (version != that._version) {
+            throw new Error("Unsupported version: " + version);
+          }
+          let lastOffset = {
+            line: -1,
+            column: 0
+          };
+          return Promise.all(
+            sections.map((s) => {
+              if (s.url) {
+                throw new Error(
+                  "Support for url field in sections not implemented."
+                );
+              }
+              const offset = util.getArg(s, "offset");
+              const offsetLine = util.getArg(offset, "line");
+              const offsetColumn = util.getArg(offset, "column");
+              if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
+                throw new Error(
+                  "Section offsets must be ordered and non-overlapping."
+                );
+              }
+              lastOffset = offset;
+              const cons = new SourceMapConsumer(
+                util.getArg(s, "map"),
+                aSourceMapURL
+              );
+              return cons.then((consumer) => {
+                return {
+                  generatedOffset: {
+                    // The offset fields are 0-based, but we use 1-based indices when
+                    // encoding/decoding from VLQ.
+                    generatedLine: offsetLine + 1,
+                    generatedColumn: offsetColumn + 1
+                  },
+                  consumer
+                };
+              });
+            })
+          ).then((s) => {
+            that._sections = s;
+            return that;
+          });
+        });
+      }
+      /**
+       * The list of original sources.
+       */
+      get sources() {
+        const sources = [];
+        for (let i = 0; i < this._sections.length; i++) {
+          for (let j = 0; j < this._sections[i].consumer.sources.length; j++) {
+            sources.push(this._sections[i].consumer.sources[j]);
+          }
+        }
+        return sources;
+      }
+      /**
+       * Returns the original source, line, and column information for the generated
+       * source's line and column positions provided. The only argument is an object
+       * with the following properties:
+       *
+       *   - line: The line number in the generated source.  The line number
+       *     is 1-based.
+       *   - column: The column number in the generated source.  The column
+       *     number is 0-based.
+       *
+       * and an object is returned with the following properties:
+       *
+       *   - source: The original source file, or null.
+       *   - line: The line number in the original source, or null.  The
+       *     line number is 1-based.
+       *   - column: The column number in the original source, or null.  The
+       *     column number is 0-based.
+       *   - name: The original identifier, or null.
+       */
+      originalPositionFor(aArgs) {
+        const needle = {
+          generatedLine: util.getArg(aArgs, "line"),
+          generatedColumn: util.getArg(aArgs, "column")
+        };
+        const sectionIndex = binarySearch.search(
+          needle,
+          this._sections,
+          function(aNeedle, section2) {
+            const cmp = aNeedle.generatedLine - section2.generatedOffset.generatedLine;
+            if (cmp) {
+              return cmp;
+            }
+            return aNeedle.generatedColumn - (section2.generatedOffset.generatedColumn - 1);
+          }
+        );
+        const section = this._sections[sectionIndex];
+        if (!section) {
+          return {
+            source: null,
+            line: null,
+            column: null,
+            name: null
+          };
+        }
+        return section.consumer.originalPositionFor({
+          line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+          column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+          bias: aArgs.bias
+        });
+      }
+      /**
+       * Return true if we have the source content for every source in the source
+       * map, false otherwise.
+       */
+      hasContentsOfAllSources() {
+        return this._sections.every(function(s) {
+          return s.consumer.hasContentsOfAllSources();
+        });
+      }
+      /**
+       * Returns the original source content. The only argument is the url of the
+       * original source file. Returns null if no original source content is
+       * available.
+       */
+      sourceContentFor(aSource, nullOnMissing) {
+        for (let i = 0; i < this._sections.length; i++) {
+          const section = this._sections[i];
+          const content = section.consumer.sourceContentFor(aSource, true);
+          if (content) {
+            return content;
+          }
+        }
+        if (nullOnMissing) {
+          return null;
+        }
+        throw new Error('"' + aSource + '" is not in the SourceMap.');
+      }
+      _findSectionIndex(source) {
+        for (let i = 0; i < this._sections.length; i++) {
+          const { consumer } = this._sections[i];
+          if (consumer._findSourceIndex(source) !== -1) {
+            return i;
+          }
+        }
+        return -1;
+      }
+      /**
+       * Returns the generated line and column information for the original source,
+       * line, and column positions provided. The only argument is an object with
+       * the following properties:
+       *
+       *   - source: The filename of the original source.
+       *   - line: The line number in the original source.  The line number
+       *     is 1-based.
+       *   - column: The column number in the original source.  The column
+       *     number is 0-based.
+       *
+       * and an object is returned with the following properties:
+       *
+       *   - line: The line number in the generated source, or null.  The
+       *     line number is 1-based.
+       *   - column: The column number in the generated source, or null.
+       *     The column number is 0-based.
+       */
+      generatedPositionFor(aArgs) {
+        const index = this._findSectionIndex(util.getArg(aArgs, "source"));
+        const section = index >= 0 ? this._sections[index] : null;
+        const nextSection = index >= 0 && index + 1 < this._sections.length ? this._sections[index + 1] : null;
+        const generatedPosition = section && section.consumer.generatedPositionFor(aArgs);
+        if (generatedPosition && generatedPosition.line !== null) {
+          const lineShift = section.generatedOffset.generatedLine - 1;
+          const columnShift = section.generatedOffset.generatedColumn - 1;
+          if (generatedPosition.line === 1) {
+            generatedPosition.column += columnShift;
+            if (typeof generatedPosition.lastColumn === "number") {
+              generatedPosition.lastColumn += columnShift;
+            }
+          }
+          if (generatedPosition.lastColumn === Infinity && nextSection && generatedPosition.line === nextSection.generatedOffset.generatedLine) {
+            generatedPosition.lastColumn = nextSection.generatedOffset.generatedColumn - 2;
+          }
+          generatedPosition.line += lineShift;
+          return generatedPosition;
+        }
+        return {
+          line: null,
+          column: null,
+          lastColumn: null
+        };
+      }
+      allGeneratedPositionsFor(aArgs) {
+        const index = this._findSectionIndex(util.getArg(aArgs, "source"));
+        const section = index >= 0 ? this._sections[index] : null;
+        const nextSection = index >= 0 && index + 1 < this._sections.length ? this._sections[index + 1] : null;
+        if (!section) return [];
+        return section.consumer.allGeneratedPositionsFor(aArgs).map((generatedPosition) => {
+          const lineShift = section.generatedOffset.generatedLine - 1;
+          const columnShift = section.generatedOffset.generatedColumn - 1;
+          if (generatedPosition.line === 1) {
+            generatedPosition.column += columnShift;
+            if (typeof generatedPosition.lastColumn === "number") {
+              generatedPosition.lastColumn += columnShift;
+            }
+          }
+          if (generatedPosition.lastColumn === Infinity && nextSection && generatedPosition.line === nextSection.generatedOffset.generatedLine) {
+            generatedPosition.lastColumn = nextSection.generatedOffset.generatedColumn - 2;
+          }
+          generatedPosition.line += lineShift;
+          return generatedPosition;
+        });
+      }
+      eachMapping(aCallback, aContext, aOrder) {
+        this._sections.forEach((section, index) => {
+          const nextSection = index + 1 < this._sections.length ? this._sections[index + 1] : null;
+          const { generatedOffset } = section;
+          const lineShift = generatedOffset.generatedLine - 1;
+          const columnShift = generatedOffset.generatedColumn - 1;
+          section.consumer.eachMapping(
+            function(mapping) {
+              if (mapping.generatedLine === 1) {
+                mapping.generatedColumn += columnShift;
+                if (typeof mapping.lastGeneratedColumn === "number") {
+                  mapping.lastGeneratedColumn += columnShift;
+                }
+              }
+              if (mapping.lastGeneratedColumn === Infinity && nextSection && mapping.generatedLine === nextSection.generatedOffset.generatedLine) {
+                mapping.lastGeneratedColumn = nextSection.generatedOffset.generatedColumn - 2;
+              }
+              mapping.generatedLine += lineShift;
+              aCallback.call(this, mapping);
+            },
+            aContext,
+            aOrder
+          );
+        });
+      }
+      computeColumnSpans() {
+        for (let i = 0; i < this._sections.length; i++) {
+          this._sections[i].consumer.computeColumnSpans();
+        }
+      }
+      destroy() {
+        for (let i = 0; i < this._sections.length; i++) {
+          this._sections[i].consumer.destroy();
+        }
+      }
+    };
+    exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+    function _factory(aSourceMap, aSourceMapURL) {
+      let sourceMap = aSourceMap;
+      if (typeof aSourceMap === "string") {
+        sourceMap = util.parseSourceMapInput(aSourceMap);
+      }
+      const consumer = sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+      return Promise.resolve(consumer);
+    }
+    function _factoryBSM(aSourceMap, aSourceMapURL) {
+      return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+    }
+  }
+});
+
+// node_modules/source-map/lib/source-node.js
+var require_source_node = __commonJS({
+  "node_modules/source-map/lib/source-node.js"(exports) {
+    var SourceMapGenerator2 = require_source_map_generator().SourceMapGenerator;
+    var util = require_util();
+    var REGEX_NEWLINE = /(\r?\n)/;
+    var NEWLINE_CODE = 10;
+    var isSourceNode = "$$$isSourceNode$$$";
+    var SourceNode = class _SourceNode {
+      constructor(aLine, aColumn, aSource, aChunks, aName) {
+        this.children = [];
+        this.sourceContents = /* @__PURE__ */ Object.create(null);
+        this.line = aLine == null ? null : aLine;
+        this.column = aColumn == null ? null : aColumn;
+        this.source = aSource == null ? null : aSource;
+        this.name = aName == null ? null : aName;
+        this[isSourceNode] = true;
+        if (aChunks != null) this.add(aChunks);
+      }
+      /**
+       * Creates a SourceNode from generated code and a SourceMapConsumer.
+       *
+       * @param aGeneratedCode The generated code
+       * @param aSourceMapConsumer The SourceMap for the generated code
+       * @param aRelativePath Optional. The path that relative sources in the
+       *        SourceMapConsumer should be relative to.
+       */
+      static fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+        const node = new _SourceNode();
+        const remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+        let remainingLinesIndex = 0;
+        const shiftNextLine = function() {
+          const lineContents = getNextLine();
+          const newLine = getNextLine() || "";
+          return lineContents + newLine;
+          function getNextLine() {
+            return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
+          }
+        };
+        let lastGeneratedLine = 1, lastGeneratedColumn = 0;
+        let lastMapping = null;
+        let nextLine;
+        aSourceMapConsumer.eachMapping(function(mapping) {
+          if (lastMapping !== null) {
+            if (lastGeneratedLine < mapping.generatedLine) {
+              addMappingWithCode(lastMapping, shiftNextLine());
+              lastGeneratedLine++;
+              lastGeneratedColumn = 0;
+            } else {
+              nextLine = remainingLines[remainingLinesIndex] || "";
+              const code = nextLine.substr(
+                0,
+                mapping.generatedColumn - lastGeneratedColumn
+              );
+              remainingLines[remainingLinesIndex] = nextLine.substr(
+                mapping.generatedColumn - lastGeneratedColumn
+              );
+              lastGeneratedColumn = mapping.generatedColumn;
+              addMappingWithCode(lastMapping, code);
+              lastMapping = mapping;
+              return;
+            }
+          }
+          while (lastGeneratedLine < mapping.generatedLine) {
+            node.add(shiftNextLine());
+            lastGeneratedLine++;
+          }
+          if (lastGeneratedColumn < mapping.generatedColumn) {
+            nextLine = remainingLines[remainingLinesIndex] || "";
+            node.add(nextLine.substr(0, mapping.generatedColumn));
+            remainingLines[remainingLinesIndex] = nextLine.substr(
+              mapping.generatedColumn
+            );
+            lastGeneratedColumn = mapping.generatedColumn;
+          }
+          lastMapping = mapping;
+        }, this);
+        if (remainingLinesIndex < remainingLines.length) {
+          if (lastMapping) {
+            addMappingWithCode(lastMapping, shiftNextLine());
+          }
+          node.add(remainingLines.splice(remainingLinesIndex).join(""));
+        }
+        aSourceMapConsumer.sources.forEach(function(sourceFile) {
+          const content = aSourceMapConsumer.sourceContentFor(sourceFile);
+          if (content != null) {
+            if (aRelativePath != null) {
+              sourceFile = util.join(aRelativePath, sourceFile);
+            }
+            node.setSourceContent(sourceFile, content);
+          }
+        });
+        return node;
+        function addMappingWithCode(mapping, code) {
+          if (mapping === null || mapping.source === void 0) {
+            node.add(code);
+          } else {
+            const source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
+            node.add(
+              new _SourceNode(
+                mapping.originalLine,
+                mapping.originalColumn,
+                source,
+                code,
+                mapping.name
+              )
+            );
+          }
+        }
+      }
+      /**
+       * Add a chunk of generated JS to this source node.
+       *
+       * @param aChunk A string snippet of generated JS code, another instance of
+       *        SourceNode, or an array where each member is one of those things.
+       */
+      add(aChunk) {
+        if (Array.isArray(aChunk)) {
+          aChunk.forEach(function(chunk) {
+            this.add(chunk);
+          }, this);
+        } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+          if (aChunk) {
+            this.children.push(aChunk);
+          }
+        } else {
+          throw new TypeError(
+            "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+          );
+        }
+        return this;
+      }
+      /**
+       * Add a chunk of generated JS to the beginning of this source node.
+       *
+       * @param aChunk A string snippet of generated JS code, another instance of
+       *        SourceNode, or an array where each member is one of those things.
+       */
+      prepend(aChunk) {
+        if (Array.isArray(aChunk)) {
+          for (let i = aChunk.length - 1; i >= 0; i--) {
+            this.prepend(aChunk[i]);
+          }
+        } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+          this.children.unshift(aChunk);
+        } else {
+          throw new TypeError(
+            "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+          );
+        }
+        return this;
+      }
+      /**
+       * Walk over the tree of JS snippets in this node and its children. The
+       * walking function is called once for each snippet of JS and is passed that
+       * snippet and the its original associated source's line/column location.
+       *
+       * @param aFn The traversal function.
+       */
+      walk(aFn) {
+        let chunk;
+        for (let i = 0, len = this.children.length; i < len; i++) {
+          chunk = this.children[i];
+          if (chunk[isSourceNode]) {
+            chunk.walk(aFn);
+          } else if (chunk !== "") {
+            aFn(chunk, {
+              source: this.source,
+              line: this.line,
+              column: this.column,
+              name: this.name
+            });
+          }
+        }
+      }
+      /**
+       * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+       * each of `this.children`.
+       *
+       * @param aSep The separator.
+       */
+      join(aSep) {
+        let newChildren;
+        let i;
+        const len = this.children.length;
+        if (len > 0) {
+          newChildren = [];
+          for (i = 0; i < len - 1; i++) {
+            newChildren.push(this.children[i]);
+            newChildren.push(aSep);
+          }
+          newChildren.push(this.children[i]);
+          this.children = newChildren;
+        }
+        return this;
+      }
+      /**
+       * Call String.prototype.replace on the very right-most source snippet. Useful
+       * for trimming whitespace from the end of a source node, etc.
+       *
+       * @param aPattern The pattern to replace.
+       * @param aReplacement The thing to replace the pattern with.
+       */
+      replaceRight(aPattern, aReplacement) {
+        const lastChild = this.children[this.children.length - 1];
+        if (lastChild[isSourceNode]) {
+          lastChild.replaceRight(aPattern, aReplacement);
+        } else if (typeof lastChild === "string") {
+          this.children[this.children.length - 1] = lastChild.replace(
+            aPattern,
+            aReplacement
+          );
+        } else {
+          this.children.push("".replace(aPattern, aReplacement));
+        }
+        return this;
+      }
+      /**
+       * Set the source content for a source file. This will be added to the SourceMapGenerator
+       * in the sourcesContent field.
+       *
+       * @param aSourceFile The filename of the source file
+       * @param aSourceContent The content of the source file
+       */
+      setSourceContent(aSourceFile, aSourceContent) {
+        this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+      }
+      /**
+       * Walk over the tree of SourceNodes. The walking function is called for each
+       * source file content and is passed the filename and source content.
+       *
+       * @param aFn The traversal function.
+       */
+      walkSourceContents(aFn) {
+        for (let i = 0, len = this.children.length; i < len; i++) {
+          if (this.children[i][isSourceNode]) {
+            this.children[i].walkSourceContents(aFn);
+          }
+        }
+        const sources = Object.keys(this.sourceContents);
+        for (let i = 0, len = sources.length; i < len; i++) {
+          aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+        }
+      }
+      /**
+       * Return the string representation of this source node. Walks over the tree
+       * and concatenates all the various snippets together to one string.
+       */
+      toString() {
+        let str = "";
+        this.walk(function(chunk) {
+          str += chunk;
+        });
+        return str;
+      }
+      /**
+       * Returns the string representation of this source node along with a source
+       * map.
+       */
+      toStringWithSourceMap(aArgs) {
+        const generated = {
+          code: "",
+          line: 1,
+          column: 0
+        };
+        const map = new SourceMapGenerator2(aArgs);
+        let sourceMappingActive = false;
+        let lastOriginalSource = null;
+        let lastOriginalLine = null;
+        let lastOriginalColumn = null;
+        let lastOriginalName = null;
+        this.walk(function(chunk, original) {
+          generated.code += chunk;
+          if (original.source !== null && original.line !== null && original.column !== null) {
+            if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
+              map.addMapping({
+                source: original.source,
+                original: {
+                  line: original.line,
+                  column: original.column
+                },
+                generated: {
+                  line: generated.line,
+                  column: generated.column
+                },
+                name: original.name
+              });
+            }
+            lastOriginalSource = original.source;
+            lastOriginalLine = original.line;
+            lastOriginalColumn = original.column;
+            lastOriginalName = original.name;
+            sourceMappingActive = true;
+          } else if (sourceMappingActive) {
+            map.addMapping({
+              generated: {
+                line: generated.line,
+                column: generated.column
+              }
+            });
+            lastOriginalSource = null;
+            sourceMappingActive = false;
+          }
+          for (let idx = 0, length = chunk.length; idx < length; idx++) {
+            if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+              generated.line++;
+              generated.column = 0;
+              if (idx + 1 === length) {
+                lastOriginalSource = null;
+                sourceMappingActive = false;
+              } else if (sourceMappingActive) {
+                map.addMapping({
+                  source: original.source,
+                  original: {
+                    line: original.line,
+                    column: original.column
+                  },
+                  generated: {
+                    line: generated.line,
+                    column: generated.column
+                  },
+                  name: original.name
+                });
+              }
+            } else {
+              generated.column++;
+            }
+          }
+        });
+        this.walkSourceContents(function(sourceFile, sourceContent) {
+          map.setSourceContent(sourceFile, sourceContent);
+        });
+        return { code: generated.code, map };
+      }
+    };
+    exports.SourceNode = SourceNode;
+  }
+});
+
+// node_modules/source-map/source-map.js
+var require_source_map = __commonJS({
+  "node_modules/source-map/source-map.js"(exports) {
+    exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+    exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
+    exports.SourceNode = require_source_node().SourceNode;
+  }
+});
+
+// src/api/generated-module/module-format.ts
+function generateImportStatement(names, source, moduleFormat) {
+  if (moduleFormat === "cjs") {
+    return `const { ${names.join(", ")} } = require('${source}');`;
+  }
+  return `import { ${names.join(", ")} } from '${source}';`;
+}
+function generateFunctionExportKeyword(moduleFormat) {
+  return moduleFormat === "cjs" ? "" : "export ";
+}
+function generateModuleExports(functionNames) {
+  if (functionNames.length === 1) {
+    return `module.exports = { ${functionNames[0]} };`;
+  }
+  return `module.exports = { ${functionNames.join(", ")} };`;
+}
+
+// src/api/generated-module/module-writer.ts
+var import_source_map = __toESM(require_source_map(), 1);
+var ModuleWriter = class {
+  constructor(workflowFunctionName, sourceFile, withSourceMap) {
+    this.sourceFile = sourceFile;
+    this.sourceMap = withSourceMap ? new import_source_map.SourceMapGenerator({ file: `${workflowFunctionName}.generated.ts` }) : void 0;
+  }
+  sourceFile;
+  lines = [];
+  /** The 1-based generated line the next appended text starts on. */
+  currentLine = 1;
+  sourceMap;
+  /** Whether mappings are being recorded (a source map was asked for and there is a source file). */
+  get mapsSource() {
+    return this.sourceMap !== void 0 && Boolean(this.sourceFile);
+  }
+  /**
+   * Appends a chunk of generated text, which may span several lines. Only
+   * `\n` ends a line: the chunk is joined with `\n`, so that is what the
+   * generated line numbers count.
+   */
+  push(chunk) {
+    this.lines.push(chunk);
+    this.currentLine += chunk.split("\n").length;
+  }
+  /** Maps the line the next appended text starts on to a line of the workflow source. */
+  map(sourceLine, sourceColumn = 0) {
+    if (this.sourceMap && this.sourceFile) {
+      this.sourceMap.addMapping({
+        generated: {
+          line: this.currentLine,
+          column: 0
+        },
+        source: this.sourceFile,
+        original: {
+          line: sourceLine,
+          column: sourceColumn
+        }
+      });
+    }
+  }
+  /** The module text. */
+  text() {
+    return this.lines.join("\n");
+  }
+  /**
+   * The finished source map, with the workflow source's content embedded, or
+   * undefined when none was asked for.
+   */
+  finishSourceMap(readSource) {
+    if (!this.sourceMap) return void 0;
+    if (this.sourceFile) {
+      this.sourceMap.setSourceContent(this.sourceFile, readSource(this.sourceFile));
+    }
+    return this.sourceMap.toString();
+  }
+};
+
+// src/api/extract-types.ts
+import * as ts from "typescript";
+import * as fs from "fs";
+function extractTypeDeclarations(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "temp.ts",
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const interfaces = [];
+  const typeAliases = [];
+  const all = [];
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isInterfaceDeclaration(node)) {
+      const text = sourceCode.slice(node.getFullStart(), node.getEnd()).trim();
+      interfaces.push(text);
+      all.push({ text, pos: node.getFullStart(), kind: "interface" });
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      const text = sourceCode.slice(node.getFullStart(), node.getEnd()).trim();
+      typeAliases.push(text);
+      all.push({ text, pos: node.getFullStart(), kind: "type" });
+    }
+  });
+  all.sort((a, b) => a.pos - b.pos);
+  return {
+    interfaces,
+    typeAliases,
+    all: all.map((item) => item.text)
+  };
+}
+function extractTypeDeclarationsFromFile(filePath) {
+  try {
+    const sourceCode = fs.readFileSync(filePath, "utf-8");
+    return extractTypeDeclarations(sourceCode);
+  } catch {
+    return { interfaces: [], typeAliases: [], all: [] };
+  }
+}
+
+// src/api/generated-module/preamble.ts
+function emitInlineRuntime(writer, production, moduleFormat) {
+  writer.push(generateInlineRuntime(production, false, "typescript", moduleFormat));
+  writer.push("");
+}
+function emitPreservedTypeDeclarations(writer, sourceFile) {
+  if (!sourceFile) return;
+  const extractedTypes = extractTypeDeclarationsFromFile(sourceFile);
+  if (extractedTypes.all.length === 0) return;
+  writer.push("");
+  writer.push("// ============================================================================");
+  writer.push("// Type Declarations (preserved from source)");
+  writer.push("// ============================================================================");
+  writer.push("");
+  extractedTypes.all.forEach((typeDecl) => {
+    writer.push(typeDecl);
+    writer.push("");
+  });
+}
+
+// src/api/generated-module/node-type-imports.ts
+import * as path from "node:path";
+function classifyNodeTypes(ast) {
+  const npmPackageNodes = ast.nodeTypes.filter((n) => n.importSource);
+  const referencedNodeTypes = new Set(ast.instances.map((i) => i.nodeType));
+  const localNodes = ast.nodeTypes.filter(
+    (n) => !n.importSource && (n.sourceLocation?.file === ast.sourceFile || !n.sourceLocation && n.functionText && n.helperText != null && referencedNodeTypes.has(n.name))
+  );
+  const importedNodes = ast.nodeTypes.filter(
+    (n) => !n.importSource && n.sourceLocation?.file !== ast.sourceFile
+  );
+  return {
+    npmPackageNodes,
+    importedNodes,
+    localFunctions: localNodes.filter((n) => n.variant !== "IMPORTED_WORKFLOW"),
+    localWorkflowNodes: localNodes.filter(
+      (n) => n.variant === "IMPORTED_WORKFLOW" && referencedNodeTypes.has(n.name)
+    )
+  };
+}
+function emitNodeTypeImports(writer, origins, bundleMode, moduleFormat) {
+  const { importedNodes, npmPackageNodes } = origins;
+  if (importedNodes.length === 0 && npmPackageNodes.length === 0) return;
+  const functionImportsByFile = /* @__PURE__ */ new Map();
+  const workflowImportsByFile = /* @__PURE__ */ new Map();
+  importedNodes.forEach((node) => {
+    const sourceFile = node.sourceLocation?.file;
+    if (!sourceFile) return;
+    if (node.variant === "IMPORTED_WORKFLOW") {
+      if (!workflowImportsByFile.has(sourceFile)) {
+        workflowImportsByFile.set(sourceFile, []);
+      }
+      workflowImportsByFile.get(sourceFile)?.push(node.functionName);
+    } else {
+      if (!functionImportsByFile.has(sourceFile)) {
+        functionImportsByFile.set(sourceFile, []);
+      }
+      functionImportsByFile.get(sourceFile)?.push(node);
+    }
+  });
+  writer.push("");
+  functionImportsByFile.forEach((nodes, sourceFile) => {
+    if (bundleMode) {
+      nodes.forEach((node) => {
+        const lowerName = node.functionName.toLowerCase();
+        const importName = `${lowerName}_impl as ${node.functionName}`;
+        writer.push(generateImportStatement([importName], `../node-types/${lowerName}.js`, moduleFormat));
+      });
+    } else {
+      const generatedFileName = path.basename(sourceFile, ".ts") + ".generated";
+      const names = nodes.map((n) => n.functionName);
+      writer.push(generateImportStatement(names, `./${generatedFileName}`, moduleFormat));
+    }
+  });
+  workflowImportsByFile.forEach((names, sourceFile) => {
+    if (bundleMode) {
+      names.forEach((name) => {
+        writer.push(generateImportStatement([name], `./${name}.js`, moduleFormat));
+      });
+    } else {
+      const sourceFileName = path.basename(sourceFile, ".ts");
+      const generatedFileName = sourceFileName.includes(".generated") ? sourceFileName : sourceFileName + ".generated";
+      writer.push(generateImportStatement(names, `./${generatedFileName}`, moduleFormat));
+    }
+  });
+  const npmImportsByPackage = /* @__PURE__ */ new Map();
+  npmPackageNodes.forEach((node) => {
+    const pkg = node.importSource;
+    if (!npmImportsByPackage.has(pkg)) npmImportsByPackage.set(pkg, []);
+    npmImportsByPackage.get(pkg).push(node.functionName);
+  });
+  npmImportsByPackage.forEach((names, pkg) => {
+    writer.push(generateImportStatement(names, pkg, moduleFormat));
+  });
+  writer.push("");
+}
+
+// src/api/generated-module/local-node-functions.ts
+function emitSourceConstants(writer, constants, localFunctions) {
+  if (constants.length === 0 || localFunctions.length === 0) return;
+  writer.push("");
+  writer.push("// Constants from source file");
+  constants.forEach((constant) => writer.push(constant));
+}
+function emitLocalNodeFunctions(writer, localFunctions, externalNodeTypes, moduleFormat, production) {
+  const externalFunctions = localFunctions.filter((n) => externalNodeTypes[n.name]);
+  const inlineFunctions = localFunctions.filter((n) => !externalNodeTypes[n.name]);
+  if (externalFunctions.length > 0) {
+    writer.push("");
+    externalFunctions.forEach((node) => {
+      const importName = `${node.functionName.toLowerCase()}_impl as ${node.functionName}`;
+      writer.push(generateImportStatement([importName], externalNodeTypes[node.name], moduleFormat));
+    });
+  }
+  if (inlineFunctions.length > 0) {
+    writer.push("");
+    emitSharedHelpers(writer, inlineFunctions, production);
+    inlineFunctions.forEach((node) => {
+      if (node.importSource) return;
+      const functionText = production && node.functionTextProduction != null ? node.functionTextProduction : node.functionText;
+      if (!functionText) return;
+      if (node.sourceLocation) {
+        writer.map(node.sourceLocation.line, node.sourceLocation.column);
+      }
+      writer.push(removeDecorators(functionText));
+      writer.push("");
+    });
+  }
+}
+function emitSharedHelpers(writer, inlineFunctions, production) {
+  const emittedHelpers = /* @__PURE__ */ new Set();
+  inlineFunctions.forEach((node) => {
+    if (node.importSource) return;
+    const helperText = production ? node.helperTextProduction ?? null : node.helperText ?? null;
+    if (helperText && !emittedHelpers.has(helperText)) {
+      emittedHelpers.add(helperText);
+      writer.push(helperText);
+      writer.push("");
+    }
+  });
+}
+function removeDecorators(functionText) {
+  return functionText.replace(/@\w+\({[\s\S]*?}\)\s*/g, "");
+}
+
+// src/api/generated-module/workflow-functions.ts
+import * as fs2 from "fs";
+function workflowSignature(workflow, keywords, shouldBeAsync) {
+  const exitPorts = extractExitPorts(workflow);
+  const workflowHasBranching = hasBranching(workflow);
+  const returnTypes = [];
+  Object.entries(exitPorts).forEach(([portName, portDef]) => {
+    const optional = workflowHasBranching ? "?" : "";
+    const tsType = mapToTypeScript(portDef.dataType, portDef.tsType);
+    returnTypes.push(`${portName}${optional}: ${tsType}`);
+  });
+  const returnTypeInner = `{ ${returnTypes.join("; ")} }`;
+  const returnType = shouldBeAsync ? `Promise<${returnTypeInner}>` : returnTypeInner;
+  return [
+    `${keywords}function ${workflow.functionName}(`,
+    // STEP Port Architecture: execute is first parameter
+    `  execute: boolean = true,`,
+    // Record<string, unknown> keeps the function compatible with HTTP handlers
+    `  params: Record<string, unknown> = {},`,
+    // One execution-scoped runtime carries cancellation, tracing, services and
+    // continuation state. It is deliberately required in the v2 generated ABI.
+    `  __runtime__: WorkflowRuntime`,
+    `): ${returnType} {`
+  ];
+}
+function asyncKeyword(shouldBeAsync, production) {
+  return shouldBeAsync || !production ? "async " : "";
+}
+function emitWorkflowFunction(writer, ast, functionBody, shouldBeAsync, production, moduleFormat) {
+  writer.push("");
+  if (writer.mapsSource && ast.sourceFile) {
+    try {
+      const sourceLines = fs2.readFileSync(ast.sourceFile, "utf-8").split(/\r?\n/);
+      const exportLineIndex = sourceLines.findIndex(
+        (line) => line.includes(`export`) && line.includes(`function ${ast.functionName}`)
+      );
+      if (exportLineIndex >= 0) {
+        writer.map(exportLineIndex + 1, 0);
+      }
+    } catch {
+    }
+  }
+  const keywords = generateFunctionExportKeyword(moduleFormat) + asyncKeyword(shouldBeAsync, production);
+  workflowSignature(ast, keywords, shouldBeAsync).forEach((line) => writer.push(line));
+  writer.push(functionBody);
+  writer.push("}");
+}
+function emitLocalWorkflowDependencies(writer, ast, localWorkflowNodes, allWorkflows, production, durableSequential) {
+  if (localWorkflowNodes.length === 0 || allWorkflows.length === 0) return;
+  const generatedWorkflows = /* @__PURE__ */ new Set([ast.functionName]);
+  writer.push("");
+  writer.push("// ============================================================================");
+  writer.push("// Local Workflow Dependencies");
+  writer.push("// ============================================================================");
+  for (const node of localWorkflowNodes) {
+    if (generatedWorkflows.has(node.functionName)) {
+      continue;
+    }
+    const depWorkflow = allWorkflows.find((w) => w.functionName === node.functionName);
+    if (!depWorkflow) {
+      writer.push(`// WARNING: Could not find workflow AST for ${node.functionName}`);
+      continue;
+    }
+    writer.push(generateWorkflowFunction(depWorkflow, production, allWorkflows, generatedWorkflows, durableSequential));
+    writer.push("");
+    generatedWorkflows.add(node.functionName);
+  }
+}
+function generateWorkflowFunction(workflow, production, allWorkflows, generatedWorkflows, durableSequential) {
+  const lines = [];
+  generatedWorkflows.add(workflow.functionName);
+  const usedNodeTypeNames = new Set(workflow.instances.map((i) => i.nodeType));
+  const localWorkflowDeps = workflow.nodeTypes.filter(
+    (n) => n.variant === "IMPORTED_WORKFLOW" && n.sourceLocation?.file === workflow.sourceFile && usedNodeTypeNames.has(n.name) && !generatedWorkflows.has(n.functionName)
+  );
+  for (const dep of localWorkflowDeps) {
+    const depWorkflow = allWorkflows.find((w) => w.functionName === dep.functionName);
+    if (depWorkflow) {
+      lines.push(generateWorkflowFunction(depWorkflow, production, allWorkflows, generatedWorkflows, durableSequential));
+      lines.push("");
+    }
+  }
+  const { shouldBeAsync } = validateWorkflowAsync(workflow, workflow.nodeTypes);
+  const functionBody = bodyGenerator.generateWithExecutionContext(
+    workflow,
+    workflow.nodeTypes,
+    shouldBeAsync,
+    production,
+    false,
+    durableSequential,
+    durableSequential ? { graphFingerprint: graphIdentity(workflow, allWorkflows).graphFingerprint } : void 0
+  );
+  lines.push(...workflowSignature(workflow, asyncKeyword(shouldBeAsync, production), shouldBeAsync));
+  lines.push(functionBody);
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/api/generate.ts
+import * as fs3 from "fs";
+function generateCode(ast, options) {
+  const {
+    production = false,
+    sourceMap = false,
+    allWorkflows = [],
+    moduleFormat = "esm",
+    bundleMode = false,
+    constants = [],
+    externalNodeTypes = {},
+    generateStubs = false,
+    outputFormat = "typescript"
+  } = options || {};
+  const durableSequential = validateDurableClosure(
+    ast,
+    allWorkflows
+  ).hasDurableGate;
+  const identity = durableSequential ? { graphFingerprint: graphIdentity(ast, allWorkflows).graphFingerprint } : void 0;
+  assertNoStubNodes(ast, generateStubs);
+  const { shouldBeAsync, warning } = validateWorkflowAsync(ast, ast.nodeTypes);
+  if (warning && !production) {
+    console.warn(warning);
+  }
+  const functionBody = bodyGenerator.generateWithExecutionContext(
+    ast,
+    ast.nodeTypes,
+    shouldBeAsync,
+    production,
+    bundleMode,
+    durableSequential,
+    identity
+  );
+  const writer = new ModuleWriter(ast.functionName, ast.sourceFile, sourceMap);
+  writer.push("");
+  writer.push("");
+  emitInlineRuntime(writer, production, moduleFormat);
+  emitPreservedTypeDeclarations(writer, ast.sourceFile);
+  const origins = classifyNodeTypes(ast);
+  emitNodeTypeImports(writer, origins, bundleMode, moduleFormat);
+  emitSourceConstants(writer, constants, origins.localFunctions);
+  emitLocalNodeFunctions(writer, origins.localFunctions, externalNodeTypes, moduleFormat, production);
+  emitLocalWorkflowDependencies(writer, ast, origins.localWorkflowNodes, allWorkflows, production, durableSequential);
+  emitWorkflowFunction(writer, ast, functionBody, shouldBeAsync, production, moduleFormat);
+  if (moduleFormat === "cjs") {
+    writer.push("");
+    writer.push(generateModuleExports([ast.functionName, ...INLINE_ENGINE_EXPORTS]));
+  }
+  let code = writer.text();
+  if (outputFormat === "javascript") {
+    code = stripTypeScript(code);
+  }
+  const map = writer.finishSourceMap((file) => fs3.readFileSync(file, "utf8"));
+  if (sourceMap && map !== void 0) {
+    return { code, sourceMap: map };
+  }
+  return code;
+}
+function assertNoStubNodes(ast, generateStubs) {
+  const stubNodeTypes = ast.nodeTypes.filter((nt) => nt.variant === "STUB");
+  if (stubNodeTypes.length > 0 && !generateStubs) {
+    const stubNames = stubNodeTypes.map((nt) => nt.functionName).join(", ");
+    throw new Error(
+      `Cannot generate code: workflow has ${stubNodeTypes.length} stub node(s) without implementation: ${stubNames}. Implement them or pass { generateStubs: true } to emit placeholder throws.`
+    );
+  }
+}
+
+// src/api/compile.ts
+import * as fs4 from "node:fs/promises";
+import * as path2 from "node:path";
+
+// src/compiler/durable-source-proof.ts
+import ts2 from "typescript";
+var authenticProofs = /* @__PURE__ */ new WeakSet();
+var DurableSourceProof = class _DurableSourceProof {
+  effects;
+  constructor(effects) {
+    this.effects = Object.freeze(effects.map((effect) => Object.freeze(effect)));
+    authenticProofs.add(this);
+    Object.freeze(this);
+  }
+  static create(parsed, source) {
+    validateDurableClosure(parsed.ast, parsed.allWorkflows);
+    const effects = durableEffects(parsed).map((effect) => ({
+      functionName: effect.functionName,
+      inputs: Object.freeze(Object.keys(effect.inputs).sort()),
+      outputs: Object.freeze(Object.keys(effect.outputs).sort()),
+      binding: effectReturnBinding(source, effect.functionName, Object.keys(effect.outputs))
+    }));
+    return new _DurableSourceProof(effects);
+  }
+};
+function applyDurableSourceProof(proof, parsed, flattenedSource) {
+  if (!authenticProofs.has(proof)) throw new Error("durable source proof was not issued by this compiler");
+  const actual = durableEffects(parsed);
+  const actualNames = actual.map((effect) => effect.functionName).sort();
+  const expectedNames = proof.effects.map((effect) => effect.functionName).sort();
+  if (actualNames.join(",") !== expectedNames.join(",")) {
+    throw new Error(`flattened durable effect set differs from typed source: expected ${expectedNames.join(", ")}, got ${actualNames.join(", ")}`);
+  }
+  for (const expected of proof.effects) {
+    const effect = actual.find((candidate) => candidate.functionName === expected.functionName);
+    if (!effect) throw new Error(`flattened source lost durable effect ${expected.functionName}`);
+    const inputs = Object.keys(effect.inputs).sort();
+    const outputs = Object.keys(effect.outputs).sort();
+    if (inputs.join(",") !== expected.inputs.join(",") || outputs.join(",") !== expected.outputs.join(",")) {
+      throw new Error(`flattened durable effect ${expected.functionName} ports differ from typed source`);
+    }
+    const binding = effectReturnBinding(flattenedSource, effect.functionName, outputs);
+    if (JSON.stringify(binding) !== JSON.stringify(expected.binding)) {
+      throw new Error(`flattened durable effect ${expected.functionName} return binding differs from typed source`);
+    }
+    effect.durableEffectContract = { valid: true, diagnostics: [] };
+  }
+}
+function durableEffects(parsed) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const workflow of parsed.allWorkflows) {
+    for (const nodeType of workflow.nodeTypes) {
+      if (nodeType.durableEffect === true) byName.set(nodeType.functionName, nodeType);
+    }
+  }
+  for (const nodeType of parsed.ast.nodeTypes) {
+    if (nodeType.durableEffect === true) byName.set(nodeType.functionName, nodeType);
+  }
+  return [...byName.values()].sort((left, right) => left.functionName.localeCompare(right.functionName));
+}
+function effectReturnBinding(source, functionName, outputNames) {
+  const file = ts2.createSourceFile("durable-source.ts", source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  const fn = file.statements.find((statement) => ts2.isFunctionDeclaration(statement) && statement.name?.text === functionName);
+  if (!fn?.body) throw new Error(`durable effect ${functionName} has no concrete function body`);
+  const operationKey = fn.parameters.at(-1)?.name;
+  if (!operationKey || !ts2.isIdentifier(operationKey)) {
+    throw new Error(`durable effect ${functionName} has no identifier operation key parameter`);
+  }
+  const returns = [];
+  const visit = (node) => {
+    if (node !== fn && ts2.isFunctionLike(node)) return;
+    if (ts2.isReturnStatement(node)) returns.push(node);
+    ts2.forEachChild(node, visit);
+  };
+  visit(fn.body);
+  if (returns.length === 0) throw new Error(`durable effect ${functionName} has no return path`);
+  const bindings = returns.map((statement) => bindingForExpression(
+    statement.expression,
+    operationKey.text,
+    outputNames,
+    functionName
+  ));
+  const first = bindings[0];
+  if (bindings.some((binding) => JSON.stringify(binding) !== JSON.stringify(first))) {
+    throw new Error(`durable effect ${functionName} has inconsistent return bindings`);
+  }
+  return first;
+}
+function bindingForExpression(expression, operationKey, outputNames, functionName) {
+  if (expression && ts2.isObjectLiteralExpression(expression)) {
+    const envelope = objectProperties(expression, `${functionName} return envelope`);
+    if ([...envelope.keys()].sort().join(",") !== "receipt,result") {
+      throw new Error(`durable effect ${functionName} must return exactly receipt and result`);
+    }
+    const receipt = envelope.get("receipt");
+    const result = envelope.get("result");
+    if (!receipt || !ts2.isObjectLiteralExpression(receipt) || !result || !ts2.isObjectLiteralExpression(result)) {
+      throw new Error(`durable effect ${functionName} direct return must contain receipt/result object literals`);
+    }
+    const receiptProperties = objectProperties(receipt, `${functionName} receipt`);
+    const key = receiptProperties.get("operationKey");
+    if (!key || !ts2.isIdentifier(key) || key.text !== operationKey) {
+      throw new Error(`durable effect ${functionName} receipt is not bound to operationKey`);
+    }
+    const resultKeys = [...objectProperties(result, `${functionName} result`).keys()].sort();
+    assertResultKeys(functionName, resultKeys, outputNames);
+    return Object.freeze({ kind: "object", resultKeys: Object.freeze(resultKeys) });
+  }
+  if (expression && ts2.isCallExpression(expression) && ts2.isIdentifier(expression.expression)) {
+    const operationKeyIndex = expression.arguments.findIndex(
+      (argument) => ts2.isIdentifier(argument) && argument.text === operationKey
+    );
+    const resultIndex = expression.arguments.findIndex((argument) => {
+      if (!ts2.isObjectLiteralExpression(argument)) return false;
+      const keys = [...objectProperties(argument, `${functionName} result argument`).keys()].sort();
+      return keys.join(",") === [...outputNames].sort().join(",");
+    });
+    if (operationKeyIndex < 0 || resultIndex < 0) {
+      throw new Error(`durable effect ${functionName} helper call is not bound to operationKey and exact result fields`);
+    }
+    const result = expression.arguments[resultIndex];
+    const resultKeys = [...objectProperties(result, `${functionName} result argument`).keys()].sort();
+    return Object.freeze({
+      kind: "call",
+      callee: expression.expression.text,
+      operationKeyIndex,
+      resultIndex,
+      resultKeys: Object.freeze(resultKeys)
+    });
+  }
+  throw new Error(`durable effect ${functionName} return path is not a canonical envelope`);
+}
+function objectProperties(object, label) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const property of object.properties) {
+    if (ts2.isShorthandPropertyAssignment(property)) {
+      properties.set(property.name.text, property.name);
+      continue;
+    }
+    if (!ts2.isPropertyAssignment(property) || !ts2.isIdentifier(property.name)) {
+      throw new Error(`${label} must use explicit identifier properties without spreads`);
+    }
+    properties.set(property.name.text, property.initializer);
+  }
+  return properties;
+}
+function assertResultKeys(functionName, actual, expected) {
+  if ([...actual].sort().join(",") !== [...expected].sort().join(",")) {
+    throw new Error(`durable effect ${functionName} result fields differ from declared outputs`);
+  }
+}
+
+// src/api/compile.ts
+async function compileWorkflow(filePath, options = {}) {
+  const startTime = Date.now();
+  const { inPlace = true } = options;
+  const parseResult = await parseWorkflow(filePath, options.parse);
+  if (parseResult.errors.length > 0) {
+    throw new Error(`Parse errors:
+${parseResult.errors.join("\n")}`);
+  }
+  if (options.durableSourceProof !== void 0) {
+    if (options.durableFlattenedSource === void 0) {
+      throw new Error("durableFlattenedSource is required with durableSourceProof");
+    }
+    applyDurableSourceProof(
+      options.durableSourceProof,
+      parseResult,
+      options.durableFlattenedSource
+    );
+  }
+  validateDurableClosure(parseResult.ast, parseResult.allWorkflows);
+  const { validateWorkflow } = await import("./flow-weaver-validate-A4UWDQN6.mjs");
+  const validationMode = options.validationMode;
+  const validationResult = validateWorkflow(parseResult.ast, validationMode ? { mode: validationMode } : void 0);
+  if (validationResult.errors.length > 0) {
+    const errorMessages = validationResult.errors.map(
+      (e) => typeof e === "string" ? e : e.message
+    );
+    throw new Error(`Validation errors:
+${errorMessages.join("\n")}`);
+  }
+  let code;
+  let outputFile;
+  if (inPlace) {
+    const sourceCode = await fs4.readFile(filePath, "utf-8");
+    const result2 = generateInPlace(sourceCode, parseResult.ast, {
+      ...options.generate,
+      allWorkflows: parseResult.allWorkflows,
+      sourceFile: options.generate?.sourceFile || path2.resolve(filePath)
+    });
+    code = result2.code;
+    outputFile = filePath;
+    if (options.write !== false) {
+      await fs4.writeFile(filePath, code, "utf-8");
+    }
+  } else {
+    code = generateCode(parseResult.ast, {
+      ...options.generate,
+      allWorkflows: parseResult.allWorkflows
+    });
+    outputFile = options.outputFile || getDefaultOutputFile(filePath);
+    if (options.write !== false) {
+      await fs4.writeFile(outputFile, code, "utf-8");
+    }
+  }
+  if (options.saveAST) {
+    const { saveASTAlongside } = await import("./flow-weaver-serialization-node-LE6PCG4M.mjs");
+    await saveASTAlongside(parseResult.ast);
+  }
+  const result = {
+    code,
+    ast: parseResult.ast,
+    analysis: {
+      controlFlowGraph: { nodes: [], edges: [], inDegree: {}, outDegree: {} },
+      executionOrder: [],
+      branchingNodes: [],
+      branchRegions: [],
+      mergeNodes: [],
+      // What validation said about the workflow it just compiled: the
+      // warnings a caller (fw_compile, the console) shows next to the code.
+      errors: validationResult.errors,
+      warnings: validationResult.warnings,
+      unusedNodes: [],
+      inlineCandidates: []
+    },
+    metadata: {
+      sourceFile: filePath,
+      outputFile,
+      compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      compilerVersion: VERSION,
+      generationTime: Date.now() - startTime
+    }
+  };
+  return result;
+}
+function getDefaultOutputFile(sourceFile) {
+  const dir = path2.dirname(sourceFile);
+  const basename3 = path2.basename(sourceFile, ".ts");
+  return path2.join(dir, `${basename3}.generated.ts`);
+}
+
+export {
+  generateCode,
+  DurableSourceProof,
+  applyDurableSourceProof,
+  compileWorkflow
+};