@vercel/python-analysis 0.10.0 → 0.11.0

package/dist/index.cjs

@@ -63,15 +63,17 @@ __export(src_exports, {
   UvConfigWorkspaceSchema: () => UvConfigWorkspaceSchema,
   UvIndexEntrySchema: () => UvIndexEntrySchema,
   classifyPackages: () => classifyPackages,
-  containsAppOrHandler: () => containsAppOrHandler,
   containsTopLevelCallable: () => containsTopLevelCallable,
   createMinimalManifest: () => createMinimalManifest,
   discoverPythonPackage: () => discoverPythonPackage,
+  evaluateMarker: () => evaluateMarker,
   extendDistRecord: () => extendDistRecord,
+  findAppOrHandler: () => findAppOrHandler,
   getStringConstant: () => getStringConstant,
   isPrivatePackageSource: () => isPrivatePackageSource,
   isWheelCompatible: () => isWheelCompatible,
   normalizePackageName: () => normalizePackageName2,
+  parsePep508: () => parsePep508,
   parseUvLock: () => parseUvLock,
   scanDistributions: () => scanDistributions,
   selectPython: () => selectPython,
@@ -202,12 +204,12 @@ async function importWasmModule() {
 }
 
 // src/semantic/entrypoints.ts
-async function containsAppOrHandler(source) {
+async function findAppOrHandler(source) {
   if (!source.includes("app") && !source.includes("application") && !source.includes("handler") && !source.includes("Handler")) {
-    return false;
+    return null;
   }
   const mod = await importWasmModule();
-  return mod.containsAppOrHandler(source);
+  return mod.findAppOrHandler(source) ?? null;
 }
 async function containsTopLevelCallable(source, name) {
   if (!source.includes(name)) {
@@ -265,6 +267,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 +956,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 +998,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 +1674,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 +1690,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 +1703,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 +1985,8 @@ async function maybeLoadPythonRequest(root, subdir) {
   return {
     kind: ".python-version" /* PythonVersion */,
     path: dotPythonVersionRelPath,
-    data: pyreq
+    data: pyreq,
+    specifier: data.trim()
   };
 }
 
@@ -1980,7 +2031,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 };
 }
@@ -2049,6 +2101,16 @@ async function isWheelCompatible(wheelFilename, pythonMajor, pythonMinor, osName
     osMinor
   );
 }
+async function evaluateMarker(marker, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
+  const mod = await importWasmModule();
+  return mod.evaluateMarker(
+    marker,
+    pythonMajor,
+    pythonMinor,
+    sysPlatform,
+    platformMachine
+  );
+}
 
 // src/manifest/python-selector.ts
 function selectPython(constraints, available) {
@@ -2356,15 +2418,17 @@ var HashDigestSchema = hashDigestSchema;
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
-  containsAppOrHandler,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
+  evaluateMarker,
   extendDistRecord,
+  findAppOrHandler,
   getStringConstant,
   isPrivatePackageSource,
   isWheelCompatible,
   normalizePackageName,
+  parsePep508,
   parseUvLock,
   scanDistributions,
   selectPython,

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  *
  * @module @vercel/python-analysis
  */
-export { containsAppOrHandler, containsTopLevelCallable, getStringConstant, } from './semantic/entrypoints';
+export { findAppOrHandler, containsTopLevelCallable, getStringConstant, } from './semantic/entrypoints';
 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,16 +14,17 @@ 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 { 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';
 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

@@ -120,12 +120,12 @@ async function importWasmModule() {
 }
 
 // src/semantic/entrypoints.ts
-async function containsAppOrHandler(source) {
+async function findAppOrHandler(source) {
   if (!source.includes("app") && !source.includes("application") && !source.includes("handler") && !source.includes("Handler")) {
-    return false;
+    return null;
   }
   const mod = await importWasmModule();
-  return mod.containsAppOrHandler(source);
+  return mod.findAppOrHandler(source) ?? null;
 }
 async function containsTopLevelCallable(source, name) {
   if (!source.includes(name)) {
@@ -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 };
 }
@@ -1970,6 +2020,16 @@ async function isWheelCompatible(wheelFilename, pythonMajor, pythonMinor, osName
     osMinor
   );
 }
+async function evaluateMarker(marker, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
+  const mod = await importWasmModule();
+  return mod.evaluateMarker(
+    marker,
+    pythonMajor,
+    pythonMinor,
+    sysPlatform,
+    platformMachine
+  );
+}
 
 // src/manifest/python-selector.ts
 function selectPython(constraints, available) {
@@ -2276,15 +2336,17 @@ export {
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
-  containsAppOrHandler,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
+  evaluateMarker,
   extendDistRecord,
+  findAppOrHandler,
   getStringConstant,
   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,10 @@ export interface UvLockPackage {
     version: string;
     source?: UvLockPackageSource;
     wheels: UvLockWheel[];
+    dependencies?: Array<{
+        name: string;
+        marker?: string;
+    }>;
 }
 /**
  * Parsed uv.lock file structure.

package/dist/manifest/wheel-compat.d.ts

@@ -2,7 +2,7 @@
  * Check if a wheel filename is compatible with a given platform.
  *
  * Uses uv's `WheelFilename::is_compatible()` and `Tags::from_env()` via WASM
- * — the same logic uv uses for resolution.
+ * -- the same logic uv uses for resolution.
  *
  * @param wheelFilename - The wheel filename (e.g. "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.whl")
  * @param pythonMajor - Python major version (e.g. 3)
@@ -14,3 +14,17 @@
  * @returns true if the wheel is compatible with the platform
  */
 export declare function isWheelCompatible(wheelFilename: string, pythonMajor: number, pythonMinor: number, osName: string, archName: string, osMajor: number, osMinor: number): Promise<boolean>;
+/**
+ * Evaluate a PEP 508 environment marker against a target environment.
+ *
+ * Uses uv's `MarkerTree::evaluate()` via WASM -- the same logic uv uses
+ * for dependency resolution.
+ *
+ * @param marker - PEP 508 marker expression (e.g. "sys_platform == 'win32'")
+ * @param pythonMajor - Python major version (e.g. 3)
+ * @param pythonMinor - Python minor version (e.g. 12)
+ * @param sysPlatform - sys_platform value: "linux", "win32", "darwin"
+ * @param platformMachine - platform_machine value: "x86_64", "aarch64", etc.
+ * @returns true if the marker is satisfied for the target environment
+ */
+export declare function evaluateMarker(marker: string, pythonMajor: number, pythonMinor: number, sysPlatform: string, platformMachine: string): Promise<boolean>;

package/dist/semantic/entrypoints.d.ts

@@ -12,21 +12,22 @@
  * accurate AST analysis without requiring a Python runtime.
  *
  * @param source - The Python source code to analyze
- * @returns Promise that resolves to true if an app or handler is found, false otherwise.
- *          Returns false for invalid Python syntax.
+ * @returns Promise that resolves to the matched variable name (e.g. "app",
+ *          "application", "handler"), or null if not found.
+ *          Returns null for invalid Python syntax.
  *
  * @example
  * ```typescript
- * import { containsAppOrHandler } from '@vercel/python-analysis';
+ * import { findAppOrHandler } from '@vercel/python-analysis';
  *
- * const hasApp = await containsAppOrHandler(`
+ * const name = await findAppOrHandler(`
  * from flask import Flask
  * app = Flask(__name__)
  * `);
- * console.log(hasApp); // true
+ * console.log(name); // "app"
  * ```
  */
-export declare function containsAppOrHandler(source: string): Promise<boolean>;
+export declare function findAppOrHandler(source: string): Promise<string | null>;
 /**
  * Check if a top-level callable with the given name exists in Python source.
  *

package/dist/wasm/vercel_python_analysis.d.ts

@@ -116,7 +116,7 @@ export interface ImportObject {
   'wasi:random/insecure-seed@0.2.6': typeof WasiRandomInsecureSeed,
 }
 export interface Root {
-  containsAppOrHandler(source: string): boolean,
+  findAppOrHandler(source: string): string | undefined,
   getStringConstant(source: string, name: string): string | undefined,
   containsTopLevelCallable(source: string, name: string): boolean,
   parseDistMetadata(content: Uint8Array): DistMetadata,
@@ -124,7 +124,9 @@ 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,
+  evaluateMarker(marker: string, pythonMajor: number, pythonMinor: number, sysPlatform: string, platformMachine: string): 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) {
@@ -3641,34 +3642,58 @@ let gen = (function* _initGenerator () {
       '9': trampoline22,
     },
   }));
-  postReturn0 = exports1['cabi_post_get-string-constant'];
+  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'];
-  let exports1ContainsAppOrHandler;
+  postReturn6 = exports1['cabi_post_parse-pep508'];
+  let exports1FindAppOrHandler;
   
-  function containsAppOrHandler(arg0) {
+  function findAppOrHandler(arg0) {
     var ptr0 = utf8Encode(arg0, realloc0, memory0);
     var len0 = utf8EncodedLen;
-    _debugLog('[iface="contains-app-or-handler", function="contains-app-or-handler"][Instruction::CallWasm] enter', {
-      funcName: 'contains-app-or-handler',
+    _debugLog('[iface="find-app-or-handler", function="find-app-or-handler"][Instruction::CallWasm] enter', {
+      funcName: 'find-app-or-handler',
       paramCount: 2,
       async: false,
-      postReturn: false,
+      postReturn: true,
     });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ContainsAppOrHandler');
-    const ret = exports1ContainsAppOrHandler(ptr0, len0);
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1FindAppOrHandler');
+    const ret = exports1FindAppOrHandler(ptr0, len0);
     endCurrentTask(0);
-    var bool1 = ret;
-    _debugLog('[iface="contains-app-or-handler", function="contains-app-or-handler"][Instruction::Return]', {
-      funcName: 'contains-app-or-handler',
+    let variant2;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        variant2 = undefined;
+        break;
+      }
+      case 1: {
+        var ptr1 = dataView(memory0).getUint32(ret + 4, true);
+        var len1 = dataView(memory0).getUint32(ret + 8, true);
+        var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+        variant2 = result1;
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for option');
+      }
+    }
+    _debugLog('[iface="find-app-or-handler", function="find-app-or-handler"][Instruction::Return]', {
+      funcName: 'find-app-or-handler',
       paramCount: 1,
       async: false,
-      postReturn: false
+      postReturn: true
     });
-    return bool1 == 0 ? false : (bool1 == 1 ? true : throwInvalidBool());
+    const retCopy = variant2;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn0(ret);
+    cstate.mayLeave = true;
+    return retCopy;
+    
   }
   let exports1GetStringConstant;
   
@@ -4836,6 +4861,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);
     }
@@ -4905,7 +5145,70 @@ let gen = (function* _initGenerator () {
     return retCopy.val;
     
   }
-  exports1ContainsAppOrHandler = exports1['contains-app-or-handler'];
+  let exports1EvaluateMarker;
+  
+  function evaluateMarker(arg0, arg1, arg2, arg3, arg4) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    var ptr1 = utf8Encode(arg3, realloc0, memory0);
+    var len1 = utf8EncodedLen;
+    var ptr2 = utf8Encode(arg4, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    _debugLog('[iface="evaluate-marker", function="evaluate-marker"][Instruction::CallWasm] enter', {
+      funcName: 'evaluate-marker',
+      paramCount: 8,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1EvaluateMarker');
+    const ret = exports1EvaluateMarker(ptr0, len0, toUint8(arg1), toUint8(arg2), ptr1, len1, ptr2, len2);
+    endCurrentTask(0);
+    let variant5;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var bool3 = dataView(memory0).getUint8(ret + 4, true);
+        variant5= {
+          tag: 'ok',
+          val: bool3 == 0 ? false : (bool3 == 1 ? true : throwInvalidBool())
+        };
+        break;
+      }
+      case 1: {
+        var ptr4 = dataView(memory0).getUint32(ret + 4, true);
+        var len4 = dataView(memory0).getUint32(ret + 8, true);
+        var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+        variant5= {
+          tag: 'err',
+          val: result4
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="evaluate-marker", function="evaluate-marker"][Instruction::Return]', {
+      funcName: 'evaluate-marker',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant5;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn0(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  exports1FindAppOrHandler = exports1['find-app-or-handler'];
   exports1GetStringConstant = exports1['get-string-constant'];
   exports1ContainsTopLevelCallable = exports1['contains-top-level-callable'];
   exports1ParseDistMetadata = exports1['parse-dist-metadata'];
@@ -4913,9 +5216,11 @@ 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'];
+  exports1EvaluateMarker = exports1['evaluate-marker'];
   
-  return { containsAppOrHandler, containsTopLevelCallable, getStringConstant, isWheelCompatible, normalizePackageName, parseDirectUrl, parseDistMetadata, parseRecord, parseRequirementsTxt,  };
+  return { containsTopLevelCallable, evaluateMarker, 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.10.0",
+  "version": "0.11.0",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",