@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/npm.mjs

@@ -0,0 +1,155 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  editJson,
+  editJsonSync,
+  readJson,
+  readJsonSync,
+  writeJson,
+  writeJsonSync
+} from "./json.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+import { resolvePathFromRoot } from "./root.mjs";
+async function editNpmShrinkWrapJson(editFunction, options = {}) {
+  const {
+    cwd,
+    shouldSkipIfMissing
+  } = options;
+  await editJson(normalizeOptionalProperties({ editFunction, path: getNpmShrinkWrapJsonPath(cwd), shouldSkipIfMissing }));
+}
+async function editPackageJson(editFunction, options = {}) {
+  const {
+    cwd,
+    shouldSkipIfMissing
+  } = options;
+  await editJson(normalizeOptionalProperties({ editFunction, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));
+}
+function editPackageJsonSync(editFunction, options = {}) {
+  const {
+    cwd,
+    shouldSkipIfMissing
+  } = options;
+  editJsonSync(normalizeOptionalProperties({ editFunction, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));
+}
+async function editPackageLockJson(editFunction, options = {}) {
+  const {
+    cwd,
+    shouldSkipIfMissing
+  } = options;
+  await editJson(normalizeOptionalProperties({ editFunction, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));
+}
+function editPackageLockJsonSync(editFunction, options = {}) {
+  const {
+    cwd,
+    shouldSkipIfMissing
+  } = options;
+  editJsonSync(normalizeOptionalProperties({ editFunction, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));
+}
+function getNpmShrinkWrapJsonPath(cwd) {
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: RepoPaths.NpmShrinkwrapJson })),
+    "Could not determine the npm-shrinkwrap.json path"
+  );
+}
+function getPackageJsonPath(cwd) {
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: RepoPaths.PackageJson })),
+    "Could not determine the package.json path"
+  );
+}
+function getPackageLockJsonPath(cwd) {
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: RepoPaths.PackageLockJson })),
+    "Could not determine the package-lock.json path"
+  );
+}
+async function readPackageJson(cwd) {
+  return await readJson(getPackageJsonPath(cwd));
+}
+function readPackageJsonSync(cwd) {
+  return readJsonSync(getPackageJsonPath(cwd));
+}
+async function readPackageLockJson(cwd) {
+  return await readJson(getPackageLockJsonPath(cwd));
+}
+function readPackageLockJsonSync(cwd) {
+  return readJsonSync(getPackageLockJsonPath(cwd));
+}
+async function writePackageJson(packageJson, cwd) {
+  await writeJson(getPackageJsonPath(cwd), packageJson);
+}
+function writePackageJsonSync(packageJson, cwd) {
+  writeJsonSync(getPackageJsonPath(cwd), packageJson);
+}
+async function writePackageLockJson(packageLockJson, cwd) {
+  await writeJson(getPackageLockJsonPath(cwd), packageLockJson);
+}
+function writePackageLockJsonSync(packageLockJson, cwd) {
+  writeJsonSync(getPackageLockJsonPath(cwd), packageLockJson);
+}
+export {
+  editNpmShrinkWrapJson,
+  editPackageJson,
+  editPackageJsonSync,
+  editPackageLockJson,
+  editPackageLockJsonSync,
+  getNpmShrinkWrapJsonPath,
+  getPackageJsonPath,
+  getPackageLockJsonPath,
+  readPackageJson,
+  readPackageJsonSync,
+  readPackageLockJson,
+  readPackageLockJsonSync,
+  writePackageJson,
+  writePackageJsonSync,
+  writePackageLockJson,
+  writePackageLockJsonSync
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/npm.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for NPM package.json.\n */\n\nimport type {\n  PackageJson,\n  Promisable\n} from 'type-fest';\n\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type {\n  EditJsonParams,\n  EditJsonSyncParams\n} from './json.ts';\nimport type { ResolvePathFromRootParams } from './root.ts';\n\nimport {\n  editJson,\n  editJsonSync,\n  readJson,\n  readJsonSync,\n  writeJson,\n  writeJsonSync\n} from './json.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport { resolvePathFromRoot } from './root.ts';\n\n/**\n * Options for {@link editNpmShrinkWrapJson}.\n */\nexport type EditNpmShrinkWrapJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageJson}.\n */\nexport interface EditPackageJsonOptions {\n  /**\n   * A current working folder where `package.json` is located.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, skips editing if the file does not exist.\n   *\n   * @default `false`\n   */\n  readonly shouldSkipIfMissing?: boolean;\n}\n\n/**\n * Options for {@link editPackageJsonSync}.\n */\nexport type EditPackageJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJson}.\n */\nexport type EditPackageLockJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJsonSync}.\n */\nexport type EditPackageLockJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * A type of the `package.json` file.\n */\n\n/**\n * A type of the `package-lock.json` file.\n */\nexport interface PackageLockJson extends Partial<PackageJson> {\n  /**\n   * Packages in the `package-lock.json` file.\n   */\n  packages?: Record<string, PackageJson>;\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFunction - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editNpmShrinkWrapJson(\n  editFunction: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditNpmShrinkWrapJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFunction, path: getNpmShrinkWrapJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFunction - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageJson(\n  editFunction: (packageJson: PackageJson) => Promisable<void>,\n  options: EditPackageJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFunction, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFunction - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageJsonSync(\n  editFunction: (packageJson: PackageJson) => void,\n  options: EditPackageJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageJson>(normalizeOptionalProperties<EditJsonSyncParams<PackageJson>>({ editFunction, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFunction - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageLockJson(\n  editFunction: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditPackageLockJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFunction, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFunction - The function to edit the parsed `PackageLockJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageLockJsonSync(\n  editFunction: (packageLockJson: PackageLockJson) => void,\n  options: EditPackageLockJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageLockJson>(normalizeOptionalProperties<EditJsonSyncParams<PackageLockJson>>({ editFunction, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Resolves the path to the `npm-shrinkwrap.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `npm-shrinkwrap.json` is located.\n * @returns The resolved path to the `npm-shrinkwrap.json` file.\n */\nexport function getNpmShrinkWrapJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: RepoPaths.NpmShrinkwrapJson })),\n    'Could not determine the npm-shrinkwrap.json path'\n  );\n}\n\n/**\n * Resolves the path to the `package.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The resolved path to the `package.json` file.\n */\nexport function getPackageJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: RepoPaths.PackageJson })),\n    'Could not determine the package.json path'\n  );\n}\n\n/**\n * Resolves the path to the `package-lock.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The resolved path to the `package-lock.json` file.\n */\nexport function getPackageLockJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: RepoPaths.PackageLockJson })),\n    'Could not determine the package-lock.json path'\n  );\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageJson(cwd?: string): Promise<PackageJson> {\n  return await readJson<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The parsed `PackageJson` object.\n */\nexport function readPackageJsonSync(cwd?: string): PackageJson {\n  return readJsonSync<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageLockJson(cwd?: string): Promise<PackageLockJson> {\n  return await readJson<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The parsed `PackageLockJson` object.\n */\nexport function readPackageLockJsonSync(cwd?: string): PackageLockJson {\n  return readJsonSync<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageJson(packageJson: PackageJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n */\nexport function writePackageJsonSync(packageJson: PackageJson, cwd?: string): void {\n  writeJsonSync(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageLockJson(packageLockJson: PackageLockJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageLockJsonPath(cwd), packageLockJson);\n}\n\n/**\n * Writes the provided `PackageLockJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n */\nexport function writePackageLockJsonSync(packageLockJson: PackageLockJson, cwd?: string): void {\n  writeJsonSync(getPackageLockJsonPath(cwd), packageLockJson);\n}\n\n// TypeScript's declaration emit adds `with { 'resolution-mode': 'import' }` to import declarations only.\n// A re-export-from would thus resolve ESM-only `type-fest` under `require` in the `.d.cts` build (TS1479).\n// Re-exporting the binding imported above keeps that resolution mode attached.\n// eslint-disable-next-line unicorn/prefer-export-from -- `export\u2026from` re-introduces TS1479, see above.\nexport type { PackageJson };\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,SAAS,mCAAmC;AAC5C,SAAS,yBAAyB;AAQlC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AA4DpC,eAAsB,sBACpB,cACA,UAAwC,CAAC,GAC1B;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,cAAc,MAAM,yBAAyB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAClK;AASA,eAAsB,gBACpB,cACA,UAAkC,CAAC,GACpB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,cAAc,MAAM,mBAAmB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAC5J;AAQO,SAAS,oBACd,cACA,UAAsC,CAAC,GACjC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA0B,4BAA6D,EAAE,cAAc,MAAM,mBAAmB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAC9J;AASA,eAAsB,oBACpB,cACA,UAAsC,CAAC,GACxB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,cAAc,MAAM,uBAAuB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAChK;AAQO,SAAS,wBACd,cACA,UAA0C,CAAC,GACrC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA8B,4BAAiE,EAAE,cAAc,MAAM,uBAAuB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAC1K;AAQO,SAAS,yBAAyB,KAAsB;AAC7D,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,UAAU,kBAAkB,CAAC,CAAC;AAAA,IACtH;AAAA,EACF;AACF;AAQO,SAAS,mBAAmB,KAAsB;AACvD,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,UAAU,YAAY,CAAC,CAAC;AAAA,IAChH;AAAA,EACF;AACF;AAQO,SAAS,uBAAuB,KAAsB;AAC3D,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,UAAU,gBAAgB,CAAC,CAAC;AAAA,IACpH;AAAA,EACF;AACF;AAQA,eAAsB,gBAAgB,KAAoC;AACxE,SAAO,MAAM,SAAsB,mBAAmB,GAAG,CAAC;AAC5D;AAQO,SAAS,oBAAoB,KAA2B;AAC7D,SAAO,aAA0B,mBAAmB,GAAG,CAAC;AAC1D;AAQA,eAAsB,oBAAoB,KAAwC;AAChF,SAAO,MAAM,SAA0B,uBAAuB,GAAG,CAAC;AACpE;AAQO,SAAS,wBAAwB,KAA+B;AACrE,SAAO,aAA8B,uBAAuB,GAAG,CAAC;AAClE;AASA,eAAsB,iBAAiB,aAA0B,KAA6B;AAC5F,QAAM,UAAU,mBAAmB,GAAG,GAAG,WAAW;AACtD;AAQO,SAAS,qBAAqB,aAA0B,KAAoB;AACjF,gBAAc,mBAAmB,GAAG,GAAG,WAAW;AACpD;AASA,eAAsB,qBAAqB,iBAAkC,KAA6B;AACxG,QAAM,UAAU,uBAAuB,GAAG,GAAG,eAAe;AAC9D;AAQO,SAAS,yBAAyB,iBAAkC,KAAoB;AAC7F,gBAAc,uBAAuB,GAAG,GAAG,eAAe;AAC5D;",
  "names": []
}


package/dist/lib/esm/package-lock-integrity.d.mts

@@ -0,0 +1,38 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Refuses a `package-lock.json` whose installed entries have lost their `resolved` or `integrity` field.
+ *
+ * You get such a lock by deleting `package-lock.json` while `node_modules` is still installed and then
+ * running `npm install`. npm records every package it reuses from `node_modules` with its version only.
+ * One measured lock went from 7 such entries to 1064 of 1234 in a single regeneration. **npm never fills
+ * the two fields back in afterwards**: a clean install into an empty directory does not, and neither does
+ * `npm install --package-lock-only`. `npm ci` skips integrity verification for those packages, so the
+ * defect is permanent and every other check stays green.
+ *
+ * The check reads the JSON and nothing else. It makes no network call and finishes in well under a second,
+ * which is why `gate()` runs it before anything else.
+ */
+import type { PackageLockJson } from './npm.mjs';
+/**
+ * Throws when the project's `package-lock.json` has an installed entry without `resolved` or `integrity`.
+ * A project with no `package-lock.json`, such as one on another package manager, passes.
+ *
+ * @param cwd - The folder to resolve the project root from. Defaults to the current one.
+ * @returns A {@link Promise} that resolves when the lock is complete.
+ */
+export declare function assertPackageLockIntegrity(cwd?: string): Promise<void>;
+/**
+ * Finds the `packages` entries of a lockfile that have no `resolved` field, or that have a registry
+ * `resolved` field and no `integrity` field.
+ *
+ * Some entries never have these fields in a healthy lock, so they are skipped: the root (`''`), a `link`,
+ * a workspace source folder (its key has no `node_modules/` segment), and a bundled dependency (`inBundle`),
+ * which comes inside its parent's tarball. `integrity` is only required when `resolved` is a registry URL,
+ * because npm records no integrity for a git dependency.
+ *
+ * @param packageLockJson - The parsed `package-lock.json`.
+ * @returns The keys of the offending entries, in lockfile order.
+ */
+export declare function findPackageLockEntriesMissingIntegrity(packageLockJson: PackageLockJson): string[];

package/dist/lib/esm/package-lock-integrity.mjs

@@ -0,0 +1,99 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { existsSync } from "node:fs";
+import {
+  getPackageLockJsonPath,
+  readPackageLockJson
+} from "./npm.mjs";
+const MAX_REPORTED_KEYS = 5;
+const NODE_MODULES_SEGMENT = "node_modules/";
+const REGISTRY_RESOLVED_REG_EXP = /^https?:\/\//;
+async function assertPackageLockIntegrity(cwd) {
+  const packageLockJsonPath = getPackageLockJsonPath(cwd);
+  if (!existsSync(packageLockJsonPath)) {
+    return;
+  }
+  const keys = findPackageLockEntriesMissingIntegrity(await readPackageLockJson(cwd));
+  if (keys.length === 0) {
+    return;
+  }
+  const shownKeys = keys.slice(0, MAX_REPORTED_KEYS).map((key) => `  ${key}`);
+  const remainingCount = keys.length - shownKeys.length;
+  if (remainingCount > 0) {
+    shownKeys.push(`  ... and ${String(remainingCount)} more`);
+  }
+  throw new Error(
+    [
+      `${packageLockJsonPath}: ${String(keys.length)} installed package(s) have no \`resolved\` or no \`integrity\`, so \`npm ci\` cannot verify them:`,
+      ...shownKeys,
+      "npm never adds these fields back by itself, and regenerating the lock would change versions. Fill each entry from the registry",
+      "metadata for the version already locked: GET https://registry.npmjs.org/<name, with / written as %2f>/<version>, and copy",
+      "`dist.tarball` into `resolved` and `dist.integrity` into `integrity`. The name is the entry's `name` field, or else the text",
+      "after the key's last `node_modules/`. Then check that `npm install --package-lock-only` leaves the file byte-identical.",
+      "To skip this check for one run, set PACKAGE_LOCK_INTEGRITY=0."
+    ].join("\n")
+  );
+}
+function findPackageLockEntriesMissingIntegrity(packageLockJson) {
+  const keys = [];
+  for (const [key, value] of Object.entries(packageLockJson.packages ?? {})) {
+    const entry = value;
+    if (key === "" || !key.includes(NODE_MODULES_SEGMENT) || entry.link || entry.inBundle) {
+      continue;
+    }
+    if (entry.resolved === void 0 || entry.integrity === void 0 && REGISTRY_RESOLVED_REG_EXP.test(entry.resolved)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+export {
+  assertPackageLockIntegrity,
+  findPackageLockEntriesMissingIntegrity
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/package-manager.d.mts

@@ -0,0 +1,93 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Resolves locally-installed tool binaries and package-script runners without assuming `npm`.
+ *
+ * Delegating to `npx` silently assumes an npm-installed tree. On Windows that assumption is fatal under
+ * `bun`: `bun install` writes `node_modules/.bin/<tool>.exe`, not the `<tool>.cmd` that npm's `npx` looks
+ * for, so `npx` misses the local install entirely and downloads the tool from the registry instead — which
+ * for `tsc` is the well-known decoy package, not TypeScript. Resolving the shim from `node_modules/.bin`
+ * ourselves sidesteps the whole shim-format question, because every package manager writes one there.
+ */
+/**
+ * A package manager that can own a project's dependency tree.
+ */
+export declare enum PackageManager {
+    /**
+     * The `bun` package manager.
+     */
+    Bun = "bun",
+    /**
+     * The `npm` package manager.
+     */
+    Npm = "npm",
+    /**
+     * The `pnpm` package manager.
+     */
+    Pnpm = "pnpm",
+    /**
+     * The `yarn` package manager.
+     */
+    Yarn = "yarn"
+}
+/**
+ * Parameters for {@link resolveToolCommand}.
+ */
+export interface ResolveToolCommandParams {
+    /**
+     * The current working folder to resolve from.
+     */
+    readonly cwd?: string;
+    /**
+     * The name of the locally-installed tool, as it appears in `node_modules/.bin`.
+     */
+    readonly tool: string;
+}
+/**
+ * Determines which package manager owns the project's dependency tree.
+ *
+ * Every signal is collected before any of them is believed, because a repo carrying two lockfiles used to
+ * resolve to whichever sat earlier in a fixed list — silently reassigning every package script and every
+ * tool invocation to a manager that never installed the tree.
+ *
+ * The order is:
+ *
+ * 1. The `packageManager` field of `package.json`. It is a deliberate declaration by the repo's author
+ *    rather than an artifact left behind by whatever ran last, so it outranks every lockfile — and it is
+ *    the only signal that helps at all before the first install, when no lockfile exists yet.
+ * 2. The sole lockfile, when exactly one manager claims the tree.
+ * 3. Among several lockfiles, the manager that launched us (`npm_config_user_agent`), when it owns one of
+ *    them — a live signal beats a file that may have been abandoned mid-migration. Otherwise the
+ *    documented fallback order in {@link LOCKFILES} decides. Note this is deliberately NOT "the most
+ *    recently modified lockfile": a stray lockfile is typically the newest file, so mtime picks precisely
+ *    the wrong one.
+ * 4. `npm_config_user_agent` on its own, when there is no lockfile.
+ * 5. {@link PackageManager.Npm}.
+ *
+ * Whenever more than one manager claims the tree, the disagreement is reported once per project through
+ * {@link warnAboutSeveralClaimants} — the resolution stays deterministic, but it stops being silent.
+ *
+ * @param cwd - The current working folder to resolve from.
+ * @returns The detected package manager, or {@link PackageManager.Npm} when nothing indicates otherwise.
+ */
+export declare function getPackageManager(cwd?: string): PackageManager;
+/**
+ * Builds the command parts that run a package script through the manager that owns the tree.
+ *
+ * @param cwd - The current working folder to resolve from.
+ * @returns The command parts, e.g. `['bun', 'run']`. The script name is appended by the caller.
+ */
+export declare function getPackageManagerRunCommand(cwd?: string): string[];
+/**
+ * Builds the command parts that run a locally-installed tool, with the tool itself already included.
+ *
+ * Prefers the shim in the nearest `node_modules/.bin`, walking up through ancestor folders so a hoisted
+ * workspace install is still found. Falls back to the owning manager's exec form when no shim resolves —
+ * which is both the previous behavior and the only thing that works under yarn's Plug'n'Play, where
+ * `node_modules/.bin` does not exist at all.
+ *
+ * @param params - The parameters for the resolution.
+ * @returns The command parts, e.g. `['/project/node_modules/.bin/tsc']` or `['bun', 'x', 'tsc']`.
+ */
+export declare function resolveToolCommand(params: ResolveToolCommandParams): string[];