pyfig 0.4.0 → 0.5.0

package/README.md

@@ -16,7 +16,7 @@ bun add pyfig
 import { createPyfig } from 'pyfig';
 
 const pyfig = createPyfig({
-  pythonRange: '>=3.11.0 <4.0.0',
+  requiresPython: '>=3.11,<4',
   requireEmbedding: true,
   requireGil: true,
 });
@@ -36,7 +36,7 @@ await pyfig.uv(
 );
 ```
 
-`prepare()` accepts runtime requirement strings plus optional `extras`, `groups`, or `allExtras`. If the project has a `pyproject.toml`, uv resolves that read-only input together with a temporary requirements file. Pyfig installs the resolved result with `uv pip install -r`, which preserves unrelated packages. Temporary inputs are created outside the repository and removed afterward.
+`prepare()` accepts PEP 508 dependency specifiers plus optional `extras`, `groups`, or `allExtras`. If the project has a `pyproject.toml`, uv resolves that read-only input together with a temporary dependency file. Pyfig installs the resolved result with `uv pip install -r`, which preserves unrelated packages. Temporary inputs are created outside the repository and removed afterward.
 
 The same uv-only surface handles direct commands:
 
@@ -89,19 +89,19 @@ await pyfig.prepare(
 Resolution follows the equivalent of:
 
 ```sh
-uv pip compile pyproject.toml /temporary/runtime-requirements.txt \
+uv pip compile pyproject.toml /temporary/runtime-dependencies.txt \
   --extra postgres --group runtime \
   --python /selected/venv/python \
-  --output-file /temporary/resolved-requirements.txt
+  --output-file /temporary/resolved-dependencies.txt
 
 uv pip install \
   --python /selected/venv/python \
-  -r /temporary/resolved-requirements.txt
+  -r /temporary/resolved-dependencies.txt
 ```
 
-When no `pyproject.toml` exists, only the temporary requirements input is compiled. Extras and dependency groups require an existing `pyproject.toml`. Pyfig does not use `uv add` or `uv pip sync`: the former would edit project metadata, while the latter could remove unrelated packages from the venv.
+When no `pyproject.toml` exists, only the temporary dependency input is compiled. Extras and dependency groups require an existing `pyproject.toml`. Pyfig does not use `uv add` or `uv pip sync`: the former would edit project metadata, while the latter could remove unrelated packages from the venv.
 
-![Runtime requirements are resolved in temporary files before installation](docs/diagrams/runtime-dependencies.png)
+![Runtime dependencies are resolved in temporary files before installation](docs/diagrams/runtime-dependencies.png)
 
 [Mermaid source](docs/diagrams/runtime-dependencies.mmd)
 
@@ -121,11 +121,11 @@ Set `projectRoot` explicitly in reusable libraries and unusual workspace layouts
 | Export | Responsibility |
 | --- | --- |
 | `createPyfig(options)` | Create a scoped client with memoized base preparation. |
-| `client.prepare(requirements?, options?)` | Select a venv and optionally resolve/install runtime dependencies. |
+| `client.prepare(dependencies?, options?)` | Select a venv and optionally resolve/install runtime dependencies. |
 | `client.pythonInfo()` | Return the selected interpreter and embedding metadata. |
 | `client.uvInfo()` | Return the selected uv executable and version. |
 | `client.uv()` / `client.uvSync()` | Spawn uv and pin pip/run commands to the selected venv. |
-| `ensureEnvironment(options?, requirements?, dependencyOptions?)` | Standalone preparation API. |
+| `ensureEnvironment(options?, dependencies?, dependencyOptions?)` | Standalone preparation API. |
 | `ensureUv(options?)` | Prefer existing uv, otherwise bootstrap verified uv when allowed. |
 | `uvSpawn()` / `uvSpawnSync()` | Standalone uv spawn API. |
 | `resolveProjectRoot(start?)` | Resolve the nearest Git root without reading manifests. |
@@ -136,10 +136,12 @@ The package exposes matching ESM and CommonJS entry points. Probe, download, loc
 
 Precedence is API or CLI option, environment variable, then default.
 
+`requiresPython` uses the same PEP 440 specifier syntax as `[project].requires-python` in `pyproject.toml`. Comma-separated clauses, compatible releases (`~=`), exclusions (`!=`), wildcard equality (`==3.12.*`), arbitrary equality (`===`), and pre-release versions are supported. For example: `>=3.10,!=3.12.*,<4`.
+
 | API option | Environment variable | Default |
 | --- | --- | --- |
 | `python` | `PYFIG_PYTHON` | uv discovery |
-| `pythonRange` | `PYFIG_PYTHON_RANGE` | `>=3.10.0 <4.0.0` |
+| `requiresPython` | `PYFIG_REQUIRES_PYTHON` | `>=3.10,<4` |
 | `managedPython` | `PYFIG_MANAGED_PYTHON` | `3.12` |
 | `uvVersion` | `PYFIG_UV_VERSION` | `0.13.6` |
 | `uvRange` | `PYFIG_UV_RANGE` | `>=0.10.0 <1.0.0` |
@@ -163,7 +165,7 @@ Set `PYFIG_UV` to choose an explicit uv executable. Set `PYFIG_AUTO_INSTALL=0` o
 ```sh
 bunx --bun pyfig
 bunx --bun pyfig --check
-bunx --bun pyfig --python-range '>=3.12.0 <3.14.0'
+bunx --bun pyfig --requires-python '>=3.12,<3.14'
 bunx --bun pyfig --require-embedding --require-gil
 bunx --bun pyfig --project-root /path/to/repository
 bunx --bun pyfig --json
@@ -179,7 +181,7 @@ Provisioning mutations use Loqkit's layered in-memory, worker, native-file-lock-
 
 ## Platform support
 
-Pyfig bootstraps uv on x64 and arm64 Windows, macOS, and Linux. Linux uses Astral's static musl artifact, which also runs on glibc. Node.js 22 through 26 and Bun 1.2+ are supported. Other JavaScript runtimes may work when they provide compatible Node built-ins and process semantics.
+Pyfig bootstraps uv on x64 and arm64 Windows, macOS, and Linux. Linux uses Astral's static musl artifact, which also runs on glibc. Node.js 22.11+ on the 22.x line, Node.js 24.10 through 26.x, and Bun 1.2+ are supported. Other JavaScript runtimes may work when they provide compatible Node built-ins and process semantics.
 
 ## Publishing
 

package/SECURITY.md

@@ -6,4 +6,4 @@ The uv release URL is pinned to an exact validated version and fetched over HTTP
 
 Provisioning uses in-process, worker, optional native advisory, and portable filesystem coordination followed by a post-lock capability check. Runtime dependency mutation uses uv's target-environment lock. Pyfig pins uv commands to the selected venv and removes configuration values that could redirect them. It reads an existing `pyproject.toml` only as a resolver input and never writes project manifests or requirements files.
 
-Executable paths, project roots, version ranges, package specifications, indexes, and proxy settings remain trusted configuration. Do not let an untrusted user choose `python`, `PYFIG_UV`, `cacheDir`, package arguments, or related environment variables in a privileged process. A checksum fetched from the same release protects transfer integrity, not a compromised upstream publisher.
+Executable paths, project roots, version specifiers, package specifications, indexes, and proxy settings remain trusted configuration. Do not let an untrusted user choose `python`, `PYFIG_UV`, `cacheDir`, package arguments, or related environment variables in a privileged process. A checksum fetched from the same release protects transfer integrity, not a compromised upstream publisher.

package/dist/cjs/index.js

@@ -66,7 +66,7 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   DEFAULT_MANAGED_PYTHON: () => DEFAULT_MANAGED_PYTHON,
-  DEFAULT_PYTHON_RANGE: () => DEFAULT_PYTHON_RANGE,
+  DEFAULT_REQUIRES_PYTHON: () => DEFAULT_REQUIRES_PYTHON,
   DEFAULT_UV_RANGE: () => DEFAULT_UV_RANGE,
   DEFAULT_UV_VERSION: () => DEFAULT_UV_VERSION,
   createPyfig: () => createPyfig,
@@ -105,8 +105,20 @@ function* ancestors(startDirectory) {
   }
 }
 
+// src/python-version.ts
+var import_pep440 = require("@renovatebot/pep440");
+function isValidPythonSpecifier(specifier) {
+  return import_pep440.validRange(specifier);
+}
+function isValidPythonVersion(version) {
+  return import_pep440.valid(version) !== null;
+}
+function pythonVersionSatisfies(version, specifier) {
+  return import_pep440.filter([version], specifier).length === 1;
+}
+
 // src/config.ts
-var DEFAULT_PYTHON_RANGE = ">=3.10.0 <4.0.0";
+var DEFAULT_REQUIRES_PYTHON = ">=3.10,<4";
 var DEFAULT_MANAGED_PYTHON = "3.12";
 var DEFAULT_UV_VERSION = "0.13.6";
 var DEFAULT_UV_RANGE = ">=0.10.0 <1.0.0";
@@ -122,13 +134,13 @@ var envPathsFunction = (() => {
 })();
 function resolveOptions(options = {}) {
   const env = { ...options.env ?? process.env };
-  const pythonRange = options.pythonRange ?? env["PYFIG_PYTHON_RANGE"] ?? DEFAULT_PYTHON_RANGE;
+  const requiresPython = options.requiresPython ?? env["PYFIG_REQUIRES_PYTHON"] ?? DEFAULT_REQUIRES_PYTHON;
   const uvRange = options.uvRange ?? env["PYFIG_UV_RANGE"] ?? DEFAULT_UV_RANGE;
-  assertRange("Python", pythonRange);
+  assertPythonSpecifier(requiresPython);
   assertRange("uv", uvRange);
   const managedPython = options.managedPython ?? env["PYFIG_MANAGED_PYTHON"] ?? DEFAULT_MANAGED_PYTHON;
   const uvVersion = options.uvVersion ?? env["PYFIG_UV_VERSION"] ?? DEFAULT_UV_VERSION;
-  assertManagedPythonRequest(managedPython, pythonRange);
+  assertManagedPythonRequest(managedPython, requiresPython);
   assertUvVersion(uvVersion, uvRange);
   const probeTimeoutMs = resolveDuration("probeTimeoutMs", options.probeTimeoutMs, env["PYFIG_PROBE_TIMEOUT_MS"], DEFAULT_PROBE_TIMEOUT_MS);
   const installTimeoutMs = resolveDuration("installTimeoutMs", options.installTimeoutMs, env["PYFIG_INSTALL_TIMEOUT_MS"], DEFAULT_INSTALL_TIMEOUT_MS);
@@ -141,7 +153,7 @@ function resolveOptions(options = {}) {
   const autoInstall = options.autoInstall ?? parseBoolean(env["PYFIG_AUTO_INSTALL"], true);
   return {
     python: options.python ?? env["PYFIG_PYTHON"] ?? "",
-    pythonRange,
+    requiresPython,
     managedPython,
     uvVersion,
     uvRange,
@@ -182,14 +194,19 @@ function assertUvVersion(version, range) {
     throw new TypeError(`Pinned uv ${version} does not satisfy supported range ${range}.`);
   }
 }
-function assertManagedPythonRequest(request, pythonRange) {
+function assertPythonSpecifier(specifier) {
+  if (!isValidPythonSpecifier(specifier)) {
+    throw new TypeError(`Invalid requires-python PEP 440 specifier: ${specifier}`);
+  }
+}
+function assertManagedPythonRequest(request, requiresPython) {
   if (!request || /[\\/\0\r\n]/u.test(request) || request.includes("..")) {
     throw new TypeError(`Invalid managed Python request: ${request}`);
   }
   if (/^\d+\.\d+(?:\.\d+)?$/u.test(request)) {
     const normalized = request.split(".").length === 2 ? `${request}.0` : request;
-    if (!import_semver.default.satisfies(normalized, pythonRange)) {
-      throw new TypeError(`Managed Python ${request} cannot satisfy configured range ${pythonRange}.`);
+    if (!pythonVersionSatisfies(normalized, requiresPython)) {
+      throw new TypeError(`Managed Python ${request} cannot satisfy requires-python ${requiresPython}.`);
     }
   }
 }
@@ -222,7 +239,7 @@ var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises2 = require("node:stream/promises");
-var import_extract_zip = __toESM(require("extract-zip"), 1);
+var import_fflate = require("fflate");
 var tar = __toESM(require("tar"), 1);
 var import_undici = require("undici");
 
@@ -512,7 +529,15 @@ if os.path.isfile(header_path) and library_path:
     }
 
 release_level = sys.version_info.releaselevel
-release_suffix = "" if release_level == "final" else f"-{release_level}.{sys.version_info.serial}"
+release_suffixes = {
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": "",
+}
+release_suffix = release_suffixes[release_level]
+if release_suffix:
+    release_suffix += str(sys.version_info.serial)
 
 print(json.dumps({
     "executable": sys.executable,
@@ -532,8 +557,8 @@ print(json.dumps({
     "embedding": embedding,
 }))
 `;
-function pythonSatisfiesRequirements(python, options) {
-  return import_semver2.default.satisfies(python.version, options.pythonRange) && (!options.requireEmbedding || python.implementation === "cpython" && python.embedding !== null && pythonArchitectureMatchesRuntime(python)) && (!options.requireGil || !python.gilDisabled);
+function pythonSatisfiesPolicy(python, options) {
+  return pythonVersionSatisfies(python.version, options.requiresPython) && (!options.requireEmbedding || python.implementation === "cpython" && python.embedding !== null && pythonArchitectureMatchesRuntime(python)) && (!options.requireGil || !python.gilDisabled);
 }
 async function probePython(candidate, options) {
   const executable = await resolveExecutable(candidate.executable, options.env);
@@ -542,7 +567,7 @@ async function probePython(candidate, options) {
   try {
     const { stdout } = run(executable, [...candidate.args, "-c", PYTHON_PROBE], options.env, options.probeTimeoutMs);
     const info = JSON.parse(stdout.trim());
-    return import_semver2.default.valid(info.version) ? info : null;
+    return isValidPythonVersion(info.version) ? info : null;
   } catch {
     return null;
   }
@@ -585,14 +610,14 @@ function pythonArchitectureMatchesRuntime(python) {
 async function ensureUv(options = {}) {
   return ensureUvResolved(resolveOptions(options));
 }
-async function ensureEnvironment(options = {}, requirements = [], dependencyOptions = {}) {
+async function ensureEnvironment(options = {}, dependencies = [], dependencyOptions = {}) {
   const resolved = resolveOptions(options);
-  const normalized = normalizeRequirements(requirements);
+  const normalized = normalizeDependencies(dependencies);
   const selections = normalizeDependencyOptions(dependencyOptions);
   const uv = await ensureUvResolved(resolved);
   const python = await ensureVirtualEnvironmentResolved(resolved, uv);
   if (normalized.length > 0 || selections.extras.length > 0 || selections.groups.length > 0 || selections.allExtras) {
-    await installRuntimeRequirements(uv, python, normalized, selections, resolved);
+    await installRuntimeDependencies(uv, python, normalized, selections, resolved);
   }
   return {
     python,
@@ -607,7 +632,7 @@ async function ensureVirtualEnvironmentResolved(options, uv) {
   const directory = virtualEnvironmentDirectory(options.projectRoot);
   const check = async () => {
     const candidate = await inspectVirtualEnvironment(directory, options);
-    return candidate && pythonSatisfiesRequirements(candidate, options) && await virtualEnvironmentMatchesConfiguredPython(candidate, options) ? candidate : null;
+    return candidate && pythonSatisfiesPolicy(candidate, options) && await virtualEnvironmentMatchesConfiguredPython(candidate, options) ? candidate : null;
   };
   if (!options.createVirtualEnvironment) {
     throw new Error(`No compatible environment is available and creation is disabled. ` + `Pyfig would create ${directory}.`);
@@ -640,7 +665,7 @@ async function ensureVirtualEnvironmentResolved(options, uv) {
 async function findReusableEnvironment(options) {
   if (options.python) {
     const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesRequirements(configured, options)) {
+    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
       throw incompatibleConfiguredPython(options);
     }
     if (configured.virtualEnvironment)
@@ -651,7 +676,7 @@ async function findReusableEnvironment(options) {
     virtualEnvironmentDirectory(options.projectRoot)
   ]) {
     const info = await inspectVirtualEnvironment(directory, options);
-    if (info && pythonSatisfiesRequirements(info, options) && await virtualEnvironmentMatchesConfiguredPython(info, options)) {
+    if (info && pythonSatisfiesPolicy(info, options) && await virtualEnvironmentMatchesConfiguredPython(info, options)) {
       return info;
     }
   }
@@ -660,13 +685,13 @@ async function findReusableEnvironment(options) {
 async function ensureBasePythonResolved(uv, options) {
   if (options.python) {
     const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesRequirements(configured, options)) {
+    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
       throw incompatibleConfiguredPython(options);
     }
     if (!configured.virtualEnvironment)
       return configured;
     const base = await probePython({ executable: configured.baseExecutable, args: [] }, options);
-    if (base && pythonSatisfiesRequirements(base, options))
+    if (base && pythonSatisfiesPolicy(base, options))
       return base;
     throw incompatibleConfiguredPython(options);
   }
@@ -708,7 +733,7 @@ async function findPythonWithUv(uv, options, source) {
     try {
       const { stdout } = await runAsync(uv.executable, args, explicitPythonSourceEnvironment(options), options.probeTimeoutMs);
       const info = await probePython({ executable: stdout.trim(), args: [] }, options);
-      if (info && pythonSatisfiesRequirements(info, options))
+      if (info && pythonSatisfiesPolicy(info, options))
         return info;
     } catch {}
   }
@@ -726,7 +751,7 @@ async function findPythonWithUv(uv, options, source) {
     const candidates = installedPythonPaths(stdout);
     for (const executable of candidates) {
       const info = await probePython({ executable, args: [] }, options);
-      if (info && !info.virtualEnvironment && pythonSatisfiesRequirements(info, options)) {
+      if (info && !info.virtualEnvironment && pythonSatisfiesPolicy(info, options)) {
         return info;
       }
     }
@@ -750,7 +775,7 @@ async function inspectVirtualEnvironment(directory, options) {
   const info = await probePython({ executable, args: [] }, options);
   return info?.virtualEnvironment && pathsEqual(info.virtualEnvironment, directory) ? info : null;
 }
-async function installRuntimeRequirements(uv, python, requirements, dependencyOptions, options) {
+async function installRuntimeDependencies(uv, python, dependencies, dependencyOptions, options) {
   if (!python.virtualEnvironment) {
     throw new Error("Runtime dependency installation requires a virtual environment.");
   }
@@ -759,18 +784,18 @@ async function installRuntimeRequirements(uv, python, requirements, dependencyOp
     timeoutMs: options.coordinationTimeoutMs,
     check: async () => null,
     mutate: async () => {
-      const temporary = await import_promises.mkdtemp(import_node_path5.default.join(import_node_os.default.tmpdir(), "pyfig-requirements-"));
+      const temporary = await import_promises.mkdtemp(import_node_path5.default.join(import_node_os.default.tmpdir(), "pyfig-dependencies-"));
       try {
-        const additions = import_node_path5.default.join(temporary, "runtime-requirements.txt");
-        const resolved = import_node_path5.default.join(temporary, "resolved-requirements.txt");
+        const additions = import_node_path5.default.join(temporary, "runtime-dependencies.txt");
+        const resolved = import_node_path5.default.join(temporary, "resolved-dependencies.txt");
         const pyproject = import_node_path5.default.join(options.projectRoot, "pyproject.toml");
         const hasPyproject = import_node_fs4.default.existsSync(pyproject);
         if (!hasPyproject && (dependencyOptions.extras.length > 0 || dependencyOptions.groups.length > 0 || dependencyOptions.allExtras)) {
           throw new Error("Runtime extras and groups require an existing pyproject.toml.");
         }
         const sources = hasPyproject ? [pyproject] : [];
-        if (requirements.length > 0) {
-          await import_promises.writeFile(additions, `${requirements.join(`
+        if (dependencies.length > 0) {
+          await import_promises.writeFile(additions, `${dependencies.join(`
 `)}
 `, "utf8");
           sources.push(additions);
@@ -829,11 +854,11 @@ async function findAvailableUv(options) {
   const managed = probeUv(uvExecutable(options), options);
   return managed?.version === options.uvVersion ? managed : null;
 }
-function normalizeRequirements(requirements) {
-  const normalized = requirements.map((requirement) => requirement.trim());
-  for (const requirement of normalized) {
-    if (!requirement || /[\0\r\n]/u.test(requirement)) {
-      throw new TypeError(`Invalid runtime requirement: ${JSON.stringify(requirement)}`);
+function normalizeDependencies(dependencies) {
+  const normalized = dependencies.map((dependency) => dependency.trim());
+  for (const dependency of normalized) {
+    if (!dependency || /[\0\r\n]/u.test(dependency)) {
+      throw new TypeError(`Invalid runtime dependency: ${JSON.stringify(dependency)}`);
     }
   }
   return [...new Set(normalized)];
@@ -870,17 +895,17 @@ function targetUvEnvironment(options, python) {
   return uvCommandEnvironment(uvEnvironment(options), python);
 }
 function incompatibleConfiguredPython(options) {
-  return new Error(`Configured Python ${options.python} is unavailable or does not satisfy ` + `${options.pythonRange}${options.requireEmbedding ? " with CPython embedding files" : ""}.`);
+  return new Error(`Configured Python ${options.python} is unavailable or does not satisfy ` + `requires-python ${options.requiresPython}` + `${options.requireEmbedding ? " with CPython embedding files" : ""}.`);
 }
 function missingPythonMessage(options, reason) {
   const embedding = options.requireEmbedding ? " with compatible CPython headers, library, architecture, and GIL ABI" : "";
-  return `No Python satisfies ${options.pythonRange}${embedding}; ${reason}.`;
+  return `No Python satisfies requires-python ${options.requiresPython}${embedding}; ${reason}.`;
 }
 async function virtualEnvironmentMatchesConfiguredPython(virtualEnvironment, options) {
   if (!options.python)
     return true;
   const configured = await probePython({ executable: options.python, args: [] }, options);
-  if (!configured || !pythonSatisfiesRequirements(configured, options))
+  if (!configured || !pythonSatisfiesPolicy(configured, options))
     return false;
   if (configured.virtualEnvironment && pathsEqual(configured.executable, virtualEnvironment.executable)) {
     return true;
@@ -909,11 +934,7 @@ async function installUv(installDir, options) {
     }
     const extracted = import_node_path5.default.join(temporary, "extracted");
     await import_promises.mkdir(extracted, { recursive: true });
-    if (asset.endsWith(".zip"))
-      await import_extract_zip.default(archive, { dir: extracted });
-    else
-      await tar.x({ file: archive, cwd: extracted, strict: true });
-    const source = await findFile(extracted, process.platform === "win32" ? "uv.exe" : "uv");
+    const source = await extractUvExecutable(archive, asset, extracted);
     if (!source)
       throw new Error(`uv archive did not contain the expected executable: ${asset}`);
     await publishUvAtomically(source, installDir, options);
@@ -922,6 +943,22 @@ async function installUv(installDir, options) {
     await import_promises.rm(temporary, { recursive: true, force: true });
   }
 }
+async function extractUvExecutable(archive, asset, destination) {
+  const executableName = process.platform === "win32" ? "uv.exe" : "uv";
+  if (!asset.endsWith(".zip")) {
+    await tar.x({ file: archive, cwd: destination, strict: true });
+    return findFile(destination, executableName);
+  }
+  const entries = import_fflate.unzipSync(await import_promises.readFile(archive), {
+    filter: ({ name }) => import_node_path5.default.posix.basename(name.replaceAll("\\", "/")) === executableName
+  });
+  const matches = Object.entries(entries).filter(([name]) => import_node_path5.default.posix.basename(name.replaceAll("\\", "/")) === executableName);
+  if (matches.length !== 1 || !matches[0])
+    return null;
+  const source = import_node_path5.default.join(destination, executableName);
+  await import_promises.writeFile(source, matches[0][1], { flag: "wx" });
+  return source;
+}
 async function publishUvAtomically(source, installDir, options) {
   await import_promises.mkdir(installDir, { recursive: true });
   const executable = uvExecutable(options);
@@ -1091,7 +1128,7 @@ function createPyfig(options = {}) {
   const baseEnvironment = import_loqkit2.memoize(() => ensureEnvironment(scopedOptions));
   const uvInfo = import_loqkit2.memoize(() => ensureUv(scopedOptions));
   return {
-    prepare: (requirements = [], dependencyOptions = {}) => requirements.length === 0 && !dependencyOptions.allExtras && (dependencyOptions.extras?.length ?? 0) === 0 && (dependencyOptions.groups?.length ?? 0) === 0 ? baseEnvironment() : ensureEnvironment(scopedOptions, requirements, dependencyOptions),
+    prepare: (dependencies = [], dependencyOptions = {}) => dependencies.length === 0 && !dependencyOptions.allExtras && (dependencyOptions.extras?.length ?? 0) === 0 && (dependencyOptions.groups?.length ?? 0) === 0 ? baseEnvironment() : ensureEnvironment(scopedOptions, dependencies, dependencyOptions),
     pythonInfo: async () => (await baseEnvironment()).python,
     uvInfo,
     uv: (args = [], spawnOptions = {}) => uvSpawn(args, spawnOptions, scopedOptions),
@@ -1099,4 +1136,4 @@ function createPyfig(options = {}) {
   };
 }
 
-//# debugId=B84AA2037417535D64756E2164756E21
+//# debugId=5564427996CDDBA964756E2164756E21