@empire-builder-kit/nx 1.0.0-rc.30 → 1.0.0-rc.32

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

@@ -6,16 +6,12 @@ const tool_versions_js_1 = require("../preset/tool-versions.js");
 const built_in_plan_shared_js_1 = require("./built-in-plan-shared.js");
 const personalStagePattern = '^personal-[a-z0-9](?:[a-z0-9-]{0,25}[a-z0-9])?$';
 /** @internal */
-function renderStandardSliceSecretRuntimeFiles(name) {
-    const pascalName = name
-        .split('-')
-        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-        .join('');
+function renderStandardSliceSecretRuntimeFiles(name, workspace = 'workspace') {
     return {
         'secrets/workload-access.json': (0, built_in_plan_shared_js_1.json)({
             bindings: [
                 {
-                    logicalName: `${pascalName}PerformanceLoadHmacKeys`,
+                    logicalName: 'GeneratedPerformanceLoadHmacKeys',
                     workload: `${name}.web-server`,
                 },
             ],
@@ -41,6 +37,7 @@ function declarationProjection(declaration) {
     !hasOnlyProperties(declaration, [
       'cache',
       'contractVersion',
+      'generation',
       'logicalName',
       'owner',
       'requiredStages',
@@ -56,17 +53,27 @@ function declarationProjection(declaration) {
     declaration.requiredStages.some((stage) => typeof stage !== 'string') ||
     !isRecord(declaration.rotation) ||
     !['manual', 'provider-managed'].includes(declaration.rotation.mode) ||
-    !['aws-managed', 'database-bootstrap', 'operator'].includes(
+    !['aws-managed', 'database-bootstrap', 'generated', 'operator'].includes(
       declaration.source,
     ) ||
     !isRecord(declaration.value) ||
     !hasOnlyProperties(declaration.value, ['kind', 'validate']) ||
     !['binary', 'json', 'string'].includes(declaration.value.kind) ||
-    typeof declaration.value.validate !== 'function'
+    typeof declaration.value.validate !== 'function' ||
+    (declaration.source === 'generated') !==
+      (declaration.generation !== undefined) ||
+    (declaration.generation !== undefined &&
+      (!isRecord(declaration.generation) ||
+        !hasOnlyProperties(declaration.generation, ['kind']) ||
+        declaration.generation.kind !== 'hmac-key-ring-v1' ||
+        declaration.value.kind !== 'json'))
   ) {
     throw new Error('invalid');
   }
   return {
+    ...(declaration.generation === undefined
+      ? {}
+      : { generation: { kind: declaration.generation.kind } }),
     logicalName: declaration.logicalName,
     owner: declaration.owner,
     requiredStages: [...declaration.requiredStages],
@@ -80,7 +87,7 @@ function parseMetadata(value) {
   if (
     !isRecord(value) ||
     !hasOnlyProperties(value, ['declarations', 'schemaVersion']) ||
-    value.schemaVersion !== 1 ||
+    value.schemaVersion !== 2 ||
     !Array.isArray(value.declarations)
   ) {
     throw new Error('invalid');
@@ -90,6 +97,7 @@ function parseMetadata(value) {
     if (
       !isRecord(declaration) ||
       !hasOnlyProperties(declaration, [
+        'generation',
         'logicalName',
         'owner',
         'requiredStages',
@@ -106,9 +114,16 @@ function parseMetadata(value) {
       !isRecord(declaration.rotation) ||
       !hasOnlyProperties(declaration.rotation, ['mode']) ||
       !['manual', 'provider-managed'].includes(declaration.rotation.mode) ||
-      !['aws-managed', 'database-bootstrap', 'operator'].includes(
+      !['aws-managed', 'database-bootstrap', 'generated', 'operator'].includes(
         declaration.source,
       ) ||
+      (declaration.source === 'generated') !==
+        (declaration.generation !== undefined) ||
+      (declaration.generation !== undefined &&
+        (!isRecord(declaration.generation) ||
+          !hasOnlyProperties(declaration.generation, ['kind']) ||
+          declaration.generation.kind !== 'hmac-key-ring-v1' ||
+          declaration.valueKind !== 'json')) ||
       !['binary', 'json', 'string'].includes(declaration.valueKind) ||
       logicalNames.has(declaration.logicalName)
     ) {
@@ -116,6 +131,9 @@ function parseMetadata(value) {
     }
     logicalNames.add(declaration.logicalName);
     return {
+      ...(declaration.generation === undefined
+        ? {}
+        : { generation: { kind: declaration.generation.kind } }),
       logicalName: declaration.logicalName,
       owner: declaration.owner,
       requiredStages: [...declaration.requiredStages],
@@ -244,6 +262,7 @@ import {
   createPersonalSecretLedgerRecord,
   isExactSstSecretAlreadyAbsent,
 } from '@empire-builder-kit/nx/secrets';
+import { assertWorkspaceStageOwnershipForWorkspace } from '@empire-builder-kit/nx/workspace-deployment';
 import { execFile } from 'node:child_process';
 import { readFile, realpath } from 'node:fs/promises';
 import { dirname, isAbsolute, relative, resolve } from 'node:path';
@@ -489,6 +508,18 @@ async function main() {
   await verifyDeclarations(projectRoot, environment);
   const binary = await workspaceSstRuntime(workspaceRoot);
   const accountId = await requiredAwsContext(environment, profile, region);
+  const ownership = await assertWorkspaceStageOwnershipForWorkspace(
+    workspaceRoot,
+    'development',
+    {
+      configFilepath: environment.AWS_CONFIG_FILE,
+      credentialsFilepath: environment.AWS_SHARED_CREDENTIALS_FILE,
+      profile,
+    },
+  );
+  if (ownership.region !== region) {
+    throw new Error('Personal secret cleanup Region differs from its exact workspace owner tuple.');
+  }
   const identity = {
     accountId,
     region,
@@ -717,15 +748,15 @@ export function createStandardSliceSecretRuntime(
 }
 `,
         'infra/personal-secrets.ts': `import {
+  canonicalOperatorSecretName,
   parseSecretMetadataRegistry,
   parseSecretWorkloadAccessRegistry,
   personalSecretNamesForWorkload,
-  type SecretWorkloadAccessPlanEntry,
 } from '@empire-builder-kit/nx/secrets';
 import secretMetadataDocument from '../secrets/metadata.json';
 import secretWorkloadAccessDocument from '../secrets/workload-access.json';
-import { createStandardSliceWorkloadRoleTopology } from './workload-roles/candidate.js';
-import { standardSliceBoundOperatorSecretDeclarations } from './workload-roles/effective-intent.js';
+import { createStandardSliceRuntimeTopology } from './native-runtime-authority/topology.js';
+import { standardSliceBoundOperatorSecretDeclarations } from './native-runtime-authority/effective-intent.js';
 
 const metadata = parseSecretMetadataRegistry(secretMetadataDocument);
 const access = parseSecretWorkloadAccessRegistry(
@@ -806,84 +837,66 @@ function expectedBindingKeys(stage: string) {
   );
 }
 
-function createProtectedLinks(
-  protectedAccess: readonly SecretWorkloadAccessPlanEntry[],
-  stage: string,
-) {
+function createProtectedLinks(stage: string) {
   const expected = expectedBindingKeys(stage);
   const observed = new Set<string>();
-  const linksByName = new Map<
-    string,
-    { arn: string; resource: any }
-  >();
+  const linksByName = new Map<string, { resource: any }>();
   const linksByWorkload = new Map<
     string,
     Array<{ logicalName: string; resource: any }>
   >();
+  const declarationsByName = new Map(
+    metadata.declarations.map((declaration) => [
+      declaration.logicalName,
+      declaration,
+    ]),
+  );
 
-  for (const entry of protectedAccess) {
+  for (const entry of access.bindings) {
+    const declaration = declarationsByName.get(entry.logicalName);
+    if (!declaration?.requiredStages.includes(stage)) continue;
     if (
-      entry.workload !== entry.intent.workload ||
-      linksByWorkload.has(entry.workload) ||
-      entry.references.length !== entry.intent.links.length
+      (declaration.source !== 'operator' &&
+        declaration.source !== 'generated') ||
+      !entry.workload.startsWith(workloadPrefix)
     ) {
       throw new Error(
         'Protected secret access differs from the declared workload registry.',
       );
     }
-    const resources: Array<{ logicalName: string; resource: any }> = [];
-    for (const reference of entry.references) {
-      const bindingKey = entry.workload + '\\0' + reference.logicalName;
-      const link = entry.intent.links.find(
-        (candidate) =>
-          candidate.link.properties.logicalName === reference.logicalName,
+    const bindingKey = entry.workload + '\\0' + entry.logicalName;
+    if (!expected.has(bindingKey) || observed.has(bindingKey)) {
+      throw new Error(
+        'Protected secret access differs from the declared workload registry.',
       );
-      if (
-        !expected.has(bindingKey) ||
-        observed.has(bindingKey) ||
-        reference.provider !== 'aws-secrets-manager' ||
-        !link ||
-        link.link.resourceName !== reference.logicalName ||
-        link.link.properties.provider !== 'aws-secrets-manager' ||
-        link.link.properties.secretArn !== reference.secretArn ||
-        link.permission.Effect !== 'Allow' ||
-        link.permission.Action.length !== 1 ||
-        link.permission.Action[0] !== 'secretsmanager:GetSecretValue' ||
-        link.permission.Resource.length !== 1 ||
-        link.permission.Resource[0] !== reference.secretArn
-      ) {
-        throw new Error(
-          'Protected secret access differs from the declared workload registry.',
-        );
-      }
-      observed.add(bindingKey);
-      const existing = linksByName.get(reference.logicalName);
-      if (existing && existing.arn !== reference.secretArn) {
-        throw new Error(
-          'A declared secret resolved to conflicting protected references.',
+    }
+    observed.add(bindingKey);
+    const existing = linksByName.get(entry.logicalName);
+    const resource =
+      existing?.resource ??
+      (() => {
+        const name = canonicalOperatorSecretName(
+          { slice: '${name}', stage, workspace: '${workspace}' },
+          entry.logicalName,
         );
-      }
-      const resource =
-        existing?.resource ??
-        new sst.Linkable(reference.logicalName, {
+        const secret = aws.secretsmanager.getSecretOutput({ name });
+        return new sst.Linkable(entry.logicalName, {
           properties: {
-            logicalName: reference.logicalName,
+            logicalName: entry.logicalName,
             provider: 'aws-secrets-manager',
-            secretArn: reference.secretArn,
+            secretArn: secret.arn,
           },
           include: [
             sst.aws.permission({
               actions: ['secretsmanager:GetSecretValue'],
-              resources: [reference.secretArn],
+              resources: [secret.arn],
             }),
           ],
         });
-      linksByName.set(reference.logicalName, {
-        arn: reference.secretArn,
-        resource,
-      });
-      resources.push({ logicalName: reference.logicalName, resource });
-    }
+      })();
+    linksByName.set(entry.logicalName, { resource });
+    const resources = linksByWorkload.get(entry.workload) ?? [];
+    resources.push({ logicalName: entry.logicalName, resource });
     linksByWorkload.set(entry.workload, resources);
   }
   if (
@@ -898,13 +911,11 @@ function createProtectedLinks(
 }
 
 export function createStandardSliceSecretLinks(
-  input: {
-    protectedAccess?: readonly SecretWorkloadAccessPlanEntry[];
-  } = {},
+  input: Record<string, never> = {},
 ): StandardSliceSecretLinks {
   if ($dev) {
     if (
-      input.protectedAccess !== undefined ||
+      Object.keys(input).length !== 0 ||
       !personalStagePattern.test($app.stage)
     ) {
       throw new Error(
@@ -913,7 +924,7 @@ export function createStandardSliceSecretLinks(
     }
     standardSliceBoundOperatorSecretDeclarations(
       'development',
-      createStandardSliceWorkloadRoleTopology('development'),
+      createStandardSliceRuntimeTopology('development'),
     );
     const resources = new Map(
       metadata.declarations
@@ -968,10 +979,10 @@ export function createStandardSliceSecretLinks(
       'A personal stage may run only under the SST development adapter.',
     );
   }
-  const linksByWorkload = createProtectedLinks(
-    input.protectedAccess ?? [],
-    $app.stage,
-  );
+  if (Object.keys(input).length !== 0) {
+    throw new Error('Protected secret link input must be empty.');
+  }
+  const linksByWorkload = createProtectedLinks($app.stage);
   return {
     linksForWorkload(
       workload: string,

package/src/generators/slice/built-in-plan-secret-runtime-files.js.map

@@ -1 +1 @@
-{"version":3,"file":"built-in-plan-secret-runtime-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-secret-runtime-files.ts"],"names":[],"mappings":";;AAOA,sFAu+BC;AA9+BD,gEAAkE;AAClE,iEAAmE;AACnE,uEAAiD;AAEjD,MAAM,oBAAoB,GAAG,iDAAiD,CAAC;AAE/E,gBAAgB;AAChB,SAAgB,qCAAqC,CACnD,IAAY;IAEZ,MAAM,UAAU,GAAG,IAAI;SACpB,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;SAChE,IAAI,CAAC,EAAE,CAAC,CAAC;IACZ,OAAO;QACL,8BAA8B,EAAE,IAAA,8BAAI,EAAC;YACnC,QAAQ,EAAE;gBACR;oBACE,WAAW,EAAE,GAAG,UAAU,yBAAyB;oBACnD,QAAQ,EAAE,GAAG,IAAI,aAAa;iBAC/B;aACF;YACD,aAAa,EAAE,CAAC;SACjB,CAAC;QACF,sCAAsC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmN3C;QACG,qCAAqC,EAAE;;;;;;;;;;;;;;;;;;;gCAmBX,wCAAqB;0CACX,IAAA,gCAAiB,EACrD,aAAa,EACb,aAAa,CACd;gCAC2B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoOtC,IAAI;;;;;;;;;;cAUJ,IAAI;eACH,IAAI;;;;;cAKL,IAAI;;;;;;;gBAOF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDnB;QACG,oBAAoB,EAAE;;;;;;;;;;;;;;;;gCAgBM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwInD;QACG,2BAA2B,EAAE;;;;;;;;;;;;;;;gCAeD,oBAAoB;0BAC1B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Q7B;KACE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"built-in-plan-secret-runtime-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-secret-runtime-files.ts"],"names":[],"mappings":";;AAOA,sFAm/BC;AA1/BD,gEAAkE;AAClE,iEAAmE;AACnE,uEAAiD;AAEjD,MAAM,oBAAoB,GAAG,iDAAiD,CAAC;AAE/E,gBAAgB;AAChB,SAAgB,qCAAqC,CACnD,IAAY,EACZ,SAAS,GAAG,WAAW;IAEvB,OAAO;QACL,8BAA8B,EAAE,IAAA,8BAAI,EAAC;YACnC,QAAQ,EAAE;gBACR;oBACE,WAAW,EAAE,kCAAkC;oBAC/C,QAAQ,EAAE,GAAG,IAAI,aAAa;iBAC/B;aACF;YACD,aAAa,EAAE,CAAC;SACjB,CAAC;QACF,sCAAsC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyO3C;QACG,qCAAqC,EAAE;;;;;;;;;;;;;;;;;;;;gCAoBX,wCAAqB;0CACX,IAAA,gCAAiB,EACrD,aAAa,EACb,aAAa,CACd;gCAC2B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoOtC,IAAI;;;;;;;;;;;;;;;;;;;;;;cAsBJ,IAAI;eACH,IAAI;;;;;cAKL,IAAI;;;;;;;gBAOF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDnB;QACG,oBAAoB,EAAE;;;;;;;;;;;;;;;;gCAgBM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwInD;QACG,2BAA2B,EAAE;;;;;;;;;;;;;;;gCAeD,oBAAoB;0BAC1B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAiHR,IAAI,yBAAyB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqI3D;KACE,CAAC;AACJ,CAAC"}

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

@@ -45,41 +45,25 @@ those validators enforce cross-field outcome rules and trusted time/workflow
 context that JSON Schema cannot establish alone.
 
 \`smoke-deployed-check\` only proves that Playwright can discover the suite. It
-does not contact or prove a deployment. Governed staging smoke runs through the
-protected \`Deployed smoke\` GitHub workflow and emits a candidate-, commit-,
-stage-, and cleanup-attributed result. Configure each protected environment's
-\`EBK_SMOKE_TARGETS\` variable as a JSON object from exact Slice name to its
-credential-free HTTPS \`webUrl\` and \`apiUrl\`, Cognito \`userPoolId\`, and
-\`clientId\`. Set \`EBK_SMOKE_AUTHORITY_VERSION\` to
-\`cognito-admin-cloudwatch-observe-v1\` only after the protected role is reviewed for
-\`DescribeUserPoolClient\`, \`AdminCreateUser\`, \`AdminSetUserPassword\`,
-\`AdminAddUserToGroup\`, and \`AdminDeleteUser\` on those pools and
-\`FilterLogEvents\` on each exact
-\`/ebk/<stage>/<slice>/event-consumer\` log group. The workflow creates one
-run-scoped synthetic customer in the Slice's narrow \`<slice>-test-writer\`
-group and one distinct synthetic reviewer in \`<slice>-admin\`. It never grants
-the customer administrator authority, strips AWS credentials from the browser
-child,
-observes the published event only from the credential-bearing parent, removes
-both principals and all raw browser and log state, and retains only allowlisted
-sanitized evidence.
+does not contact or prove a deployment. The root governed lifecycle runs each
+Slice's \`smoke-deployed\` target immediately after its successful native SST
+deployment and migration. Local and GitHub execution use the same stage
+deployment role and exact deployed outputs; no separate smoke role, workflow,
+target registry, or staging-evidence reconciliation graph exists.
 
-The environment-only \`AWS_SMOKE_ROLE_ARN\` is a setup/observation role, never
-a deployment role. Its GitHub OIDC trust is limited to this repository and the
-matching protected environment. Its policy names only the reviewed user-pool
-ARNs for the five Cognito actions above and the exact generated event-consumer
-log-group ARNs for \`logs:FilterLogEvents\`. It has no CloudFormation, SST,
-application mutation, wildcard Logs query, \`GetLogEvents\`, \`StartQuery\`, or
-\`logs:Unmask\` authority. GitHub bootstrap verifies that the secret name exists
-only in each protected environment; it never creates the secret or role and
-cannot attest to the hidden role policy. Review that policy before setting the
-authority-version acknowledgement.
+Development and staging smoke wait up to sixteen minutes for the exact durable
+event on the fifteen-minute nonproduction outbox schedule. Production waits up
+to ninety seconds for the same proof on its one-minute schedule. These bounds
+include CloudWatch Logs request latency and the runner aborts an in-flight
+request when no bounded observation time remains.
 
-A successful \`develop\` deployment automatically starts staging smoke for
-every registered Slice target at that exact commit. The credential-free
-\`staging-evidence\` promotion check downloads only artifacts from the managed
-smoke workflow and rejects missing, mismatched, flaky, failed, incomplete, or
-cleanup-deficient evidence.
+The runner creates one run-scoped synthetic customer in the Slice's narrow
+\`<slice>-test-writer\` group and one distinct synthetic reviewer in
+\`<slice>-admin\`. It never grants the customer administrator authority, strips
+AWS credentials from the browser child, observes the published event only from
+the credential-bearing parent, removes both principals and all raw browser and
+log state, and retains only allowlisted sanitized evidence. A failed smoke ends
+the lifecycle immediately and no successful deployment receipt is written.
 
 One optional evidence-level retry replays the complete, identical browser or
 live-integration proof. Consequently \`counts.retried\` is always zero or one.
@@ -1333,6 +1317,7 @@ import {
   writeFileSync,
 } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
+import { performance } from 'node:perf_hooks';
 import { createRequire } from 'node:module';
 import { TextDecoder } from 'node:util';
 import {
@@ -1340,6 +1325,7 @@ import {
   playwrightSkippedTestIds,
   reconcileRunnerQuarantine,
 } from '../testing/quarantine-runtime.mjs';
+import { assertWorkspaceStageOwnershipForWorkspace } from '@empire-builder-kit/nx/workspace-deployment';
 
 const require = createRequire(import.meta.url);
 const {
@@ -1397,6 +1383,14 @@ const userPoolId = process.env.EBK_SMOKE_USER_POOL_ID ?? '';
 const clientId = process.env.EBK_SMOKE_CLIENT_ID ?? '';
 const smokeAuthority =
   process.env.EBK_SMOKE_AUTHORITY_VERSION ?? '';
+const lifecycleAdapter = process.env.EBK_NX_STAGE_LIFECYCLE ?? '';
+const deployedEnvironmentClass =
+  lifecycleAdapter === 'local'
+    ? 'local-federated'
+    : lifecycleAdapter === 'github'
+      ? 'protected-github'
+      : undefined;
+const unexpectedArguments = process.argv.slice(2);
 const requestedRunId = process.env.EBK_TEST_RUN_ID;
 const runId = requestedRunId ?? randomUUID().replaceAll('-', '');
 const seed = process.env.EBK_TEST_SEED ?? runId;
@@ -1483,7 +1477,7 @@ function failPreflight(
     attempts: [],
     cleanup,
     environment: {
-      class: 'protected-github',
+      class: deployedEnvironmentClass ?? 'unresolved-adapter',
       deployed: true,
       stage: stage || 'unresolved',
     },
@@ -1690,6 +1684,18 @@ function inspectPlaywrightReportPolicy(report) {
   };
 }
 
+function requiresScheduledDeliveryObservation(stage) {
+  return ['development', 'staging', 'production'].includes(stage);
+}
+
+function scheduledDeliveryDeadlineFinding() {
+  return {
+    classification: 'assertion-failed',
+    summary:
+      'The exact published event and correlation were not observed in the managed event-consumer log group within the bounded window.',
+  };
+}
+
 async function observePublishedEvent(logs, observationPath, attemptStartedAt) {
   let intent;
   try {
@@ -1711,7 +1717,11 @@ async function observePublishedEvent(logs, observationPath, attemptStartedAt) {
   }
   const logGroupName = '/ebk/' + stage + '/${name}/event-consumer';
   const startTime = Math.max(0, Date.parse(attemptStartedAt) - 5_000);
-  for (let poll = 0; poll < 8; poll += 1) {
+  const timeoutMilliseconds = stage === 'production' ? 90_000 : 960_000;
+  const deadline = performance.now() + timeoutMilliseconds;
+  while (true) {
+    const remainingRequestMilliseconds = deadline - performance.now();
+    if (remainingRequestMilliseconds <= 0) break;
     let response;
     try {
       response = await logs.send(
@@ -1721,14 +1731,28 @@ async function observePublishedEvent(logs, observationPath, attemptStartedAt) {
           logGroupName,
           startTime,
         }),
+        {
+          abortSignal: AbortSignal.timeout(
+            Math.max(1, Math.ceil(remainingRequestMilliseconds)),
+          ),
+        },
       );
     } catch (error) {
+      if (
+        performance.now() >= deadline ||
+        ['AbortError', 'TimeoutError'].includes(error?.name)
+      ) {
+        return scheduledDeliveryDeadlineFinding();
+      }
       return permissionFailure(
         error,
         'event-consumer observation',
         'CloudWatch Logs',
       );
     }
+    if (performance.now() > deadline) {
+      return scheduledDeliveryDeadlineFinding();
+    }
     const observed = (response.events ?? []).some(({ message }) => {
       const record = structuredLogRecord(message);
       return (
@@ -1744,15 +1768,13 @@ async function observePublishedEvent(logs, observationPath, attemptStartedAt) {
       );
     });
     if (observed) return undefined;
-    if (poll < 7) {
-      await new Promise((resolveDelay) => setTimeout(resolveDelay, 3_000));
-    }
+    const remainingDelayMilliseconds = deadline - performance.now();
+    if (remainingDelayMilliseconds <= 0) break;
+    await new Promise((resolveDelay) =>
+      setTimeout(resolveDelay, Math.min(3_000, remainingDelayMilliseconds)),
+    );
   }
-  return {
-    classification: 'assertion-failed',
-    summary:
-      'The exact published event and correlation were not observed in the managed event-consumer log group within the bounded window.',
-  };
+  return scheduledDeliveryDeadlineFinding();
 }
 
 const url = credentialFreeHttpsUrl(smokeUrl);
@@ -1763,7 +1785,7 @@ const validIdentity =
   /^[A-Za-z0-9_-]{1,128}_[A-Za-z0-9]{1,128}$/.test(userPoolId) &&
   /^[a-z0-9]{1,128}$/.test(clientId);
 if (
-  !['staging', 'production'].includes(stage) ||
+  !['development', 'staging', 'production'].includes(stage) ||
   !url ||
   !apiUrl ||
   normalizedProductPath !== expectedProductPath ||
@@ -1772,14 +1794,35 @@ if (
   !validSourceCommit ||
   !validRunId ||
   !validSeed ||
+  !deployedEnvironmentClass ||
+  unexpectedArguments.length > 0 ||
   smokeAuthority !== 'cognito-admin-cloudwatch-observe-v1' ||
   !process.env.AWS_REGION
 ) {
   failPreflight(
     'prerequisite-missing',
-    'Protected smoke requires staging or production, one exact source commit, reviewed credential-free HTTPS web and API targets, exact Cognito identity, bounded run/seed identity, AWS region, and cognito-admin-cloudwatch-observe-v1 authority acknowledgement.',
+    'Deployed smoke requires development, staging, or production, one exact source commit, native credential-free HTTPS web and API outputs, exact Cognito identity, bounded run/seed identity, AWS region, and cognito-admin-cloudwatch-observe-v1 authority acknowledgement.',
   );
 }
+if (process.exitCode === undefined) {
+  try {
+    const ownership = await assertWorkspaceStageOwnershipForWorkspace(workspaceRoot, stage, {
+      ...(process.env.AWS_PROFILE ? { profile: process.env.AWS_PROFILE } : {}),
+      ...(process.env.AWS_CONFIG_FILE ? { configFilepath: process.env.AWS_CONFIG_FILE } : {}),
+      ...(process.env.AWS_SHARED_CREDENTIALS_FILE
+        ? { credentialsFilepath: process.env.AWS_SHARED_CREDENTIALS_FILE }
+        : {}),
+    });
+    if (process.env.AWS_REGION !== ownership.region) {
+      throw new Error('Deployed smoke Region differs from its exact workspace owner tuple.');
+    }
+  } catch {
+    failPreflight(
+      'authorization-denied',
+      'Deployed smoke requires this workspace to own the exact account, Region, and canonical stage tuple.',
+    );
+  }
+}
 if (process.exitCode === undefined) {
   let quarantine;
   try {
@@ -2020,6 +2063,7 @@ if (process.exitCode === undefined) {
               EBK_SMOKE_API_URL: apiUrl.href,
               EBK_SMOKE_DATA_CLEANUP_PATH: cleanupPath,
               EBK_SMOKE_EMAIL: principalEmail,
+              EBK_FRONTEND_SECURITY_PROFILE: 'deployed-https',
               EBK_SMOKE_PASSWORD: principalPassword,
               EBK_SMOKE_REVIEWER_EMAIL: reviewerEmail,
               EBK_SMOKE_REVIEWER_PASSWORD: reviewerPassword,
@@ -2077,7 +2121,10 @@ if (process.exitCode === undefined) {
         } else {
           reportInvalid = true;
         }
-        if (execution?.status === 0) {
+        if (
+          execution?.status === 0 &&
+          requiresScheduledDeliveryObservation(stage)
+        ) {
           observationFinding = await observePublishedEvent(
             logs,
             observationPath,
@@ -2362,7 +2409,7 @@ if (process.exitCode === undefined) {
       attempts,
       cleanup,
       environment: {
-        class: 'protected-github',
+        class: deployedEnvironmentClass,
         deployed: true,
         stage,
       },

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

@@ -1 +1 @@
-{"version":3,"file":"built-in-plan-testing-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-testing-files.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"built-in-plan-testing-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-testing-files.ts"],"names":[],"mappings":"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"}

package/src/generators/slice/built-in-plan-thin-release-files.d.ts

@@ -0,0 +1,11 @@
+import type { DeploymentProfile } from '../../repository-policy/index.js';
+/**
+ * Prerelease release-manifest and rollout scripts used Pulumi previews as
+ * deployment authorization. The thin SST lifecycle keeps immutable candidate
+ * capture, but deployment evidence is the post-operation receipt emitted by
+ * the shared lifecycle adapter. Those old scripts are deliberately not
+ * generated.
+ */
+export declare const RETIRED_PREVIEW_RELEASE_PATHS: readonly ["scripts/release-lifecycle.mjs", "scripts/release-manifest.mjs", "scripts/release-rollout-proof.mjs", "scripts/release-rollout.mjs"];
+/** @internal */
+export declare function renderProductThinReleaseFiles(name: string, configurationSeed: string, deploymentProfile: DeploymentProfile): Readonly<Record<string, string>>;