lurqrun 0.1.6 → 0.1.8

package/dist/extract-6WG265BL.js

@@ -0,0 +1,455 @@
+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-PJ3SC32M.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-FVYFV5HA.js";
+import "./chunk-D3VTZS7V.js";
+import "./chunk-KYKSZ3XZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-72Y2FDVS.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  extractUnpacked,
+  fetchAndExtract,
+  fetchManifest,
+  resolveTarball,
+  unpackPackage,
+  verifyIntegrity
+};

package/dist/firstTouch-COJCMOB3.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-7MHE3RL7.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
+};