versionary 0.28.0 → 0.28.2

package/dist/release/release.js

@@ -1,40 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTargetPackageName = resolveTargetPackageName;
-exports.extractReleaseNotes = extractReleaseNotes;
-exports.extractClosingReferencesFromNotes = extractClosingReferencesFromNotes;
-exports.resolveTargetChangelogFile = resolveTargetChangelogFile;
-exports.runRelease = runRelease;
-exports.runReleaseDetailed = runReleaseDetailed;
-exports.runSimpleRelease = runSimpleRelease;
-exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
-const client_js_1 = require("../scm/client.js");
-const package_context_js_1 = require("../strategy/package-context.js");
-const resolve_js_1 = require("../strategy/resolve.js");
-const plan_js_1 = require("./plan.js");
-const pr_js_1 = require("./pr.js");
-const recovery_js_1 = require("./recovery.js");
-const state_js_1 = require("./state.js");
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
+import { getScmClient } from "../scm/client.js";
+import { resolvePackageStrategyContext, resolveReleaseName, } from "../strategy/package-context.js";
+import { resolveVersionStrategy } from "../strategy/resolve.js";
+import { getChangelogDefaults } from "./plan.js";
+import { isReleaseCommitMessage } from "./pr.js";
+import { executeIdempotentReleaseTarget } from "./recovery.js";
+import { readReleaseTargets } from "./state.js";
 function escapeRegExp(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function resolveTargetPackageName(cwd, config, targetPath) {
+export function resolveTargetPackageName(cwd, config, targetPath) {
     const packageConfig = config.packages?.[targetPath] ?? {};
-    const { strategy, config: strategyConfig } = (0, package_context_js_1.resolvePackageStrategyContext)(config, targetPath, packageConfig);
-    const resolved = (0, package_context_js_1.resolveReleaseName)(cwd, targetPath, packageConfig, strategy, strategyConfig);
+    const { strategy, config: strategyConfig } = resolvePackageStrategyContext(config, targetPath, packageConfig);
+    const resolved = resolveReleaseName(cwd, targetPath, packageConfig, strategy, strategyConfig);
     if (!resolved || resolved === targetPath) {
         return undefined;
     }
     return resolved;
 }
-function extractReleaseNotes(content, version, changelogFormat) {
+export function extractReleaseNotes(content, version, changelogFormat) {
     const lines = content.split("\n");
     const shortVersion = version.replace(/\.\d+$/u, "");
     const start = changelogFormat === "r-news"
@@ -72,22 +59,22 @@ function extractReleaseNotes(content, version, changelogFormat) {
         .trim();
 }
 function getHeadCommitMessage(cwd) {
-    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
+    return execFileSync("git", ["log", "-1", "--pretty=%B"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
 function readReleaseNotes(cwd, version, changelogFile, changelogFormat) {
-    const changelogPath = node_path_1.default.join(cwd, changelogFile);
-    if (!node_fs_1.default.existsSync(changelogPath)) {
+    const changelogPath = path.join(cwd, changelogFile);
+    if (!fs.existsSync(changelogPath)) {
         return `Automated release for v${version}`;
     }
-    const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
+    const content = fs.readFileSync(changelogPath, "utf8");
     const notes = extractReleaseNotes(content, version, changelogFormat);
     return notes.length > 0 ? notes : `Automated release for v${version}`;
 }
-function extractClosingReferencesFromNotes(notes) {
+export function extractClosingReferencesFromNotes(notes) {
     const refs = new Set();
     const linkedPattern = /\b(close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b\s+\[#(\d+)\]\([^)]+\)/giu;
     for (const match of notes.matchAll(linkedPattern)) {
@@ -105,30 +92,30 @@ function extractClosingReferencesFromNotes(notes) {
     }
     return [...refs].sort((a, b) => a - b);
 }
-function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
+export function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
     if (targetPath === ".") {
         return rootChangelogFile;
     }
     const packageConfig = config.packages?.[targetPath];
-    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+    const packageStrategy = resolveVersionStrategy({
         ...config,
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
     });
-    const { changelogFile: packageChangelogFile } = (0, plan_js_1.getChangelogDefaults)({
+    const { changelogFile: packageChangelogFile } = getChangelogDefaults({
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
         "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
         "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
         defaultChangelogFormat: packageStrategy.getDefaultChangelogFormat?.(),
     });
-    return node_path_1.default.posix.join(targetPath, packageChangelogFile);
+    return path.posix.join(targetPath, packageChangelogFile);
 }
 function resolveTargetChangelogFormat(config, targetPath) {
     const packageConfig = config.packages?.[targetPath];
-    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+    const packageStrategy = resolveVersionStrategy({
         ...config,
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
     });
-    const { changelogFormat } = (0, plan_js_1.getChangelogDefaults)({
+    const { changelogFormat } = getChangelogDefaults({
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
         "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
         "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
@@ -136,31 +123,31 @@ function resolveTargetChangelogFormat(config, targetPath) {
     });
     return changelogFormat;
 }
-async function runRelease(cwd = process.cwd()) {
+export async function runRelease(cwd = process.cwd()) {
     const result = await runReleaseDetailed(cwd, { logger: console });
     if (result.action === "release-skipped") {
         return result.reason;
     }
     return result.message;
 }
-async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
+export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     const commitMessage = getHeadCommitMessage(cwd);
-    if (!(0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
+    if (!isReleaseCommitMessage(commitMessage)) {
         return {
             action: "release-skipped",
             reason: "No release commit context detected; skipping release stage.",
         };
     }
-    const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
-    const { changelogFile } = (0, plan_js_1.getChangelogDefaults)({
+    const loaded = loadConfig(cwd);
+    const strategy = resolveVersionStrategy(loaded.config);
+    const { changelogFile } = getChangelogDefaults({
         ...loaded.config,
         defaultChangelogFormat: strategy.getDefaultChangelogFormat?.(),
     });
     const referenceCommentMode = loaded.config["release-reference-comments"] ?? "off";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
+    const releaseTargets = readReleaseTargets(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
         : [
@@ -181,7 +168,7 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             message: `Dry run: would publish releases ${targetList.join(", ")}`,
         };
     }
-    const scmClient = (0, client_js_1.getScmClient)();
+    const scmClient = getScmClient();
     const releases = [];
     const referenceReleases = [];
     for (const target of targets) {
@@ -189,7 +176,7 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
         const targetChangelogFormat = resolveTargetChangelogFormat(loaded.config, target.path);
         const releaseNotes = readReleaseNotes(cwd, target.version, targetChangelogFile, targetChangelogFormat);
         const references = extractClosingReferencesFromNotes(releaseNotes);
-        const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
+        const outcome = await executeIdempotentReleaseTarget(cwd, {
             tag: target.tag,
             version: target.version,
             notes: releaseNotes,
@@ -237,10 +224,10 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     };
 }
 /** @deprecated Use runRelease. */
-async function runSimpleRelease(cwd = process.cwd()) {
+export async function runSimpleRelease(cwd = process.cwd()) {
     return runRelease(cwd);
 }
 /** @deprecated Use runReleaseDetailed. */
-async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
+export async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     return runReleaseDetailed(cwd, options);
 }

package/dist/release/semver.js

@@ -1,11 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxReleaseType = maxReleaseType;
-exports.parseVersion = parseVersion;
-exports.isValidVersion = isValidVersion;
-exports.compareVersions = compareVersions;
-exports.bumpVersion = bumpVersion;
-function maxReleaseType(types) {
+export function maxReleaseType(types) {
     if (types.includes("major")) {
         return "major";
     }
@@ -28,7 +21,7 @@ function normalizeVersionInput(version) {
     const [, major, minor, patch, prerelease] = compatMatch;
     return `${major}.${minor}.${patch}-${prerelease}`;
 }
-function parseVersion(version) {
+export function parseVersion(version) {
     const normalized = normalizeVersionInput(version);
     const match = normalized.match(SEMVER_PATTERN);
     if (!match) {
@@ -42,7 +35,7 @@ function parseVersion(version) {
         build: match[5] ? match[5].split(".") : [],
     };
 }
-function isValidVersion(version) {
+export function isValidVersion(version) {
     return SEMVER_PATTERN.test(normalizeVersionInput(version));
 }
 function isNumericIdentifier(identifier) {
@@ -76,7 +69,7 @@ function comparePreReleaseIdentifiers(left, right) {
     }
     return 0;
 }
-function compareVersions(leftRaw, rightRaw) {
+export function compareVersions(leftRaw, rightRaw) {
     const left = parseVersion(leftRaw);
     const right = parseVersion(rightRaw);
     if (left.major !== right.major) {
@@ -116,7 +109,7 @@ function compareVersions(leftRaw, rightRaw) {
     }
     return 0;
 }
-function bumpVersion(current, releaseType, options = {}) {
+export function bumpVersion(current, releaseType, options = {}) {
     const parsed = parseVersion(current);
     const allowStableMajor = options.allowStableMajor ?? false;
     if (releaseType === "major") {

package/dist/release/state.js

@@ -1,16 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBaselineStatePath = getBaselineStatePath;
-exports.readBaselineSha = readBaselineSha;
-exports.readReleaseTargets = readReleaseTargets;
-exports.writeBaselineSha = writeBaselineSha;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";
@@ -47,48 +38,48 @@ function parseStateFile(raw, filePath) {
     }
     return manifest;
 }
-function getBaselineStatePath(cwd) {
-    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+export function getBaselineStatePath(cwd) {
+    const loaded = loadConfig(cwd);
     const configured = loaded.config["baseline-file"];
     if (configured) {
-        return node_path_1.default.join(cwd, configured);
+        return path.join(cwd, configured);
     }
-    const preferred = node_path_1.default.join(cwd, ".versionary-manifest.json");
-    if (node_fs_1.default.existsSync(preferred)) {
+    const preferred = path.join(cwd, ".versionary-manifest.json");
+    if (fs.existsSync(preferred)) {
         return preferred;
     }
-    const legacy = node_path_1.default.join(cwd, "versionary.versions.json");
-    if (node_fs_1.default.existsSync(legacy)) {
+    const legacy = path.join(cwd, "versionary.versions.json");
+    if (fs.existsSync(legacy)) {
         return legacy;
     }
     return preferred;
 }
-function readBaselineSha(cwd = process.cwd()) {
+export function readBaselineSha(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
-    if (!node_fs_1.default.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
         return null;
     }
-    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[BASELINE_SHA_KEY] ?? null;
 }
-function readReleaseTargets(cwd = process.cwd()) {
+export function readReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
-    if (!node_fs_1.default.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
         return [];
     }
-    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
-function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
+export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
-        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+        execFileSync("git", ["rev-parse", "HEAD"], {
             cwd,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     const filePath = getBaselineStatePath(cwd);
-    const existing = node_fs_1.default.existsSync(filePath)
-        ? parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath)
+    const existing = fs.existsSync(filePath)
+        ? parseStateFile(fs.readFileSync(filePath, "utf8"), filePath)
         : {};
     const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
     const nextTargets = releaseTargets === undefined
@@ -104,5 +95,5 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
         [BASELINE_SHA_KEY]: baselineShaValue,
         [RELEASE_TARGETS_KEY]: nextTargets,
     };
-    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/release/verify-project.js

@@ -1,26 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = verifyProject;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
-const package_context_js_1 = require("../strategy/package-context.js");
-const resolve_js_1 = require("../strategy/resolve.js");
-function verifyProject(cwd = process.cwd()) {
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
+import { resolvePackageStrategyContext } from "../strategy/package-context.js";
+import { resolveVersionStrategy } from "../strategy/resolve.js";
+export function verifyProject(cwd = process.cwd()) {
     const checks = [];
-    const config = (0, load_config_js_1.loadConfig)(cwd);
+    const config = loadConfig(cwd);
     checks.push({
         name: "config-load",
         ok: true,
-        details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
+        details: `Loaded ${path.basename(config.path)} (${config.format})`,
         category: "config",
     });
-    const strategy = (0, resolve_js_1.resolveVersionStrategy)(config.config);
+    const strategy = resolveVersionStrategy(config.config);
     const versionFile = strategy.getVersionFile(config.config);
-    const exists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, versionFile));
+    const exists = fs.existsSync(path.join(cwd, versionFile));
     checks.push({
         name: `version-file:${versionFile}`,
         ok: exists,
@@ -44,8 +38,8 @@ function verifyProject(cwd = process.cwd()) {
     }
     if (config.config.packages) {
         for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
-            const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
-            const exists = node_fs_1.default.existsSync(pkgPath);
+            const pkgPath = path.join(cwd, pkgPathRaw);
+            const exists = fs.existsSync(pkgPath);
             checks.push({
                 name: `package-path:${pkgPathRaw}`,
                 ok: exists,
@@ -56,9 +50,9 @@ function verifyProject(cwd = process.cwd()) {
                     : `Create ${pkgPathRaw} or remove/rename this entry under "packages" in versionary config.`,
             });
             if (exists) {
-                const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
+                const packageContext = resolvePackageStrategyContext(config.config, pkgPathRaw, packageConfig);
                 const packageVersionFile = packageContext.versionFile;
-                const packageVersionExists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, packageVersionFile));
+                const packageVersionExists = fs.existsSync(path.join(cwd, packageVersionFile));
                 checks.push({
                     name: `version-file:${packageVersionFile}`,
                     ok: packageVersionExists,

package/dist/scm/capabilities.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginHasCapability = pluginHasCapability;
-exports.findPluginsByCapability = findPluginsByCapability;
-function pluginHasCapability(plugin, capability) {
+export function pluginHasCapability(plugin, capability) {
     return plugin.capabilities.includes(capability);
 }
-function findPluginsByCapability(plugins, capability) {
+export function findPluginsByCapability(plugins, capability) {
     return plugins.filter((plugin) => pluginHasCapability(plugin, capability));
 }

package/dist/scm/client.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScmClient = getScmClient;
-const github_plugin_js_1 = require("./github-plugin.js");
-function getScmClient() {
-    return (0, github_plugin_js_1.createGitHubPlugin)();
+import { createGitHubPlugin } from "./github-plugin.js";
+export function getScmClient() {
+    return createGitHubPlugin();
 }

package/dist/scm/github-plugin.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGitHubPlugin = createGitHubPlugin;
-const rest_1 = require("@octokit/rest");
+import { Octokit } from "@octokit/rest";
 function parseRepoSlug(input) {
     const [owner, repo] = input.split("/");
     if (!owner || !repo) {
@@ -122,7 +119,7 @@ function renderReleaseReferenceCommentBody(releases) {
         .join("\n");
     return `This is included in the following releases: :tada:\n\n${bullets}\n\n${footer}`;
 }
-function createGitHubPlugin() {
+export function createGitHubPlugin() {
     return {
         name: "github",
         capabilities: [
@@ -133,7 +130,7 @@ function createGitHubPlugin() {
         provider: "github",
         async createOrUpdateReviewRequest(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const listHead = resolveHeadForList(repo, input.headBranch);
             let existing;
             try {
@@ -212,7 +209,7 @@ function createGitHubPlugin() {
         },
         async closeReviewRequestIfExists(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const listHead = resolveHeadForList(repo, input.headBranch);
             let existing;
             try {
@@ -274,7 +271,7 @@ function createGitHubPlugin() {
         },
         async createReleaseMetadata(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             try {
                 const existing = await octokit.repos.getReleaseByTag({
                     owner: repo.owner,
@@ -310,7 +307,7 @@ function createGitHubPlugin() {
         },
         async createReleaseReferenceComments(input, context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const mode = input.mode ?? "best-effort";
             const releasesByIssue = groupReleasesByIssue(input.releases);
             const commented = [];

package/dist/scm/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/strategy/composite.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compositeVersionStrategy = compositeVersionStrategy;
 function configForSecondary(config) {
     if (config["version-file"] === undefined) {
         return config;
@@ -11,7 +8,7 @@ function configForSecondary(config) {
 function dedupedSorted(values) {
     return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
-function compositeVersionStrategy(strategies) {
+export function compositeVersionStrategy(strategies) {
     if (strategies.length === 0) {
         throw new Error("compositeVersionStrategy requires at least one strategy.");
     }

package/dist/strategy/latex.js

@@ -1,25 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.latexVersionStrategy = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+import fs from "node:fs";
+import path from "node:path";
 const BUILD_LUA_VERSION_PATTERN = /^(\s*version\s*=\s*")([^"]+)(")/mu;
 const PROVIDES_PACKAGE_PATTERN = /\\ProvidesPackage\{([^}]+)\}\[\d{4}-\d{2}-\d{2} v([0-9]+\.[0-9]+\.[0-9]+) ([^\]]+)\]/gu;
 const PROVIDES_EXPL_PACKAGE_PATTERN = /\\ProvidesExplPackage\{([^}]+)\}\{\d{4}-\d{2}-\d{2}\}\{[^}]+\}\{([^}]*)\}/gu;
 function normalizeRelative(base, target) {
-    return node_path_1.default.relative(base, target).replaceAll("\\", "/");
+    return path.relative(base, target).replaceAll("\\", "/");
 }
 function collectDtxFiles(dir) {
-    if (!node_fs_1.default.existsSync(dir)) {
+    if (!fs.existsSync(dir)) {
         return [];
     }
-    const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-        const target = node_path_1.default.join(dir, entry.name);
+        const target = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             files.push(...collectDtxFiles(target));
             continue;
@@ -51,18 +45,18 @@ function replaceProvidesPackageMetadata(content, version, releaseDate, relativeP
     }
     return content.replace(PROVIDES_PACKAGE_PATTERN, (_full, pkg, _prevVersion, desc) => `\\ProvidesPackage{${pkg}}[${releaseDate} v${version} ${desc}]`);
 }
-exports.latexVersionStrategy = {
+export const latexVersionStrategy = {
     name: "latex",
     getVersionFile(config) {
         return config["version-file"] ?? "build.lua";
     },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
-        const versionPath = node_path_1.default.join(cwd, versionFile);
-        if (!node_fs_1.default.existsSync(versionPath)) {
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
-        const content = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const content = fs.readFileSync(versionPath, "utf8");
         const match = content.match(BUILD_LUA_VERSION_PATTERN);
         if (!match?.[2]) {
             throw new Error(`${versionFile} is missing a valid version field required by release-type "latex".`);
@@ -71,31 +65,31 @@ exports.latexVersionStrategy = {
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
-        const versionPath = node_path_1.default.join(cwd, versionFile);
-        if (!node_fs_1.default.existsSync(versionPath)) {
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
-        const next = replaceBuildLuaVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), version, versionFile);
-        node_fs_1.default.writeFileSync(versionPath, next, "utf8");
+        const next = replaceBuildLuaVersion(fs.readFileSync(versionPath, "utf8"), version, versionFile);
+        fs.writeFileSync(versionPath, next, "utf8");
         return [versionFile];
     },
     finalizeVersionWrites(cwd, writes, context) {
         const updated = new Set();
         for (const write of writes) {
-            const packageRoot = write.packagePath === "." ? cwd : node_path_1.default.join(cwd, write.packagePath);
-            const srcDir = node_path_1.default.join(packageRoot, "src");
+            const packageRoot = write.packagePath === "." ? cwd : path.join(cwd, write.packagePath);
+            const srcDir = path.join(packageRoot, "src");
             const dtxFiles = collectDtxFiles(srcDir);
             if (dtxFiles.length === 0) {
                 throw new Error(`release-type "latex" requires at least one .dtx file under ${normalizeRelative(cwd, srcDir)}.`);
             }
             for (const dtxPath of dtxFiles) {
                 const relativePath = normalizeRelative(cwd, dtxPath);
-                const existing = node_fs_1.default.readFileSync(dtxPath, "utf8");
+                const existing = fs.readFileSync(dtxPath, "utf8");
                 const next = replaceProvidesPackageMetadata(existing, write.version, context.releaseDate, relativePath);
                 if (next === existing) {
                     continue;
                 }
-                node_fs_1.default.writeFileSync(dtxPath, next, "utf8");
+                fs.writeFileSync(dtxPath, next, "utf8");
                 updated.add(relativePath);
             }
         }