@tokenoftrust/storefront-runner 2.0.2 → 2.0.4

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

@@ -1,177 +0,0 @@
-/**
- * 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

@@ -1,251 +0,0 @@
-/**
- * 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

@@ -1,241 +0,0 @@
-/** 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,
-  };
-}