@empire-builder-kit/nx 1.0.0-rc.4 → 1.0.0-rc.40

package/src/generators/slice/slice.js

@@ -8,12 +8,19 @@ const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
 const index_js_1 = require("../../blueprints/index.js");
 const index_js_2 = require("../../foundation/index.js");
+const capability_plan_js_1 = require("../../foundation/capability-plan.js");
+const preview_changes_js_1 = require("../../developer-agent/preview-changes.js");
+const upgrade_js_1 = require("../upgrade/upgrade.js");
 const index_js_3 = require("../../ownership/index.js");
 const index_js_4 = require("../../repository-policy/index.js");
 const blueprint_verification_authority_js_1 = require("../../supply-chain/blueprint-verification-authority.js");
 const blueprint_trust_js_1 = require("../../supply-chain/blueprint-trust.js");
 const post_generation_install_js_1 = require("../post-generation-install.js");
+const formatting_js_1 = require("../formatting.js");
+const workspace_files_js_1 = require("../preset/workspace-files.js");
 const built_in_plan_js_1 = require("./built-in-plan.js");
+const data_policy_review_seed_js_1 = require("./data-policy-review-seed.js");
+const tree_policy_js_1 = require("../repository-policy/tree-policy.js");
 var built_in_plan_js_2 = require("./built-in-plan.js");
 Object.defineProperty(exports, "PRODUCT_PACKAGE_MANAGED_JSON_POINTERS", { enumerable: true, get: function () { return built_in_plan_js_2.PRODUCT_PACKAGE_MANAGED_JSON_POINTERS; } });
 Object.defineProperty(exports, "STANDARD_LOCAL_DEV_ADAPTER", { enumerable: true, get: function () { return built_in_plan_js_2.STANDARD_LOCAL_DEV_ADAPTER; } });
@@ -47,6 +54,24 @@ function workspaceScope(packageJson) {
 function json(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
+async function formatSliceBeforeOwnershipRestamp(tree, root, preserveBuiltInFormatSensitiveFiles) {
+    const prefix = `${root}/`;
+    const restoreProtectedFiles = (0, formatting_js_1.createTreeFileRestorer)(tree, (path) => {
+        // Paired Foundation generation has already formatted and hashed its own
+        // output. A Slice formatter must not invalidate that completed ownership.
+        if (!path.startsWith(prefix))
+            return true;
+        if ((0, workspace_files_js_1.isRawWorkspaceAuthorityPath)(path))
+            return true;
+        return (preserveBuiltInFormatSensitiveFiles &&
+            path.startsWith(prefix) &&
+            (0, built_in_plan_js_1.isBuiltInSliceFormatSensitivePath)(path.slice(prefix.length)));
+    });
+    await (0, formatting_js_1.formatChangedTreeToFixedPoint)(tree, restoreProtectedFiles);
+}
+async function formatSliceOwnership(tree, root) {
+    await (0, formatting_js_1.formatTreeFileToFixedPoint)(tree, node_path_1.posix.join(root, '.ebk/ownership.json'));
+}
 function assertExternalBlueprintVerificationProgram(input) {
     (0, blueprint_verification_authority_js_1.assertExternalBlueprintGeneratedNxProjectConfinement)({
         files: input.files,
@@ -103,28 +128,6 @@ function assertExternalBlueprintVerificationProgram(input) {
         targets: rootProject.targets,
     });
 }
-const FORMAT_SENSITIVE_BUILT_IN_PATHS = new Set([
-    'api/generated/contract.json',
-    'api/generated/openapi.json',
-    'web/next-env.d.ts',
-]);
-function dataPolicyReviewSeed(tree, root) {
-    const path = node_path_1.posix.join(root, 'data/policy.json');
-    const existing = tree.read(path, 'utf8');
-    if (existing !== null) {
-        try {
-            const reviewedAt = JSON.parse(existing).governance?.reviewedAt;
-            if (typeof reviewedAt === 'string' &&
-                new Date(reviewedAt).toISOString() === reviewedAt) {
-                return reviewedAt;
-            }
-        }
-        catch {
-            // The generated ownership/reconciliation path reports malformed policy.
-        }
-    }
-    return new Date().toISOString();
-}
 function reportSlicePolicyPosture(tree, name) {
     const contents = tree.read(index_js_4.REPOSITORY_POLICY_FILE, 'utf8');
     if (contents === null) {
@@ -132,7 +135,7 @@ function reportSlicePolicyPosture(tree, name) {
         return;
     }
     try {
-        const policy = (0, index_js_4.parseRepositoryOperatingPolicy)(contents, index_js_4.REPOSITORY_POLICY_FILE);
+        const policy = (0, tree_policy_js_1.readRepositoryOperatingPolicyFromTree)(tree);
         const status = policy.slices[name]?.productionStatus;
         if (status) {
             devkit_1.logger.info(`[ebk-repository-policy] Product Slice ${name} retains explicit production status ${status}.`);
@@ -144,6 +147,13 @@ function reportSlicePolicyPosture(tree, name) {
         devkit_1.logger.warn(`[ebk-repository-policy] Product Slice ${name} is blocked from production because the repository policy is invalid. ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+function requireRepositoryDeploymentProfile(tree) {
+    const contents = tree.read(index_js_4.REPOSITORY_POLICY_FILE, 'utf8');
+    if (contents === null) {
+        throw new Error(`${index_js_4.REPOSITORY_POLICY_FILE} is required before generating a built-in Product Slice.`);
+    }
+    return (0, tree_policy_js_1.readRepositoryOperatingPolicyFromTree)(tree).deploymentProfile;
+}
 function parseBlueprintInputs(inputs) {
     if (inputs === undefined) {
         return {};
@@ -181,6 +191,7 @@ async function sliceGenerator(tree, options) {
         },
         resumeArguments: [
             'pnpm',
+            '--config.verify-deps-before-run=warn',
             'nx',
             'generate',
             '@empire-builder-kit/nx:slice',
@@ -213,7 +224,15 @@ async function sliceGenerator(tree, options) {
             .join('\n')}`);
     }
     const foundationDescriptor = readJson(tree, 'packages/foundation/contracts/foundation.json', 'Standard Foundation descriptor');
-    const compatibility = (0, index_js_2.validateFoundationCompatibility)(blueprint.manifest.foundation, foundationDescriptor);
+    const foundationRequirement = blueprint.source === 'built-in'
+        ? (0, capability_plan_js_1.standardPersistenceRequirement)(inputResult.value)
+        : blueprint.manifest.foundation;
+    const compatibility = (0, index_js_2.validateFoundationCompatibility)(foundationRequirement, blueprint.source === 'built-in'
+        ? (0, capability_plan_js_1.planFoundationCapabilities)({
+            current: foundationDescriptor,
+            requirements: [foundationRequirement],
+        }).descriptor
+        : foundationDescriptor);
     if (!compatibility.valid) {
         throw new Error(`Standard Foundation is incompatible with this Blueprint:\n${compatibility.issues
             .map((issue) => `- ${issue.path}: ${issue.message}`)
@@ -222,7 +241,7 @@ async function sliceGenerator(tree, options) {
     const installScope = {
         exactPaths: ['package.json'],
         requiredPaths: [node_path_1.posix.join(root, '.ebk/ownership.json')],
-        roots: [root],
+        roots: blueprint.source === 'built-in' ? [root, 'packages/foundation'] : [root],
     };
     const installState = options.skipInstall
         ? undefined
@@ -315,13 +334,11 @@ async function sliceGenerator(tree, options) {
             };
             tree.write('package.json', json(packageJson));
         }
-        if (!options.skipFormat) {
-            await (0, devkit_1.formatFiles)(tree);
-        }
+        if (!options.skipFormat)
+            await formatSliceBeforeOwnershipRestamp(tree, root, false);
         (0, index_js_3.restampProductSliceOwnership)(tree, name);
-        if (!options.skipFormat) {
-            await (0, devkit_1.formatFiles)(tree);
-        }
+        if (!options.skipFormat)
+            await formatSliceOwnership(tree, root);
         reportSlicePolicyPosture(tree, name);
         if (options.skipInstall)
             return undefined;
@@ -334,33 +351,27 @@ async function sliceGenerator(tree, options) {
     if (!runtimeVersion) {
         throw new Error('Workspace package.json must depend on @empire-builder-kit/runtime before generating a Product Slice.');
     }
-    const plan = (0, built_in_plan_js_1.createBuiltInSlicePlan)(name, scope, runtimeVersion, blueprint.manifest, inputResult.value, dataPolicyReviewSeed(tree, root));
+    const plan = (0, built_in_plan_js_1.createBuiltInSlicePlan)(name, scope, runtimeVersion, blueprint.manifest, inputResult.value, (0, data_policy_review_seed_js_1.dataPolicyReviewSeed)(tree, root), requireRepositoryDeploymentProfile(tree));
     const ownershipValidation = (0, index_js_3.validateGeneratedOwnershipRecord)(plan.ownership);
     if (!ownershipValidation.valid) {
         throw new Error(`Generated ownership metadata is invalid:\n${ownershipValidation.issues
             .map((issue) => `- ${issue.path}: ${issue.message}`)
             .join('\n')}`);
     }
+    // Foundation capability growth and Slice creation are one ownership-preserving
+    // source operation. A later validation/formatting failure must not leave half
+    // of a relational declaration applied to the caller's tree.
+    const deferred = new preview_changes_js_1.DeferredDeveloperAgentTree(tree);
+    await (0, upgrade_js_1.upgradeFoundationForRequirements)(deferred, [foundationRequirement], true);
     for (const [relativePath, contents] of Object.entries(plan.files)) {
-        tree.write(node_path_1.posix.join(root, relativePath), contents);
-    }
-    const restoreFormatSensitiveFiles = () => {
-        for (const [relativePath, contents] of Object.entries(plan.files)) {
-            if (relativePath.startsWith('database/migrations/') ||
-                FORMAT_SENSITIVE_BUILT_IN_PATHS.has(relativePath)) {
-                tree.write(node_path_1.posix.join(root, relativePath), contents);
-            }
-        }
-    };
-    if (!options.skipFormat) {
-        await (0, devkit_1.formatFiles)(tree);
-        restoreFormatSensitiveFiles();
-    }
-    (0, index_js_3.restampProductSliceOwnership)(tree, name);
-    if (!options.skipFormat) {
-        await (0, devkit_1.formatFiles)(tree);
-        restoreFormatSensitiveFiles();
+        deferred.write(node_path_1.posix.join(root, relativePath), contents);
     }
+    if (!options.skipFormat)
+        await formatSliceBeforeOwnershipRestamp(deferred, root, true);
+    (0, index_js_3.restampProductSliceOwnership)(deferred, name);
+    if (!options.skipFormat)
+        await formatSliceOwnership(deferred, root);
+    deferred.apply();
     reportSlicePolicyPosture(tree, name);
     if (options.skipInstall)
         return undefined;

package/src/generators/sql/schema.d.ts

@@ -0,0 +1,7 @@
+export interface SqlGeneratorSchema {
+  name: string;
+  reason: string;
+  apply?: boolean;
+  skipFormat?: boolean;
+  skipInstall?: boolean;
+}

package/src/generators/sql/schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "EmpireBuilderKitSql",
+  "title": "Add a relational requirement to an existing Standard Slice",
+  "description": "Report or apply an additive Foundation/Slice SQL declaration while preserving existing data stores and managed ownership. No AWS calls.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9-]{0,62}$",
+      "$default": { "$source": "argv", "index": 0 },
+      "description": "Existing Standard Product Slice."
+    },
+    "reason": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 512,
+      "description": "Concrete relational requirement, such as integrity constraints or reporting joins. Stored in the existing Blueprint inputs.sql declaration."
+    },
+    "apply": {
+      "type": "boolean",
+      "default": false,
+      "description": "Apply the paired managed Foundation/Slice source upgrade; otherwise only report it. No AWS operation is performed."
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Leave source formatting to a subsequent explicit check."
+    },
+    "skipInstall": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not run the dependency-install callback after applying source changes."
+    }
+  },
+  "required": ["name", "reason"]
+}

package/src/generators/sql/sql.d.ts

@@ -0,0 +1,6 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { type UpgradeGeneratorLogger } from '../upgrade/upgrade.js';
+import type { SqlGeneratorSchema } from './schema.js';
+/** One additive entry point; the existing upgrader owns validation and all writes. */
+export declare function sqlGenerator(tree: Tree, options: SqlGeneratorSchema, output?: UpgradeGeneratorLogger): Promise<void | GeneratorCallback>;
+export default sqlGenerator;

package/src/generators/sql/sql.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlGenerator = sqlGenerator;
+const devkit_1 = require("@nx/devkit");
+const index_js_1 = require("../../blueprints/index.js");
+const capability_plan_js_1 = require("../../foundation/capability-plan.js");
+const index_js_2 = require("../../ownership/index.js");
+const upgrade_js_1 = require("../upgrade/upgrade.js");
+/** One additive entry point; the existing upgrader owns validation and all writes. */
+async function sqlGenerator(tree, options, output = devkit_1.logger) {
+    if (typeof options.name !== 'string' ||
+        !/^[a-z][a-z0-9-]{0,62}$/.test(options.name) ||
+        ['foundation', 'workspace'].includes(options.name))
+        throw new Error('SQL requires one existing Standard Product Slice name.');
+    const declaration = (0, capability_plan_js_1.readStandardSqlDeclaration)({
+        sql: { reason: options.reason },
+    });
+    if (!declaration)
+        throw new Error('A concrete relational reason is required.');
+    const ownershipPath = `packages/${options.name}/.ebk/ownership.json`;
+    const source = tree.read(ownershipPath, 'utf8');
+    if (!source)
+        throw new Error(`Standard Slice ownership is missing at ${ownershipPath}. Generate the Slice first.`);
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        throw new Error(`Standard Slice ownership is invalid at ${ownershipPath}.`);
+    }
+    const ownership = (0, index_js_2.validateGeneratedOwnershipRecord)(parsed);
+    if (!ownership.valid || ownership.value.slice !== options.name)
+        throw new Error(`Standard Slice ownership is invalid at ${ownershipPath}.`);
+    if (ownership.value.blueprint.name !== index_js_1.BUILTIN_BLUEPRINT_NAME)
+        throw new Error('The sql generator only supports the Standard Blueprint. Declare relational capabilities through the external Blueprint owner.');
+    const existing = (0, capability_plan_js_1.readStandardSqlDeclaration)(ownership.value.inputs);
+    if (existing && existing.reason !== declaration.reason)
+        throw new Error('SQL is already declared with a different reason. Keep the recorded reason, or use the managed upgrade inputs surface for an intentional declaration change.');
+    output.info(`[ebk-sql] ${options.name}: ${existing ? 'retain' : 'add'} the relational declaration. ` +
+        'The paired upgrade reports Foundation Aurora, private networking/container compute and Slice Drizzle/migration sources. ' +
+        'Existing default-store records, resource identities, capacity, protections and seeded features are preserved. ' +
+        'Aurora/network/container resources can add recurring cost; inspect the generated plan and committed capacity policy before deployment. ' +
+        'This command does not deploy, copy data or retire SQL.');
+    return (0, upgrade_js_1.upgradeGenerator)(tree, {
+        name: options.name,
+        inputs: { ...ownership.value.inputs, sql: declaration },
+        apply: options.apply === true,
+        skipFormat: options.skipFormat,
+        skipInstall: options.skipInstall,
+    }, output);
+}
+exports.default = sqlGenerator;
+//# sourceMappingURL=sql.js.map

package/src/generators/upgrade/sql-seeded-reconciliation.d.ts

@@ -0,0 +1,2 @@
+/** Only append required SQL members; never replace an adopter's seeded decisions. */
+export declare function planSqlSeededReconciliation(current: ReadonlyMap<string, string | null>, target: Readonly<Record<string, string>>): Map<string, string>;

package/src/generators/upgrade/sql-seeded-reconciliation.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planSqlSeededReconciliation = planSqlSeededReconciliation;
+const node_util_1 = require("node:util");
+const ts = require("typescript");
+/** Only append required SQL members; never replace an adopter's seeded decisions. */
+function planSqlSeededReconciliation(current, target) {
+    const updates = new Map();
+    const read = (path, contents) => {
+        const value = JSON.parse(contents);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error(`SQL reconciliation requires an object at ${path}.`);
+        return value;
+    };
+    const append = (path, property, key, select, preserveExisting = false, equivalent = node_util_1.isDeepStrictEqual) => {
+        const contents = current.get(path);
+        if (contents == null)
+            return;
+        const existing = read(path, contents), desired = read(path, target[path]);
+        if (!Array.isArray(existing[property]) || !Array.isArray(desired[property]))
+            throw new Error(`SQL reconciliation requires ${path}#/${property}.`);
+        let changed = false;
+        for (const addition of desired[property].filter(select)) {
+            const matches = existing[property].filter((entry) => entry?.[key] === addition[key]);
+            if (matches.length > 1 ||
+                (matches.length === 1 &&
+                    !preserveExisting &&
+                    !equivalent(matches[0], addition)))
+                throw new Error(`SQL reconciliation conflict at ${path}: ${addition[key]}. Preserve the customization and reconcile this required declaration explicitly; no files changed.`);
+            if (matches.length === 0) {
+                existing[property].push(addition);
+                changed = true;
+            }
+        }
+        if (changed)
+            updates.set(path, JSON.stringify(existing, null, 2) + '\n');
+    };
+    append('operations/features.json', 'features', 'id', (entry) => entry.id === 'database-lifecycle', true);
+    append('secrets/metadata.json', 'declarations', 'logicalName', (entry) => entry.source === 'database-bootstrap', false, (existing, desired) => {
+        // Rotation is an adopter decision. Required identity, stage and source
+        // bindings still have to agree; never silently overwrite either kind.
+        const existingBinding = { ...existing }, desiredBinding = { ...desired };
+        delete existingBinding.rotation;
+        delete desiredBinding.rotation;
+        return (0, node_util_1.isDeepStrictEqual)(existingBinding, desiredBinding);
+    });
+    append('operations/release.json', 'artifactInventory', 'id', (entry) => typeof entry.id === 'string' &&
+        /\.job\.database-(migration|retirement)$/.test(entry.id), true);
+    const backgroundPath = 'operations/background-work.json';
+    const background = current.get(backgroundPath);
+    if (background != null) {
+        const existing = read(backgroundPath, background), desired = read(backgroundPath, target[backgroundPath]);
+        if (!existing.stages ||
+            typeof existing.stages !== 'object' ||
+            Array.isArray(existing.stages))
+            throw new Error('SQL reconciliation requires declared background-work stages.');
+        let changed = false;
+        for (const [stage, defaults] of Object.entries(desired.stages)) {
+            const settings = existing.stages[stage];
+            if (!settings ||
+                typeof settings !== 'object' ||
+                Array.isArray(settings) ||
+                typeof settings.outbox?.enabled !== 'boolean')
+                throw new Error(`SQL reconciliation requires the existing ${stage} outbox pause decision.`);
+            if (!Object.prototype.hasOwnProperty.call(settings, 'sqlOutboxRecovery')) {
+                settings.sqlOutboxRecovery = {
+                    ...defaults.sqlOutboxRecovery,
+                    enabled: settings.outbox.enabled,
+                };
+                changed = true;
+            }
+        }
+        if (changed)
+            updates.set(backgroundPath, JSON.stringify(existing, null, 2) + '\n');
+    }
+    const path = 'secrets/declarations.ts', contents = current.get(path);
+    if (contents == null)
+        return updates;
+    const parse = (source) => {
+        const file = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true);
+        const declarations = file.statements
+            .flatMap((statement) => ts.isVariableStatement(statement)
+            ? [...statement.declarationList.declarations]
+            : [])
+            .filter((declaration) => ts.isIdentifier(declaration.name) &&
+            declaration.name.text === 'SecretDefinitions');
+        let expression = declarations.length === 1 ? declarations[0].initializer : undefined;
+        while (expression &&
+            (ts.isAsExpression(expression) ||
+                ts.isSatisfiesExpression(expression) ||
+                ts.isParenthesizedExpression(expression)))
+            expression = expression.expression;
+        if (!expression ||
+            !ts.isObjectLiteralExpression(expression) ||
+            expression.properties.some((property) => !ts.isPropertyAssignment(property)))
+            throw new Error('SQL reconciliation requires a literal SecretDefinitions object without spreads. Preserve custom declarations and add the generated database credential explicitly; no files changed.');
+        return {
+            file,
+            object: expression,
+            properties: expression.properties.filter(ts.isPropertyAssignment),
+        };
+    };
+    const existing = parse(contents), desired = parse(target[path]);
+    const name = (property) => ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)
+        ? property.name.text
+        : undefined;
+    // Compare syntax, not the printer's retained quote style or trailing commas.
+    // Formatting a seeded declaration must not turn an unchanged binding into a
+    // conflict. Preserve every expression/operator and literal value in the shape.
+    const shape = (node) => {
+        if (ts.isStringLiteral(node) ||
+            ts.isNumericLiteral(node) ||
+            ts.isIdentifier(node))
+            return [node.kind, node.text];
+        const children = [];
+        ts.forEachChild(node, (child) => {
+            children.push(shape(child));
+        });
+        return [node.kind, children.length ? children : node.getText()];
+    };
+    const additions = [];
+    const bindingShape = (property) => {
+        const value = property.initializer;
+        if (!ts.isObjectLiteralExpression(value))
+            return shape(property);
+        return value.properties
+            .filter((entry) => !ts.isPropertyAssignment(entry) || name(entry) !== 'rotation')
+            .map(shape);
+    };
+    for (const property of desired.properties.filter((entry) => name(entry)?.endsWith('PrimaryDatabaseCredential'))) {
+        const matches = existing.properties.filter((entry) => name(entry) === name(property));
+        if (matches.length > 1 ||
+            (matches.length === 1 &&
+                !(0, node_util_1.isDeepStrictEqual)(bindingShape(matches[0]), bindingShape(property))))
+            throw new Error(`SQL reconciliation conflict at ${path}: ${name(property)}. No files changed.`);
+        if (!matches.length)
+            additions.push(property.getText(desired.file));
+    }
+    if (additions.length) {
+        // Use AST offsets so unrelated declarations, comments and feature code remain byte-for-byte intact.
+        const end = existing.object.end - 1;
+        const comma = existing.properties.length && !existing.object.properties.hasTrailingComma
+            ? ','
+            : '';
+        let result = contents.slice(0, end) +
+            comma +
+            '\n' +
+            additions.join(',\n') +
+            ',\n' +
+            contents.slice(end);
+        const imports = existing.file.statements.filter(ts.isImportDeclaration);
+        const schemaImport = imports.some((entry) => ts.isStringLiteral(entry.moduleSpecifier) &&
+            entry.moduleSpecifier.text === '@empire-builder-kit/runtime/database' &&
+            entry.importClause?.namedBindings &&
+            ts.isNamedImports(entry.importClause.namedBindings) &&
+            entry.importClause.namedBindings.elements.some((binding) => binding.name.text === 'databaseCredentialSecretSchema' &&
+                (!binding.propertyName ||
+                    binding.propertyName.text === 'databaseCredentialSecretSchema')));
+        if (!schemaImport) {
+            if (/\bdatabaseCredentialSecretSchema\b/.test(contents))
+                throw new Error(`SQL reconciliation conflict at ${path}: databaseCredentialSecretSchema is already bound. No files changed.`);
+            result =
+                "import { databaseCredentialSecretSchema } from '@empire-builder-kit/runtime/database';\n" +
+                    result;
+        }
+        updates.set(path, result);
+    }
+    return updates;
+}
+//# sourceMappingURL=sql-seeded-reconciliation.js.map

package/src/generators/upgrade/upgrade.d.ts

@@ -55,7 +55,7 @@ export interface UpgradeReport {
 }
 export interface SeededReconciliationWork {
     adopterContentSha256: string;
-    category: 'async-adapter' | 'async-settings' | 'configuration-contract' | 'configuration-values' | 'feature-controls' | 'frontend-contract' | 'frontend-security' | 'performance-aggregate-provider' | 'performance-policy' | 'reliability-operations' | 'reliability-slo' | 'release-controls';
+    category: 'async-adapter' | 'async-settings' | 'configuration-contract' | 'configuration-values' | 'feature-controls' | 'frontend-contract' | 'frontend-security' | 'performance-aggregate-provider' | 'performance-policy' | 'reliability-operations' | 'reliability-slo' | 'release-controls' | 'secret-contract';
     currentFrameworkSha256: string | null;
     implications: string[];
     markerReference: 'PLAN:5.6/seeded-upgrade-reconciliation';
@@ -71,7 +71,21 @@ interface JsonOwnershipChanges {
 }
 type OwnershipPaths = Pick<GeneratedOwnershipRecord, 'paths'>;
 export declare function preserveCompositionRegions(current: string, target: string): string;
+/**
+ * Re-emits every recorded composition into the managed native runtime
+ * authority regions of a regenerated Product Slice. Region preservation only
+ * carries a body when the current file exposes the same-named markers, so a
+ * Slice whose compositions predate the native-runtime-authority region names
+ * (or whose regions were emptied by an earlier managed upgrade) would
+ * otherwise lose the recorded workload authority. The recorded compositions in
+ * `.ebk/ownership.json` are the source of truth; compositions already present
+ * in a region are left untouched so a second apply is byte-stable.
+ * (EBK-INT-2026-070)
+ */
+export declare function reemitRecordedNativeRuntimeCompositions(files: Readonly<Record<string, string>>, ownership: Pick<GeneratedOwnershipRecord, 'compositions'>): Readonly<Record<string, string>>;
 export declare function inspectWorkspaceSstVersion(tree: Tree, packageJson: WorkspacePackageJson): WorkspaceSstVersionState;
 export declare function createUpgradeReport(currentFiles: ReadonlyMap<string, string | null>, currentOwnership: OwnershipPaths, targetFiles: ReadonlyMap<string, string>, targetOwnership: OwnershipPaths, jsonOwnershipChanges?: JsonOwnershipChanges): UpgradeReport;
+/** Internal paired-generation path: the ordinary ownership-preserving upgrader owns Foundation writes. */
+export declare function upgradeFoundationForRequirements(tree: Tree, requirements: readonly unknown[], apply: boolean, output?: UpgradeGeneratorLogger): Promise<void>;
 export declare function upgradeGenerator(tree: Tree, options: UpgradeGeneratorSchema, output?: UpgradeGeneratorLogger, executionOptions?: UpgradeGeneratorExecutionOptions): Promise<GeneratorCallback | void>;
 export default upgradeGenerator;