@vercel/python-analysis 0.1.1

package/dist/manifest/package.js

@@ -0,0 +1,422 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var package_exports = {};
+__export(package_exports, {
+  PythonConfigKind: () => PythonConfigKind,
+  PythonManifestConvertedKind: () => PythonManifestConvertedKind,
+  PythonManifestKind: () => PythonManifestKind,
+  discoverPythonPackage: () => discoverPythonPackage
+});
+module.exports = __toCommonJS(package_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_minimatch = require("minimatch");
+var import_config = require("../util/config");
+var import_error = require("../util/error");
+var import_fs = require("../util/fs");
+var import_pep440 = require("./pep440");
+var import_schema = require("./pipfile/schema");
+var import_pipfile_parser = require("./pipfile-parser");
+var import_schema2 = require("./pyproject/schema");
+var import_requirements_txt_parser = require("./requirements-txt-parser");
+var import_schema3 = require("./uv-config/schema");
+var import_uv_python_version_parser = require("./uv-python-version-parser");
+var PythonConfigKind = /* @__PURE__ */ ((PythonConfigKind2) => {
+  PythonConfigKind2["PythonVersion"] = ".python-version";
+  return PythonConfigKind2;
+})(PythonConfigKind || {});
+var PythonManifestKind = /* @__PURE__ */ ((PythonManifestKind2) => {
+  PythonManifestKind2["PyProjectToml"] = "pyproject.toml";
+  return PythonManifestKind2;
+})(PythonManifestKind || {});
+var PythonManifestConvertedKind = /* @__PURE__ */ ((PythonManifestConvertedKind2) => {
+  PythonManifestConvertedKind2["Pipfile"] = "Pipfile";
+  PythonManifestConvertedKind2["PipfileLock"] = "Pipfile.lock";
+  PythonManifestConvertedKind2["RequirementsIn"] = "requirements.in";
+  PythonManifestConvertedKind2["RequirementsTxt"] = "requirements.txt";
+  return PythonManifestConvertedKind2;
+})(PythonManifestConvertedKind || {});
+async function discoverPythonPackage({
+  entrypointDir,
+  rootDir
+}) {
+  const entrypointPath = (0, import_fs.normalizePath)(entrypointDir);
+  const rootPath = (0, import_fs.normalizePath)(rootDir);
+  let prefix = import_node_path.default.relative(rootPath, entrypointPath);
+  if (prefix.startsWith("..")) {
+    throw new import_error.PythonAnalysisError({
+      message: "Entrypoint directory outside of repository root",
+      code: "PYTHON_INVALID_ENTRYPOINT_PATH"
+    });
+  }
+  const manifests = [];
+  let configs = [];
+  for (; ; ) {
+    const prefixConfigs = await loadPythonConfigs(rootPath, prefix);
+    if (Object.keys(prefixConfigs).length !== 0) {
+      configs.push(prefixConfigs);
+    }
+    const prefixManifest = await loadPythonManifest(rootPath, prefix);
+    if (prefixManifest != null) {
+      manifests.push(prefixManifest);
+      if (prefixManifest.isRoot) {
+        break;
+      }
+    }
+    if (prefix === "" || prefix === ".") {
+      break;
+    }
+    prefix = import_node_path.default.dirname(prefix);
+  }
+  let entrypointManifest;
+  let workspaceManifest;
+  if (manifests.length === 0) {
+    return {
+      configs
+    };
+  } else {
+    entrypointManifest = manifests[0];
+    const entrypointWorkspaceManifest = findWorkspaceManifestFor(
+      entrypointManifest,
+      manifests
+    );
+    workspaceManifest = entrypointWorkspaceManifest;
+    configs = configs.filter(
+      (config) => Object.values(config).some(
+        (cfg) => cfg !== void 0 && (0, import_fs.isSubpath)(
+          import_node_path.default.dirname(cfg.path),
+          import_node_path.default.dirname(entrypointWorkspaceManifest.path)
+        )
+      )
+    );
+  }
+  const requiresPython = computeRequiresPython(
+    entrypointManifest,
+    workspaceManifest,
+    configs
+  );
+  return {
+    manifest: entrypointManifest,
+    workspaceManifest,
+    configs,
+    requiresPython
+  };
+}
+function computeRequiresPython(manifest, workspaceManifest, configs) {
+  const constraints = [];
+  for (const configSet of configs) {
+    const pythonVersionConfig = configSet[".python-version" /* PythonVersion */];
+    if (pythonVersionConfig !== void 0) {
+      constraints.push({
+        request: pythonVersionConfig.data,
+        source: `${pythonVersionConfig.path}`
+      });
+      break;
+    }
+  }
+  const manifestRequiresPython = manifest?.data.project?.["requires-python"];
+  if (manifestRequiresPython) {
+    const parsed = (0, import_pep440.parsePep440Constraint)(manifestRequiresPython);
+    if (parsed?.length) {
+      const request = (0, import_uv_python_version_parser.pythonRequestFromConstraint)(parsed);
+      constraints.push({
+        request: [request],
+        source: `"requires-python" key in ${manifest.path}`
+      });
+    }
+  } else {
+    const workspaceRequiresPython = workspaceManifest?.data.project?.["requires-python"];
+    if (workspaceRequiresPython) {
+      const parsed = (0, import_pep440.parsePep440Constraint)(workspaceRequiresPython);
+      if (parsed?.length) {
+        const request = (0, import_uv_python_version_parser.pythonRequestFromConstraint)(parsed);
+        constraints.push({
+          request: [request],
+          source: `"requires-python" key in ${workspaceManifest.path}`
+        });
+      }
+    }
+  }
+  return constraints;
+}
+function findWorkspaceManifestFor(manifest, manifestStack) {
+  if (manifest.isRoot) {
+    return manifest;
+  }
+  for (const parentManifest of manifestStack) {
+    if (parentManifest.path === manifest.path) {
+      continue;
+    }
+    const workspace = parentManifest.data.tool?.uv?.workspace;
+    if (workspace !== void 0) {
+      let members = workspace.members ?? [];
+      if (!Array.isArray(members)) {
+        members = [];
+      }
+      let exclude = workspace.exclude ?? [];
+      if (!Array.isArray(exclude)) {
+        exclude = [];
+      }
+      const entrypointRelPath = import_node_path.default.relative(
+        import_node_path.default.dirname(parentManifest.path),
+        import_node_path.default.dirname(manifest.path)
+      );
+      if (members.length > 0 && members.some(
+        (pat) => (0, import_minimatch.match)([entrypointRelPath], pat).length > 0
+      ) && !exclude.some(
+        (pat) => (0, import_minimatch.match)([entrypointRelPath], pat).length > 0
+      )) {
+        return parentManifest;
+      }
+    }
+  }
+  return manifest;
+}
+async function loadPythonManifest(root, prefix) {
+  let manifest = null;
+  const pyproject = await maybeLoadPyProjectToml(root, prefix);
+  if (pyproject != null) {
+    manifest = pyproject;
+    manifest.isRoot = pyproject.data.tool?.uv?.workspace !== void 0;
+  } else {
+    const pipfileLockPyProject = await maybeLoadPipfileLock(root, prefix);
+    if (pipfileLockPyProject != null) {
+      manifest = pipfileLockPyProject;
+      manifest.isRoot = true;
+    } else {
+      const pipfilePyProject = await maybeLoadPipfile(root, prefix);
+      if (pipfilePyProject != null) {
+        manifest = pipfilePyProject;
+        manifest.isRoot = true;
+      } else {
+        for (const fileName of [
+          "requirements.frozen.txt",
+          "requirements-frozen.txt",
+          "requirements.txt",
+          "requirements.in",
+          import_node_path.default.join("requirements", "prod.txt")
+        ]) {
+          const requirementsTxtManifest = await maybeLoadRequirementsTxt(
+            root,
+            prefix,
+            fileName
+          );
+          if (requirementsTxtManifest != null) {
+            manifest = requirementsTxtManifest;
+            manifest.isRoot = true;
+            break;
+          }
+        }
+      }
+    }
+  }
+  return manifest;
+}
+async function maybeLoadPyProjectToml(root, subdir) {
+  const pyprojectTomlRelPath = import_node_path.default.join(subdir, "pyproject.toml");
+  const pyprojectTomlPath = import_node_path.default.join(root, pyprojectTomlRelPath);
+  let pyproject;
+  try {
+    pyproject = await (0, import_config.readConfigIfExists)(
+      pyprojectTomlPath,
+      import_schema2.PyProjectTomlSchema
+    );
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      error.path = pyprojectTomlRelPath;
+      throw error;
+    }
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse pyproject.toml: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_PYPROJECT_PARSE_ERROR",
+      path: pyprojectTomlRelPath
+    });
+  }
+  if (pyproject == null) {
+    return null;
+  }
+  const uvTomlRelPath = import_node_path.default.join(subdir, "uv.toml");
+  const uvTomlPath = import_node_path.default.join(root, uvTomlRelPath);
+  let uvToml;
+  try {
+    uvToml = await (0, import_config.readConfigIfExists)(uvTomlPath, import_schema3.UvConfigSchema);
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      error.path = uvTomlRelPath;
+      throw error;
+    }
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse uv.toml: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_UV_CONFIG_PARSE_ERROR",
+      path: uvTomlRelPath
+    });
+  }
+  if (uvToml != null) {
+    if (pyproject.tool == null) {
+      pyproject.tool = { uv: uvToml };
+    } else {
+      pyproject.tool.uv = uvToml;
+    }
+  }
+  return {
+    path: pyprojectTomlRelPath,
+    data: pyproject
+  };
+}
+async function maybeLoadPipfile(root, subdir) {
+  const pipfileRelPath = import_node_path.default.join(subdir, "Pipfile");
+  const pipfilePath = import_node_path.default.join(root, pipfileRelPath);
+  let pipfile;
+  try {
+    pipfile = await (0, import_config.readConfigIfExists)(pipfilePath, import_schema.PipfileLikeSchema, ".toml");
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      error.path = pipfileRelPath;
+      throw error;
+    }
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse Pipfile: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_PIPFILE_PARSE_ERROR",
+      path: pipfileRelPath
+    });
+  }
+  if (pipfile == null) {
+    return null;
+  }
+  const pyproject = (0, import_pipfile_parser.convertPipfileToPyprojectToml)(pipfile);
+  return {
+    path: pipfileRelPath,
+    data: pyproject,
+    origin: {
+      kind: "Pipfile" /* Pipfile */,
+      path: pipfileRelPath
+    }
+  };
+}
+async function maybeLoadPipfileLock(root, subdir) {
+  const pipfileLockRelPath = import_node_path.default.join(subdir, "Pipfile.lock");
+  const pipfileLockPath = import_node_path.default.join(root, pipfileLockRelPath);
+  let pipfileLock;
+  try {
+    pipfileLock = await (0, import_config.readConfigIfExists)(
+      pipfileLockPath,
+      import_schema.PipfileLockLikeSchema,
+      ".json"
+    );
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      error.path = pipfileLockRelPath;
+      throw error;
+    }
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse Pipfile.lock: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_PIPFILE_LOCK_PARSE_ERROR",
+      path: pipfileLockRelPath
+    });
+  }
+  if (pipfileLock == null) {
+    return null;
+  }
+  const pyproject = (0, import_pipfile_parser.convertPipfileLockToPyprojectToml)(pipfileLock);
+  return {
+    path: pipfileLockRelPath,
+    data: pyproject,
+    origin: {
+      kind: "Pipfile.lock" /* PipfileLock */,
+      path: pipfileLockRelPath
+    }
+  };
+}
+async function maybeLoadRequirementsTxt(root, subdir, fileName) {
+  const requirementsTxtRelPath = import_node_path.default.join(subdir, fileName);
+  const requirementsTxtPath = import_node_path.default.join(root, requirementsTxtRelPath);
+  const requirementsContent = await (0, import_fs.readFileTextIfExists)(requirementsTxtPath);
+  if (requirementsContent == null) {
+    return null;
+  }
+  try {
+    const pyproject = (0, import_requirements_txt_parser.convertRequirementsToPyprojectToml)(requirementsContent);
+    return {
+      path: requirementsTxtRelPath,
+      data: pyproject,
+      origin: {
+        kind: "requirements.txt" /* RequirementsTxt */,
+        path: requirementsTxtRelPath
+      }
+    };
+  } catch (error) {
+    if (error instanceof import_error.PythonAnalysisError) {
+      error.path = requirementsTxtRelPath;
+      throw error;
+    }
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse ${fileName}: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_REQUIREMENTS_PARSE_ERROR",
+      path: requirementsTxtRelPath
+    });
+  }
+}
+async function loadPythonConfigs(root, prefix) {
+  const configs = {};
+  const pythonRequest = await maybeLoadPythonRequest(root, prefix);
+  if (pythonRequest != null) {
+    configs[".python-version" /* PythonVersion */] = pythonRequest;
+  }
+  return configs;
+}
+async function maybeLoadPythonRequest(root, subdir) {
+  const dotPythonVersionRelPath = import_node_path.default.join(subdir, ".python-version");
+  const dotPythonVersionPath = import_node_path.default.join(
+    root,
+    dotPythonVersionRelPath
+  );
+  const data = await (0, import_fs.readFileTextIfExists)(dotPythonVersionPath);
+  if (data == null) {
+    return null;
+  }
+  const pyreq = (0, import_uv_python_version_parser.parsePythonVersionFile)(data);
+  if (pyreq == null) {
+    throw new import_error.PythonAnalysisError({
+      message: `could not parse .python-version file: no valid Python version requests found`,
+      code: "PYTHON_VERSION_FILE_PARSE_ERROR",
+      path: dotPythonVersionRelPath
+    });
+  }
+  return {
+    kind: ".python-version" /* PythonVersion */,
+    path: dotPythonVersionRelPath,
+    data: pyreq
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PythonConfigKind,
+  PythonManifestConvertedKind,
+  PythonManifestKind,
+  discoverPythonPackage
+});

package/dist/manifest/pep440.d.ts

@@ -0,0 +1,6 @@
+import type { Pep440Version, Pep440Constraint } from '@renovatebot/pep440';
+export type { Pep440Version, Pep440Constraint } from '@renovatebot/pep440';
+export { parse as parsePep440Version } from '@renovatebot/pep440';
+export { parse as parsePep440Constraint, satisfies as pep440Satisfies, } from '@renovatebot/pep440/lib/specifier';
+export declare function pep440ConstraintFromVersion(v: Pep440Version): Pep440Constraint[];
+export declare function unparsePep440Version(v: Pep440Version): string;

package/dist/manifest/pep440.js

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pep440_exports = {};
+__export(pep440_exports, {
+  parsePep440Constraint: () => import_specifier.parse,
+  parsePep440Version: () => import_pep440.parse,
+  pep440ConstraintFromVersion: () => pep440ConstraintFromVersion,
+  pep440Satisfies: () => import_specifier.satisfies,
+  unparsePep440Version: () => unparsePep440Version
+});
+module.exports = __toCommonJS(pep440_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_version = require("@renovatebot/pep440/lib/version");
+var import_pep440 = require("@renovatebot/pep440");
+var import_specifier = require("@renovatebot/pep440/lib/specifier");
+function pep440ConstraintFromVersion(v) {
+  return [
+    {
+      operator: "==",
+      version: unparsePep440Version(v),
+      prefix: ""
+    }
+  ];
+}
+function unparsePep440Version(v) {
+  const verstr = (0, import_version.stringify)(v);
+  (0, import_node_assert.default)(verstr != null, "pep440/lib/version:stringify returned null");
+  return verstr;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePep440Constraint,
+  parsePep440Version,
+  pep440ConstraintFromVersion,
+  pep440Satisfies,
+  unparsePep440Version
+});

package/dist/manifest/pep508.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared utilities for PEP 508 dependency string formatting and normalization.
+ *
+ * PEP 508 defines the format for Python dependency specifiers:
+ * https://peps.python.org/pep-0508/
+ *
+ * Format: name[extras] (version) @ url ; markers
+ * Examples:
+ *   - requests>=2.0
+ *   - requests[security]>=2.0
+ *   - mypackage @ https://example.com/pkg.zip
+ *   - requests>=2.0 ; python_version >= "3.8"
+ */
+import type { NormalizedRequirement } from './requirement/types';
+/**
+ * Split a package specification into name and extras.
+ *
+ * @param spec - Package specification that may include extras (e.g., "requests[security,socks]")
+ * @returns Tuple of [name, extras] where extras is undefined if not present
+ *
+ * @example
+ * splitExtras("requests") // ["requests", undefined]
+ * splitExtras("requests[security]") // ["requests", ["security"]]
+ * splitExtras("requests[security,socks]") // ["requests", ["security", "socks"]]
+ */
+export declare function splitExtras(spec: string): [string, string[] | undefined];
+/**
+ * Normalize a Python package name according to PEP 503.
+ *
+ * PEP 503 specifies that package names should be compared case-insensitively
+ * and with underscores, hyphens, and periods treated as equivalent.
+ *
+ * @param name - Package name to normalize
+ * @returns Lowercase name with separators normalized to hyphens
+ *
+ * @example
+ * normalizePackageName("My_Package.Name") // "my-package-name"
+ */
+export declare function normalizePackageName(name: string): string;
+/**
+ * Format a normalized requirement as a PEP 508 dependency string.
+ *
+ * @param req - Normalized requirement to format
+ * @returns PEP 508 formatted string
+ *
+ * @example
+ * formatPep508({ name: "requests", version: ">=2.0" })
+ * // "requests>=2.0"
+ *
+ * formatPep508({ name: "mypackage", url: "https://example.com/pkg.zip" })
+ * // "mypackage @ https://example.com/pkg.zip"
+ *
+ * formatPep508({ name: "requests", version: ">=2.0", extras: ["security"], markers: "python_version >= '3.8'" })
+ * // "requests[security]>=2.0 ; python_version >= '3.8'"
+ */
+export declare function formatPep508(req: NormalizedRequirement): string;
+/**
+ * Merge extras arrays, combining and deduplicating entries.
+ *
+ * @param existing - Existing extras array (may be undefined)
+ * @param additional - Additional extras to merge (may be undefined or a single 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;

package/dist/manifest/pep508.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pep508_exports = {};
+__export(pep508_exports, {
+  formatPep508: () => formatPep508,
+  mergeExtras: () => mergeExtras,
+  normalizePackageName: () => normalizePackageName,
+  splitExtras: () => splitExtras
+});
+module.exports = __toCommonJS(pep508_exports);
+const EXTRAS_REGEX = /^(.+)\[([^\]]+)\]$/;
+function splitExtras(spec) {
+  const match = EXTRAS_REGEX.exec(spec);
+  if (!match) {
+    return [spec, void 0];
+  }
+  const extras = match[2].split(",").map((e) => e.trim());
+  return [match[1], extras];
+}
+function normalizePackageName(name) {
+  return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+function formatPep508(req) {
+  let result = req.name;
+  if (req.extras && req.extras.length > 0) {
+    result += `[${req.extras.join(",")}]`;
+  }
+  if (req.url) {
+    result += ` @ ${req.url}`;
+  } else if (req.version && req.version !== "*") {
+    result += req.version;
+  }
+  if (req.markers) {
+    result += ` ; ${req.markers}`;
+  }
+  return result;
+}
+function mergeExtras(existing, additional) {
+  const result = new Set(existing || []);
+  if (additional) {
+    const additionalArray = Array.isArray(additional) ? additional : [additional];
+    for (const extra of additionalArray) {
+      result.add(extra);
+    }
+  }
+  return result.size > 0 ? Array.from(result) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatPep508,
+  mergeExtras,
+  normalizePackageName,
+  splitExtras
+});

package/dist/manifest/pipfile/schema.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Zod schemas for Pipfile and Pipfile.lock configuration types.
+ *
+ * Types are defined in types.ts (source of truth).
+ * Schemas are generated by ts-to-zod and re-exported here with proper typing.
+ *
+ * @module pipfile/schema
+ */
+import type { z } from 'zod';
+import type { PipfileDependency, PipfileDependencyDetail, PipfileLike, PipfileLockLike, PipfileLockMeta, PipfileSource } from './types';
+/**
+ * Schema for Pipfile dependency detail.
+ */
+export declare const PipfileDependencyDetailSchema: z.ZodType<PipfileDependencyDetail, z.ZodTypeDef, PipfileDependencyDetail>;
+/**
+ * Schema for Pipfile dependency (string version specifier or detail object).
+ */
+export declare const PipfileDependencySchema: z.ZodType<PipfileDependency, z.ZodTypeDef, PipfileDependency>;
+/**
+ * Schema for Pipfile source configuration.
+ */
+export declare const PipfileSourceSchema: z.ZodType<PipfileSource, z.ZodTypeDef, PipfileSource>;
+/**
+ * Schema for Pipfile.
+ *
+ * Note: This is an intersection type (z.record().and(z.object())) so we don't
+ * call .passthrough() - the record part already allows additional keys.
+ */
+export declare const PipfileLikeSchema: z.ZodType<PipfileLike, z.ZodTypeDef, PipfileLike>;
+/**
+ * Schema for Pipfile.lock _meta section.
+ */
+export declare const PipfileLockMetaSchema: z.ZodType<PipfileLockMeta, z.ZodTypeDef, PipfileLockMeta>;
+/**
+ * Schema for Pipfile.lock.
+ *
+ * Note: This is an intersection type (z.record().and(z.object())) so we don't
+ * call .passthrough() - the record part already allows additional keys.
+ */
+export declare const PipfileLockLikeSchema: z.ZodType<PipfileLockLike, z.ZodTypeDef, PipfileLockLike>;