versionary 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -20,27 +20,81 @@ function printVerifyResult() {
     }
     return result.ok ? 0 : 1;
 }
+function parseFlags(args) {
+    return {
+        json: args.includes("--json"),
+    };
+}
+function emitJson(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
 async function main() {
     const [, , command, ...args] = process.argv;
+    const flags = parseFlags(args);
+    const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
         const subject = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
         if ((0, pr_js_1.isReleaseCommitMessage)(subject)) {
+            if (flags.json) {
+                const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                    logger,
+                });
+                if (release.action === "release-skipped") {
+                    emitJson({
+                        action: "release-skipped",
+                        message: release.reason,
+                        releaseCreated: false,
+                        tagNames: [],
+                    });
+                    return 0;
+                }
+                emitJson({
+                    action: "release-published",
+                    message: release.message,
+                    releaseCreated: release.releases.length > 0,
+                    tagNames: release.releases.map((target) => target.tag),
+                });
+                return 0;
+            }
             const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
             console.log(message);
             return 0;
         }
         const plan = (0, plan_js_1.createSimplePlan)();
         if (!plan.nextVersion) {
-            console.log("No releasable commits found. Nothing to do.");
+            const message = "No releasable commits found. Nothing to do.";
+            if (flags.json) {
+                emitJson({
+                    action: "noop",
+                    message,
+                    releaseCreated: false,
+                    tagNames: [],
+                });
+                return 0;
+            }
+            console.log(message);
             return 0;
         }
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
-        console.log(`Prepared release PR branch ${pr.branch}`);
+        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
+        const message = `Prepared release PR branch ${pr.branch}`;
+        if (flags.json) {
+            emitJson({
+                action: "pr-prepared",
+                message,
+                releaseCreated: false,
+                tagNames: [],
+                reviewUrl: reviewResult,
+                branch: pr.branch,
+                title: pr.title,
+            });
+            return 0;
+        }
+        console.log(message);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);
         return 0;
@@ -76,7 +130,7 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger: console });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
         console.log(`Prepared release PR branch ${pr.branch}`);
@@ -91,7 +145,7 @@ async function main() {
     }
     console.log("Usage: versionary <command>");
     console.log("Commands:");
-    console.log("  run     Auto-dispatch release PR/update or release publish by context");
+    console.log("  run [--json]  Auto-dispatch release PR/update or release publish by context");
     console.log("  verify  Validate config and basic repository shape");
     console.log("  plan    Print release plan (simple mode)");
     console.log("  changelog [--write]  Print or write changelog section");

package/dist/config/schema.js

@@ -2,11 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configSchema = void 0;
 const zod_1 = require("zod");
-const artifactRuleSchema = zod_1.z.object({
+const artifactRuleSchema = zod_1.z
+    .object({
     type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
     path: zod_1.z.string().min(1),
     jsonpath: zod_1.z.string().optional(),
     pattern: zod_1.z.string().optional(),
+})
+    .superRefine((value, ctx) => {
+    const needsJsonPath = value.type === "json" || value.type === "toml" || value.type === "yaml";
+    if (needsJsonPath && !value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules require "jsonpath".`,
+            path: ["jsonpath"],
+        });
+    }
+    if (needsJsonPath && value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules do not support "pattern".`,
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && !value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules require "pattern".',
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules do not support "jsonpath".',
+            path: ["jsonpath"],
+        });
+    }
 });
 const packageSchema = zod_1.z.object({
     "release-type": zod_1.z.string().optional(),

package/dist/domain/release/changelog.js

@@ -95,7 +95,7 @@ function renderSimpleReleaseNotes(input, options = {}) {
     }
     const lines = [header, "", ...sections];
     if (options.includeFooter) {
-        lines.push("This PR was generated by Versionary.");
+        lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
     }
     return lines.join("\n");
 }

package/dist/domain/strategy/node.js

@@ -6,10 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeVersionStrategy = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+function readJsonFile(targetPath) {
+    return JSON.parse(node_fs_1.default.readFileSync(targetPath, "utf8"));
+}
+function writeJsonFile(targetPath, value) {
+    node_fs_1.default.writeFileSync(targetPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function updateNodeLockfileVersion(cwd, version) {
+    const updated = [];
+    for (const lockfile of ["package-lock.json", "npm-shrinkwrap.json"]) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        if (!node_fs_1.default.existsSync(lockfilePath)) {
+            continue;
+        }
+        const parsed = readJsonFile(lockfilePath);
+        parsed.version = version;
+        if (parsed.packages?.[""]) {
+            parsed.packages[""].version = version;
+        }
+        writeJsonFile(lockfilePath, parsed);
+        updated.push(lockfile);
+    }
+    return updated;
+}
 exports.nodeVersionStrategy = {
     name: "node",
     getVersionFile(config) {
-        return config["version-file"] ?? "version.txt";
+        return config["version-file"] ?? "package.json";
     },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
@@ -17,21 +40,28 @@ exports.nodeVersionStrategy = {
         if (!node_fs_1.default.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
-        return node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
+        }
+        return packageJson.version.trim();
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
         const versionPath = node_path_1.default.join(cwd, versionFile);
-        node_fs_1.default.writeFileSync(versionPath, `${version}\n`, "utf8");
-        const updatedFiles = [versionFile];
-        const packageJsonPath = node_path_1.default.join(cwd, "package.json");
-        if (node_fs_1.default.existsSync(packageJsonPath)) {
-            const packageJsonRaw = node_fs_1.default.readFileSync(packageJsonPath, "utf8");
-            const packageJson = JSON.parse(packageJsonRaw);
-            packageJson.version = version;
-            node_fs_1.default.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
-            updatedFiles.push("package.json");
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
         }
+        packageJson.version = version;
+        writeJsonFile(versionPath, packageJson);
+        const updatedFiles = [
+            versionFile,
+            ...updateNodeLockfileVersion(cwd, version),
+        ];
         return updatedFiles;
     },
 };

package/dist/domain/strategy/r.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare const rVersionStrategy: VersionStrategy;

package/dist/domain/strategy/r.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function readDescriptionVersion(content, versionFile) {
+    const match = content.match(/^Version:\s*(.+)\s*$/mu);
+    if (!match || !match[1]) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return match[1].trim();
+}
+function writeDescriptionVersion(content, versionFile, version) {
+    if (!/^Version:\s*/mu.test(content)) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return content.replace(/^Version:\s*.*$/mu, `Version: ${version}`);
+}
+exports.rVersionStrategy = {
+    name: "r",
+    getVersionFile(config) {
+        return config["version-file"] ?? "DESCRIPTION";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        return readDescriptionVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), versionFile);
+    },
+    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)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const existing = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const updated = writeDescriptionVersion(existing, versionFile, version);
+        node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+        return [versionFile];
+    },
+};

package/dist/domain/strategy/resolve.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveVersionStrategy = resolveVersionStrategy;
 const node_js_1 = require("./node.js");
+const r_js_1 = require("./r.js");
+const rust_js_1 = require("./rust.js");
 const simple_js_1 = require("./simple.js");
 function resolveVersionStrategy(config) {
     if (config["release-type"] === "node") {
         return node_js_1.nodeVersionStrategy;
     }
+    if (config["release-type"] === "rust") {
+        return rust_js_1.rustVersionStrategy;
+    }
+    if (config["release-type"] === "r") {
+        return r_js_1.rVersionStrategy;
+    }
     return simple_js_1.simpleVersionStrategy;
 }

package/dist/domain/strategy/rust.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare const rustVersionStrategy: VersionStrategy;

package/dist/domain/strategy/rust.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const ROOT_DEPENDENCY_SECTIONS = new Set([
+    "dependencies",
+    "dev-dependencies",
+    "build-dependencies",
+]);
+function normalizeSlashPath(input) {
+    return input.replaceAll("\\", "/");
+}
+function hasGlobPattern(pattern) {
+    return /[*?]/u.test(pattern);
+}
+function escapeRegex(input) {
+    return input.replace(/[.+^${}()|\\]/gu, "\\$&");
+}
+function globToRegex(pattern) {
+    const normalized = normalizeSlashPath(pattern);
+    let source = "^";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const current = normalized[index] ?? "";
+        const next = normalized[index + 1] ?? "";
+        if (current === "*" && next === "*") {
+            source += ".*";
+            index += 1;
+            continue;
+        }
+        if (current === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (current === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegex(current);
+    }
+    source += "$";
+    return new RegExp(source, "u");
+}
+function findCargoManifestDirectories(rootDir) {
+    const results = new Set();
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, {
+            withFileTypes: true,
+        });
+        let hasCargoManifest = false;
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === "Cargo.toml") {
+                hasCargoManifest = true;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+        }
+        if (hasCargoManifest) {
+            const rel = normalizeSlashPath(node_path_1.default.relative(rootDir, currentDir));
+            results.add(rel === "" ? "." : rel);
+        }
+    }
+    return [...results].sort((a, b) => a.localeCompare(b));
+}
+function parseCargoManifest(versionFile, cargoTomlRaw) {
+    let parsed;
+    try {
+        parsed = toml_1.default.parse(cargoTomlRaw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse ${versionFile}: ${message}`);
+    }
+    const parsedRecord = parsed;
+    const packageTable = parsedRecord.package && typeof parsedRecord.package === "object"
+        ? parsedRecord.package
+        : null;
+    const workspaceTable = parsedRecord.workspace && typeof parsedRecord.workspace === "object"
+        ? parsedRecord.workspace
+        : null;
+    return { packageTable, workspaceTable };
+}
+function isCrateManifest(versionFile, cargoTomlRaw) {
+    const parsed = parseCargoManifest(versionFile, cargoTomlRaw);
+    return parsed.packageTable !== null;
+}
+function readWorkspaceMemberPatterns(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const members = workspaceTable.members;
+    if (!Array.isArray(members)) {
+        return [];
+    }
+    return members
+        .filter((member) => typeof member === "string")
+        .map((member) => normalizeSlashPath(member.trim()))
+        .filter((member) => member.length > 0);
+}
+function readWorkspaceExcludes(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const excludes = workspaceTable.exclude;
+    if (!Array.isArray(excludes)) {
+        return [];
+    }
+    return excludes
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => normalizeSlashPath(entry.trim()))
+        .filter((entry) => entry.length > 0);
+}
+function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
+    const memberPatterns = readWorkspaceMemberPatterns(workspaceTable);
+    if (memberPatterns.length === 0) {
+        return [];
+    }
+    const excludes = readWorkspaceExcludes(workspaceTable);
+    const excludeRegexes = excludes.map((pattern) => globToRegex(pattern));
+    const cargoDirs = findCargoManifestDirectories(rootDir);
+    const manifests = new Set();
+    for (const pattern of memberPatterns) {
+        if (hasGlobPattern(pattern)) {
+            const regex = globToRegex(pattern);
+            for (const dir of cargoDirs) {
+                if (regex.test(dir)) {
+                    manifests.add(normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml")));
+                }
+            }
+            continue;
+        }
+        const candidateDir = normalizeSlashPath(pattern);
+        if (excludeRegexes.some((regex) => regex.test(candidateDir))) {
+            continue;
+        }
+        const cargoPath = node_path_1.default.join(rootDir, candidateDir, "Cargo.toml");
+        if (node_fs_1.default.existsSync(cargoPath)) {
+            manifests.add(normalizeSlashPath(node_path_1.default.posix.join(candidateDir, "Cargo.toml")));
+        }
+    }
+    const filtered = [...manifests].filter((manifestPath) => {
+        const dir = normalizeSlashPath(node_path_1.default.posix.dirname(manifestPath));
+        return !excludeRegexes.some((regex) => regex.test(dir));
+    });
+    return filtered.sort((a, b) => a.localeCompare(b));
+}
+function collectRustTargetManifests(cwd, versionFile) {
+    if (node_path_1.default.basename(versionFile) !== "Cargo.toml") {
+        throw new Error(`Rust strategy requires "version-file" to point to a Cargo.toml manifest (received "${versionFile}").`);
+    }
+    const rootManifestPath = node_path_1.default.join(cwd, versionFile);
+    if (!node_fs_1.default.existsSync(rootManifestPath)) {
+        throw new Error(`Versionary requires ${versionFile} to exist.`);
+    }
+    const rootRaw = node_fs_1.default.readFileSync(rootManifestPath, "utf8");
+    const parsedRoot = parseCargoManifest(versionFile, rootRaw);
+    const rootIsCrate = parsedRoot.packageTable !== null;
+    const rootDir = node_path_1.default.dirname(rootManifestPath);
+    const workspaceMembers = resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable);
+    if (rootIsCrate) {
+        const relRoot = normalizeSlashPath(node_path_1.default.relative(cwd, rootManifestPath));
+        return [...new Set([relRoot, ...workspaceMembers])].sort((a, b) => a.localeCompare(b));
+    }
+    if (workspaceMembers.length > 0) {
+        return workspaceMembers;
+    }
+    throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. Expected [package].version or [workspace].members with crate Cargo.toml files.`);
+}
+function readCargoVersion(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    const rawVersion = packageTable.version;
+    if (rawVersion === undefined) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].version. Expected a non-empty SemVer string.`);
+    }
+    return rawVersion.trim();
+}
+function readCargoPackageName(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].name. Add [package] with a crate name.`);
+    }
+    const rawName = packageTable.name;
+    if (typeof rawName !== "string" || rawName.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].name. Expected a non-empty crate name.`);
+    }
+    return rawName.trim();
+}
+function writeCargoVersion(cargoTomlRaw, versionFile, version) {
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let inPackageSection = false;
+    let foundPackageSection = false;
+    let replacedVersion = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            const section = sectionMatch[1]?.trim();
+            inPackageSection = section === "package";
+            if (inPackageSection) {
+                foundPackageSection = true;
+            }
+            continue;
+        }
+        if (!inPackageSection) {
+            continue;
+        }
+        const versionMatch = line.match(/^(\s*version\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+        if (!versionMatch) {
+            continue;
+        }
+        const [, prefix = "", quote = '"', , , suffix = ""] = versionMatch;
+        lines[index] = `${prefix}${quote}${version}${quote}${suffix}`;
+        replacedVersion = true;
+        break;
+    }
+    if (!foundPackageSection) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (!replacedVersion) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+function isDependencySection(section) {
+    if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
+        return true;
+    }
+    if (!section.startsWith("target.")) {
+        return false;
+    }
+    return (section.endsWith(".dependencies") ||
+        section.endsWith(".dev-dependencies") ||
+        section.endsWith(".build-dependencies"));
+}
+function parseDependencyName(line) {
+    const match = line.match(/^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*=/u);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version) {
+    if (!internalCrates.has(dependencyName)) {
+        return line;
+    }
+    const stringVersionMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+    if (stringVersionMatch) {
+        const [, prefix = "", quote = '"', , , suffix = ""] = stringVersionMatch;
+        return `${prefix}${quote}${version}${quote}${suffix}`;
+    }
+    const inlineTableMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*\{)(.*)(\}\s*(?:#.*)?)$/u);
+    if (!inlineTableMatch) {
+        return line;
+    }
+    const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
+    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${version}$4`);
+    if (updatedTableBody === tableBody) {
+        return line;
+    }
+    return `${prefix}${updatedTableBody}${suffix}`;
+}
+function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version) {
+    if (internalCrates.size === 0) {
+        return cargoTomlRaw;
+    }
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let currentSection = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1]?.trim() ?? null;
+            continue;
+        }
+        if (!currentSection || !isDependencySection(currentSection)) {
+            continue;
+        }
+        const dependencyName = parseDependencyName(line);
+        if (!dependencyName) {
+            continue;
+        }
+        lines[index] = writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+exports.rustVersionStrategy = {
+    name: "rust",
+    getVersionFile(config) {
+        return config["version-file"] ?? "Cargo.toml";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const selectedManifest = manifests[0];
+        if (!selectedManifest) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
+        return readCargoVersion(cargoTomlRaw, selectedManifest);
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const updatedFiles = [];
+        const internalCrates = new Set();
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            internalCrates.add(readCargoPackageName(cargoTomlRaw, manifest));
+        }
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            readCargoVersion(cargoTomlRaw, manifest);
+            const updatedCargoToml = writeInternalDependencyVersions(writeCargoVersion(cargoTomlRaw, manifest, version), internalCrates, version);
+            node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+            updatedFiles.push(manifest);
+        }
+        if (updatedFiles.length === 0) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest to update.`);
+        }
+        return updatedFiles.sort((a, b) => a.localeCompare(b));
+    },
+};