@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/lib/chunk-mhxe717m.js

@@ -0,0 +1,572 @@
+import {
+  newSessionId2
+} from "./chunk-jdjagvgr.js";
+import {
+  getSessionRoot2,
+  normalizeMessages2,
+  createLogger,
+  scopedLogger
+} from "./chunk-sgd2126b.js";
+import {
+  __export
+} from "./chunk-n0ba7khr.js";
+
+// src/core/session/persistence.ts
+var exports_persistence = {};
+__export(exports_persistence, {
+  buildManifestEntries: () => buildManifestEntries2,
+  convertModelMessagesToUI: () => convertModelMessagesToUI2,
+  finalizeManifest: () => finalizeManifest2,
+  getCompletedAgentIds: () => getCompletedAgentIds2,
+  loadSubagentMessages: () => loadSubagentMessages2,
+  loadSubagents: () => loadSubagents2,
+  readAgentManifest: () => readAgentManifest2,
+  reconcileManifestOnResume: () => reconcileManifestOnResume2,
+  rehydrateFromConsoleTree: () => rehydrateFromConsoleTree2,
+  repairOrphanToolCalls: () => repairOrphanToolCalls2,
+  saveSubagentData: () => saveSubagentData2,
+  updateManifestEntryStatus: () => updateManifestEntryStatus2,
+  writeAgentManifest: () => writeAgentManifest2
+});
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+var log = scopedLogger(() => createLogger("session:persistence"));
+var SUBAGENTS_DIR = "subagents";
+var MANIFEST_FILE = "agent-manifest.json";
+function loadSubagentMessages2(session, key) {
+  const stepPath = join(session.rootPath, SUBAGENTS_DIR, key, "messages.json");
+  if (existsSync(stepPath)) {
+    try {
+      return JSON.parse(readFileSync(stepPath, "utf-8"));
+    } catch {}
+  }
+  const snapshotPath = join(session.rootPath, SUBAGENTS_DIR, `${key}.json`);
+  if (!existsSync(snapshotPath))
+    return [];
+  try {
+    const data = JSON.parse(readFileSync(snapshotPath, "utf-8"));
+    return data.messages ?? [];
+  } catch {
+    return [];
+  }
+}
+function saveSubagentData2(session, data) {
+  const subagentsDir = join(session.rootPath, SUBAGENTS_DIR);
+  mkdirSync(subagentsDir, { recursive: true });
+  let toolCallCount = 0;
+  let stepCount = 0;
+  for (const msg of data.messages) {
+    if (msg.role === "assistant") {
+      stepCount++;
+      if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === "tool-call")
+            toolCallCount++;
+        }
+      }
+    }
+  }
+  const savedData = {
+    agentName: data.agentName,
+    timestamp: new Date().toISOString(),
+    target: data.target,
+    objective: data.objective,
+    vulnerabilityClass: data.vulnerabilityClass,
+    toolCallCount,
+    stepCount,
+    findingsCount: data.findingsCount ?? 0,
+    status: data.status,
+    error: data.error,
+    messages: data.messages,
+    systemPrompt: data.systemPrompt,
+    userPrompt: data.userPrompt
+  };
+  writeFileSync(join(subagentsDir, `${data.agentName}.json`), JSON.stringify(savedData, null, 2));
+}
+function writeAgentManifest2(session, entries) {
+  const manifestPath = join(session.rootPath, MANIFEST_FILE);
+  writeFileSync(manifestPath, JSON.stringify(entries, null, 2));
+}
+function readAgentManifest2(session) {
+  const manifestPath = join(session.rootPath, MANIFEST_FILE);
+  if (!existsSync(manifestPath))
+    return [];
+  try {
+    return JSON.parse(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function buildManifestEntries2(targets, mintId = () => newSessionId2()) {
+  return targets.map((t, i) => {
+    const sessionId = mintId(t.name ?? "pentest-worker", i);
+    return {
+      id: sessionId,
+      sessionId,
+      name: `Pentest Agent ${i + 1}`,
+      target: t.target,
+      vulnerabilityClass: t.objectives[0] || "general",
+      objective: t.objectives.join("; "),
+      status: "running",
+      spawnedAt: new Date().toISOString()
+    };
+  });
+}
+function reconcileManifestOnResume2(existing, fresh) {
+  return fresh.map((f, i) => {
+    const prev = existing[i];
+    if (!prev || prev.target !== f.target)
+      return f;
+    if (prev.status === "completed")
+      return prev;
+    return {
+      ...f,
+      id: prev.id,
+      sessionId: prev.sessionId ?? prev.id,
+      spawnedAt: prev.spawnedAt
+    };
+  });
+}
+function finalizeManifest2(session, entries, results) {
+  const finalManifest = entries.map((entry, i) => {
+    if (entry.status === "completed")
+      return entry;
+    return {
+      ...entry,
+      status: results[i] != null ? "completed" : "failed",
+      completedAt: new Date().toISOString()
+    };
+  });
+  writeAgentManifest2(session, finalManifest);
+}
+function updateManifestEntryStatus2(session, agentId, status) {
+  const manifest = readAgentManifest2(session);
+  const updated = manifest.map((e) => e.id === agentId ? { ...e, status, completedAt: new Date().toISOString() } : e);
+  writeAgentManifest2(session, updated);
+}
+function getCompletedAgentIds2(session) {
+  const manifest = readAgentManifest2(session);
+  return new Set(manifest.filter((e) => e.status === "completed").map((e) => e.id));
+}
+function parseSubagentFilename(filename) {
+  if (filename.startsWith("attack-surface-agent")) {
+    return { agentType: "attack-surface", name: "Attack Surface Discovery" };
+  }
+  if (filename === "whitebox-apps-discovery") {
+    return { agentType: "pentest", name: "Whitebox Apps Discovery" };
+  }
+  if (filename === "whitebox-incremental") {
+    return { agentType: "pentest", name: "Incremental Recon" };
+  }
+  if (filename.startsWith("pages-")) {
+    const appName = filename.replace("pages-", "");
+    return { agentType: "pentest", name: `Pages: ${appName}` };
+  }
+  if (filename.startsWith("apiEndpoints-")) {
+    const appName = filename.replace("apiEndpoints-", "");
+    return { agentType: "pentest", name: `API Endpoints: ${appName}` };
+  }
+  if (filename.startsWith("cloudResourceEndpoints-")) {
+    const appName = filename.replace("cloudResourceEndpoints-", "");
+    return { agentType: "pentest", name: `Cloud Resources: ${appName}` };
+  }
+  if (filename.startsWith("threat-model-")) {
+    const rest = filename.replace("threat-model-", "");
+    return { agentType: "pentest", name: `Threat Model: ${rest}` };
+  }
+  const pentestMatch = filename.match(/^pentest-agent-(\d+)/);
+  if (pentestMatch) {
+    return {
+      agentType: "pentest",
+      name: `Pentest Agent ${pentestMatch[1]}`
+    };
+  }
+  const codingMatch = filename.match(/^coding-agent-(\d+)/);
+  if (codingMatch) {
+    return {
+      agentType: "pentest",
+      name: `Coding Agent ${codingMatch[1]}`
+    };
+  }
+  if (filename === "auth-agent") {
+    return { agentType: "pentest", name: "Auth Agent" };
+  }
+  if (filename.startsWith("vuln-test-")) {
+    const parts = filename.replace("vuln-test-", "").split("-");
+    const vulnClass = parts[0] || "generic";
+    const vulnClassFormatted = vulnClass.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    return {
+      agentType: "pentest",
+      name: `${vulnClassFormatted} Test`
+    };
+  }
+  if (filename.startsWith("orchestrator-")) {
+    return { agentType: "pentest", name: "Orchestrator Summary" };
+  }
+  if (filename.startsWith("ses_")) {
+    return { agentType: "pentest", name: "Pentest Worker" };
+  }
+  return { agentType: "pentest", name: filename.split("-")[0] || "Unknown" };
+}
+function unwrapAiSdkToolOutput(output) {
+  if (output === null || typeof output !== "object")
+    return output;
+  const o = output;
+  switch (o.type) {
+    case "json":
+    case "error-json":
+      if ("value" in o)
+        return o.value;
+      break;
+    case "text":
+    case "error-text":
+      if (typeof o.value === "string")
+        return o.value;
+      break;
+    case "execution-denied":
+      return o.reason ?? "Tool execution denied";
+  }
+  return output;
+}
+function convertMessagesToUI(messages, baseTime) {
+  const uiMessages = [];
+  let messageIndex = 0;
+  const toolResults = new Map;
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "tool-result" && part.toolCallId) {
+          toolResults.set(part.toolCallId, unwrapAiSdkToolOutput(part.output));
+        }
+      }
+    }
+  }
+  for (const msg of messages) {
+    const createdAt = new Date(baseTime.getTime() + messageIndex * 1000);
+    messageIndex++;
+    if (typeof msg.content === "string") {
+      uiMessages.push({
+        role: msg.role,
+        content: msg.content,
+        createdAt
+      });
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text" && part.text) {
+          uiMessages.push({
+            role: "assistant",
+            content: part.text,
+            createdAt
+          });
+        } else if (part.type === "tool-call") {
+          const input = part.input;
+          const toolDescription = typeof input?.toolCallDescription === "string" ? input.toolCallDescription : part.toolName || "tool";
+          const hasResult = part.toolCallId ? toolResults.has(part.toolCallId) : false;
+          const result = part.toolCallId ? toolResults.get(part.toolCallId) : undefined;
+          const resultText = typeof result === "string" ? result : result != null && typeof result === "object" && ("value" in result) && typeof result.value === "string" ? result.value : undefined;
+          const cancelled = typeof resultText === "string" && resultText.toLowerCase().includes("cancelled");
+          const interrupted = !hasResult;
+          uiMessages.push({
+            role: "tool",
+            content: toolDescription,
+            createdAt,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: input,
+            result: interrupted ? "Interrupted" : result,
+            status: cancelled || interrupted ? "error" : "completed"
+          });
+        }
+      }
+    }
+  }
+  return uiMessages;
+}
+function convertModelMessagesToUI2(messages) {
+  return convertMessagesToUI(messages, new Date);
+}
+function loadSubagents2(rootPath) {
+  const subagentsPath = join(rootPath, SUBAGENTS_DIR);
+  const manifestNameById = new Map;
+  {
+    const manifestPath = join(rootPath, MANIFEST_FILE);
+    if (existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        for (const entry of manifest)
+          manifestNameById.set(entry.id, entry.name);
+      } catch {}
+    }
+  }
+  const subagents = [];
+  const agentNameIndex = new Map;
+  if (existsSync(subagentsPath)) {
+    const files = readdirSync(subagentsPath).filter((f) => f.endsWith(".json"));
+    files.sort();
+    for (const file of files) {
+      if (file.startsWith("orchestrator-"))
+        continue;
+      try {
+        const filePath = join(subagentsPath, file);
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        const { agentType, name } = parseSubagentFilename(file);
+        const timestamp = new Date(data.timestamp);
+        const agentName = data.agentName;
+        const stepPath = join(subagentsPath, agentName, "messages.json");
+        let messages;
+        if (existsSync(stepPath)) {
+          try {
+            const raw = JSON.parse(readFileSync(stepPath, "utf-8"));
+            messages = convertMessagesToUI(raw, timestamp);
+          } catch {
+            messages = convertMessagesToUI(data.messages ?? [], timestamp);
+          }
+        } else {
+          messages = convertMessagesToUI(data.messages ?? [], timestamp);
+        }
+        let status = "completed";
+        switch (data.status) {
+          case "canceled":
+          case "failed":
+          case "completed":
+          case "pending":
+            status = data.status;
+            break;
+          default:
+            if (typeof data.findingsCount === "number" && data.findingsCount < 0) {
+              status = "failed";
+            }
+            break;
+        }
+        agentNameIndex.set(data.agentName, subagents.length);
+        subagents.push({
+          id: data.agentName,
+          name: manifestNameById.get(data.agentName) ?? (data.agentName === "attack-surface-agent" ? "Attack Surface Discovery" : name),
+          type: agentType,
+          target: data.target || "Unknown",
+          messages,
+          createdAt: timestamp,
+          status
+        });
+      } catch (e) {
+        log.error(`Failed to load subagent file ${file}`, e instanceof Error ? e : undefined, { error: String(e) });
+      }
+    }
+    const entries = readdirSync(subagentsPath, { withFileTypes: true });
+    for (const dirent of entries) {
+      if (!dirent.isDirectory())
+        continue;
+      const entry = dirent.name;
+      if (agentNameIndex.has(entry))
+        continue;
+      if (entry.endsWith("-tasks") || entry.endsWith("-plan"))
+        continue;
+      const messagesPath = join(subagentsPath, entry, "messages.json");
+      try {
+        const raw = JSON.parse(readFileSync(messagesPath, "utf-8"));
+        if (!Array.isArray(raw) || raw.length === 0)
+          continue;
+        const { agentType, name } = parseSubagentFilename(entry);
+        const timestamp = statSync(messagesPath).mtime;
+        const messages = convertMessagesToUI(raw, timestamp);
+        agentNameIndex.set(entry, subagents.length);
+        subagents.push({
+          id: entry,
+          name: manifestNameById.get(entry) ?? name,
+          type: agentType,
+          target: "Unknown",
+          messages,
+          createdAt: timestamp,
+          status: "completed"
+        });
+      } catch {}
+    }
+  }
+  const manifestPath = join(rootPath, MANIFEST_FILE);
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      for (const entry of manifest) {
+        if (entry.status !== "running")
+          continue;
+        const resumeInfo = {
+          target: entry.target,
+          objective: entry.objective,
+          vulnerabilityClass: entry.vulnerabilityClass,
+          authenticationInfo: entry.authInfo
+        };
+        const existingIndex = agentNameIndex.get(entry.id);
+        if (existingIndex !== undefined) {
+          subagents[existingIndex] = {
+            ...subagents[existingIndex],
+            status: "paused",
+            resumeInfo
+          };
+        } else {
+          subagents.push({
+            id: entry.id,
+            name: entry.name,
+            type: "pentest",
+            target: entry.target,
+            messages: [],
+            createdAt: new Date(entry.spawnedAt),
+            status: "paused",
+            resumeInfo
+          });
+        }
+      }
+    } catch (e) {
+      log.error("Failed to load agent manifest", e instanceof Error ? e : undefined, { error: String(e) });
+    }
+  }
+  return subagents;
+}
+function toolOutputToModelOutput(output) {
+  if (typeof output === "string")
+    return { type: "text", value: output };
+  return { type: "text", value: output.preview };
+}
+function consoleMessageToModelMessages(message, parts) {
+  const ordered = [...parts].sort((a, b) => a.index - b.index);
+  if (message.role === "user" || message.role === "system") {
+    const text = ordered.filter((p) => p.type === "text").map((p) => p.data?.text ?? "").join("");
+    return [{ role: message.role, content: text }];
+  }
+  const assistantContent = [];
+  const toolResults = [];
+  for (const part of ordered) {
+    if (part.type === "text") {
+      const text = part.data?.text ?? "";
+      if (text)
+        assistantContent.push({ type: "text", text });
+    } else if (part.type === "tool") {
+      const tool = part.data;
+      if (!tool)
+        continue;
+      assistantContent.push({
+        type: "tool-call",
+        toolCallId: tool.toolCallId,
+        toolName: tool.tool,
+        input: tool.state.input ?? {}
+      });
+      if (tool.state.status === "completed") {
+        toolResults.push({
+          type: "tool-result",
+          toolCallId: tool.toolCallId,
+          toolName: tool.tool,
+          output: toolOutputToModelOutput(tool.state.output)
+        });
+      } else if (tool.state.status === "error") {
+        toolResults.push({
+          type: "tool-result",
+          toolCallId: tool.toolCallId,
+          toolName: tool.tool,
+          output: {
+            type: "text",
+            value: `tool failed: ${tool.state.errorMessage}`
+          }
+        });
+      }
+    }
+  }
+  const out = [];
+  if (assistantContent.length > 0) {
+    out.push({ role: "assistant", content: assistantContent });
+  }
+  if (toolResults.length > 0) {
+    out.push({ role: "tool", content: toolResults });
+  }
+  return out;
+}
+function nodeToModelMessages(node) {
+  const partsByMessage = new Map;
+  for (const part of node.parts) {
+    const arr = partsByMessage.get(part.messageId);
+    if (arr)
+      arr.push(part);
+    else
+      partsByMessage.set(part.messageId, [part]);
+  }
+  const messages = [...node.messages].sort((a, b) => a.sequence - b.sequence);
+  const out = [];
+  for (const message of messages) {
+    out.push(...consoleMessageToModelMessages(message, partsByMessage.get(message.id) ?? []));
+  }
+  return out;
+}
+function repairOrphanToolCalls2(messages) {
+  const resolved = new Set;
+  for (const msg of messages) {
+    if (msg.role !== "tool" || !Array.isArray(msg.content))
+      continue;
+    for (const part of msg.content) {
+      if (part.type === "tool-result" && typeof part.toolCallId === "string") {
+        resolved.add(part.toolCallId);
+      }
+    }
+  }
+  const result = [];
+  for (const msg of messages) {
+    result.push(msg);
+    if (msg.role !== "assistant" || !Array.isArray(msg.content))
+      continue;
+    const orphanResults = [];
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && typeof part.toolCallId === "string" && !resolved.has(part.toolCallId)) {
+        resolved.add(part.toolCallId);
+        orphanResults.push({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          output: { type: "text", value: "tool failed: process terminated" }
+        });
+      }
+    }
+    if (orphanResults.length > 0) {
+      result.push({ role: "tool", content: orphanResults });
+    }
+  }
+  return result;
+}
+function finalizeResumeMessages(messages) {
+  return normalizeMessages2(repairOrphanToolCalls2(messages));
+}
+function atomicWriteJson(filePath, value) {
+  mkdirSync(join(filePath, ".."), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value, null, 2), "utf-8");
+  renameSync(tmp, filePath);
+}
+function rehydrateFromConsoleTree2(sessionId, tree) {
+  const rootPath = getSessionRoot2(sessionId);
+  const rootMessages = finalizeResumeMessages(nodeToModelMessages(tree));
+  const sessionJsonPath = join(rootPath, "session.json");
+  if (!existsSync(sessionJsonPath)) {
+    atomicWriteJson(sessionJsonPath, {
+      id: tree.session.id,
+      agentType: tree.session.agentType,
+      parentSessionId: tree.session.parentSessionId,
+      status: tree.session.status,
+      metadata: tree.session.metadata ?? null
+    });
+  }
+  atomicWriteJson(join(rootPath, "messages.json"), rootMessages);
+  const subagentMessages = new Map;
+  for (const descendant of tree.descendants) {
+    const childId = descendant.session.id;
+    const childMessages = finalizeResumeMessages(nodeToModelMessages(descendant));
+    subagentMessages.set(childId, childMessages);
+    atomicWriteJson(join(rootPath, SUBAGENTS_DIR, childId, "messages.json"), childMessages);
+  }
+  return { rootPath, messages: rootMessages, subagentMessages };
+}
+
+export { loadSubagentMessages2, saveSubagentData2, writeAgentManifest2, readAgentManifest2, buildManifestEntries2, reconcileManifestOnResume2, finalizeManifest2, updateManifestEntryStatus2, getCompletedAgentIds2, convertModelMessagesToUI2, loadSubagents2, repairOrphanToolCalls2, rehydrateFromConsoleTree2, exports_persistence };

package/build/lib/chunk-mv74mq5n.js

@@ -0,0 +1,59 @@
+// src/core/agents/offSecAgent/tools/smsInbox.ts
+function requireAgentApi() {
+  const base = process.env.AGENT_API_URL;
+  const token = process.env.AGENT_API_TOKEN;
+  if (!base || !token) {
+    throw new Error("sms_list_messages requires AGENT_API_URL and AGENT_API_TOKEN (Console sandbox dispatch). Local CLI without Console cannot read inbound SMS.");
+  }
+  return { base: base.replace(/\/+$/, ""), token };
+}
+function refusalForStatus(status) {
+  if (status === 429)
+    return "lease-held";
+  if (status === 403)
+    return "not-configured";
+  if (status === 409)
+    return "already-claimed";
+  return null;
+}
+
+class HttpSmsInbox2 {
+  async get(params, signal) {
+    const { base, token } = requireAgentApi();
+    const url = new URL(`${base}/agent/sms/messages`);
+    url.search = params.toString();
+    return fetch(url.toString(), {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` },
+      signal
+    });
+  }
+  async reserve(signal) {
+    const res = await this.get(new URLSearchParams({ reserve: "1" }), signal);
+    const refusal = refusalForStatus(res.status);
+    if (refusal)
+      return { ok: false, reason: refusal };
+    if (!res.ok) {
+      throw new Error(`SMS list API error ${res.status} ${res.statusText}`);
+    }
+    return { ok: true };
+  }
+  async list(opts, signal) {
+    const params = new URLSearchParams({
+      since: new Date(opts.sinceMs).toISOString()
+    });
+    if (opts.claim)
+      params.set("claim", "1");
+    const res = await this.get(params, signal);
+    const refusal = refusalForStatus(res.status);
+    if (refusal)
+      return { ok: false, reason: refusal };
+    if (!res.ok) {
+      throw new Error(`SMS list API error ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return { ok: true, messages: data.messages, claimed: data.claimed };
+  }
+}
+
+export { HttpSmsInbox2 };

package/build/lib/chunk-n0ba7khr.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+
+export { __export, __esm, __using, __callDispose };