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

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

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

@@ -0,0 +1,409 @@
+/**
+ * Exact-clone, transport-free proof that reviewed GA4 and Amplitude destinations
+ * can be drafted and installed through WS1's public Integration Management API.
+ * The injected client is the only authority: this module has no database,
+ * environment/config, network, lifecycle-publish, or runtime execution seam.
+ */
+import {
+  APPROVED_MARKETING_ACTION_NAMES,
+  MANAGED_ANALYTICS_SCHEMA_VERSION,
+  MANAGED_ANALYTICS_API_VERSION,
+  eventDedupeKey,
+  platformAdapterCatalog,
+  sha256Hex,
+  snapshotManagedAnalyticsDeclarativeInput,
+  stableIntegrationStringify,
+  validateAdapterDefinition,
+  validateCreateMigrationDraftRequest,
+  validateManagedAnalyticsSafePayload,
+  validateMigrationDraftV1,
+  type AdapterDefinition,
+  type CreateMigrationDraftRequest,
+  type MigrationDraftV1,
+} from "@tot/public-runtime";
+import {
+  prepareWs1ApiResponse,
+  reviewInstallDraft,
+} from "./gtmMigrationInstall.js";
+import type { Ws1ManagedAnalyticsMigrationClient } from "./ws1ManagedAnalyticsClient.js";
+import type { V84CloneMigrationEvidence } from "./v84CloneMigrationEvidence.js";
+
+export const V84_NATIVE_SOURCE_TENANT = "tokenoftrust.com" as const;
+export const V84_NATIVE_CLONE_TENANT = "tokenoftrust.com~clone~gtm-migration-v84" as const;
+export const V84_WS1_FINAL = "13feb8eeb80a5f86d133c50d5a0246b43a2634ea" as const;
+export const V84_WS1_API_CONTRACT = "8d8b1a5807fa5e4a22ef9060470da958c70ac691" as const;
+export const V84_WS2_FINAL = "1c9accab31aff3e72ccd435ce7b6f85e683d105d" as const;
+/** SHA-256 of the complete deterministic WS2 evidence pinned by V84_WS2_FINAL. */
+export const V84_WS2_EVIDENCE_SHA256 = "7156b52af31f29a1055e60bdbc5488cc06bedf68e8ab89325d92ae542b303881" as const;
+
+const DESTINATIONS = [
+  {
+    key: "ga4",
+    adapterId: "platform.google-measurement",
+    destinationId: "G-V84FAKE01",
+    findings: ["v84.ga4.reviewed", "canonical.actions.allowlisted"],
+    provenance: "ws2-draft-plus-reviewed-fake-configuration" as const,
+  },
+  {
+    key: "amplitude",
+    adapterId: "platform.amplitude",
+    destinationId: "0123456789abcdef0123456789abcdef",
+    findings: ["v84.amplitude.reviewed", "canonical.actions.allowlisted"],
+    provenance: "separately-reviewed-native-addition" as const,
+  },
+] as const;
+
+/** Public-runtime-only adapter snapshots for the offline WS1 fake client. */
+export function v84PublicAdapterDefinitions(): AdapterDefinition[] {
+  return platformAdapterCatalog().map((card) => {
+    const checked = validateAdapterDefinition({
+      schemaVersion: MANAGED_ANALYTICS_SCHEMA_VERSION,
+      adapterId: card.adapterId,
+      adapterVersion: "1.0.0",
+      displayName: card.name,
+      description: card.purpose,
+      availability: "available",
+      configuration: [{
+        key: "destinationId",
+        label: card.idLabel,
+        description: "Public destination identifier used by this reviewed adapter.",
+        kind: "string",
+        required: true,
+      }],
+      eventTypes: [...card.eventTypes],
+      consentPurposes: [...card.consentPurposes],
+      collectionOrigins: [...card.cspOrigins].sort(),
+    });
+    if (!checked.ok) throw new Error("The public adapter catalog failed its pinned WS1 contract.");
+    return checked.value;
+  });
+}
+
+export interface V84NativeInstallEvidence {
+  readonly schemaVersion: 1;
+  readonly scope: {
+    readonly sourceTenant: typeof V84_NATIVE_SOURCE_TENANT;
+    readonly sourceMode: "read-only";
+    readonly cloneTenant: typeof V84_NATIVE_CLONE_TENANT;
+    readonly environment: "diagnostic-clone";
+    readonly destinationMode: "offline-in-memory-fake-only";
+    readonly publicClientTransport: "tenant-bound-http-adapter-with-injected-no-network-fetch";
+  };
+  readonly contractPins: {
+    readonly ws1Final: typeof V84_WS1_FINAL;
+    readonly ws1ApiContract: typeof V84_WS1_API_CONTRACT;
+    readonly ws2Final: typeof V84_WS2_FINAL;
+    readonly ws2EvidenceSha256: typeof V84_WS2_EVIDENCE_SHA256;
+  };
+  readonly installations: readonly {
+    readonly adapterId: string;
+    readonly adapterVersion: string;
+    readonly configurationKeys: readonly ["destinationId"];
+    readonly destinationValueRedacted: true;
+    readonly consentPurposes: readonly string[];
+    readonly collectionOrigins: readonly string[];
+    readonly eventTypes: readonly string[];
+    readonly adapterSnapshotCount: 1;
+    readonly provenance: "ws2-draft-plus-reviewed-fake-configuration" | "separately-reviewed-native-addition";
+    readonly desired: {
+      readonly installStatus: "disabled";
+      readonly revisionStatus: "draft";
+      readonly configured: true;
+    };
+    readonly effective: {
+      readonly activeRevisionId: null;
+      readonly materialized: false;
+    };
+  }[];
+  readonly semanticActions: readonly string[];
+  readonly eventIdentity: {
+    readonly logicalId: "evt-v84-proof";
+    readonly dedupeKey: "evt-v84-proof";
+    readonly duplicateActionNames: 0;
+  };
+  readonly operationCounts: {
+    readonly createMigrationDraft: 2;
+    readonly getMigrationDraft: 2;
+    /** Reads performed by this install composition, independent of prior evidence production. */
+    readonly getAdapterDefinition: 2;
+    readonly createIntegrationInstall: 2;
+    readonly reviseIntegrationInstall: 0;
+    readonly setIntegrationInstallStatus: 0;
+    readonly publish: 0;
+  };
+  readonly priorEvidenceOperationCounts: {
+    /** The validated catalog snapshot already represented by the supplied WS2 evidence. */
+    readonly getAdapterDefinition: 1;
+  };
+  readonly composedOperationCounts: {
+    readonly createMigrationDraft: 2;
+    readonly getMigrationDraft: 2;
+    readonly getAdapterDefinition: 3;
+    readonly createIntegrationInstall: 2;
+    readonly reviseIntegrationInstall: 0;
+    readonly setIntegrationInstallStatus: 0;
+    readonly publish: 0;
+  };
+  readonly assurances: {
+    readonly hostileInputSnapshot: "frozen-public-validator";
+    readonly draftAndInstallWritesIdempotencyKeyed: true;
+    readonly adapterVersionSource: "one-getAdapterDefinition-snapshot-per-install";
+    readonly responseValidation: "frozen-public-validator";
+    readonly diagnosticsCarryDestinationValues: false;
+  };
+  readonly safety: {
+    readonly sourceMutationCount: 0;
+    readonly liveDestinationCount: 0;
+    readonly externalNetworkRequestCount: 0;
+    readonly importedCodeExecuted: false;
+    readonly runtimeLoaded: false;
+    readonly lifecycle: "reviewed-disabled-draft-only";
+    readonly diagnostics: "redacted";
+  };
+}
+
+async function createAndReviewFixedDestination(
+  client: Ws1ManagedAnalyticsMigrationClient,
+  destination: (typeof DESTINATIONS)[number],
+) {
+  const request: CreateMigrationDraftRequest = {
+    apiVersion: MANAGED_ANALYTICS_API_VERSION,
+    idempotencyKey: `v84-${destination.key}-draft-create`,
+    expectedRevision: 0,
+    body: {
+      proposedAdapterId: destination.adapterId,
+      proposedConfiguration: { destinationId: destination.destinationId },
+      findings: [...destination.findings],
+    },
+  };
+  const checked = validateCreateMigrationDraftRequest(request);
+  if (!checked.ok) throw new Error(`The fixed ${destination.key} migration draft request failed validation.`);
+
+  let rawResponse: Awaited<ReturnType<typeof client.createMigrationDraft>>;
+  try {
+    rawResponse = await client.createMigrationDraft(checked.value);
+  } catch {
+    throw new Error(`The fixed ${destination.key} migration draft request failed safely.`);
+  }
+  const response = prepareWs1ApiResponse<MigrationDraftV1>(
+    rawResponse,
+    `corr-v84-${destination.key}-draft`,
+    "mutation",
+  );
+  if (!response.ok) {
+    throw new Error(`The fixed ${destination.key} migration draft response was refused.`);
+  }
+  const draftCheck = validateMigrationDraftV1(response.value.data);
+  if (!draftCheck.ok) throw new Error(`The fixed ${destination.key} migration draft response failed validation.`);
+  const draft = draftCheck.value;
+  if (
+    draft.proposedAdapterId !== checked.value.body.proposedAdapterId ||
+    stableIntegrationStringify(draft.proposedConfiguration) !== stableIntegrationStringify(checked.value.body.proposedConfiguration) ||
+    stableIntegrationStringify(draft.findings) !== stableIntegrationStringify(checked.value.body.findings)
+  ) {
+    throw new Error(`The fixed ${destination.key} migration draft response changed reviewed input.`);
+  }
+
+  const result = await reviewInstallDraft(client, {
+    draftId: draft.draftId,
+    idempotencyKey: `v84-${destination.key}-install-create`,
+    correlationId: `corr-v84-${destination.key}-install`,
+  }, draft);
+  if (!result.ok) throw new Error(`The fixed ${destination.key} review/install proof was refused: ${result.code ?? "unknown"}.`);
+  return { ...result, draft };
+}
+
+const EXACT_WS2_SCOPE = {
+  sourceTenant: V84_NATIVE_SOURCE_TENANT,
+  sourceMode: "read-only-fixture",
+  cloneTenant: V84_NATIVE_CLONE_TENANT,
+  destinationMode: "offline-in-memory-only",
+} as const;
+const EXACT_WS2_ACCOUNTING = {
+  parsedRecords: 86,
+  syntheticNodes: 3,
+  classifiedObjects: 89,
+  classifiedDanglingReferences: 0,
+  accountedTotal: 89,
+} as const;
+const EXACT_WS2_ADAPTER_RESOLUTION = {
+  operation: "getAdapterDefinition",
+  request: { apiVersion: "v1", query: { adapterId: "platform.google-measurement" } },
+  adapterId: "platform.google-measurement",
+  adapterVersion: "1.0.0",
+  snapshotCount: 1,
+} as const;
+const EXACT_WS2_SAFETY = {
+  sourceMutationCount: 0,
+  cloneMutationCount: 0,
+  installMutationCount: 0,
+  networkRequestCount: 0,
+  listenerCount: 0,
+  markupAdded: false,
+  cspChanged: false,
+  runtimeLoaded: false,
+  importedCodeExecuted: false,
+  draftStatus: "draft",
+  draftEnabled: false,
+  draftPublishes: false,
+  lifecycle: "draft-only",
+} as const;
+
+function sameEvidenceValue(left: unknown, right: unknown): boolean {
+  return stableIntegrationStringify(left) === stableIntegrationStringify(right);
+}
+
+/** Fail closed unless this is the complete deterministic evidence pinned by WS2 final. */
+async function assertV84ImportProvenance(input: unknown): Promise<V84CloneMigrationEvidence> {
+  const snapshot = snapshotManagedAnalyticsDeclarativeInput<V84CloneMigrationEvidence>(input);
+  if (!snapshot.ok) {
+    throw new Error("The native install proof requires the exact inert v84 WS2 draft evidence.");
+  }
+  const importEvidence = snapshot.value;
+  const draft = importEvidence.draftEvidence?.draft;
+  const draftCheck = validateMigrationDraftV1(draft);
+  const evidenceDigest = await sha256Hex(stableIntegrationStringify(importEvidence));
+  if (
+    importEvidence.schemaVersion !== 1 ||
+    !sameEvidenceValue(importEvidence.scope, EXACT_WS2_SCOPE) ||
+    !sameEvidenceValue(importEvidence.accounting, EXACT_WS2_ACCOUNTING) ||
+    !draftCheck.ok ||
+    draft?.proposedAdapterId !== "platform.google-measurement" ||
+    !sameEvidenceValue(draft?.proposedConfiguration, {}) ||
+    draft?.enabled !== false ||
+    draft?.publishes !== false ||
+    !validateManagedAnalyticsSafePayload(draft).ok ||
+    importEvidence.draftEvidence?.mappedConcepts?.length !== 44 ||
+    importEvidence.draftEvidence?.unresolvedInventory?.length !== 45 ||
+    importEvidence.analysis?.graph?.nodes?.length !== 89 ||
+    importEvidence.analysis?.graph?.edges?.length !== 150 ||
+    importEvidence.analysis?.dispositions?.length !== 89 ||
+    importEvidence.analysis?.graph?.danglingReferences?.length !== 0 ||
+    !sameEvidenceValue(importEvidence.adapterResolution, EXACT_WS2_ADAPTER_RESOLUTION) ||
+    importEvidence.codeExecutionUnsupported?.length !== 8 ||
+    importEvidence.nonportableCodeCoaching?.dossiers?.length !== 8 ||
+    !sameEvidenceValue(importEvidence.approvedSemanticActions, APPROVED_MARKETING_ACTION_NAMES) ||
+    !sameEvidenceValue(importEvidence.safety, EXACT_WS2_SAFETY) ||
+    evidenceDigest !== V84_WS2_EVIDENCE_SHA256
+  ) {
+    throw new Error("The native install proof requires the exact inert v84 WS2 draft evidence.");
+  }
+  return importEvidence;
+}
+
+/** Configure, review, and install both fake destinations through the public client. */
+export async function buildV84CloneNativeInstallEvidence(
+  client: Ws1ManagedAnalyticsMigrationClient,
+  importEvidence: V84CloneMigrationEvidence,
+): Promise<V84NativeInstallEvidence> {
+  const exactImportEvidence = await assertV84ImportProvenance(importEvidence);
+  const currentCatalogReads = 2 as const;
+  const priorCatalogReads = exactImportEvidence.adapterResolution.snapshotCount;
+  const composedCatalogReads = currentCatalogReads + priorCatalogReads;
+  if (priorCatalogReads !== 1 || composedCatalogReads !== 3) {
+    throw new Error("The native install proof catalog-read ledger did not compose exactly.");
+  }
+  const installations: V84NativeInstallEvidence["installations"][number][] = [];
+
+  for (const destination of DESTINATIONS) {
+    if (destination.key === "ga4" && destination.adapterId !== exactImportEvidence.draftEvidence.draft.proposedAdapterId) {
+      throw new Error("The reviewed GA4 destination no longer matches the v84 WS2 draft.");
+    }
+    const result = await createAndReviewFixedDestination(client, destination);
+    if (
+      result.install.status !== "disabled" ||
+      result.install.activeRevisionId !== null ||
+      result.revision.status !== "draft" ||
+      result.revision.adapterVersion !== result.adapter.adapterVersion ||
+      result.adapter.adapterId !== destination.adapterId
+    ) {
+      throw new Error(`The offline ${destination.key} install did not remain a disabled draft.`);
+    }
+    if (!result.adapter.eventTypes.includes("storefront.action.activated.v1")) {
+      throw new Error(`The offline ${destination.key} adapter omitted the canonical semantic action event.`);
+    }
+    installations.push({
+      adapterId: result.adapter.adapterId,
+      adapterVersion: result.adapter.adapterVersion,
+      configurationKeys: ["destinationId"],
+      destinationValueRedacted: true,
+      consentPurposes: [...result.adapter.consentPurposes],
+      collectionOrigins: [...result.adapter.collectionOrigins],
+      eventTypes: [...result.adapter.eventTypes],
+      adapterSnapshotCount: 1,
+      provenance: destination.provenance,
+      desired: { installStatus: "disabled", revisionStatus: "draft", configured: true },
+      effective: { activeRevisionId: null, materialized: false },
+    });
+  }
+
+  const semanticActions = [...APPROVED_MARKETING_ACTION_NAMES];
+  if (eventDedupeKey({ id: "evt-v84-proof" }) !== "evt-v84-proof") {
+    throw new Error("The canonical event identity did not remain its dedupe key.");
+  }
+  if (new Set(semanticActions).size !== semanticActions.length) {
+    throw new Error("The canonical semantic action allowlist contains a duplicate.");
+  }
+  const evidence: V84NativeInstallEvidence = {
+    schemaVersion: 1,
+    scope: {
+      sourceTenant: V84_NATIVE_SOURCE_TENANT,
+      sourceMode: "read-only",
+      cloneTenant: V84_NATIVE_CLONE_TENANT,
+      environment: "diagnostic-clone",
+      destinationMode: "offline-in-memory-fake-only",
+      publicClientTransport: "tenant-bound-http-adapter-with-injected-no-network-fetch",
+    },
+    contractPins: {
+      ws1Final: V84_WS1_FINAL,
+      ws1ApiContract: V84_WS1_API_CONTRACT,
+      ws2Final: V84_WS2_FINAL,
+      ws2EvidenceSha256: V84_WS2_EVIDENCE_SHA256,
+    },
+    installations,
+    semanticActions,
+    eventIdentity: {
+      logicalId: "evt-v84-proof",
+      dedupeKey: "evt-v84-proof",
+      duplicateActionNames: 0,
+    },
+    operationCounts: {
+      createMigrationDraft: 2,
+      getMigrationDraft: 2,
+      getAdapterDefinition: currentCatalogReads,
+      createIntegrationInstall: 2,
+      reviseIntegrationInstall: 0,
+      setIntegrationInstallStatus: 0,
+      publish: 0,
+    },
+    priorEvidenceOperationCounts: {
+      getAdapterDefinition: priorCatalogReads,
+    },
+    composedOperationCounts: {
+      createMigrationDraft: 2,
+      getMigrationDraft: 2,
+      getAdapterDefinition: composedCatalogReads,
+      createIntegrationInstall: 2,
+      reviseIntegrationInstall: 0,
+      setIntegrationInstallStatus: 0,
+      publish: 0,
+    },
+    assurances: {
+      hostileInputSnapshot: "frozen-public-validator",
+      draftAndInstallWritesIdempotencyKeyed: true,
+      adapterVersionSource: "one-getAdapterDefinition-snapshot-per-install",
+      responseValidation: "frozen-public-validator",
+      diagnosticsCarryDestinationValues: false,
+    },
+    safety: {
+      sourceMutationCount: 0,
+      liveDestinationCount: 0,
+      externalNetworkRequestCount: 0,
+      importedCodeExecuted: false,
+      runtimeLoaded: false,
+      lifecycle: "reviewed-disabled-draft-only",
+      diagnostics: "redacted",
+    },
+  };
+  return evidence;
+}