lurqrun 0.1.6 → 0.1.7

package/dist/e2b-FVPHDULZ.js

@@ -0,0 +1,172 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  DEFAULT_TARGET
+} from "./chunk-GE37NVLN.js";
+import {
+  getConfig
+} from "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/sandbox/e2b.ts
+init_esm_shims();
+var INSTALL_TIMEOUT_MS = 12e4;
+var SMOKE_TIMEOUT_MS = 3e4;
+var ERROR_MAX = 500;
+var WORKDIR = "/home/user";
+function shQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function installCommand(specs, allowScripts) {
+  const bad = specs.find((s) => s.startsWith("-"));
+  if (bad) throw new Error(`Invalid package spec: ${bad}`);
+  const flags = ["--no-audit", "--no-fund", "--no-package-lock", "--no-save"];
+  if (!allowScripts) flags.push("--ignore-scripts");
+  return `npm install ${specs.map(shQuote).join(" ")} ${flags.join(" ")}`;
+}
+function smokeCommand(pkg) {
+  return `node --input-type=module -e ${shQuote(`await import(${JSON.stringify(pkg)})`)}`;
+}
+function condense(s) {
+  return s.replace(/\s+/g, " ").trim().slice(0, ERROR_MAX);
+}
+function errText(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.stderr === "string" && e.stderr.trim()) return e.stderr;
+    if (typeof e.message === "string") return e.message;
+  }
+  return String(err);
+}
+var toSpec = (p) => p.version ? `${p.name}@${p.version}` : p.name;
+var E2BSandbox = class {
+  name = "e2b";
+  async verify(pkg, version, opts = {}) {
+    const set = await this.verifySet([{ name: pkg, version }], opts);
+    return {
+      driver: this.name,
+      moduleSystem: set.moduleSystem,
+      installed: set.installed,
+      imported: set.loaded[0]?.loaded ?? null,
+      ranScripts: opts.allowScripts ?? false,
+      durationMs: set.durationMs,
+      error: set.error
+    };
+  }
+  async verifySet(packages, opts = {}) {
+    const config = getConfig();
+    const target = opts.target ?? DEFAULT_TARGET;
+    const allowScripts = opts.allowScripts ?? false;
+    const specs = packages.map(toSpec);
+    const installTimeout = opts.timeoutMs ?? INSTALL_TIMEOUT_MS;
+    const started = Date.now();
+    const smokeTargets = opts.smokePackages ?? packages;
+    const loaded = smokeTargets.map((p) => ({ name: p.name, loaded: null }));
+    let installed = false;
+    let error = null;
+    const install = installCommand(specs, allowScripts);
+    const { default: Sandbox } = await import("e2b");
+    const createOpts = {
+      apiKey: config.E2B_API_KEY,
+      timeoutMs: installTimeout + SMOKE_TIMEOUT_MS * packages.length + 3e4
+    };
+    const sandbox = config.E2B_TEMPLATE ? await Sandbox.create(config.E2B_TEMPLATE, createOpts) : await Sandbox.create(createOpts);
+    try {
+      await sandbox.files.write(
+        `${WORKDIR}/package.json`,
+        JSON.stringify({ name: "lurq-sandbox", version: "0.0.0", private: true })
+      );
+      await sandbox.commands.run(install, { cwd: WORKDIR, timeoutMs: installTimeout });
+      installed = true;
+      for (let i = 0; i < smokeTargets.length; i++) {
+        try {
+          await sandbox.commands.run(smokeCommand(smokeTargets[i].name), {
+            cwd: WORKDIR,
+            timeoutMs: SMOKE_TIMEOUT_MS
+          });
+          loaded[i].loaded = true;
+        } catch (err) {
+          loaded[i].loaded = false;
+          if (!error) error = condense(errText(err));
+        }
+      }
+    } catch (err) {
+      error = condense(errText(err));
+    } finally {
+      await sandbox.kill().catch(() => {
+      });
+    }
+    return {
+      driver: this.name,
+      moduleSystem: target.moduleSystem,
+      installed,
+      loaded,
+      durationMs: Date.now() - started,
+      error
+    };
+  }
+  async exec(command, opts = {}) {
+    const config = getConfig();
+    const timeoutMs = opts.timeoutMs ?? SMOKE_TIMEOUT_MS;
+    const install = opts.install?.length ? installCommand(opts.install.map(toSpec), opts.allowScripts ?? false) : null;
+    const { default: Sandbox } = await import("e2b");
+    const createOpts = {
+      apiKey: config.E2B_API_KEY,
+      timeoutMs: (install ? INSTALL_TIMEOUT_MS : 0) + timeoutMs + 3e4
+    };
+    const sandbox = config.E2B_TEMPLATE ? await Sandbox.create(config.E2B_TEMPLATE, createOpts) : await Sandbox.create(createOpts);
+    try {
+      await sandbox.files.write(
+        `${WORKDIR}/package.json`,
+        JSON.stringify({ name: "lurq-sandbox", version: "0.0.0", private: true })
+      );
+      if (install) {
+        await sandbox.commands.run(install, { cwd: WORKDIR, timeoutMs: INSTALL_TIMEOUT_MS });
+      }
+      const out = await sandbox.commands.run(command, { cwd: WORKDIR, timeoutMs });
+      return { exitCode: out.exitCode ?? 0, stdout: out.stdout ?? "", stderr: out.stderr ?? "" };
+    } catch (err) {
+      const e = err;
+      if (typeof e?.exitCode === "number") {
+        return {
+          exitCode: e.exitCode,
+          stdout: typeof e.stdout === "string" ? e.stdout : "",
+          stderr: typeof e.stderr === "string" ? e.stderr : errText(err)
+        };
+      }
+      throw err;
+    } finally {
+      await sandbox.kill().catch(() => {
+      });
+    }
+  }
+  async getRuntimeInfo() {
+    let nodeVersion = "unknown";
+    let npmVersion = "unknown";
+    const config = getConfig();
+    try {
+      const { default: Sandbox } = await import("e2b");
+      const createOpts = { apiKey: config.E2B_API_KEY, timeoutMs: 3e4 };
+      const sandbox = config.E2B_TEMPLATE ? await Sandbox.create(config.E2B_TEMPLATE, createOpts) : await Sandbox.create(createOpts);
+      try {
+        const nodeOut = await sandbox.commands.run("node --version");
+        nodeVersion = (nodeOut.stdout ?? "").trim() || "unknown";
+        const npmOut = await sandbox.commands.run("npm --version");
+        npmVersion = (npmOut.stdout ?? "").trim() || "unknown";
+      } finally {
+        await sandbox.kill().catch(() => {
+        });
+      }
+    } catch {
+    }
+    return { nodeVersion, npmVersion };
+  }
+};
+export {
+  E2BSandbox,
+  installCommand,
+  shQuote,
+  smokeCommand
+};

package/dist/extract-NKGKLIVT.js

@@ -0,0 +1,444 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  readManifest,
+  resolveEntryCandidates,
+  resolveInternal,
+  resolvesInsidePackage
+} from "./chunk-ELGCAM7P.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/extract.ts
+init_esm_shims();
+import { readFileSync } from "fs";
+import { relative } from "path";
+import ts from "typescript";
+var TIER = "shipped_js_ast";
+var MAX_FILES = 400;
+function classify(node) {
+  if (ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isFunctionDeclaration(node)) {
+    return { kind: "function", arity: arityOf(node), maxArity: maxArityOf(node) };
+  }
+  if (ts.isClassExpression(node) || ts.isClassDeclaration(node)) return { kind: "class", arity: null };
+  if (ts.isObjectLiteralExpression(node)) return { kind: "object", arity: null };
+  if (ts.isStringLiteral(node) || ts.isNumericLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword) {
+    return { kind: "primitive", arity: null };
+  }
+  return { kind: "object", arity: null };
+}
+function arityOf(fn) {
+  let n = 0;
+  for (const p of fn.parameters) {
+    if (p.initializer || p.dotDotDotToken) break;
+    n++;
+  }
+  return n;
+}
+function maxArityOf(fn) {
+  if (fn.parameters.some((p) => p.dotDotDotToken)) return null;
+  let readsArguments = false;
+  const visit = (n) => {
+    if (readsArguments) return;
+    if (ts.isIdentifier(n) && n.text === "arguments") readsArguments = true;
+    else if (!(ts.isFunctionLike(n) && !ts.isArrowFunction(n))) ts.forEachChild(n, visit);
+  };
+  if (fn.body) visit(fn.body);
+  return readsArguments ? null : fn.parameters.length;
+}
+function lineOf(sf, node) {
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+function put(out, sym) {
+  if (!out.has(sym.path)) out.set(sym.path, sym);
+}
+function localBinding(sf, name) {
+  let found = null;
+  for (const stmt of sf.statements) {
+    if (ts.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (ts.isIdentifier(d.name) && d.name.text === name && d.initializer) found = d.initializer;
+      }
+    } else if (ts.isFunctionDeclaration(stmt) && stmt.name?.text === name) {
+      found = stmt;
+    } else if (ts.isClassDeclaration(stmt) && stmt.name?.text === name) {
+      found = stmt;
+    }
+  }
+  return found;
+}
+function isModuleExports(e) {
+  return ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression) && e.expression.text === "module" && e.name.text === "exports";
+}
+function exportTargetName(e) {
+  if (!ts.isPropertyAccessExpression(e)) return null;
+  if (ts.isIdentifier(e.expression) && e.expression.text === "exports") return e.name.text;
+  if (isModuleExports(e.expression)) return e.name.text;
+  return null;
+}
+function hasDeprecatedTag(sf, node) {
+  const full = node.getFullText(sf);
+  const lead = full.slice(0, full.length - node.getText(sf).length);
+  return /@deprecated/i.test(lead);
+}
+function flattenStatements(stmts, depth = 0) {
+  if (depth > 6) return [...stmts];
+  const out = [];
+  for (const s of stmts) {
+    out.push(s);
+    if (ts.isBlock(s)) out.push(...flattenStatements(s.statements, depth + 1));
+    else if (ts.isIfStatement(s)) {
+      const branches = [s.thenStatement, s.elseStatement].filter(Boolean);
+      for (const b of branches) {
+        out.push(...flattenStatements(ts.isBlock(b) ? b.statements : [b], depth + 1));
+      }
+    } else if (ts.isTryStatement(s)) {
+      out.push(...flattenStatements(s.tryBlock.statements, depth + 1));
+      if (s.catchClause) out.push(...flattenStatements(s.catchClause.block.statements, depth + 1));
+      if (s.finallyBlock) out.push(...flattenStatements(s.finallyBlock.statements, depth + 1));
+    } else if (ts.isSwitchStatement(s)) {
+      for (const c of s.caseBlock.clauses) {
+        out.push(...flattenStatements(c.statements, depth + 1));
+      }
+    }
+  }
+  return out;
+}
+function walk(file, ctx, out) {
+  if (ctx.visited.has(file)) return;
+  if (ctx.filesWalked >= MAX_FILES) {
+    ctx.truncated = true;
+    return;
+  }
+  ctx.visited.add(file);
+  ctx.filesWalked++;
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return;
+  }
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+  const rel = relative(ctx.pkgDir, file);
+  const add = (path, node, over = {}) => {
+    const { kind, arity, maxArity } = classify(node);
+    put(out, {
+      path,
+      kind,
+      arity,
+      ...maxArity !== void 0 ? { maxArity } : {},
+      origin: "local",
+      deprecated: hasDeprecatedTag(sf, node),
+      tier: TIER,
+      sourceRef: { file: rel, line: lineOf(sf, node), offset: node.getStart(sf) },
+      ...over
+    });
+  };
+  const reExport = (spec, names, picks) => {
+    if (resolvesInsidePackage(spec)) {
+      const target = resolveInternal(file, spec, ctx.pkgDir);
+      if (!target) return;
+      if (!picks) {
+        walk(target, ctx, out);
+        return;
+      }
+      const sub = /* @__PURE__ */ new Map();
+      walk(target, { ...ctx, visited: new Set(ctx.visited) }, sub);
+      for (const pick of picks) {
+        const found = sub.get(pick.from);
+        if (found) put(out, { ...found, path: pick.as });
+        else put(out, { path: pick.as, kind: "object", arity: null, origin: "local", deprecated: false, tier: TIER, sourceRef: { file: rel, line: 1 } });
+      }
+      return;
+    }
+    ctx.external.add(spec);
+    for (const n of names ?? []) {
+      put(out, {
+        path: n,
+        kind: "object",
+        arity: null,
+        origin: `external:${spec}`,
+        deprecated: false,
+        tier: TIER,
+        sourceRef: { file: rel, line: 1 }
+      });
+    }
+  };
+  for (const stmt of flattenStatements(sf.statements)) {
+    if (ts.isExportDeclaration(stmt)) {
+      const spec = stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : null;
+      const isTypeOnly = stmt.isTypeOnly;
+      if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        const names = stmt.exportClause.elements.map((el) => el.name.text);
+        if (spec) {
+          reExport(
+            spec,
+            names,
+            stmt.exportClause.elements.map((el) => ({
+              from: el.propertyName?.text ?? el.name.text,
+              as: el.name.text
+            }))
+          );
+        } else {
+          for (const el of stmt.exportClause.elements) {
+            const local = el.propertyName?.text ?? el.name.text;
+            const decl = localBinding(sf, local);
+            if (isTypeOnly || el.isTypeOnly) {
+              put(out, {
+                path: el.name.text,
+                kind: "type_only",
+                arity: null,
+                origin: "local",
+                deprecated: false,
+                tier: TIER,
+                sourceRef: { file: rel, line: lineOf(sf, el) }
+              });
+            } else if (decl) {
+              add(el.name.text, decl);
+            } else {
+              add(el.name.text, el);
+            }
+          }
+        }
+      } else if (spec) {
+        reExport(spec, null);
+      }
+      continue;
+    }
+    const mods = ts.canHaveModifiers(stmt) ? ts.getModifiers(stmt) : void 0;
+    const exported = mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (exported) {
+      if (ts.isVariableStatement(stmt)) {
+        for (const d of stmt.declarationList.declarations) {
+          if (ts.isIdentifier(d.name)) add(d.name.text, d.initializer ?? d);
+        }
+      } else if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+        add(stmt.name.text, stmt);
+      } else if (ts.isClassDeclaration(stmt) && stmt.name) {
+        add(stmt.name.text, stmt);
+      } else if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) {
+        put(out, {
+          path: stmt.name.text,
+          kind: "type_only",
+          arity: null,
+          origin: "local",
+          deprecated: false,
+          tier: TIER,
+          sourceRef: { file: rel, line: lineOf(sf, stmt) }
+        });
+      }
+      continue;
+    }
+    if (ts.isExportAssignment(stmt)) {
+      const target = ts.isIdentifier(stmt.expression) ? localBinding(sf, stmt.expression.text) ?? stmt.expression : stmt.expression;
+      add("default", target);
+      continue;
+    }
+    if (ts.isExpressionStatement(stmt)) {
+      const e = stmt.expression;
+      if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && ts.isIdentifier(e.expression.expression) && e.expression.expression.text === "Object" && e.expression.name.text === "defineProperty" && e.arguments.length >= 2) {
+        const targetArg = e.arguments[0];
+        const isExportsTarget = ts.isIdentifier(targetArg) && targetArg.text === "exports" || isModuleExports(targetArg);
+        const nameArg = e.arguments[1];
+        if (isExportsTarget && ts.isStringLiteral(nameArg) && nameArg.text !== "__esModule") {
+          put(out, {
+            path: nameArg.text,
+            kind: "object",
+            arity: null,
+            origin: "local",
+            deprecated: hasDeprecatedTag(sf, stmt),
+            tier: TIER,
+            sourceRef: { file: rel, line: lineOf(sf, stmt) }
+          });
+          continue;
+        }
+      }
+      if (ts.isCallExpression(e)) {
+        const callee = e.expression;
+        const isObjectAssign = ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign" && e.arguments.length > 0 && isModuleExports(e.arguments[0]);
+        const isExportStar = ts.isIdentifier(callee) && /^_{0,2}(exportStar|reExport|export)$/i.test(callee.text);
+        if (isObjectAssign || isExportStar) {
+          for (const arg of e.arguments.slice(isObjectAssign ? 1 : 0)) {
+            const spec = requireSpecifier(arg);
+            if (spec) reExport(spec, null);
+            else if (ts.isObjectLiteralExpression(arg)) {
+              for (const p of arg.properties) {
+                if (p.name && ts.isIdentifier(p.name)) {
+                  const value = ts.isPropertyAssignment(p) ? p.initializer : p;
+                  add(p.name.text, isExportStar ? throughGetter(sf, value) : value);
+                }
+              }
+            } else if (ts.isIdentifier(arg)) {
+              const b = localBinding(sf, arg.text);
+              if (b && ts.isObjectLiteralExpression(b)) {
+                for (const p of b.properties) {
+                  if (p.name && ts.isIdentifier(p.name)) {
+                    add(p.name.text, ts.isPropertyAssignment(p) ? p.initializer : p);
+                  }
+                }
+              }
+            }
+          }
+          continue;
+        }
+      }
+      if (!ts.isBinaryExpression(e) || e.operatorToken.kind !== ts.SyntaxKind.EqualsToken) continue;
+      const lhs = e.left;
+      const rhs = e.right;
+      if (isModuleExports(lhs)) {
+        const spec = requireSpecifier(rhs);
+        if (spec) {
+          reExport(spec, null);
+          continue;
+        }
+        if (ts.isObjectLiteralExpression(rhs)) {
+          for (const p of rhs.properties) {
+            if (p.name && ts.isIdentifier(p.name)) {
+              add(p.name.text, ts.isPropertyAssignment(p) ? p.initializer : p);
+            }
+          }
+          continue;
+        }
+        if (ts.isIdentifier(rhs)) {
+          const b = localBinding(sf, rhs.text);
+          if (b && ts.isObjectLiteralExpression(b)) {
+            for (const p of b.properties) {
+              if (p.name && ts.isIdentifier(p.name)) {
+                add(p.name.text, ts.isPropertyAssignment(p) ? p.initializer : p);
+              }
+            }
+            continue;
+          }
+          if (b) {
+            add("default", b);
+            continue;
+          }
+        }
+        add("default", rhs);
+        continue;
+      }
+      const name = exportTargetName(lhs);
+      if (name) {
+        const spec = requireSpecifier(rhs);
+        if (spec && !resolvesInsidePackage(spec)) {
+          ctx.external.add(spec);
+          put(out, {
+            path: name,
+            kind: "object",
+            arity: null,
+            origin: `external:${spec}`,
+            deprecated: false,
+            tier: TIER,
+            sourceRef: { file: rel, line: lineOf(sf, stmt) }
+          });
+          continue;
+        }
+        const target = ts.isIdentifier(rhs) ? localBinding(sf, rhs.text) ?? rhs : rhs;
+        add(name, target, { deprecated: hasDeprecatedTag(sf, stmt) });
+      }
+    }
+  }
+}
+function throughGetter(sf, value) {
+  if (!(ts.isArrowFunction(value) || ts.isFunctionExpression(value)) || value.parameters.length) return value;
+  let returned;
+  if (!ts.isBlock(value.body)) returned = value.body;
+  else if (value.body.statements.length === 1 && ts.isReturnStatement(value.body.statements[0])) {
+    returned = value.body.statements[0].expression;
+  }
+  if (!returned) return value;
+  return ts.isIdentifier(returned) ? localBinding(sf, returned.text) ?? returned : returned;
+}
+function requireSpecifier(node) {
+  let n = node;
+  if (ts.isPropertyAccessExpression(n)) n = n.expression;
+  if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "require" && n.arguments.length === 1 && ts.isStringLiteral(n.arguments[0])) {
+    return n.arguments[0].text;
+  }
+  return null;
+}
+function isReadable(symbols) {
+  if (symbols.length === 0) return false;
+  return !(symbols.length === 1 && symbols[0].path === "default");
+}
+function extractSurface(pkgDir, opts = {}) {
+  const manifest = opts.manifest ?? readManifest(pkgDir);
+  const candidates = resolveEntryCandidates(pkgDir, manifest, opts.subpath);
+  const base = {
+    package: manifest?.name ?? pkgDir,
+    version: manifest?.version ?? null,
+    tier: TIER,
+    entry: null,
+    symbols: [],
+    filesWalked: 0,
+    externalReExports: []
+  };
+  if (!candidates.length) {
+    return {
+      ...base,
+      undeclaredReason: opts.subpath ? `no resolvable JS entry point for subpath ./${opts.subpath}` : "no resolvable JS entry point"
+    };
+  }
+  const attempts = [];
+  for (const entry of candidates) {
+    const ctx = {
+      pkgDir,
+      visited: /* @__PURE__ */ new Set(),
+      filesWalked: 0,
+      external: /* @__PURE__ */ new Set(),
+      truncated: false
+    };
+    const out = /* @__PURE__ */ new Map();
+    walk(entry, ctx, out);
+    attempts.push({
+      entry,
+      symbols: [...out.values()].sort((a, b) => a.path.localeCompare(b.path)),
+      walked: ctx.filesWalked,
+      external: [...ctx.external].sort()
+    });
+    if (isReadable(attempts[attempts.length - 1].symbols)) break;
+  }
+  const attempt = attempts.find((a) => isReadable(a.symbols)) ?? attempts[0];
+  return {
+    ...base,
+    entry: relative(pkgDir, attempt.entry),
+    symbols: attempt.symbols,
+    filesWalked: attempt.walked,
+    externalReExports: attempt.external,
+    ...attempt.symbols.length === 0 ? { undeclaredReason: "entry resolved but no exports found" } : {}
+  };
+}
+function usesTopLevelAwait(pkgDir, entry) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [entry];
+  while (queue.length && seen.size < MAX_FILES) {
+    const file = queue.pop();
+    if (seen.has(file)) continue;
+    seen.add(file);
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
+    for (const stmt of sf.statements) {
+      if (awaitsAtTopLevel(stmt)) return true;
+      const spec = ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt) ? stmt.moduleSpecifier : void 0;
+      if (spec && ts.isStringLiteral(spec) && resolvesInsidePackage(spec.text)) {
+        const next = resolveInternal(file, spec.text, pkgDir);
+        if (next) queue.push(next);
+      }
+    }
+  }
+  return false;
+}
+function awaitsAtTopLevel(node) {
+  if (ts.isFunctionLike(node) || ts.isClassLike(node)) return false;
+  if (ts.isAwaitExpression(node) || ts.isForOfStatement(node) && node.awaitModifier) return true;
+  return ts.forEachChild(node, awaitsAtTopLevel) ?? false;
+}
+export {
+  extractSurface,
+  usesTopLevelAwait
+};

package/dist/fetch-QYTUJVG2.js

@@ -0,0 +1,22 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  extractUnpacked,
+  fetchAndExtract,
+  fetchManifest,
+  resolveTarball,
+  unpackPackage,
+  verifyIntegrity
+} from "./chunk-BV32UNLL.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  extractUnpacked,
+  fetchAndExtract,
+  fetchManifest,
+  resolveTarball,
+  unpackPackage,
+  verifyIntegrity
+};

package/dist/firstTouch-QQTJH4QX.js

@@ -0,0 +1,55 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  withBudget
+} from "./chunk-4ESO33J6.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/pipeline/firstTouch.ts
+init_esm_shims();
+var SURFACE_FIRST_TOUCH_BUDGET_MS = 4e3;
+var MAX_INFLIGHT = 64;
+var inFlight = /* @__PURE__ */ new Map();
+function extractOnce(db, pkg, version) {
+  const key = `${pkg}@${version ?? "latest"}`;
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  if (inFlight.size >= MAX_INFLIGHT) return Promise.resolve(null);
+  const task = (async () => {
+    const { extractAndStore } = await import("./surface-V62GE554.js");
+    const { outcome, version: resolved } = await extractAndStore(db, pkg, version);
+    return outcome === "stored" || outcome === "cached" ? resolved : null;
+  })().catch((err) => {
+    logger.warn(
+      `surface first-touch failed for ${key}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }).finally(() => {
+    inFlight.delete(key);
+  });
+  inFlight.set(key, task);
+  return task;
+}
+function firstTouchSurface(db, pkg, version, budgetMs = SURFACE_FIRST_TOUCH_BUDGET_MS) {
+  const task = extractOnce(db, pkg, version);
+  return budgetMs <= 0 ? Promise.resolve(null) : withBudget(task, budgetMs).then((v) => v ?? null);
+}
+async function firstTouchPair(db, pkg, fromVersion, toVersion, budgetMs = SURFACE_FIRST_TOUCH_BUDGET_MS) {
+  if (budgetMs <= 0) return false;
+  const pair = Promise.all([extractOnce(db, pkg, fromVersion), extractOnce(db, pkg, toVersion)]);
+  const settled = await withBudget(pair, budgetMs);
+  return Boolean(settled && settled[0] && settled[1]);
+}
+function resetSurfaceFirstTouch() {
+  inFlight.clear();
+}
+export {
+  SURFACE_FIRST_TOUCH_BUDGET_MS,
+  firstTouchPair,
+  firstTouchSurface,
+  resetSurfaceFirstTouch
+};