@mondaydotcomorg/atp-compiler 0.19.8 → 0.19.10

package/dist/index.cjs

@@ -0,0 +1,2947 @@
+'use strict';
+
+var parser = require('@babel/parser');
+var _traverse = require('@babel/traverse');
+var _generate = require('@babel/generator');
+var t7 = require('@babel/types');
+var atpRuntime = require('@mondaydotcomorg/atp-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var _traverse__default = /*#__PURE__*/_interopDefault(_traverse);
+var _generate__default = /*#__PURE__*/_interopDefault(_generate);
+var t7__namespace = /*#__PURE__*/_interopNamespace(t7);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/types.ts
+var PAUSABLE_CALL_PATTERNS = [
+  {
+    namespace: "atp.llm",
+    method: "call"
+  },
+  {
+    namespace: "atp.llm",
+    method: "extract"
+  },
+  {
+    namespace: "atp.llm",
+    method: "classify"
+  },
+  {
+    namespace: "atp.llm",
+    method: "stream"
+  },
+  {
+    namespace: "atp.llm",
+    method: "generate"
+  },
+  {
+    namespace: "atp.approval",
+    method: "request"
+  },
+  {
+    namespace: "atp.approval",
+    method: "confirm"
+  },
+  {
+    namespace: "atp.approval",
+    method: "verify"
+  },
+  {
+    namespace: "atp.embedding",
+    method: "embed"
+  },
+  {
+    namespace: "atp.embedding",
+    method: "search"
+  },
+  {
+    namespace: "atp.embedding",
+    method: "create"
+  },
+  {
+    namespace: "atp.embedding",
+    method: "generate"
+  },
+  {
+    namespace: "atp.embedding",
+    method: "encode"
+  }
+];
+var DEFAULT_COMPILER_CONFIG = {
+  enableBatchParallel: true,
+  maxLoopNesting: 10,
+  checkpointInterval: 1,
+  debugMode: false,
+  batchSizeThreshold: 10
+};
+function isPausableCall(node) {
+  if (!t7__namespace.isAwaitExpression(node)) {
+    return false;
+  }
+  const argument = node.argument;
+  if (!t7__namespace.isCallExpression(argument)) {
+    return false;
+  }
+  return isPausableCallExpression(argument);
+}
+__name(isPausableCall, "isPausableCall");
+function isPausableCallExpression(node) {
+  const callee = node.callee;
+  if (!t7__namespace.isMemberExpression(callee)) {
+    return false;
+  }
+  const fullPath = getMemberExpressionPath(callee);
+  return PAUSABLE_CALL_PATTERNS.some((pattern) => fullPath === `${pattern.namespace}.${pattern.method}`);
+}
+__name(isPausableCallExpression, "isPausableCallExpression");
+function getMemberExpressionPath(node) {
+  const parts = [];
+  let current = node;
+  while (t7__namespace.isMemberExpression(current)) {
+    if (t7__namespace.isIdentifier(current.property)) {
+      parts.unshift(current.property.name);
+    }
+    current = current.object;
+  }
+  if (t7__namespace.isIdentifier(current)) {
+    parts.unshift(current.name);
+  }
+  return parts.join(".");
+}
+__name(getMemberExpressionPath, "getMemberExpressionPath");
+function containsAwait(node) {
+  let hasAwait = false;
+  const checkNode = /* @__PURE__ */ __name((n) => {
+    if (t7__namespace.isAwaitExpression(n)) {
+      hasAwait = true;
+      return;
+    }
+    if (hasAwait) return;
+    Object.keys(n).forEach((key) => {
+      const value = n[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object" && item.type) {
+            checkNode(item);
+          }
+        });
+      } else if (value && typeof value === "object" && value.type) {
+        checkNode(value);
+      }
+    });
+  }, "checkNode");
+  checkNode(node);
+  return hasAwait;
+}
+__name(containsAwait, "containsAwait");
+function containsPausableCall(node) {
+  let hasPausable = false;
+  const checkNode = /* @__PURE__ */ __name((n) => {
+    if (t7__namespace.isAwaitExpression(n) && isPausableCall(n)) {
+      hasPausable = true;
+      return;
+    }
+    if (hasPausable) return;
+    Object.keys(n).forEach((key) => {
+      const value = n[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object" && item.type) {
+            checkNode(item);
+          }
+        });
+      } else if (value && typeof value === "object" && value.type) {
+        checkNode(value);
+      }
+    });
+  }, "checkNode");
+  checkNode(node);
+  return hasPausable;
+}
+__name(containsPausableCall, "containsPausableCall");
+function isAsyncFunction(node) {
+  return (t7__namespace.isFunctionDeclaration(node) || t7__namespace.isFunctionExpression(node) || t7__namespace.isArrowFunctionExpression(node)) && node.async === true;
+}
+__name(isAsyncFunction, "isAsyncFunction");
+function getNodeLocation(node) {
+  if (node.loc) {
+    return {
+      line: node.loc.start.line,
+      column: node.loc.start.column
+    };
+  }
+  return void 0;
+}
+__name(getNodeLocation, "getNodeLocation");
+function createRuntimeCall(fnName, args) {
+  return t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier(fnName)), args));
+}
+__name(createRuntimeCall, "createRuntimeCall");
+function wrapInAsyncFunction(body) {
+  return t7__namespace.functionExpression(null, [], t7__namespace.blockStatement(body), false, true);
+}
+__name(wrapInAsyncFunction, "wrapInAsyncFunction");
+function isArrayMethod(node, methodName) {
+  if (!t7__namespace.isCallExpression(node)) {
+    return false;
+  }
+  const callee = node.callee;
+  if (!t7__namespace.isMemberExpression(callee)) {
+    return false;
+  }
+  return t7__namespace.isIdentifier(callee.property) && callee.property.name === methodName;
+}
+__name(isArrayMethod, "isArrayMethod");
+function extractForOfParamName(left) {
+  if (t7__namespace.isVariableDeclaration(left)) {
+    const id = left.declarations[0]?.id;
+    return t7__namespace.isIdentifier(id) ? id.name : "item";
+  } else if (t7__namespace.isIdentifier(left)) {
+    return left.name;
+  } else {
+    return "item";
+  }
+}
+__name(extractForOfParamName, "extractForOfParamName");
+
+// src/transformer/detector.ts
+var traverse = typeof _traverse__default.default.default === "function" ? _traverse__default.default.default : _traverse__default.default;
+var AsyncIterationDetector = class {
+  static {
+    __name(this, "AsyncIterationDetector");
+  }
+  detect(code) {
+    const patterns = [];
+    let batchableParallel = false;
+    try {
+      const ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: [
+          "typescript"
+        ],
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true
+      });
+      traverse(ast, {
+        ForOfStatement: /* @__PURE__ */ __name((path) => {
+          if (containsAwait(path.node.body)) {
+            patterns.push("for-of-await");
+          }
+        }, "ForOfStatement"),
+        WhileStatement: /* @__PURE__ */ __name((path) => {
+          if (containsAwait(path.node.body)) {
+            patterns.push("while-await");
+          }
+        }, "WhileStatement"),
+        CallExpression: /* @__PURE__ */ __name((path) => {
+          const node = path.node;
+          if (isArrayMethod(node, "map")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("map-async");
+            }
+          }
+          if (isArrayMethod(node, "forEach")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("forEach-async");
+            }
+          }
+          if (isArrayMethod(node, "filter")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("filter-async");
+            }
+          }
+          if (isArrayMethod(node, "reduce")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("reduce-async");
+            }
+          }
+          if (isArrayMethod(node, "find")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("find-async");
+            }
+          }
+          if (isArrayMethod(node, "some")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("some-async");
+            }
+          }
+          if (isArrayMethod(node, "every")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("every-async");
+            }
+          }
+          if (isArrayMethod(node, "flatMap")) {
+            const callback = node.arguments[0];
+            if (callback && t7__namespace.isFunction(callback) && callback.async) {
+              patterns.push("flatMap-async");
+            }
+          }
+          if (this.isPromiseAll(node)) {
+            patterns.push("promise-all");
+            if (this.canBatchPromiseAll(node)) {
+              batchableParallel = true;
+            }
+          }
+          if (this.isPromiseAllSettled(node)) {
+            patterns.push("promise-allSettled");
+          }
+        }, "CallExpression")
+      });
+      return {
+        needsTransform: patterns.length > 0,
+        patterns: [
+          ...new Set(patterns)
+        ],
+        batchableParallel
+      };
+    } catch (error) {
+      return {
+        needsTransform: false,
+        patterns: [],
+        batchableParallel: false
+      };
+    }
+  }
+  isPromiseAll(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "all"
+    });
+  }
+  isPromiseAllSettled(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "allSettled"
+    });
+  }
+  canBatchPromiseAll(node) {
+    const arrayArg = node.arguments[0];
+    if (!t7__namespace.isArrayExpression(arrayArg)) {
+      return false;
+    }
+    if (arrayArg.elements.length === 0) {
+      return false;
+    }
+    return arrayArg.elements.every((el) => {
+      if (!el || t7__namespace.isSpreadElement(el)) {
+        return false;
+      }
+      return this.isDirectPausableCall(el);
+    });
+  }
+  isDirectPausableCall(node) {
+    if (t7__namespace.isAwaitExpression(node)) {
+      node = node.argument;
+    }
+    if (!t7__namespace.isCallExpression(node)) {
+      return false;
+    }
+    return isPausableCallExpression(node);
+  }
+};
+
+// src/runtime/context.ts
+var contextStack = [];
+function setRuntimeContext(context) {
+  contextStack.push(context);
+}
+__name(setRuntimeContext, "setRuntimeContext");
+function getRuntimeContext() {
+  const context = contextStack[contextStack.length - 1];
+  if (!context) {
+    throw new Error("No runtime context available. Compiler runtime not properly initialized.");
+  }
+  return context;
+}
+__name(getRuntimeContext, "getRuntimeContext");
+function clearRuntimeContext() {
+  contextStack.pop();
+}
+__name(clearRuntimeContext, "clearRuntimeContext");
+function hasRuntimeContext() {
+  return contextStack.length > 0;
+}
+__name(hasRuntimeContext, "hasRuntimeContext");
+var idCounter = 0;
+function generateUniqueId(prefix) {
+  return `${prefix}_${Date.now()}_${idCounter++}`;
+}
+__name(generateUniqueId, "generateUniqueId");
+function resetIdCounter() {
+  idCounter = 0;
+}
+__name(resetIdCounter, "resetIdCounter");
+var BatchOptimizer = class {
+  static {
+    __name(this, "BatchOptimizer");
+  }
+  arrayMethodsWithEarlyExit = [
+    "find",
+    "some",
+    "every"
+  ];
+  canBatchArrayMethod(callback) {
+    if (!callback.async) {
+      return {
+        canBatch: false,
+        reason: "Not async"
+      };
+    }
+    const body = callback.body;
+    if (!t7__namespace.isBlockStatement(body)) {
+      if (t7__namespace.isAwaitExpression(body)) {
+        if (this.isDirectPausableCall(body.argument)) {
+          return {
+            canBatch: true,
+            llmCallPattern: "single",
+            hasConditionals: false
+          };
+        }
+      }
+      return {
+        canBatch: false,
+        reason: "Non-block body without direct call"
+      };
+    }
+    const statements = body.body;
+    if (statements.length === 0) {
+      return {
+        canBatch: false,
+        reason: "Empty body"
+      };
+    }
+    let hasConditionals = false;
+    let hasLoops = false;
+    let hasTryCatch = false;
+    for (const stmt of statements) {
+      if (t7__namespace.isIfStatement(stmt) || t7__namespace.isSwitchStatement(stmt)) {
+        hasConditionals = true;
+      }
+      if (t7__namespace.isTryStatement(stmt)) {
+        hasTryCatch = true;
+      }
+      if (t7__namespace.isForStatement(stmt) || t7__namespace.isForOfStatement(stmt) || t7__namespace.isForInStatement(stmt) || t7__namespace.isWhileStatement(stmt) || t7__namespace.isDoWhileStatement(stmt)) {
+        hasLoops = true;
+      }
+      if (t7__namespace.isBreakStatement(stmt) || t7__namespace.isContinueStatement(stmt)) {
+        return {
+          canBatch: false,
+          reason: "Contains break/continue"
+        };
+      }
+      if (t7__namespace.isReturnStatement(stmt) && stmt !== statements[statements.length - 1]) {
+        return {
+          canBatch: false,
+          reason: "Early return"
+        };
+      }
+    }
+    if (hasLoops) {
+      return {
+        canBatch: false,
+        reason: "Contains loops",
+        hasLoops: true
+      };
+    }
+    if (hasTryCatch) {
+      return {
+        canBatch: false,
+        reason: "Contains try-catch"
+      };
+    }
+    const pausableCalls = this.countPausableCalls(body);
+    if (pausableCalls === 0) {
+      return {
+        canBatch: false,
+        reason: "No pausable calls"
+      };
+    }
+    if (pausableCalls > 1) {
+      return {
+        canBatch: false,
+        reason: "Multiple pausable calls",
+        llmCallPattern: "multiple"
+      };
+    }
+    if (hasConditionals) {
+      return {
+        canBatch: true,
+        llmCallPattern: "conditional",
+        hasConditionals: true,
+        reason: "Simple conditional - can batch but consider array size"
+      };
+    }
+    return {
+      canBatch: true,
+      llmCallPattern: "single",
+      hasConditionals: false
+    };
+  }
+  /**
+  * Smart decision: Should we batch based on array size and method type?
+  */
+  makeSmartBatchDecision(methodName, batchResult, arrayNode, threshold = 10) {
+    if (!batchResult.canBatch) {
+      return {
+        shouldBatch: false,
+        reason: "Complex callback - use sequential",
+        strategy: "never-batch"
+      };
+    }
+    if (!batchResult.hasConditionals) {
+      return {
+        shouldBatch: true,
+        reason: "Simple callback - batching is faster",
+        strategy: "always-batch"
+      };
+    }
+    const hasEarlyExitBenefit = this.arrayMethodsWithEarlyExit.includes(methodName);
+    if (!hasEarlyExitBenefit) {
+      const arraySize2 = this.estimateArraySize(arrayNode);
+      if (arraySize2 !== null && arraySize2 < threshold) {
+        return {
+          shouldBatch: true,
+          reason: `Small array (${arraySize2} < ${threshold}) - batch despite conditionals`,
+          strategy: "size-dependent"
+        };
+      }
+      return {
+        shouldBatch: false,
+        reason: "Conditionals + large/unknown array - sequential for safety",
+        strategy: "size-dependent"
+      };
+    }
+    const arraySize = this.estimateArraySize(arrayNode);
+    if (arraySize !== null && arraySize < threshold) {
+      return {
+        shouldBatch: true,
+        reason: `Small array (${arraySize} < ${threshold}) - batch for speed`,
+        strategy: "size-dependent"
+      };
+    }
+    if (arraySize !== null && arraySize >= threshold) {
+      return {
+        shouldBatch: false,
+        reason: `Large array (${arraySize} >= ${threshold}) + conditionals - sequential for early-exit savings`,
+        strategy: "size-dependent"
+      };
+    }
+    if (t7__namespace.isArrayExpression(arrayNode)) {
+      return {
+        shouldBatch: true,
+        reason: "Array literal (likely small) - batch",
+        strategy: "size-dependent"
+      };
+    }
+    return {
+      shouldBatch: false,
+      reason: "Unknown array size + conditionals - sequential for safety",
+      strategy: "size-dependent"
+    };
+  }
+  estimateArraySize(arrayNode) {
+    if (t7__namespace.isArrayExpression(arrayNode)) {
+      return arrayNode.elements.length;
+    }
+    return null;
+  }
+  canBatchForOfLoop(loopNode) {
+    const body = loopNode.body;
+    if (!t7__namespace.isBlockStatement(body)) {
+      return {
+        canBatch: false,
+        reason: "Loop body not a block"
+      };
+    }
+    const statements = body.body;
+    if (statements.length === 0) {
+      return {
+        canBatch: false,
+        reason: "Empty loop body"
+      };
+    }
+    const hasBreakOrContinue = this.containsBreakOrContinue(body);
+    if (hasBreakOrContinue) {
+      return {
+        canBatch: false,
+        reason: "Contains break/continue"
+      };
+    }
+    let hasConditionals = false;
+    for (const stmt of statements) {
+      if (t7__namespace.isIfStatement(stmt) || t7__namespace.isSwitchStatement(stmt)) {
+        hasConditionals = true;
+      }
+      if (t7__namespace.isForStatement(stmt) || t7__namespace.isForOfStatement(stmt) || t7__namespace.isForInStatement(stmt) || t7__namespace.isWhileStatement(stmt) || t7__namespace.isDoWhileStatement(stmt)) {
+        return {
+          canBatch: false,
+          reason: "Contains nested loops",
+          hasLoops: true
+        };
+      }
+    }
+    const pausableCalls = this.countPausableCalls(body);
+    if (pausableCalls === 0) {
+      return {
+        canBatch: false,
+        reason: "No pausable calls"
+      };
+    }
+    if (pausableCalls > 1) {
+      return {
+        canBatch: false,
+        reason: "Multiple pausable calls",
+        llmCallPattern: "multiple"
+      };
+    }
+    if (hasConditionals) {
+      return {
+        canBatch: true,
+        llmCallPattern: "conditional",
+        hasConditionals: true,
+        reason: "Simple conditional - can batch but consider array size"
+      };
+    }
+    return {
+      canBatch: true,
+      llmCallPattern: "single",
+      hasConditionals: false
+    };
+  }
+  containsBreakOrContinue(node) {
+    let found = false;
+    const visit = /* @__PURE__ */ __name((n) => {
+      if (found) return;
+      if (t7__namespace.isBreakStatement(n) || t7__namespace.isContinueStatement(n)) {
+        found = true;
+        return;
+      }
+      if (t7__namespace.isForStatement(n) || t7__namespace.isForOfStatement(n) || t7__namespace.isForInStatement(n) || t7__namespace.isWhileStatement(n) || t7__namespace.isDoWhileStatement(n)) {
+        return;
+      }
+      Object.keys(n).forEach((key) => {
+        const value = n[key];
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            if (item && typeof item === "object" && item.type) {
+              visit(item);
+            }
+          });
+        } else if (value && typeof value === "object" && value.type) {
+          visit(value);
+        }
+      });
+    }, "visit");
+    visit(node);
+    return found;
+  }
+  isDirectPausableCall(node) {
+    if (!t7__namespace.isCallExpression(node)) {
+      return false;
+    }
+    return isPausableCallExpression(node);
+  }
+  countPausableCalls(body) {
+    let count = 0;
+    const visit = /* @__PURE__ */ __name((node) => {
+      if (t7__namespace.isAwaitExpression(node) && this.isDirectPausableCall(node.argument)) {
+        count++;
+        return;
+      }
+      Object.keys(node).forEach((key) => {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            if (item && typeof item === "object" && item.type) {
+              visit(item);
+            }
+          });
+        } else if (value && typeof value === "object" && value.type) {
+          visit(value);
+        }
+      });
+    }, "visit");
+    visit(body);
+    return count;
+  }
+};
+var BatchParallelDetector = class {
+  static {
+    __name(this, "BatchParallelDetector");
+  }
+  canBatch(promiseAllNode) {
+    const arrayArg = promiseAllNode.arguments[0];
+    if (!t7__namespace.isArrayExpression(arrayArg)) {
+      return false;
+    }
+    if (arrayArg.elements.length === 0) {
+      return false;
+    }
+    return arrayArg.elements.every((el) => {
+      if (!el || t7__namespace.isSpreadElement(el)) {
+        return false;
+      }
+      return this.isDirectPausableCall(el);
+    });
+  }
+  isDirectPausableCall(node) {
+    if (t7__namespace.isAwaitExpression(node)) {
+      node = node.argument;
+    }
+    if (!t7__namespace.isCallExpression(node)) {
+      return false;
+    }
+    return isPausableCallExpression(node);
+  }
+  extractBatchCalls(arrayNode) {
+    const calls = [];
+    for (const el of arrayNode.elements) {
+      if (!el || t7__namespace.isSpreadElement(el)) {
+        continue;
+      }
+      let callNode = el;
+      if (t7__namespace.isAwaitExpression(callNode)) {
+        callNode = callNode.argument;
+      }
+      if (!t7__namespace.isCallExpression(callNode)) {
+        continue;
+      }
+      const callInfo = this.extractCallInfo(callNode);
+      if (callInfo) {
+        calls.push(callInfo);
+      }
+    }
+    return calls;
+  }
+  extractCallInfo(callNode) {
+    if (!t7__namespace.isMemberExpression(callNode.callee)) {
+      return null;
+    }
+    const path = getMemberExpressionPath(callNode.callee);
+    const parts = path.split(".");
+    if (parts.length < 3) {
+      return null;
+    }
+    const [namespace, service, method] = parts;
+    if (namespace !== "atp" || !method) {
+      return null;
+    }
+    const type = service;
+    const payload = this.extractPayload(callNode.arguments);
+    return {
+      type,
+      operation: method,
+      payload
+    };
+  }
+  /**
+  * Extract payload AST node directly
+  */
+  extractPayloadNode(callNode) {
+    if (callNode.arguments.length === 0) {
+      return t7__namespace.objectExpression([]);
+    }
+    const firstArg = callNode.arguments[0];
+    if (!firstArg || t7__namespace.isSpreadElement(firstArg) || !t7__namespace.isExpression(firstArg)) {
+      return null;
+    }
+    return firstArg;
+  }
+  extractPayload(args) {
+    if (args.length === 0) {
+      return {};
+    }
+    const firstArg = args[0];
+    if (t7__namespace.isSpreadElement(firstArg)) {
+      return {};
+    }
+    if (t7__namespace.isObjectExpression(firstArg)) {
+      return this.objectExpressionToRecord(firstArg);
+    }
+    if (t7__namespace.isStringLiteral(firstArg)) {
+      return {
+        message: firstArg.value
+      };
+    }
+    return {};
+  }
+  objectExpressionToRecord(obj) {
+    const record = {};
+    for (const prop of obj.properties) {
+      if (t7__namespace.isObjectProperty(prop) && !prop.computed) {
+        const key = t7__namespace.isIdentifier(prop.key) ? prop.key.name : String(prop.key);
+        const value = this.extractValue(prop.value);
+        record[key] = value;
+      }
+    }
+    return record;
+  }
+  extractValue(node) {
+    if (t7__namespace.isStringLiteral(node)) {
+      return node.value;
+    }
+    if (t7__namespace.isNumericLiteral(node)) {
+      return node.value;
+    }
+    if (t7__namespace.isBooleanLiteral(node)) {
+      return node.value;
+    }
+    if (t7__namespace.isNullLiteral(node)) {
+      return null;
+    }
+    if (t7__namespace.isArrayExpression(node)) {
+      return node.elements.map((el) => el && !t7__namespace.isSpreadElement(el) ? this.extractValue(el) : null);
+    }
+    if (t7__namespace.isObjectExpression(node)) {
+      return this.objectExpressionToRecord(node);
+    }
+    return void 0;
+  }
+};
+function findLLMCallExpression(body) {
+  let found = null;
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (found) return;
+    if (t7__namespace.isAwaitExpression(node) && t7__namespace.isCallExpression(node.argument)) {
+      const call = node.argument;
+      if (t7__namespace.isMemberExpression(call.callee)) {
+        found = call;
+        return;
+      }
+    }
+    Object.keys(node).forEach((key) => {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object" && item.type) {
+            visit(item);
+          }
+        });
+      } else if (value && typeof value === "object" && value.type) {
+        visit(value);
+      }
+    });
+  }, "visit");
+  visit(body);
+  return found;
+}
+__name(findLLMCallExpression, "findLLMCallExpression");
+function getArrayMethodName(node) {
+  const arrayMethods = [
+    "map",
+    "forEach",
+    "filter",
+    "reduce",
+    "find",
+    "some",
+    "every",
+    "flatMap"
+  ];
+  for (const method of arrayMethods) {
+    if (isArrayMethod(node, method)) {
+      return method;
+    }
+  }
+  return null;
+}
+__name(getArrayMethodName, "getArrayMethodName");
+function getRuntimeMethodName(arrayMethod) {
+  const mapping = {
+    map: "resumableMap",
+    forEach: "resumableForEach",
+    filter: "resumableFilter",
+    reduce: "resumableReduce",
+    find: "resumableFind",
+    some: "resumableSome",
+    every: "resumableEvery",
+    flatMap: "resumableFlatMap"
+  };
+  return mapping[arrayMethod] || null;
+}
+__name(getRuntimeMethodName, "getRuntimeMethodName");
+function canUseBatchParallel(methodName) {
+  return [
+    "map",
+    "forEach",
+    "filter",
+    "find",
+    "some",
+    "every"
+  ].includes(methodName);
+}
+__name(canUseBatchParallel, "canUseBatchParallel");
+
+// src/transformer/loop-transformer.ts
+var LoopTransformer = class {
+  static {
+    __name(this, "LoopTransformer");
+  }
+  transformCount = 0;
+  batchOptimizer;
+  batchDetector;
+  batchSizeThreshold;
+  constructor(batchSizeThreshold = 10) {
+    this.batchOptimizer = new BatchOptimizer();
+    this.batchDetector = new BatchParallelDetector();
+    this.batchSizeThreshold = batchSizeThreshold;
+  }
+  transformForOfLoop(path) {
+    const node = path.node;
+    if (!containsAwait(node.body)) {
+      return false;
+    }
+    const batchResult = this.batchOptimizer.canBatchForOfLoop(node);
+    if (batchResult.canBatch) {
+      const decision = this.batchOptimizer.makeSmartBatchDecision("for...of", batchResult, node.right, this.batchSizeThreshold);
+      if (decision.shouldBatch) {
+        return this.transformForOfToBatch(path, node);
+      }
+    }
+    return this.transformForOfToSequential(path, node);
+  }
+  /**
+  * Transform simple for...of to batch parallel
+  */
+  transformForOfToBatch(path, node) {
+    const loopId = generateUniqueId("for_of_batch");
+    const right = node.right;
+    const paramName = extractForOfParamName(node.left);
+    const llmCall = findLLMCallExpression(node.body);
+    if (!llmCall) {
+      return this.transformForOfToSequential(path, node);
+    }
+    const callInfo = this.batchDetector.extractCallInfo(llmCall);
+    if (!callInfo) {
+      return this.transformForOfToSequential(path, node);
+    }
+    const payloadNode = this.batchDetector.extractPayloadNode(llmCall);
+    if (!payloadNode) {
+      return this.transformForOfToSequential(path, node);
+    }
+    const batchCallsArray = t7__namespace.callExpression(t7__namespace.memberExpression(right, t7__namespace.identifier("map")), [
+      t7__namespace.arrowFunctionExpression([
+        t7__namespace.identifier(paramName)
+      ], t7__namespace.objectExpression([
+        t7__namespace.objectProperty(t7__namespace.identifier("type"), t7__namespace.stringLiteral(callInfo.type)),
+        t7__namespace.objectProperty(t7__namespace.identifier("operation"), t7__namespace.stringLiteral(callInfo.operation)),
+        t7__namespace.objectProperty(t7__namespace.identifier("payload"), payloadNode)
+      ]))
+    ]);
+    const batchCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("batchParallel")), [
+      batchCallsArray,
+      t7__namespace.stringLiteral(loopId)
+    ]));
+    path.replaceWith(t7__namespace.expressionStatement(batchCall));
+    this.transformCount++;
+    return true;
+  }
+  /**
+  * Transform for...of to sequential with checkpoints (fallback)
+  */
+  transformForOfToSequential(path, node) {
+    const loopId = generateUniqueId("for_of");
+    const right = node.right;
+    const paramName = extractForOfParamName(node.left);
+    const bodyStatements = t7__namespace.isBlockStatement(node.body) ? node.body.body : [
+      node.body
+    ];
+    const callbackFn = t7__namespace.arrowFunctionExpression([
+      t7__namespace.identifier(paramName),
+      t7__namespace.identifier("__index")
+    ], t7__namespace.blockStatement(bodyStatements), true);
+    const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("resumableForOf")), [
+      right,
+      callbackFn,
+      t7__namespace.stringLiteral(loopId)
+    ]));
+    path.replaceWith(t7__namespace.expressionStatement(runtimeCall));
+    this.transformCount++;
+    return true;
+  }
+  transformWhileLoop(path) {
+    const node = path.node;
+    if (!containsAwait(node.body)) {
+      return false;
+    }
+    const loopId = generateUniqueId("while");
+    const conditionFn = t7__namespace.arrowFunctionExpression([], node.test, false);
+    const bodyStatements = t7__namespace.isBlockStatement(node.body) ? node.body.body : [
+      node.body
+    ];
+    const bodyFn = t7__namespace.arrowFunctionExpression([
+      t7__namespace.identifier("__iteration")
+    ], t7__namespace.blockStatement(bodyStatements), true);
+    const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("resumableWhile")), [
+      conditionFn,
+      bodyFn,
+      t7__namespace.stringLiteral(loopId)
+    ]));
+    path.replaceWith(t7__namespace.expressionStatement(runtimeCall));
+    this.transformCount++;
+    return true;
+  }
+  transformForLoop(path) {
+    const node = path.node;
+    if (!containsAwait(node.body)) {
+      return false;
+    }
+    if (!node.init || !node.test || !node.update) {
+      return false;
+    }
+    const loopId = generateUniqueId("for");
+    let initValue = t7__namespace.numericLiteral(0);
+    let loopVar = "__i";
+    if (t7__namespace.isVariableDeclaration(node.init)) {
+      const decl = node.init.declarations[0];
+      if (decl && t7__namespace.isIdentifier(decl.id) && decl.init) {
+        loopVar = decl.id.name;
+        initValue = decl.init;
+      }
+    }
+    const conditionFn = t7__namespace.arrowFunctionExpression([
+      t7__namespace.identifier(loopVar)
+    ], node.test, false);
+    const bodyStatements = t7__namespace.isBlockStatement(node.body) ? node.body.body : [
+      node.body
+    ];
+    const bodyFn = t7__namespace.arrowFunctionExpression([
+      t7__namespace.identifier(loopVar)
+    ], t7__namespace.blockStatement(bodyStatements), true);
+    let incrementFn;
+    if (t7__namespace.isUpdateExpression(node.update)) {
+      if (node.update.operator === "++") {
+        incrementFn = t7__namespace.arrowFunctionExpression([
+          t7__namespace.identifier(loopVar)
+        ], t7__namespace.binaryExpression("+", t7__namespace.identifier(loopVar), t7__namespace.numericLiteral(1)), false);
+      } else if (node.update.operator === "--") {
+        incrementFn = t7__namespace.arrowFunctionExpression([
+          t7__namespace.identifier(loopVar)
+        ], t7__namespace.binaryExpression("-", t7__namespace.identifier(loopVar), t7__namespace.numericLiteral(1)), false);
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+    const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("resumableForLoop")), [
+      initValue,
+      conditionFn,
+      incrementFn,
+      bodyFn,
+      t7__namespace.stringLiteral(loopId)
+    ]));
+    path.replaceWith(t7__namespace.expressionStatement(runtimeCall));
+    this.transformCount++;
+    return true;
+  }
+  getTransformCount() {
+    return this.transformCount;
+  }
+  resetTransformCount() {
+    this.transformCount = 0;
+  }
+};
+function wrapFilterResult(batchCall, array, methodId) {
+  const resultsVar = `__filter_results_${methodId}`;
+  const indexVar = `__i_${methodId}`;
+  const arrayClone = t7__namespace.cloneNode(array, true);
+  return t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.arrowFunctionExpression([], t7__namespace.blockStatement([
+    t7__namespace.variableDeclaration("const", [
+      t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall.argument)
+    ]),
+    t7__namespace.returnStatement(t7__namespace.callExpression(t7__namespace.memberExpression(arrayClone, t7__namespace.identifier("filter")), [
+      t7__namespace.arrowFunctionExpression([
+        t7__namespace.identifier("_"),
+        t7__namespace.identifier(indexVar)
+      ], t7__namespace.callExpression(t7__namespace.identifier("Boolean"), [
+        t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier(indexVar), true)
+      ]))
+    ]))
+  ]), true), []));
+}
+__name(wrapFilterResult, "wrapFilterResult");
+function wrapFindResult(batchCall, array, methodId) {
+  const resultsVar = `__find_results_${methodId}`;
+  const arrayClone = t7__namespace.cloneNode(array, true);
+  return t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.arrowFunctionExpression([], t7__namespace.blockStatement([
+    t7__namespace.variableDeclaration("const", [
+      t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall.argument)
+    ]),
+    t7__namespace.returnStatement(t7__namespace.callExpression(t7__namespace.memberExpression(arrayClone, t7__namespace.identifier("find")), [
+      t7__namespace.arrowFunctionExpression([
+        t7__namespace.identifier("_"),
+        t7__namespace.identifier("__i")
+      ], t7__namespace.callExpression(t7__namespace.identifier("Boolean"), [
+        t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier("__i"), true)
+      ]))
+    ]))
+  ]), true), []));
+}
+__name(wrapFindResult, "wrapFindResult");
+function wrapSomeResult(batchCall, methodId) {
+  const resultsVar = `__some_results_${methodId}`;
+  return t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.arrowFunctionExpression([], t7__namespace.blockStatement([
+    t7__namespace.variableDeclaration("const", [
+      t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall.argument)
+    ]),
+    t7__namespace.returnStatement(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier("some")), [
+      t7__namespace.arrowFunctionExpression([
+        t7__namespace.identifier("r")
+      ], t7__namespace.callExpression(t7__namespace.identifier("Boolean"), [
+        t7__namespace.identifier("r")
+      ]))
+    ]))
+  ]), true), []));
+}
+__name(wrapSomeResult, "wrapSomeResult");
+function wrapEveryResult(batchCall, methodId) {
+  const resultsVar = `__every_results_${methodId}`;
+  return t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.arrowFunctionExpression([], t7__namespace.blockStatement([
+    t7__namespace.variableDeclaration("const", [
+      t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall.argument)
+    ]),
+    t7__namespace.returnStatement(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier("every")), [
+      t7__namespace.arrowFunctionExpression([
+        t7__namespace.identifier("r")
+      ], t7__namespace.callExpression(t7__namespace.identifier("Boolean"), [
+        t7__namespace.identifier("r")
+      ]))
+    ]))
+  ]), true), []));
+}
+__name(wrapEveryResult, "wrapEveryResult");
+function wrapBatchResultIfNeeded(batchCall, methodName, array, methodId) {
+  switch (methodName) {
+    case "filter":
+      return wrapFilterResult(batchCall, array, methodId);
+    case "find":
+      return wrapFindResult(batchCall, array, methodId);
+    case "some":
+      return wrapSomeResult(batchCall, methodId);
+    case "every":
+      return wrapEveryResult(batchCall, methodId);
+    case "forEach":
+      return batchCall;
+    default:
+      return batchCall;
+  }
+}
+__name(wrapBatchResultIfNeeded, "wrapBatchResultIfNeeded");
+
+// src/transformer/array-transformer-batch.ts
+function extractBatchCallInfo(callback, batchDetector) {
+  const paramName = callback.params[0];
+  if (!t7__namespace.isIdentifier(paramName)) {
+    return null;
+  }
+  const param = paramName.name;
+  const llmCall = findLLMCallExpression(callback.body);
+  if (!llmCall) {
+    return null;
+  }
+  const callInfo = batchDetector.extractCallInfo(llmCall);
+  if (!callInfo) {
+    return null;
+  }
+  const payloadNode = batchDetector.extractPayloadNode(llmCall);
+  if (!payloadNode) {
+    return null;
+  }
+  const mapperFunction = t7__namespace.arrowFunctionExpression([
+    t7__namespace.identifier(param)
+  ], t7__namespace.objectExpression([
+    t7__namespace.objectProperty(t7__namespace.identifier("type"), t7__namespace.stringLiteral(callInfo.type)),
+    t7__namespace.objectProperty(t7__namespace.identifier("operation"), t7__namespace.stringLiteral(callInfo.operation)),
+    t7__namespace.objectProperty(t7__namespace.identifier("payload"), payloadNode)
+  ]));
+  return {
+    mapperFunction
+  };
+}
+__name(extractBatchCallInfo, "extractBatchCallInfo");
+function transformToBatchParallel(path, node, methodName, callback, batchDetector, onTransform, fallbackTransform) {
+  const methodId = generateUniqueId(`${methodName}_batch`);
+  const array = node.callee.object;
+  const callInfo = extractBatchCallInfo(callback, batchDetector);
+  if (!callInfo) {
+    return fallbackTransform();
+  }
+  const batchCallsArray = t7__namespace.callExpression(t7__namespace.memberExpression(array, t7__namespace.identifier("map")), [
+    callInfo.mapperFunction
+  ]);
+  const batchCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("batchParallel")), [
+    batchCallsArray,
+    t7__namespace.stringLiteral(methodId)
+  ]));
+  const finalCall = wrapBatchResultIfNeeded(batchCall, methodName, array, methodId);
+  path.replaceWith(finalCall);
+  onTransform();
+  return true;
+}
+__name(transformToBatchParallel, "transformToBatchParallel");
+function transformToSequential(path, node, methodName, callback, onTransform) {
+  const runtimeMethod = getRuntimeMethodName(methodName);
+  if (!runtimeMethod) {
+    return false;
+  }
+  const methodId = generateUniqueId(methodName);
+  const array = node.callee.object;
+  const args = [
+    array,
+    callback,
+    t7__namespace.stringLiteral(methodId)
+  ];
+  if (methodName === "reduce" && node.arguments[1]) {
+    args.push(node.arguments[1]);
+  }
+  const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier(runtimeMethod)), args));
+  path.replaceWith(runtimeCall);
+  onTransform();
+  return true;
+}
+__name(transformToSequential, "transformToSequential");
+
+// src/transformer/array-transformer.ts
+var ArrayTransformer = class {
+  static {
+    __name(this, "ArrayTransformer");
+  }
+  transformCount = 0;
+  batchOptimizer;
+  batchDetector;
+  batchSizeThreshold;
+  constructor(batchSizeThreshold = 10) {
+    this.batchOptimizer = new BatchOptimizer();
+    this.batchDetector = new BatchParallelDetector();
+    this.batchSizeThreshold = batchSizeThreshold;
+  }
+  transformArrayMethod(path) {
+    const node = path.node;
+    const methodName = getArrayMethodName(node);
+    if (!methodName) {
+      return false;
+    }
+    const callback = node.arguments[0];
+    if (!callback || !t7__namespace.isFunction(callback) || !callback.async) {
+      return false;
+    }
+    const batchResult = this.batchOptimizer.canBatchArrayMethod(callback);
+    if (batchResult.canBatch && canUseBatchParallel(methodName)) {
+      const array = node.callee.object;
+      const decision = this.batchOptimizer.makeSmartBatchDecision(methodName, batchResult, array, this.batchSizeThreshold);
+      if (decision.shouldBatch) {
+        return transformToBatchParallel(path, node, methodName, callback, this.batchDetector, () => this.transformCount++, () => this.doTransformToSequential(path, node, methodName, callback));
+      }
+    }
+    return this.doTransformToSequential(path, node, methodName, callback);
+  }
+  doTransformToSequential(path, node, methodName, callback) {
+    return transformToSequential(path, node, methodName, callback, () => this.transformCount++);
+  }
+  getTransformCount() {
+    return this.transformCount;
+  }
+  resetTransformCount() {
+    this.transformCount = 0;
+  }
+};
+
+// src/runtime/runtime-functions.ts
+var RuntimeFunction = {
+  // Promise operations
+  RESUMABLE_PROMISE_ALL: "resumablePromiseAll",
+  RESUMABLE_PROMISE_ALL_SETTLED: "resumablePromiseAllSettled",
+  BATCH_PARALLEL: "batchParallel",
+  // Loop operations
+  RESUMABLE_FOR_OF: "resumableForOf",
+  RESUMABLE_FOR_LOOP: "resumableForLoop",
+  RESUMABLE_WHILE: "resumableWhile",
+  // Array method operations
+  RESUMABLE_MAP: "resumableMap",
+  RESUMABLE_FOR_EACH: "resumableForEach",
+  RESUMABLE_FILTER: "resumableFilter",
+  RESUMABLE_REDUCE: "resumableReduce",
+  RESUMABLE_FIND: "resumableFind",
+  RESUMABLE_SOME: "resumableSome",
+  RESUMABLE_EVERY: "resumableEvery",
+  RESUMABLE_FLAT_MAP: "resumableFlatMap"
+};
+var IN_ISOLATE_RUNTIME_FUNCTIONS = [
+  RuntimeFunction.RESUMABLE_PROMISE_ALL,
+  RuntimeFunction.RESUMABLE_PROMISE_ALL_SETTLED,
+  RuntimeFunction.RESUMABLE_FOR_OF,
+  RuntimeFunction.RESUMABLE_FOR_LOOP,
+  RuntimeFunction.RESUMABLE_WHILE,
+  RuntimeFunction.RESUMABLE_MAP,
+  RuntimeFunction.RESUMABLE_FOR_EACH,
+  RuntimeFunction.RESUMABLE_FILTER,
+  RuntimeFunction.RESUMABLE_REDUCE,
+  RuntimeFunction.RESUMABLE_FIND,
+  RuntimeFunction.RESUMABLE_SOME,
+  RuntimeFunction.RESUMABLE_EVERY,
+  RuntimeFunction.RESUMABLE_FLAT_MAP
+];
+function isInIsolateRuntimeFunction(name) {
+  return IN_ISOLATE_RUNTIME_FUNCTIONS.includes(name);
+}
+__name(isInIsolateRuntimeFunction, "isInIsolateRuntimeFunction");
+
+// src/transformer/promise-transformer.ts
+var PromiseTransformer = class {
+  static {
+    __name(this, "PromiseTransformer");
+  }
+  transformCount = 0;
+  batchDetector;
+  enableBatchParallel;
+  constructor(enableBatchParallel = true) {
+    this.batchDetector = new BatchParallelDetector();
+    this.enableBatchParallel = enableBatchParallel;
+  }
+  transformPromiseAll(path) {
+    const node = path.node;
+    if (!this.isPromiseAll(node)) {
+      return false;
+    }
+    const arrayArg = node.arguments[0];
+    if (this.enableBatchParallel && this.batchDetector.canBatch(node)) {
+      return this.transformToBatchParallel(path, node);
+    }
+    if (t7__namespace.isArrayExpression(arrayArg)) {
+      return this.transformToSequential(path, node);
+    }
+    return false;
+  }
+  transformPromiseAllSettled(path) {
+    const node = path.node;
+    if (!this.isPromiseAllSettled(node)) {
+      return false;
+    }
+    const arrayArg = node.arguments[0];
+    if (t7__namespace.isArrayExpression(arrayArg)) {
+      const parallelId = generateUniqueId("allSettled");
+      const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier(RuntimeFunction.RESUMABLE_PROMISE_ALL_SETTLED)), [
+        arrayArg,
+        t7__namespace.stringLiteral(parallelId)
+      ]));
+      path.replaceWith(runtimeCall);
+      this.transformCount++;
+      return true;
+    }
+    return false;
+  }
+  transformToBatchParallel(path, node) {
+    const arrayArg = node.arguments[0];
+    if (!t7__namespace.isArrayExpression(arrayArg)) {
+      return false;
+    }
+    const batchId = generateUniqueId("batch");
+    const batchCallsArray = t7__namespace.arrayExpression(arrayArg.elements.map((el) => {
+      if (!el || t7__namespace.isSpreadElement(el)) {
+        return t7__namespace.nullLiteral();
+      }
+      let callNode = el;
+      if (t7__namespace.isAwaitExpression(callNode)) {
+        callNode = callNode.argument;
+      }
+      if (!t7__namespace.isCallExpression(callNode) || !t7__namespace.isMemberExpression(callNode.callee)) {
+        return t7__namespace.nullLiteral();
+      }
+      const callInfo = this.batchDetector.extractCallInfo(callNode);
+      if (!callInfo) {
+        return t7__namespace.nullLiteral();
+      }
+      const payloadArg = callNode.arguments[0];
+      return t7__namespace.objectExpression([
+        t7__namespace.objectProperty(t7__namespace.identifier("type"), t7__namespace.stringLiteral(callInfo.type)),
+        t7__namespace.objectProperty(t7__namespace.identifier("operation"), t7__namespace.stringLiteral(callInfo.operation)),
+        t7__namespace.objectProperty(t7__namespace.identifier("payload"), payloadArg && t7__namespace.isExpression(payloadArg) ? payloadArg : t7__namespace.objectExpression([]))
+      ]);
+    }));
+    const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier(RuntimeFunction.BATCH_PARALLEL)), [
+      batchCallsArray,
+      t7__namespace.stringLiteral(batchId)
+    ]));
+    path.replaceWith(runtimeCall);
+    this.transformCount++;
+    return true;
+  }
+  transformToSequential(path, node) {
+    const arrayArg = node.arguments[0];
+    if (!t7__namespace.isArrayExpression(arrayArg)) {
+      return false;
+    }
+    const parallelId = generateUniqueId("parallel");
+    const runtimeCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier(RuntimeFunction.RESUMABLE_PROMISE_ALL)), [
+      arrayArg,
+      t7__namespace.stringLiteral(parallelId)
+    ]));
+    path.replaceWith(runtimeCall);
+    this.transformCount++;
+    return true;
+  }
+  payloadToExpression(payload) {
+    const properties = [];
+    for (const [key, value] of Object.entries(payload)) {
+      properties.push(t7__namespace.objectProperty(t7__namespace.identifier(key), this.valueToExpression(value)));
+    }
+    return t7__namespace.objectExpression(properties);
+  }
+  valueToExpression(value) {
+    if (typeof value === "string") {
+      return t7__namespace.stringLiteral(value);
+    }
+    if (typeof value === "number") {
+      return t7__namespace.numericLiteral(value);
+    }
+    if (typeof value === "boolean") {
+      return t7__namespace.booleanLiteral(value);
+    }
+    if (value === null) {
+      return t7__namespace.nullLiteral();
+    }
+    if (Array.isArray(value)) {
+      return t7__namespace.arrayExpression(value.map((v) => this.valueToExpression(v)));
+    }
+    if (typeof value === "object") {
+      return this.payloadToExpression(value);
+    }
+    return t7__namespace.identifier("undefined");
+  }
+  isPromiseAll(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "all"
+    });
+  }
+  isPromiseAllSettled(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "allSettled"
+    });
+  }
+  getTransformCount() {
+    return this.transformCount;
+  }
+  resetTransformCount() {
+    this.transformCount = 0;
+  }
+};
+
+// src/runtime/errors.ts
+exports.CheckpointOperation = void 0;
+(function(CheckpointOperation2) {
+  CheckpointOperation2["SAVE"] = "save";
+  CheckpointOperation2["LOAD"] = "load";
+  CheckpointOperation2["CLEAR"] = "clear";
+})(exports.CheckpointOperation || (exports.CheckpointOperation = {}));
+var BatchPauseExecutionError = class extends Error {
+  static {
+    __name(this, "BatchPauseExecutionError");
+  }
+  calls;
+  batchId;
+  sequenceNumber;
+  constructor(calls, batchId, sequenceNumber) {
+    super(`Batch pause for parallel execution (${calls.length} callbacks)`);
+    this.name = "BatchPauseExecutionError";
+    this.calls = calls;
+    this.batchId = batchId;
+    this.sequenceNumber = sequenceNumber;
+  }
+};
+var CheckpointError = class extends Error {
+  static {
+    __name(this, "CheckpointError");
+  }
+  checkpointId;
+  operation;
+  constructor(message, checkpointId, operation) {
+    super(`Checkpoint ${operation} failed for ${checkpointId}: ${message}`);
+    this.name = "CheckpointError";
+    this.checkpointId = checkpointId;
+    this.operation = operation;
+  }
+};
+var TransformationError = class extends Error {
+  static {
+    __name(this, "TransformationError");
+  }
+  code;
+  pattern;
+  location;
+  constructor(message, code, pattern, location) {
+    const loc = location ? ` at line ${location.line}:${location.column}` : "";
+    super(`Transformation failed for ${pattern}${loc}: ${message}`);
+    this.name = "TransformationError";
+    this.code = code;
+    this.pattern = pattern;
+    this.location = location;
+  }
+};
+var InfiniteLoopDetectionError = class extends Error {
+  static {
+    __name(this, "InfiniteLoopDetectionError");
+  }
+  loopId;
+  iterationCount;
+  constructor(loopId, iterationCount) {
+    super(`Infinite loop detected: ${loopId} exceeded ${iterationCount} iterations without completing`);
+    this.name = "InfiniteLoopDetectionError";
+    this.loopId = loopId;
+    this.iterationCount = iterationCount;
+  }
+};
+function isBatchPauseError(error) {
+  return error instanceof BatchPauseExecutionError;
+}
+__name(isBatchPauseError, "isBatchPauseError");
+function isCheckpointError(error) {
+  return error instanceof CheckpointError;
+}
+__name(isCheckpointError, "isCheckpointError");
+function isTransformationError(error) {
+  return error instanceof TransformationError;
+}
+__name(isTransformationError, "isTransformationError");
+
+// src/transformer/index.ts
+var traverse2 = _traverse__default.default.default || _traverse__default.default;
+var generate = _generate__default.default.default || _generate__default.default;
+var ATPCompiler = class {
+  static {
+    __name(this, "ATPCompiler");
+  }
+  config;
+  detector;
+  loopTransformer;
+  arrayTransformer;
+  promiseTransformer;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_COMPILER_CONFIG,
+      ...config
+    };
+    this.detector = new AsyncIterationDetector();
+    this.loopTransformer = new LoopTransformer(this.config.batchSizeThreshold);
+    this.arrayTransformer = new ArrayTransformer(this.config.batchSizeThreshold);
+    this.promiseTransformer = new PromiseTransformer(this.config.enableBatchParallel);
+  }
+  detect(code) {
+    return this.detector.detect(code);
+  }
+  transform(code) {
+    resetIdCounter();
+    const detection = this.detector.detect(code);
+    if (!detection.needsTransform) {
+      return {
+        code,
+        transformed: false,
+        patterns: [],
+        metadata: {
+          loopCount: 0,
+          arrayMethodCount: 0,
+          parallelCallCount: 0,
+          batchableCount: 0
+        }
+      };
+    }
+    try {
+      const ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: [
+          "typescript"
+        ],
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true
+      });
+      this.loopTransformer.resetTransformCount();
+      this.arrayTransformer.resetTransformCount();
+      this.promiseTransformer.resetTransformCount();
+      traverse2(ast, {
+        ForOfStatement: /* @__PURE__ */ __name((path) => {
+          this.loopTransformer.transformForOfLoop(path);
+        }, "ForOfStatement"),
+        WhileStatement: /* @__PURE__ */ __name((path) => {
+          this.loopTransformer.transformWhileLoop(path);
+        }, "WhileStatement"),
+        ForStatement: /* @__PURE__ */ __name((path) => {
+          this.loopTransformer.transformForLoop(path);
+        }, "ForStatement"),
+        CallExpression: /* @__PURE__ */ __name((path) => {
+          if (this.isArrayMethodCall(path.node)) {
+            this.arrayTransformer.transformArrayMethod(path);
+          } else if (this.isPromiseAllCall(path.node)) {
+            this.promiseTransformer.transformPromiseAll(path);
+          } else if (this.isPromiseAllSettledCall(path.node)) {
+            this.promiseTransformer.transformPromiseAllSettled(path);
+          }
+        }, "CallExpression")
+      });
+      const output = generate(ast, {
+        sourceMaps: false,
+        retainLines: true,
+        comments: true
+      });
+      const metadata = {
+        loopCount: this.loopTransformer.getTransformCount(),
+        arrayMethodCount: this.arrayTransformer.getTransformCount(),
+        parallelCallCount: this.promiseTransformer.getTransformCount(),
+        batchableCount: detection.batchableParallel ? 1 : 0
+      };
+      return {
+        code: output.code,
+        transformed: true,
+        patterns: detection.patterns,
+        metadata
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new TransformationError(message, code, "unknown");
+    }
+  }
+  isArrayMethodCall(node) {
+    if (!t7__namespace.isMemberExpression(node.callee)) {
+      return false;
+    }
+    const property = node.callee.property;
+    if (!t7__namespace.isIdentifier(property)) {
+      return false;
+    }
+    const arrayMethods = [
+      "map",
+      "forEach",
+      "filter",
+      "reduce",
+      "find",
+      "some",
+      "every",
+      "flatMap"
+    ];
+    return arrayMethods.includes(property.name);
+  }
+  isPromiseAllCall(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "all"
+    });
+  }
+  isPromiseAllSettledCall(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "allSettled"
+    });
+  }
+  /**
+  * Get the compiler type identifier (ICompiler interface requirement)
+  */
+  getType() {
+    return "ATPCompiler";
+  }
+  /**
+  * Get cache statistics (ICompiler interface requirement)
+  * ATPCompiler doesn't cache ASTs, so returns null
+  */
+  getCacheStats() {
+    return null;
+  }
+};
+
+// src/runtime/checkpoint-manager.ts
+var MAX_CHECKPOINT_SIZE = 10 * 1024 * 1024;
+var CHECKPOINT_TTL = 3600;
+var CheckpointManager = class {
+  static {
+    __name(this, "CheckpointManager");
+  }
+  cache;
+  executionId;
+  prefix;
+  constructor(executionId, cache, prefix = "checkpoint") {
+    this.executionId = executionId;
+    this.cache = cache;
+    this.prefix = prefix;
+  }
+  async save(checkpoint) {
+    const key = this.getKey(checkpoint.loopId);
+    try {
+      const serialized = JSON.stringify(checkpoint);
+      if (serialized.length > MAX_CHECKPOINT_SIZE) {
+        throw new CheckpointError(`Checkpoint size ${serialized.length} exceeds maximum ${MAX_CHECKPOINT_SIZE}`, checkpoint.loopId, exports.CheckpointOperation.SAVE);
+      }
+      await this.cache.set(key, checkpoint, CHECKPOINT_TTL);
+    } catch (error) {
+      if (error instanceof CheckpointError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CheckpointError(message, checkpoint.loopId, exports.CheckpointOperation.SAVE);
+    }
+  }
+  async load(loopId) {
+    const key = this.getKey(loopId);
+    try {
+      const checkpoint = await this.cache.get(key);
+      if (!checkpoint) {
+        return null;
+      }
+      if (checkpoint.completed && checkpoint.completed instanceof Array) {
+        checkpoint.completed = new Set(checkpoint.completed);
+      }
+      return checkpoint;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CheckpointError(message, loopId, exports.CheckpointOperation.LOAD);
+    }
+  }
+  async clear(loopId) {
+    const key = this.getKey(loopId);
+    try {
+      await this.cache.delete(key);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CheckpointError(message, loopId, exports.CheckpointOperation.CLEAR);
+    }
+  }
+  async clearAll() {
+  }
+  getKey(loopId) {
+    return `${this.prefix}:${this.executionId}:${loopId}`;
+  }
+  getExecutionId() {
+    return this.executionId;
+  }
+};
+var globalCheckpointManager = null;
+function setCheckpointManager(manager) {
+  globalCheckpointManager = manager;
+}
+__name(setCheckpointManager, "setCheckpointManager");
+function getCheckpointManager() {
+  if (!globalCheckpointManager) {
+    throw new Error("CheckpointManager not initialized");
+  }
+  return globalCheckpointManager;
+}
+__name(getCheckpointManager, "getCheckpointManager");
+function clearCheckpointManager() {
+  globalCheckpointManager = null;
+}
+__name(clearCheckpointManager, "clearCheckpointManager");
+function hasCheckpointManager() {
+  return globalCheckpointManager !== null;
+}
+__name(hasCheckpointManager, "hasCheckpointManager");
+
+// src/runtime/resumable-loops.ts
+var MAX_ITERATIONS = 1e6;
+async function resumableForOf(items, callback, loopId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(loopId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS) {
+      throw new InfiniteLoopDetectionError(loopId, i);
+    }
+    await callback(items[i], i);
+    const newCheckpoint = {
+      loopId,
+      currentIndex: i + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(loopId);
+}
+__name(resumableForOf, "resumableForOf");
+async function resumableWhile(conditionFn, bodyFn, loopId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(loopId);
+  let iteration = checkpoint?.currentIndex || 0;
+  while (await Promise.resolve(conditionFn())) {
+    if (iteration > MAX_ITERATIONS) {
+      throw new InfiniteLoopDetectionError(loopId, iteration);
+    }
+    await bodyFn(iteration);
+    const newCheckpoint = {
+      loopId,
+      currentIndex: iteration + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+    iteration++;
+  }
+  await checkpointManager.clear(loopId);
+}
+__name(resumableWhile, "resumableWhile");
+async function resumableForLoop(initValue, conditionFn, incrementFn, bodyFn, loopId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(loopId);
+  let i = checkpoint?.currentIndex !== void 0 ? checkpoint.currentIndex : initValue;
+  let iterations = 0;
+  while (conditionFn(i)) {
+    if (iterations++ > MAX_ITERATIONS) {
+      throw new InfiniteLoopDetectionError(loopId, iterations);
+    }
+    await bodyFn(i);
+    const newCheckpoint = {
+      loopId,
+      currentIndex: incrementFn(i),
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+    i = incrementFn(i);
+  }
+  await checkpointManager.clear(loopId);
+}
+__name(resumableForLoop, "resumableForLoop");
+
+// src/runtime/resumable-arrays.ts
+var MAX_ITERATIONS2 = 1e6;
+async function resumableMap(items, callback, mapId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(mapId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  const results = checkpoint?.results || [];
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(mapId, i);
+    }
+    results[i] = await callback(items[i], i, items);
+    const newCheckpoint = {
+      loopId: mapId,
+      currentIndex: i + 1,
+      results,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(mapId);
+  return results;
+}
+__name(resumableMap, "resumableMap");
+async function resumableForEach(items, callback, forEachId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(forEachId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(forEachId, i);
+    }
+    await callback(items[i], i, items);
+    const newCheckpoint = {
+      loopId: forEachId,
+      currentIndex: i + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(forEachId);
+}
+__name(resumableForEach, "resumableForEach");
+async function resumableFilter(items, callback, filterId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(filterId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  const results = checkpoint?.results || [];
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(filterId, i);
+    }
+    const passed = await callback(items[i], i, items);
+    if (passed) {
+      results.push(items[i]);
+    }
+    const newCheckpoint = {
+      loopId: filterId,
+      currentIndex: i + 1,
+      results,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(filterId);
+  return results;
+}
+__name(resumableFilter, "resumableFilter");
+async function resumableReduce(items, callback, initialValue, reduceId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(reduceId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  let accumulator = checkpoint?.accumulator ?? initialValue;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(reduceId, i);
+    }
+    accumulator = await callback(accumulator, items[i], i, items);
+    const newCheckpoint = {
+      loopId: reduceId,
+      currentIndex: i + 1,
+      accumulator,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(reduceId);
+  return accumulator;
+}
+__name(resumableReduce, "resumableReduce");
+async function resumableFind(items, callback, findId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(findId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(findId, i);
+    }
+    const found = await callback(items[i], i, items);
+    if (found) {
+      await checkpointManager.clear(findId);
+      return items[i];
+    }
+    const newCheckpoint = {
+      loopId: findId,
+      currentIndex: i + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(findId);
+  return void 0;
+}
+__name(resumableFind, "resumableFind");
+async function resumableSome(items, callback, someId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(someId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(someId, i);
+    }
+    const result = await callback(items[i], i, items);
+    if (result) {
+      await checkpointManager.clear(someId);
+      return true;
+    }
+    const newCheckpoint = {
+      loopId: someId,
+      currentIndex: i + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(someId);
+  return false;
+}
+__name(resumableSome, "resumableSome");
+async function resumableEvery(items, callback, everyId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(everyId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(everyId, i);
+    }
+    const result = await callback(items[i], i, items);
+    if (!result) {
+      await checkpointManager.clear(everyId);
+      return false;
+    }
+    const newCheckpoint = {
+      loopId: everyId,
+      currentIndex: i + 1,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(everyId);
+  return true;
+}
+__name(resumableEvery, "resumableEvery");
+async function resumableFlatMap(items, callback, flatMapId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(flatMapId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  const results = checkpoint?.results || [];
+  for (let i = startIndex; i < items.length; i++) {
+    if (i > MAX_ITERATIONS2) {
+      throw new InfiniteLoopDetectionError(flatMapId, i);
+    }
+    const mapped = await callback(items[i], i, items);
+    results.push(...mapped);
+    const newCheckpoint = {
+      loopId: flatMapId,
+      currentIndex: i + 1,
+      results,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(flatMapId);
+  return results;
+}
+__name(resumableFlatMap, "resumableFlatMap");
+
+// src/runtime/resumable-parallel.ts
+async function resumablePromiseAll(promises, parallelId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(parallelId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  const results = checkpoint?.results || [];
+  for (let i = startIndex; i < promises.length; i++) {
+    results[i] = await promises[i];
+    const newCheckpoint = {
+      loopId: parallelId,
+      currentIndex: i + 1,
+      results,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(parallelId);
+  return results;
+}
+__name(resumablePromiseAll, "resumablePromiseAll");
+async function resumablePromiseAllSettled(promises, parallelId) {
+  const checkpointManager = getCheckpointManager();
+  const checkpoint = await checkpointManager.load(parallelId);
+  const startIndex = checkpoint?.currentIndex || 0;
+  const results = checkpoint?.results || [];
+  for (let i = startIndex; i < promises.length; i++) {
+    try {
+      const value = await promises[i];
+      results[i] = {
+        status: "fulfilled",
+        value
+      };
+    } catch (reason) {
+      results[i] = {
+        status: "rejected",
+        reason
+      };
+    }
+    const newCheckpoint = {
+      loopId: parallelId,
+      currentIndex: i + 1,
+      results,
+      timestamp: Date.now()
+    };
+    await checkpointManager.save(newCheckpoint);
+  }
+  await checkpointManager.clear(parallelId);
+  return results;
+}
+__name(resumablePromiseAllSettled, "resumablePromiseAllSettled");
+async function batchParallel(batchCalls, parallelId) {
+  const currentSequence = atpRuntime.getCallSequenceNumber();
+  const cachedResult = atpRuntime.getCachedResult(currentSequence);
+  if (cachedResult !== void 0) {
+    atpRuntime.nextSequenceNumber();
+    return cachedResult;
+  }
+  const sequenceForPause = atpRuntime.nextSequenceNumber();
+  throw new BatchPauseExecutionError(batchCalls, parallelId, sequenceForPause);
+}
+__name(batchParallel, "batchParallel");
+
+// src/runtime/index.ts
+function initializeRuntime(options) {
+  const checkpointManager = new CheckpointManager(options.executionId, options.cache, options.checkpointPrefix);
+  setCheckpointManager(checkpointManager);
+  setRuntimeContext({
+    executionId: options.executionId,
+    cache: options.cache,
+    checkpointPrefix: options.checkpointPrefix
+  });
+}
+__name(initializeRuntime, "initializeRuntime");
+function cleanupRuntime() {
+}
+__name(cleanupRuntime, "cleanupRuntime");
+
+// src/types/compiler-interface.ts
+function isCompiler(obj) {
+  return typeof obj === "object" && obj !== null && "detect" in obj && "transform" in obj && "getType" in obj && typeof obj.detect === "function" && typeof obj.transform === "function" && typeof obj.getType === "function";
+}
+__name(isCompiler, "isCompiler");
+
+// src/plugin-system/plugin-api.ts
+var PluginRegistry = class {
+  static {
+    __name(this, "PluginRegistry");
+  }
+  detectors = [];
+  transformers = [];
+  optimizers = [];
+  validators = [];
+  /**
+  * Register a plugin
+  */
+  register(plugin) {
+    if (this.findPlugin(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered. Please use a unique name or unregister the existing plugin first.`);
+    }
+    if (this.isDetectionPlugin(plugin)) {
+      this.detectors.push(plugin);
+      this.detectors.sort((a, b) => (b.priority || 50) - (a.priority || 50));
+    }
+    if (this.isTransformationPlugin(plugin)) {
+      this.transformers.push(plugin);
+      this.transformers.sort((a, b) => (b.priority || 50) - (a.priority || 50));
+    }
+    if (this.isOptimizerPlugin(plugin)) {
+      this.optimizers.push(plugin);
+      this.optimizers.sort((a, b) => (b.priority || 50) - (a.priority || 50));
+    }
+    if (this.isValidatorPlugin(plugin)) {
+      this.validators.push(plugin);
+      this.validators.sort((a, b) => (b.priority || 50) - (a.priority || 50));
+    }
+  }
+  /**
+  * Find a plugin by name
+  */
+  findPlugin(name) {
+    const allPlugins = [
+      ...this.detectors,
+      ...this.transformers,
+      ...this.optimizers,
+      ...this.validators
+    ];
+    return allPlugins.find((p) => p.name === name);
+  }
+  /**
+  * Unregister a plugin by name
+  */
+  unregister(name) {
+    let removed = false;
+    this.detectors = this.detectors.filter((p) => {
+      if (p.name === name) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    this.transformers = this.transformers.filter((p) => {
+      if (p.name === name) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    this.optimizers = this.optimizers.filter((p) => {
+      if (p.name === name) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    this.validators = this.validators.filter((p) => {
+      if (p.name === name) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    return removed;
+  }
+  /**
+  * Get all detection plugins
+  */
+  getDetectors() {
+    return this.detectors;
+  }
+  /**
+  * Get all transformation plugins
+  */
+  getTransformers() {
+    return this.transformers;
+  }
+  /**
+  * Get all optimizer plugins
+  */
+  getOptimizers() {
+    return this.optimizers;
+  }
+  /**
+  * Get all validator plugins
+  */
+  getValidators() {
+    return this.validators;
+  }
+  /**
+  * Initialize all plugins
+  */
+  async initializeAll(config) {
+    const allPlugins = [
+      ...this.detectors,
+      ...this.transformers,
+      ...this.optimizers,
+      ...this.validators
+    ];
+    for (const plugin of allPlugins) {
+      if (plugin.initialize) {
+        await plugin.initialize(config);
+      }
+    }
+  }
+  /**
+  * Dispose all plugins
+  */
+  async disposeAll() {
+    const allPlugins = [
+      ...this.detectors,
+      ...this.transformers,
+      ...this.optimizers,
+      ...this.validators
+    ];
+    for (const plugin of allPlugins) {
+      if (plugin.dispose) {
+        await plugin.dispose();
+      }
+    }
+  }
+  /**
+  * Type guards
+  */
+  isDetectionPlugin(plugin) {
+    return "detect" in plugin && "patterns" in plugin;
+  }
+  isTransformationPlugin(plugin) {
+    return "getVisitor" in plugin && "getMetadata" in plugin && "reset" in plugin;
+  }
+  isOptimizerPlugin(plugin) {
+    return "optimize" in plugin;
+  }
+  isValidatorPlugin(plugin) {
+    return "validate" in plugin;
+  }
+};
+function createTransformPlugin(config) {
+  let transformCount = 0;
+  return {
+    name: config.name,
+    version: config.version,
+    priority: config.priority || 50,
+    getVisitor() {
+      return config.visitor;
+    },
+    getMetadata() {
+      return config.getMetadata ? config.getMetadata() : {
+        loopCount: transformCount
+      };
+    },
+    reset() {
+      transformCount = 0;
+    }
+  };
+}
+__name(createTransformPlugin, "createTransformPlugin");
+var traverse3 = _traverse__default.default.default || _traverse__default.default;
+var generate2 = _generate__default.default.default || _generate__default.default;
+var PluggableCompiler = class {
+  static {
+    __name(this, "PluggableCompiler");
+  }
+  config;
+  registry;
+  initialized = false;
+  /**
+  * AST cache - maps code string to parsed AST
+  * This avoids re-parsing the same code multiple times
+  * (e.g., once in detect() and once in transform())
+  *
+  * Performance Impact: ~30% reduction in compile time
+  */
+  astCache = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_COMPILER_CONFIG,
+      ...config
+    };
+    this.registry = new PluginRegistry();
+  }
+  /**
+  * Register a plugin (chainable)
+  */
+  use(plugin) {
+    this.registry.register(plugin);
+    return this;
+  }
+  /**
+  * Unregister a plugin by name
+  */
+  remove(pluginName) {
+    return this.registry.unregister(pluginName);
+  }
+  /**
+  * Initialize all plugins
+  */
+  async initialize() {
+    if (this.initialized) return;
+    await this.registry.initializeAll(this.config);
+    this.initialized = true;
+  }
+  /**
+  * Detect patterns using all detection plugins
+  */
+  async detect(code) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      const ast = this.parseCode(code);
+      const detectors = this.registry.getDetectors();
+      const allPatterns = /* @__PURE__ */ new Set();
+      let batchableParallel = false;
+      for (const detector of detectors) {
+        const result = await detector.detect(code, ast);
+        result.patterns.forEach((p) => allPatterns.add(p));
+        if (result.batchableParallel) {
+          batchableParallel = true;
+        }
+      }
+      return {
+        needsTransform: allPatterns.size > 0,
+        patterns: Array.from(allPatterns),
+        batchableParallel
+      };
+    } catch (error) {
+      return {
+        needsTransform: false,
+        patterns: [],
+        batchableParallel: false
+      };
+    }
+  }
+  /**
+  * Transform code using all transformation plugins
+  */
+  async transform(code) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    resetIdCounter();
+    await this.runValidation(code, "pre");
+    const detection = await this.detect(code);
+    if (!detection.needsTransform) {
+      return {
+        code,
+        transformed: false,
+        patterns: [],
+        metadata: {
+          loopCount: 0,
+          arrayMethodCount: 0,
+          parallelCallCount: 0,
+          batchableCount: 0
+        }
+      };
+    }
+    try {
+      const ast = this.parseCode(code);
+      const transformers = this.registry.getTransformers();
+      for (const transformer of transformers) {
+        transformer.reset();
+      }
+      const visitors = {};
+      for (const transformer of transformers) {
+        const visitor = transformer.getVisitor(this.config);
+        for (const [nodeType, handler] of Object.entries(visitor)) {
+          if (!visitors[nodeType]) {
+            visitors[nodeType] = handler;
+          } else {
+            const existing = visitors[nodeType];
+            visitors[nodeType] = (path) => {
+              existing(path);
+              handler(path);
+            };
+          }
+        }
+      }
+      traverse3(ast, visitors);
+      let optimizedAst = ast;
+      const optimizers = this.registry.getOptimizers();
+      for (const optimizer of optimizers) {
+        optimizedAst = await optimizer.optimize(optimizedAst, this.config);
+      }
+      const output = generate2(optimizedAst, {
+        sourceMaps: false,
+        retainLines: true,
+        comments: true
+      });
+      const metadata = {
+        loopCount: 0,
+        arrayMethodCount: 0,
+        parallelCallCount: 0,
+        batchableCount: detection.batchableParallel ? 1 : 0
+      };
+      for (const transformer of transformers) {
+        const pluginMetadata = transformer.getMetadata();
+        metadata.loopCount += pluginMetadata.loopCount || 0;
+        metadata.arrayMethodCount += pluginMetadata.arrayMethodCount || 0;
+        metadata.parallelCallCount += pluginMetadata.parallelCallCount || 0;
+        metadata.batchableCount += pluginMetadata.batchableCount || 0;
+      }
+      await this.runValidation(output.code, "post");
+      return {
+        code: output.code,
+        transformed: true,
+        patterns: detection.patterns,
+        metadata
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const context = detection.patterns.length > 0 ? `[Plugin transformation] ${message}` : message;
+      throw new TransformationError(context, code, "plugin-error");
+    }
+  }
+  /**
+  * Dispose compiler and all plugins
+  */
+  async dispose() {
+    await this.registry.disposeAll();
+    this.astCache.clear();
+    this.initialized = false;
+  }
+  /**
+  * Get current configuration
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+  /**
+  * Update configuration
+  */
+  setConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+  }
+  /**
+  * Parse code to AST with caching
+  *
+  * Caches parsed AST to avoid re-parsing the same code multiple times.
+  * This provides ~30% performance improvement when detect() and transform()
+  * are called on the same code.
+  */
+  parseCode(code) {
+    const cached = this.astCache.get(code);
+    if (cached) {
+      return cached;
+    }
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: [
+        "typescript"
+      ],
+      allowAwaitOutsideFunction: true,
+      allowReturnOutsideFunction: true
+    });
+    this.astCache.set(code, ast);
+    return ast;
+  }
+  /**
+  * Clear AST cache
+  *
+  * Call this method to free memory if you've compiled many different code snippets.
+  * The cache is automatically managed and uses Map, so old entries don't leak memory.
+  */
+  clearCache() {
+    this.astCache.clear();
+  }
+  /**
+  * Get the compiler type identifier (ICompiler interface requirement)
+  */
+  getType() {
+    return "PluggableCompiler";
+  }
+  /**
+  * Get cache statistics (for debugging/monitoring)
+  */
+  getCacheStats() {
+    return {
+      size: this.astCache.size,
+      enabled: true
+    };
+  }
+  /**
+  * Run validators
+  */
+  async runValidation(code, phase) {
+    const validators = this.registry.getValidators();
+    const ast = this.parseCode(code);
+    for (const validator of validators) {
+      await validator.validate(code, ast, phase);
+    }
+  }
+};
+
+// src/plugin-system/default-plugins/detection-plugin.ts
+var DefaultDetectionPlugin = class {
+  static {
+    __name(this, "DefaultDetectionPlugin");
+  }
+  name = "atp-default-detector";
+  version = "1.0.0";
+  priority = 100;
+  patterns = [
+    "for-of-await",
+    "while-await",
+    "map-async",
+    "forEach-async",
+    "filter-async",
+    "reduce-async",
+    "find-async",
+    "some-async",
+    "every-async",
+    "flatMap-async",
+    "promise-all",
+    "promise-allSettled"
+  ];
+  detector;
+  constructor() {
+    this.detector = new AsyncIterationDetector();
+  }
+  async detect(code, ast) {
+    return this.detector.detect(code);
+  }
+};
+
+// src/plugin-system/default-plugins/loop-transformer-plugin.ts
+var DefaultLoopTransformerPlugin = class {
+  static {
+    __name(this, "DefaultLoopTransformerPlugin");
+  }
+  name = "atp-loop-transformer";
+  version = "1.0.0";
+  priority = 100;
+  transformer;
+  constructor(batchSizeThreshold) {
+    this.transformer = new LoopTransformer(batchSizeThreshold);
+  }
+  getVisitor(config) {
+    return {
+      ForOfStatement: /* @__PURE__ */ __name((path) => {
+        this.transformer.transformForOfLoop(path);
+      }, "ForOfStatement"),
+      WhileStatement: /* @__PURE__ */ __name((path) => {
+        this.transformer.transformWhileLoop(path);
+      }, "WhileStatement"),
+      ForStatement: /* @__PURE__ */ __name((path) => {
+        this.transformer.transformForLoop(path);
+      }, "ForStatement")
+    };
+  }
+  getMetadata() {
+    return {
+      loopCount: this.transformer.getTransformCount()
+    };
+  }
+  reset() {
+    this.transformer.resetTransformCount();
+  }
+};
+var DefaultArrayTransformerPlugin = class {
+  static {
+    __name(this, "DefaultArrayTransformerPlugin");
+  }
+  name = "atp-array-transformer";
+  version = "1.0.0";
+  priority = 100;
+  transformer;
+  constructor(batchSizeThreshold) {
+    this.transformer = new ArrayTransformer(batchSizeThreshold);
+  }
+  getVisitor(config) {
+    return {
+      CallExpression: /* @__PURE__ */ __name((path) => {
+        const node = path.node;
+        if (this.isArrayMethodCall(node)) {
+          this.transformer.transformArrayMethod(path);
+        }
+      }, "CallExpression")
+    };
+  }
+  getMetadata() {
+    return {
+      arrayMethodCount: this.transformer.getTransformCount()
+    };
+  }
+  reset() {
+    this.transformer.resetTransformCount();
+  }
+  isArrayMethodCall(node) {
+    if (!t7__namespace.isMemberExpression(node.callee)) {
+      return false;
+    }
+    const property = node.callee.property;
+    if (!t7__namespace.isIdentifier(property)) {
+      return false;
+    }
+    const arrayMethods = [
+      "map",
+      "forEach",
+      "filter",
+      "reduce",
+      "find",
+      "some",
+      "every",
+      "flatMap"
+    ];
+    return arrayMethods.includes(property.name);
+  }
+};
+var DefaultPromiseTransformerPlugin = class {
+  static {
+    __name(this, "DefaultPromiseTransformerPlugin");
+  }
+  name = "atp-promise-transformer";
+  version = "1.0.0";
+  priority = 100;
+  transformer;
+  constructor(enableBatchParallel) {
+    this.transformer = new PromiseTransformer(enableBatchParallel);
+  }
+  getVisitor(config) {
+    return {
+      CallExpression: /* @__PURE__ */ __name((path) => {
+        const node = path.node;
+        if (this.isPromiseAllCall(node)) {
+          this.transformer.transformPromiseAll(path);
+        } else if (this.isPromiseAllSettledCall(node)) {
+          this.transformer.transformPromiseAllSettled(path);
+        }
+      }, "CallExpression")
+    };
+  }
+  getMetadata() {
+    return {
+      parallelCallCount: this.transformer.getTransformCount()
+    };
+  }
+  reset() {
+    this.transformer.resetTransformCount();
+  }
+  isPromiseAllCall(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "all"
+    });
+  }
+  isPromiseAllSettledCall(node) {
+    const callee = node.callee;
+    return t7__namespace.isMemberExpression(callee) && t7__namespace.isIdentifier(callee.object, {
+      name: "Promise"
+    }) && t7__namespace.isIdentifier(callee.property, {
+      name: "allSettled"
+    });
+  }
+};
+
+// src/plugin-system/create-default-compiler.ts
+function createDefaultCompiler(config = {}) {
+  const compiler = new PluggableCompiler(config);
+  compiler.use(new DefaultDetectionPlugin());
+  compiler.use(new DefaultLoopTransformerPlugin(config.batchSizeThreshold));
+  compiler.use(new DefaultArrayTransformerPlugin(config.batchSizeThreshold));
+  compiler.use(new DefaultPromiseTransformerPlugin(config.enableBatchParallel));
+  return compiler;
+}
+__name(createDefaultCompiler, "createDefaultCompiler");
+var AsyncTimeoutPlugin = class {
+  static {
+    __name(this, "AsyncTimeoutPlugin");
+  }
+  name = "async-timeout";
+  version = "1.0.0";
+  priority = 40;
+  options;
+  transformCount = 0;
+  constructor(options = {}) {
+    this.options = {
+      timeout: options.timeout || 5e3,
+      patterns: options.patterns || [
+        "fetch",
+        "axios.*",
+        "http.*"
+      ],
+      wrapAll: options.wrapAll || false
+    };
+  }
+  getVisitor(config) {
+    return {
+      AwaitExpression: /* @__PURE__ */ __name((path) => {
+        if (!this.shouldWrap(path.node.argument)) {
+          return;
+        }
+        const timeoutPromise = t7__namespace.newExpression(t7__namespace.identifier("Promise"), [
+          t7__namespace.arrowFunctionExpression([
+            t7__namespace.identifier("_"),
+            t7__namespace.identifier("reject")
+          ], t7__namespace.blockStatement([
+            t7__namespace.expressionStatement(t7__namespace.callExpression(t7__namespace.identifier("setTimeout"), [
+              t7__namespace.arrowFunctionExpression([], t7__namespace.callExpression(t7__namespace.identifier("reject"), [
+                t7__namespace.newExpression(t7__namespace.identifier("Error"), [
+                  t7__namespace.stringLiteral(`Timeout after ${this.options.timeout}ms`)
+                ])
+              ])),
+              t7__namespace.numericLiteral(this.options.timeout)
+            ]))
+          ]))
+        ]);
+        const raceCall = t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("Promise"), t7__namespace.identifier("race")), [
+          t7__namespace.arrayExpression([
+            path.node.argument,
+            timeoutPromise
+          ])
+        ]);
+        path.node.argument = raceCall;
+        this.transformCount++;
+      }, "AwaitExpression")
+    };
+  }
+  getMetadata() {
+    return {
+      // Custom metadata
+      loopCount: 0,
+      arrayMethodCount: 0,
+      parallelCallCount: this.transformCount,
+      batchableCount: 0
+    };
+  }
+  reset() {
+    this.transformCount = 0;
+  }
+  /**
+  * Check if this await should be wrapped with timeout
+  */
+  shouldWrap(node) {
+    if (this.options.wrapAll) {
+      return true;
+    }
+    if (t7__namespace.isCallExpression(node)) {
+      const funcName = this.getFunctionName(node);
+      if (funcName) {
+        return this.options.patterns.some((pattern) => {
+          const regex = new RegExp(pattern.replace("*", ".*"));
+          return regex.test(funcName);
+        });
+      }
+    }
+    return false;
+  }
+  /**
+  * Get function name from call expression
+  */
+  getFunctionName(node) {
+    if (t7__namespace.isIdentifier(node.callee)) {
+      return node.callee.name;
+    }
+    if (t7__namespace.isMemberExpression(node.callee)) {
+      const obj = t7__namespace.isIdentifier(node.callee.object) ? node.callee.object.name : "";
+      const prop = t7__namespace.isIdentifier(node.callee.property) ? node.callee.property.name : "";
+      return `${obj}.${prop}`;
+    }
+    return null;
+  }
+};
+var traverse4 = _traverse__default.default.default || _traverse__default.default;
+var SecurityValidatorPlugin = class {
+  static {
+    __name(this, "SecurityValidatorPlugin");
+  }
+  name = "security-validator";
+  version = "1.0.0";
+  priority = 100;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      forbiddenPatterns: options.forbiddenPatterns || [
+        /\beval\s*\(/,
+        /new\s+Function\s*\(/,
+        /constructor\s*\[\s*['"`]constructor['"`]\s*\]/
+      ],
+      maxComplexity: options.maxComplexity || 50,
+      maxNesting: options.maxNesting || 10,
+      forbiddenGlobals: options.forbiddenGlobals || [
+        "process",
+        "require",
+        "__dirname",
+        "__filename"
+      ]
+    };
+  }
+  async validate(code, ast, phase) {
+    if (phase === "post") {
+      return;
+    }
+    for (const pattern of this.options.forbiddenPatterns) {
+      if (pattern.test(code)) {
+        throw new SecurityValidationError(`Forbidden pattern detected: ${pattern}`, "forbidden-pattern");
+      }
+    }
+    let maxNestingFound = 0;
+    let complexityScore = 0;
+    traverse4(ast, {
+      enter(path) {
+        const depth = path.scope.path.node ? getDepth(path) : 0;
+        maxNestingFound = Math.max(maxNestingFound, depth);
+        if (path.isIfStatement() || path.isWhileStatement() || path.isForStatement() || path.isForOfStatement() || path.isSwitchCase() || path.isCatchClause()) {
+          complexityScore++;
+        }
+      },
+      // 3. Check forbidden globals
+      Identifier: /* @__PURE__ */ __name((path) => {
+        if (this.options.forbiddenGlobals.includes(path.node.name) && !path.scope.hasBinding(path.node.name)) {
+          throw new SecurityValidationError(`Access to forbidden global: ${path.node.name}`, "forbidden-global");
+        }
+      }, "Identifier")
+    });
+    if (maxNestingFound > this.options.maxNesting) {
+      throw new SecurityValidationError(`Maximum nesting depth exceeded: ${maxNestingFound} > ${this.options.maxNesting}`, "max-nesting");
+    }
+    if (complexityScore > this.options.maxComplexity) {
+      throw new SecurityValidationError(`Maximum complexity exceeded: ${complexityScore} > ${this.options.maxComplexity}`, "max-complexity");
+    }
+  }
+};
+var SecurityValidationError = class extends Error {
+  static {
+    __name(this, "SecurityValidationError");
+  }
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SecurityValidationError";
+  }
+};
+function getDepth(path) {
+  let depth = 0;
+  let current = path;
+  while (current.parentPath) {
+    if (current.isBlockStatement() || current.isFunctionDeclaration() || current.isArrowFunctionExpression()) {
+      depth++;
+    }
+    current = current.parentPath;
+  }
+  return depth;
+}
+__name(getDepth, "getDepth");
+
+exports.ATPCompiler = ATPCompiler;
+exports.ArrayTransformer = ArrayTransformer;
+exports.AsyncIterationDetector = AsyncIterationDetector;
+exports.AsyncTimeoutPlugin = AsyncTimeoutPlugin;
+exports.BatchOptimizer = BatchOptimizer;
+exports.BatchParallelDetector = BatchParallelDetector;
+exports.BatchPauseExecutionError = BatchPauseExecutionError;
+exports.CheckpointError = CheckpointError;
+exports.CheckpointManager = CheckpointManager;
+exports.DEFAULT_COMPILER_CONFIG = DEFAULT_COMPILER_CONFIG;
+exports.DefaultArrayTransformerPlugin = DefaultArrayTransformerPlugin;
+exports.DefaultDetectionPlugin = DefaultDetectionPlugin;
+exports.DefaultLoopTransformerPlugin = DefaultLoopTransformerPlugin;
+exports.DefaultPromiseTransformerPlugin = DefaultPromiseTransformerPlugin;
+exports.IN_ISOLATE_RUNTIME_FUNCTIONS = IN_ISOLATE_RUNTIME_FUNCTIONS;
+exports.InfiniteLoopDetectionError = InfiniteLoopDetectionError;
+exports.LoopTransformer = LoopTransformer;
+exports.PAUSABLE_CALL_PATTERNS = PAUSABLE_CALL_PATTERNS;
+exports.PluggableCompiler = PluggableCompiler;
+exports.PluginRegistry = PluginRegistry;
+exports.PromiseTransformer = PromiseTransformer;
+exports.RuntimeFunction = RuntimeFunction;
+exports.SecurityValidationError = SecurityValidationError;
+exports.SecurityValidatorPlugin = SecurityValidatorPlugin;
+exports.TransformationError = TransformationError;
+exports.batchParallel = batchParallel;
+exports.cleanupRuntime = cleanupRuntime;
+exports.clearCheckpointManager = clearCheckpointManager;
+exports.clearRuntimeContext = clearRuntimeContext;
+exports.containsAwait = containsAwait;
+exports.containsPausableCall = containsPausableCall;
+exports.createDefaultCompiler = createDefaultCompiler;
+exports.createRuntimeCall = createRuntimeCall;
+exports.createTransformPlugin = createTransformPlugin;
+exports.extractForOfParamName = extractForOfParamName;
+exports.generateUniqueId = generateUniqueId;
+exports.getCheckpointManager = getCheckpointManager;
+exports.getMemberExpressionPath = getMemberExpressionPath;
+exports.getNodeLocation = getNodeLocation;
+exports.getRuntimeContext = getRuntimeContext;
+exports.hasCheckpointManager = hasCheckpointManager;
+exports.hasRuntimeContext = hasRuntimeContext;
+exports.initializeRuntime = initializeRuntime;
+exports.isArrayMethod = isArrayMethod;
+exports.isAsyncFunction = isAsyncFunction;
+exports.isBatchPauseError = isBatchPauseError;
+exports.isCheckpointError = isCheckpointError;
+exports.isCompiler = isCompiler;
+exports.isInIsolateRuntimeFunction = isInIsolateRuntimeFunction;
+exports.isPausableCall = isPausableCall;
+exports.isPausableCallExpression = isPausableCallExpression;
+exports.isTransformationError = isTransformationError;
+exports.resetIdCounter = resetIdCounter;
+exports.resumableEvery = resumableEvery;
+exports.resumableFilter = resumableFilter;
+exports.resumableFind = resumableFind;
+exports.resumableFlatMap = resumableFlatMap;
+exports.resumableForEach = resumableForEach;
+exports.resumableForLoop = resumableForLoop;
+exports.resumableForOf = resumableForOf;
+exports.resumableMap = resumableMap;
+exports.resumablePromiseAll = resumablePromiseAll;
+exports.resumablePromiseAllSettled = resumablePromiseAllSettled;
+exports.resumableReduce = resumableReduce;
+exports.resumableSome = resumableSome;
+exports.resumableWhile = resumableWhile;
+exports.setCheckpointManager = setCheckpointManager;
+exports.setRuntimeContext = setRuntimeContext;
+exports.wrapInAsyncFunction = wrapInAsyncFunction;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map