@empire-builder-kit/nx 1.0.0-rc.37 → 1.0.0-rc.39

package/src/generators/slice/built-in-plan-performance-files.js

@@ -4,6 +4,7 @@ exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = void 0;
 exports.renderProductPerformanceFiles = renderProductPerformanceFiles;
 const built_in_plan_shared_js_1 = require("./built-in-plan-shared.js");
 const index_js_1 = require("../../performance/index.js");
+const built_in_plan_key_value_performance_js_1 = require("./built-in-plan-key-value-performance.js");
 exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = [
     'docs/runbooks/performance-capacity-cost.md',
     'performance/aggregate-count-provider.ts',
@@ -14,6 +15,10 @@ exports.PRODUCT_PERFORMANCE_SEEDED_PATHS = [
 ];
 /** @internal */
 function renderProductPerformanceFiles(name, deploymentProfile = 'starter') {
+    const databaseAdapter = 'ebk-dynamodb-v1';
+    const asyncAdapter = 'ebk-dynamodb-async-v1';
+    const databaseSignal = 'dynamodb:protected-request-budget-utilization-percent';
+    const asyncSignal = 'dynamodb:protected-run-unprocessed-effects-percent';
     const pascalName = name
         .split('-')
         .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
@@ -230,19 +235,19 @@ export function create${pascalName}PerformanceCostControls(input: {
                     kind: 'async-worker',
                     protectionRef: 'control:async-worker-concurrency',
                     quotaMaximum: null,
-                    saturationSignalRef: 'database:protected-async-backlog-utilization-percent',
+                    saturationSignalRef: asyncSignal,
                     status: 'requires-adopter-value',
                 },
                 {
-                    capacityUnit: 'database-connections',
+                    capacityUnit: 'concurrent-requests',
                     configuredMaximum: null,
                     downstreamMaximum: null,
-                    failureMode: 'connection-or-capacity-exhaustion',
+                    failureMode: 'request-latency-or-throttling',
                     id: 'database',
                     kind: 'database',
-                    protectionRef: 'control:database-connections',
+                    protectionRef: 'control:database-request-concurrency',
                     quotaMaximum: null,
-                    saturationSignalRef: 'database:connection-utilization-percent',
+                    saturationSignalRef: databaseSignal,
                     status: 'requires-adopter-value',
                 },
                 {
@@ -319,22 +324,22 @@ export function create${pascalName}PerformanceCostControls(input: {
                 },
                 {
                     adapterStatus: 'managed',
-                    adapterId: 'ebk-async-worker-v1',
+                    adapterId: asyncAdapter,
                     demandShape: 'bounded-flash-burst-and-recovery',
                     disabledUntilAdopted: true,
                     estimatedCostUsdPerRequest: 0.00002,
-                    id: 'async-burst',
-                    saturationSignalRef: 'database:protected-async-backlog-utilization-percent',
+                    id: 'async-key-value-burst',
+                    saturationSignalRef: asyncSignal,
                     workload: 'async-worker',
                 },
                 {
                     adapterStatus: 'managed',
-                    adapterId: 'ebk-database-v1',
-                    demandShape: 'idle-window-then-first-request',
+                    adapterId: databaseAdapter,
+                    demandShape: 'bounded-write-and-consistent-read',
                     disabledUntilAdopted: true,
                     estimatedCostUsdPerRequest: 0.0001,
-                    id: 'database-cold-resume',
-                    saturationSignalRef: 'database:connection-utilization-percent',
+                    id: 'database-read-write',
+                    saturationSignalRef: databaseSignal,
                     workload: 'database',
                 },
                 {
@@ -443,7 +448,7 @@ export function create${pascalName}PerformanceCostControls(input: {
                 accountBudgetAndAnomalyRoute: 'required-pre-v1',
                 actualBillingAndTwoUnitCosts: 'required-pre-v1',
                 coldAndWarmLambdaNextPaths: 'required-pre-v1',
-                databaseColdResumeAndIdleCost: 'required-pre-v1',
+                databaseColdResumeAndIdleCost: 'not-applicable-without-sql',
                 profileTransitionRehearsal: 'required-pre-v1',
                 protectedApiAsyncDatabaseLoad: 'required-pre-v1',
                 serviceRuntimeLoad: 'required-pre-v1-adopter-integration',
@@ -452,8 +457,8 @@ export function create${pascalName}PerformanceCostControls(input: {
             load: {
                 allowlistedScenarioAdapters: [
                     'ebk-api-lambda-v1',
-                    'ebk-async-worker-v1',
-                    'ebk-database-v1',
+                    asyncAdapter,
+                    databaseAdapter,
                 ],
                 localProtectedMutationForbidden: true,
                 productionExceptionalOnly: true,
@@ -1898,18 +1903,15 @@ import {
   handleProtectedLoadCleanupEndpoint,
   handleProtectedLoadScenarioEndpoint,
   type ProtectedLoadEndpointBindingV1,
-  type ProtectedLoadEndpointAdapterId,
   type ProtectedLoadRequestAuthorizationV1,
+${'  DYNAMODB_PROTECTED_REQUEST_BUDGET_MS,\n'}\
 } from '@empire-builder-kit/runtime/performance';
-import { randomUUID } from 'node:crypto';
-import { withPrimaryDatabase } from '../../../../../database/runtime-client';
+${`import { dataStore } from '../../../../../data/key-value';
+import { createPerformancePersistence } from '../../../../../performance/persistence';`}
 import { Secrets } from '../../../../../secrets/declarations';
 import { createStandardSliceSecretRuntime } from '../../../../../secrets/runtime';
 
-type ManagedAdapterId = Exclude<
-  ProtectedLoadEndpointAdapterId,
-  'ebk-service-v1'
->;
+type ManagedAdapterId = 'ebk-api-lambda-v1' | '${asyncAdapter}' | '${databaseAdapter}';
 
 function required(name: string): string {
   const value = process.env[name]?.trim();
@@ -2047,396 +2049,7 @@ function memorySaturation(): number {
   return Math.min(100, (memory.heapUsed / memory.heapTotal) * 100);
 }
 
-function effectUuid(effectId: string): string {
-  return [
-    effectId.slice(0, 8),
-    effectId.slice(8, 12),
-    '4' + effectId.slice(13, 16),
-    '8' + effectId.slice(17, 20),
-    effectId.slice(20, 32),
-  ].join('-');
-}
-
-interface ProtectedPerformanceRunRow {
-  adapterId: string;
-  cleanupStartedAt: Date | null;
-  createdAt: Date;
-  expiresAt: Date;
-  maximumRequests: number;
-  releaseMaterialDigest: string;
-  runId: string;
-  scenarioId: string;
-  sourceCommit: string;
-  stage: string;
-}
-
-function matchesProtectedPerformanceRun(
-  actual: ProtectedPerformanceRunRow | undefined,
-  authorization: ProtectedLoadRequestAuthorizationV1,
-): actual is ProtectedPerformanceRunRow {
-  return (
-    actual !== undefined &&
-    actual.adapterId === authorization.adapterId &&
-    actual.createdAt.toISOString() === authorization.createdAt &&
-    actual.expiresAt.toISOString() === authorization.expiresAt &&
-    actual.maximumRequests === authorization.maximumRequests &&
-    actual.releaseMaterialDigest ===
-      authorization.release.releaseMaterialDigest &&
-    actual.runId === authorization.runId &&
-    actual.scenarioId === authorization.scenarioId &&
-    actual.sourceCommit === authorization.release.sourceCommit &&
-    actual.stage === authorization.stage
-  );
-}
-
-export async function reserveRequest(
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        await client.query(
-          \`INSERT INTO performance_load_runs
-             (plan_digest, run_id, adapter_id, scenario_id, stage,
-              source_commit, release_material_digest, maximum_requests,
-              created_at, expires_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz,
-                   $10::timestamptz)
-           ON CONFLICT (plan_digest) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.runId,
-            authorization.adapterId,
-            authorization.scenarioId,
-            authorization.stage,
-            authorization.release.sourceCommit,
-            authorization.release.releaseMaterialDigest,
-            authorization.maximumRequests,
-            authorization.createdAt,
-            authorization.expiresAt,
-          ],
-        );
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        const actual = run.rows[0];
-        if (
-          !matchesProtectedPerformanceRun(actual, authorization) ||
-          actual.cleanupStartedAt !== null
-        ) {
-          throw new Error('protected-performance-run-collision');
-        }
-        const claimed = await client.query(
-          \`INSERT INTO performance_load_requests
-             (plan_digest, request_ordinal, effect_id)
-           VALUES ($1, $2, $3)
-           ON CONFLICT (plan_digest, request_ordinal) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.requestOrdinal,
-            authorization.effectId,
-          ],
-        );
-        if (claimed.rowCount !== 1) {
-          throw new Error('protected-performance-request-replayed');
-        }
-        await client.query('COMMIT');
-        return 'claimed' as const;
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
-export async function databaseExecution(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
-  effectId: string,
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        const activeRun = run.rows[0];
-        if (
-          !matchesProtectedPerformanceRun(activeRun, authorization) ||
-          activeRun.cleanupStartedAt !== null
-        ) {
-          throw new Error('protected-performance-run-cleaning');
-        }
-        if (adapterId === 'ebk-async-worker-v1') {
-          const inserted = await client.query(
-            \`INSERT INTO performance_load_async_effects
-               (effect_id, plan_digest, run_id, expires_at)
-             VALUES ($1, $2, $3, now() + INTERVAL '24 hours')
-             ON CONFLICT (effect_id) DO NOTHING\`,
-            [
-              effectId,
-              authorization.planMaterialDigest,
-              authorization.runId,
-            ],
-          );
-          const identity = await client.query<{
-            planDigest: string;
-            runId: string;
-          }>(
-            \`SELECT
-               plan_digest AS "planDigest",
-               run_id AS "runId"
-             FROM performance_load_async_effects
-             WHERE effect_id = $1\`,
-            [effectId],
-          );
-          if (
-            identity.rows[0]?.planDigest !==
-              authorization.planMaterialDigest ||
-            identity.rows[0]?.runId !== authorization.runId
-          ) {
-            throw new Error('protected-performance-effect-collision');
-          }
-          const pending = await client.query<{ count: string }>(
-            \`SELECT count(*)::text AS count
-             FROM performance_load_async_effects
-             WHERE processed_at IS NULL AND expires_at > now()\`,
-          );
-          const maximum = authorization.configuredMaximum;
-          if (!Number.isFinite(maximum) || maximum <= 0) {
-            throw new Error('protected-performance-async-maximum-invalid');
-          }
-          const result = {
-            effectState:
-              inserted.rowCount === 1
-                ? ('created' as const)
-                : ('already-existed' as const),
-            saturationPercent: Math.min(
-              100,
-              (Number(pending.rows[0]?.count ?? 0) / maximum) * 100,
-            ),
-          };
-          await client.query('COMMIT');
-          return result;
-        }
-        const id = effectUuid(effectId);
-        const inserted = await client.query(
-          \`INSERT INTO records
-             (id, name, owner_id, run_scope, test_expires_at)
-           VALUES (
-             $1::uuid,
-             'ebk-protected-performance-load',
-             'ebk-performance',
-             $2,
-             now() + INTERVAL '24 hours'
-           )
-           ON CONFLICT (id) DO NOTHING\`,
-          [id, authorization.planMaterialDigest],
-        );
-        const identity = await client.query<{
-          name: string;
-          ownerId: string;
-          runScope: string;
-        }>(
-          \`SELECT
-             name,
-             owner_id AS "ownerId",
-             run_scope AS "runScope"
-           FROM records
-           WHERE id = $1::uuid\`,
-          [id],
-        );
-        if (
-          identity.rows[0]?.name !== 'ebk-protected-performance-load' ||
-          identity.rows[0]?.ownerId !== 'ebk-performance' ||
-          identity.rows[0]?.runScope !== authorization.planMaterialDigest
-        ) {
-          throw new Error('protected-performance-effect-collision');
-        }
-        const activity = await client.query<{
-          active: string;
-          maximum: string;
-        }>(
-          \`SELECT
-             count(*)::text AS active,
-             current_setting('max_connections') AS maximum
-           FROM pg_stat_activity
-           WHERE datname = current_database()\`,
-        );
-        const active = Number(activity.rows[0]?.active ?? 0);
-        const maximum = Number(activity.rows[0]?.maximum ?? 0);
-        if (!Number.isFinite(maximum) || maximum <= 0) {
-          throw new Error('protected-performance-database-maximum-invalid');
-        }
-        const result = {
-          effectState:
-            inserted.rowCount === 1
-              ? ('created' as const)
-              : ('already-existed' as const),
-          saturationPercent: Math.min(100, (active / maximum) * 100),
-        };
-        await client.query('COMMIT');
-        return result;
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
-export async function cleanupRun(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
-  authorization: ProtectedLoadRequestAuthorizationV1,
-) {
-  return withPrimaryDatabase(
-    { correlationId: randomUUID() },
-    'web-server',
-    async (client) => {
-      await client.query('BEGIN');
-      try {
-        await client.query(
-          \`INSERT INTO performance_load_runs
-             (plan_digest, run_id, adapter_id, scenario_id, stage,
-              source_commit, release_material_digest, maximum_requests,
-              created_at, expires_at, cleanup_started_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz,
-                   $10::timestamptz, now())
-           ON CONFLICT (plan_digest) DO NOTHING\`,
-          [
-            authorization.planMaterialDigest,
-            authorization.runId,
-            authorization.adapterId,
-            authorization.scenarioId,
-            authorization.stage,
-            authorization.release.sourceCommit,
-            authorization.release.releaseMaterialDigest,
-            authorization.maximumRequests,
-            authorization.createdAt,
-            authorization.expiresAt,
-          ],
-        );
-        const run = await client.query<ProtectedPerformanceRunRow>(
-          \`SELECT
-             adapter_id AS "adapterId",
-             cleanup_started_at AS "cleanupStartedAt",
-             created_at AS "createdAt",
-             expires_at AS "expiresAt",
-             maximum_requests AS "maximumRequests",
-             release_material_digest AS "releaseMaterialDigest",
-             run_id AS "runId",
-             scenario_id AS "scenarioId",
-             source_commit AS "sourceCommit",
-             stage
-           FROM performance_load_runs
-           WHERE plan_digest = $1
-           FOR UPDATE\`,
-          [authorization.planMaterialDigest],
-        );
-        if (!matchesProtectedPerformanceRun(run.rows[0], authorization)) {
-          throw new Error('protected-performance-run-collision');
-        }
-        await client.query(
-          \`UPDATE performance_load_runs
-           SET cleanup_started_at = COALESCE(cleanup_started_at, now())
-           WHERE plan_digest = $1\`,
-          [authorization.planMaterialDigest],
-        );
-        await client.query('COMMIT');
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-
-      await client.query('BEGIN');
-      try {
-        const removed =
-          adapterId === 'ebk-async-worker-v1'
-            ? await client.query(
-                \`DELETE FROM performance_load_async_effects
-                 WHERE plan_digest = $1
-                   AND run_id = $2\`,
-                [authorization.planMaterialDigest, authorization.runId],
-              )
-            : await client.query(
-                \`DELETE FROM records
-                 WHERE owner_id = 'ebk-performance'
-                   AND name = 'ebk-protected-performance-load'
-                   AND run_scope = $1\`,
-                [authorization.planMaterialDigest],
-              );
-        const remaining =
-          adapterId === 'ebk-async-worker-v1'
-            ? await client.query<{ count: string }>(
-                \`SELECT count(*)::text AS count
-                 FROM performance_load_async_effects
-                 WHERE plan_digest = $1
-                   AND run_id = $2\`,
-                [authorization.planMaterialDigest, authorization.runId],
-              )
-            : await client.query<{ count: string }>(
-                \`SELECT count(*)::text AS count
-                 FROM records
-                 WHERE owner_id = 'ebk-performance'
-                   AND name = 'ebk-protected-performance-load'
-                   AND run_scope = $1\`,
-                [authorization.planMaterialDigest],
-              );
-        const remainingEffectCount = Number(remaining.rows[0]?.count ?? 0);
-        if (
-          !Number.isSafeInteger(remainingEffectCount) ||
-          remainingEffectCount !== 0
-        ) {
-          throw new Error('protected-performance-cleanup-incomplete');
-        }
-        await client.query('COMMIT');
-        return {
-          remainingEffectCount,
-          removedEffectCount: removed.rowCount ?? 0,
-        };
-      } catch (error) {
-        await client.query('ROLLBACK').catch(() => undefined);
-        throw error;
-      }
-    },
-  );
-}
-
+${(0, built_in_plan_key_value_performance_js_1.renderKeyValuePerformanceEndpointFunctions)()}
 function refused() {
   return Response.json(
     {
@@ -2461,8 +2074,8 @@ export async function runPerformanceScenarioEndpoint(
         binding,
         execute: async ({ authorization, effectId }) => {
           if (
-            adapterId === 'ebk-async-worker-v1' ||
-            adapterId === 'ebk-database-v1'
+            adapterId === '${asyncAdapter}' ||
+            adapterId === '${databaseAdapter}'
           ) {
             if (!effectId) throw new Error('protected-effect-required');
             return databaseExecution(adapterId, effectId, authorization);
@@ -2480,7 +2093,7 @@ export async function runPerformanceScenarioEndpoint(
 }
 
 export async function runPerformanceCleanupEndpoint(
-  adapterId: 'ebk-async-worker-v1' | 'ebk-database-v1',
+  adapterId: '${asyncAdapter}' | '${databaseAdapter}',
   request: Request,
 ) {
   try {
@@ -2533,9 +2146,9 @@ vi.mock('@empire-builder-kit/runtime/performance', () => ({
     status: 200,
   })),
 }));
-vi.mock('../../../../../database/runtime-client', () => ({
-  withPrimaryDatabase: vi.fn(),
-}));
+${`vi.mock('../../../../../performance/persistence', () => ({
+  createPerformancePersistence: vi.fn(),
+}));`}
 vi.mock('../../../../../secrets/declarations', () => ({
   Secrets: { GeneratedPerformanceLoadHmacKeys: {} },
 }));
@@ -2581,590 +2194,7 @@ describe('${name} protected performance secret cache lifetime', () => {
   });
 });
 `,
-        'integration/performance-load-cleanup.spec.ts': `import { Client } from 'pg';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { ProtectedLoadRequestAuthorizationV1 } from '@empire-builder-kit/runtime/performance';
-import { createInboxCleanupHandler } from '../async/inbox-cleanup.js';
-import {
-  cleanupRun,
-  databaseExecution,
-  reserveRequest,
-} from '../web/src/app/%5F%5Febk/performance/handler.js';
-
-vi.mock('server-only', () => ({}));
-vi.mock('../database/runtime-client.js', () => ({
-  withPrimaryDatabase: async (
-    _context: unknown,
-    _workload: unknown,
-    operation: (client: Client) => Promise<unknown>,
-  ) => {
-    const { Client: RuntimeClient } = await import('pg');
-    const client = new RuntimeClient({
-      connectionString: process.env.DATABASE_URL,
-    });
-    await client.connect();
-    try {
-      return await operation(client);
-    } finally {
-      await client.end();
-    }
-  },
-}));
-
-const databaseUrl = process.env.DATABASE_URL;
-if (!databaseUrl) {
-  throw new Error(
-    'DATABASE_URL is required for ${name} performance cleanup integration proof.',
-  );
-}
-
-const touchedPlanDigests = new Set<string>();
-
-function authorization(input: {
-  effectId: string | null;
-  operation: 'cleanup' | 'execute';
-  planMaterialDigest: string;
-  requestOrdinal?: number;
-}): ProtectedLoadRequestAuthorizationV1 {
-  return {
-    adapterId: 'ebk-async-worker-v1',
-    configuredMaximum: 100,
-    createdAt: '2026-07-29T12:00:00.000Z',
-    durationSeconds: 60,
-    effectId: input.effectId,
-    expiresAt: '2026-07-29T13:00:00.000Z',
-    hmacKeyId: 'integration-v1',
-    maximumRequests: 10,
-    operation: input.operation,
-    planMaterialDigest: input.planMaterialDigest,
-    release: {
-      candidateDigest: 'c'.repeat(64),
-      releaseId: 'integration-release',
-      releaseMaterialDigest: 'd'.repeat(64),
-      sourceCommit: 'b'.repeat(40),
-    },
-    requestOrdinal: input.requestOrdinal ?? 1,
-    runId: 'integration-run-' + input.planMaterialDigest.slice(0, 8),
-    saturationSignalRef:
-      'database:protected-async-backlog-utilization-percent',
-    scenarioId: 'async-burst',
-    stage: 'staging',
-    target: {
-      accountFingerprint: 'sha256:' + 'e'.repeat(64),
-      endpoint:
-        'https://performance.example.test/${name}/__ebk/performance/async-worker',
-      region: 'us-east-1',
-      slice: '${name}',
-    },
-    workload: 'async-worker',
-  };
-}
-
-async function withClient<Result>(
-  operation: (client: Client) => Promise<Result>,
-): Promise<Result> {
-  const client = new Client({ connectionString: databaseUrl });
-  await client.connect();
-  try {
-    return await operation(client);
-  } finally {
-    await client.end();
-  }
-}
-
-// A loaded-host budget: hosted runners share four cores between Vitest,
-// the proof registry, and the dockerized database.
-async function waitForActiveStatement(
-  client: Client,
-  fragment: string,
-): Promise<void> {
-  const deadline = Date.now() + 15_000;
-  while (Date.now() < deadline) {
-    const active = await client.query<{ count: string }>(
-      \`SELECT count(*)::text AS count
-       FROM pg_stat_activity
-       WHERE datname = current_database()
-         AND pid <> pg_backend_pid()
-         AND state = 'active'
-         AND query LIKE $1\`,
-      ['%' + fragment + '%'],
-    );
-    if (Number(active.rows[0]?.count ?? 0) > 0) return;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  throw new Error('Timed out waiting for the adversarial database statement.');
-}
-
-afterEach(async () => {
-  await withClient(async (client) => {
-    await client
-      .query(
-        'DROP TRIGGER IF EXISTS ebk_performance_delay_effect ON performance_load_async_effects',
-      )
-      .catch(() => undefined);
-    await client
-      .query('DROP FUNCTION IF EXISTS ebk_performance_delay_effect()')
-      .catch(() => undefined);
-    for (const planDigest of touchedPlanDigests) {
-      await client.query('DELETE FROM records WHERE run_scope = $1', [
-        planDigest,
-      ]);
-      await client.query(
-        'DELETE FROM performance_load_async_effects WHERE plan_digest = $1',
-        [planDigest],
-      );
-      await client.query(
-        'DELETE FROM performance_load_requests WHERE plan_digest = $1',
-        [planDigest],
-      );
-      await client.query(
-        'DELETE FROM performance_load_runs WHERE plan_digest = $1',
-        [planDigest],
-      );
-    }
-    await client.query(
-      "DELETE FROM cleanup_deadline_reports WHERE feature = 'performance-load'",
-    );
-  });
-  touchedPlanDigests.clear();
-});
-
-describe('${name} protected performance cleanup integration', () => {
-  it('serializes cleanup behind an in-flight effect and rejects every late effect', async () => {
-    const planMaterialDigest = '1'.repeat(64);
-    const effectId = '2'.repeat(64);
-    touchedPlanDigests.add(planMaterialDigest);
-    const executeAuthorization = authorization({
-      effectId,
-      operation: 'execute',
-      planMaterialDigest,
-    });
-    const cleanupAuthorization = authorization({
-      effectId: null,
-      operation: 'cleanup',
-      planMaterialDigest,
-    });
-
-    await reserveRequest(executeAuthorization);
-    await withClient(async (client) => {
-      await client.query(
-        \`CREATE OR REPLACE FUNCTION ebk_performance_delay_effect()
-         RETURNS trigger
-         LANGUAGE plpgsql
-         AS $$
-         BEGIN
-           PERFORM pg_sleep(1);
-           RETURN NEW;
-         END
-         $$\`,
-      );
-      await client.query(
-        \`CREATE TRIGGER ebk_performance_delay_effect
-         BEFORE INSERT ON performance_load_async_effects
-         FOR EACH ROW EXECUTE FUNCTION ebk_performance_delay_effect()\`,
-      );
-    });
-
-    const observer = new Client({ connectionString: databaseUrl });
-    await observer.connect();
-    try {
-      const effect = databaseExecution(
-        'ebk-async-worker-v1',
-        effectId,
-        executeAuthorization,
-      );
-      await waitForActiveStatement(
-        observer,
-        'INSERT INTO performance_load_async_effects',
-      );
-      const cleanup = cleanupRun(
-        'ebk-async-worker-v1',
-        cleanupAuthorization,
-      );
-      await expect(effect).resolves.toMatchObject({ effectState: 'created' });
-      await expect(cleanup).resolves.toEqual({
-        remainingEffectCount: 0,
-        removedEffectCount: 1,
-      });
-    } finally {
-      await observer.end();
-    }
-
-    await expect(
-      databaseExecution(
-        'ebk-async-worker-v1',
-        '3'.repeat(64),
-        {
-          ...executeAuthorization,
-          effectId: '3'.repeat(64),
-          requestOrdinal: 2,
-        },
-      ),
-    ).rejects.toThrow('protected-performance-run-cleaning');
-    await expect(
-      reserveRequest({
-        ...executeAuthorization,
-        effectId: '3'.repeat(64),
-        requestOrdinal: 2,
-      }),
-    ).rejects.toThrow('protected-performance-run-collision');
-
-    await withClient(async (client) => {
-      const state = await client.query<{
-        cleanupStarted: boolean;
-        effects: string;
-      }>(
-        \`SELECT
-           run.cleanup_started_at IS NOT NULL AS "cleanupStarted",
-           (
-             SELECT count(*)::text
-             FROM performance_load_async_effects AS effect
-             WHERE effect.plan_digest = run.plan_digest
-           ) AS effects
-         FROM performance_load_runs AS run
-         WHERE run.plan_digest = $1\`,
-        [planMaterialDigest],
-      );
-      expect(state.rows).toEqual([
-        { cleanupStarted: true, effects: '0' },
-      ]);
-    });
-  });
-
-  it('tombstones and proves an effect-free run absent without a local ledger', async () => {
-    const planMaterialDigest = '4'.repeat(64);
-    touchedPlanDigests.add(planMaterialDigest);
-    const cleanupAuthorization = authorization({
-      effectId: null,
-      operation: 'cleanup',
-      planMaterialDigest,
-    });
-
-    await expect(
-      cleanupRun('ebk-async-worker-v1', cleanupAuthorization),
-    ).resolves.toEqual({
-      remainingEffectCount: 0,
-      removedEffectCount: 0,
-    });
-    await expect(
-      cleanupRun('ebk-async-worker-v1', cleanupAuthorization),
-    ).resolves.toEqual({
-      remainingEffectCount: 0,
-      removedEffectCount: 0,
-    });
-    await expect(
-      reserveRequest({
-        ...cleanupAuthorization,
-        effectId: '5'.repeat(64),
-        operation: 'execute',
-      }),
-    ).rejects.toThrow('protected-performance-run-collision');
-  });
-
-  it('expires only framework-owned due rows and retains fresh audit state', async () => {
-    const oldPlan = '6'.repeat(64);
-    const freshPlan = '7'.repeat(64);
-    const expiredEffectPlan = '8'.repeat(64);
-    const freshEffectPlan = '9'.repeat(64);
-    for (const digest of [
-      oldPlan,
-      freshPlan,
-      expiredEffectPlan,
-      freshEffectPlan,
-    ]) {
-      touchedPlanDigests.add(digest);
-    }
-    const expiredRecordId = '10000000-0000-4000-8000-000000000001';
-    const freshRecordId = '10000000-0000-4000-8000-000000000002';
-    const adopterRecordId = '10000000-0000-4000-8000-000000000003';
-
-    await withClient(async (client) => {
-      await client.query(
-        \`INSERT INTO performance_load_runs
-           (plan_digest, run_id, adapter_id, scenario_id, stage,
-            source_commit, release_material_digest, maximum_requests,
-            created_at, expires_at)
-         VALUES
-           ($1, 'old-run', 'ebk-async-worker-v1', 'async-burst', 'staging',
-            $3, $4, 10, now() - INTERVAL '32 days',
-            now() - INTERVAL '31 days'),
-           ($2, 'fresh-run', 'ebk-async-worker-v1', 'async-burst', 'staging',
-            $3, $4, 10, now() - INTERVAL '30 days',
-            now() - INTERVAL '29 days')\`,
-        [oldPlan, freshPlan, 'b'.repeat(40), 'd'.repeat(64)],
-      );
-      await client.query(
-        \`INSERT INTO performance_load_requests
-           (plan_digest, request_ordinal, effect_id)
-         VALUES ($1, 1, NULL), ($2, 1, NULL)\`,
-        [oldPlan, freshPlan],
-      );
-      await client.query(
-        \`INSERT INTO performance_load_async_effects
-           (effect_id, plan_digest, run_id, expires_at)
-         VALUES
-           ($1, $2, 'expired', now() - INTERVAL '1 minute'),
-           ($3, $4, 'fresh', now() + INTERVAL '1 day')\`,
-        ['a'.repeat(64), expiredEffectPlan, 'f'.repeat(64), freshEffectPlan],
-      );
-      await client.query(
-        \`INSERT INTO records
-           (id, name, owner_id, run_scope, test_expires_at)
-         VALUES
-           ($1::uuid, 'ebk-protected-performance-load', 'ebk-performance',
-            $4, now() - INTERVAL '1 minute'),
-           ($2::uuid, 'ebk-protected-performance-load', 'ebk-performance',
-            $5, now() + INTERVAL '1 day'),
-           ($3::uuid, 'adopter-performance-data', 'adopter-owner',
-            $4, now() - INTERVAL '1 minute')\`,
-        [
-          expiredRecordId,
-          freshRecordId,
-          adopterRecordId,
-          expiredEffectPlan,
-          freshEffectPlan,
-        ],
-      );
-    });
-
-    const emitted: Array<{ metricName?: string; value?: number }> = [];
-    const handler = createInboxCleanupHandler({
-      logger: {
-        error: vi.fn(),
-        info: vi.fn(),
-      } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          emitted.push(metric);
-          return {} as never;
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(handler({ id: 'performance-expiry-proof' })).resolves.toMatchObject({
-      performanceAuditRetentionDays: 30,
-      performanceCleanupDeadlineHours: 24,
-      reportedPerformanceDeadlineBreaches: 0,
-      remainingPerformanceExpired: 0,
-      removedPerformance: 4,
-    });
-    expect(emitted).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupBacklog',
-        value: 0,
-      }),
-    );
-    expect(emitted).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 0,
-      }),
-    );
-
-    await withClient(async (client) => {
-      const effects = await client.query<{ planDigest: string }>(
-        \`SELECT plan_digest AS "planDigest"
-         FROM performance_load_async_effects
-         WHERE plan_digest = ANY($1::text[])
-         ORDER BY plan_digest\`,
-        [[expiredEffectPlan, freshEffectPlan]],
-      );
-      expect(effects.rows).toEqual([{ planDigest: freshEffectPlan }]);
-      const records = await client.query<{ id: string }>(
-        \`SELECT id::text AS id
-         FROM records
-         WHERE id = ANY($1::uuid[])
-         ORDER BY id\`,
-        [[expiredRecordId, freshRecordId, adopterRecordId]],
-      );
-      expect(records.rows).toEqual([
-        { id: freshRecordId },
-        { id: adopterRecordId },
-      ]);
-      const audits = await client.query<{
-        planDigest: string;
-        requests: string;
-      }>(
-        \`SELECT
-           run.plan_digest AS "planDigest",
-           count(request.request_ordinal)::text AS requests
-         FROM performance_load_runs AS run
-         LEFT JOIN performance_load_requests AS request
-           ON request.plan_digest = run.plan_digest
-         WHERE run.plan_digest = ANY($1::text[])
-         GROUP BY run.plan_digest
-         ORDER BY run.plan_digest\`,
-        [[oldPlan, freshPlan]],
-      );
-      expect(audits.rows).toEqual([
-        { planDigest: freshPlan, requests: '1' },
-      ]);
-    });
-  });
-
-  it('durably retries deadline telemetry after deleting stale protected residue', async () => {
-    const stalePlan = 'a'.repeat(64);
-    const staleEffectId = 'b'.repeat(64);
-    const atDeadlinePlan = 'c'.repeat(64);
-    const atDeadlineEffectId = 'd'.repeat(64);
-    const beforeDeadlinePlan = 'e'.repeat(64);
-    const beforeDeadlineEffectId = 'f'.repeat(64);
-    const staleRecordId = '10000000-0000-4000-8000-000000000004';
-    for (const planDigest of [
-      stalePlan,
-      atDeadlinePlan,
-      beforeDeadlinePlan,
-    ]) {
-      touchedPlanDigests.add(planDigest);
-    }
-    await withClient(async (client) => {
-      await client.query(
-        \`INSERT INTO performance_load_async_effects
-           (effect_id, plan_digest, run_id, expires_at)
-         VALUES
-           ($1, $2, 'stale-deadline',
-             clock_timestamp() - INTERVAL '25 hours'),
-           ($3, $4, 'exact-deadline',
-             clock_timestamp() - INTERVAL '24 hours'),
-           ($5, $6, 'before-deadline',
-             clock_timestamp() - INTERVAL '23 hours 59 minutes')\`,
-        [
-          staleEffectId,
-          stalePlan,
-          atDeadlineEffectId,
-          atDeadlinePlan,
-          beforeDeadlineEffectId,
-          beforeDeadlinePlan,
-        ],
-      );
-      await client.query(
-        \`INSERT INTO records
-           (id, name, owner_id, run_scope, test_expires_at)
-         VALUES ($1::uuid, 'ebk-protected-performance-load',
-           'ebk-performance', $2, now() - INTERVAL '25 hours')\`,
-        [staleRecordId, stalePlan],
-      );
-    });
-
-    const failedEmissions: Array<{ metricName?: string; value?: number }> = [];
-    const failedHandler = createInboxCleanupHandler({
-      logger: { error: vi.fn(), info: vi.fn() } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          failedEmissions.push(metric);
-          return metric.metricName ===
-            'PerformanceLoadCleanupDeadlineBreaches'
-            ? undefined
-            : ({} as never);
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(
-      failedHandler({ id: 'performance-deadline-report-failure' }),
-    ).rejects.toThrow('Performance cleanup deadline metric delivery failed.');
-
-    await withClient(async (client) => {
-      const state = await client.query<{
-        effects: string;
-        records: string;
-        reports: string;
-        resourceRefs: string[];
-      }>(
-        \`SELECT
-           (SELECT count(*)::text
-            FROM performance_load_async_effects
-            WHERE effect_id = ANY($1::text[])) AS effects,
-           (SELECT count(*)::text
-            FROM records
-            WHERE id = $2::uuid) AS records,
-           (SELECT count(*)::text
-            FROM cleanup_deadline_reports
-            WHERE feature = 'performance-load') AS reports,
-           (SELECT array_agg(resource_ref ORDER BY resource_ref)
-            FROM cleanup_deadline_reports
-            WHERE feature = 'performance-load') AS "resourceRefs"\`,
-        [
-          [staleEffectId, atDeadlineEffectId, beforeDeadlineEffectId],
-          staleRecordId,
-        ],
-      );
-      expect(state.rows).toEqual([
-        {
-          effects: '0',
-          records: '0',
-          reports: '3',
-          resourceRefs: [
-            'async-effect:' + staleEffectId,
-            'async-effect:' + atDeadlineEffectId,
-            'record:' + staleRecordId,
-          ].sort(),
-        },
-      ]);
-    });
-    expect(JSON.stringify(failedEmissions)).not.toContain(staleEffectId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(staleRecordId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(atDeadlineEffectId);
-    expect(JSON.stringify(failedEmissions)).not.toContain(
-      beforeDeadlineEffectId,
-    );
-
-    const retryEmissions: Array<{ metricName?: string; value?: number }> = [];
-    const retryHandler = createInboxCleanupHandler({
-      logger: { error: vi.fn(), info: vi.fn() } as never,
-      metrics: {
-        emit: (metric: { metricName?: string; value?: number }) => {
-          retryEmissions.push(metric);
-          return {} as never;
-        },
-      } as never,
-      now: Date.now,
-      withDatabase: (async (
-        _context: unknown,
-        _workload: unknown,
-        operation: (client: Client) => Promise<unknown>,
-      ) => withClient(operation)) as never,
-    });
-    await expect(
-      retryHandler({ id: 'performance-deadline-report-retry' }),
-    ).rejects.toThrow('performance-load-cleanup-deadline-breached');
-    expect(retryEmissions).toContainEqual(
-      expect.objectContaining({
-        metricName: 'PerformanceLoadCleanupDeadlineBreaches',
-        value: 3,
-      }),
-    );
-    expect(JSON.stringify(retryEmissions)).not.toContain(staleEffectId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(staleRecordId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(atDeadlineEffectId);
-    expect(JSON.stringify(retryEmissions)).not.toContain(
-      beforeDeadlineEffectId,
-    );
-
-    await withClient(async (client) => {
-      const reports = await client.query<{ count: string }>(
-        \`SELECT count(*)::text AS count
-         FROM cleanup_deadline_reports
-         WHERE feature = 'performance-load'\`,
-      );
-      expect(reports.rows).toEqual([{ count: '0' }]);
-    });
-    await expect(
-      retryHandler({ id: 'performance-deadline-after-ack' }),
-    ).resolves.toMatchObject({ reportedPerformanceDeadlineBreaches: 0 });
-  });
-});
-`,
+        ...{},
         'web/src/app/%5F%5Febk/performance/api-lambda/route.ts': `import 'server-only';
 import { runPerformanceScenarioEndpoint } from '../handler';
 
@@ -3176,32 +2206,74 @@ export function GET(request: Request) {
 import { runPerformanceScenarioEndpoint } from '../handler';
 
 export function POST(request: Request) {
-  return runPerformanceScenarioEndpoint('ebk-async-worker-v1', request);
+  return runPerformanceScenarioEndpoint('${asyncAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/async-worker/cleanup/route.ts': `import 'server-only';
 import { runPerformanceCleanupEndpoint } from '../../handler';
 
 export function POST(request: Request) {
-  return runPerformanceCleanupEndpoint('ebk-async-worker-v1', request);
+  return runPerformanceCleanupEndpoint('${asyncAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/database/route.ts': `import 'server-only';
 import { runPerformanceScenarioEndpoint } from '../handler';
 
 export function POST(request: Request) {
-  return runPerformanceScenarioEndpoint('ebk-database-v1', request);
+  return runPerformanceScenarioEndpoint('${databaseAdapter}', request);
 }
 `,
         'web/src/app/%5F%5Febk/performance/database/cleanup/route.ts': `import 'server-only';
 import { runPerformanceCleanupEndpoint } from '../../handler';
 
 export function POST(request: Request) {
-  return runPerformanceCleanupEndpoint('ebk-database-v1', request);
+  return runPerformanceCleanupEndpoint('${databaseAdapter}', request);
 }
 `,
         'docs/runbooks/performance-capacity-cost.md': `# Performance, capacity, and cost
 
+${`The default database scenarios use DynamoDB, not PostgreSQL. The database
+request signal measures the complete protected write/consistent-read operation
+against a one-second budget; it is a latency proxy, not connection count or
+measured DynamoDB service saturation. The async signal measures this run's
+unprocessed synthetic effects against its configured maximum. Expired but
+uncleaned effects remain counted until cleanup, so the signal is conservative.
+The backlog observation is a run-bound sample shared for at most one second
+inside each warm worker process. Concurrent requests reuse that sample instead
+of rescanning the pending collection per request; separate processes may sample
+independently. This is a bounded operational signal, never authorization or a
+global account-wide counter. Cleanup and async processing invalidate the local
+sample; exact per-request identity and effect checks are never cached.
+Neither signal claims account-wide capacity. Cold Aurora resume and idle cost
+apply only after SQL is explicitly declared; default key-value tests do not
+prove that relational acceptance. The signed-request, release, target, quota,
+and exact run-cleanup requirements are unchanged.
+
+Explicit run cleanup closes the exact run before removing effects in bounded
+chunks. A progress response is not acceptance: the harness follows signed
+continuations within its existing deadline and accepts only \`run-absent\` with
+zero remaining effects. If interrupted or timed out, retain the run identity
+and retry its protected cleanup; never reopen the closed run or fabricate an
+absence receipt. Expiry maintenance remains the bounded recovery path.
+
+Native expiry cleanup drains bounded exact pages within a shared four-minute
+invocation budget. It inspects at most 10,000 provider receipts and 5,000
+performance records per invocation; limits and time exhaustion retain cursors
+and report continuation. Provider receipts are removed after thirty days only
+when terminal; uncertain effects stay retained for reconciliation. Performance
+effects expire after twenty-four hours, with request/run audit history retained
+for thirty days after run expiry. Logical request expiry, not physical deletion
+or DynamoDB TTL timing, prevents replay.
+
+Overdue effect deletion and its deadline report commit atomically. Reports stay
+durable until metric emission and acknowledgement succeed; a lost acknowledgement
+may repeat the breach metric. A partial scan does not emit a fabricated zero
+backlog. Require complete-scan evidence and no continuation or pending deadline
+reports before retiring an old signing key. Explicit maintenance pauses retain
+their existing behavior and can delay cleanup; selecting a capacity profile
+does not resume this worker.
+
+`}\
 The generated policy is deliberately an unadopted seed. Replace example budgets,
 unknown capacity values, owner, review date, and allocation drivers from actual
 product requirements before protected promotion. Reliability remains authority
@@ -3355,10 +2427,12 @@ counts, evidence digests, account, Region, stage, workspace, Slice, period, and
 release from that validated evidence; clean generation reports the missing live
 evidence as incomplete.
 
-The generated scenarios cover API/Lambda, async worker, database cold resume,
-and a Service extension that becomes managed when its Service is generated,
-but are disabled until deliberately adopted. A clean generated Slice therefore reports incomplete rather than
-claiming capacity, cost, or live load evidence.
+The generated scenarios cover API/Lambda, async worker, and DynamoDB-backed
+database operations. Cold Aurora resume and idle cost are separate acceptance
+cases only when SQL is declared. A Service extension becomes managed when its
+Service is generated. Scenarios are disabled until deliberately adopted. A
+clean generated Slice therefore reports incomplete rather than claiming
+capacity, cost, or live load evidence.
 `,
     };
 }