mustflow 1.15.97

package/dist/core/source-anchors.js

@@ -0,0 +1,194 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+export const SOURCE_ANCHOR_EXTENSIONS = new Set(['.cjs', '.go', '.js', '.jsx', '.mjs', '.py', '.rs', '.ts', '.tsx']);
+export const SOURCE_ANCHOR_DEFAULT_EXCLUDED_PATH_PARTS = new Set([
+    '.git',
+    '.mustflow',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+    'third_party',
+    'vendor',
+]);
+export const SOURCE_ANCHOR_GENERATED_PATH_PARTS = new Set([
+    '__generated__',
+    'build',
+    'dist',
+    'generated',
+    'third_party',
+    'vendor',
+]);
+export const SOURCE_ANCHOR_ALLOWED_FIELDS = new Set(['purpose', 'search', 'invariant', 'risk']);
+export const SOURCE_ANCHOR_ALLOWED_RISKS = new Set([
+    'authn',
+    'authz',
+    'authorization',
+    'cache',
+    'config',
+    'data_consistency',
+    'data_loss',
+    'dependency',
+    'external_request',
+    'file_upload',
+    'injection',
+    'migration',
+    'payment',
+    'pii',
+    'privacy',
+    'retention',
+    'secrets',
+    'security',
+    'ssrf',
+    'state',
+    'xss',
+]);
+export const SOURCE_ANCHOR_ID_PATTERN = /^[a-z0-9][a-z0-9.-]{0,95}$/u;
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function listFilesRecursive(root, ignoredDirectoryNames, current = root) {
+    if (!existsSync(current)) {
+        return [];
+    }
+    const files = [];
+    for (const entry of readdirSync(current)) {
+        const entryPath = path.join(current, entry);
+        const stat = statSync(entryPath);
+        if (stat.isDirectory()) {
+            if (ignoredDirectoryNames.has(entry)) {
+                continue;
+            }
+            files.push(...listFilesRecursive(root, ignoredDirectoryNames, entryPath));
+            continue;
+        }
+        if (stat.isFile()) {
+            files.push(path.relative(root, entryPath));
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+export function listSourceAnchorFiles(root, options = {}) {
+    const ignoredDirectoryNames = options.ignoredDirectoryNames ?? SOURCE_ANCHOR_DEFAULT_EXCLUDED_PATH_PARTS;
+    return listFilesRecursive(root, ignoredDirectoryNames)
+        .map((relativePath) => toPosixPath(relativePath))
+        .filter((relativePath) => SOURCE_ANCHOR_EXTENSIONS.has(path.posix.extname(relativePath)));
+}
+export function stripSourceAnchorCommentPrefix(line) {
+    return line
+        .trim()
+        .replace(/^\/\*\*?/u, '')
+        .replace(/\*\/$/u, '')
+        .replace(/^\/\//u, '')
+        .replace(/^#/u, '')
+        .replace(/^\*/u, '')
+        .trim();
+}
+function readSourceAnchorField(line) {
+    const separator = line.indexOf(':');
+    if (separator === -1) {
+        return null;
+    }
+    const key = line.slice(0, separator).trim().toLowerCase();
+    const value = line.slice(separator + 1).trim();
+    if (key.length === 0 || value.length === 0) {
+        return null;
+    }
+    return { key, value };
+}
+export function splitSourceAnchorList(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(/[,;]/u)
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+export function sourceAnchorPathIsGeneratedOrVendor(relativePath) {
+    const normalized = toPosixPath(relativePath);
+    const parts = normalized.split('/');
+    if (normalized.endsWith('.min.js') || normalized.endsWith('.min.css')) {
+        return true;
+    }
+    return parts.some((part) => SOURCE_ANCHOR_GENERATED_PATH_PARTS.has(part));
+}
+export function parseSourceAnchorsInContent(relativePath, content) {
+    const lines = content.split(/\r?\n/);
+    const anchors = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const normalized = stripSourceAnchorCommentPrefix(lines[index] ?? '');
+        if (!normalized.startsWith('mf:anchor')) {
+            continue;
+        }
+        const anchorMatch = normalized.match(/^mf:anchor(?:\s+(.+))?$/u);
+        const rawId = anchorMatch?.[1]?.trim() ?? '';
+        const fields = new Map();
+        const unsupportedFields = [];
+        const rawLines = [normalized];
+        for (let fieldIndex = index + 1; fieldIndex < lines.length; fieldIndex += 1) {
+            const fieldLine = stripSourceAnchorCommentPrefix(lines[fieldIndex] ?? '');
+            if (fieldLine.length === 0) {
+                continue;
+            }
+            if (fieldLine.startsWith('@') || /^[A-Za-z_$][\w$]*\s/u.test(fieldLine)) {
+                break;
+            }
+            const field = readSourceAnchorField(fieldLine);
+            if (!field) {
+                break;
+            }
+            rawLines.push(fieldLine);
+            if (!SOURCE_ANCHOR_ALLOWED_FIELDS.has(field.key)) {
+                unsupportedFields.push(field.key);
+                continue;
+            }
+            fields.set(field.key, field.value);
+        }
+        anchors.push({
+            id: SOURCE_ANCHOR_ID_PATTERN.test(rawId) ? rawId : '',
+            rawId,
+            idValid: SOURCE_ANCHOR_ID_PATTERN.test(rawId),
+            path: relativePath,
+            lineStart: index + 1,
+            fields,
+            unsupportedFields,
+            rawText: rawLines.join('\n'),
+        });
+    }
+    return anchors;
+}
+/**
+ * mf:anchor core.source-anchors.collect
+ * purpose: Collect structured inline source anchors without treating source text as workflow authority.
+ * search: source anchor parser, navigation metadata, purpose search invariant risk
+ * invariant: Collected anchors always report navigationOnly true and canInstructAgent false.
+ * risk: config, security
+ */
+export function collectSourceAnchorSummaries(projectRoot) {
+    const anchors = [];
+    for (const relativePath of listSourceAnchorFiles(projectRoot)) {
+        const filePath = path.join(projectRoot, ...relativePath.split('/'));
+        if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+            continue;
+        }
+        const content = readFileSync(filePath, 'utf8');
+        for (const anchor of parseSourceAnchorsInContent(relativePath, content)) {
+            if (!anchor.idValid) {
+                continue;
+            }
+            anchors.push({
+                id: anchor.rawId,
+                path: relativePath,
+                lineStart: anchor.lineStart,
+                purpose: anchor.fields.get('purpose') ?? null,
+                search: splitSourceAnchorList(anchor.fields.get('search')),
+                invariant: anchor.fields.get('invariant') ?? null,
+                risk: splitSourceAnchorList(anchor.fields.get('risk')),
+                navigationOnly: true,
+                canInstructAgent: false,
+            });
+        }
+    }
+    return anchors.sort((left, right) => left.id.localeCompare(right.id) || left.path.localeCompare(right.path));
+}

package/dist/core/surface-decision-model.js

@@ -0,0 +1,18 @@
+export const CHANGE_CLASSIFICATION_SURFACE_AUTHORITY = {
+    canInstructAgent: false,
+    canGrantCommandPermission: false,
+    canSelectVerification: true,
+};
+export const DOCUMENT_REVIEW_SURFACE_AUTHORITY = {
+    canInstructAgent: false,
+    canGrantCommandPermission: false,
+    canSelectVerification: false,
+};
+export const SOURCE_ANCHOR_SURFACE_AUTHORITY = {
+    canInstructAgent: false,
+    canGrantCommandPermission: false,
+    canSelectVerification: false,
+};
+export function createPathTarget(path, lineStart) {
+    return lineStart === undefined ? { kind: 'path', path } : { kind: 'path', path, lineStart };
+}

package/dist/core/toml.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'node:fs';
+import { parse, stringify } from 'smol-toml';
+export function parseTomlText(value) {
+    return parse(value);
+}
+export function readTomlFile(filePath) {
+    return parseTomlText(readFileSync(filePath, 'utf8'));
+}
+export function stringifyToml(value) {
+    return `${stringify(value).trimEnd()}\n`;
+}

package/dist/core/verification-plan.js

@@ -0,0 +1,41 @@
+import { isRecord, readStringArray, } from './config-loading.js';
+import { evaluateCommandIntentEligibility, } from './command-intent-eligibility.js';
+function hasRequiredAfter(intent, reason) {
+    return (readStringArray(intent, 'required_after') ?? []).includes(reason);
+}
+export function classifyVerificationCandidate(intentName, rawIntent) {
+    const eligibility = evaluateCommandIntentEligibility(intentName, rawIntent);
+    if (!eligibility.ok) {
+        return {
+            intent: intentName,
+            status: 'skipped',
+            reason: eligibility.code,
+            detail: eligibility.detail,
+        };
+    }
+    return {
+        intent: intentName,
+        status: 'runnable',
+        reason: null,
+        detail: null,
+    };
+}
+export function createVerificationPlan(contract, reason) {
+    const candidates = Object.entries(contract.intents)
+        .filter(([, intent]) => isRecord(intent) && hasRequiredAfter(intent, reason))
+        .map(([intentName, intent]) => classifyVerificationCandidate(intentName, intent))
+        .sort((left, right) => left.intent.localeCompare(right.intent));
+    return {
+        reason,
+        candidates: candidates.length > 0
+            ? candidates
+            : [
+                {
+                    intent: '',
+                    status: 'skipped',
+                    reason: 'no_matching_intents',
+                    detail: `No command intents declare required_after = "${reason}".`,
+                },
+            ],
+    };
+}

package/dist/core/verification-scheduler.js

@@ -0,0 +1,92 @@
+import { commandEffectsConflict, normalizeCommandEffects, } from './command-effects.js';
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function toScheduleEffect(effect) {
+    return {
+        intent: effect.intent,
+        source: effect.source,
+        access: effect.access,
+        mode: effect.mode,
+        path: effect.path,
+        lock: effect.lock,
+        concurrency: effect.concurrency,
+    };
+}
+function entriesConflict(left, right) {
+    const conflicts = [];
+    for (const leftEffect of left.effects) {
+        for (const rightEffect of right.effects) {
+            if (!commandEffectsConflict(leftEffect, rightEffect)) {
+                continue;
+            }
+            conflicts.push({
+                intent: left.intent,
+                conflictsWith: right.intent,
+                lock: leftEffect.lock,
+                detail: `${left.intent} and ${right.intent} both touch ${leftEffect.lock}; run them serially.`,
+            });
+        }
+    }
+    return conflicts;
+}
+function addEntryToBatches(batches, batchEntries, entry) {
+    for (let batchIndex = 0; batchIndex < batchEntries.length; batchIndex += 1) {
+        const existingEntries = batchEntries[batchIndex] ?? [];
+        const hasConflict = existingEntries.some((existing) => entriesConflict(entry, existing).length > 0);
+        if (hasConflict) {
+            continue;
+        }
+        existingEntries.push(entry);
+        batchEntries[batchIndex] = existingEntries;
+        batches[batchIndex] = {
+            index: batchIndex + 1,
+            intents: uniqueSorted(existingEntries.map((item) => item.intent)),
+            locks: uniqueSorted(existingEntries.flatMap((item) => item.locks)),
+        };
+        return;
+    }
+    const index = batches.length + 1;
+    batchEntries.push([entry]);
+    batches.push({
+        index,
+        intents: [entry.intent],
+        locks: entry.locks,
+    });
+}
+export function createVerificationSchedule(projectRoot, commandContract, candidates) {
+    const runnableIntents = uniqueSorted(candidates
+        .filter((candidate) => candidate.status === 'runnable' && candidate.intent.length > 0)
+        .map((candidate) => candidate.intent));
+    const baseEntries = runnableIntents.map((intent) => {
+        const effects = normalizeCommandEffects(projectRoot, commandContract, intent).map(toScheduleEffect);
+        return {
+            intent,
+            status: 'runnable',
+            effects,
+            locks: uniqueSorted(effects.map((effect) => effect.lock)),
+            conflicts: [],
+        };
+    });
+    const entries = baseEntries.map((entry) => ({
+        ...entry,
+        conflicts: baseEntries
+            .filter((other) => other.intent !== entry.intent)
+            .flatMap((other) => entriesConflict(entry, other))
+            .sort((left, right) => left.conflictsWith.localeCompare(right.conflictsWith) || left.lock.localeCompare(right.lock)),
+    }));
+    const batches = [];
+    const batchEntries = [];
+    for (const entry of entries) {
+        addEntryToBatches(batches, batchEntries, entry);
+    }
+    return {
+        runner: 'serial_mf_run_receipts',
+        batches,
+        entries,
+        notes: [
+            'Batches explain resource compatibility for planning only.',
+            'mf run still writes the latest receipt to a single path, so execute copied commands serially.',
+        ],
+    };
+}

package/dist/core/version-impact.js

@@ -0,0 +1,54 @@
+const METADATA_REASONS = new Set([
+    'package_metadata_change',
+    'template_version_change',
+    'packaging_change',
+]);
+const CONTRACT_REASONS = new Set([
+    'public_api_change',
+]);
+const RELEASE_SENSITIVE_REASONS = new Set([
+    ...METADATA_REASONS,
+    ...CONTRACT_REASONS,
+    'release_risk',
+]);
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+export function summarizeVersionImpact(classificationReport, versionSources) {
+    const changedFiles = new Set(classificationReport.files);
+    const affectedVersionSources = versionSources
+        .filter((source) => changedFiles.has(source.path))
+        .map((source) => source.path);
+    const validationReasons = new Set(classificationReport.summary.validationReasons);
+    const reasons = [];
+    const hasMetadataImpact = affectedVersionSources.length > 0 || [...validationReasons].some((reason) => METADATA_REASONS.has(reason));
+    const hasContractImpact = [...validationReasons].some((reason) => CONTRACT_REASONS.has(reason));
+    if (affectedVersionSources.length > 0) {
+        reasons.push('version_source_changed');
+    }
+    if (validationReasons.has('package_metadata_change')) {
+        reasons.push('package_metadata_changed');
+    }
+    if (validationReasons.has('template_version_change')) {
+        reasons.push('template_surface_changed');
+    }
+    if (validationReasons.has('public_api_change')) {
+        reasons.push('public_contract_changed');
+    }
+    if ([...validationReasons].some((reason) => RELEASE_SENSITIVE_REASONS.has(reason))) {
+        reasons.push('release_sensitive_surface_changed');
+    }
+    const affectedSurfaces = uniqueSorted(classificationReport.classifications
+        .filter((classification) => classification.surface.isPublicSurface)
+        .map((classification) => classification.surface.kind));
+    const severity = hasContractImpact ? 'contract' : hasMetadataImpact ? 'metadata' : 'none';
+    const requiresVersionDecision = reasons.length > 0;
+    return {
+        requiresVersionDecision,
+        severity,
+        suggestedBump: severity === 'contract' ? 'minor' : severity === 'metadata' ? 'patch' : null,
+        reasons: uniqueSorted(reasons),
+        affectedVersionSources: uniqueSorted(affectedVersionSources),
+        affectedSurfaces,
+    };
+}

package/dist/core/version-sources.js

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { isRecord } from './config-loading.js';
+import { readTomlFile } from './toml.js';
+const RELEASE_VERSIONING_ACTIVE_FIELDS = [
+    'impact_check',
+    'suggest_bump',
+    'auto_bump',
+    'sync_template_version',
+    'sync_docs_examples',
+    'sync_tests',
+];
+export const VERSIONING_CONFIG_PATH = '.mustflow/config/versioning.toml';
+export const VERSION_SOURCE_KINDS = ['template_lock', 'template_manifest', 'package_manifest'];
+export const VERSION_SOURCE_AUTHORITIES = ['source', 'derived'];
+const VERSION_SOURCE_CANDIDATE_FILES = [
+    {
+        relativePath: '.mustflow/config/manifest.lock.toml',
+        kind: 'template_lock',
+        pattern: /^\s*version\s*=\s*["'][^"']+["']/mu,
+    },
+    {
+        relativePath: 'templates/default/manifest.toml',
+        kind: 'template_manifest',
+        pattern: /^\s*version\s*=\s*["'][^"']+["']/mu,
+    },
+    { relativePath: 'package.json', kind: 'package_manifest', mode: 'json' },
+    { relativePath: 'pyproject.toml', kind: 'package_manifest', pattern: /^\s*version\s*=\s*["'][^"']+["']/mu },
+    { relativePath: 'Cargo.toml', kind: 'package_manifest', pattern: /^\s*version\s*=\s*["'][^"']+["']/mu },
+    { relativePath: 'deno.json', kind: 'package_manifest', mode: 'json' },
+    { relativePath: 'deno.jsonc', kind: 'package_manifest', pattern: /"version"\s*:\s*"[^"]+"/u },
+    { relativePath: 'jsr.json', kind: 'package_manifest', mode: 'json' },
+    { relativePath: 'jsr.jsonc', kind: 'package_manifest', pattern: /"version"\s*:\s*"[^"]+"/u },
+    { relativePath: 'composer.json', kind: 'package_manifest', mode: 'json' },
+    { relativePath: 'pom.xml', kind: 'package_manifest', pattern: /<version>[^<]+<\/version>/u },
+    { relativePath: 'build.gradle', kind: 'package_manifest', pattern: /^\s*version\s*=/mu },
+    { relativePath: 'build.gradle.kts', kind: 'package_manifest', pattern: /^\s*version\s*=/mu },
+    { relativePath: 'pubspec.yaml', kind: 'package_manifest', pattern: /^\s*version\s*:\s*\S+/mu },
+    { relativePath: 'Chart.yaml', kind: 'package_manifest', pattern: /^\s*version\s*:\s*\S+/mu },
+];
+const GO_RELEASE_TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u;
+const VERSION_SOURCE_ROOT_FILE_PATTERNS = [
+    {
+        suffix: '.csproj',
+        kind: 'package_manifest',
+        pattern: /<(?:Version|PackageVersion)>[^<]+<\/(?:Version|PackageVersion)>/u,
+    },
+    {
+        suffix: '.fsproj',
+        kind: 'package_manifest',
+        pattern: /<(?:Version|PackageVersion)>[^<]+<\/(?:Version|PackageVersion)>/u,
+    },
+    {
+        suffix: '.vbproj',
+        kind: 'package_manifest',
+        pattern: /<(?:Version|PackageVersion)>[^<]+<\/(?:Version|PackageVersion)>/u,
+    },
+    { suffix: '.gemspec', kind: 'package_manifest', pattern: /\.version\s*=/u },
+];
+function isSafeRelativePath(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return false;
+    }
+    const normalized = value.replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(value)) {
+        return false;
+    }
+    return segments.length > 0 && segments.every((segment) => segment !== '.' && segment !== '..');
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function isVersionSourceKind(value) {
+    return typeof value === 'string' && VERSION_SOURCE_KINDS.includes(value);
+}
+function isVersionSourceAuthority(value) {
+    return typeof value === 'string' && VERSION_SOURCE_AUTHORITIES.includes(value);
+}
+function hasJsonVersion(filePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        return isRecord(parsed) && typeof parsed.version === 'string' && parsed.version.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function hasVersionPattern(filePath, pattern) {
+    try {
+        return pattern.test(readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return false;
+    }
+}
+function hasVersionSourceCandidate(projectRoot, candidate) {
+    const filePath = path.join(projectRoot, candidate.relativePath);
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    if ('mode' in candidate && candidate.mode === 'json') {
+        return hasJsonVersion(filePath);
+    }
+    return 'pattern' in candidate && hasVersionPattern(filePath, candidate.pattern);
+}
+function resolveGitDirectory(projectRoot) {
+    const gitPath = path.join(projectRoot, '.git');
+    if (!existsSync(gitPath)) {
+        return undefined;
+    }
+    try {
+        if (statSync(gitPath).isDirectory()) {
+            return gitPath;
+        }
+        const match = /^gitdir:\s*(.+)$/imu.exec(readFileSync(gitPath, 'utf8'));
+        if (!match) {
+            return undefined;
+        }
+        const gitDirectory = match[1].trim();
+        return path.resolve(projectRoot, gitDirectory);
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasSemverReleaseTag(projectRoot) {
+    const gitDirectory = resolveGitDirectory(projectRoot);
+    if (!gitDirectory) {
+        return false;
+    }
+    const tagRoot = path.join(gitDirectory, 'refs', 'tags');
+    try {
+        for (const entry of readdirSync(tagRoot, { withFileTypes: true })) {
+            if (entry.isFile() && GO_RELEASE_TAG_PATTERN.test(entry.name)) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // Packed tags are checked below.
+    }
+    try {
+        const packedRefs = readFileSync(path.join(gitDirectory, 'packed-refs'), 'utf8');
+        return packedRefs
+            .split(/\r?\n/u)
+            .some((line) => GO_RELEASE_TAG_PATTERN.test(line.replace(/^.*\srefs\/tags\//u, '').trim()));
+    }
+    catch {
+        return false;
+    }
+}
+function hasGoModuleVersionSource(projectRoot) {
+    return existsSync(path.join(projectRoot, 'go.mod')) && hasSemverReleaseTag(projectRoot);
+}
+export function readDeclaredVersionSources(projectRoot) {
+    try {
+        const versioningConfig = readTomlFile(path.join(projectRoot, VERSIONING_CONFIG_PATH));
+        if (!isRecord(versioningConfig) || !Array.isArray(versioningConfig.sources)) {
+            return [];
+        }
+        return versioningConfig.sources.flatMap((source) => {
+            if (!isRecord(source) || !isSafeRelativePath(source.path) || !isVersionSourceKind(source.kind)) {
+                return [];
+            }
+            const versionSource = {
+                path: toPosixPath(source.path),
+                kind: source.kind,
+                declared: true,
+            };
+            return isVersionSourceAuthority(source.authority)
+                ? [{ ...versionSource, authority: source.authority }]
+                : [versionSource];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * mf:anchor core.version.sources.detect
+ * purpose: Detect repository version sources before suggesting or applying version changes.
+ * search: version source, package metadata, template version, release tag, auto bump
+ * invariant: Declared version sources are preferred before fallback candidate detection.
+ * risk: config, data_consistency
+ */
+export function detectVersionSources(projectRoot) {
+    const sources = readDeclaredVersionSources(projectRoot);
+    sources.push(...VERSION_SOURCE_CANDIDATE_FILES.filter((candidate) => hasVersionSourceCandidate(projectRoot, candidate)).map((candidate) => ({
+        path: toPosixPath(candidate.relativePath),
+        kind: candidate.kind,
+    })));
+    if (hasGoModuleVersionSource(projectRoot)) {
+        sources.push({ path: 'go.mod', kind: 'package_manifest' });
+    }
+    try {
+        for (const entry of readdirSync(projectRoot, { withFileTypes: true })) {
+            if (!entry.isFile()) {
+                continue;
+            }
+            const match = VERSION_SOURCE_ROOT_FILE_PATTERNS.find((candidate) => entry.name.endsWith(candidate.suffix));
+            if (match && hasVersionPattern(path.join(projectRoot, entry.name), match.pattern)) {
+                sources.push({ path: toPosixPath(entry.name), kind: match.kind });
+            }
+        }
+    }
+    catch {
+        return uniqueVersionSources(sources);
+    }
+    return uniqueVersionSources(sources);
+}
+function uniqueVersionSources(sources) {
+    const byKey = new Map();
+    for (const source of sources) {
+        const key = `${source.kind}:${source.path}`;
+        const existing = byKey.get(key);
+        if (!existing || source.declared === true) {
+            byKey.set(key, source);
+        }
+    }
+    return [...byKey.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+export function detectVersionSourcePaths(projectRoot) {
+    return detectVersionSources(projectRoot).map((source) => source.path);
+}
+export function releaseVersioningIsEnabled(preferencesToml) {
+    if (!preferencesToml || !isRecord(preferencesToml.release)) {
+        return false;
+    }
+    const { versioning } = preferencesToml.release;
+    if (!isRecord(versioning)) {
+        return false;
+    }
+    return RELEASE_VERSIONING_ACTIVE_FIELDS.some((field) => versioning[field] === true);
+}