@vercel/python-analysis 0.10.1 → 0.11.0

package/dist/index.cjs

@@ -63,11 +63,12 @@ __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,
@@ -203,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)) {
@@ -2100,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) {
@@ -2407,11 +2418,12 @@ var HashDigestSchema = hashDigestSchema;
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
-  containsAppOrHandler,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
+  evaluateMarker,
   extendDistRecord,
+  findAppOrHandler,
   getStringConstant,
   isPrivatePackageSource,
   isWheelCompatible,

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,7 +14,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 { 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

@@ -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)) {
@@ -2020,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) {
@@ -2326,11 +2336,12 @@ export {
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   classifyPackages,
-  containsAppOrHandler,
   containsTopLevelCallable,
   createMinimalManifest,
   discoverPythonPackage,
+  evaluateMarker,
   extendDistRecord,
+  findAppOrHandler,
   getStringConstant,
   isPrivatePackageSource,
   isWheelCompatible,

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

@@ -25,6 +25,7 @@ export interface UvLockPackage {
     wheels: UvLockWheel[];
     dependencies?: Array<{
         name: string;
+        marker?: string;
     }>;
 }
 /**

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,
@@ -126,6 +126,7 @@ export interface Root {
   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

@@ -3642,35 +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'];
   postReturn6 = exports1['cabi_post_parse-pep508'];
-  let exports1ContainsAppOrHandler;
+  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;
   
@@ -5122,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'];
@@ -5132,8 +5218,9 @@ let gen = (function* _initGenerator () {
   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, parsePep508, 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.1",
+  "version": "0.11.0",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",