@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/fs.cjs

@@ -0,0 +1,123 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 fs_exports = {};
+__export(fs_exports, {
+  readdirPosix: () => readdirPosix
+});
+module.exports = __toCommonJS(fs_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_promises = require('node:fs/promises');
+async function readdirPosix(path, options = {}) {
+  if (isStringResultOptions(options)) {
+    const paths = await (0, import_promises.readdir)(path, options);
+    return paths.map((entryPath) => (0, import_path.toPosixPath)(entryPath));
+  }
+  if (isBufferResultOptions(options)) {
+    const buffers = await (0, import_promises.readdir)(path, options);
+    return buffers.map((buffer) => (0, import_path.toPosixBuffer)(buffer));
+  }
+  const dirents = await (0, import_promises.readdir)(path, options);
+  for (const dirent of dirents) {
+    dirent.name = (0, import_path.toPosixPath)(dirent.name);
+    dirent.parentPath = (0, import_path.toPosixPath)(dirent.parentPath);
+  }
+  return dirents;
+}
+function isBufferResultOptions(options) {
+  (0, import_type_guards.assertNonNullable)(options);
+  if (options === "buffer") {
+    return true;
+  }
+  const commonOptions = options;
+  return commonOptions.withFileTypes !== true && commonOptions.encoding === "buffer";
+}
+function isStringResultOptions(options) {
+  (0, import_type_guards.assertNonNullable)(options);
+  if (options === "buffer") {
+    return false;
+  }
+  const commonOptions = options;
+  return !(commonOptions.encoding === "buffer" || commonOptions.withFileTypes === true);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readdirPosix
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/fs.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for file system operations.\n */\n\nimport type {\n  Dirent,\n  ObjectEncodingOptions,\n  PathLike\n} from 'node:fs';\n\nimport {\n  toPosixBuffer,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { readdir } from 'node:fs/promises';\n\n/**\n * Options for controlling the format of the result when returning buffers.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.\n */\nexport type BufferResultOptions = 'buffer' | BufferResultObjectOptions;\n\n/**\n * Options for controlling the format of the result when returning Dirent objects.\n */\nexport type DirentResultOptions = DirentResultBaseOptions & ObjectEncodingOptions;\n\n/**\n * Options for controlling the format of the result when returning strings.\n */\nexport type StringResultOptions =\n  | ObjectEncodingOptions & StringResultBaseOptions\n  | undefined;\n\ninterface BufferResultObjectOptions {\n  /**\n   * Should be set to \"buffer\" to return buffers.\n   */\n  readonly encoding: 'buffer';\n\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `false` to return buffers.\n   */\n  readonly withFileTypes?: false;\n}\n\n/**\n * Common options for controlling the format of the result.\n */\ninterface CommonOptions {\n  /**\n   * Encoding to use when returning strings.\n   */\n  readonly encoding?: 'buffer' | NodeJS.BufferEncoding;\n\n  /**\n   * Set `true` to return Dirent objects or `false` to return strings or buffers.\n   */\n  readonly withFileTypes?: boolean;\n}\n\ninterface DirentResultBaseOptions {\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `true` to return Dirent objects.\n   */\n  readonly withFileTypes: true;\n}\n\ninterface StringResultBaseOptions {\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `false` to return strings.\n   */\n  readonly withFileTypes?: false;\n}\n\n/**\n * Reads the contents of a directory and returns an array of strings with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. If not provided, returns strings.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.\n */\nexport async function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;\n/**\n * Reads the contents of a directory and returns an array of buffers with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify \"buffer\" to return buffers.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.\n */\nexport async function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;\n/**\n * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.\n */\nexport async function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;\n/**\n * Reads the contents of a directory and converts file paths or buffer results to POSIX format.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths, buffers, or Dirent objects.\n */\nexport async function readdirPosix(\n  path: PathLike,\n  options: BufferResultOptions | DirentResultOptions | StringResultOptions = {}\n): Promise<Buffer[] | Dirent[] | string[]> {\n  if (isStringResultOptions(options)) {\n    const paths = await readdir(path, options);\n    return paths.map((entryPath) => toPosixPath(entryPath));\n  }\n\n  if (isBufferResultOptions(options)) {\n    const buffers = await readdir(path, options);\n    return buffers.map((buffer) => toPosixBuffer(buffer));\n  }\n\n  const dirents = await readdir(path, options);\n  for (const dirent of dirents) {\n    dirent.name = toPosixPath(dirent.name);\n    dirent.parentPath = toPosixPath(dirent.parentPath);\n  }\n\n  return dirents;\n}\n\n/**\n * Type guard to check if the options are for returning buffers.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning buffers, otherwise `false`.\n */\nfunction isBufferResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is BufferResultOptions {\n  assertNonNullable(options);\n\n  if (options === 'buffer') {\n    return true;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  // The encoding check never fails in practice: isStringResultOptions already handles non-buffer encoding before this is called.\n  return commonOptions.withFileTypes !== true && commonOptions.encoding === 'buffer';\n}\n\n/**\n * Type guard to check if the options are for returning strings.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning strings, otherwise `false`.\n */\nfunction isStringResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is StringResultOptions {\n  assertNonNullable(options);\n\n  if (options === 'buffer') {\n    return false;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  return !((commonOptions.encoding === 'buffer') || (commonOptions.withFileTypes === true));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,kBAGO;AACP,yBAAkC;AAClC,sBAAwB;AA4GxB,eAAsB,aACpB,MACA,UAA2E,CAAC,GACnC;AACzC,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,QAAQ,UAAM,yBAAQ,MAAM,OAAO;AACzC,WAAO,MAAM,IAAI,CAAC,kBAAc,yBAAY,SAAS,CAAC;AAAA,EACxD;AAEA,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,UAAU,UAAM,yBAAQ,MAAM,OAAO;AAC3C,WAAO,QAAQ,IAAI,CAAC,eAAW,2BAAc,MAAM,CAAC;AAAA,EACtD;AAEA,QAAM,UAAU,UAAM,yBAAQ,MAAM,OAAO;AAC3C,aAAW,UAAU,SAAS;AAC5B,WAAO,WAAO,yBAAY,OAAO,IAAI;AACrC,WAAO,iBAAa,yBAAY,OAAO,UAAU;AAAA,EACnD;AAEA,SAAO;AACT;AAQA,SAAS,sBAAsB,SAA0G;AACvI,4CAAkB,OAAO;AAEzB,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAGtB,SAAO,cAAc,kBAAkB,QAAQ,cAAc,aAAa;AAC5E;AAQA,SAAS,sBAAsB,SAA0G;AACvI,4CAAkB,OAAO;AAEzB,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,SAAO,EAAG,cAAc,aAAa,YAAc,cAAc,kBAAkB;AACrF;",
  "names": []
}


package/dist/lib/cjs/fs.d.cts

@@ -0,0 +1,80 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Contains utility functions for file system operations.
+ */
+import type { Dirent, ObjectEncodingOptions, PathLike } from 'node:fs' with { 'resolution-mode': 'import' };
+/**
+ * Options for controlling the format of the result when returning buffers.
+ *
+ * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.
+ */
+export type BufferResultOptions = 'buffer' | BufferResultObjectOptions;
+/**
+ * Options for controlling the format of the result when returning Dirent objects.
+ */
+export type DirentResultOptions = DirentResultBaseOptions & ObjectEncodingOptions;
+/**
+ * Options for controlling the format of the result when returning strings.
+ */
+export type StringResultOptions = ObjectEncodingOptions & StringResultBaseOptions | undefined;
+interface BufferResultObjectOptions {
+    /**
+     * Should be set to "buffer" to return buffers.
+     */
+    readonly encoding: 'buffer';
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return buffers.
+     */
+    readonly withFileTypes?: false;
+}
+interface DirentResultBaseOptions {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `true` to return Dirent objects.
+     */
+    readonly withFileTypes: true;
+}
+interface StringResultBaseOptions {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return strings.
+     */
+    readonly withFileTypes?: false;
+}
+/**
+ * Reads the contents of a directory and returns an array of strings with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. If not provided, returns strings.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.
+ */
+export declare function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;
+/**
+ * Reads the contents of a directory and returns an array of buffers with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify "buffer" to return buffers.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.
+ */
+export declare function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;
+/**
+ * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.
+ */
+export declare function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;
+export {};

package/dist/lib/cjs/gate.cjs

@@ -0,0 +1,140 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 gate_exports = {};
+__export(gate_exports, {
+  gate: () => gate,
+  parseGateArguments: () => parseGateArguments
+});
+module.exports = __toCommonJS(gate_exports);
+var import_node_util = require('node:util');
+var import_env_toggle = require('./env-toggle.cjs');
+var import_npm_run = require('./npm-run.cjs');
+var import_package_lock_integrity = require('./package-lock-integrity.cjs');
+const PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE = "PACKAGE_LOCK_INTEGRITY";
+async function gate(options = {}) {
+  const {
+    shouldBuild = true,
+    shouldRunChecks = true,
+    shouldRunIntegrationTests = false
+  } = options;
+  if (shouldRunChecks) {
+    if (!(0, import_env_toggle.isEnvVariableOff)(PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE)) {
+      await (0, import_package_lock_integrity.assertPackageLockIntegrity)();
+    }
+    await (0, import_npm_run.npmRunOptional)("format:check");
+    await (0, import_npm_run.npmRunOptional)("spellcheck");
+    await (0, import_npm_run.npmRunOptional)("lint:md");
+  }
+  if (shouldBuild) {
+    await (0, import_npm_run.npmRun)("build");
+  }
+  if (!shouldRunChecks) {
+    return;
+  }
+  await (0, import_npm_run.npmRunOptional)("lint");
+  await (0, import_npm_run.npmRunOptional)("find-overexposed");
+  if (await (0, import_npm_run.npmRunOptional)("test:coverage") === import_npm_run.NpmRunOptionalResult.Skipped) {
+    await (0, import_npm_run.npmRunOptional)("test");
+  }
+  if (shouldRunIntegrationTests) {
+    await (0, import_npm_run.npmRunOptional)("test:integration");
+  }
+}
+function parseGateArguments($arguments) {
+  const { values } = (0, import_node_util.parseArgs)({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.
+    args: $arguments,
+    options: {
+      "integration": { type: "boolean" },
+      "no-build": { type: "boolean" },
+      "no-checks": { type: "boolean" }
+    }
+  });
+  return {
+    shouldBuild: !(values["no-build"] ?? false),
+    shouldRunChecks: !(values["no-checks"] ?? false),
+    shouldRunIntegrationTests: values.integration ?? false
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gate,
+  parseGateArguments
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/gate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The branch gate: the verification sequence that `updateVersion` runs as its release preflight, available\n * as a command of its own.\n *\n * Four of the preflight's checks \u2014 `format:check`, `spellcheck`, `find-overexposed` and `test:coverage` \u2014\n * are reachable by no other routine command. So the natural branch gate (build, lint, test) can be green\n * while the release is still going to fail, and the failure arrives at release time rather than in seconds\n * on the branch.\n *\n * This module exists so the two are the same code rather than two lists that agree today: `updateVersion`\n * calls {@link gate}, and a check added here is reachable from both. What the gate deliberately leaves to\n * the release path is the clean-repo assertion \u2014 a branch gate is run on a dirty tree, which is the whole\n * point of running it before committing \u2014 and the integration suite, which is the one preflight step that\n * already has a routine command of its own (`npm run test:integration`) and so is not in the class this\n * module exists for.\n *\n * The tests run ONCE, through `test:coverage` where the project defines it and through `test` otherwise.\n * Running both, as this did until 2026-09-05, was a duplicate everywhere it mattered: a project scopes its\n * two test scripts to the same vitest projects \u2014 every repo in this workspace passes the same `projects`\n * array to both \u2014 so `test:coverage` is `test` plus the threshold flags, over the identical files. It buys\n * no fail-fast either, because the coverage run fails on exactly the failures the plain run would have\n * caught. The one thing lost is the ability to switch off only the coverage half: `TEST_COVERAGE=0` now\n * turns off the gate's whole test step rather than demoting it to `test`.\n */\n\nimport { parseArgs } from 'node:util';\n\nimport { isEnvVariableOff } from './env-toggle.ts';\nimport {\n  npmRun,\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { assertPackageLockIntegrity } from './package-lock-integrity.ts';\n\n/**\n * The off switch for the lockfile check. The check is no npm script, so npm cannot derive a switch from a\n * script name for it, but the name follows the same pattern.\n */\nconst PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE = 'PACKAGE_LOCK_INTEGRITY';\n\n/**\n * Options for {@link gate}.\n */\nexport interface GateOptions {\n  /**\n   * Whether to run the build. The build is not a verification check \u2014 it is kept in the gate because it is\n   * the only step that type-checks the project, and a green lint is not a type-check.\n   *\n   * @default `true`\n   */\n  readonly shouldBuild?: boolean;\n\n  /**\n   * Whether to run the verification checks. When `false`, only the build runs, which is what\n   * `npm run version -- --no-checks` does.\n   *\n   * @default `true`\n   */\n  readonly shouldRunChecks?: boolean;\n\n  /**\n   * Whether to run the integration test suite. Off by default, on two reasons that are about COST rather\n   * than about contention \u2014 desktop runs stopped contending in `obsidian-integration-testing` 5.0.0, which\n   * gives every run its own user-data dir and CDP port, and the Android emulator that is still shared is\n   * serialized by that package's own `android` setup lock, which waits rather than failing.\n   *\n   * The reasons that do hold: `test:integration` is the one preflight step reachable by a routine command\n   * of its own, unlike the four this gate exists for; and in a project whose suite includes an Android\n   * test it boots an AVD and an Appium server, then queues behind any other Android run for up to that\n   * lock's hour-long acquisition timeout. A command whose whole selling point is answering in seconds must\n   * not start one unasked. The release path opts in, so nothing is skipped before a publish.\n   *\n   * @default `false`\n   */\n  readonly shouldRunIntegrationTests?: boolean;\n}\n\n/**\n * Runs the verification sequence that `npm run version` runs as its preflight.\n *\n * The order is deliberate. The lockfile check ({@link assertPackageLockIntegrity}) comes first, because it\n * is an in-process JSON read that takes well under a second. Then come the checks that finish in seconds (`format:check`, `spellcheck`, `lint:md`) run\n * first, so a typo fails the gate immediately instead of after the coverage run. Each step is dispatched\n * through the package manager, so a project overriding one of these scripts gets its own version, and each\n * step carries its own environment off switch.\n *\n * Every step but `build` is run with {@link npmRunOptional}, so it is skipped when the project does not define\n * it: a project that chose no formatter, spell checker, markdown linter or linter has nothing to check there,\n * and requiring those scripts made `npm run version` die on its first step in exactly those projects. `build`\n * stays required, because a release with nothing built has nothing to ship. The test step is the one place that reads that skip: `test:coverage` is preferred, and\n * `test` runs only as its fallback, so the suite is never run twice. The unit tests stay ahead of\n * `test:integration` for the same fastest-first reason \u2014 a broken unit test should fail before an\n * integration suite is started, not after.\n *\n * @param options - The {@link GateOptions} controlling which steps run.\n * @returns A {@link Promise} that resolves when every step has passed.\n */\nexport async function gate(options: GateOptions = {}): Promise<void> {\n  const {\n    shouldBuild = true,\n    shouldRunChecks = true,\n    shouldRunIntegrationTests = false\n  } = options;\n\n  if (shouldRunChecks) {\n    if (!isEnvVariableOff(PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE)) {\n      await assertPackageLockIntegrity();\n    }\n\n    await npmRunOptional('format:check');\n    await npmRunOptional('spellcheck');\n    await npmRunOptional('lint:md');\n  }\n\n  if (shouldBuild) {\n    await npmRun('build');\n  }\n\n  if (!shouldRunChecks) {\n    return;\n  }\n\n  await npmRunOptional('lint');\n  await npmRunOptional('find-overexposed');\n\n  if (await npmRunOptional('test:coverage') === NpmRunOptionalResult.Skipped) {\n    await npmRunOptional('test');\n  }\n\n  if (shouldRunIntegrationTests) {\n    await npmRunOptional('test:integration');\n  }\n}\n\n/**\n * Parses the command-line arguments for the gate script.\n *\n * The two `--no-` flags switch off steps that are on; `--integration` is the one that switches a step ON,\n * because {@link GateOptions.shouldRunIntegrationTests} is off by default for cost. It exists so that\n * default is a choice the caller can make per run rather than one only a programmatic caller can reach.\n *\n * @param $arguments - The command-line arguments to parse.\n * @returns The parsed {@link GateOptions}.\n */\nexport function parseGateArguments($arguments: string[]): GateOptions {\n  const { values } = parseArgs({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: {\n      'integration': { type: 'boolean' },\n      'no-build': { type: 'boolean' },\n      'no-checks': { type: 'boolean' }\n    }\n  });\n\n  return {\n    shouldBuild: !(values['no-build'] ?? false),\n    shouldRunChecks: !(values['no-checks'] ?? false),\n    shouldRunIntegrationTests: values.integration ?? false\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,uBAA0B;AAE1B,wBAAiC;AACjC,qBAIO;AACP,oCAA2C;AAM3C,MAAM,sCAAsC;AA2D5C,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM;AAAA,IACJ,cAAc;AAAA,IACd,kBAAkB;AAAA,IAClB,4BAA4B;AAAA,EAC9B,IAAI;AAEJ,MAAI,iBAAiB;AACnB,QAAI,KAAC,oCAAiB,mCAAmC,GAAG;AAC1D,gBAAM,0DAA2B;AAAA,IACnC;AAEA,cAAM,+BAAe,cAAc;AACnC,cAAM,+BAAe,YAAY;AACjC,cAAM,+BAAe,SAAS;AAAA,EAChC;AAEA,MAAI,aAAa;AACf,cAAM,uBAAO,OAAO;AAAA,EACtB;AAEA,MAAI,CAAC,iBAAiB;AACpB;AAAA,EACF;AAEA,YAAM,+BAAe,MAAM;AAC3B,YAAM,+BAAe,kBAAkB;AAEvC,MAAI,UAAM,+BAAe,eAAe,MAAM,oCAAqB,SAAS;AAC1E,cAAM,+BAAe,MAAM;AAAA,EAC7B;AAEA,MAAI,2BAA2B;AAC7B,cAAM,+BAAe,kBAAkB;AAAA,EACzC;AACF;AAYO,SAAS,mBAAmB,YAAmC;AACpE,QAAM,EAAE,OAAO,QAAI,4BAAU;AAAA;AAAA,IAE3B,MAAM;AAAA,IACN,SAAS;AAAA,MACP,eAAe,EAAE,MAAM,UAAU;AAAA,MACjC,YAAY,EAAE,MAAM,UAAU;AAAA,MAC9B,aAAa,EAAE,MAAM,UAAU;AAAA,IACjC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,aAAa,EAAE,OAAO,UAAU,KAAK;AAAA,IACrC,iBAAiB,EAAE,OAAO,WAAW,KAAK;AAAA,IAC1C,2BAA2B,OAAO,eAAe;AAAA,EACnD;AACF;",
  "names": []
}


package/dist/lib/cjs/gate.d.cts

@@ -0,0 +1,93 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The branch gate: the verification sequence that `updateVersion` runs as its release preflight, available
+ * as a command of its own.
+ *
+ * Four of the preflight's checks — `format:check`, `spellcheck`, `find-overexposed` and `test:coverage` —
+ * are reachable by no other routine command. So the natural branch gate (build, lint, test) can be green
+ * while the release is still going to fail, and the failure arrives at release time rather than in seconds
+ * on the branch.
+ *
+ * This module exists so the two are the same code rather than two lists that agree today: `updateVersion`
+ * calls {@link gate}, and a check added here is reachable from both. What the gate deliberately leaves to
+ * the release path is the clean-repo assertion — a branch gate is run on a dirty tree, which is the whole
+ * point of running it before committing — and the integration suite, which is the one preflight step that
+ * already has a routine command of its own (`npm run test:integration`) and so is not in the class this
+ * module exists for.
+ *
+ * The tests run ONCE, through `test:coverage` where the project defines it and through `test` otherwise.
+ * Running both, as this did until 2026-09-05, was a duplicate everywhere it mattered: a project scopes its
+ * two test scripts to the same vitest projects — every repo in this workspace passes the same `projects`
+ * array to both — so `test:coverage` is `test` plus the threshold flags, over the identical files. It buys
+ * no fail-fast either, because the coverage run fails on exactly the failures the plain run would have
+ * caught. The one thing lost is the ability to switch off only the coverage half: `TEST_COVERAGE=0` now
+ * turns off the gate's whole test step rather than demoting it to `test`.
+ */
+/**
+ * Options for {@link gate}.
+ */
+export interface GateOptions {
+    /**
+     * Whether to run the build. The build is not a verification check — it is kept in the gate because it is
+     * the only step that type-checks the project, and a green lint is not a type-check.
+     *
+     * @default `true`
+     */
+    readonly shouldBuild?: boolean;
+    /**
+     * Whether to run the verification checks. When `false`, only the build runs, which is what
+     * `npm run version -- --no-checks` does.
+     *
+     * @default `true`
+     */
+    readonly shouldRunChecks?: boolean;
+    /**
+     * Whether to run the integration test suite. Off by default, on two reasons that are about COST rather
+     * than about contention — desktop runs stopped contending in `obsidian-integration-testing` 5.0.0, which
+     * gives every run its own user-data dir and CDP port, and the Android emulator that is still shared is
+     * serialized by that package's own `android` setup lock, which waits rather than failing.
+     *
+     * The reasons that do hold: `test:integration` is the one preflight step reachable by a routine command
+     * of its own, unlike the four this gate exists for; and in a project whose suite includes an Android
+     * test it boots an AVD and an Appium server, then queues behind any other Android run for up to that
+     * lock's hour-long acquisition timeout. A command whose whole selling point is answering in seconds must
+     * not start one unasked. The release path opts in, so nothing is skipped before a publish.
+     *
+     * @default `false`
+     */
+    readonly shouldRunIntegrationTests?: boolean;
+}
+/**
+ * Runs the verification sequence that `npm run version` runs as its preflight.
+ *
+ * The order is deliberate. The lockfile check ({@link assertPackageLockIntegrity}) comes first, because it
+ * is an in-process JSON read that takes well under a second. Then come the checks that finish in seconds (`format:check`, `spellcheck`, `lint:md`) run
+ * first, so a typo fails the gate immediately instead of after the coverage run. Each step is dispatched
+ * through the package manager, so a project overriding one of these scripts gets its own version, and each
+ * step carries its own environment off switch.
+ *
+ * Every step but `build` is run with {@link npmRunOptional}, so it is skipped when the project does not define
+ * it: a project that chose no formatter, spell checker, markdown linter or linter has nothing to check there,
+ * and requiring those scripts made `npm run version` die on its first step in exactly those projects. `build`
+ * stays required, because a release with nothing built has nothing to ship. The test step is the one place that reads that skip: `test:coverage` is preferred, and
+ * `test` runs only as its fallback, so the suite is never run twice. The unit tests stay ahead of
+ * `test:integration` for the same fastest-first reason — a broken unit test should fail before an
+ * integration suite is started, not after.
+ *
+ * @param options - The {@link GateOptions} controlling which steps run.
+ * @returns A {@link Promise} that resolves when every step has passed.
+ */
+export declare function gate(options?: GateOptions): Promise<void>;
+/**
+ * Parses the command-line arguments for the gate script.
+ *
+ * The two `--no-` flags switch off steps that are on; `--integration` is the one that switches a step ON,
+ * because {@link GateOptions.shouldRunIntegrationTests} is off by default for cost. It exists so that
+ * default is a choice the caller can make per run rather than one only a programmatic caller can reach.
+ *
+ * @param $arguments - The command-line arguments to parse.
+ * @returns The parsed {@link GateOptions}.
+ */
+export declare function parseGateArguments($arguments: string[]): GateOptions;

package/dist/lib/cjs/git.cjs

@@ -0,0 +1,109 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 git_exports = {};
+__export(git_exports, {
+  getNonIgnoredFiles: () => getNonIgnoredFiles
+});
+module.exports = __toCommonJS(git_exports);
+var import_root = require('./root.cjs');
+const NUL_SEPARATOR = "\0";
+async function getNonIgnoredFiles(options) {
+  const { patterns = [] } = options ?? {};
+  const command = [
+    "git",
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    ...patterns.length > 0 ? ["--", ...patterns] : []
+  ];
+  let stdout;
+  try {
+    stdout = await (0, import_root.execFromRoot)(command, { isQuiet: true });
+  } catch {
+    return null;
+  }
+  return [...new Set(stdout.split(NUL_SEPARATOR).filter((path) => path !== ""))];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNonIgnoredFiles
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/git.d.cts

@@ -0,0 +1,37 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Git-derived file listings for the repo-walking scripts.
+ *
+ * Tooling that walks the repository must skip whatever `.gitignore` skips — otherwise every script grows its
+ * own hand-maintained ignore list, the lists drift apart, and a path that is gitignored but not enumerated
+ * (a nested `node_modules` under a test fixture, say) is walked anyway. Most tools have a native switch for
+ * this; the ones that do not take a file list instead, and that is what this module produces.
+ *
+ * Asking git rather than parsing `.gitignore` is deliberate: it honors nested ignore files, `!` negations,
+ * `.git/info/exclude`, and the user's global excludes, at no cost to us.
+ */
+/**
+ * Options for {@link getNonIgnoredFiles}.
+ */
+export interface GetNonIgnoredFilesOptions {
+    /**
+     * Git pathspecs limiting the listing, e.g. `['*.md']`. When omitted, every non-ignored file is listed.
+     *
+     * @default `[]`
+     */
+    readonly patterns?: readonly string[] | undefined;
+}
+/**
+ * Lists the repository files that `.gitignore` does not exclude.
+ *
+ * Covers both tracked files and untracked-but-not-ignored ones, so a brand-new file is checked before it is
+ * ever committed.
+ *
+ * @param options - The {@link GetNonIgnoredFilesOptions}.
+ * @returns A {@link Promise} that resolves with the matching paths, relative to the root folder and
+ * separated by `/`; or with `null` when git cannot answer — it is not installed, or the project is not a
+ * git repository (a tarball checkout, for instance). Callers fall back to their own listing in that case.
+ */
+export declare function getNonIgnoredFiles(options?: GetNonIgnoredFilesOptions): Promise<null | string[]>;