@vercel/python-analysis 0.10.0 → 0.10.1

package/dist/index.cjs

@@ -72,6 +72,7 @@ __export(src_exports, {
   isPrivatePackageSource: () => isPrivatePackageSource,
   isWheelCompatible: () => isWheelCompatible,
   normalizePackageName: () => normalizePackageName2,
+  parsePep508: () => parsePep508,
   parseUvLock: () => parseUvLock,
   scanDistributions: () => scanDistributions,
   selectPython: () => selectPython,
@@ -265,6 +266,41 @@ function mergeExtras(existing, additional) {
   }
   return result.size > 0 ? Array.from(result) : void 0;
 }
+function wasmEntryToRequirement(entry) {
+  const req = {
+    name: entry.name || ""
+  };
+  if (entry.versionSpec) {
+    req.version = entry.versionSpec;
+  }
+  if (entry.extras.length > 0) {
+    req.extras = entry.extras;
+  }
+  if (entry.markers) {
+    req.markers = entry.markers;
+  }
+  if (entry.url) {
+    req.url = entry.url;
+  }
+  return req;
+}
+async function parsePep508(depOrDeps) {
+  const wasm = await importWasmModule();
+  if (Array.isArray(depOrDeps)) {
+    return depOrDeps.map((dep) => {
+      try {
+        return wasmEntryToRequirement(wasm.parsePep508(dep));
+      } catch {
+        return null;
+      }
+    });
+  }
+  try {
+    return wasmEntryToRequirement(wasm.parsePep508(depOrDeps));
+  } catch {
+    return null;
+  }
+}
 
 // src/manifest/dist-metadata.ts
 async function readDistInfoFile(distInfoDir, filename) {
@@ -919,7 +955,8 @@ var uvIndexEntrySchema = import_zod3.z.object({
 var uvConfigSchema = import_zod3.z.object({
   sources: import_zod3.z.record(import_zod3.z.union([dependencySourceSchema, import_zod3.z.array(dependencySourceSchema)])).optional(),
   index: import_zod3.z.array(uvIndexEntrySchema).optional(),
-  workspace: uvConfigWorkspaceSchema.optional()
+  workspace: uvConfigWorkspaceSchema.optional(),
+  "dev-dependencies": import_zod3.z.array(import_zod3.z.string()).optional()
 });
 
 // src/manifest/pyproject/schema.zod.ts
@@ -960,7 +997,16 @@ var pyProjectProjectSchema = import_zod4.z.object({
   scripts: import_zod4.z.record(import_zod4.z.string()).optional(),
   entry_points: import_zod4.z.record(import_zod4.z.record(import_zod4.z.string())).optional()
 });
-var pyProjectDependencyGroupsSchema = import_zod4.z.record(import_zod4.z.array(import_zod4.z.string()));
+var dependencyGroupIncludeSchema = import_zod4.z.object({
+  "include-group": import_zod4.z.string()
+});
+var dependencyGroupEntrySchema = import_zod4.z.union([
+  import_zod4.z.string(),
+  dependencyGroupIncludeSchema
+]);
+var pyProjectDependencyGroupsSchema = import_zod4.z.record(
+  import_zod4.z.array(dependencyGroupEntrySchema)
+);
 var pyProjectToolSectionSchema = import_zod4.z.object({
   uv: uvConfigSchema.optional()
 });
@@ -1627,7 +1673,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
       constraints.push({
         request: pythonVersionConfig.data,
         source: pythonVersionConfig.path,
-        prettySource: pythonVersionConfig.path
+        prettySource: pythonVersionConfig.path,
+        specifier: pythonVersionConfig.specifier
       });
       hasPythonVersionFile = true;
       break;
@@ -1642,7 +1689,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
         constraints.push({
           request: [request],
           source: manifest.path,
-          prettySource: `"requires-python" key in ${manifest.path}`
+          prettySource: `"requires-python" key in ${manifest.path}`,
+          specifier: manifestRequiresPython
         });
       }
     } else {
@@ -1654,7 +1702,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
           constraints.push({
             request: [request],
             source: workspaceManifest.path,
-            prettySource: `"requires-python" key in ${workspaceManifest.path}`
+            prettySource: `"requires-python" key in ${workspaceManifest.path}`,
+            specifier: workspaceRequiresPython
           });
         }
       }
@@ -1935,7 +1984,8 @@ async function maybeLoadPythonRequest(root, subdir) {
   return {
     kind: ".python-version" /* PythonVersion */,
     path: dotPythonVersionRelPath,
-    data: pyreq
+    data: pyreq,
+    specifier: data.trim()
   };
 }
 
@@ -1980,7 +2030,8 @@ function parseUvLock(content, path4) {
     name: pkg.name,
     version: pkg.version,
     source: pkg.source,
-    wheels: (pkg.wheels ?? []).map((w) => ({ url: w.url }))
+    wheels: (pkg.wheels ?? []).map((w) => ({ url: w.url })),
+    ...pkg.dependencies ? { dependencies: pkg.dependencies } : {}
   }));
   return { version: parsed.version, packages };
 }
@@ -2365,6 +2416,7 @@ var HashDigestSchema = hashDigestSchema;
   isPrivatePackageSource,
   isWheelCompatible,
   normalizePackageName,
+  parsePep508,
   parseUvLock,
   scanDistributions,
   selectPython,

package/dist/index.d.ts

@@ -19,11 +19,12 @@ export type { PythonSelectionResult, PythonVersionSelectionResult, } from './man
 export { selectPython, selectPythonVersion } from './manifest/python-selector';
 export { PythonAnalysisError } from './util/error';
 export { LicenseObjectSchema, LicenseSchema, PersonSchema, PyProjectBuildSystemSchema, PyProjectDependencyGroupsSchema, PyProjectProjectSchema, PyProjectToolSectionSchema, PyProjectTomlSchema, ReadmeObjectSchema, ReadmeSchema, } from './manifest/pyproject/schema';
-export type { License, LicenseObject, Person, PyProjectBuildSystem, PyProjectDependencyGroups, PyProjectProject, PyProjectToml, PyProjectToolSection, Readme, ReadmeObject, } from './manifest/pyproject/types';
+export type { DependencyGroupEntry, DependencyGroupInclude, License, LicenseObject, Person, PyProjectBuildSystem, PyProjectDependencyGroups, PyProjectProject, PyProjectToml, PyProjectToolSection, Readme, ReadmeObject, } from './manifest/pyproject/types';
 export { UvConfigSchema, UvConfigWorkspaceSchema, UvIndexEntrySchema, } from './manifest/uv-config/schema';
 export type { UvConfig, UvConfigWorkspace, UvIndexEntry, } from './manifest/uv-config/types';
 export { PipfileDependencyDetailSchema, PipfileDependencySchema, PipfileLikeSchema, PipfileLockLikeSchema, PipfileLockMetaSchema, PipfileSourceSchema, } from './manifest/pipfile/schema';
 export type { PipfileDependency, PipfileDependencyDetail, PipfileLike, PipfileLockLike, PipfileLockMeta, PipfileSource, } from './manifest/pipfile/types';
 export { DependencySourceSchema, HashDigestSchema, NormalizedRequirementSchema, } from './manifest/requirement/schema';
 export type { DependencySource, HashDigest, NormalizedRequirement, } from './manifest/requirement/types';
+export { parsePep508 } from './manifest/pep508';
 export { PythonBuild, PythonConstraint, PythonImplementation, PythonPlatformRequest, PythonRequest, PythonVariant, PythonVersion, PythonVersionRequest, UnknownPythonImplementation, } from './manifest/python-specifiers';

package/dist/index.js

@@ -183,6 +183,41 @@ function mergeExtras(existing, additional) {
   }
   return result.size > 0 ? Array.from(result) : void 0;
 }
+function wasmEntryToRequirement(entry) {
+  const req = {
+    name: entry.name || ""
+  };
+  if (entry.versionSpec) {
+    req.version = entry.versionSpec;
+  }
+  if (entry.extras.length > 0) {
+    req.extras = entry.extras;
+  }
+  if (entry.markers) {
+    req.markers = entry.markers;
+  }
+  if (entry.url) {
+    req.url = entry.url;
+  }
+  return req;
+}
+async function parsePep508(depOrDeps) {
+  const wasm = await importWasmModule();
+  if (Array.isArray(depOrDeps)) {
+    return depOrDeps.map((dep) => {
+      try {
+        return wasmEntryToRequirement(wasm.parsePep508(dep));
+      } catch {
+        return null;
+      }
+    });
+  }
+  try {
+    return wasmEntryToRequirement(wasm.parsePep508(depOrDeps));
+  } catch {
+    return null;
+  }
+}
 
 // src/manifest/dist-metadata.ts
 async function readDistInfoFile(distInfoDir, filename) {
@@ -840,7 +875,8 @@ var uvIndexEntrySchema = z3.object({
 var uvConfigSchema = z3.object({
   sources: z3.record(z3.union([dependencySourceSchema, z3.array(dependencySourceSchema)])).optional(),
   index: z3.array(uvIndexEntrySchema).optional(),
-  workspace: uvConfigWorkspaceSchema.optional()
+  workspace: uvConfigWorkspaceSchema.optional(),
+  "dev-dependencies": z3.array(z3.string()).optional()
 });
 
 // src/manifest/pyproject/schema.zod.ts
@@ -881,7 +917,16 @@ var pyProjectProjectSchema = z4.object({
   scripts: z4.record(z4.string()).optional(),
   entry_points: z4.record(z4.record(z4.string())).optional()
 });
-var pyProjectDependencyGroupsSchema = z4.record(z4.array(z4.string()));
+var dependencyGroupIncludeSchema = z4.object({
+  "include-group": z4.string()
+});
+var dependencyGroupEntrySchema = z4.union([
+  z4.string(),
+  dependencyGroupIncludeSchema
+]);
+var pyProjectDependencyGroupsSchema = z4.record(
+  z4.array(dependencyGroupEntrySchema)
+);
 var pyProjectToolSectionSchema = z4.object({
   uv: uvConfigSchema.optional()
 });
@@ -1548,7 +1593,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
       constraints.push({
         request: pythonVersionConfig.data,
         source: pythonVersionConfig.path,
-        prettySource: pythonVersionConfig.path
+        prettySource: pythonVersionConfig.path,
+        specifier: pythonVersionConfig.specifier
       });
       hasPythonVersionFile = true;
       break;
@@ -1563,7 +1609,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
         constraints.push({
           request: [request],
           source: manifest.path,
-          prettySource: `"requires-python" key in ${manifest.path}`
+          prettySource: `"requires-python" key in ${manifest.path}`,
+          specifier: manifestRequiresPython
         });
       }
     } else {
@@ -1575,7 +1622,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
           constraints.push({
             request: [request],
             source: workspaceManifest.path,
-            prettySource: `"requires-python" key in ${workspaceManifest.path}`
+            prettySource: `"requires-python" key in ${workspaceManifest.path}`,
+            specifier: workspaceRequiresPython
           });
         }
       }
@@ -1856,7 +1904,8 @@ async function maybeLoadPythonRequest(root, subdir) {
   return {
     kind: ".python-version" /* PythonVersion */,
     path: dotPythonVersionRelPath,
-    data: pyreq
+    data: pyreq,
+    specifier: data.trim()
   };
 }
 
@@ -1901,7 +1950,8 @@ function parseUvLock(content, path4) {
     name: pkg.name,
     version: pkg.version,
     source: pkg.source,
-    wheels: (pkg.wheels ?? []).map((w) => ({ url: w.url }))
+    wheels: (pkg.wheels ?? []).map((w) => ({ url: w.url })),
+    ...pkg.dependencies ? { dependencies: pkg.dependencies } : {}
   }));
   return { version: parsed.version, packages };
 }
@@ -2285,6 +2335,7 @@ export {
   isPrivatePackageSource,
   isWheelCompatible,
   normalizePackageName2 as normalizePackageName,
+  parsePep508,
   parseUvLock,
   scanDistributions,
   selectPython,

package/dist/manifest/package.d.ts

@@ -98,6 +98,8 @@ export interface PythonVersionConfig {
     path: RelPath;
     /** Parsed Python version requests from the file. */
     data: PythonRequest[];
+    /** Raw version string from the file (e.g. "3.12", ">=3.12,<3.13"). */
+    specifier: string;
 }
 /**
  * Union type for all Python configuration file types.

package/dist/manifest/pep508.d.ts

@@ -62,3 +62,22 @@ export declare function formatPep508(req: NormalizedRequirement): string;
  * @returns Merged extras array, or undefined if both inputs are empty/undefined
  */
 export declare function mergeExtras(existing: string[] | undefined, additional: string[] | string | undefined): string[] | undefined;
+/**
+ * Parse a single PEP 508 dependency string into a NormalizedRequirement.
+ *
+ * Uses the uv-pep508 Rust crate via WASM for spec-compliant parsing.
+ *
+ * @param dep - A PEP 508 dependency string (e.g., "flask[async]>=2.0 ; python_version >= '3.8'")
+ * @returns The parsed requirement, or null if parsing fails
+ */
+export declare function parsePep508(dep: string): Promise<NormalizedRequirement | null>;
+/**
+ * Parse multiple PEP 508 dependency strings in a single batch.
+ *
+ * Loads the WASM module once and parses all strings synchronously,
+ * avoiding per-item async overhead.
+ *
+ * @param deps - Array of PEP 508 dependency strings
+ * @returns Array of parsed requirements (null for entries that fail to parse)
+ */
+export declare function parsePep508(deps: string[]): Promise<(NormalizedRequirement | null)[]>;

package/dist/manifest/pyproject/schema.zod.d.ts

@@ -174,7 +174,27 @@ export declare const pyProjectProjectSchema: z.ZodObject<{
     scripts?: Record<string, string> | undefined;
     entry_points?: Record<string, Record<string, string>> | undefined;
 }>;
-export declare const pyProjectDependencyGroupsSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+export declare const dependencyGroupIncludeSchema: z.ZodObject<{
+    'include-group': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'include-group': string;
+}, {
+    'include-group': string;
+}>;
+export declare const dependencyGroupEntrySchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    'include-group': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'include-group': string;
+}, {
+    'include-group': string;
+}>]>;
+export declare const pyProjectDependencyGroupsSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    'include-group': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'include-group': string;
+}, {
+    'include-group': string;
+}>]>, "many">>;
 export declare const pyProjectToolSectionSchema: z.ZodObject<{
     uv: z.ZodOptional<z.ZodObject<{
         sources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -243,6 +263,7 @@ export declare const pyProjectToolSectionSchema: z.ZodObject<{
             members?: string[] | undefined;
             exclude?: string[] | undefined;
         }>>;
+        'dev-dependencies': z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         sources?: Record<string, {
             index?: string | undefined;
@@ -268,6 +289,7 @@ export declare const pyProjectToolSectionSchema: z.ZodObject<{
             members?: string[] | undefined;
             exclude?: string[] | undefined;
         } | undefined;
+        'dev-dependencies'?: string[] | undefined;
     }, {
         sources?: Record<string, {
             index?: string | undefined;
@@ -293,6 +315,7 @@ export declare const pyProjectToolSectionSchema: z.ZodObject<{
             members?: string[] | undefined;
             exclude?: string[] | undefined;
         } | undefined;
+        'dev-dependencies'?: string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     uv?: {
@@ -320,6 +343,7 @@ export declare const pyProjectToolSectionSchema: z.ZodObject<{
             members?: string[] | undefined;
             exclude?: string[] | undefined;
         } | undefined;
+        'dev-dependencies'?: string[] | undefined;
     } | undefined;
 }, {
     uv?: {
@@ -347,6 +371,7 @@ export declare const pyProjectToolSectionSchema: z.ZodObject<{
             members?: string[] | undefined;
             exclude?: string[] | undefined;
         } | undefined;
+        'dev-dependencies'?: string[] | undefined;
     } | undefined;
 }>;
 export declare const pyProjectTomlSchema: z.ZodObject<{
@@ -475,7 +500,13 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
         'build-backend'?: string | undefined;
         'backend-path'?: string[] | undefined;
     }>>;
-    'dependency-groups': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    'dependency-groups': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        'include-group': z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        'include-group': string;
+    }, {
+        'include-group': string;
+    }>]>, "many">>>;
     tool: z.ZodOptional<z.ZodObject<{
         uv: z.ZodOptional<z.ZodObject<{
             sources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -544,6 +575,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             }>>;
+            'dev-dependencies': z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             sources?: Record<string, {
                 index?: string | undefined;
@@ -569,6 +601,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         }, {
             sources?: Record<string, {
                 index?: string | undefined;
@@ -594,6 +627,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         uv?: {
@@ -621,6 +655,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         } | undefined;
     }, {
         uv?: {
@@ -648,6 +683,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -686,7 +722,9 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
         'build-backend'?: string | undefined;
         'backend-path'?: string[] | undefined;
     } | undefined;
-    'dependency-groups'?: Record<string, string[]> | undefined;
+    'dependency-groups'?: Record<string, (string | {
+        'include-group': string;
+    })[]> | undefined;
     tool?: {
         uv?: {
             sources?: Record<string, {
@@ -713,6 +751,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -751,7 +790,9 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
         'build-backend'?: string | undefined;
         'backend-path'?: string[] | undefined;
     } | undefined;
-    'dependency-groups'?: Record<string, string[]> | undefined;
+    'dependency-groups'?: Record<string, (string | {
+        'include-group': string;
+    })[]> | undefined;
     tool?: {
         uv?: {
             sources?: Record<string, {
@@ -778,6 +819,7 @@ export declare const pyProjectTomlSchema: z.ZodObject<{
                 members?: string[] | undefined;
                 exclude?: string[] | undefined;
             } | undefined;
+            'dev-dependencies'?: string[] | undefined;
         } | undefined;
     } | undefined;
 }>;

package/dist/manifest/pyproject/types.d.ts

@@ -71,9 +71,19 @@ export interface PyProjectProject {
     entry_points?: Record<string, Record<string, string>>;
 }
 /**
- * [dependency-groups].
+ * PEP 735 include-group directive: `{include-group: "other-group"}`.
  */
-export type PyProjectDependencyGroups = Record<string, string[]>;
+export interface DependencyGroupInclude {
+    'include-group': string;
+}
+/**
+ * A single entry in a dependency group: either a PEP 508 string or an include directive.
+ */
+export type DependencyGroupEntry = string | DependencyGroupInclude;
+/**
+ * [dependency-groups] per PEP 735.
+ */
+export type PyProjectDependencyGroups = Record<string, DependencyGroupEntry[]>;
 /**
  * [tool.FOO] section.
  * @passthrough

package/dist/manifest/python-specifiers.d.ts

@@ -55,6 +55,8 @@ export interface PythonConstraint {
     source: string;
     /** Human-readable description of where this constraint came from. */
     prettySource: string;
+    /** Raw version specifier string from the source file (e.g. ">=3.12", "3.12"). */
+    specifier?: string;
 }
 export type PythonVersion = {
     major: number;

package/dist/manifest/uv-config/schema.zod.d.ts

@@ -95,6 +95,7 @@ export declare const uvConfigSchema: z.ZodObject<{
         members?: string[] | undefined;
         exclude?: string[] | undefined;
     }>>;
+    'dev-dependencies': z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     sources?: Record<string, {
         index?: string | undefined;
@@ -120,6 +121,7 @@ export declare const uvConfigSchema: z.ZodObject<{
         members?: string[] | undefined;
         exclude?: string[] | undefined;
     } | undefined;
+    'dev-dependencies'?: string[] | undefined;
 }, {
     sources?: Record<string, {
         index?: string | undefined;
@@ -145,4 +147,5 @@ export declare const uvConfigSchema: z.ZodObject<{
         members?: string[] | undefined;
         exclude?: string[] | undefined;
     } | undefined;
+    'dev-dependencies'?: string[] | undefined;
 }>;

package/dist/manifest/uv-config/types.d.ts

@@ -47,4 +47,9 @@ export interface UvConfig {
      * Workspace configuration.
      */
     workspace?: UvConfigWorkspace;
+    /**
+     * Legacy dev dependencies (pre-PEP 735).
+     * Equivalent to `[dependency-groups].dev`.
+     */
+    'dev-dependencies'?: string[];
 }

package/dist/manifest/uv-lock-parser.d.ts

@@ -23,6 +23,9 @@ export interface UvLockPackage {
     version: string;
     source?: UvLockPackageSource;
     wheels: UvLockWheel[];
+    dependencies?: Array<{
+        name: string;
+    }>;
 }
 /**
  * Parsed uv.lock file structure.

package/dist/wasm/vercel_python_analysis.d.ts

@@ -124,6 +124,7 @@ export interface Root {
   parseDirectUrl(content: string): DirectUrlInfo,
   normalizePackageName(name: string): string,
   parseRequirementsTxt(content: string, workingDir: string | undefined, filename: string | undefined): ParsedRequirementsTxt,
+  parsePep508(dep: string): ParsedReqEntry,
   isWheelCompatible(wheelFilename: string, pythonMajor: number, pythonMinor: number, osName: string, archName: string, osMajor: number, osMinor: number): boolean,
 }
 

package/dist/wasm/vercel_python_analysis.js

@@ -3452,6 +3452,7 @@ let gen = (function* _initGenerator () {
   let postReturn3;
   let postReturn4;
   let postReturn5;
+  let postReturn6;
   function trampoline0(handle) {
     const handleEntry = rscTableRemove(handleTable1, handle);
     if (handleEntry.own) {
@@ -3647,6 +3648,7 @@ let gen = (function* _initGenerator () {
   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'];
   let exports1ContainsAppOrHandler;
   
   function containsAppOrHandler(arg0) {
@@ -4836,6 +4838,221 @@ let gen = (function* _initGenerator () {
     
     
     
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  let exports1ParsePep508;
+  
+  function parsePep508(arg0) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    _debugLog('[iface="parse-pep508", function="parse-pep508"][Instruction::CallWasm] enter', {
+      funcName: 'parse-pep508',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ParsePep508');
+    const ret = exports1ParsePep508(ptr0, len0);
+    endCurrentTask(0);
+    let variant22;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        let variant2;
+        switch (dataView(memory0).getUint8(ret + 4, true)) {
+          case 0: {
+            variant2 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr1 = dataView(memory0).getUint32(ret + 8, true);
+            var len1 = dataView(memory0).getUint32(ret + 12, true);
+            var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+            variant2 = result1;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var ptr3 = dataView(memory0).getUint32(ret + 16, true);
+        var len3 = dataView(memory0).getUint32(ret + 20, true);
+        var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+        var len5 = dataView(memory0).getUint32(ret + 28, true);
+        var base5 = dataView(memory0).getUint32(ret + 24, true);
+        var result5 = [];
+        for (let i = 0; i < len5; i++) {
+          const base = base5 + i * 8;
+          var ptr4 = dataView(memory0).getUint32(base + 0, true);
+          var len4 = dataView(memory0).getUint32(base + 4, true);
+          var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+          result5.push(result4);
+        }
+        let variant7;
+        switch (dataView(memory0).getUint8(ret + 32, true)) {
+          case 0: {
+            variant7 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr6 = dataView(memory0).getUint32(ret + 36, true);
+            var len6 = dataView(memory0).getUint32(ret + 40, true);
+            var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+            variant7 = result6;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant9;
+        switch (dataView(memory0).getUint8(ret + 44, true)) {
+          case 0: {
+            variant9 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr8 = dataView(memory0).getUint32(ret + 48, true);
+            var len8 = dataView(memory0).getUint32(ret + 52, true);
+            var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+            variant9 = result8;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant11;
+        switch (dataView(memory0).getUint8(ret + 56, true)) {
+          case 0: {
+            variant11 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr10 = dataView(memory0).getUint32(ret + 60, true);
+            var len10 = dataView(memory0).getUint32(ret + 64, true);
+            var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+            variant11 = result10;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len13 = dataView(memory0).getUint32(ret + 72, true);
+        var base13 = dataView(memory0).getUint32(ret + 68, true);
+        var result13 = [];
+        for (let i = 0; i < len13; i++) {
+          const base = base13 + i * 8;
+          var ptr12 = dataView(memory0).getUint32(base + 0, true);
+          var len12 = dataView(memory0).getUint32(base + 4, true);
+          var result12 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr12, len12));
+          result13.push(result12);
+        }
+        var bool14 = dataView(memory0).getUint8(ret + 76, true);
+        let variant18;
+        switch (dataView(memory0).getUint8(ret + 80, true)) {
+          case 0: {
+            variant18 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr15 = dataView(memory0).getUint32(ret + 84, true);
+            var len15 = dataView(memory0).getUint32(ret + 88, true);
+            var result15 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr15, len15));
+            let variant17;
+            switch (dataView(memory0).getUint8(ret + 92, true)) {
+              case 0: {
+                variant17 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr16 = dataView(memory0).getUint32(ret + 96, true);
+                var len16 = dataView(memory0).getUint32(ret + 100, true);
+                var result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
+                variant17 = result16;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            variant18 = {
+              url: result15,
+              rev: variant17,
+            };
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant20;
+        switch (dataView(memory0).getUint8(ret + 104, true)) {
+          case 0: {
+            variant20 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr19 = dataView(memory0).getUint32(ret + 108, true);
+            var len19 = dataView(memory0).getUint32(ret + 112, true);
+            var result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
+            variant20 = result19;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        variant22= {
+          tag: 'ok',
+          val: {
+            name: variant2,
+            pep508: result3,
+            extras: result5,
+            markers: variant7,
+            versionSpec: variant9,
+            url: variant11,
+            hashes: result13,
+            editable: bool14 == 0 ? false : (bool14 == 1 ? true : throwInvalidBool()),
+            vcs: variant18,
+            givenUrl: variant20,
+          }
+        };
+        break;
+      }
+      case 1: {
+        var ptr21 = dataView(memory0).getUint32(ret + 4, true);
+        var len21 = dataView(memory0).getUint32(ret + 8, true);
+        var result21 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr21, len21));
+        variant22= {
+          tag: 'err',
+          val: result21
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="parse-pep508", function="parse-pep508"][Instruction::Return]', {
+      funcName: 'parse-pep508',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant22;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn6(ret);
+    cstate.mayLeave = true;
+    
+    
+    
     if (typeof retCopy === 'object' && retCopy.tag === 'err') {
       throw new ComponentError(retCopy.val);
     }
@@ -4913,9 +5130,10 @@ let gen = (function* _initGenerator () {
   exports1ParseDirectUrl = exports1['parse-direct-url'];
   exports1NormalizePackageName = exports1['normalize-package-name'];
   exports1ParseRequirementsTxt = exports1['parse-requirements-txt'];
+  exports1ParsePep508 = exports1['parse-pep508'];
   exports1IsWheelCompatible = exports1['is-wheel-compatible'];
   
-  return { containsAppOrHandler, containsTopLevelCallable, getStringConstant, isWheelCompatible, normalizePackageName, parseDirectUrl, parseDistMetadata, parseRecord, parseRequirementsTxt,  };
+  return { containsAppOrHandler, containsTopLevelCallable, 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.10.0",
+  "version": "0.10.1",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",