@tokenoftrust/storefront-runner 1.4.2-rc.0 → 2.0.1

package/apps/storefront/src/lib/apps/v84CloneLifecycleEvidence.ts

@@ -0,0 +1,177 @@
+/**
+ * Exact-clone, offline lifecycle validation composed from public product seams.
+ *
+ * It consumes the already-reviewed native-install evidence, then exercises only
+ * public-value environment, consent, semantic-event, lifecycle-bridge, and cache
+ * contracts. It has no renderer, integration loader, destination runtime, network,
+ * persistence, GTM, eval, or publish authority.
+ */
+import {
+  APPROVED_MARKETING_ACTION_NAMES,
+  planCacheIdentity,
+  sha256Hex,
+  snapshotManagedAnalyticsDeclarativeInput,
+  stableIntegrationStringify,
+} from "@tot/public-runtime";
+import { buildV84CloneCacheEvidence } from "./v84CloneLifecycleCacheEvidence.js";
+import {
+  validateV84DisabledInstallMaterialization,
+  type V84LifecycleMaterializationDependencies,
+} from "./v84CloneLifecycleMaterialization.js";
+import { buildV84CloneLifecycleSemantics } from "./v84CloneLifecycleSemantics.js";
+import {
+  V84_NATIVE_CLONE_TENANT,
+  V84_NATIVE_SOURCE_TENANT,
+  V84_WS1_API_CONTRACT,
+  V84_WS1_FINAL,
+  V84_WS2_EVIDENCE_SHA256,
+  V84_WS2_FINAL,
+  type V84NativeInstallEvidence,
+} from "./v84CloneNativeInstallEvidence.js";
+import {
+  sameV84ReplayValue,
+  type V84CleanCloneReplayContext,
+} from "./v84CleanCloneReplayContext.js";
+
+/** SHA-256 of the full canonical native-install evidence accepted by this unit. */
+export const V84_NATIVE_INSTALL_EVIDENCE_SHA256 = "d479a8b07cdde0808c75abea7410c7f1c685ed8d79f5e62f21a6261d1087eda8" as const;
+
+function assertNativeEvidence(evidence: V84NativeInstallEvidence): void {
+  if (
+    evidence.scope.sourceTenant !== V84_NATIVE_SOURCE_TENANT ||
+    evidence.scope.sourceMode !== "read-only" ||
+    evidence.scope.cloneTenant !== V84_NATIVE_CLONE_TENANT ||
+    evidence.scope.destinationMode !== "offline-in-memory-fake-only" ||
+    evidence.contractPins.ws1Final !== V84_WS1_FINAL ||
+    evidence.contractPins.ws1ApiContract !== V84_WS1_API_CONTRACT ||
+    evidence.contractPins.ws2Final !== V84_WS2_FINAL ||
+    evidence.contractPins.ws2EvidenceSha256 !== V84_WS2_EVIDENCE_SHA256 ||
+    evidence.installations.length !== 2 ||
+    evidence.installations.some((item) =>
+      item.desired.installStatus !== "disabled" ||
+      item.desired.revisionStatus !== "draft" ||
+      item.effective.activeRevisionId !== null ||
+      item.effective.materialized !== false
+    ) ||
+    stableIntegrationStringify(evidence.semanticActions) !==
+      stableIntegrationStringify(APPROVED_MARKETING_ACTION_NAMES) ||
+    evidence.operationCounts.reviseIntegrationInstall !== 0 ||
+    evidence.operationCounts.setIntegrationInstallStatus !== 0 ||
+    evidence.operationCounts.publish !== 0 ||
+    evidence.safety.sourceMutationCount !== 0 ||
+    evidence.safety.liveDestinationCount !== 0 ||
+    evidence.safety.externalNetworkRequestCount !== 0 ||
+    evidence.safety.importedCodeExecuted ||
+    evidence.safety.runtimeLoaded ||
+    evidence.safety.lifecycle !== "reviewed-disabled-draft-only"
+  ) {
+    throw new Error("The supplied native-install evidence is outside the exact disabled v84 proof.");
+  }
+}
+
+/** Build deterministic, sanitized evidence. Every delivery remains an in-memory callback. */
+export async function buildV84CloneLifecycleEvidence(
+  unsafeNativeEvidence: unknown,
+  materializationDependencies?: V84LifecycleMaterializationDependencies,
+  replayContext?: V84CleanCloneReplayContext,
+) {
+  const snapshot = snapshotManagedAnalyticsDeclarativeInput<V84NativeInstallEvidence>(unsafeNativeEvidence);
+  if (!snapshot.ok) throw new Error("The native-install evidence could not be snapshotted safely.");
+  const nativeEvidence = snapshot.value;
+  assertNativeEvidence(nativeEvidence);
+  if (replayContext && !sameV84ReplayValue(
+    replayContext.read<V84NativeInstallEvidence>("stage/native/handoff"),
+    nativeEvidence,
+  )) {
+    throw new Error("The lifecycle proof did not receive the shared native handoff.");
+  }
+  const nativeEvidenceSha256 = await sha256Hex(stableIntegrationStringify(nativeEvidence));
+  if (nativeEvidenceSha256 !== V84_NATIVE_INSTALL_EVIDENCE_SHA256) {
+    throw new Error("The supplied native-install evidence does not match the pinned exact proof.");
+  }
+
+  const semantics = buildV84CloneLifecycleSemantics();
+  const materialization = await validateV84DisabledInstallMaterialization(
+    nativeEvidence.installations,
+    semantics.candidateEnvironment,
+    semantics.stagedEnvironment,
+    materializationDependencies,
+    replayContext,
+  );
+  const candidatePlan = materialization.candidatePlanAfter;
+  const stagedPlan = materialization.stagedPlanAfter;
+  const cache = await buildV84CloneCacheEvidence(materialization, replayContext);
+
+  const evidence = {
+    schemaVersion: 1 as const,
+    scope: {
+      sourceTenant: V84_NATIVE_SOURCE_TENANT,
+      sourceMode: "read-only" as const,
+      cloneTenant: V84_NATIVE_CLONE_TENANT,
+      destinationMode: "offline-in-memory-callback-only" as const,
+      environments: ["candidate", "staged"] as const,
+    },
+    contractPins: {
+      ws1Final: V84_WS1_FINAL,
+      ws1ApiContract: V84_WS1_API_CONTRACT,
+      ws2Final: V84_WS2_FINAL,
+      ws2EvidenceSha256: V84_WS2_EVIDENCE_SHA256,
+      nativeInstallEvidenceSha256: nativeEvidenceSha256,
+    },
+    disabledDrafts: {
+      count: nativeEvidence.installations.length,
+      statuses: nativeEvidence.installations.map(({ desired }) => ({
+        install: desired.installStatus,
+        revision: desired.revisionStatus,
+      })),
+      activeRevisionCount: nativeEvidence.installations.filter(({ effective }) => effective.activeRevisionId !== null).length,
+      materializedCount: candidatePlan.integrations.length + stagedPlan.integrations.length,
+      materializedDeclarationCount: materialization.materializedDeclarationCount,
+      materializedAssetCount: materialization.materializedAssetCount,
+      readModelUnmaterializedCount: materialization.readModelUnmaterializedCount,
+      lifecycleRefusalCount: materialization.lifecycleRefusalCount,
+      lifecycleMutationCount: materialization.lifecycleMutationCount,
+    },
+    environment: {
+      candidate: semantics.candidateEnvironment,
+      staged: semantics.stagedEnvironment,
+      candidatePlanIdentity: planCacheIdentity(candidatePlan),
+      stagedPlanIdentity: planCacheIdentity(stagedPlan),
+      distinctPlanIdentities: planCacheIdentity(candidatePlan) !== planCacheIdentity(stagedPlan),
+      liveEnvironmentCount: 0,
+    },
+    consent: semantics.consent,
+    lifecycle: semantics.lifecycle,
+    routes: semantics.routes,
+    actions: semantics.actions,
+    warmCache: cache.warmCache,
+    operationCounts: {
+      sourceReads: 0,
+      sourceWrites: 0,
+      managedMaterializationReads: materialization.materializationReadCount,
+      managedReadModelAssemblies: materialization.readModelAssemblyCount,
+      managedLifecycleLoads: materialization.lifecycleLoadCount,
+      cloneCacheReads: cache.cloneCacheReads,
+      cloneCacheWrites: cache.cloneCacheWrites,
+      inMemoryEventDeliveries: semantics.inMemoryEventDeliveries,
+      externalNetworkRequests: 0,
+      lifecycleMutations: 0,
+      publishes: 0,
+    },
+    safety: {
+      importedCodeExecuted: false,
+      rendererCalled: false,
+      integrationLifecycleRuntimeInitialized: false,
+      nativeDestinationRuntimeInvoked: false,
+      gtmLoaded: false,
+      markupEvaluated: false,
+      externalNetworkUsed: false,
+      liveSecretUsed: false,
+      productionUsed: false,
+      sourceMutated: false,
+      diagnosticsCarryDestinationValues: false,
+    },
+  };
+  replayContext?.write("stage/lifecycle/handoff", evidence);
+  return evidence;
+}

package/apps/storefront/src/lib/apps/v84CloneLifecycleMaterialization.ts

@@ -0,0 +1,251 @@
+/**
+ * Fake/local adapter that proves disabled managed-install rows remain absent from
+ * the real declaration, admin read-model, and lifecycle seams.
+ */
+import {
+  resolveEffectivePlan,
+  stableIntegrationStringify,
+  type BrowserEnvironment,
+  type EffectivePlan,
+  type IntegrationDeclarationInput,
+} from "@tot/public-runtime";
+import type { Queryable } from "../d1/catalog.js";
+import { loadActiveManagedInstallDeclarations } from "../integration/managedInstallDeclarations.js";
+import { assembleIntegrationReadModel } from "./integrationReadModel.js";
+import { handleLifecycleRequest } from "./integrationLifecycleController.js";
+import {
+  V84_NATIVE_CLONE_TENANT,
+  type V84NativeInstallEvidence,
+} from "./v84CloneNativeInstallEvidence.js";
+import type { V84CleanCloneReplayContext } from "./v84CleanCloneReplayContext.js";
+
+type NativeInstall = V84NativeInstallEvidence["installations"][number];
+
+interface LocalManagedRow {
+  readonly install_id: string;
+  readonly tenant_id: string;
+  readonly managed_kind: "managed-analytics-v1";
+  readonly status: "suspended";
+  readonly app_id: string;
+  readonly app_version: string;
+  readonly manifest: "{}";
+  readonly revision_status: "draft";
+}
+
+export interface V84LifecycleMaterializationDependencies {
+  readonly loadDeclarations: typeof loadActiveManagedInstallDeclarations;
+}
+
+const dependencies: V84LifecycleMaterializationDependencies = {
+  loadDeclarations: loadActiveManagedInstallDeclarations,
+};
+
+function resolvePlan(
+  environment: BrowserEnvironment,
+  declarations: readonly IntegrationDeclarationInput[],
+): EffectivePlan {
+  const result = resolveEffectivePlan({
+    tenantPublicId: V84_NATIVE_CLONE_TENANT,
+    environment,
+    declarations,
+  });
+  if (!result.ok) throw new Error("The local managed-install plan failed safely.");
+  return result.value;
+}
+
+function localRows(installations: readonly NativeInstall[]): LocalManagedRow[] {
+  return installations.map((install, index) => ({
+    install_id: `v84-local-managed-${index + 1}`,
+    tenant_id: V84_NATIVE_CLONE_TENANT,
+    managed_kind: "managed-analytics-v1",
+    status: "suspended",
+    app_id: install.adapterId,
+    app_version: install.adapterVersion,
+    manifest: "{}",
+    revision_status: install.desired.revisionStatus,
+  }));
+}
+
+/** Minimal local Queryable that executes the materializer's active-row predicate. */
+function localManagedInstallDb(rows: readonly LocalManagedRow[]): Queryable {
+  const unexpected = async (): Promise<never> => {
+    throw new Error("The disabled managed-install proof reached an unexpected persistence operation.");
+  };
+  return {
+    all: async <T>(sql: string, ...params: unknown[]) => {
+      const normalized = sql.replace(/\s+/g, " ").trim();
+      if (
+        !normalized.includes("FROM app_installs") ||
+        !normalized.includes("tenant_id = ?") ||
+        !normalized.includes("managed_kind = ?") ||
+        !normalized.includes("status = 'active'") ||
+        params.length !== 2
+      ) {
+        throw new Error("The managed-install materializer widened its active-row boundary.");
+      }
+      const [tenantId, managedKind] = params;
+      return rows
+        .filter((row) =>
+          row.tenant_id === tenantId &&
+          row.managed_kind === managedKind &&
+          row.status === ("active" as string)
+        )
+        .map(({ install_id, app_id, app_version, manifest }) => ({
+          install_id,
+          app_id,
+          app_version,
+          manifest,
+        })) as T[];
+    },
+    first: unexpected,
+    run: unexpected,
+    exec: unexpected,
+  };
+}
+
+export interface V84DisabledInstallMaterializationResult {
+  readonly candidatePlanBefore: EffectivePlan;
+  readonly candidatePlanAfter: EffectivePlan;
+  readonly stagedPlanAfter: EffectivePlan;
+  readonly managedInstallStateChanged: true;
+  readonly readModelUnmaterializedCount: 2;
+  readonly lifecycleRefusalCount: 2;
+  readonly materializedDeclarationCount: 0;
+  readonly materializedAssetCount: 0;
+  readonly materializationReadCount: 2;
+  readonly readModelAssemblyCount: 1;
+  readonly lifecycleLoadCount: 2;
+  readonly lifecycleMutationCount: 0;
+}
+
+/**
+ * Exercise the actual managed-install declaration loader, admin read model, and
+ * lifecycle controller over local rows derived from the canonical install output.
+ */
+export async function validateV84DisabledInstallMaterialization(
+  installations: readonly NativeInstall[],
+  candidateEnvironment: BrowserEnvironment,
+  stagedEnvironment: BrowserEnvironment,
+  deps: V84LifecycleMaterializationDependencies = dependencies,
+  replayContext?: V84CleanCloneReplayContext,
+): Promise<V84DisabledInstallMaterializationResult> {
+  const localBeforeRows: readonly LocalManagedRow[] = [];
+  const localAfterRows = localRows(installations);
+  if (replayContext) {
+    replayContext.write("stage/lifecycle/materialization/before", localBeforeRows);
+    replayContext.write("stage/lifecycle/materialization/after", localAfterRows);
+  }
+  const beforeRows = replayContext
+    ? replayContext.read<readonly LocalManagedRow[]>("stage/lifecycle/materialization/before") ?? []
+    : localBeforeRows;
+  const afterRows = replayContext
+    ? replayContext.read<readonly LocalManagedRow[]>("stage/lifecycle/materialization/after") ?? []
+    : localAfterRows;
+  if (
+    afterRows.length !== 2 ||
+    afterRows.some((row) => row.status !== "suspended" || row.revision_status !== "draft") ||
+    stableIntegrationStringify(beforeRows) === stableIntegrationStringify(afterRows)
+  ) {
+    throw new Error("The local disabled managed-install state was not exact.");
+  }
+
+  let materializationReadCount = 0;
+  const loadDeclarations = async (db: Queryable) => {
+    materializationReadCount += 1;
+    return deps.loadDeclarations(db, V84_NATIVE_CLONE_TENANT);
+  };
+  const beforeDeclarations = await loadDeclarations(
+    localManagedInstallDb(beforeRows),
+  );
+  const afterDeclarations = await loadDeclarations(
+    localManagedInstallDb(afterRows),
+  );
+  if (beforeDeclarations.length !== 0 || afterDeclarations.length !== 0) {
+    throw new Error("A disabled draft was treated as a materializable managed install.");
+  }
+
+  const candidatePlanBefore = resolvePlan(candidateEnvironment, beforeDeclarations);
+  const candidatePlanAfter = resolvePlan(candidateEnvironment, afterDeclarations);
+  const stagedPlanAfter = resolvePlan(stagedEnvironment, afterDeclarations);
+  let readModelAssemblyCount = 0;
+  readModelAssemblyCount += 1;
+  const readModel = assembleIntegrationReadModel({
+    tenantPublicId: V84_NATIVE_CLONE_TENANT,
+    stage: "candidate",
+    items: afterRows.map((row) => ({
+      install: {
+        installId: row.install_id,
+        appId: row.app_id,
+        appVersion: row.app_version,
+        tenantId: row.tenant_id,
+        status: row.status,
+      },
+      purpose: "Reviewed managed analytics destination.",
+      desiredConfig: { destinationConfigured: true },
+      declaredTier: "platform-adapter",
+      effectivePlan: null,
+      effectiveCsp: null,
+      consentSnapshot: null,
+      candidate: null,
+      knownGood: null,
+    })),
+  });
+  if (
+    !readModel.ok ||
+    readModel.value.items.length !== 2 ||
+    readModel.value.items.some((item) => item.effective !== null || !item.drift.unmaterialized)
+  ) {
+    throw new Error("The disabled managed-install read model materialized an effective state.");
+  }
+
+  let lifecycleMutationCount = 0;
+  let lifecycleRefusalCount = 0;
+  let lifecycleLoadCount = 0;
+  for (const row of afterRows) {
+    const response = await handleLifecycleRequest({
+      load: async () => { lifecycleLoadCount += 1; return null; },
+      save: async () => { lifecycleMutationCount += 1; },
+      resolveCandidateEvidence: async () => {
+        throw new Error("An unmaterialized disabled install must not resolve candidate evidence.");
+      },
+      resolveGate: async () => {
+        throw new Error("An unmaterialized disabled install must not resolve a publish gate.");
+      },
+    }, {
+      action: "preview",
+      installId: row.install_id,
+      actor: "v84-local-reviewer",
+    });
+    if (response.status !== 409 || JSON.stringify(response.body) !== JSON.stringify({
+      error: "integration is not materialized",
+      code: "not_materialized",
+    })) {
+      throw new Error("The disabled managed-install lifecycle did not fail closed.");
+    }
+    lifecycleRefusalCount += 1;
+  }
+  if (
+    materializationReadCount !== 2 ||
+    readModelAssemblyCount !== 1 ||
+    lifecycleLoadCount !== 2 ||
+    lifecycleMutationCount !== 0 ||
+    lifecycleRefusalCount !== 2
+  ) {
+    throw new Error("The disabled managed-install lifecycle changed local state.");
+  }
+
+  return {
+    candidatePlanBefore,
+    candidatePlanAfter,
+    stagedPlanAfter,
+    managedInstallStateChanged: true,
+    readModelUnmaterializedCount: 2,
+    lifecycleRefusalCount: 2,
+    materializedDeclarationCount: afterDeclarations.length as 0,
+    materializedAssetCount: afterDeclarations.flatMap((item) => item.materializedAssets).length as 0,
+    materializationReadCount: materializationReadCount as 2,
+    readModelAssemblyCount: readModelAssemblyCount as 1,
+    lifecycleLoadCount: lifecycleLoadCount as 2,
+    lifecycleMutationCount,
+  };
+}

package/apps/storefront/src/lib/apps/v84CloneLifecycleSemantics.ts

@@ -0,0 +1,241 @@
+/** Offline semantic-lifecycle evidence built only from public product contracts. */
+import {
+  APPROVED_MARKETING_ACTION_NAMES,
+  CommerceEventBroker,
+  CONSENT_CONFIG_SCHEMA_VERSION,
+  ManagedAnalyticsEventBrokerBridge,
+  buildTenantConsentBroker,
+  resolveBrowserEnvironment,
+  stableIntegrationStringify,
+  validateBrowserEnvironment,
+  validateConsentConfig,
+  validateTenantActionRegistry,
+  type CommerceEvent,
+  type ManagedAnalyticsBridgeResult,
+} from "@tot/public-runtime";
+import { V84_NATIVE_CLONE_TENANT } from "./v84CloneNativeInstallEvidence.js";
+
+const AT = "2026-08-29T00:00:00.000Z";
+const CORRELATION = { id: "corr-v84-lifecycle", expiresAt: "2026-08-29T02:00:00.000Z" };
+const DIAGNOSTIC_HOST = "gtm-migration-v84.invalid";
+
+function emitted(result: ManagedAnalyticsBridgeResult): boolean {
+  return result.ok && result.emitted;
+}
+
+function skipped(result: ManagedAnalyticsBridgeResult, reason: string): boolean {
+  return result.ok && !result.emitted && result.skipReason === reason;
+}
+
+/** Exercise candidate/staged environments, consent, routes, actions, and disposal. */
+export function buildV84CloneLifecycleSemantics() {
+  const candidateEnvironment = resolveBrowserEnvironment({
+    siteSurface: "marketing",
+    canonicalHost: DIAGNOSTIC_HOST,
+    revision: "v84-lifecycle-candidate",
+    dev: false,
+    localHost: false,
+    candidate: true,
+    previewHost: false,
+    customizationEnv: "test",
+  });
+  const stagedEnvironment = resolveBrowserEnvironment({
+    siteSurface: "marketing",
+    canonicalHost: DIAGNOSTIC_HOST,
+    revision: "v84-lifecycle-staged",
+    dev: false,
+    localHost: false,
+    candidate: false,
+    previewHost: true,
+    customizationEnv: "test",
+  });
+  if (!validateBrowserEnvironment(candidateEnvironment).ok || !validateBrowserEnvironment(stagedEnvironment).ok) {
+    throw new Error("The product environment resolver emitted an invalid public environment.");
+  }
+
+  const consentResult = validateConsentConfig({
+    schemaVersion: CONSENT_CONFIG_SCHEMA_VERSION,
+    purposes: [{ purpose: "analytics", legalBasis: "consent", defaultState: "denied" }],
+    cmp: { mode: "none" },
+  });
+  if (!consentResult.ok) throw new Error("The fixed analytics consent policy failed validation.");
+  const consent = buildTenantConsentBroker(consentResult.value);
+  const defaultSnapshot = consent.getSnapshot();
+  const registryResult = validateTenantActionRegistry({
+    schemaVersion: 1,
+    actions: APPROVED_MARKETING_ACTION_NAMES.map((name) => ({ name })),
+  });
+  if (!registryResult.ok) throw new Error("The canonical action registry failed validation.");
+
+  const candidateEvents: CommerceEvent[] = [];
+  const candidateBroker = new CommerceEventBroker({
+    trusted: {
+      tenant: V84_NATIVE_CLONE_TENANT,
+      environment: candidateEnvironment.environment,
+      siteSurface: candidateEnvironment.siteSurface,
+    },
+    source: "urn:tot:storefront:v84-lifecycle-candidate",
+    consentSnapshot: () => consent.getSnapshot(),
+    tenantActionRegistry: registryResult.value,
+    now: () => AT,
+  });
+  candidateBroker.subscribe({
+    id: "offline-v84-candidate-receiver",
+    consentPurpose: "analytics",
+    sink: { kind: "callback", handler: (event) => candidateEvents.push(event) },
+  });
+  const candidateBridge = new ManagedAnalyticsEventBrokerBridge({ broker: candidateBroker });
+  const deniedInitialize = candidateBridge.initialize({
+    logicalId: "page-v84-candidate-initial",
+    path: "/v84-lifecycle",
+    correlation: CORRELATION,
+  });
+  if (!skipped(deniedInitialize, "consent-ineligible")) {
+    throw new Error("Default-denied analytics unexpectedly emitted.");
+  }
+  const grantedSnapshot = consent.setDecisions({ analytics: "granted" });
+  const consentUpdate = candidateBridge.consentUpdated();
+  const actionResults = APPROVED_MARKETING_ACTION_NAMES.map((name, index) =>
+    candidateBridge.activate({
+      logicalId: `action-v84-${index + 1}`,
+      name,
+      correlation: CORRELATION,
+    })
+  );
+  const documentRoute = candidateBridge.navigationCommitted({
+    logicalId: "route-v84-document",
+    path: "/v84-document",
+    correlation: CORRELATION,
+    kind: "document",
+  });
+  const redirectRoute = candidateBridge.navigationCommitted({
+    logicalId: "route-v84-redirect",
+    path: "/v84-redirect",
+    correlation: CORRELATION,
+    kind: "redirect",
+  });
+  const backForwardRoute = candidateBridge.navigationCommitted({
+    logicalId: "route-v84-back-forward",
+    path: "/v84-back-forward",
+    correlation: CORRELATION,
+    kind: "back-forward",
+  });
+  const hashRoute = candidateBridge.navigationCommitted({
+    logicalId: "route-v84-hash",
+    path: "/v84-lifecycle#review",
+    correlation: CORRELATION,
+    kind: "hash",
+  });
+  const abortedRoute = candidateBridge.navigationCommitted({
+    logicalId: "route-v84-aborted",
+    path: "/v84-aborted",
+    correlation: CORRELATION,
+    kind: "redirect",
+    aborted: true,
+  });
+  const duplicateInitialize = candidateBridge.initialize({
+    logicalId: "page-v84-duplicate",
+    path: "/v84-duplicate",
+    correlation: CORRELATION,
+  });
+  candidateBridge.dispose();
+  const afterDispose = candidateBridge.activate({
+    logicalId: "action-v84-after-dispose",
+    name: APPROVED_MARKETING_ACTION_NAMES[0],
+    correlation: CORRELATION,
+  });
+  if (
+    !skipped(consentUpdate, "lifecycle-unchanged") ||
+    actionResults.some((result) => !emitted(result)) ||
+    !skipped(documentRoute, "not-page-view-owner") ||
+    !emitted(redirectRoute) ||
+    !emitted(backForwardRoute) ||
+    !skipped(hashRoute, "not-page-view-owner") ||
+    !skipped(abortedRoute, "not-page-view-owner") ||
+    !skipped(duplicateInitialize, "already-initialized") ||
+    !skipped(afterDispose, "disposed")
+  ) {
+    throw new Error("The managed semantic bridge lifecycle changed.");
+  }
+
+  const stagedEvents: CommerceEvent[] = [];
+  const stagedBroker = new CommerceEventBroker({
+    trusted: {
+      tenant: V84_NATIVE_CLONE_TENANT,
+      environment: stagedEnvironment.environment,
+      siteSurface: stagedEnvironment.siteSurface,
+    },
+    source: "urn:tot:storefront:v84-lifecycle-staged",
+    consentSnapshot: () => consent.getSnapshot(),
+    tenantActionRegistry: registryResult.value,
+    now: () => AT,
+  });
+  stagedBroker.subscribe({
+    id: "offline-v84-staged-receiver",
+    consentPurpose: "analytics",
+    sink: { kind: "callback", handler: (event) => stagedEvents.push(event) },
+  });
+  const stagedBridge = new ManagedAnalyticsEventBrokerBridge({ broker: stagedBroker });
+  const stagedInitialize = stagedBridge.initialize({
+    logicalId: "page-v84-staged-initial",
+    path: "/v84-lifecycle",
+    correlation: CORRELATION,
+  });
+  stagedBridge.dispose();
+  if (!emitted(stagedInitialize)) throw new Error("The staged in-memory lifecycle did not initialize once.");
+
+  const allEvents = [...candidateEvents, ...stagedEvents];
+  const actionEvents = candidateEvents.filter((event) => event.type === "storefront.action.activated.v1");
+  const routeEvents = candidateEvents.filter((event) => event.type === "storefront.page.viewed.v2");
+  const actionPayloadKeys = actionEvents[0] ? Object.keys(actionEvents[0].data).sort() : [];
+  if (
+    candidateEvents.length !== 7 ||
+    stagedEvents.length !== 1 ||
+    actionEvents.length !== APPROVED_MARKETING_ACTION_NAMES.length ||
+    stableIntegrationStringify(actionEvents.map((event) => event.data["name"])) !==
+      stableIntegrationStringify(APPROVED_MARKETING_ACTION_NAMES) ||
+    actionEvents.some((event) => stableIntegrationStringify(Object.keys(event.data).sort()) !== '["name"]') ||
+    stableIntegrationStringify(routeEvents.map((event) => event.data)) !==
+      stableIntegrationStringify([{ path: "/v84-redirect" }, { path: "/v84-back-forward" }]) ||
+    stableIntegrationStringify(stagedEvents.map((event) => event.data)) !==
+      stableIntegrationStringify([{ path: "/v84-lifecycle" }]) ||
+    allEvents.some((event) => event.storefront.tenant !== V84_NATIVE_CLONE_TENANT) ||
+    allEvents.some((event) => event.storefront.environment === "live")
+  ) {
+    throw new Error("The in-memory event evidence escaped its clone/non-live scope.");
+  }
+
+  return {
+    candidateEnvironment,
+    stagedEnvironment,
+    consent: {
+      purpose: "analytics" as const,
+      defaultEligible: defaultSnapshot.eligiblePurposes,
+      grantedEligible: grantedSnapshot.eligiblePurposes,
+      defaultInitializeEmitted: false,
+      consentUpdateReinitialized: false,
+    },
+    lifecycle: {
+      candidateInitializeCount: 1,
+      stagedInitializeCount: 1,
+      duplicateInitializeEmitted: false,
+      disposeTerminal: true,
+      destinationKind: "in-memory-callback" as const,
+    },
+    routes: {
+      documentOwner: "document-bootstrap" as const,
+      redirectOwner: "navigation-commit" as const,
+      backForwardOwner: "navigation-commit" as const,
+      hashOwner: "none" as const,
+      abortedOwner: "none" as const,
+      emittedRouteCount: 2,
+    },
+    actions: {
+      approvedNames: [...APPROVED_MARKETING_ACTION_NAMES],
+      emittedCount: actionResults.length,
+      duplicateNames: new Set(APPROVED_MARKETING_ACTION_NAMES).size === APPROVED_MARKETING_ACTION_NAMES.length ? 0 : 1,
+      payloadKeys: actionPayloadKeys,
+    },
+    inMemoryEventDeliveries: allEvents.length,
+  };
+}