@empire-builder-kit/nx 1.0.0-beta.10

package/src/generators/upgrade/upgrade.js

@@ -0,0 +1,682 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preserveCompositionRegions = preserveCompositionRegions;
+exports.createUpgradeReport = createUpgradeReport;
+exports.upgradeGenerator = upgradeGenerator;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
+const prettier_1 = require("prettier");
+const index_js_1 = require("../../blueprints/index.js");
+const index_js_2 = require("../../foundation/index.js");
+const index_js_3 = require("../../ownership/index.js");
+const function_js_1 = require("../function/function.js");
+const generator_js_1 = require("../preset/generator.js");
+const workspace_files_js_1 = require("../preset/workspace-files.js");
+const slice_js_1 = require("../slice/slice.js");
+const workload_js_1 = require("../workload/workload.js");
+const COMPOSITION_REGIONS = [
+    'composition-imports',
+    'workload-registrations',
+    'function-registrations',
+    'composition-outputs',
+];
+function preserveCompositionRegions(current, target) {
+    let merged = target;
+    for (const region of COMPOSITION_REGIONS) {
+        const start = `// <ebk:${region}:start>`;
+        const end = `// <ebk:${region}:end>`;
+        const currentStart = current.indexOf(start);
+        const currentEnd = current.indexOf(end);
+        const targetStart = merged.indexOf(start);
+        const targetEnd = merged.indexOf(end);
+        if (currentStart < 0 ||
+            currentEnd < currentStart ||
+            targetStart < 0 ||
+            targetEnd < targetStart) {
+            continue;
+        }
+        const currentBody = current.slice(currentStart + start.length, currentEnd);
+        merged =
+            merged.slice(0, targetStart + start.length) +
+                currentBody +
+                merged.slice(targetEnd);
+    }
+    return merged;
+}
+function json(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function upgradeConflictMessage(label, report) {
+    const ownershipDetails = [
+        ...report.conflictingJsonMembers.map((member) => `- conflicting JSON ownership claim: ${member}`),
+        ...report.expandedJsonOwnership.map((path) => `- unsafe expansion to whole-file JSON ownership: ${path}`),
+    ];
+    return `${label} upgrade has user-modified managed files or unsafe JSON ownership changes:\n${report.conflicting.map((path) => `- ${path}`).join('\n')}${ownershipDetails.length > 0 ? `\n${ownershipDetails.join('\n')}` : ''}\nResolve or restore them before applying the upgrade.`;
+}
+async function formatRenderedFiles(files, prefix = '') {
+    return Object.fromEntries(await Promise.all(Object.entries(files).map(async ([path, contents]) => {
+        try {
+            return [
+                path,
+                await (0, prettier_1.format)(contents, {
+                    filepath: node_path_1.posix.join(prefix, path),
+                    singleQuote: true,
+                }),
+            ];
+        }
+        catch {
+            return [path, contents];
+        }
+    })));
+}
+function readJson(tree, path, label) {
+    const contents = tree.read(path, 'utf8');
+    if (contents === null)
+        throw new Error(`${label} does not exist at ${path}.`);
+    try {
+        return JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function ownershipValidationMessage(label, issues) {
+    const details = issues
+        .map((issue) => `- ${issue.path}: ${issue.message}`)
+        .join('\n');
+    const regenerateHint = issues.some(({ path }) => path === 'ownership.schemaVersion')
+        ? '\nOwnership schema v2 has no pre-release migration shim. Regenerate this unpublished alpha workspace as documented in docs/upgrades.md.'
+        : '';
+    return `${label} is invalid:\n${details}${regenerateHint}`;
+}
+function requireUpgradePrerequisites(tree, target) {
+    const installedVersion = (0, generator_js_1.frameworkPackageVersion)();
+    const workspaceResult = (0, index_js_3.validateWorkspaceOwnershipRecord)(readJson(tree, '.ebk/ownership.json', 'Workspace ownership metadata'));
+    if (!workspaceResult.valid) {
+        throw new Error(ownershipValidationMessage('Workspace ownership metadata', workspaceResult.issues));
+    }
+    if (workspaceResult.value.frameworkVersion !== installedVersion) {
+        throw new Error(`Workspace tooling is recorded at ${workspaceResult.value.frameworkVersion}, but the installed @empire-builder-kit/nx version is ${installedVersion}. Report and apply the workspace upgrade before upgrading the ${target === 'foundation' ? 'Standard Foundation' : 'Product Slice'}.`);
+    }
+    if (target === 'foundation')
+        return;
+    const foundationResult = (0, index_js_3.validateFoundationOwnershipRecord)(readJson(tree, 'packages/foundation/.ebk/ownership.json', 'Standard Foundation ownership metadata'));
+    if (!foundationResult.valid) {
+        throw new Error(ownershipValidationMessage('Standard Foundation ownership metadata', foundationResult.issues));
+    }
+    if (foundationResult.value.frameworkVersion !== installedVersion) {
+        throw new Error(`Standard Foundation is recorded at ${foundationResult.value.frameworkVersion}, but the installed @empire-builder-kit/nx version is ${installedVersion}. Report and apply the Foundation upgrade before upgrading a Product Slice.`);
+    }
+}
+function requireName(name) {
+    const value = name.trim();
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(value)) {
+        throw new Error('Upgrade target name must use lowercase letters, numbers, and hyphens.');
+    }
+    return value;
+}
+function workspaceScope(packageJson) {
+    const name = packageJson.name?.trim();
+    if (!name || !/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new Error('Workspace package.json must have an unscoped lowercase name.');
+    }
+    return `@${name}`;
+}
+function parseInputs(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'string')
+        return value;
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            throw new Error('value must be a JSON object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Blueprint --inputs must be valid JSON object syntax: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function breakingTransitionMessage(current, blueprint, transition) {
+    const declarations = transition.availableMigrations.map(({ from, id, manualSuccession, to }) => `- ${id}: ${from} -> ${to}; guide ${blueprint.manifest.name}@${blueprint.manifest.version}:${manualSuccession}`);
+    const reason = transition.reason === 'blueprint-identity-change'
+        ? 'Changing Blueprint package identity is a manual replacement, not a v1 managed upgrade.'
+        : transition.reason === 'ambiguous-migrations'
+            ? 'More than one publisher migration matches the recorded version; the publisher must make the transition unambiguous.'
+            : transition.reason === 'source-range-mismatch'
+                ? 'The target Blueprint declares migrations, but none has a source range matching the recorded version.'
+                : 'The target Blueprint declares no breaking-version migration.';
+    return `[ebk-upgrade] blocked breaking Blueprint transition
+Recorded: ${current.name}@${current.version}
+Requested: ${blueprint.manifest.name}@${blueprint.manifest.version}
+Compatible target line: ${current.name}@${transition.compatibilityLine}
+Reason: ${reason}
+${declarations.length > 0 ? `Available target declarations:\n${declarations.join('\n')}\n` : ''}No Blueprint files were rendered or changed. Keep using an exact compatible-line target, or create a reviewed replacement Product Slice with publisher guidance.`;
+}
+function gateBreakingBlueprintTransition(current, blueprint, apply) {
+    const transition = (0, index_js_1.classifyBlueprintTransition)(current, blueprint.manifest);
+    if (transition.kind === 'compatible')
+        return false;
+    if (transition.kind === 'blocked') {
+        throw new Error(breakingTransitionMessage(current, blueprint, transition));
+    }
+    const { migration } = transition;
+    const report = {
+        affectedManagedSurfaces: migration.affectedManagedSurfaces,
+        contracts: migration.contracts,
+        databaseChange: migration.databaseChange,
+        dependencyChanges: migration.dependencyChanges,
+        executor: migration.executor
+            ? `${blueprint.manifest.name}@${blueprint.manifest.version}:${migration.executor}`
+            : null,
+        infrastructureChanges: migration.infrastructureChanges,
+        maintenanceWindowRequired: migration.maintenanceWindowRequired,
+        migration: migration.id,
+        preflight: migration.preflight,
+        recorded: `${current.name}@${current.version}`,
+        requested: `${blueprint.manifest.name}@${blueprint.manifest.version}`,
+        rollback: migration.rollback,
+        sourceRange: migration.from,
+        manualSuccession: `${blueprint.manifest.name}@${blueprint.manifest.version}:${migration.manualSuccession}`,
+        verification: migration.verification,
+    };
+    devkit_1.logger.info(`[ebk-upgrade] declared breaking Blueprint transition — manual succession only\n${JSON.stringify(report, null, 2)}\nNo Blueprint files were rendered or changed. The declared executor, if any, was not executed.`);
+    if (apply) {
+        throw new Error(`Breaking Blueprint migration ${migration.id} is report-only in v1 and was not applied. Follow ${report.manualSuccession}; do not restamp the target Blueprint as active until manual succession is complete.`);
+    }
+    return true;
+}
+function createUpgradeReport(currentFiles, currentOwnership, targetFiles, targetOwnership, jsonOwnershipChanges = {
+    claimedJsonMembers: [],
+    conflictingJsonMembers: [],
+    expandedJsonOwnership: [],
+    releasedJsonMembers: [],
+}) {
+    const report = {
+        addedSeeded: [],
+        changed: [],
+        claimedJsonMembers: [...jsonOwnershipChanges.claimedJsonMembers],
+        conflicting: [],
+        conflictingJsonMembers: [...jsonOwnershipChanges.conflictingJsonMembers],
+        expandedJsonOwnership: [...jsonOwnershipChanges.expandedJsonOwnership],
+        missing: [],
+        obsolete: [],
+        preservedSeeded: [],
+        releasedJsonMembers: [...jsonOwnershipChanges.releasedJsonMembers],
+        unchanged: [],
+    };
+    const targetPaths = new Set(targetOwnership.paths.map(({ path }) => path));
+    const currentPathOwnership = new Map(currentOwnership.paths.map((entry) => [entry.path, entry]));
+    for (const { mode, path } of targetOwnership.paths) {
+        const current = currentFiles.get(path) ?? null;
+        const target = targetFiles.get(path);
+        const currentEntry = currentPathOwnership.get(path);
+        if (target === undefined) {
+            throw new Error(`Target Blueprint did not render owned path ${path}.`);
+        }
+        if (mode === 'seeded') {
+            (current === null ? report.addedSeeded : report.preservedSeeded).push(path);
+        }
+        else if (current === null) {
+            report.missing.push(path);
+        }
+        else if (currentEntry !== undefined &&
+            (0, index_js_3.hashOwnedContent)(current, currentEntry) !== currentEntry.sha256) {
+            report.conflicting.push(path);
+        }
+        else if (current === target) {
+            report.unchanged.push(path);
+        }
+        else if (currentEntry === undefined) {
+            report.conflicting.push(path);
+        }
+        else {
+            report.changed.push(path);
+        }
+    }
+    for (const entry of currentOwnership.paths) {
+        const { mode, origin, path, sha256 } = entry;
+        if (mode !== 'managed' ||
+            origin === 'composition' ||
+            targetPaths.has(path)) {
+            continue;
+        }
+        const current = currentFiles.get(path) ?? null;
+        if (current === null)
+            continue;
+        if ((0, index_js_3.hashOwnedContent)(current, entry) === sha256) {
+            report.obsolete.push(path);
+        }
+        else if (!report.conflicting.includes(path)) {
+            report.conflicting.push(path);
+        }
+    }
+    const ownershipConflictPaths = new Set([
+        ...report.expandedJsonOwnership,
+        ...report.conflictingJsonMembers.map((member) => member.slice(0, member.indexOf('#/'))),
+    ]);
+    for (const path of ownershipConflictPaths) {
+        report.changed = report.changed.filter((entry) => entry !== path);
+        report.unchanged = report.unchanged.filter((entry) => entry !== path);
+        if (!report.conflicting.includes(path))
+            report.conflicting.push(path);
+    }
+    for (const paths of Object.values(report))
+        paths.sort();
+    return report;
+}
+function mergeStructuredTargetFiles(currentFiles, currentOwnership, targetFiles, targetOwnership) {
+    const files = new Map(targetFiles);
+    const changes = {
+        claimedJsonMembers: [],
+        conflictingJsonMembers: [],
+        expandedJsonOwnership: [],
+        releasedJsonMembers: [],
+    };
+    const currentEntries = new Map(currentOwnership.paths.map((entry) => [entry.path, entry]));
+    for (const targetEntry of targetOwnership.paths) {
+        const currentEntry = currentEntries.get(targetEntry.path);
+        const current = currentFiles.get(targetEntry.path) ?? null;
+        const target = files.get(targetEntry.path);
+        if (current === null || target === undefined)
+            continue;
+        if (currentEntry?.managedJsonPointers && !targetEntry.managedJsonPointers) {
+            if (targetEntry.mode === 'managed') {
+                changes.expandedJsonOwnership.push(targetEntry.path);
+            }
+            else {
+                changes.releasedJsonMembers.push(...currentEntry.managedJsonPointers.map((pointer) => `${targetEntry.path}#${pointer}`));
+            }
+            continue;
+        }
+        if (!targetEntry.managedJsonPointers)
+            continue;
+        if (currentEntry?.managedJsonPointers) {
+            const transition = (0, index_js_3.analyzeManagedJsonPointerTransition)(current, target, currentEntry.managedJsonPointers, targetEntry.managedJsonPointers);
+            changes.claimedJsonMembers.push(...transition.claimed.map((pointer) => `${targetEntry.path}#${pointer}`));
+            changes.conflictingJsonMembers.push(...transition.conflictingClaims.map((pointer) => `${targetEntry.path}#${pointer}`));
+            changes.releasedJsonMembers.push(...transition.released.map((pointer) => `${targetEntry.path}#${pointer}`));
+            if (transition.conflictingClaims.length > 0) {
+                files.set(targetEntry.path, current);
+                continue;
+            }
+        }
+        files.set(targetEntry.path, (0, index_js_3.mergeManagedJsonContents)(current, target, targetEntry.managedJsonPointers));
+    }
+    return { files, ...changes };
+}
+function renderCompositionUpgradePlan(ownership) {
+    const compositionPaths = ownership.paths.filter(({ origin }) => origin === 'composition');
+    const functionNames = new Set();
+    const workloads = new Map();
+    for (const { path } of compositionPaths) {
+        const functionMatch = /^infra\/functions\/([^/]+)\.ts$/.exec(path);
+        if (functionMatch?.[1])
+            functionNames.add(functionMatch[1]);
+        const workloadMatch = /^(services|jobs)\/([^/]+)\//.exec(path);
+        if (workloadMatch?.[1] && workloadMatch[2]) {
+            workloads.set(`${workloadMatch[1]}/${workloadMatch[2]}`, {
+                kind: workloadMatch[1] === 'services' ? 'service' : 'job',
+                name: workloadMatch[2],
+            });
+        }
+    }
+    const files = {};
+    const paths = new Map();
+    const addPlan = (planFiles, planPaths) => {
+        Object.assign(files, planFiles);
+        for (const entry of planPaths) {
+            const contents = planFiles[entry.path];
+            if (contents === undefined) {
+                throw new Error(`Composition plan did not render ${entry.path}.`);
+            }
+            paths.set(entry.path, {
+                ...(entry.managedJsonPointers
+                    ? { managedJsonPointers: entry.managedJsonPointers }
+                    : {}),
+                mode: entry.mode ?? 'managed',
+                origin: 'composition',
+                path: entry.path,
+                sha256: (0, index_js_3.hashOwnedContent)(contents, entry),
+            });
+        }
+    };
+    for (const name of functionNames) {
+        const plan = (0, function_js_1.createFunctionFilePlan)(ownership.slice, name);
+        addPlan(plan.files, plan.paths);
+    }
+    for (const { kind, name } of workloads.values()) {
+        const plan = (0, workload_js_1.createWorkloadFilePlan)(ownership.slice, name, kind);
+        addPlan(plan.files, plan.paths);
+    }
+    for (const entry of compositionPaths) {
+        if (paths.has(entry.path))
+            continue;
+        paths.set(entry.path, entry);
+    }
+    return { files, paths: [...paths.values()] };
+}
+async function upgradeFoundation(tree, options, packageJson) {
+    if (options.blueprint !== undefined || options.inputs !== undefined) {
+        throw new Error('Standard Foundation upgrades do not accept Blueprint or input options.');
+    }
+    const root = 'packages/foundation';
+    const ownershipResult = (0, index_js_3.validateFoundationOwnershipRecord)(readJson(tree, node_path_1.posix.join(root, '.ebk/ownership.json'), 'Standard Foundation ownership metadata'));
+    if (!ownershipResult.valid) {
+        throw new Error(ownershipValidationMessage('Standard Foundation ownership metadata', ownershipResult.issues));
+    }
+    if (!packageJson.name) {
+        throw new Error('Workspace package.json must declare a name.');
+    }
+    const currentOwnership = ownershipResult.value;
+    const renderedTarget = (0, workspace_files_js_1.renderFoundationFilePlan)({
+        frameworkVersion: (0, generator_js_1.frameworkPackageVersion)(),
+        name: packageJson.name,
+    });
+    const target = {
+        ...renderedTarget,
+        files: await formatRenderedFiles(renderedTarget.files, root),
+    };
+    const targetValidation = (0, index_js_3.validateFoundationOwnershipRecord)(target.ownership);
+    if (!targetValidation.valid) {
+        throw new Error(`Target Standard Foundation ownership metadata is invalid:\n${targetValidation.issues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join('\n')}`);
+    }
+    const allPaths = new Set([
+        ...currentOwnership.paths.map(({ path }) => path),
+        ...target.ownership.paths.map(({ path }) => path),
+    ]);
+    const currentFiles = new Map([...allPaths].map((path) => [
+        path,
+        tree.read(node_path_1.posix.join(root, path), 'utf8'),
+    ]));
+    const mergedTarget = mergeStructuredTargetFiles(currentFiles, currentOwnership, new Map(Object.entries(target.files)), target.ownership);
+    const report = createUpgradeReport(currentFiles, currentOwnership, mergedTarget.files, target.ownership, mergedTarget);
+    devkit_1.logger.info(`[ebk-upgrade] foundation ${currentOwnership.frameworkVersion} -> ${target.ownership.frameworkVersion}\n${JSON.stringify(report, null, 2)}`);
+    if (!options.apply)
+        return;
+    if (report.conflicting.length > 0) {
+        throw new Error(upgradeConflictMessage('Standard Foundation', report));
+    }
+    for (const path of report.obsolete)
+        tree.delete(node_path_1.posix.join(root, path));
+    const writePaths = new Set([
+        ...report.changed,
+        ...report.missing,
+        ...report.addedSeeded,
+        '.ebk/ownership.json',
+    ]);
+    for (const path of writePaths) {
+        const contents = mergedTarget.files.get(path);
+        if (contents === undefined) {
+            throw new Error(`Target Standard Foundation did not render ${path}.`);
+        }
+        tree.write(node_path_1.posix.join(root, path), contents);
+    }
+    if (!options.skipFormat)
+        await (0, devkit_1.formatFiles)(tree);
+    (0, index_js_3.restampFoundationOwnership)(tree);
+}
+async function upgradeWorkspace(tree, options, packageJson) {
+    if (options.blueprint !== undefined || options.inputs !== undefined) {
+        throw new Error('Workspace upgrades do not accept Blueprint or input options.');
+    }
+    const ownershipResult = (0, index_js_3.validateWorkspaceOwnershipRecord)(readJson(tree, '.ebk/ownership.json', 'Workspace ownership metadata'));
+    if (!ownershipResult.valid) {
+        throw new Error(ownershipValidationMessage('Workspace ownership metadata', ownershipResult.issues));
+    }
+    if (!packageJson.name) {
+        throw new Error('Workspace package.json must declare a name.');
+    }
+    const currentOwnership = ownershipResult.value;
+    const renderedTarget = (0, workspace_files_js_1.renderWorkspaceRootFilePlan)({
+        frameworkVersion: (0, generator_js_1.frameworkPackageVersion)(),
+        name: packageJson.name,
+    });
+    const target = {
+        ...renderedTarget,
+        files: await formatRenderedFiles(renderedTarget.files),
+    };
+    const targetValidation = (0, index_js_3.validateWorkspaceOwnershipRecord)(target.ownership);
+    if (!targetValidation.valid) {
+        throw new Error('Target workspace ownership metadata is invalid.');
+    }
+    const allPaths = new Set([
+        ...currentOwnership.paths.map(({ path }) => path),
+        ...target.ownership.paths.map(({ path }) => path),
+    ]);
+    const currentFiles = new Map([...allPaths].map((path) => [path, tree.read(path, 'utf8')]));
+    const mergedTarget = mergeStructuredTargetFiles(currentFiles, currentOwnership, new Map(Object.entries(target.files)), target.ownership);
+    const report = createUpgradeReport(currentFiles, currentOwnership, mergedTarget.files, target.ownership, mergedTarget);
+    devkit_1.logger.info(`[ebk-upgrade] workspace ${currentOwnership.frameworkVersion} -> ${target.ownership.frameworkVersion}\n${JSON.stringify(report, null, 2)}`);
+    const repositoryPolicyContents = tree.read('ebk.repository-policy.json', 'utf8');
+    if (repositoryPolicyContents !== null) {
+        try {
+            const repositoryPolicy = JSON.parse(repositoryPolicyContents);
+            if (typeof repositoryPolicy === 'object' &&
+                repositoryPolicy !== null &&
+                !Array.isArray(repositoryPolicy) &&
+                !Object.prototype.hasOwnProperty.call(repositoryPolicy, 'productionApproval')) {
+                devkit_1.logger.warn('[ebk-upgrade] Preserved pre-beta.7 Repository Operating Policy requires an explicit production approval amendment before workspace health or GitHub bootstrap. Report it with pnpm nx g @empire-builder-kit/nx:repository-policy --productionApprovalMode=promotion-pr, then rerun with --apply after review. Use environment-reviewer instead only when that stronger committed contract is intended and supported.');
+            }
+        }
+        catch {
+            // The upgrade preserves adopter-owned policy source. Its normal validator
+            // reports malformed JSON; this notice is only for the known missing member.
+        }
+    }
+    if (!options.apply)
+        return;
+    if (report.conflicting.length > 0) {
+        throw new Error(upgradeConflictMessage('Workspace', report));
+    }
+    for (const path of report.obsolete)
+        tree.delete(path);
+    const writePaths = new Set([
+        ...report.changed,
+        ...report.missing,
+        ...report.addedSeeded,
+        '.ebk/ownership.json',
+    ]);
+    for (const path of writePaths) {
+        const contents = mergedTarget.files.get(path);
+        if (contents === undefined) {
+            throw new Error(`Target workspace did not render ${path}.`);
+        }
+        tree.write(path, contents);
+    }
+    if (!options.skipFormat)
+        await (0, devkit_1.formatFiles)(tree);
+    (0, index_js_3.restampWorkspaceOwnership)(tree);
+}
+async function upgradeGenerator(tree, options) {
+    const name = requireName(options.name);
+    const packageJson = readJson(tree, 'package.json', 'Workspace package.json');
+    if (name === 'workspace') {
+        return upgradeWorkspace(tree, options, packageJson);
+    }
+    if (name === 'foundation') {
+        requireUpgradePrerequisites(tree, 'foundation');
+        return upgradeFoundation(tree, options, packageJson);
+    }
+    requireUpgradePrerequisites(tree, 'product-slice');
+    const root = node_path_1.posix.join('packages', name);
+    const ownershipResult = (0, index_js_3.validateGeneratedOwnershipRecord)(readJson(tree, node_path_1.posix.join(root, '.ebk/ownership.json'), 'Product Slice ownership metadata'));
+    if (!ownershipResult.valid) {
+        throw new Error(ownershipValidationMessage('Product Slice ownership metadata', ownershipResult.issues));
+    }
+    const currentOwnership = ownershipResult.value;
+    if (currentOwnership.slice !== name) {
+        throw new Error(`Ownership metadata belongs to ${currentOwnership.slice}, not ${name}.`);
+    }
+    const recordedReference = currentOwnership.blueprint.name === index_js_1.BUILTIN_BLUEPRINT_NAME
+        ? index_js_1.BUILTIN_BLUEPRINT_REFERENCE
+        : `${currentOwnership.blueprint.name}@${currentOwnership.blueprint.version}`;
+    const blueprint = (0, index_js_1.resolveBlueprint)({
+        localPackages: packageJson.ebk?.blueprints?.localPackages,
+        reference: options.blueprint ?? recordedReference,
+        trust: { packages: packageJson.ebk?.blueprints?.trustedPackages ?? [] },
+        workspaceRoot: tree.root,
+    });
+    const inputResult = (0, index_js_1.validateBlueprintInputs)(blueprint.inputSchema, parseInputs(options.inputs, currentOwnership.inputs));
+    if (!inputResult.valid) {
+        throw new Error(`Blueprint inputs are invalid:\n${inputResult.issues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join('\n')}`);
+    }
+    const compatibility = (0, index_js_2.validateFoundationCompatibility)(blueprint.manifest.foundation, readJson(tree, 'packages/foundation/contracts/foundation.json', 'Standard Foundation descriptor'));
+    if (!compatibility.valid) {
+        throw new Error(`Standard Foundation is incompatible with the target Blueprint:\n${compatibility.issues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join('\n')}`);
+    }
+    if (gateBreakingBlueprintTransition(currentOwnership.blueprint, blueprint, options.apply === true)) {
+        return;
+    }
+    let targetFiles;
+    let targetOwnership;
+    const scope = workspaceScope(packageJson);
+    if (blueprint.source === 'built-in') {
+        const runtimeVersion = packageJson.dependencies?.['@empire-builder-kit/runtime'];
+        if (!runtimeVersion)
+            throw new Error('Workspace must depend on @empire-builder-kit/runtime.');
+        const plan = (0, slice_js_1.createBuiltInSlicePlan)(name, scope, runtimeVersion, blueprint.manifest, inputResult.value);
+        targetFiles = Object.fromEntries(Object.entries(plan.files).map(([path, contents]) => {
+            const current = tree.read(node_path_1.posix.join(root, path), 'utf8');
+            return [
+                path,
+                current === null
+                    ? contents
+                    : preserveCompositionRegions(current, contents),
+            ];
+        }));
+        targetOwnership = plan.ownership;
+    }
+    else {
+        if (!blueprint.generatorPath) {
+            throw new Error('Resolved external Blueprint has no generator entry point.');
+        }
+        const generated = await (0, index_js_1.executeBlueprintGenerator)(blueprint.generatorPath, {
+            foundation: compatibility.value,
+            inputs: inputResult.value,
+            manifest: blueprint.manifest,
+            name,
+            root,
+            workspace: { name: packageJson.name ?? '', scope },
+        });
+        const paths = generated.files.map(({ contents, managedJsonPointers, mode, path }) => ({
+            ...(managedJsonPointers ? { managedJsonPointers } : {}),
+            mode,
+            origin: 'blueprint',
+            path,
+            sha256: (0, index_js_3.hashOwnedContent)(contents, { managedJsonPointers }),
+        }));
+        paths.sort((left, right) => left.path.localeCompare(right.path));
+        targetOwnership = {
+            blueprint: {
+                name: blueprint.manifest.name,
+                version: blueprint.manifest.version,
+            },
+            contracts: generated.contracts,
+            foundation: blueprint.manifest.foundation,
+            inputs: inputResult.value,
+            paths,
+            projects: generated.projects,
+            schemaVersion: index_js_3.GENERATED_OWNERSHIP_SCHEMA_VERSION,
+            slice: name,
+            verification: blueprint.manifest.verification,
+        };
+        targetFiles = Object.fromEntries([
+            ...generated.files.map(({ contents, path }) => [path, contents]),
+            ['.ebk/ownership.json', json(targetOwnership)],
+        ]);
+    }
+    const targetPathSet = new Set(targetOwnership.paths.map(({ path }) => path));
+    const compositionPlan = renderCompositionUpgradePlan(currentOwnership);
+    const compositionPaths = compositionPlan.paths.filter(({ path }) => !targetPathSet.has(path));
+    for (const entry of compositionPaths) {
+        const contents = compositionPlan.files[entry.path] ??
+            tree.read(node_path_1.posix.join(root, entry.path), 'utf8');
+        if (contents === null) {
+            throw new Error(`Composed owned path is missing: ${entry.path}.`);
+        }
+        targetFiles = { ...targetFiles, [entry.path]: contents };
+    }
+    targetFiles = await formatRenderedFiles(targetFiles, root);
+    targetOwnership = {
+        ...targetOwnership,
+        ...(targetOwnership.migrationHistory === undefined &&
+            currentOwnership.migrationHistory !== undefined
+            ? { migrationHistory: currentOwnership.migrationHistory }
+            : {}),
+        paths: [...targetOwnership.paths, ...compositionPaths].map((entry) => {
+            const contents = targetFiles[entry.path];
+            if (contents === undefined) {
+                throw new Error(`Target Blueprint did not render ${entry.path}.`);
+            }
+            return { ...entry, sha256: (0, index_js_3.hashOwnedContent)(contents, entry) };
+        }),
+        projects: [
+            ...new Set([...targetOwnership.projects, ...currentOwnership.projects]),
+        ].sort(),
+    };
+    targetFiles = {
+        ...targetFiles,
+        '.ebk/ownership.json': json(targetOwnership),
+    };
+    const targetValidation = (0, index_js_3.validateGeneratedOwnershipRecord)(targetOwnership);
+    if (!targetValidation.valid) {
+        throw new Error(`Target ownership metadata is invalid:\n${targetValidation.issues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join('\n')}`);
+    }
+    const allPaths = new Set([
+        ...currentOwnership.paths.map(({ path }) => path),
+        ...targetOwnership.paths.map(({ path }) => path),
+    ]);
+    const currentFiles = new Map([...allPaths].map((path) => [
+        path,
+        tree.read(node_path_1.posix.join(root, path), 'utf8'),
+    ]));
+    const mergedTarget = mergeStructuredTargetFiles(currentFiles, currentOwnership, new Map(Object.entries(targetFiles)), targetOwnership);
+    const report = createUpgradeReport(currentFiles, currentOwnership, mergedTarget.files, targetOwnership, mergedTarget);
+    devkit_1.logger.info(`[ebk-upgrade] ${name} ${currentOwnership.blueprint.name}@${currentOwnership.blueprint.version} -> ${blueprint.manifest.name}@${blueprint.manifest.version}\n${JSON.stringify(report, null, 2)}`);
+    if (!options.apply)
+        return;
+    if (report.conflicting.length > 0) {
+        throw new Error(upgradeConflictMessage('Product Slice', report));
+    }
+    for (const path of report.obsolete)
+        tree.delete(node_path_1.posix.join(root, path));
+    const writePaths = new Set([
+        ...report.changed,
+        ...report.missing,
+        ...report.addedSeeded,
+        '.ebk/ownership.json',
+    ]);
+    for (const path of writePaths) {
+        const contents = mergedTarget.files.get(path);
+        if (contents === undefined)
+            throw new Error(`Target Blueprint did not render ${path}.`);
+        tree.write(node_path_1.posix.join(root, path), contents);
+    }
+    if (blueprint.source === 'installed') {
+        packageJson.devDependencies = {
+            ...packageJson.devDependencies,
+            [blueprint.manifest.name]: blueprint.manifest.version,
+        };
+        tree.write('package.json', json(packageJson));
+    }
+    if (!options.skipFormat)
+        await (0, devkit_1.formatFiles)(tree);
+    (0, index_js_3.restampProductSliceOwnership)(tree, name);
+    return options.skipInstall
+        ? undefined
+        : () => (0, devkit_1.installPackagesTask)(tree, true);
+}
+exports.default = upgradeGenerator;
+//# sourceMappingURL=upgrade.js.map