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

package/src/performance/cost-controls.js

@@ -158,6 +158,7 @@ function requireExactFoundationAccountCostAuthority(input) {
 }
 function createFoundationAccountCostControlPlan(input) {
     const policy = validateFoundationAccountCostPolicy(input.policy);
+    const rehearsalStage = input.rehearsalStage ?? 'staging';
     if (!IDENTIFIER.test(input.stage) ||
         input.stage.length > 128 ||
         input.workspace !== policy.workspace) {
@@ -178,8 +179,14 @@ function createFoundationAccountCostControlPlan(input) {
         stage: input.stage,
         workspace: input.workspace,
     };
-    if (input.stage !== 'staging' && input.stage !== 'production') {
-        return { ...shared, budget: null, status: 'disabled-non-protected-stage' };
+    if ((input.stage === 'development' && policy.status === 'example') ||
+        (input.stage !== rehearsalStage && input.stage !== 'production')) {
+        return {
+            ...shared,
+            anomaly: null,
+            budget: null,
+            status: 'disabled-non-protected-stage',
+        };
     }
     requireCommercialBillingRegion(input.region ?? '');
     if (!(0, model_js_1.isIsoInstant)(input.evaluatedAt) ||
@@ -191,6 +198,29 @@ function createFoundationAccountCostControlPlan(input) {
     }
     return {
         ...shared,
+        anomaly: input.stage === 'production'
+            ? {
+                monitor: {
+                    dimension: 'SERVICE',
+                    monitorType: 'DIMENSIONAL',
+                    owner: 'foundation',
+                    scope: 'production-account',
+                },
+                subscription: {
+                    frequency: 'IMMEDIATE',
+                    name: stableName(100, input.workspace, 'account-cost-anomaly-alerts'),
+                    thresholdExpression: {
+                        dimension: {
+                            key: 'ANOMALY_TOTAL_IMPACT_ABSOLUTE',
+                            matchOptions: ['GREATER_THAN_OR_EQUAL'],
+                            values: [
+                                (Math.max(1, Math.ceil(policy.monthlyMaximumUsd * 100 * 0.05)) / 100).toFixed(2),
+                            ],
+                        },
+                    },
+                },
+            }
+            : null,
         budget: {
             budgetType: 'COST',
             limitAmount: policy.monthlyMaximumUsd.toFixed(2),
@@ -218,6 +248,7 @@ function createFoundationAccountCostControlPlan(input) {
 }
 function createPerformanceCostControlPlan(input) {
     const policy = (0, model_js_1.validatePerformancePolicy)(input.policy);
+    const rehearsalStage = input.rehearsalStage ?? 'staging';
     const accountBudgetAuthority = validateFoundationAccountCostAuthority(input.accountBudgetAuthority);
     if (!IDENTIFIER.test(input.workspace) ||
         input.workspace.length > 128 ||
@@ -235,6 +266,7 @@ function createPerformanceCostControlPlan(input) {
     const materialDigest = `sha256:${(0, model_js_1.performanceDigest)({
         accountBudgetAuthority,
         policyDigest,
+        rehearsalStage,
     })}`;
     const shared = {
         accountBudgetAuthority,
@@ -252,7 +284,8 @@ function createPerformanceCostControlPlan(input) {
         stage: input.stage,
         workspace: input.workspace,
     };
-    if (input.stage !== 'staging' && input.stage !== 'production') {
+    if ((input.stage === 'development' && policy.cost.status === 'example') ||
+        (input.stage !== rehearsalStage && input.stage !== 'production')) {
         return {
             ...shared,
             anomaly: null,
@@ -263,7 +296,7 @@ function createPerformanceCostControlPlan(input) {
     requireCommercialBillingRegion(input.region ?? '');
     requireAdoptedCostPolicy(policy, input.evaluatedAt);
     const budgetNotifications = notifications(policy);
-    if (input.stage === 'staging') {
+    if (input.stage === rehearsalStage) {
         return {
             ...shared,
             anomaly: null,
@@ -289,7 +322,7 @@ function createPerformanceCostControlPlan(input) {
                             tags: {
                                 key: 'user:ebk:stage',
                                 matchOptions: ['EQUALS'],
-                                values: ['staging'],
+                                values: [rehearsalStage],
                             },
                         },
                     ],
@@ -306,29 +339,7 @@ function createPerformanceCostControlPlan(input) {
     }
     return {
         ...shared,
-        anomaly: {
-            monitor: {
-                monitorSpecification: JSON.stringify({
-                    Tags: {
-                        Key: 'ebk:cost-scope',
-                        Values: [`${input.workspace}/${policy.slice}/${input.stage}`],
-                    },
-                }),
-                monitorType: 'CUSTOM',
-                name: stableName(100, input.workspace, policy.slice, 'service-cost-anomalies'),
-            },
-            subscription: {
-                frequency: 'IMMEDIATE',
-                name: stableName(100, input.workspace, policy.slice, 'cost-anomaly-alerts'),
-                thresholdExpression: {
-                    dimension: {
-                        key: 'ANOMALY_TOTAL_IMPACT_ABSOLUTE',
-                        matchOptions: ['GREATER_THAN_OR_EQUAL'],
-                        values: [policy.cost.anomalyThresholdUsd.toFixed(2)],
-                    },
-                },
-            },
-        },
+        anomaly: null,
         pilotBudget: null,
         status: 'ready',
     };

package/src/performance/evidence.d.ts

@@ -14,7 +14,7 @@ export interface PerformanceObservationV1 {
     budgetId: string;
     environment: {
         accountFingerprint?: string;
-        class: 'ci' | 'local' | 'production' | 'staging';
+        class: 'ci' | 'development' | 'local' | 'production' | 'staging';
         region?: string;
         stage?: string;
     };

package/src/performance/evidence.js

@@ -94,8 +94,9 @@ function observationFinding(budget, observation, policy, now, expectedRelease) {
             !budget.evidenceProvenance.includes(observation.provenance)) {
             throw new Error('observation identity, population, percentile, unit, scenario, or provenance does not match the budget');
         }
-        if (!['ci', 'local', 'production', 'staging'].includes(observation.environment.class) ||
-            ((observation.environment.class === 'production' ||
+        if (!['ci', 'development', 'local', 'production', 'staging'].includes(observation.environment.class) ||
+            ((observation.environment.class === 'development' ||
+                observation.environment.class === 'production' ||
                 observation.environment.class === 'staging') &&
                 (!observation.environment.accountFingerprint?.trim() ||
                     !observation.environment.region?.trim() ||
@@ -117,7 +118,8 @@ function observationFinding(budget, observation, policy, now, expectedRelease) {
             (budget.metric === 'monthly-cost-usd' ||
                 budget.metric === 'unit-cost-usd')) {
             const billing = observation.billingPeriod;
-            if ((observation.environment.class !== 'production' &&
+            if ((observation.environment.class !== 'development' &&
+                observation.environment.class !== 'production' &&
                 observation.environment.class !== 'staging') ||
                 billing?.provider !== 'aws-billing-actual' ||
                 !(0, model_js_1.isIsoInstant)(billing.start) ||

package/src/performance/load-safety.js

@@ -181,8 +181,10 @@ function createProtectedLoadPlan(policyValue, input) {
     if (validateEndpoint(input.target.endpoint) !== input.target.endpoint) {
         throw new model_js_1.PerformanceContractError('performance-load-plan-invalid', 'plan/target/endpoint', 'must use the canonical exact HTTPS URL');
     }
-    if (input.target.stage !== 'staging' && input.target.stage !== 'production') {
-        throw new model_js_1.PerformanceContractError('performance-load-plan-invalid', 'plan/target/stage', 'must equal staging or production');
+    if (input.target.stage !== 'development' &&
+        input.target.stage !== 'staging' &&
+        input.target.stage !== 'production') {
+        throw new model_js_1.PerformanceContractError('performance-load-plan-invalid', 'plan/target/stage', 'must equal development, staging, or production');
     }
     if (!model_js_1.PERFORMANCE_WORKLOAD_KINDS.includes(input.workload)) {
         throw new model_js_1.PerformanceContractError('performance-load-plan-invalid', 'plan/workload', 'must be a supported workload kind');
@@ -331,7 +333,7 @@ function validateProtectedLoadAuthorization(input) {
             throw new model_js_1.PerformanceContractError('performance-load-production-refused', 'approval/productionException', 'production load requires explicit human-reviewed exceptional evidence');
         }
     }
-    else if (!policy.load.allowedProtectedStages.includes(input.plan.target.stage)) {
+    else if (!new Set(policy.load.allowedProtectedStages).has(input.plan.target.stage)) {
         throw new model_js_1.PerformanceContractError('performance-load-authorization-invalid', 'plan/target/stage', 'stage is not permitted by the adopter-owned protected-load policy');
     }
     return {

package/src/performance/model.d.ts

@@ -3,11 +3,11 @@ export declare const PERFORMANCE_POLICY_KIND: "ebk-performance-policy";
 export declare const PERFORMANCE_EVIDENCE_PROVENANCE: readonly ["estimate", "test", "actual"];
 export declare const PERFORMANCE_POPULATIONS: readonly ["all", "cache-hit", "cache-miss", "cold", "warm"];
 export declare const PERFORMANCE_WORKLOAD_KINDS: readonly ["api-lambda", "async-worker", "browser", "database", "job", "service"];
-export declare const PERFORMANCE_REQUIRED_TAG_KEYS: readonly ["ebk:cost-allocation", "ebk:cost-scope", "ebk:framework-version", "ebk:managed-by", "ebk:owner", "ebk:production-profile", "ebk:repository", "ebk:slice", "ebk:stage", "ebk:workspace"];
+export declare const PERFORMANCE_REQUIRED_TAG_KEYS: readonly ["ebk:cost-allocation", "ebk:cost-scope", "ebk:framework-version", "ebk:managed-by", "ebk:owner", "ebk:slice", "ebk:stage", "ebk:workspace"];
 export type PerformanceEvidenceProvenance = (typeof PERFORMANCE_EVIDENCE_PROVENANCE)[number];
 export type PerformancePopulation = (typeof PERFORMANCE_POPULATIONS)[number];
 export type PerformanceWorkloadKind = (typeof PERFORMANCE_WORKLOAD_KINDS)[number];
-export type PerformanceStage = 'production' | 'staging';
+export type PerformanceStage = 'development' | 'production' | 'staging';
 export interface PerformanceAuthorityHooksV1 {
     /**
      * Opaque reference to the reliability-owned journey/SLO declaration.
@@ -49,7 +49,7 @@ export interface PerformanceCapacityResourceV1 {
 }
 export declare const STANDARD_SERVICE_PER_TASK_CONCURRENCY = 32;
 export interface PerformanceLoadLimitsV1 {
-    allowedProtectedStages: readonly ['staging'];
+    allowedProtectedStages: readonly ['development'] | readonly ['staging'];
     maximumConcurrency: number;
     maximumDurationSeconds: number;
     maximumEstimatedCostUsd: number;
@@ -116,7 +116,7 @@ export declare function createStandardResourceTags(input: {
     frameworkVersion: string;
     managedBy?: string;
     owner: string;
-    productionProfile: 'cost-optimized' | 'standard';
+    productionProfile: 'cost-optimized' | 'balanced' | 'standard';
     repository: string;
     slice: string;
     stage: string;

package/src/performance/model.js

@@ -39,8 +39,6 @@ exports.PERFORMANCE_REQUIRED_TAG_KEYS = [
     'ebk:framework-version',
     'ebk:managed-by',
     'ebk:owner',
-    'ebk:production-profile',
-    'ebk:repository',
     'ebk:slice',
     'ebk:stage',
     'ebk:workspace',
@@ -296,10 +294,11 @@ function validatePerformancePolicy(value) {
         'maximumRequests',
         'productionExceptionalOnly',
     ], 'policy/load');
-    if (JSON.stringify(value.load.allowedProtectedStages) !==
-        JSON.stringify(['staging']) ||
+    const allowedProtectedStages = JSON.stringify(value.load.allowedProtectedStages);
+    if ((allowedProtectedStages !== JSON.stringify(['development']) &&
+        allowedProtectedStages !== JSON.stringify(['staging'])) ||
         value.load.productionExceptionalOnly !== true) {
-        throw new PerformanceContractError('performance-policy-invalid', 'policy/load', 'must default to protected staging and exceptional production only');
+        throw new PerformanceContractError('performance-policy-invalid', 'policy/load', 'must default to the profile rehearsal stage and exceptional production only');
     }
     positiveInteger(value.load.maximumConcurrency, 'policy/load/maximumConcurrency');
     positiveInteger(value.load.maximumDurationSeconds, 'policy/load/maximumDurationSeconds');

package/src/performance/scenario.d.ts

@@ -36,6 +36,28 @@ export declare const PROTECTED_LOAD_SCENARIO_ADAPTERS: readonly [{
     readonly saturationSignalRef: "database:connection-utilization-percent";
     readonly version: "1.0.0";
     readonly workload: "database";
+}, {
+    readonly capacityBound: "rate";
+    readonly cleanupPath: "/__ebk/performance/async-worker/cleanup";
+    readonly id: "ebk-dynamodb-async-v1";
+    readonly mutation: true;
+    readonly requestMethod: "POST";
+    readonly requestPath: "/__ebk/performance/async-worker";
+    readonly scenarioId: "async-key-value-burst";
+    readonly saturationSignalRef: "dynamodb:protected-run-unprocessed-effects-percent";
+    readonly version: "1.0.0";
+    readonly workload: "async-worker";
+}, {
+    readonly capacityBound: "concurrency";
+    readonly cleanupPath: "/__ebk/performance/database/cleanup";
+    readonly id: "ebk-dynamodb-v1";
+    readonly mutation: true;
+    readonly requestMethod: "POST";
+    readonly requestPath: "/__ebk/performance/database";
+    readonly scenarioId: "database-read-write";
+    readonly saturationSignalRef: "dynamodb:protected-request-budget-utilization-percent";
+    readonly version: "1.0.0";
+    readonly workload: "database";
 }, {
     readonly capacityBound: "concurrency";
     readonly cleanupPath: "/__ebk/performance/service/cleanup";

package/src/performance/scenario.js

@@ -613,101 +613,109 @@ async function cleanupProtectedLoadScenarioEffects(input) {
     });
     let remoteCleanup = 'not-required';
     if (adapter.cleanupPath !== null) {
-        const controller = new AbortController();
-        let timeout;
-        try {
-            const authorization = requestAuthorization({
-                adapter,
-                capacity,
-                hmacKeyId: input.hmacKey.id,
-                operation: 'cleanup',
-                plan: input.plan,
-                requestOrdinal: 1,
-                scenario,
-            });
-            const remainingRuntime = cleanupDeadline - Date.now();
-            if (remainingRuntime <= 0) {
-                throw invalid('cleanup/deadline', 'exhausted the bounded cleanup runtime before the request');
-            }
-            const requestTimeout = Math.min(CLEANUP_MAXIMUM_REQUEST_MILLISECONDS, remainingRuntime);
-            const request = (async () => {
-                const response = await fetchImplementation(scenarioUrl(input.plan, cleanupPath(adapter)), {
-                    body: JSON.stringify({
-                        planMaterialDigest: input.plan.materialDigest,
-                        release: input.plan.release,
-                        requestOrdinal: 1,
-                        runId: input.plan.runId,
-                        scenarioId: input.plan.scenarioId,
-                        workload: input.plan.workload,
-                    }),
-                    headers: {
-                        accept: 'application/json',
-                        'content-type': 'application/json',
-                        ...authorizationHeaders({
-                            authorization,
-                            hmacKey: input.hmacKey,
+        let removedSoFar = 0;
+        for (;;) {
+            const controller = new AbortController();
+            let timeout;
+            try {
+                const authorization = requestAuthorization({
+                    adapter,
+                    capacity,
+                    hmacKeyId: input.hmacKey.id,
+                    operation: 'cleanup',
+                    plan: input.plan,
+                    requestOrdinal: 1,
+                    scenario,
+                });
+                const remainingRuntime = cleanupDeadline - Date.now();
+                if (remainingRuntime <= 0) {
+                    throw invalid('cleanup/deadline', 'exhausted the bounded cleanup runtime before the request');
+                }
+                const requestTimeout = Math.min(CLEANUP_MAXIMUM_REQUEST_MILLISECONDS, remainingRuntime);
+                const request = (async () => {
+                    const response = await fetchImplementation(scenarioUrl(input.plan, cleanupPath(adapter)), {
+                        body: JSON.stringify({
+                            planMaterialDigest: input.plan.materialDigest,
+                            release: input.plan.release,
+                            requestOrdinal: 1,
+                            runId: input.plan.runId,
+                            scenarioId: input.plan.scenarioId,
+                            workload: input.plan.workload,
                         }),
-                        'user-agent': 'empire-builder-kit-protected-load-cleanup/1.0.0',
-                    },
-                    method: 'POST',
-                    redirect: 'manual',
-                    signal: controller.signal,
+                        headers: {
+                            accept: 'application/json',
+                            'content-type': 'application/json',
+                            ...authorizationHeaders({
+                                authorization,
+                                hmacKey: input.hmacKey,
+                            }),
+                            'user-agent': 'empire-builder-kit-protected-load-cleanup/1.0.0',
+                        },
+                        method: 'POST',
+                        redirect: 'manual',
+                        signal: controller.signal,
+                    });
+                    return { body: await response.json(), response };
+                })();
+                const expired = new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => {
+                        controller.abort();
+                        reject(invalid('cleanup/deadline', 'exceeded the bounded cleanup request deadline'));
+                    }, requestTimeout);
                 });
-                return { body: await response.json(), response };
-            })();
-            const expired = new Promise((_resolve, reject) => {
-                timeout = setTimeout(() => {
-                    controller.abort();
-                    reject(invalid('cleanup/deadline', 'exceeded the bounded cleanup request deadline'));
-                }, requestTimeout);
-            });
-            const { body, response } = await Promise.race([request, expired]);
-            onlyKeys(body, [
-                'kind',
-                'hmacKeyId',
-                'planMaterialDigest',
-                'release',
-                'remainingEffectCount',
-                'removedEffectCount',
-                'runId',
-                'scenarioId',
-                'schemaVersion',
-                'status',
-                'target',
-            ], 'cleanup/response');
-            validateRelease(body.release, input.plan.release, 'cleanup/response/release');
-            onlyKeys(body.target, ['accountFingerprint', 'endpoint', 'region', 'slice'], 'cleanup/response/target');
-            if (!response.ok ||
-                body.kind !== 'ebk-protected-load-cleanup-result' ||
-                body.hmacKeyId !== input.hmacKey.id ||
-                body.planMaterialDigest !== input.plan.materialDigest ||
-                typeof body.remainingEffectCount !== 'number' ||
-                !Number.isSafeInteger(body.remainingEffectCount) ||
-                body.remainingEffectCount !== 0 ||
-                typeof body.removedEffectCount !== 'number' ||
-                !Number.isSafeInteger(body.removedEffectCount) ||
-                body.removedEffectCount < 0 ||
-                body.runId !== input.plan.runId ||
-                body.scenarioId !== input.plan.scenarioId ||
-                body.schemaVersion !== 1 ||
-                body.status !== 'run-absent' ||
-                JSON.stringify(body.target) !==
-                    JSON.stringify({
-                        accountFingerprint: input.plan.target.accountFingerprint,
-                        endpoint: scenarioUrl(input.plan, cleanupPath(adapter)),
-                        region: input.plan.target.region,
-                        slice: input.plan.slice,
-                    })) {
-                throw invalid('cleanup/response', 'must prove every protected effect for the exact run is absent');
+                const { body, response } = await Promise.race([request, expired]);
+                onlyKeys(body, [
+                    'kind',
+                    'hmacKeyId',
+                    'planMaterialDigest',
+                    'release',
+                    'remainingEffectCount',
+                    'removedEffectCount',
+                    'runId',
+                    'scenarioId',
+                    'schemaVersion',
+                    'status',
+                    'target',
+                ], 'cleanup/response');
+                validateRelease(body.release, input.plan.release, 'cleanup/response/release');
+                onlyKeys(body.target, ['accountFingerprint', 'endpoint', 'region', 'slice'], 'cleanup/response/target');
+                const incomplete = body.status === 'cleanup-in-progress' &&
+                    body.remainingEffectCount === null;
+                if (!response.ok ||
+                    body.kind !== 'ebk-protected-load-cleanup-result' ||
+                    body.hmacKeyId !== input.hmacKey.id ||
+                    body.planMaterialDigest !== input.plan.materialDigest ||
+                    (!incomplete && body.remainingEffectCount !== 0) ||
+                    typeof body.removedEffectCount !== 'number' ||
+                    !Number.isSafeInteger(body.removedEffectCount) ||
+                    body.removedEffectCount < (incomplete ? 1 : 0) ||
+                    body.removedEffectCount > input.plan.maximumRequests - removedSoFar ||
+                    body.runId !== input.plan.runId ||
+                    body.scenarioId !== input.plan.scenarioId ||
+                    body.schemaVersion !== 1 ||
+                    (!incomplete && body.status !== 'run-absent') ||
+                    JSON.stringify(body.target) !==
+                        JSON.stringify({
+                            accountFingerprint: input.plan.target.accountFingerprint,
+                            endpoint: scenarioUrl(input.plan, cleanupPath(adapter)),
+                            region: input.plan.target.region,
+                            slice: input.plan.slice,
+                        })) {
+                    throw invalid('cleanup/response', 'must prove every protected effect for the exact run is absent');
+                }
+                removedSoFar += body.removedEffectCount;
+                if (incomplete)
+                    continue;
+                remoteCleanup = 'run-proved-absent';
+                break;
+            }
+            catch (error) {
+                throw invalid('cleanup', `did not prove the exact protected run absent (${error instanceof Error ? error.message : String(error)})`);
+            }
+            finally {
+                if (timeout !== undefined)
+                    clearTimeout(timeout);
             }
-            remoteCleanup = 'run-proved-absent';
-        }
-        catch (error) {
-            throw invalid('cleanup', `did not prove the exact protected run absent (${error instanceof Error ? error.message : String(error)})`);
-        }
-        finally {
-            if (timeout !== undefined)
-                clearTimeout(timeout);
         }
     }
     const unsigned = {

package/src/release/index.d.ts

@@ -1,4 +1,2 @@
-export * from './lifecycle.js';
-export * from './manifest.js';
 export * from './rollout.js';
 export * from './source-authority.js';

package/src/release/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lifecycle.js"), exports);
-tslib_1.__exportStar(require("./manifest.js"), exports);
 tslib_1.__exportStar(require("./rollout.js"), exports);
 tslib_1.__exportStar(require("./source-authority.js"), exports);
 //# sourceMappingURL=index.js.map

package/src/release/source-authority.d.ts

@@ -3,17 +3,17 @@ export interface ReviewedReleaseCheckoutInput {
     releaseSourceCommit: string | undefined;
     repositoryRoot?: string;
     reviewedSourceCommit?: string;
+    sstEnvironmentProjectRoot?: string;
 }
 export interface ReviewedReleaseCheckout {
     deploymentSourceCommit: string;
-    mode: 'exact-tree' | 'infrastructure-approval-only';
+    mode: 'exact-tree';
     releaseSourceCommit: string;
 }
 /**
  * Proves that protected release evidence can be consumed from the checked-out
- * deployment commit. A different tree is accepted only for the framework's
- * committed infrastructure-approval resume, and only when that exact Git delta
- * contains the approval batch which binds every project back to the immutable
- * release source.
+ * deployment commit. Merge commits are supported through reviewedSourceCommit,
+ * but all three commits must resolve to the same exact source tree. Committed
+ * approval descendants and other source mutations are never release authority.
  */
 export declare function validateReviewedReleaseCheckout(input: ReviewedReleaseCheckoutInput): ReviewedReleaseCheckout;