@vibesdotdev/tools 0.0.0-stage → 1.0.0-rc.3

package/dist/codemod/fold/planner.consumer.js

@@ -0,0 +1,1178 @@
+import { basename } from '@vibesdotdev/filesystem/core';
+import { attemptSync, failureLabel } from "../../shared/attempt.js";
+import { DependencyMapSchema, JsonObjectSchema, PackageManifestSchema, PeerDependenciesMetaSchema, jsonArrayOf, jsonObjectOf, mapJson, stringsOf } from "./manifest.js";
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'optionalDependencies',
+    'peerDependencies',
+    'devDependencies'
+];
+const EXECUTABLE_EXTENSIONS = /\.(?:[cm]?[jt]sx?|svelte|jsonc|css|scss|pcss|html|yaml|yml)$/;
+const REQUIRED_SPEC_SECTIONS = [
+    'Owns',
+    'Does not own',
+    'Hard rules',
+    'Public entrypoints',
+    'Verification'
+];
+const HANDLED_SURFACE_MANIFEST_FIELDS = new Set([
+    'name',
+    'version',
+    'description',
+    'keywords',
+    'author',
+    'contributors',
+    'funding',
+    'homepage',
+    'bugs',
+    'repository',
+    'license',
+    'private',
+    'type',
+    'main',
+    'types',
+    'exports',
+    'files',
+    'scripts',
+    'dependencies',
+    'optionalDependencies',
+    'peerDependencies',
+    'peerDependenciesMeta',
+    'devDependencies',
+    'publishConfig',
+    'sideEffects',
+    'vibes'
+]);
+function containsPackageReference(content, packageName) {
+    let fromIndex = 0;
+    while (fromIndex < content.length) {
+        const index = content.indexOf(packageName, fromIndex);
+        if (index === -1)
+            return false;
+        const before = content[index - 1];
+        const after = content[index + packageName.length];
+        const continuesPackageName = (character) => character !== undefined && /[A-Za-z0-9._-]/.test(character);
+        if (!continuesPackageName(before) && !continuesPackageName(after))
+            return true;
+        fromIndex = index + packageName.length;
+    }
+    return false;
+}
+function stableJson(value) {
+    return `${JSON.stringify(value, null, '\t')}\n`;
+}
+function normalizeJsonc(content) {
+    let uncommented = '';
+    let inString = false;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const character = content[index];
+        const next = content[index + 1];
+        if (lineComment) {
+            if (character === '\n') {
+                lineComment = false;
+                uncommented += character;
+            }
+            else
+                uncommented += ' ';
+            continue;
+        }
+        if (blockComment) {
+            if (character === '*' && next === '/') {
+                blockComment = false;
+                uncommented += '  ';
+                index += 1;
+            }
+            else
+                uncommented += character === '\n' ? '\n' : ' ';
+            continue;
+        }
+        if (!inString && character === '/' && next === '/') {
+            lineComment = true;
+            uncommented += '  ';
+            index += 1;
+            continue;
+        }
+        if (!inString && character === '/' && next === '*') {
+            blockComment = true;
+            uncommented += '  ';
+            index += 1;
+            continue;
+        }
+        uncommented += character;
+        if (inString && character === '\\' && !escaped) {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' && !escaped)
+            inString = !inString;
+        escaped = false;
+    }
+    let normalized = '';
+    inString = false;
+    escaped = false;
+    for (let index = 0; index < uncommented.length; index += 1) {
+        const character = uncommented[index];
+        if (!inString && character === ',') {
+            let nextIndex = index + 1;
+            while (/\s/.test(uncommented[nextIndex] ?? ''))
+                nextIndex += 1;
+            if (uncommented[nextIndex] === '}' || uncommented[nextIndex] === ']')
+                continue;
+        }
+        normalized += character;
+        if (inString && character === '\\' && !escaped) {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' && !escaped)
+            inString = !inString;
+        escaped = false;
+    }
+    return normalized;
+}
+function parseObject(content, path, blockers) {
+    const text = /(^|\/)tsconfig(?:\.[^/]+)?\.json$/.test(path) ? normalizeJsonc(content) : content;
+    const parsed = attemptSync(() => JSON.parse(text));
+    if (!parsed.ok) {
+        blockers.push({
+            code: 'INVALID_JSON',
+            message: `${path} is not valid JSON (${failureLabel(parsed.failure)}).`,
+            paths: [path]
+        });
+        return null;
+    }
+    const object = JsonObjectSchema.safeParse(parsed.value);
+    if (object.success)
+        return object.data;
+    blockers.push({
+        code: 'INVALID_JSON',
+        message: `${path} must contain a JSON object.`,
+        paths: [path]
+    });
+    return null;
+}
+function clone(value) {
+    return structuredClone(value);
+}
+function packageRecords(snapshot, blockers) {
+    const records = [];
+    const names = new Map();
+    const files = new Map(snapshot.files.map((file) => [file.path, file]));
+    for (const target of snapshot.workspaceTargets) {
+        const file = files.get(target.manifestPath);
+        if (!file) {
+            blockers.push({
+                code: 'MISSING_WORKSPACE_MANIFEST_EVIDENCE',
+                message: `${target.manifestPath} is classified but absent from the immutable snapshot.`,
+                paths: [target.manifestPath]
+            });
+            continue;
+        }
+        if (file.content === undefined) {
+            blockers.push({
+                code: 'UNREADABLE_MANIFEST',
+                message: `${file.path} is not UTF-8 text.`,
+                paths: [file.path]
+            });
+            continue;
+        }
+        const object = parseObject(file.content, file.path, blockers);
+        if (!object)
+            continue;
+        const manifest = PackageManifestSchema.safeParse(object);
+        if (!manifest.success) {
+            blockers.push({
+                code: 'INVALID_MANIFEST',
+                message: `${file.path} is not a package manifest: ${[...new Set(manifest.error.issues.map((issue) => issue.path.join('.') || '(root)'))].join(', ')}.`,
+                paths: [file.path]
+            });
+            continue;
+        }
+        const parsed = manifest.data;
+        if (!parsed.name) {
+            blockers.push({
+                code: 'NAMELESS_WORKSPACE_MANIFEST',
+                message: `${file.path} is a canonical workspace manifest without a package name.`,
+                paths: [file.path]
+            });
+            continue;
+        }
+        const duplicate = names.get(parsed.name);
+        if (duplicate) {
+            blockers.push({
+                code: 'DUPLICATE_WORKSPACE_PACKAGE_NAME',
+                message: `${parsed.name} is declared by multiple canonical workspace manifests.`,
+                paths: [duplicate, file.path].sort()
+            });
+        }
+        else
+            names.set(parsed.name, file.path);
+        records.push({
+            path: file.path,
+            dir: target.root,
+            manifest: parsed,
+            artifact: target.artifact
+        });
+    }
+    return records.sort((left, right) => left.manifest.name.localeCompare(right.manifest.name));
+}
+function resolvePackage(records, input) {
+    return records.find((record) => record.manifest.name === input ||
+        record.dir === input.replace(/\/$/, '') ||
+        record.dir === `${input.replace(/^@vibesdotdev\//, '')}`);
+}
+function dependencyNames(manifest) {
+    return [
+        ...new Set(DEPENDENCY_SECTIONS.flatMap((section) => Object.keys(manifest[section] ?? {})))
+    ].sort();
+}
+function isExecutableConsumerPath(path) {
+    return (EXECUTABLE_EXTENSIONS.test(path) ||
+        path.endsWith('/package.json') ||
+        path === 'package.json' ||
+        /(^|\/)tsconfig(?:\.[^/]+)?\.json$/.test(path));
+}
+function isHistoricalEvidencePath(path) {
+    return (/^(?:docs|provenance|receipts)\//.test(path) ||
+        /(?:^|\/)(?:validation-report|audit-report|[^/]*ledger)(?:\.[^/]*)?$/i.test(path));
+}
+function packageGraph(records) {
+    return records.map((record) => ({
+        name: record.manifest.name,
+        dependencies: dependencyNames(record.manifest)
+    }));
+}
+function mapTarget(target, subpath) {
+    return mapJson(target, {
+        text: (value) => value
+            .replace(/^\.\/src(?:\/|$)/, `./src/${subpath}/`)
+            .replace(/^\.\/dist(?:\/|$)/, `./dist/${subpath}/`),
+        key: (name) => name
+    });
+}
+function mapExports(exportsMap, subpath) {
+    return Object.fromEntries(Object.entries(exportsMap).map(([key, target]) => [
+        key === '.' ? `./${subpath}` : `./${subpath}${key.slice(1)}`,
+        mapTarget(target, subpath)
+    ]));
+}
+function replacePathStrings(value, surfaceName, targetName, subpath) {
+    return mapJson(value, {
+        text: (text) => {
+            if (text === surfaceName)
+                return targetName;
+            return text
+                .replaceAll(surfaceName, targetName)
+                .replace(/(^|\/)src(?=\/|$)/g, `$1src/${subpath}`)
+                .replace(/(^|\/)dist(?=\/|$)/g, `$1dist/${subpath}`)
+                .replace(/(^|\/)(test|tests|__tests__)(?=\/|$)/g, `$1$2/${subpath}`);
+        },
+        key: (name) => name.replaceAll(surfaceName, targetName)
+    });
+}
+function mergeDependency(target, name, range, blockers, path) {
+    const existing = target[name];
+    if (existing && existing !== range) {
+        blockers.push({
+            code: 'DEPENDENCY_RANGE_CONFLICT',
+            message: `${name} has incompatible ranges ${existing} and ${range}; choose one explicitly.`,
+            paths: [path]
+        });
+        return;
+    }
+    target[name] = range;
+}
+function dependencyRangesAreCompatible(left, right) {
+    if (left === right)
+        return true;
+    if (left.startsWith('workspace:') && right.startsWith('workspace:'))
+        return true;
+    return false;
+}
+function rewriteManifestDependency(content, oldName, baseName) {
+    const manifest = JsonObjectSchema.parse(JSON.parse(content));
+    let replacements = 0;
+    for (const section of DEPENDENCY_SECTIONS) {
+        const parsed = DependencyMapSchema.safeParse(manifest[section]);
+        if (!parsed.success || !parsed.data[oldName])
+            continue;
+        const dependencies = parsed.data;
+        if (!dependencies[baseName])
+            dependencies[baseName] = dependencies[oldName];
+        delete dependencies[oldName];
+        manifest[section] = dependencies;
+        replacements += 1;
+    }
+    const meta = PeerDependenciesMetaSchema.safeParse(manifest.peerDependenciesMeta);
+    if (meta.success && meta.data[oldName]) {
+        meta.data[baseName] ??= meta.data[oldName];
+        delete meta.data[oldName];
+        manifest.peerDependenciesMeta = meta.data;
+        replacements += 1;
+    }
+    return { content: replacements > 0 ? stableJson(manifest) : content, replacements };
+}
+function rewriteSpecifiers(content, oldName, targetName) {
+    const expression = new RegExp(`${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[/"'])`, 'g');
+    let replacements = 0;
+    return {
+        content: content.replace(expression, () => {
+            replacements += 1;
+            return targetName;
+        }),
+        replacements
+    };
+}
+function writeOperation(sha256Hex, path, beforeSha256, content, reason) {
+    return { kind: 'write', path, beforeSha256, afterSha256: sha256Hex(content), content, reason };
+}
+function mappedPackageConfigPath(baseDir, relative, subpath) {
+    const [tool, , ...extension] = relative.split('.');
+    return `${baseDir}/${tool}.${subpath}.config.${extension.join('.')}`;
+}
+function mapSideEffectPattern(pattern, subpath) {
+    if (pattern.startsWith('./src/'))
+        return pattern.replace('./src/', `./src/${subpath}/`);
+    if (pattern.startsWith('src/'))
+        return pattern.replace('src/', `src/${subpath}/`);
+    if (pattern.startsWith('./dist/'))
+        return pattern.replace('./dist/', `./dist/${subpath}/`);
+    if (pattern.startsWith('dist/'))
+        return pattern.replace('dist/', `dist/${subpath}/`);
+    return pattern;
+}
+function mapSurfaceCommandPaths(command, subpath) {
+    return command
+        .replace(/(^|[\s"'=])src\//g, `$1src/${subpath}/`)
+        .replace(/(^|[\s"'=])test\//g, `$1test/${subpath}/`)
+        .replace(/(^|[\s"'=])tests\//g, `$1tests/${subpath}/`)
+        .replace(/(^|[\s"'=])__tests__\//g, `$1__tests__/${subpath}/`);
+}
+function namespacedScriptName(name, subpath) {
+    const [root, ...rest] = name.split(':');
+    return [root, subpath, ...rest].join(':');
+}
+function rewritePackageConfigContent(content, surfaceName, targetName, subpath) {
+    const namespaceRewrite = rewriteSpecifiers(content, surfaceName, targetName);
+    let rewritten = namespaceRewrite.content;
+    let replacements = namespaceRewrite.replacements;
+    rewritten = rewritten.replace(/(["'])\.\/(src|test|tests|__tests__)\//g, (_match, quote, root) => {
+        replacements += 1;
+        return `${quote}./${root === 'src' ? `src/${subpath}` : `${root}/${subpath}`}/`;
+    });
+    const unsupportedRelativeImports = [
+        ...new Set([
+            ...rewritten.matchAll(/(?:from\s*|import\s*(?:\(\s*)?|require\s*\(\s*)["'](\.\/[^"']+)["']/g)
+        ]
+            .map((match) => match[1])
+            .filter((specifier) => !specifier.startsWith(`./src/${subpath}/`) &&
+            !specifier.startsWith(`./test/${subpath}/`) &&
+            !specifier.startsWith(`./tests/${subpath}/`) &&
+            !specifier.startsWith(`./__tests__/${subpath}/`)))
+    ].sort();
+    return { content: rewritten, replacements, unsupportedRelativeImports };
+}
+export function compileFoldPlan(snapshot, baseInput, surfaceInput, authorities) {
+    const blockers = [];
+    const files = new Map(snapshot.files.map((file) => [file.path, file]));
+    const packages = packageRecords(snapshot, blockers);
+    const base = resolvePackage(packages, baseInput);
+    const surface = resolvePackage(packages, surfaceInput);
+    if (!base || !surface) {
+        const missing = [!base ? baseInput : null, !surface ? surfaceInput : null].filter((entry) => Boolean(entry));
+        throw new Error(`Workspace package not found: ${missing.join(', ')}`);
+    }
+    const baseName = base.manifest.name;
+    const surfaceName = surface.manifest.name;
+    const prefix = `${baseName}-`;
+    if (base.artifact !== 'package' || surface.artifact !== 'package') {
+        blockers.push({
+            code: 'NON_PACKAGE_FOLD_TARGET',
+            message: 'Only canonical package artifacts may participate in a base/surface fold.',
+            paths: [base.path, surface.path]
+        });
+    }
+    if (!surfaceName.startsWith(prefix)) {
+        blockers.push({
+            code: 'OWNERSHIP_MISMATCH',
+            message: `${surfaceName} is not a surface sibling of ${baseName}; ownership cannot be derived safely.`,
+            paths: [base.path, surface.path]
+        });
+    }
+    const subpath = surfaceName.startsWith(prefix) ? surfaceName.slice(prefix.length) : 'unknown';
+    const targetName = `${baseName}/${subpath}`;
+    const destinationSource = `${base.dir}/src/${subpath}`;
+    const surfaceSource = `${surface.dir}/src/`;
+    if (snapshot.files.some((file) => file.path.startsWith(`${destinationSource}/`))) {
+        blockers.push({
+            code: 'DESTINATION_EXISTS',
+            message: `${destinationSource} already contains files; refusing to overlay ownership.`,
+            paths: [destinationSource]
+        });
+    }
+    const beforeCycles = authorities
+        .findPackageCycles(packageGraph(packages))
+        .map((cycle) => [...cycle.packages]);
+    if (beforeCycles.length > 0) {
+        blockers.push({
+            code: 'PRE_FOLD_CYCLE',
+            message: 'The workspace graph is cyclic before the fold; no contraction can be attributed safely.',
+            paths: beforeCycles.flat()
+        });
+    }
+    const nextManifest = clone(base.manifest);
+    for (const field of Object.keys(surface.manifest).sort()) {
+        if (HANDLED_SURFACE_MANIFEST_FIELDS.has(field))
+            continue;
+        blockers.push({
+            code: 'UNHANDLED_SURFACE_MANIFEST_FIELD',
+            message: `Surface manifest field ${field} has no proven lossless fold rule.`,
+            paths: [surface.path]
+        });
+    }
+    for (const field of ['type', 'license', 'private', 'publishConfig']) {
+        const surfaceValue = surface.manifest[field];
+        if (surfaceValue === undefined)
+            continue;
+        const baseValue = nextManifest[field];
+        if (baseValue === undefined)
+            nextManifest[field] = clone(surfaceValue);
+        else if (JSON.stringify(baseValue) !== JSON.stringify(surfaceValue)) {
+            blockers.push({
+                code: 'MANIFEST_CONTRACT_CONFLICT',
+                message: `Base and surface ${field} contracts differ and require explicit adjudication.`,
+                paths: [base.path, surface.path]
+            });
+        }
+    }
+    const surfaceVibes = jsonObjectOf(surface.manifest.vibes);
+    if (surfaceVibes) {
+        const unhandledVibes = Object.keys(surfaceVibes).filter((field) => field !== 'visibility');
+        if (unhandledVibes.length > 0) {
+            blockers.push({
+                code: 'UNHANDLED_SURFACE_MANIFEST_FIELD',
+                message: `Surface vibes metadata has no fold rule: ${unhandledVibes.sort().join(', ')}.`,
+                paths: [surface.path]
+            });
+        }
+        const visibility = surfaceVibes.visibility;
+        if (visibility !== undefined) {
+            const baseVibes = jsonObjectOf(nextManifest.vibes) ?? {};
+            if (baseVibes.visibility !== undefined && baseVibes.visibility !== visibility) {
+                blockers.push({
+                    code: 'MANIFEST_CONTRACT_CONFLICT',
+                    message: 'Base and surface visibility contracts differ.',
+                    paths: [base.path, surface.path]
+                });
+            }
+            else
+                baseVibes.visibility = visibility;
+            nextManifest.vibes = baseVibes;
+        }
+    }
+    nextManifest.exports ??= {};
+    const mappedExports = mapExports(surface.manifest.exports ?? { '.': './dist/index.js' }, subpath);
+    for (const [key, value] of Object.entries(mappedExports)) {
+        if (key in nextManifest.exports) {
+            blockers.push({
+                code: 'EXPORT_COLLISION',
+                message: `Base export ${key} already exists.`,
+                paths: [base.path]
+            });
+        }
+        else
+            nextManifest.exports[key] = value;
+    }
+    const surfaceSideEffects = surface.manifest.sideEffects;
+    if (surfaceSideEffects !== undefined) {
+        if (surfaceSideEffects === true || surfaceSideEffects === false) {
+            if (nextManifest.sideEffects !== undefined && nextManifest.sideEffects !== surfaceSideEffects) {
+                blockers.push({
+                    code: 'MANIFEST_CONTRACT_CONFLICT',
+                    message: 'Base and surface sideEffects booleans differ.',
+                    paths: [base.path, surface.path]
+                });
+            }
+            else
+                nextManifest.sideEffects = surfaceSideEffects;
+        }
+        else {
+            const baseSideEffects = nextManifest.sideEffects;
+            if (baseSideEffects === true || baseSideEffects === false) {
+                blockers.push({
+                    code: 'MANIFEST_CONTRACT_CONFLICT',
+                    message: 'Array surface sideEffects cannot be merged into a boolean base contract.',
+                    paths: [base.path, surface.path]
+                });
+            }
+            else {
+                nextManifest.sideEffects = [
+                    ...new Set([
+                        ...(baseSideEffects ?? []),
+                        ...surfaceSideEffects.map((pattern) => mapSideEffectPattern(pattern, subpath))
+                    ])
+                ].sort();
+            }
+        }
+    }
+    nextManifest.peerDependencies ??= {};
+    nextManifest.devDependencies ??= {};
+    nextManifest.peerDependenciesMeta ??= {};
+    const optionalPeerDevPairs = new Set();
+    const surfaceRuntimeRanges = new Map();
+    for (const section of ['dependencies', 'optionalDependencies', 'peerDependencies']) {
+        for (const [name, range] of Object.entries(surface.manifest[section] ?? {})) {
+            if (name === baseName)
+                continue;
+            const declarations = surfaceRuntimeRanges.get(name) ?? new Map();
+            declarations.set(section, range);
+            surfaceRuntimeRanges.set(name, declarations);
+        }
+    }
+    for (const [name, declarations] of [...surfaceRuntimeRanges].sort(([left], [right]) => left.localeCompare(right))) {
+        const distinctRanges = [...new Set(declarations.values())];
+        if (distinctRanges.length !== 1) {
+            blockers.push({
+                code: 'DEPENDENCY_RANGE_CONFLICT',
+                message: `${name} has conflicting surface runtime ranges: ${[...declarations]
+                    .map(([section, range]) => `${section}=${range}`)
+                    .join(', ')}.`,
+                paths: [surface.path]
+            });
+        }
+        const range = distinctRanges[0];
+        const hardBaseSections = ['dependencies', 'optionalDependencies'];
+        const hardBaseSection = hardBaseSections.find((section) => nextManifest[section]?.[name]);
+        if (hardBaseSection) {
+            blockers.push({
+                code: 'HARD_SURFACE_DEPENDENCY',
+                message: `${name} is a hard base ${hardBaseSection} entry; the folded optional surface cannot preserve isolation.`,
+                paths: [base.path, surface.path]
+            });
+        }
+        if (nextManifest.peerDependencies?.[name] &&
+            nextManifest.peerDependenciesMeta?.[name]?.optional !== true) {
+            blockers.push({
+                code: 'NONOPTIONAL_BASE_PEER',
+                message: `${name} is an existing nonoptional base peer; folding cannot silently weaken that contract.`,
+                paths: [base.path]
+            });
+        }
+        mergeDependency(nextManifest.peerDependencies, name, range, blockers, base.path);
+        const devRange = surface.manifest.devDependencies?.[name] ?? range;
+        const existingDevRange = nextManifest.devDependencies[name];
+        if (existingDevRange && !dependencyRangesAreCompatible(existingDevRange, devRange)) {
+            blockers.push({
+                code: 'DEPENDENCY_RANGE_CONFLICT',
+                message: `${name} has incompatible base dev range ${existingDevRange} and surface dev range ${devRange}.`,
+                paths: [base.path, surface.path]
+            });
+        }
+        else if (!existingDevRange)
+            nextManifest.devDependencies[name] = devRange;
+        nextManifest.peerDependenciesMeta[name] = {
+            ...nextManifest.peerDependenciesMeta[name],
+            optional: true
+        };
+        optionalPeerDevPairs.add(name);
+    }
+    for (const [name, range] of Object.entries(surface.manifest.devDependencies ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (name === baseName || surfaceRuntimeRanges.has(name))
+            continue;
+        nextManifest.devDependencies[name] ??= range;
+    }
+    const vibes = jsonObjectOf(nextManifest.vibes) ?? {};
+    const existingProfiles = jsonArrayOf(vibes.publishProofProfiles);
+    if (vibes.publishProofProfiles !== undefined && !existingProfiles) {
+        blockers.push({
+            code: 'INVALID_PUBLISH_PROOF_PROFILES',
+            message: 'vibes.publishProofProfiles must be an array before a folded surface profile can be added.',
+            paths: [base.path]
+        });
+    }
+    const profiles = existingProfiles ?? [];
+    const profile = {
+        id: `fold:${subpath}`,
+        requiredOptionalPeers: [...optionalPeerDevPairs].sort(),
+        importSpecifiers: [baseName, targetName]
+    };
+    const priorProfile = profiles.find((entry) => jsonObjectOf(entry)?.id === profile.id);
+    if (priorProfile && JSON.stringify(priorProfile) !== JSON.stringify(profile)) {
+        blockers.push({
+            code: 'PUBLISH_PROOF_PROFILE_COLLISION',
+            message: `Registry publish proof profile ${profile.id} already exists with a different contract.`,
+            paths: [base.path]
+        });
+    }
+    else if (!priorProfile)
+        profiles.push(profile);
+    vibes.publishProofProfiles = profiles;
+    nextManifest.vibes = vibes;
+    const sourceFiles = snapshot.files
+        .filter((file) => file.path.startsWith(surfaceSource))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    if (sourceFiles.length === 0) {
+        blockers.push({
+            code: 'EMPTY_SURFACE',
+            message: `${surface.dir}/src has no files to fold.`,
+            paths: [surface.dir]
+        });
+    }
+    const operations = [];
+    const artifactTransfers = [];
+    for (const file of sourceFiles) {
+        const destination = `${destinationSource}/${file.path.slice(surfaceSource.length)}`;
+        const sourceRelative = file.path.slice(surfaceSource.length);
+        const isTestSource = /(^|\/)(?:__tests__|test|tests)\//.test(sourceRelative) ||
+            /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(sourceRelative);
+        operations.push({ kind: 'move', from: file.path, to: destination, beforeSha256: file.sha256 });
+        artifactTransfers.push({
+            source: file.path,
+            destination,
+            classification: isTestSource ? 'test-move' : 'source-move'
+        });
+        if (file.content === undefined)
+            continue;
+        const rewritten = rewriteSpecifiers(file.content, surfaceName, targetName);
+        if (rewritten.content !== file.content) {
+            operations.push({
+                kind: 'rewrite',
+                path: destination,
+                beforeSha256: file.sha256,
+                afterSha256: authorities.sha256Hex(rewritten.content),
+                content: rewritten.content,
+                replacements: rewritten.replacements
+            });
+        }
+    }
+    const surfaceTsconfigPaths = snapshot.files
+        .filter((file) => new RegExp(`^${surface.dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/tsconfig(?:\\.[^/]+)?\\.json$`).test(file.path))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    if (surfaceTsconfigPaths.length === 0) {
+        blockers.push({
+            code: 'MISSING_BUILD_CONFIG',
+            message: 'Surface package has no tsconfig to map.',
+            paths: [surface.dir]
+        });
+    }
+    else {
+        for (const surfaceTsconfig of surfaceTsconfigPaths) {
+            const suffix = surfaceTsconfig.path.slice(`${surface.dir}/tsconfig`.length, -'.json'.length);
+            const mappedPath = suffix === '.package'
+                ? `${base.dir}/tsconfig.${subpath}.json`
+                : suffix === ''
+                    ? `${base.dir}/tsconfig.${subpath}.check.json`
+                    : `${base.dir}/tsconfig.${subpath}${suffix}.json`;
+            artifactTransfers.push({
+                source: surfaceTsconfig.path,
+                destination: mappedPath,
+                classification: 'build-config-map'
+            });
+            if (files.has(mappedPath)) {
+                blockers.push({
+                    code: 'BUILD_CONFIG_COLLISION',
+                    message: `${mappedPath} already exists; mapped surface compiler options require explicit composition.`,
+                    paths: [surfaceTsconfig.path, mappedPath]
+                });
+            }
+            if (surfaceTsconfig.content === undefined) {
+                blockers.push({
+                    code: 'UNREADABLE_BUILD_CONFIG',
+                    message: `${surfaceTsconfig.path} is not UTF-8 text.`,
+                    paths: [surfaceTsconfig.path]
+                });
+                continue;
+            }
+            const parsed = parseObject(surfaceTsconfig.content, surfaceTsconfig.path, blockers);
+            if (!parsed)
+                continue;
+            const mapped = JsonObjectSchema.parse(replacePathStrings(parsed, surfaceName, targetName, subpath));
+            if (mapped.extends === './tsconfig.json') {
+                mapped.extends = `./tsconfig.${subpath}.check.json`;
+            }
+            const mappedCompilerOptions = jsonObjectOf(mapped.compilerOptions);
+            if (suffix === '.package' && mappedCompilerOptions) {
+                mappedCompilerOptions.outDir = `dist/${subpath}`;
+                mappedCompilerOptions.rootDir = `src/${subpath}`;
+                mappedCompilerOptions.tsBuildInfoFile = `dist/${subpath}/tsconfig.tsbuildinfo`;
+                mapped.compilerOptions = mappedCompilerOptions;
+            }
+            const mappedIncludes = stringsOf(mapped.include);
+            if (suffix.includes('test') &&
+                mappedIncludes.some((entry) => /^(?:\.\/)?(?:test|tests|__tests__)\//.test(entry))) {
+                const compilerOptions = jsonObjectOf(mapped.compilerOptions) ?? {};
+                compilerOptions.rootDir = '.';
+                mapped.compilerOptions = compilerOptions;
+            }
+            operations.push(writeOperation(authorities.sha256Hex, mappedPath, files.get(mappedPath)?.sha256 ?? null, stableJson(mapped), 'surface build config'));
+        }
+    }
+    const baseTsconfig = files.get(`${base.dir}/tsconfig.json`);
+    if (!baseTsconfig) {
+        blockers.push({
+            code: 'MISSING_BUILD_CONFIG',
+            message: 'Base package has no tsconfig.json.',
+            paths: [base.dir]
+        });
+    }
+    else if (baseTsconfig.content === undefined) {
+        blockers.push({
+            code: 'UNREADABLE_BUILD_CONFIG',
+            message: `${baseTsconfig.path} is not UTF-8 text.`,
+            paths: [baseTsconfig.path]
+        });
+    }
+    else {
+        const parsed = parseObject(baseTsconfig.content, baseTsconfig.path, blockers);
+        if (parsed) {
+            const corePath = `${base.dir}/tsconfig.core.json`;
+            const existingCore = files.get(corePath);
+            if (existingCore && existingCore.content === undefined) {
+                blockers.push({
+                    code: 'UNREADABLE_BUILD_CONFIG',
+                    message: `${corePath} is not UTF-8 text.`,
+                    paths: [corePath]
+                });
+            }
+            const parsedCore = existingCore?.content
+                ? parseObject(existingCore.content, corePath, blockers)
+                : null;
+            const coreSource = parsedCore ?? { extends: './tsconfig.json' };
+            const baseExcludes = stringsOf(parsed.exclude);
+            const coreExcludes = stringsOf(coreSource.exclude);
+            const core = {
+                ...coreSource,
+                exclude: [...new Set([...baseExcludes, ...coreExcludes, `src/${subpath}/**`])]
+            };
+            operations.push(writeOperation(authorities.sha256Hex, corePath, existingCore?.sha256 ?? null, stableJson(core), 'exclude folded surface from core build'));
+        }
+    }
+    const baseBuild = nextManifest.scripts?.build;
+    const surfaceBuild = surface.manifest.scripts?.build;
+    if (!baseBuild ||
+        !surfaceBuild ||
+        !/tsc\s+-p\s+tsconfig\.json/.test(baseBuild) ||
+        !/svelte-package\s+--input\s+\.\/src\s+--output\s+\.\/dist/.test(surfaceBuild)) {
+        blockers.push({
+            code: 'UNSUPPORTED_BUILD_PIPELINE',
+            message: 'Build scripts are not the recognized tsc core + svelte-package surface pair; refusing a shell-string guess.',
+            paths: [base.path, surface.path]
+        });
+    }
+    else {
+        const coreBuild = baseBuild.replace(/tsc\s+-p\s+tsconfig\.json/, 'tsc -p tsconfig.core.json');
+        const mappedSurfaceBuild = surfaceBuild
+            .replace('--input ./src', `--input ./src/${subpath}`)
+            .replace('--output ./dist', `--output ./dist/${subpath}`)
+            .replace('--tsconfig ./tsconfig.package.json', `--tsconfig ./tsconfig.${subpath}.json`)
+            .replaceAll('dist/__tests__', `dist/${subpath}/__tests__`)
+            .replaceAll('find dist ', `find dist/${subpath} `);
+        nextManifest.scripts = {
+            ...nextManifest.scripts,
+            build: `${coreBuild} && ${mappedSurfaceBuild}`
+        };
+        const surfaceCheck = surface.manifest.scripts?.check;
+        if (surfaceCheck) {
+            const mappedSurfaceCheck = surfaceCheck
+                .replaceAll('./tsconfig.package.json', `./tsconfig.${subpath}.json`)
+                .replaceAll('./tsconfig.test.json', `./tsconfig.${subpath}.test.json`)
+                .replaceAll('./tsconfig.json', `./tsconfig.${subpath}.check.json`)
+                .replaceAll('tsconfig.package.json', `tsconfig.${subpath}.json`)
+                .replaceAll('tsconfig.test.json', `tsconfig.${subpath}.test.json`)
+                .replaceAll('tsconfig.json', `tsconfig.${subpath}.check.json`);
+            nextManifest.scripts.check = nextManifest.scripts.check
+                ? `${nextManifest.scripts.check} && ${mappedSurfaceCheck}`
+                : mappedSurfaceCheck;
+        }
+        const surfaceTest = surface.manifest.scripts?.test;
+        const baseTest = nextManifest.scripts.test;
+        const surfaceConfigs = snapshot.files.filter((file) => {
+            if (!file.path.startsWith(`${surface.dir}/`))
+                return false;
+            const relative = file.path.slice(surface.dir.length + 1);
+            return /^(?:vitest|vite)\.config\.[cm]?[jt]s$/.test(relative);
+        });
+        const surfaceConfig = surfaceConfigs[0];
+        let testConfigAmbiguityReported = false;
+        const mapAndBindSurfaceCommand = (command) => {
+            let mapped = mapSurfaceCommandPaths(command, subpath);
+            if (!/\bvitest\b/.test(mapped))
+                return mapped;
+            if (surfaceConfigs.length > 1 && !testConfigAmbiguityReported) {
+                testConfigAmbiguityReported = true;
+                blockers.push({
+                    code: 'AMBIGUOUS_TEST_CONFIG',
+                    message: 'Surface has multiple Vitest/Vite configs; choose one explicitly before folding.',
+                    paths: surfaceConfigs.map((file) => file.path).sort()
+                });
+            }
+            if (!surfaceConfig) {
+                if (/--config(?:=|\s+)\S+/.test(mapped)) {
+                    blockers.push({
+                        code: 'MISSING_TEST_CONFIG',
+                        message: 'Vitest command names a config that has no classified surface config transfer.',
+                        paths: [surface.path]
+                    });
+                }
+                return mapped;
+            }
+            const relative = surfaceConfig.path.slice(surface.dir.length + 1);
+            const mappedConfig = basename(mappedPackageConfigPath(base.dir, relative, subpath));
+            if (/--config(?:=|\s+)\S+/.test(mapped)) {
+                mapped = mapped.replace(/--config(?:=|\s+)\S+/, `--config ${mappedConfig}`);
+            }
+            else
+                mapped = `${mapped} --config ${mappedConfig}`;
+            return mapped;
+        };
+        let mappedSurfaceTest = surfaceTest ? mapAndBindSurfaceCommand(surfaceTest) : undefined;
+        if (mappedSurfaceTest &&
+            /(?:^|\s)(?:\$\{BUN:-bun\}|bun)(?:\s+--bun)?\s+test\s*$/.test(mappedSurfaceTest)) {
+            const testRoots = new Set();
+            if (sourceFiles.some((file) => {
+                const relative = file.path.slice(surfaceSource.length);
+                return (/(^|\/)(?:__tests__|test|tests)\//.test(relative) ||
+                    /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(relative));
+            }))
+                testRoots.add(`src/${subpath}`);
+            for (const root of ['test', 'tests', '__tests__']) {
+                if (snapshot.files.some((file) => file.path.startsWith(`${surface.dir}/${root}/`)))
+                    testRoots.add(`${root}/${subpath}`);
+            }
+            mappedSurfaceTest = `${mappedSurfaceTest} ${[...testRoots].sort().join(' ')}`.trimEnd();
+        }
+        if (surfaceTest) {
+            const scriptName = `test:${subpath}`;
+            nextManifest.scripts[scriptName] = mappedSurfaceTest;
+            nextManifest.scripts.test = baseTest
+                ? `${baseTest} && bun run ${scriptName}`
+                : `bun run ${scriptName}`;
+        }
+        for (const [name, command] of Object.entries(surface.manifest.scripts ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+            if (name === 'build' || name === 'check' || name === 'test')
+                continue;
+            if (/^(?:pre|post)?(?:pack|publish|publishOnly|install|prepare)$/.test(name)) {
+                blockers.push({
+                    code: 'UNSUPPORTED_LIFECYCLE_SCRIPT',
+                    message: `Surface lifecycle script ${name} requires explicit base composition.`,
+                    paths: [surface.path]
+                });
+                continue;
+            }
+            const mappedName = namespacedScriptName(name, subpath);
+            const mappedCommand = mapAndBindSurfaceCommand(command);
+            if (nextManifest.scripts[mappedName] && nextManifest.scripts[mappedName] !== mappedCommand) {
+                blockers.push({
+                    code: 'SCRIPT_COLLISION',
+                    message: `Base script ${mappedName} already exists with a different command.`,
+                    paths: [base.path, surface.path]
+                });
+            }
+            else
+                nextManifest.scripts[mappedName] = mappedCommand;
+        }
+    }
+    const hasSourceCondition = JSON.stringify(nextManifest.exports).includes('"./src/');
+    const sourcePublishFiles = [
+        ...new Set([
+            ...(nextManifest.files ?? ['dist']),
+            ...(hasSourceCondition
+                ? ['src/**', '!src/**/__tests__/**', '!src/**/*.test.*', '!src/**/*.spec.*']
+                : [])
+        ])
+    ];
+    nextManifest.files = sourcePublishFiles;
+    const workspaceVersions = Object.fromEntries(packages.flatMap((record) => record.manifest.version === undefined ? [] : [[record.manifest.name, record.manifest.version]]));
+    const publishProjection = PackageManifestSchema.parse(authorities.projectPublishManifest(clone(nextManifest), workspaceVersions));
+    if (JSON.stringify(publishProjection.exports).includes('./src/') ||
+        (publishProjection.files ?? []).some((entry) => entry === 'src' || entry.startsWith('src/'))) {
+        blockers.push({
+            code: 'INVALID_PUBLISH_PROJECTION',
+            message: 'Registry staging projection retains source-only targets or files.',
+            paths: [base.path]
+        });
+    }
+    operations.push(writeOperation(authorities.sha256Hex, base.path, files.get(base.path).sha256, stableJson(nextManifest), 'merge surface exports, build, and optional peer/dev pairs'));
+    const consumerFiles = snapshot.files
+        .filter((file) => file.path !== base.path && !file.path.startsWith(`${surface.dir}/`))
+        .filter((file) => file.content !== undefined)
+        .filter((file) => !isHistoricalEvidencePath(file.path))
+        .filter((file) => isExecutableConsumerPath(file.path))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const consumers = [];
+    for (const file of consumerFiles) {
+        let rewritten = file.content;
+        let replacements = 0;
+        if (file.path.endsWith('/package.json') || file.path === 'package.json') {
+            const result = rewriteManifestDependency(rewritten, surfaceName, baseName);
+            rewritten = result.content;
+            replacements += result.replacements;
+        }
+        const specifierResult = rewriteSpecifiers(rewritten, surfaceName, targetName);
+        rewritten = specifierResult.content;
+        replacements += specifierResult.replacements;
+        if (rewritten === file.content)
+            continue;
+        consumers.push({ path: file.path, replacements });
+        operations.push({
+            kind: 'rewrite',
+            path: file.path,
+            beforeSha256: file.sha256,
+            afterSha256: authorities.sha256Hex(rewritten),
+            content: rewritten,
+            replacements
+        });
+    }
+    const consumerPaths = new Set(consumers.map((consumer) => consumer.path));
+    const nonExecutableReferences = snapshot.files
+        .filter((file) => file.content !== undefined && !consumerPaths.has(file.path))
+        .filter((file) => !file.path.startsWith(`${surface.dir}/`))
+        .filter((file) => containsPackageReference(file.content, surfaceName))
+        .map((file) => file.path)
+        .sort();
+    const unresolvedProductionReferences = nonExecutableReferences.filter((path) => !isHistoricalEvidencePath(path) &&
+        !/(?:^|\/)(?:SPEC|README|SEALED|MIGRATION)(?:\.[^.]+)?\.md$/.test(path));
+    if (unresolvedProductionReferences.length > 0) {
+        blockers.push({
+            code: 'UNRESOLVED_PRODUCTION_REFERENCE',
+            message: 'Production/config files still reference the retired surface namespace.',
+            paths: unresolvedProductionReferences
+        });
+    }
+    const baseSpecPath = `${base.dir}/SPEC.md`;
+    const surfaceSpecPath = `${surface.dir}/SPEC.md`;
+    const baseSpec = files.get(baseSpecPath);
+    const surfaceSpec = files.get(surfaceSpecPath);
+    if (!baseSpec?.content || !surfaceSpec?.content) {
+        blockers.push({
+            code: 'MISSING_OWNER_SPEC',
+            message: 'Both owner SPECs must be readable before ownership can be contracted.',
+            paths: [baseSpecPath, surfaceSpecPath]
+        });
+    }
+    else {
+        const missingSections = REQUIRED_SPEC_SECTIONS.filter((section) => !new RegExp(`^## ${section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm').test(surfaceSpec.content));
+        if (missingSections.length > 0) {
+            blockers.push({
+                code: 'INCOMPLETE_OWNER_SPEC',
+                message: `Surface SPEC lacks canonical ownership sections: ${missingSections.join(', ')}.`,
+                paths: [surfaceSpecPath]
+            });
+        }
+        else {
+            const marker = `## Folded surface ownership: ./${subpath}`;
+            if (baseSpec.content.includes(marker)) {
+                blockers.push({
+                    code: 'OWNER_SPEC_COLLISION',
+                    message: `${baseSpecPath} already contains the folded surface marker.`,
+                    paths: [baseSpecPath]
+                });
+            }
+            else {
+                const mergedSpec = `${baseSpec.content.trimEnd()}\n\n${marker}\n\n**Archived provenance — non-normative after this fold.** The base sections above are the active owner contract; the complete pre-fold surface SPEC bytes are preserved below only for review history.\n\n${surfaceSpec.content}${surfaceSpec.content.endsWith('\n') ? '' : '\n'}`;
+                operations.push(writeOperation(authorities.sha256Hex, baseSpecPath, baseSpec.sha256, mergedSpec, 'absorb the complete reviewed surface owner contract'));
+            }
+        }
+    }
+    artifactTransfers.push({
+        source: surface.path,
+        destination: base.path,
+        classification: 'manifest-absorption'
+    });
+    artifactTransfers.push({
+        source: surfaceSpecPath,
+        destination: baseSpecPath,
+        classification: 'owner-spec-absorption'
+    });
+    operations.push({
+        kind: 'delete',
+        path: surface.path,
+        beforeSha256: files.get(surface.path).sha256
+    });
+    if (surfaceSpec)
+        operations.push({ kind: 'delete', path: surfaceSpecPath, beforeSha256: surfaceSpec.sha256 });
+    for (const surfaceTsconfig of surfaceTsconfigPaths) {
+        operations.push({
+            kind: 'delete',
+            path: surfaceTsconfig.path,
+            beforeSha256: surfaceTsconfig.sha256
+        });
+    }
+    const classifiedSources = new Set(artifactTransfers.map((transfer) => transfer.source));
+    const remainingSurfaceFiles = snapshot.files
+        .filter((file) => file.path.startsWith(`${surface.dir}/`))
+        .filter((file) => !classifiedSources.has(file.path))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    for (const file of remainingSurfaceFiles) {
+        const relative = file.path.slice(surface.dir.length + 1);
+        let destination;
+        let classification;
+        if (/^(?:test|tests|__tests__)\//.test(relative)) {
+            const [testRoot, ...rest] = relative.split('/');
+            destination = `${base.dir}/${testRoot}/${subpath}/${rest.join('/')}`;
+            classification = 'test-move';
+        }
+        else if (/^(?:svelte|vite|vitest|eslint|prettier|tailwind|postcss)\.config\.[cm]?[jt]s$/.test(relative)) {
+            destination = mappedPackageConfigPath(base.dir, relative, subpath);
+            classification = 'package-config-move';
+        }
+        else if (/^(?:README|SEALED|MIGRATION|VIBES|AUDIT|STATUS)(?:\.[^.]+)?\.md$/.test(relative)) {
+            destination = `${base.dir}/docs/${subpath}/${relative}`;
+            classification = 'documentation-move';
+        }
+        else if (relative === 'LICENSE') {
+            const baseLicense = files.get(`${base.dir}/LICENSE`);
+            if (baseLicense?.sha256 === file.sha256) {
+                artifactTransfers.push({
+                    source: file.path,
+                    destination: baseLicense.path,
+                    classification: 'legal-absorption'
+                });
+                operations.push({ kind: 'delete', path: file.path, beforeSha256: file.sha256 });
+                continue;
+            }
+            blockers.push({
+                code: 'LEGAL_REVIEW_REQUIRED',
+                message: 'Surface license is not byte-identical to the base owner license.',
+                paths: [file.path, `${base.dir}/LICENSE`]
+            });
+            continue;
+        }
+        if (!destination || !classification) {
+            blockers.push({
+                code: 'UNCLASSIFIED_SURFACE_ARTIFACT',
+                message: 'Surface artifact has no proven lossless transfer rule.',
+                paths: [file.path]
+            });
+            continue;
+        }
+        if (files.has(destination)) {
+            blockers.push({
+                code: 'DESTINATION_EXISTS',
+                message: `${destination} already exists; refusing to overlay a surface artifact.`,
+                paths: [file.path, destination]
+            });
+        }
+        artifactTransfers.push({ source: file.path, destination, classification });
+        operations.push({ kind: 'move', from: file.path, to: destination, beforeSha256: file.sha256 });
+        if (classification === 'package-config-move' && relative.startsWith('svelte.config.')) {
+            const rootConfigPath = `${base.dir}/${relative}`;
+            if (files.has(rootConfigPath)) {
+                blockers.push({
+                    code: 'CONFIG_COMPOSITION_REQUIRED',
+                    message: 'Base and surface Svelte configs require an explicit reviewed composition.',
+                    paths: [rootConfigPath, file.path]
+                });
+            }
+            else {
+                operations.push(writeOperation(authorities.sha256Hex, rootConfigPath, null, `export { default } from './${basename(destination)}';\n`, 'preserve Svelte config discovery through the namespaced surface config'));
+            }
+        }
+        if (file.content !== undefined) {
+            const rewritten = classification === 'package-config-move'
+                ? rewritePackageConfigContent(file.content, surfaceName, targetName, subpath)
+                : {
+                    ...rewriteSpecifiers(file.content, surfaceName, targetName),
+                    unsupportedRelativeImports: []
+                };
+            if (rewritten.unsupportedRelativeImports.length > 0) {
+                blockers.push({
+                    code: 'UNSUPPORTED_CONFIG_RELATIVE_IMPORT',
+                    message: `Moved package config has unclassified relative imports: ${rewritten.unsupportedRelativeImports.join(', ')}.`,
+                    paths: [file.path]
+                });
+            }
+            if (rewritten.content !== file.content) {
+                operations.push({
+                    kind: 'rewrite',
+                    path: destination,
+                    beforeSha256: file.sha256,
+                    afterSha256: authorities.sha256Hex(rewritten.content),
+                    content: rewritten.content,
+                    replacements: rewritten.replacements
+                });
+            }
+        }
+    }
+    const nextPackages = packages
+        .filter((record) => record !== surface)
+        .map((record) => ({
+        ...record,
+        manifest: record === base ? nextManifest : clone(record.manifest)
+    }));
+    for (const record of nextPackages) {
+        for (const section of DEPENDENCY_SECTIONS) {
+            const dependencies = record.manifest[section];
+            if (!dependencies?.[surfaceName])
+                continue;
+            dependencies[baseName] ??= dependencies[surfaceName];
+            delete dependencies[surfaceName];
+        }
+    }
+    const afterCycles = authorities
+        .findPackageCycles(packageGraph(nextPackages))
+        .map((cycle) => [...cycle.packages]);
+    if (afterCycles.length > 0) {
+        blockers.push({
+            code: 'POST_FOLD_CYCLE',
+            message: 'The compiled fold creates a workspace dependency cycle.',
+            paths: afterCycles.flat()
+        });
+    }
+    operations.sort((left, right) => {
+        const leftPath = left.kind === 'move' ? left.from : left.path;
+        const rightPath = right.kind === 'move' ? right.from : right.path;
+        return leftPath.localeCompare(rightPath) || left.kind.localeCompare(right.kind);
+    });
+    blockers.sort((left, right) => left.code.localeCompare(right.code) || left.message.localeCompare(right.message));
+    artifactTransfers.sort((left, right) => left.source.localeCompare(right.source));
+    return {
+        version: 1,
+        mode: 'dry-run',
+        status: blockers.length === 0 ? 'ready-for-review' : 'blocked',
+        source: snapshot.source,
+        base: { name: baseName, path: base.dir },
+        surface: { name: surfaceName, path: surface.dir, subpath },
+        graph: { beforeCycles, afterCycles },
+        manifest: {
+            optionalPeerDevPairs: [...optionalPeerDevPairs].sort(),
+            exportSubpaths: Object.keys(mappedExports).sort(),
+            sourceFiles: sourcePublishFiles,
+            publishFiles: publishProjection.files ?? [],
+            publishProjection,
+            publishContract: {
+                stagingRequired: true,
+                artifactPolicy: 'dist-only',
+                authority: {
+                    package: '@vibesdotdev/registry',
+                    export: 'rewriteRegistryPublishManifest'
+                },
+                projectionInputSha256: authorities.sha256Hex(stableJson(nextManifest)),
+                projectionSha256: authorities.sha256Hex(stableJson(publishProjection)),
+                verification: [
+                    'verify staged package.json export targets',
+                    'npm pack the staged directory',
+                    'assert tarball contains dist/** and no src/**, tests, specs, or tsbuildinfo',
+                    'install the tarball in a clean consumer and import the base plus folded subpath'
+                ]
+            }
+        },
+        consumers,
+        nonExecutableReferences,
+        unresolvedProductionReferences,
+        artifactTransfers,
+        ownerSpecMigration: {
+            from: surfaceSpecPath,
+            to: baseSpecPath,
+            requiredSections: [...REQUIRED_SPEC_SECTIONS],
+            preservedSourceSha256: surfaceSpec?.sha256 ?? 'missing',
+            operationPath: baseSpecPath
+        },
+        operations,
+        blockers
+    };
+}
+//# sourceMappingURL=planner.consumer.js.map