@vercel/python-analysis 0.12.0 → 0.13.2

package/dist/index.cjs

@@ -66,11 +66,13 @@ __export(src_exports, {
   UvConfigWorkspaceSchema: () => UvConfigWorkspaceSchema,
   UvIndexEntrySchema: () => UvIndexEntrySchema,
   classifyPackages: () => classifyPackages,
+  collectImportClosure: () => collectImportClosure,
   containsTopLevelCallable: () => containsTopLevelCallable,
   createMinimalManifest: () => createMinimalManifest,
   discoverPythonPackage: () => discoverPythonPackage,
   evaluateMarker: () => evaluateMarker,
   extendDistRecord: () => extendDistRecord,
+  extractImports: () => extractImports,
   findAppOrHandler: () => findAppOrHandler,
   getStringConstant: () => getStringConstant,
   isPrivatePackageSource: () => isPrivatePackageSource,
@@ -226,6 +228,224 @@ async function getStringConstant(source, name) {
   return mod.getStringConstant(source, name) ?? null;
 }
 
+// src/semantic/import-graph.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = require("path");
+async function extractImports(source) {
+  if (!source.includes("import")) {
+    return [];
+  }
+  const mod = await importWasmModule();
+  return mod.extractImports(source);
+}
+var DEFAULT_MAX_FILES = 3e4;
+async function readStatKind(path4) {
+  try {
+    const stats = await import_fs.default.promises.stat(path4);
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "dir";
+  } catch {
+  }
+  return null;
+}
+function statKind(path4, cache) {
+  const cached = cache.statKinds.get(path4);
+  if (cached)
+    return cached;
+  const pending = readStatKind(path4);
+  cache.statKinds.set(path4, pending);
+  return pending;
+}
+async function resolveNamePartsUncached(parts, searchDirs, cache) {
+  const rel = (0, import_path.join)(...parts);
+  for (const root of searchDirs) {
+    let target = null;
+    let targetKind = null;
+    const candidateInit = (0, import_path.join)(root, rel, "__init__.py");
+    if (await statKind(candidateInit, cache) === "file") {
+      target = candidateInit;
+      targetKind = "file";
+    } else {
+      const candidateModule = (0, import_path.join)(root, `${rel}.py`);
+      if (await statKind(candidateModule, cache) === "file") {
+        target = candidateModule;
+        targetKind = "file";
+      } else if (await statKind((0, import_path.join)(root, rel), cache) === "dir") {
+        target = (0, import_path.join)(root, rel);
+        targetKind = "dir";
+      }
+    }
+    if (target !== null) {
+      const parentChain = [];
+      let acc = root;
+      for (const part of parts.slice(0, -1)) {
+        acc = (0, import_path.join)(acc, part);
+        const init = (0, import_path.join)(acc, "__init__.py");
+        if (await statKind(init, cache) === "file") {
+          parentChain.push(init);
+        }
+      }
+      return { target, targetKind, parentChain };
+    }
+  }
+  return null;
+}
+function resolveNameParts(parts, searchDirs, searchKey, cache) {
+  if (parts.length === 0)
+    return Promise.resolve(null);
+  const key = `${searchKey}\0${parts.join(".")}`;
+  const cached = cache.names.get(key);
+  if (cached)
+    return cached;
+  const pending = resolveNamePartsUncached(parts, searchDirs, cache);
+  cache.names.set(key, pending);
+  return pending;
+}
+async function resolveSeedName(parts, searchDirs, searchKey, cache) {
+  for (let length = parts.length; length > 0; length--) {
+    const resolved = await resolveNameParts(
+      parts.slice(0, length),
+      searchDirs,
+      searchKey,
+      cache
+    );
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function submoduleDir(target, targetKind) {
+  if (targetKind === "dir")
+    return target;
+  if (targetKind === "file" && target.endsWith(`${import_path.sep}__init__.py`)) {
+    return (0, import_path.dirname)(target);
+  }
+  return null;
+}
+async function resolveImport(stmt, importerPath, roots, rootsKey, cache) {
+  const resolved = /* @__PURE__ */ new Set();
+  let search = roots;
+  let searchKey = rootsKey;
+  if (stmt.level > 0) {
+    let base = (0, import_path.dirname)(importerPath);
+    for (let i = 1; i < stmt.level; i++) {
+      base = (0, import_path.dirname)(base);
+    }
+    search = [base];
+    searchKey = base;
+  }
+  const parts = stmt.module ? stmt.module.split(".") : [];
+  let target;
+  let targetKind;
+  if (parts.length > 0) {
+    const name = await resolveNameParts(parts, search, searchKey, cache);
+    if (!name)
+      return [];
+    target = name.target;
+    targetKind = name.targetKind;
+    if (targetKind === "file")
+      resolved.add(target);
+    for (const init of name.parentChain) {
+      resolved.add(init);
+    }
+  } else if (stmt.level > 0) {
+    target = search[0];
+    targetKind = "dir";
+  } else {
+    return [];
+  }
+  const subDir = submoduleDir(target, targetKind);
+  if (subDir) {
+    for (const name of stmt.names) {
+      if (name === "*")
+        continue;
+      const sub = await resolveNameParts([name], [subDir], subDir, cache);
+      if (sub) {
+        if (sub.targetKind === "file")
+          resolved.add(sub.target);
+        for (const init of sub.parentChain) {
+          resolved.add(init);
+        }
+      }
+    }
+  }
+  return [...resolved];
+}
+function isModuleNameSeed(seed) {
+  return !(0, import_path.isAbsolute)(seed) && /^[A-Za-z_][\w]*(\.[A-Za-z_][\w]*)*$/.test(seed);
+}
+async function collectImportClosure({
+  seeds,
+  searchRoots,
+  maxFiles = DEFAULT_MAX_FILES
+}) {
+  const roots = searchRoots.map((r) => (0, import_path.resolve)(r));
+  const rootsKey = roots.join("\0");
+  const cache = {
+    statKinds: /* @__PURE__ */ new Map(),
+    names: /* @__PURE__ */ new Map()
+  };
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = [];
+  let truncated = false;
+  for (const seed of seeds) {
+    if (isModuleNameSeed(seed)) {
+      const name = await resolveSeedName(
+        seed.split("."),
+        roots,
+        rootsKey,
+        cache
+      );
+      if (name) {
+        if (name.targetKind === "file")
+          frontier.push(name.target);
+        frontier.push(...name.parentChain);
+      }
+    } else {
+      const seedPath = (0, import_path.resolve)(seed);
+      if (await statKind(seedPath, cache) === "file") {
+        frontier.push(seedPath);
+      }
+    }
+  }
+  while (frontier.length > 0) {
+    const batch = [...new Set(frontier)].filter((p) => !visited.has(p));
+    frontier = [];
+    if (batch.length === 0)
+      continue;
+    for (const path4 of batch) {
+      visited.add(path4);
+    }
+    if (visited.size > maxFiles) {
+      truncated = true;
+      break;
+    }
+    const dependencies = await Promise.all(
+      batch.map(async (importerPath) => {
+        let source;
+        try {
+          source = await import_fs.default.promises.readFile(importerPath, "utf8");
+        } catch {
+          return [];
+        }
+        const stmts = await extractImports(source);
+        const files = await Promise.all(
+          stmts.filter((s) => s.isModuleLevel && !s.inTypeChecking).map((s) => resolveImport(s, importerPath, roots, rootsKey, cache))
+        );
+        return files.flat();
+      })
+    );
+    for (const dep of dependencies.flat()) {
+      if (!visited.has(dep)) {
+        frontier.push(dep);
+      }
+    }
+  }
+  return { files: visited, truncated };
+}
+
 // src/manifest/dist-metadata.ts
 var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
@@ -394,7 +614,7 @@ async function scanDistributions(sitePackagesDir) {
   return index;
 }
 function hashFile(filePath) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const h = (0, import_node_crypto.createHash)("sha256");
     let size = 0;
     const stream = (0, import_node_fs.createReadStream)(filePath);
@@ -404,7 +624,7 @@ function hashFile(filePath) {
     });
     stream.on("error", reject);
     stream.on("end", () => {
-      resolve({ hash: h.digest("base64url"), size });
+      resolve2({ hash: h.digest("base64url"), size });
     });
   });
 }
@@ -2435,11 +2655,13 @@ var HashDigestSchema = hashDigestSchema;
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
+  collectImportClosure,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
   evaluateMarker,
   extendDistRecord,
+  extractImports,
   findAppOrHandler,
   getStringConstant,
   isPrivatePackageSource,

package/dist/index.d.ts

@@ -7,6 +7,8 @@
  * @module @vercel/python-analysis
  */
 export { findAppOrHandler, containsTopLevelCallable, getStringConstant, } from './semantic/entrypoints';
+export { collectImportClosure, extractImports } from './semantic/import-graph';
+export type { ImportClosureOptions, ImportClosureResult, ImportStmt, } from './semantic/import-graph';
 export type { Distribution, DistributionIndex, PackagePath, DirectUrlInfo, } from './manifest/dist-metadata';
 export { extendDistRecord, scanDistributions } from './manifest/dist-metadata';
 export type { PythonConfig, PythonConfigs, PythonLockFile, PythonManifest, PythonManifestOrigin, PythonPackage, PythonVersionConfig, } from './manifest/package';
@@ -14,7 +16,7 @@ export { discoverPythonPackage, PythonConfigKind, PythonLockFileKind, PythonMani
 export { createMinimalManifest, stringifyManifest, type CreateMinimalManifestOptions, } from './manifest/serialize';
 export type { ClassifyPackagesOptions, PackageClassification, UvLockFile, UvLockPackage, UvLockPackageSource, UvLockWheel, } from './manifest/uv-lock-parser';
 export { classifyPackages, isPrivatePackageSource, normalizePackageName, parseUvLock, } from './manifest/uv-lock-parser';
-export { evaluateMarker, isWheelCompatible, } from './manifest/wheel-compat';
+export { evaluateMarker, isWheelCompatible } from './manifest/wheel-compat';
 export type { PythonSelectionResult, PythonVersionSelectionResult, } from './manifest/python-selector';
 export { selectPython, selectPythonVersion } from './manifest/python-selector';
 export { PythonAnalysisError } from './util/error';

package/dist/index.js

@@ -139,11 +139,229 @@ async function getStringConstant(source, name) {
   return mod.getStringConstant(source, name) ?? null;
 }
 
+// src/semantic/import-graph.ts
+import fs from "fs";
+import { isAbsolute, join as join2, dirname as dirname2, resolve, sep } from "path";
+async function extractImports(source) {
+  if (!source.includes("import")) {
+    return [];
+  }
+  const mod = await importWasmModule();
+  return mod.extractImports(source);
+}
+var DEFAULT_MAX_FILES = 3e4;
+async function readStatKind(path4) {
+  try {
+    const stats = await fs.promises.stat(path4);
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "dir";
+  } catch {
+  }
+  return null;
+}
+function statKind(path4, cache) {
+  const cached = cache.statKinds.get(path4);
+  if (cached)
+    return cached;
+  const pending = readStatKind(path4);
+  cache.statKinds.set(path4, pending);
+  return pending;
+}
+async function resolveNamePartsUncached(parts, searchDirs, cache) {
+  const rel = join2(...parts);
+  for (const root of searchDirs) {
+    let target = null;
+    let targetKind = null;
+    const candidateInit = join2(root, rel, "__init__.py");
+    if (await statKind(candidateInit, cache) === "file") {
+      target = candidateInit;
+      targetKind = "file";
+    } else {
+      const candidateModule = join2(root, `${rel}.py`);
+      if (await statKind(candidateModule, cache) === "file") {
+        target = candidateModule;
+        targetKind = "file";
+      } else if (await statKind(join2(root, rel), cache) === "dir") {
+        target = join2(root, rel);
+        targetKind = "dir";
+      }
+    }
+    if (target !== null) {
+      const parentChain = [];
+      let acc = root;
+      for (const part of parts.slice(0, -1)) {
+        acc = join2(acc, part);
+        const init = join2(acc, "__init__.py");
+        if (await statKind(init, cache) === "file") {
+          parentChain.push(init);
+        }
+      }
+      return { target, targetKind, parentChain };
+    }
+  }
+  return null;
+}
+function resolveNameParts(parts, searchDirs, searchKey, cache) {
+  if (parts.length === 0)
+    return Promise.resolve(null);
+  const key = `${searchKey}\0${parts.join(".")}`;
+  const cached = cache.names.get(key);
+  if (cached)
+    return cached;
+  const pending = resolveNamePartsUncached(parts, searchDirs, cache);
+  cache.names.set(key, pending);
+  return pending;
+}
+async function resolveSeedName(parts, searchDirs, searchKey, cache) {
+  for (let length = parts.length; length > 0; length--) {
+    const resolved = await resolveNameParts(
+      parts.slice(0, length),
+      searchDirs,
+      searchKey,
+      cache
+    );
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function submoduleDir(target, targetKind) {
+  if (targetKind === "dir")
+    return target;
+  if (targetKind === "file" && target.endsWith(`${sep}__init__.py`)) {
+    return dirname2(target);
+  }
+  return null;
+}
+async function resolveImport(stmt, importerPath, roots, rootsKey, cache) {
+  const resolved = /* @__PURE__ */ new Set();
+  let search = roots;
+  let searchKey = rootsKey;
+  if (stmt.level > 0) {
+    let base = dirname2(importerPath);
+    for (let i = 1; i < stmt.level; i++) {
+      base = dirname2(base);
+    }
+    search = [base];
+    searchKey = base;
+  }
+  const parts = stmt.module ? stmt.module.split(".") : [];
+  let target;
+  let targetKind;
+  if (parts.length > 0) {
+    const name = await resolveNameParts(parts, search, searchKey, cache);
+    if (!name)
+      return [];
+    target = name.target;
+    targetKind = name.targetKind;
+    if (targetKind === "file")
+      resolved.add(target);
+    for (const init of name.parentChain) {
+      resolved.add(init);
+    }
+  } else if (stmt.level > 0) {
+    target = search[0];
+    targetKind = "dir";
+  } else {
+    return [];
+  }
+  const subDir = submoduleDir(target, targetKind);
+  if (subDir) {
+    for (const name of stmt.names) {
+      if (name === "*")
+        continue;
+      const sub = await resolveNameParts([name], [subDir], subDir, cache);
+      if (sub) {
+        if (sub.targetKind === "file")
+          resolved.add(sub.target);
+        for (const init of sub.parentChain) {
+          resolved.add(init);
+        }
+      }
+    }
+  }
+  return [...resolved];
+}
+function isModuleNameSeed(seed) {
+  return !isAbsolute(seed) && /^[A-Za-z_][\w]*(\.[A-Za-z_][\w]*)*$/.test(seed);
+}
+async function collectImportClosure({
+  seeds,
+  searchRoots,
+  maxFiles = DEFAULT_MAX_FILES
+}) {
+  const roots = searchRoots.map((r) => resolve(r));
+  const rootsKey = roots.join("\0");
+  const cache = {
+    statKinds: /* @__PURE__ */ new Map(),
+    names: /* @__PURE__ */ new Map()
+  };
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = [];
+  let truncated = false;
+  for (const seed of seeds) {
+    if (isModuleNameSeed(seed)) {
+      const name = await resolveSeedName(
+        seed.split("."),
+        roots,
+        rootsKey,
+        cache
+      );
+      if (name) {
+        if (name.targetKind === "file")
+          frontier.push(name.target);
+        frontier.push(...name.parentChain);
+      }
+    } else {
+      const seedPath = resolve(seed);
+      if (await statKind(seedPath, cache) === "file") {
+        frontier.push(seedPath);
+      }
+    }
+  }
+  while (frontier.length > 0) {
+    const batch = [...new Set(frontier)].filter((p) => !visited.has(p));
+    frontier = [];
+    if (batch.length === 0)
+      continue;
+    for (const path4 of batch) {
+      visited.add(path4);
+    }
+    if (visited.size > maxFiles) {
+      truncated = true;
+      break;
+    }
+    const dependencies = await Promise.all(
+      batch.map(async (importerPath) => {
+        let source;
+        try {
+          source = await fs.promises.readFile(importerPath, "utf8");
+        } catch {
+          return [];
+        }
+        const stmts = await extractImports(source);
+        const files = await Promise.all(
+          stmts.filter((s) => s.isModuleLevel && !s.inTypeChecking).map((s) => resolveImport(s, importerPath, roots, rootsKey, cache))
+        );
+        return files.flat();
+      })
+    );
+    for (const dep of dependencies.flat()) {
+      if (!visited.has(dep)) {
+        frontier.push(dep);
+      }
+    }
+  }
+  return { files: visited, truncated };
+}
+
 // src/manifest/dist-metadata.ts
 import { createHash } from "crypto";
 import { createReadStream } from "fs";
 import { appendFile, readdir, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/manifest/pep508.ts
 var EXTRAS_REGEX = /^(.+)\[([^\]]+)\]$/;
@@ -222,7 +440,7 @@ async function parsePep508(depOrDeps) {
 // src/manifest/dist-metadata.ts
 async function readDistInfoFile(distInfoDir, filename) {
   try {
-    return await readFile2(join2(distInfoDir, filename), "utf-8");
+    return await readFile2(join3(distInfoDir, filename), "utf-8");
   } catch {
     return void 0;
   }
@@ -238,7 +456,7 @@ async function scanDistributions(sitePackagesDir) {
   }
   const distInfoDirs = entries.filter((e) => e.endsWith(".dist-info"));
   for (const dirName of distInfoDirs) {
-    const distInfoPath = join2(sitePackagesDir, dirName);
+    const distInfoPath = join3(sitePackagesDir, dirName);
     const metadataContent = await readDistInfoFile(distInfoPath, "METADATA");
     if (!metadataContent) {
       console.debug(`Missing METADATA in ${dirName}`);
@@ -307,7 +525,7 @@ async function scanDistributions(sitePackagesDir) {
   return index;
 }
 function hashFile(filePath) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const h = createHash("sha256");
     let size = 0;
     const stream = createReadStream(filePath);
@@ -317,7 +535,7 @@ function hashFile(filePath) {
     });
     stream.on("error", reject);
     stream.on("end", () => {
-      resolve({ hash: h.digest("base64url"), size });
+      resolve2({ hash: h.digest("base64url"), size });
     });
   });
 }
@@ -339,7 +557,7 @@ async function extendDistRecord(sitePackagesDir, packageName, paths) {
       `No .dist-info directory found for package "${packageName}" in ${sitePackagesDir}`
     );
   }
-  const recordPath = join2(sitePackagesDir, distInfoDirName, "RECORD");
+  const recordPath = join3(sitePackagesDir, distInfoDirName, "RECORD");
   let existingRecord;
   try {
     existingRecord = await readFile2(recordPath, "utf-8");
@@ -354,7 +572,7 @@ async function extendDistRecord(sitePackagesDir, packageName, paths) {
     const prefix = existingRecord.length > 0 && !existingRecord.endsWith("\n") ? "\n" : "";
     const lines = [];
     for (const p of newEntries) {
-      const fullPath = join2(sitePackagesDir, p);
+      const fullPath = join3(sitePackagesDir, p);
       const { hash, size } = await hashFile(fullPath);
       lines.push(`${p},sha256=${hash},${size}`);
     }
@@ -963,7 +1181,7 @@ var PyProjectToolSectionSchema = pyProjectToolSectionSchema.passthrough();
 var PyProjectTomlSchema = pyProjectTomlSchema.extend({ tool: PyProjectToolSectionSchema.optional() }).passthrough();
 
 // src/manifest/requirements-txt-parser.ts
-import { isAbsolute, join as join3, relative } from "path/posix";
+import { isAbsolute as isAbsolute2, join as join4, relative } from "path/posix";
 var PRIMARY_INDEX_NAME = "primary";
 var EXTRA_INDEX_PREFIX = "extra-";
 var FIND_LINKS_PREFIX = "find-links-";
@@ -1028,11 +1246,11 @@ function wasmEntryToNormalized(entry, editable) {
 function rebasePath(p, workingDir, packageRoot) {
   if (!workingDir || !packageRoot || workingDir === packageRoot)
     return p;
-  if (isAbsolute(p))
+  if (isAbsolute2(p))
     return p;
-  const abs = join3(workingDir, p);
+  const abs = join4(workingDir, p);
   const rel = relative(packageRoot, abs);
-  if (isAbsolute(rel))
+  if (isAbsolute2(rel))
     return rel;
   if (rel.startsWith(".."))
     return rel;
@@ -2350,11 +2568,13 @@ export {
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
+  collectImportClosure,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
   evaluateMarker,
   extendDistRecord,
+  extractImports,
   findAppOrHandler,
   getStringConstant,
   isPrivatePackageSource,

package/dist/semantic/import-graph.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Static import-graph analysis: compute the transitive closure of modules a
+ * Python application imports at startup, without executing any user code.
+ *
+ * The closure feeds bytecode packing. Both error directions are safe:
+ * over-included modules waste capacity, and missed modules (plugin loaders,
+ * imports made by compiled extensions) still ship from residual capacity.
+ *
+ * Resolution semantics mirror CPython:
+ * - dotted name -> `a/b/__init__.py` | `a/b.py` | PEP 420 namespace dir
+ * - importing `a.b.c` executes every parent `__init__.py` (emitted + recursed)
+ * - `from a import b` probes `b` as a submodule of `a`
+ * - relative imports resolve against the importer's package by dot level
+ * - first search root wins, so app modules shadow vendor (runtime sys.path)
+ *
+ * Startup heuristics (applied on top of the raw WASM extraction):
+ * - imports inside function bodies are lazy and excluded
+ * - `if TYPE_CHECKING:` blocks never run at runtime and are excluded
+ * - both branches of module-level `if` / `try` are included
+ */
+export interface ImportStmt {
+    /** Dotted module path for from-imports; undefined for `from . import x`. */
+    module?: string;
+    /** Relative-import level (number of leading dots). 0 = absolute. */
+    level: number;
+    /** Imported names for from-imports (each may be a submodule). */
+    names: string[];
+    /** False when nested in a function body (lazy import). */
+    isModuleLevel: boolean;
+    /** True when under `if TYPE_CHECKING:` (never runs at runtime). */
+    inTypeChecking: boolean;
+}
+/**
+ * Extract every import statement in Python source with its syntactic
+ * context. Returns an empty list for invalid syntax.
+ */
+export declare function extractImports(source: string): Promise<ImportStmt[]>;
+export interface ImportClosureOptions {
+    /**
+     * Entry points of the closure: absolute `.py` file paths and/or dotted
+     * module or object names (e.g. Django's ROOT_URLCONF / INSTALLED_APPS
+     * strings), resolved to their longest importable prefix against searchRoots.
+     */
+    seeds: string[];
+    /**
+     * Ordered module search roots (e.g. [workPath, ...sitePackageDirs]).
+     * First match wins, so earlier roots shadow later ones.
+     */
+    searchRoots: string[];
+    /**
+     * Approximate safety bound on parsed files, checked per frontier batch.
+     * On overflow the partial closure is returned with `truncated: true`
+     * (remaining modules fall to the residual bytecode tier).
+     */
+    maxFiles?: number;
+}
+export interface ImportClosureResult {
+    /** Absolute paths of every `.py` file imported at startup. */
+    files: Set<string>;
+    truncated: boolean;
+}
+/**
+ * Compute the transitive closure of modules imported at startup.
+ *
+ * Only module-level imports outside `if TYPE_CHECKING:` blocks are followed
+ * (see module docstring). Files are read and parsed frontier-by-frontier in
+ * parallel; cycles are cut by the visited set.
+ */
+export declare function collectImportClosure({ seeds, searchRoots, maxFiles, }: ImportClosureOptions): Promise<ImportClosureResult>;

package/dist/wasm/vercel_python_analysis.d.ts

@@ -1,4 +1,11 @@
 // world root:component/root
+export interface ImportStmt {
+  module?: string,
+  level: number,
+  names: Array<string>,
+  isModuleLevel: boolean,
+  inTypeChecking: boolean,
+}
 export interface RecordEntry {
   path: string,
   hash?: string,
@@ -121,6 +128,7 @@ export interface Root {
   findAppOrHandler(source: string): string | undefined,
   getStringConstant(source: string, name: string): string | undefined,
   containsTopLevelCallable(source: string, name: string): boolean,
+  extractImports(source: string): Array<ImportStmt>,
   parseDistMetadata(content: Uint8Array): DistMetadata,
   parseRecord(content: string): Array<RecordEntry>,
   parseDirectUrl(content: string): DirectUrlInfo,

package/dist/wasm/vercel_python_analysis.js

@@ -709,6 +709,11 @@ const I32_MAX = 2_147_483_647;
 const I32_MIN = -2_147_483_648;
 const _typeCheckValidI32 = (n) => typeof n === 'number' && n >= I32_MIN && n <= I32_MAX;
 
+function clampGuest(i, min, max) {
+  if (i < min || i > max) throw new TypeError(`must be between ${min} and ${max}`);
+  return i;
+}
+
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 let _fs;
 async function fetchCompile (url) {
@@ -3521,6 +3526,7 @@ let gen = (function* _initGenerator () {
   let postReturn4;
   let postReturn5;
   let postReturn6;
+  let postReturn7;
   function trampoline0(handle) {
     const handleEntry = rscTableRemove(handleTable1, handle);
     if (handleEntry.own) {
@@ -3716,12 +3722,13 @@ let gen = (function* _initGenerator () {
     },
   }));
   postReturn0 = exports1['cabi_post_evaluate-marker'];
-  postReturn1 = exports1['cabi_post_parse-dist-metadata'];
-  postReturn2 = exports1['cabi_post_parse-record'];
-  postReturn3 = exports1['cabi_post_parse-direct-url'];
-  postReturn4 = exports1['cabi_post_normalize-package-name'];
-  postReturn5 = exports1['cabi_post_parse-requirements-txt'];
-  postReturn6 = exports1['cabi_post_parse-pep508'];
+  postReturn1 = exports1['cabi_post_extract-imports'];
+  postReturn2 = exports1['cabi_post_parse-dist-metadata'];
+  postReturn3 = exports1['cabi_post_parse-record'];
+  postReturn4 = exports1['cabi_post_parse-direct-url'];
+  postReturn5 = exports1['cabi_post_normalize-package-name'];
+  postReturn6 = exports1['cabi_post_parse-requirements-txt'];
+  postReturn7 = exports1['cabi_post_parse-pep508'];
   let exports1FindAppOrHandler;
   
   function findAppOrHandler(arg0) {
@@ -3841,6 +3848,77 @@ let gen = (function* _initGenerator () {
     });
     return bool2 == 0 ? false : (bool2 == 1 ? true : throwInvalidBool());
   }
+  let exports1ExtractImports;
+  
+  function extractImports(arg0) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    _debugLog('[iface="extract-imports", function="extract-imports"][Instruction::CallWasm] enter', {
+      funcName: 'extract-imports',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ExtractImports');
+    const ret = exports1ExtractImports(ptr0, len0);
+    endCurrentTask(0);
+    var len7 = dataView(memory0).getUint32(ret + 4, true);
+    var base7 = dataView(memory0).getUint32(ret + 0, true);
+    var result7 = [];
+    for (let i = 0; i < len7; i++) {
+      const base = base7 + i * 28;
+      let variant2;
+      switch (dataView(memory0).getUint8(base + 0, true)) {
+        case 0: {
+          variant2 = undefined;
+          break;
+        }
+        case 1: {
+          var ptr1 = dataView(memory0).getUint32(base + 4, true);
+          var len1 = dataView(memory0).getUint32(base + 8, true);
+          var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+          variant2 = result1;
+          break;
+        }
+        default: {
+          throw new TypeError('invalid variant discriminant for option');
+        }
+      }
+      var len4 = dataView(memory0).getUint32(base + 20, true);
+      var base4 = dataView(memory0).getUint32(base + 16, true);
+      var result4 = [];
+      for (let i = 0; i < len4; i++) {
+        const base = base4 + i * 8;
+        var ptr3 = dataView(memory0).getUint32(base + 0, true);
+        var len3 = dataView(memory0).getUint32(base + 4, true);
+        var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+        result4.push(result3);
+      }
+      var bool5 = dataView(memory0).getUint8(base + 24, true);
+      var bool6 = dataView(memory0).getUint8(base + 25, true);
+      result7.push({
+        module: variant2,
+        level: clampGuest(dataView(memory0).getUint8(base + 12, true), 0, 255),
+        names: result4,
+        isModuleLevel: bool5 == 0 ? false : (bool5 == 1 ? true : throwInvalidBool()),
+        inTypeChecking: bool6 == 0 ? false : (bool6 == 1 ? true : throwInvalidBool()),
+      });
+    }
+    _debugLog('[iface="extract-imports", function="extract-imports"][Instruction::Return]', {
+      funcName: 'extract-imports',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = result7;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn1(ret);
+    cstate.mayLeave = true;
+    return retCopy;
+    
+  }
   let exports1ParseDistMetadata;
   
   function parseDistMetadata(arg0) {
@@ -4171,7 +4249,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn1(ret);
+    postReturn2(ret);
     cstate.mayLeave = true;
     
     
@@ -4274,7 +4352,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn2(ret);
+    postReturn3(ret);
     cstate.mayLeave = true;
     
     
@@ -4434,7 +4512,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn3(ret);
+    postReturn4(ret);
     cstate.mayLeave = true;
     
     
@@ -4472,7 +4550,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn4(ret);
+    postReturn5(ret);
     cstate.mayLeave = true;
     return retCopy;
     
@@ -4929,7 +5007,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn5(ret);
+    postReturn6(ret);
     cstate.mayLeave = true;
     
     
@@ -5144,7 +5222,7 @@ let gen = (function* _initGenerator () {
     
     let cstate = getOrCreateAsyncState(0);
     cstate.mayLeave = false;
-    postReturn6(ret);
+    postReturn7(ret);
     cstate.mayLeave = true;
     
     
@@ -5284,6 +5362,7 @@ let gen = (function* _initGenerator () {
   exports1FindAppOrHandler = exports1['find-app-or-handler'];
   exports1GetStringConstant = exports1['get-string-constant'];
   exports1ContainsTopLevelCallable = exports1['contains-top-level-callable'];
+  exports1ExtractImports = exports1['extract-imports'];
   exports1ParseDistMetadata = exports1['parse-dist-metadata'];
   exports1ParseRecord = exports1['parse-record'];
   exports1ParseDirectUrl = exports1['parse-direct-url'];
@@ -5293,7 +5372,7 @@ let gen = (function* _initGenerator () {
   exports1IsWheelCompatible = exports1['is-wheel-compatible'];
   exports1EvaluateMarker = exports1['evaluate-marker'];
   
-  return { containsTopLevelCallable, evaluateMarker, findAppOrHandler, getStringConstant, isWheelCompatible, normalizePackageName, parseDirectUrl, parseDistMetadata, parsePep508, parseRecord, parseRequirementsTxt,  };
+  return { containsTopLevelCallable, evaluateMarker, extractImports, findAppOrHandler, getStringConstant, isWheelCompatible, normalizePackageName, parseDirectUrl, parseDistMetadata, parsePep508, parseRecord, parseRequirementsTxt,  };
 })();
 let promise, resolve, reject;
 function runNext (value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python-analysis",
-  "version": "0.12.0",
+  "version": "0.13.2",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -43,15 +43,14 @@
     "@types/js-yaml": "4.0.9",
     "@types/node": "20.11.0",
     "ts-to-zod": "^3",
-    "vitest": "2.1.4"
+    "vitest": "4.1.10"
   },
   "scripts": {
-    "build": "pnpm generate:schemas && pnpm build:wasm && node scripts/build.mjs",
+    "build": "node scripts/build.mjs",
     "build:wasm": "node scripts/build-wasm.mjs",
     "generate:schemas": "ts-to-zod --all",
     "test": "vitest run --config ../../vitest.config.mts",
-    "vitest-run": "vitest -c ../../vitest.config.mts",
-    "vitest-unit": "glob --absolute 'test/*.test.ts'",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "test-unit": "vitest run --config ../../vitest.config.mts"
   }
 }

package/dist/wasm/host-utils.d.ts

@@ -1,22 +0,0 @@
-/**
- * Host-side implementation of the `vercel:python-analysis/host-utils` WIT interface.
- */
-import { AsyncLocalStorage } from 'node:async_hooks';
-/**
- * Function type for reading referenced requirement files.
- */
-export type ReadFileFn = (path: string) => string | null;
-export interface ReadFileContext {
-    readFile: ReadFileFn;
-    workingDir?: string;
-}
-export declare const readFileStorage: AsyncLocalStorage<ReadFileContext>;
-export declare function createHostUtils(): {
-    readFile(path: string): string;
-    domainToAscii(domain: string): string;
-    domainToUnicode(domain: string): [string, boolean];
-    nfcNormalize(s: string): string;
-    nfdNormalize(s: string): string;
-    nfkcNormalize(s: string): string;
-    nfkdNormalize(s: string): string;
-};

package/dist/wasm/load.d.ts

@@ -1,4 +0,0 @@
-type ModuleType = typeof import('#wasm/vercel_python_analysis.js');
-type RootType = Awaited<ReturnType<ModuleType['instantiate']>>;
-export declare function importWasmModule(): Promise<RootType>;
-export {};