@tokenoftrust/storefront-runner 1.4.1 → 2.0.0

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,
+  };
+}

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

@@ -0,0 +1,211 @@
+/**
+ * Deterministic, read-only WS3 proof that the synthetic v84 fixture can pass
+ * through the pinned WS2 importer for the exact diagnostic clone.
+ *
+ * This module only composes pure importer functions and one injected WS1 catalog
+ * read. It has no install/publish/enable seam, no storage seam, and no browser or
+ * network primitive. Imported records remain inert data throughout.
+ */
+import {
+  APPROVED_MARKETING_ACTION_NAMES,
+  MANAGED_ANALYTICS_API_VERSION,
+  buildMigrationGraph,
+  classifyMigration,
+  generateDisabledMigrationDraft,
+  parseGtmExport,
+  validateAdapterDefinition,
+  validateManagedAnalyticsSafePayload,
+  validateMigrationDraftV1,
+  type AdapterDefinition,
+  type DisabledDraftResult,
+  type GetAdapterDefinitionRequest,
+  type GetAdapterDefinitionResponse,
+} from "@tot/public-runtime";
+import { analyzeGtmExport, type GtmMigrationReport } from "./gtmMigrationReport.js";
+import {
+  buildV84NonportableCodeCoaching,
+  type V84NonportableCodeCoaching,
+} from "./v84NonportableCodeCoaching.js";
+import type { V84CleanCloneReplayContext } from "./v84CleanCloneReplayContext.js";
+
+export const V84_SOURCE_TENANT = "tokenoftrust.com" as const;
+export const V84_CLONE_TENANT = "tokenoftrust.com~clone~gtm-migration-v84" as const;
+export const V84_EVIDENCE_AT = "2026-08-29T00:00:00.000Z" as const;
+
+export interface ReadOnlyAdapterCatalog {
+  getAdapterDefinition(request: GetAdapterDefinitionRequest): Promise<GetAdapterDefinitionResponse>;
+}
+
+export interface V84CloneMigrationEvidence {
+  readonly schemaVersion: 1;
+  readonly scope: {
+    readonly sourceTenant: typeof V84_SOURCE_TENANT;
+    readonly sourceMode: "read-only-fixture";
+    readonly cloneTenant: typeof V84_CLONE_TENANT;
+    readonly destinationMode: "offline-in-memory-only";
+  };
+  readonly accounting: {
+    readonly parsedRecords: number;
+    readonly syntheticNodes: number;
+    readonly classifiedObjects: number;
+    readonly classifiedDanglingReferences: number;
+    readonly accountedTotal: number;
+  };
+  /** Complete redacted inventory, graph, dispositions, findings, and recommendations. */
+  readonly analysis: GtmMigrationReport;
+  readonly draftEvidence: DisabledDraftResult;
+  readonly adapterResolution: {
+    readonly operation: "getAdapterDefinition";
+    readonly request: GetAdapterDefinitionRequest;
+    readonly adapterId: string;
+    readonly adapterVersion: string;
+    readonly snapshotCount: 1;
+  };
+  /** Exactly the inert coaching records that cannot be represented as code. */
+  readonly codeExecutionUnsupported: DisabledDraftResult["unresolvedInventory"];
+  /** Reviewed, per-object native coaching for every unsupported code record. */
+  readonly nonportableCodeCoaching: V84NonportableCodeCoaching;
+  readonly approvedSemanticActions: readonly string[];
+  readonly safety: {
+    readonly sourceMutationCount: 0;
+    readonly cloneMutationCount: 0;
+    readonly installMutationCount: 0;
+    readonly networkRequestCount: 0;
+    readonly listenerCount: 0;
+    readonly markupAdded: false;
+    readonly cspChanged: false;
+    readonly runtimeLoaded: false;
+    readonly importedCodeExecuted: false;
+    readonly draftStatus: "draft";
+    readonly draftEnabled: false;
+    readonly draftPublishes: false;
+    readonly lifecycle: "draft-only";
+  };
+}
+
+function safeAdapterResponse(response: GetAdapterDefinitionResponse): AdapterDefinition {
+  if ("error" in response) throw new Error("The offline adapter snapshot was unavailable.");
+  const checked = validateAdapterDefinition(response.data);
+  if (!checked.ok) throw new Error("The offline adapter snapshot failed the pinned contract.");
+  return checked.value;
+}
+
+function assertExactV84Evidence(evidence: V84CloneMigrationEvidence): void {
+  if (evidence.accounting.parsedRecords !== 86 || evidence.accounting.syntheticNodes !== 3) {
+    throw new Error("The synthetic v84 fixture inventory changed.");
+  }
+  if (evidence.accounting.classifiedObjects !== 89 || evidence.accounting.classifiedDanglingReferences !== 0) {
+    throw new Error("The synthetic v84 fixture classification is incomplete.");
+  }
+  if (evidence.accounting.accountedTotal !== 89) throw new Error("The synthetic v84 accounting did not close.");
+  if (evidence.codeExecutionUnsupported.length !== 8) {
+    throw new Error("The synthetic v84 code-execution coaching inventory changed.");
+  }
+  if (evidence.draftEvidence.mappedConcepts.length + evidence.draftEvidence.unresolvedInventory.length !== 89) {
+    throw new Error("The disabled draft inventory did not account for every classified object.");
+  }
+  if (!validateMigrationDraftV1(evidence.draftEvidence.draft).ok) {
+    throw new Error("The generated draft failed the pinned MigrationDraft v1 contract.");
+  }
+  if (!validateManagedAnalyticsSafePayload(evidence.draftEvidence.draft).ok) {
+    throw new Error("The generated draft failed the managed-analytics safety boundary.");
+  }
+}
+
+/**
+ * Run the exact synthetic v84 fixture text through the WS2 pipeline and resolve
+ * its adapter version from one injected, read-only WS1 catalog snapshot.
+ */
+export async function buildV84CloneMigrationEvidence(
+  fixtureText: string,
+  catalog: ReadOnlyAdapterCatalog,
+  replayContext?: V84CleanCloneReplayContext,
+): Promise<V84CloneMigrationEvidence> {
+  const parsed = parseGtmExport(fixtureText);
+  if (!parsed.ok) throw new Error("The synthetic v84 fixture failed the pinned parser.");
+  const graph = buildMigrationGraph(parsed.container);
+  const disposition = classifyMigration(graph);
+
+  // Determine the proposed public adapter using WS2, then resolve its version
+  // through the exact WS1 read operation. The returned definition is the single
+  // catalog snapshot supplied to the final draft generation (no TOCTOU re-read).
+  const initialDraft = generateDisabledMigrationDraft({
+    container: parsed.container,
+    graph,
+    disposition,
+    provenance: { draftId: "draft-v84-clone-evidence", generatedAt: V84_EVIDENCE_AT },
+  });
+  const request: GetAdapterDefinitionRequest = {
+    apiVersion: MANAGED_ANALYTICS_API_VERSION,
+    query: { adapterId: initialDraft.draft.proposedAdapterId },
+  };
+  const adapter = safeAdapterResponse(await catalog.getAdapterDefinition(request));
+  if (adapter.adapterId !== initialDraft.draft.proposedAdapterId) {
+    throw new Error("The offline adapter snapshot did not match the proposed adapter.");
+  }
+
+  const draftEvidence = generateDisabledMigrationDraft({
+    container: parsed.container,
+    graph,
+    disposition,
+    provenance: { draftId: "draft-v84-clone-evidence", generatedAt: V84_EVIDENCE_AT },
+    adapterCatalog: [adapter],
+  });
+  const analyzed = analyzeGtmExport(fixtureText, {
+    tenantId: V84_CLONE_TENANT,
+    correlationId: "corr-v84-clone-evidence",
+    generatedAt: V84_EVIDENCE_AT,
+  });
+  if (!analyzed.ok) throw new Error("The synthetic v84 fixture failed redacted report generation.");
+
+  const scope = {
+    sourceTenant: V84_SOURCE_TENANT,
+    sourceMode: "read-only-fixture" as const,
+    cloneTenant: V84_CLONE_TENANT,
+    destinationMode: "offline-in-memory-only" as const,
+  };
+  const codeExecutionUnsupported = draftEvidence.unresolvedInventory.filter(
+    (item) => item.reasonCode === "code-execution-unsupported",
+  );
+  const evidence: V84CloneMigrationEvidence = {
+    schemaVersion: 1,
+    scope,
+    accounting: {
+      parsedRecords: Object.values(parsed.accounting.counts).reduce((sum, count) => sum + count, 0),
+      syntheticNodes: graph.accounting.syntheticNodeCount,
+      classifiedObjects: disposition.objects.length,
+      classifiedDanglingReferences: disposition.dangling.length,
+      accountedTotal: disposition.summary.total,
+    },
+    analysis: analyzed.report,
+    draftEvidence,
+    adapterResolution: {
+      operation: "getAdapterDefinition",
+      request,
+      adapterId: adapter.adapterId,
+      adapterVersion: adapter.adapterVersion,
+      snapshotCount: 1,
+    },
+    codeExecutionUnsupported,
+    nonportableCodeCoaching: buildV84NonportableCodeCoaching({ scope, codeExecutionUnsupported }),
+    approvedSemanticActions: [...APPROVED_MARKETING_ACTION_NAMES],
+    safety: {
+      sourceMutationCount: 0,
+      cloneMutationCount: 0,
+      installMutationCount: 0,
+      networkRequestCount: 0,
+      listenerCount: 0,
+      markupAdded: false,
+      cspChanged: false,
+      runtimeLoaded: false,
+      importedCodeExecuted: false,
+      draftStatus: draftEvidence.draft.status,
+      draftEnabled: draftEvidence.draft.enabled,
+      draftPublishes: draftEvidence.draft.publishes,
+      lifecycle: "draft-only",
+    },
+  };
+  assertExactV84Evidence(evidence);
+  replayContext?.write("stage/import/handoff", evidence);
+  return evidence;
+}