versionary 0.8.1 → 0.9.0

package/README.md

@@ -101,6 +101,8 @@ For a quick trial, use:
   - `independent` computes package bumps per path
   - `fixed` computes one shared bump across configured package paths
   - per-package `package-name` can override release identity (labels + tag base)
+  - per-package `changelog-file` writes package release notes to
+    `<package-path>/<changelog-file>`
 
 Rust strategy examples:
 
@@ -123,6 +125,8 @@ Rust strategy examples:
 Current rust auto-update behavior (phase scope):
 
 - updates crate versions in each targeted crate `[package].version`
+- supports targeted crates using `version.workspace = true` by updating
+  `[workspace.package].version` in the owning workspace manifest
 - updates internal workspace dependency versions when the dependency name
   matches another targeted crate name
 - refreshes `Cargo.lock` via `cargo generate-lockfile` when `Cargo.lock` exists

package/dist/app/release/artifact-rules.js

@@ -33,13 +33,17 @@ function parseFieldPath(fieldPath) {
             const numberMatch = rest.match(/^(\d+)\]/u);
             if (numberMatch) {
                 tokens.push(Number(numberMatch[1]));
-                index += 2 + numberMatch[1].length;
+                index += 2 + numberMatch[1]?.length;
                 continue;
             }
             const keyMatch = rest.match(/^"([^"]+)"\]/u);
             if (keyMatch) {
-                tokens.push(keyMatch[1]);
-                index += 4 + keyMatch[1].length;
+                const key = keyMatch[1];
+                if (!key) {
+                    throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
+                }
+                tokens.push(key);
+                index += 4 + keyMatch[1]?.length;
                 continue;
             }
             throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
@@ -56,6 +60,9 @@ function setVersionAtJsonPath(document, fieldPath, version) {
     let cursor = document;
     for (let index = 0; index < tokens.length - 1; index += 1) {
         const token = tokens[index];
+        if (token === undefined) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
         if (typeof token === "number") {
             if (!Array.isArray(cursor) || token >= cursor.length) {
                 throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
@@ -69,6 +76,9 @@ function setVersionAtJsonPath(document, fieldPath, version) {
         cursor = cursor[token];
     }
     const leaf = tokens.at(-1);
+    if (leaf === undefined) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
     if (typeof leaf === "number") {
         if (!Array.isArray(cursor) || leaf >= cursor.length) {
             throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
@@ -99,7 +109,12 @@ function resolveFieldPath(rule) {
 function parseRegexPattern(pattern) {
     const slashPattern = pattern.match(/^\/((?:\\\/|[^/])+)\/([a-z]*)$/u);
     if (slashPattern) {
-        return new RegExp(slashPattern[1], slashPattern[2]);
+        const source = slashPattern[1];
+        const flags = slashPattern[2];
+        if (!source || flags === undefined) {
+            throw new Error(`Invalid regex pattern "${pattern}".`);
+        }
+        return new RegExp(source, flags);
     }
     return new RegExp(pattern, "m");
 }
@@ -114,6 +129,9 @@ function applyRegexRule(content, pattern, version) {
         throw new Error(`Regex pattern must match exactly one occurrence; matched ${matches.length}.`);
     }
     const match = matches[0];
+    if (!match) {
+        throw new Error("Regex match result missing.");
+    }
     const start = match.index;
     if (start === undefined) {
         throw new Error("Regex match did not include an index.");
@@ -131,6 +149,9 @@ function applyTomlRulePreservingFormatting(content, fieldPath, version) {
         return `${toml_1.default.stringify(parsed)}\n`;
     }
     const key = simplePath[1];
+    if (!key) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
     const linePattern = new RegExp(`^(\\s*${key}\\s*=\\s*)(["'])([^"']*)(\\2)(\\s*(?:#.*)?)$`, "mu");
     const match = content.match(linePattern);
     if (!match) {
@@ -141,6 +162,9 @@ function applyTomlRulePreservingFormatting(content, fieldPath, version) {
 }
 function applyArtifactRuleToContent(content, rule, version) {
     if (rule.type === "regex") {
+        if (!rule.pattern) {
+            throw new Error('regex artifact rules require "pattern".');
+        }
         return applyRegexRule(content, rule.pattern, version);
     }
     if (rule.type === "json") {

package/dist/app/release/pr.js

@@ -71,24 +71,60 @@ function ensureCleanWorktree(cwd, logger) {
         logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
+function normalizeSlashPath(input) {
+    return input.replaceAll("\\", "/");
+}
+function listCargoLockFiles(cwd) {
+    const lockfiles = [];
+    const queue = [cwd];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === ".git") {
+                continue;
+            }
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile() || entry.name !== "Cargo.lock") {
+                continue;
+            }
+            lockfiles.push(normalizeSlashPath(node_path_1.default.relative(cwd, fullPath)));
+        }
+    }
+    return lockfiles.sort((a, b) => a.localeCompare(b));
+}
 function ensureCargoLockUpToDate(cwd) {
-    const lockfilePath = node_path_1.default.join(cwd, "Cargo.lock");
-    if (!node_fs_1.default.existsSync(lockfilePath)) {
+    const lockfiles = listCargoLockFiles(cwd);
+    if (lockfiles.length === 0) {
         return [];
     }
-    const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
-    try {
-        (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
-            cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to refresh Cargo.lock via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
+    const updatedLockfiles = [];
+    for (const lockfile of lockfiles) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        try {
+            (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
+                cwd: node_path_1.default.dirname(lockfilePath),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to refresh ${lockfile} via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
+        }
+        const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        if (after !== before) {
+            updatedLockfiles.push(lockfile);
+        }
     }
-    const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
-    return after !== before ? ["Cargo.lock"] : [];
+    return updatedLockfiles;
 }
 function normalizeReleaseNameForTag(releaseName) {
     return releaseName
@@ -178,6 +214,22 @@ function buildReleaseTargets(cwd, plan, loadedConfig) {
     }
     return releaseTargets;
 }
+function buildPackageReleaseMetadata(cwd, plan, loadedConfig) {
+    const metadataByPath = {};
+    for (const pkg of plan.packages ?? []) {
+        if (!pkg.nextVersion || pkg.path === ".") {
+            continue;
+        }
+        const packageConfig = loadedConfig.packages?.[pkg.path] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loadedConfig, pkg.path, packageConfig);
+        const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy.name, packageContext.versionFile);
+        metadataByPath[pkg.path] = {
+            releaseName,
+            tagPrefix: normalizeReleaseNameForTag(releaseName),
+        };
+    }
+    return metadataByPath;
+}
 function formatReleaseCommitTitle(releaseTargets) {
     if (releaseTargets.length === 0) {
         return "chore(release): v0.0.0";
@@ -216,8 +268,33 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const updatedRustLockFiles = ensureCargoLockUpToDate(cwd);
+    const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
+    const updatedChangelogFiles = [plan.changelogFile];
+    for (const packagePlan of plan.packages ?? []) {
+        if (!packagePlan.nextVersion || packagePlan.path === ".") {
+            continue;
+        }
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageChangelogFile = packageConfig["changelog-file"];
+        if (!packageChangelogFile) {
+            continue;
+        }
+        const packageMetadata = packageReleaseMetadata[packagePlan.path];
+        if (!packageMetadata) {
+            continue;
+        }
+        const packageSection = (0, changelog_js_1.renderPackageChangelogSection)({
+            currentVersion: packagePlan.currentVersion,
+            nextVersion: packagePlan.nextVersion,
+            commits: packagePlan.commits,
+            tagPrefix: packageMetadata.tagPrefix,
+            cwd,
+        });
+        (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection);
+        updatedChangelogFiles.push(node_path_1.default.posix.join(packagePlan.path, packageChangelogFile));
+    }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
     const branch = plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
@@ -230,7 +307,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
             ...updatedRustLockFiles,
-            plan.changelogFile,
+            ...updatedChangelogFiles,
         ]),
     ];
     (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {

package/dist/app/release/release.js

@@ -75,6 +75,7 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     if (!plugin?.createReleaseMetadata) {
         throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createReleaseMetadata.`);
     }
+    const createReleaseMetadata = plugin.createReleaseMetadata;
     const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
@@ -92,7 +93,10 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
             version: target.version,
             notes: readReleaseNotes(cwd, target.version, changelogFile),
         }, {
-            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: options.logger }),
+            createReleaseMetadata: (input) => createReleaseMetadata(input, {
+                cwd,
+                logger: options.logger,
+            }),
             logger: options.logger,
         });
         releases.push({

package/dist/cli/index.js

@@ -125,7 +125,7 @@ async function main() {
             : "";
         const heading = "# Changelog\n\n";
         const body = existing.replace(/^# Changelog\s*/u, "");
-        node_fs_1.default.writeFileSync(changelogPath, `${heading}${section}\n${body}`.trimEnd() + "\n", "utf8");
+        node_fs_1.default.writeFileSync(changelogPath, `${`${heading}${section}\n${body}`.trimEnd()}\n`, "utf8");
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }

package/dist/config/schema.d.ts

@@ -22,6 +22,7 @@ export declare const configSchema: z.ZodObject<{
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         "release-type": z.ZodOptional<z.ZodString>;
         "package-name": z.ZodOptional<z.ZodString>;
+        "changelog-file": z.ZodOptional<z.ZodString>;
         "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
         "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{

package/dist/config/schema.js

@@ -53,6 +53,7 @@ const packageSchema = zod_1.z
     .object({
     "release-type": zod_1.z.string().optional(),
     "package-name": zod_1.z.string().optional(),
+    "changelog-file": zod_1.z.string().optional(),
     "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
     "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
 })

package/dist/domain/release/changelog.d.ts

@@ -9,4 +9,11 @@ export declare function renderSimpleReleaseNotes(input: {
     includeFooter?: boolean;
 }): string;
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
+export declare function renderPackageChangelogSection(input: {
+    currentVersion: string;
+    nextVersion: string;
+    commits: ParsedCommit[];
+    tagPrefix: string;
+    cwd?: string;
+}): string;
 export declare function prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/domain/release/changelog.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
 exports.renderSimpleChangelog = renderSimpleChangelog;
+exports.renderPackageChangelogSection = renderPackageChangelogSection;
 exports.prependChangelog = prependChangelog;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -110,6 +111,24 @@ function renderSimpleChangelog(plan) {
         cwd: process.cwd(),
     });
 }
+function renderPackageChangelogSection(input) {
+    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const header = repoUrl
+        ? `## [${input.nextVersion}](${repoUrl}/compare/${input.tagPrefix}-v${input.currentVersion}...${input.tagPrefix}-v${input.nextVersion}) (${formatDate()})`
+        : `## ${input.nextVersion} (${formatDate()})`;
+    const grouped = groupCommitLines(input.commits, repoUrl);
+    const sections = [];
+    if (grouped.breaking.length > 0) {
+        sections.push("### Breaking changes", ...grouped.breaking, "");
+    }
+    if (grouped.features.length > 0) {
+        sections.push("### Features", ...grouped.features, "");
+    }
+    if (grouped.fixes.length > 0) {
+        sections.push("### Bug Fixes", ...grouped.fixes, "");
+    }
+    return [header, "", ...sections].join("\n");
+}
 function prependChangelog(cwd, changelogFile, section) {
     const changelogPath = node_path_1.default.join(cwd, changelogFile);
     const existing = node_fs_1.default.existsSync(changelogPath)

package/dist/domain/strategy/package-context.js

@@ -22,8 +22,20 @@ function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
         : { ...rootConfig };
     const baseStrategy = (0, resolve_js_1.resolveVersionStrategy)(baseConfig);
     if (!packageReleaseType) {
-        const versionFile = baseConfig["version-file"] ?? baseStrategy.getVersionFile(baseConfig);
-        const config = withVersionFile(baseConfig, versionFile);
+        const versionFile = packagePath === "."
+            ? (baseConfig["version-file"] ??
+                baseStrategy.getVersionFile(baseConfig))
+            : baseStrategy.name === "simple"
+                ? (baseConfig["version-file"] ??
+                    baseStrategy.getVersionFile(baseConfig))
+                : node_path_1.default.posix.join(packagePath, baseStrategy.getVersionFile({
+                    ...baseConfig,
+                    "version-file": undefined,
+                }));
+        const config = withVersionFile({
+            ...baseConfig,
+            packages: undefined,
+        }, versionFile);
         return {
             strategy: baseStrategy,
             config,

package/dist/domain/strategy/r.js

@@ -8,7 +8,7 @@ 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]) {
+    if (!match?.[1]) {
         throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
     }
     return match[1].trim();

package/dist/domain/strategy/rust.js

@@ -202,19 +202,73 @@ function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
     }
     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);
+function isWorkspaceInheritedVersion(rawVersion) {
+    if (!rawVersion || typeof rawVersion !== "object") {
+        return false;
+    }
+    const versionRecord = rawVersion;
+    return versionRecord.workspace === true;
+}
+function readWorkspacePackageVersion(cargoTomlRaw, versionFile) {
+    const { workspaceTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!workspaceTable || typeof workspaceTable !== "object") {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    const workspacePackage = workspaceTable.package && typeof workspaceTable.package === "object"
+        ? workspaceTable.package
+        : null;
+    const rawVersion = workspacePackage?.version;
+    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    return rawVersion.trim();
+}
+function findWorkspaceManifestForMember(cwd, memberManifest) {
+    const cwdAbs = node_path_1.default.resolve(cwd);
+    let currentDir = node_path_1.default.resolve(cwd, node_path_1.default.dirname(memberManifest));
+    while (true) {
+        const relativeDir = node_path_1.default.relative(cwdAbs, currentDir);
+        if (relativeDir.startsWith("..")) {
+            break;
+        }
+        const candidatePath = node_path_1.default.join(currentDir, "Cargo.toml");
+        if (node_fs_1.default.existsSync(candidatePath)) {
+            const relativeManifest = normalizeSlashPath(node_path_1.default.relative(cwdAbs, candidatePath));
+            const cargoTomlRaw = node_fs_1.default.readFileSync(candidatePath, "utf8");
+            const parsed = parseCargoManifest(relativeManifest, cargoTomlRaw);
+            if (parsed.workspaceTable) {
+                return relativeManifest;
+            }
+        }
+        if (currentDir === cwdAbs) {
+            break;
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new Error(`${memberManifest} uses version.workspace = true, but no workspace Cargo.toml with [workspace.package].version was found between that crate and repository root.`);
+}
+function readResolvedCargoVersion(cwd, manifest, cargoTomlRaw) {
+    const { packageTable } = parseCargoManifest(manifest, cargoTomlRaw);
     if (!packageTable || typeof packageTable !== "object") {
-        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+        throw new Error(`${manifest} 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.`);
+        throw new Error(`${manifest} 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.`);
+    if (typeof rawVersion === "string" && rawVersion.trim().length > 0) {
+        return rawVersion.trim();
     }
-    return rawVersion.trim();
+    if (!isWorkspaceInheritedVersion(rawVersion)) {
+        throw new Error(`${manifest} has invalid [package].version. Expected a non-empty SemVer string or version.workspace = true.`);
+    }
+    const workspaceManifest = findWorkspaceManifestForMember(cwd, manifest);
+    const workspaceRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, workspaceManifest), "utf8");
+    return readWorkspacePackageVersion(workspaceRaw, workspaceManifest);
 }
 function readCargoPackageName(cargoTomlRaw, versionFile) {
     const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
@@ -272,6 +326,56 @@ function writeCargoVersion(cargoTomlRaw, versionFile, version) {
     }
     return updated;
 }
+function writeWorkspacePackageVersion(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 inWorkspacePackageSection = false;
+    let foundWorkspacePackageSection = 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();
+            inWorkspacePackageSection = section === "workspace.package";
+            if (inWorkspacePackageSection) {
+                foundWorkspacePackageSection = true;
+            }
+            continue;
+        }
+        if (!inWorkspacePackageSection) {
+            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 (!foundWorkspacePackageSection || !replacedVersion) {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    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 usesWorkspaceInheritedVersion(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        return false;
+    }
+    const rawVersion = packageTable.version;
+    return isWorkspaceInheritedVersion(rawVersion);
+}
 function isDependencySection(section) {
     if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
         return true;
@@ -450,13 +554,14 @@ exports.rustVersionStrategy = {
             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);
+        return readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
         const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
         const updatedFiles = [];
         const internalCrates = new Set();
+        const workspaceManifestsToUpdate = new Set();
         for (const manifest of manifests) {
             const versionPath = node_path_1.default.join(cwd, manifest);
             if (!node_fs_1.default.existsSync(versionPath)) {
@@ -467,6 +572,7 @@ exports.rustVersionStrategy = {
                 continue;
             }
             internalCrates.add(readCargoPackageName(cargoTomlRaw, manifest));
+            readResolvedCargoVersion(cwd, manifest, cargoTomlRaw);
         }
         for (const manifest of manifests) {
             const versionPath = node_path_1.default.join(cwd, manifest);
@@ -477,10 +583,30 @@ exports.rustVersionStrategy = {
             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);
+            let updatedCargoToml = cargoTomlRaw;
+            if (usesWorkspaceInheritedVersion(cargoTomlRaw, manifest)) {
+                workspaceManifestsToUpdate.add(findWorkspaceManifestForMember(cwd, manifest));
+            }
+            else {
+                updatedCargoToml = writeCargoVersion(updatedCargoToml, manifest, version);
+            }
+            updatedCargoToml = writeInternalDependencyVersions(updatedCargoToml, internalCrates, version);
+            if (updatedCargoToml !== cargoTomlRaw) {
+                node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+                updatedFiles.push(manifest);
+            }
+        }
+        for (const workspaceManifest of workspaceManifestsToUpdate) {
+            const workspacePath = node_path_1.default.join(cwd, workspaceManifest);
+            if (!node_fs_1.default.existsSync(workspacePath)) {
+                continue;
+            }
+            const workspaceRaw = node_fs_1.default.readFileSync(workspacePath, "utf8");
+            const updatedWorkspaceToml = writeInternalDependencyVersions(writeWorkspacePackageVersion(workspaceRaw, workspaceManifest, version), internalCrates, version);
+            if (updatedWorkspaceToml !== workspaceRaw) {
+                node_fs_1.default.writeFileSync(workspacePath, updatedWorkspaceToml, "utf8");
+                updatedFiles.push(workspaceManifest);
+            }
         }
         if (updatedFiles.length === 0) {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest to update.`);

package/dist/types/config.d.ts

@@ -9,6 +9,7 @@ export interface VersionaryArtifactRule {
 export interface VersionaryPackage {
     "release-type"?: string;
     "package-name"?: string;
+    "changelog-file"?: string;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",