@drip-apex/sdk 0.1.0 → 0.3.0

package/src/assignment-runtime.ts

@@ -0,0 +1,3204 @@
+declare const __DRIP_FEATURE_QA__: boolean;
+declare const __DRIP_FEATURE_DEVTOOLS__: boolean;
+declare const __DRIP_FEATURE_AUDIT__: boolean;
+declare const __DRIP_FEATURE_HEATMAP__: boolean;
+declare const __DRIP_FEATURE_REPLAY__: boolean;
+declare const __DRIP_FEATURE_HARNESS__: boolean;
+const FEATURE_QA = __DRIP_FEATURE_QA__;
+const FEATURE_DEVTOOLS = __DRIP_FEATURE_DEVTOOLS__;
+const FEATURE_AUDIT = __DRIP_FEATURE_AUDIT__;
+const FEATURE_HEATMAP = __DRIP_FEATURE_HEATMAP__;
+const FEATURE_REPLAY = __DRIP_FEATURE_REPLAY__;
+const FEATURE_HARNESS = __DRIP_FEATURE_HARNESS__;
+import { cleanUrl, onPageEnter, onPageExit } from "./analytics";
+import { normalizeEndpoint } from "./endpoint";
+import { EVENT_TYPE_PATTERN, normalizeEventName } from "@drip/event-schema/event-name";
+import { isExperimentServable } from "@drip/event-schema/experiment-servability";
+import {
+  applyAntiFlicker,
+  bootedTooLateForAntiFlicker,
+  removeAntiFlicker,
+} from "./antiflicker";
+import {
+  clearPersistedAssignments,
+  findPersistedVariation,
+  persistAssignmentForExperiment,
+  prunePersistedAssignments,
+  removePersistedAssignmentsForExperiments,
+  __assignmentStoreInternals,
+} from "./assignment-store";
+import { cleanupBucketingStorage } from "./bucketing-cleanup";
+import { chooseVariation, inTrafficAllocation } from "./bucket";
+import { buildAssignment, decideAssignments } from "./decide-assignments";
+import { weekdayScheduleBlocksDelivery } from "./weekday-schedule";
+import { CONSENT_REQUIRED, DNT_BLOCKED, evaluateSynchronousConsent, readConfiguredConsent, readPath, resolveSynchronousConsentGranted } from "./consent-evaluation";
+import { clearEarlyInteractions, drainBootstrapEarlyInteractions, drainEarlyInteractions } from "./early-interaction-capture";
+import { getCwvMetrics, markCwvReveal, startCwvMeasurement, waitForCwvMetrics } from "./cwv";
+import { collectDeliveryTiming } from "./delivery-timing";
+import {
+  startStorefrontVitals,
+  stopStorefrontVitals,
+  type StorefrontVitalsContext,
+} from "./storefront-vitals";
+import {
+  browserGroupStickyStore,
+  clearBrowserGroupStickyStore,
+  resolveExclusionGroups,
+  type ExclusionGroupDecision,
+  type PersistedGroupSelection,
+} from "./exclusion-groups";
+import type { CompactGroupSelections } from "./persistence-decoders";
+import {
+  applyCommercePrice,
+  isCommercePriceWorkPending,
+  cleanupCommercePrice,
+  hasCommercePriceState,
+  COMMERCE_PRICE_SELECTORS,
+  isCommercePriceActive,
+  isCommercePriceExposureEligible,
+  notifyCommerceCartStampConfirmed,
+  setCommercePriceExposureListener,
+} from "./commerce-price";
+import {
+  applyCommerceShipping,
+  classifyShippingExposure,
+  cleanupCommerceShipping,
+  isShippingCartEligible,
+  isShippingCartEligibilityConfirmed,
+} from "./commerce-shipping";
+import {
+  addCssOwners,
+  injectCss,
+  injectExperimentCss,
+  injectExternalCss,
+  removeCssForOwner,
+} from "./css";
+import { configureDebug, debugLog, debugWarn, debugGroup, debugGroupEnd, isDebugEnabled } from "./debug";
+import { loadDebugBuild } from "./debug-loader";
+import { observeDomChanges } from "./dom-trigger";
+import { edgeRuntimeActive, readEdgeRuntimeAssignments } from "./edge-runtime";
+import { normalizeDataLayerEntry } from "./data-layer-normalize";
+import { interceptEditorLaunch, isEditorDevicePreview } from "./editor-bootstrap";
+import { cleanupGoals, goalWiringKeys, setupGoals, triggerGoal, triggerGoalsForEvent } from "./goals";
+import { clearQaForceFromUrl, isBot, isDuplicate, isIframe, isOptedOut, isQaMode, isScreenshotMode, parseForceParam, persistQaForce, persistUrlQaForce, exitQaMode, getQaSessionId } from "./guards";
+import { adoptUserId, applyHoldoutGate, configureIdentityStorage, getEphemeralUserId, getUserId, hashToFloat, isHoldoutVisitor, variationHashToFloat } from "./hash";
+import { createBucketingHandoverPayload, handoverMintTimeoutMs, hasBucketingHandover, installBucketingHandover, readBucketingHandover } from "./handover";
+import { revealAll } from "./hideflicker";
+import {
+  addExternalJsOwners,
+  execJs,
+  loadExternalJs,
+  removeExternalJsForOwner,
+  setJsPolicy,
+} from "./js";
+import {
+  addAppliedMutationOwners,
+  applyMutations,
+  applyToElement,
+  invalidateArtifact,
+  reassertNonStructuralMutations,
+  replayArtifact,
+  resetAppliedMutationsForOwner,
+} from "./mutate";
+import { registerMutedObserver, runMuted, unregisterMutedObserver } from "./observer-mute";
+import { assignmentsHaveVisualWork, awaitHydration, hasMutationHold, holdMutations, releaseMutations, signalHydrated } from "./hydration";
+import {
+  assignmentsHaveCustomJs,
+  assignmentsHaveStructuralMutations,
+  installEarlyReassert,
+  shouldUseEarlyReassert,
+} from "./early-reassert";
+import { trackAppliedMutation } from "./reassert-sentinel";
+import { observeRouteChanges, PAGE_URL_POLL_INTERVAL_MS } from "./router";
+import { buildExposureSignalContext } from "./exposure-signals";
+import {
+  buildRedirectDestination,
+  clearPendingRedirectAssignmentCarry,
+  finalizeRedirectAssignmentCarryHandover,
+  hasGeneratedRedirectAssignmentCarry,
+  filterUnsafeRedirectAssignments,
+  importRedirectAssignmentCarry,
+  isRedirectLoop,
+  markRedirectAssignmentCarryExposed,
+  parseRedirectAssignmentCarry,
+  persistPendingRedirectAssignmentCarry,
+  readPendingRedirectAssignmentCarry,
+  REDIRECT_ASSIGNMENT_PARAM,
+  redirectPlanForAssignment,
+  stripRedirectAssignmentCarry,
+  validateRedirectAssignmentCarry,
+  verifyRedirectAssignmentCarry,
+} from "./redirect";
+import type { VerifiedRedirectCarry } from "./redirect";
+import { buildPrerequisiteContext, evaluateProjectPrerequisite } from "./prerequisites";
+import {
+  REPLAY_PROGRESS_KEY_PREFIX,
+  REPLAY_SAMPLE_KEY_PREFIX,
+  resolveReplayRecorderUrl,
+  startReplayCapture,
+  type ReplayController,
+} from "./replay";
+import {
+  buildCartAttributeEntries,
+  buildCartMetafieldInputs,
+  buildSignedCartAttributeEntries,
+  APEX_CART_ATTRIBUTE_KEYS,
+  cannotRequestRequiredCommerceAuthorization,
+  getCartMetafieldStaleKeys as collectCartMetafieldStaleKeys,
+  invalidateShopifyCartAttributeSync,
+  normalizeCartMetafieldNamespace,
+  syncShopifyCartAttributes,
+  type CartAssignment,
+  type CartAttributeEntry,
+  type CartMetafieldInput,
+  type CartAttributeSyncInput,
+} from "./shopify-cart";
+import { onShopifyCartMutation } from "./shopify-cart-events";
+import {
+  getPendingGiftChoices,
+  noteCartSnapshotForGifts,
+  selectGiftOption,
+  syncGiftWithPurchase,
+  type GiftSyncOptions,
+} from "./commerce-gift";
+import { CART_DRAWER_OPEN_SIGNAL, installSurfaceSignals } from "./surface-signals";
+import {
+  assignmentSignature,
+  canUseEmptyProjectProfile,
+  computeUrlDiffNeeds,
+  getBlankScreenMs,
+  readPerfFlags,
+  resolveActivationMode,
+  resolvePlatform,
+  resolveRouterMode,
+  shouldReevaluateForUrlChange,
+} from "./runtime";
+import type { PerfFlagState } from "./runtime";
+import {
+  buildTargetingAttributes,
+  evaluateTargetingGatesDetailed,
+  matchPageTargetingRule,
+  readShopifySignal,
+  targetingHasJsTriggers,
+} from "./targeting";
+import { createApexRuntimeTools, type ApexRuntimeTools } from "./runtime-tools";
+import { createEventId, Tracker } from "./track";
+import {
+  clearStoredSignals,
+  configureSignalPersistenceAllowed,
+  clearRuntimeSignal,
+  getSignals as getStoredSignals,
+  getSignalDiagnostics,
+  rememberProduct,
+  setCartSignals,
+  setRuntimeSignal,
+  setSearchSignal,
+  setSignal as setStoredSignal,
+} from "./signals";
+import {
+  evaluateFlag as evaluateFlagFromExperiments,
+  evaluateFlagAssignment as evaluateFlagAssignmentFromExperiments,
+  evaluateFlagValue as evaluateFlagValueFromExperiments,
+} from "./flags";
+import {
+  ActivationMode,
+  AntiFlickerMode,
+  Assignment,
+  ActivationDiagnostics,
+  ActivationGateDiagnostic,
+  ConditionDiagnostic,
+  ConfigProfile,
+  ConsentModeSettings,
+  CustomJsPolicy,
+  DebugSettings,
+  ExecutionMode,
+  Experiment,
+  ExperimentActivationDiagnostic,
+  ExclusionGroupConfig,
+  ExclusionGroupMemberConfig,
+  Goal,
+  InitConfig,
+  PageTargetingRule,
+  PageActivationDiagnostic,
+  PageDeactivationMode,
+  PageTriggerMode,
+  PageTriggerSettings,
+  PerfFeatureFlag,
+  PerfFeatureFlags,
+  PlatformHint,
+  ProjectPrerequisites,
+  RouterMode,
+  SegmentCondition,
+  SpaSettings,
+  Targeting,
+  ExternalTrackingSettings,
+  ProjectCodeSettings,
+  RuntimeEnvironmentSettings,
+  RuntimeSignalDefinition,
+  SdkDiagnostics,
+  SnippetCriticalMutation,
+  SnippetCriticalMutationPlanItem,
+  SnippetDeliveryUrlRule,
+  BucketingCleanupSettings,
+  DataProtectionSettings,
+  DataLayerSignalMapping,
+  DataLayerTriggerSettings,
+  ExposureDestinationsSettings,
+  Mutation,
+  TrackEvent,
+  TrackingStart,
+  Variation,
+} from "./types";
+import {
+  addWaitEntryOwners,
+  applyMutationWithWait,
+  resetWaitEntriesForOwner,
+} from "./wait";import { OrderIdentityPlatform, SDKState, QaAssistantRuntimeSnapshot, PageActivationRuntimeState, PageRulePollController, state, runtimeSharedState } from "./runtime-state";
+import { applyRuntimeAntiFlicker, SDK_SCRIPT_SRC, HeatmapController, SemanticController, FetchAttemptInfo, FetchRetryOptions, DEFAULT_CONFIG_FETCH_TIMEOUT_MS, DEFAULT_CONFIG_FETCH_SLOW_MS, CONFIG_FETCH_RETRY_COUNT, CONFIG_FETCH_RETRY_DELAY_MS, CONFIG_FETCH_MAX_WAIT_MS, CACHED_REDIRECT_HIDE_TIMEOUT_MS, createFetchTimeoutError, fetchWithTimeout, fetchWithRetry, CONFIG_CACHE_KEY_PREFIX, DEFAULT_CONFIG_CACHE_TTL_MS, DEFAULT_ANTI_FLICKER_TIMEOUT_MS, DEFAULT_TRACKING_IDLE_TIMEOUT_MS, DEFAULT_EXECUTION_MODE, DEFAULT_TRACKING_START, DEFAULT_JS_POLICY, PAGE_RULE_POLL_WINDOW_MS, PAGE_RULE_POLL_INTERVAL_MS, CONSENT_COOKIE_NAME, IDENTITY_CONTEXT_COOKIE_NAME, IDENTITY_CONTEXT_COOKIE_MAX_AGE_SECONDS, IDENTITY_CONTEXT_COOKIE_MAX_ENCODED_BYTES, SESSION_STORAGE_KEY, collectScopedSelectors, ResolvedRuntimeConfig, UrlDiffNeeds, ConfigSource, PendingPerfEvent, InitPhaseKey, InitPerfContext, MAX_PERF_DURATION_MS, monotonicNow, boundedPerfDuration, createInitPerfContext, BootstrapPredecision, bootstrapPredecision, addInitPhase, DeliveryHealthStatus, DeliveryHealthTracker, RouteDiagnostic, DataLayerDiagnostic, ShopifySyncDiagnostic, ExposureDestinationDiagnostic, RuntimeLoadDiagnostic, DripPerfWindow, normalizeNumber, resolveRuntimeConfig, resolvePageTriggerMode, resolveDomPageTrigger, dtLog, traceName, traceStep, traceGate, browserDoNotTrackValue, trackingBlocked, storefrontVitalsGateOpen, syncStorefrontVitals, doNotTrackEnabled, storageAllowed, readWindowPath, configuredConsentGranted, syncConfiguredConsent, CUSTOM_CONSENT_POLL_INTERVAL_MS, CUSTOM_CONSENT_POLL_MAX_MS, MANUAL_CALLBACK_TRIGGER_RERUN_INTERVAL_MS, MANUAL_CALLBACK_TRIGGER_RERUN_MAX_MS, MANUAL_CALLBACK_TRIGGER_MAX_RERUNS, EVENT_DRIVEN_CONSENT_PROVIDERS, shouldPollConfiguredConsent, installConsentChangeListeners, resolveConsentRequired, resolveConsentGranted, persistentStorageAllowed, coerceSignalValue, captureUrlSignals, installClickSignalCaptures, captureEventPropertySignals, setCapturedSignal, setPublicSignal, getPublicSignals, normalizePageApiName, pageTriggerSignal, triggerPage, readElementCaptureValue, captureDomAndGlobalSignals, consentAwareDataProtection, writeConsentCookie, readConsentCookie, clearConsentStorage, applyConsentStorageMode, runWhenDomReady, applyProjectCode, resetProjectCode, runProjectStartupCode, collectJsTriggerConditions, collectPageTriggerRules, PageDetectorMode, PageRuleReconcileScope, collectPageDetectorRules, experimentsForGlobalRouteReevaluation, conditionUsesActivateTrigger, buildJsTriggerContext, runJsTriggerReset, normalizeActivationValue, installActivateJsTrigger, installPageTriggerRule, installJsTriggerObserver, notifyQaAssistantRuntimeListeners, HarnessManifest, harnessPollTimer, harnessPollKey, harnessVisibilityInstalled, activeHarnessAssignment, stopHarnessPolling, applyHarnessManifest, pollHarnessManifest, startHarnessPolling, getEventsEndpoint, mintBucketingHandoverPayload, verifyBucketingHandoverToken, clearScheduledAnalyticsStart, normalizeDataLayerTriggers, applyDataLayerMappings, readNumericPath, readStringPath, RESERVED_DATA_LAYER_REVENUE_KEYS, PendingDataLayerEvent, MAX_PENDING_DATA_LAYER_EVENTS, pendingDataLayerEvents, processedDataLayerEntries, isDataLayerEntryObject, markDataLayerEntryProcessed, trackDataLayerRevenue, trackDataLayerEvent, enqueuePendingDataLayerEvent, drainPendingDataLayerEvents, finishInitializingAssignments, handleDataLayerEvent, recordObserverError } from "./config-runtime";
+import { scheduleDeferredRouteReevaluation, installDataLayerTriggers, experimentsUseSurfaceSignals, rememberExposureDestination, clarityUpgradeSent, clarityTagKey, pushExposureToQueue, emitExposureDestinations, ensureTrackerStarted, exposureAssignmentKey, priceAssignmentAuthorizationKey, isPriceDisplayAssignmentAuthorized, isShippingDisplayAssignmentAuthorized, isOffersDisplayAssignmentAuthorized, giftSyncOptions, assignmentHasRenderableArtifacts, authorizeOffersDisplayAndRender, revokeOffersDisplayAuthorization, exposureEligibleAssignments, isShippingExposureCartEligible, trackViewedAssignmentsAfterShippingEligibility, EMPTY_TARGETING_ATTRIBUTES, TargetingEvaluationPass, activeTargetingEvaluationPass, createTargetingEvaluationPass, targetingAttributesForPass, trackViewedAssignments, sameStringSet, setupGoalTracking, setupHeatmapTracking, cleanupHeatmapTracking, setupReplayTracking, cleanupReplayTracking, setupSemanticTracking, cleanupSemanticTracking, buildExperimentBehaviorEvents, buildPageExitEvents, analyticsTrack, syncLoadDiagnosticsToPerf, updateLoadDiagnostics, resetLoadDiagnostics, queuePerfEvent, RuntimeInstallClaim, RUNTIME_INSTALL_CLAIM_KEY, RUNTIME_INSTALL_CONFLICT_KEY, telemetryLabel, readRuntimeInstallClaim, rememberRuntimeInstallClaim, claimInstallConflictEmission, sdkAttributionData, sendRuntimeEventNow, sendRuntimePerfNow, readDripPerf, markDripPerf, numberPerf, coexistencePerfFields, buildPerfEvent, flushPendingPerf, orderIdentityEndpoint, ORDER_EXPOSURE_STORAGE_KEY, ORDER_EXPOSURE_MAX_ENTRIES, ORDER_EXPOSURE_TTL_MS, StoredOrderExposure, pruneStoredOrderExposures, readStoredOrderExposures, writeStoredOrderExposures, clearIdentityContextCookie, recentIdentityContextExposures, buildIdentityContextCookieValue, generateSessionId, getIdentityContextSessionId, writeIdentityContextCookie, isOffTargetPersistedAssignment, restoreRecordedExposureDedup, rememberOrderExposure, mergedOrderIdentityAssignments, cleanOrderIdentityText, resolveOrderIdentityPlatform, detectOrderIdentity, orderIdentityDedupeKey, scheduleOrderIdentityBeacon, deliveryStatus, queueDeliveryHealthEvent, flushPendingDeliveryHealth, startAnalyticsStage, scheduleAnalyticsStart, startAnalyticsIfReady, getConfigCacheKey, storageAvailable, getConfigCacheTtlMs, configuredStoreOrigins, readCachedExperiments, hashConfigPayload, writeCachedExperiments, withRuntimeSettings, serializeForceMap, getHashId } from "./analytics-runtime";
+import { generateQaSessionId, SHOPIFY_ASSIGNMENT_SYNC_DELAYS_MS, shopifyAssignmentSyncTimers, CommerceOnlyAdoptionState, commercePriceAdoptionState, ensureCommercePriceAdoptionState, currentCommercePriceContext, withCommercePriceAssignments, clearShopifyAssignmentSyncTimers, adoptAuthoritativePriceAssignments, OffersAdoptionPlan, planAuthoritativeOffersAdoption, canAdoptAuthoritativeOffersAssignments, adoptAuthoritativeOffersAssignments, sdkCartMintAllowed, buildSdkCartMintInput, buildScopedCartAttributeSyncInput, buildActiveCartAttributeSyncInput, sdkCartMintSync, syncSdkCartMint, removeSdkCartMintTrigger, onSdkCartMintClick, installSdkCartMintTrigger, HeadlessCartAuthorizationState, headlessCartAuthorizationState, ensureHeadlessCartAuthorizationState, hasChargeAffectingCommerceAssignment, hasActiveAuthorizationPlane, hasActivePriceAuthorizationPlane, hasActiveShippingAuthorizationPlane, hasActiveOffersAuthorizationPlane, hasActiveCommerceAuthorizationPlane, requiresCommerceCohortPin, getChargeAffectingCommerceExperimentIds, isCohortStampedOnCart, syncActiveAssignmentToShopifyCart, configureChargeCorrectnessCartSync, holdoutConfigEpoch, publishAssignmentsToShopify, scheduleShopifyAssignmentSync, variationsAllowed, updateProjectActivationDiagnostics, trackingAllowed, experimentById, targetingLifecycleMode, preservePersistentAssignments, stopAnalyticsStage, canMintVerifiedRedirectCarry, planRedirectAssignment, navigateForRedirectAssignment, RECONCILE_MAX_DRAINS, reevaluateAssignments, reevaluateAssignmentsPass, reapplyQaAssistantForceMap, reconcileForcedUnavailable, __getQaAssistantRuntimeSnapshot, __subscribeQaAssistantRuntime, __forceQaAssistantVariation, __resetQaAssistantForce, clearQaForceFromCurrentUrl, initWithExperiments } from "./activation-runtime";
+import { loadQaToolbar, loadQaAssistant, loadDevtoolsIfEnabled, loadDevtools, init, trackEvent, track, funnelStepStorageKey, shouldTrackFunnelStep, trackStep, trackGoal, setConsent, hold, release, hydrated, recheckPrerequisites, reInit, RevenueEventData, normalizeRevenueCurrency, trackRevenue, flush, getAssignments, buildCurrentCartAttributes, getCartAttributes, getCartMetafields, getCartMetafieldStaleKeys, mergeCartAttributes, normalizedHeadlessCartToken, getSignedCartAttributes, confirmCartAttributesWritten, getExperiments, getGoals, getActiveExperimentIds, getRuntimeValue, getRuntimeTools, buildFlagContext, evaluateFlag, evaluateFlagAssignment, evaluateFlagValue, getDiagnostics, QueueCommand, processCommand, processQueue, installedGlobalApi, createGlobalApi, installGlobalApi } from "./public-api";
+
+
+export type PersistedAssignmentMap = ReturnType<typeof prunePersistedAssignments>;
+export const GLOBAL_PAGE_PREFIX = "\u0001experiment:";
+export const appliedAssignmentsByKey = new Map<string, Assignment>();
+export type ArtifactId = string & { readonly __artifactId: unique symbol };
+export const invalidatedArtifactIds = new Set<ArtifactId>();
+export /**
+ * Per-artifact epochs, keyed exactly like `appliedAssignmentsByKey`: the apply
+ * pass that last wrote each artifact. A deferred continuation in
+ * `applyAssignmentCode` revalidates its own artifact keys against its pass
+ * epoch at resume, so a page-scoped reapply invalidates only the artifacts it
+ * rewrote — an unrelated page's pending external CSS/JS continuation survives.
+ * Teardown deletes the entry, and pass epochs only ever increase, so a
+ * torn-down artifact that is applied again never revives a stale continuation.
+ */
+const artifactEpochs = new Map<string, number>();
+export let applyPassEpoch = 0;
+
+export /** A continuation is current while any artifact it applied still holds its pass epoch. */
+function artifactEpochCurrent(
+  ownerKeys: readonly string[],
+  epoch: number,
+): boolean {
+  return ownerKeys.some((ownerKey) => artifactEpochs.get(ownerKey) === epoch);
+}
+
+export type PageActivationTransition = {
+  pageId: string;
+  mode: PageDeactivationMode;
+  previousActive: boolean;
+  active: boolean;
+  teardown: boolean;
+  reapply: boolean;
+};
+
+export function normalizePageDeactivationMode(
+  rule: PageTargetingRule,
+): PageDeactivationMode {
+  const mode = rule.trigger?.deactivationMode;
+  if (mode === "reset" || mode === "deactivate" || mode === "persistent") return mode;
+  if (mode === "force-reset") return "force_reset";
+  return rule.disabled || rule.trigger?.disabled ? "deactivate" : "reset";
+}
+
+export function effectiveDeactivationMode(
+  experiment: Experiment,
+  rule: PageTargetingRule,
+): PageDeactivationMode {
+  if (
+    rule.trigger &&
+    Object.prototype.hasOwnProperty.call(rule.trigger, "deactivationMode")
+  ) {
+    return normalizePageDeactivationMode(rule);
+  }
+  // Legacy experiments can still store an explicit experiment mode. Keep it
+  // only until every affected Page has a mode and cached configs have expired.
+  return targetingLifecycleMode(experiment);
+}
+
+export function includedPageRules(experiment: Experiment | undefined): PageTargetingRule[] {
+  return (experiment?.targeting?.pageRules ?? []).filter(
+    (rule) => rule.include !== false && Boolean(rule.id),
+  );
+}
+
+export // Page activation must evaluate against the same URL the assignment pass uses:
+// the InitConfig override at init time, the live URL on re-evaluation.
+function currentPageMatchContext(
+  url: string,
+  targetingPass?: TargetingEvaluationPass,
+): {
+  url: string;
+  attributes: Record<string, unknown>;
+} {
+  const sourceAttributes = state.config?.attributes ?? EMPTY_TARGETING_ATTRIBUTES;
+  return {
+    url,
+    attributes: targetingAttributesForPass(
+      targetingPass,
+      sourceAttributes,
+      url,
+      persistentStorageAllowed(),
+    ),
+  };
+}
+
+export function pageActivationDiagnosticRows(
+  options: { includePageNames?: boolean } = {},
+): PageActivationDiagnostic[] {
+  const names = new Map<string, string>();
+  const alwaysEmbeddedPageIds = new Set<string>();
+  for (const experiment of state.config?.experiments ?? []) {
+    for (const rule of experiment.targeting?.pageRules ?? []) {
+      if (rule.id && rule.name) names.set(rule.id, rule.name);
+      if (rule.id && rule.trigger?.alwaysEmbedInSnippet === true) {
+        alwaysEmbeddedPageIds.add(rule.id);
+      }
+    }
+  }
+  return Array.from(state.pageActivation.entries())
+    .filter(([pageId]) => !pageId.startsWith(GLOBAL_PAGE_PREFIX))
+    .map(([pageId, pageState]) => ({
+      pageId,
+      ...(options.includePageNames && names.get(pageId)
+        ? { pageName: names.get(pageId) }
+        : {}),
+      active: pageState.active,
+      appliedArtifactCount: pageState.appliedKeys.size,
+      ...(alwaysEmbeddedPageIds.has(pageId)
+        ? { alwaysEmbedInSnippet: true }
+        : {}),
+      ...(pageState.lastTransitionMode
+        ? { lastTransitionMode: pageState.lastTransitionMode }
+        : {}),
+      ...(pageState.isolationFallback
+        ? { isolationFallback: pageState.isolationFallback }
+        : {}),
+      ...(pageState.isolationFallbackExperimentId
+        ? {
+            isolationFallbackExperimentId:
+              pageState.isolationFallbackExperimentId,
+          }
+        : {}),
+      ...(pageState.triggerDetector
+        ? { triggerDetector: pageState.triggerDetector }
+        : {}),
+      ...(pageState.triggerPollAttempts !== undefined
+        ? { triggerPollAttempts: pageState.triggerPollAttempts }
+        : {}),
+      ...(pageState.triggerOutcome
+        ? { triggerOutcome: pageState.triggerOutcome }
+        : {}),
+      ...(pageState.triggerElapsedMs !== undefined
+        ? { triggerElapsedMs: pageState.triggerElapsedMs }
+        : {}),
+    }))
+    .sort((left, right) => left.pageId.localeCompare(right.pageId));
+}
+
+export function reconcilePageActivation(
+  experiments: Experiment[],
+  url: string,
+  options: {
+    previous?: ReadonlyMap<string, PageActivationRuntimeState>;
+    persistedAssignments?: PersistedAssignmentMap;
+    targetingPass?: TargetingEvaluationPass;
+    pageRuleScope?: PageRuleReconcileScope;
+  } = {},
+): {
+  transitions: PageActivationTransition[];
+  next: Map<string, PageActivationRuntimeState>;
+  pollRules: PageTargetingRule[];
+} {
+  const context = currentPageMatchContext(url, options.targetingPass);
+  const previous = options.previous ?? state.pageActivation;
+  const definitions = new Map<
+    string,
+    { mode: PageDeactivationMode; matched: boolean; evaluate: boolean; scopeOnly?: boolean }
+  >();
+  const pollRules = new Map<string, PageTargetingRule>();
+  for (const experiment of experiments) {
+    const rules = includedPageRules(experiment);
+    const activatableRules = rules.filter(
+      (rule) => !rule.disabled && !rule.trigger?.disabled,
+    );
+    if (rules.length === 0) {
+      const pageId = GLOBAL_PAGE_PREFIX + experiment.id;
+      const shouldEvaluate = !options.pageRuleScope ||
+        options.pageRuleScope.includeImmediate;
+      const hasPersistentAssignment =
+        targetingLifecycleMode(experiment) === "persistent" &&
+        Boolean(
+          options.persistedAssignments &&
+            findPersistedVariation(experiment, options.persistedAssignments),
+        );
+      const hasRedirectCarry = Array.from(
+        state.carryImportedAssignmentKeys,
+      ).some((key) => key.startsWith(experiment.id + ":"));
+      definitions.set(pageId, {
+        // A global entry has no Page rule that can own deactivation behavior.
+        mode: targetingLifecycleMode(experiment),
+        matched: shouldEvaluate
+          ? hasPersistentAssignment ||
+            hasRedirectCarry ||
+            evaluateTargetingGatesDetailed(
+              experiment.targeting,
+              context,
+            ).matched
+          : previous.get(pageId)?.active === true,
+        evaluate: shouldEvaluate,
+      });
+    }
+    for (const rule of activatableRules) {
+      const triggerMode = rule.trigger?.mode ?? "immediate";
+      const shouldEvaluate = !options.pageRuleScope ||
+        (triggerMode === "immediate"
+          ? options.pageRuleScope.includeImmediate
+          : options.pageRuleScope.triggeredPageIds.has(rule.id));
+      const matched = shouldEvaluate
+        ? matchPageTargetingRule(rule, context)
+        : previous.get(rule.id)?.active === true;
+      if (shouldEvaluate) {
+        if (matched) {
+          cancelPageRulePoll(rule.id);
+        } else if (
+          rule.trigger?.pollOnRules === true &&
+          triggerMode === "immediate"
+        ) {
+          // Start after the caller completes teardown. Teardown cancels the
+          // previous retry window and must not cancel this new retry window.
+          pollRules.set(rule.id, rule);
+        }
+      }
+      const existing = definitions.get(rule.id);
+      if (existing) {
+        existing.matched = existing.matched || matched;
+        existing.evaluate = existing.evaluate || shouldEvaluate;
+        if (existing.scopeOnly) {
+          existing.mode = effectiveDeactivationMode(experiment, rule);
+          existing.scopeOnly = false;
+        }
+      } else {
+        definitions.set(rule.id, {
+          mode: effectiveDeactivationMode(experiment, rule),
+          matched,
+          evaluate: shouldEvaluate,
+        });
+      }
+    }
+    const targetingIds = new Set(activatableRules.map((rule) => rule.id));
+    for (const rule of experiment.goalPageRules ?? []) {
+      if (!rule.id || targetingIds.has(rule.id) || definitions.has(rule.id)) continue;
+      const triggerMode = rule.trigger?.mode ?? "immediate";
+      const shouldEvaluate = !options.pageRuleScope ||
+        (triggerMode === "immediate"
+          ? options.pageRuleScope.includeImmediate
+          : options.pageRuleScope.triggeredPageIds.has(rule.id));
+      definitions.set(rule.id, {
+        mode: "reset",
+        matched: shouldEvaluate
+          ? matchPageTargetingRule(rule, context)
+          : previous.get(rule.id)?.active === true,
+        evaluate: shouldEvaluate,
+        scopeOnly: true,
+      });
+    }
+  }
+
+  const transitions: PageActivationTransition[] = [];
+  const next = new Map<string, PageActivationRuntimeState>();
+  for (const [pageId, pageState] of previous) {
+    if (definitions.has(pageId)) continue;
+    if (pageState.scopeOnly) continue;
+    transitions.push({
+      pageId,
+      mode:
+        pageState.configuredMode ??
+        pageState.lastTransitionMode ??
+        "reset",
+      previousActive: pageState.active,
+      active: false,
+      teardown: pageState.active || pageState.appliedKeys.size > 0,
+      reapply: false,
+    });
+  }
+  for (const [pageId, definition] of definitions) {
+    const pageState = previous.get(pageId) ?? {
+      active: false,
+      appliedKeys: new Set<string>(),
+    };
+    const previousActive = pageState.active;
+    if (definition.scopeOnly) {
+      if (
+        !pageState.scopeOnly &&
+        (pageState.active || pageState.appliedKeys.size > 0)
+      ) {
+        transitions.push({
+          pageId,
+          mode:
+            pageState.configuredMode ??
+            pageState.lastTransitionMode ??
+            "reset",
+          previousActive,
+          active: false,
+          teardown: true,
+          reapply: false,
+        });
+      }
+      pageState.active = definition.matched;
+      pageState.scopeOnly = true;
+      pageState.appliedKeys.clear();
+      pageState.configuredMode = undefined;
+      pageState.lastTransitionMode = undefined;
+      pageState.isolationFallback = undefined;
+      pageState.isolationFallbackExperimentId = undefined;
+      next.set(pageId, pageState);
+      continue;
+    }
+    pageState.scopeOnly = false;
+    let active = definition.matched;
+    let teardown = false;
+    let reapply = !previousActive && active;
+
+    if (definition.mode === "persistent") {
+      active = previousActive || definition.matched;
+      reapply = !previousActive && active;
+    } else if (definition.mode === "force_reset" && definition.evaluate) {
+      teardown = previousActive || pageState.appliedKeys.size > 0;
+      active = definition.matched;
+      reapply = active;
+    } else if (previousActive && !definition.matched) {
+      teardown = true;
+    }
+
+    pageState.active = active;
+    pageState.configuredMode = definition.mode;
+    if (
+      active !== previousActive ||
+      (definition.mode === "force_reset" && definition.evaluate)
+    ) {
+      pageState.lastTransitionMode = definition.mode;
+      pageState.isolationFallback = undefined;
+      pageState.isolationFallbackExperimentId = undefined;
+    }
+    next.set(pageId, pageState);
+    transitions.push({
+      pageId,
+      mode: definition.mode,
+      previousActive,
+      active,
+      teardown,
+      reapply,
+    });
+  }
+  return { transitions, next, pollRules: Array.from(pollRules.values()) };
+}
+
+export function cancelPageRulePoll(pageId: string): void {
+  const controller = runtimeSharedState.pageRulePollControllers.get(pageId);
+  if (!controller) return;
+  window.clearInterval(controller.intervalId);
+  runtimeSharedState.pageRulePollControllers.delete(pageId);
+}
+
+export function cancelAllPageRulePolls(): void {
+  for (const pageId of Array.from(runtimeSharedState.pageRulePollControllers.keys())) {
+    cancelPageRulePoll(pageId);
+  }
+}
+
+export function pageRulePollSettings(): {
+  intervalMs: number;
+  windowMs: number;
+} {
+  return {
+    intervalMs: normalizeNumber(
+      state.config?.pageTrigger?.rulePollIntervalMs,
+      PAGE_RULE_POLL_INTERVAL_MS,
+    ),
+    windowMs: normalizeNumber(
+      state.config?.pageTrigger?.rulePollWindowMs,
+      PAGE_RULE_POLL_WINDOW_MS,
+    ),
+  };
+}
+
+export function deactivationModeForTriggeredRule(
+  rule: PageTargetingRule,
+): PageDeactivationMode {
+  for (const experiment of state.config?.experiments ?? []) {
+    const configured = includedPageRules(experiment).find(
+      (candidate) => candidate.id === rule.id,
+    );
+    if (configured) return effectiveDeactivationMode(experiment, configured);
+  }
+  return normalizePageDeactivationMode(rule);
+}
+
+export function reconcileTriggeredPageMatch(
+  rule: PageTargetingRule,
+  matched: boolean,
+  detector?: PageDetectorMode,
+  options: {
+    elapsedMs?: number;
+    fromPoll?: boolean;
+    pollAttempts?: number;
+  } = {},
+): boolean {
+  const pageState = state.pageActivation.get(rule.id) ?? {
+    active: false,
+    appliedKeys: new Set<string>(),
+  };
+  const previousActive = pageState.active;
+  const mode = deactivationModeForTriggeredRule(rule);
+  let active = matched;
+  let teardown = false;
+
+  if (mode === "persistent") {
+    active = previousActive || matched;
+  } else if (mode === "force_reset") {
+    teardown = previousActive || pageState.appliedKeys.size > 0;
+  } else if (previousActive && !matched) {
+    teardown = true;
+  }
+
+  if (teardown) {
+    cancelPageRulePoll(rule.id);
+    teardownTransaction([{ pageId: rule.id, mode }], {
+      goalUrl: typeof location !== "undefined" ? location.href : undefined,
+    });
+  }
+
+  pageState.active = active;
+  pageState.configuredMode = mode;
+  if (detector) pageState.triggerDetector = detector;
+  pageState.triggerPollAttempts = options.pollAttempts ?? 0;
+  pageState.triggerElapsedMs = Math.max(0, Math.round(options.elapsedMs ?? 0));
+  pageState.triggerOutcome = matched ? "activated" : "condition_failed";
+  if (active !== previousActive || mode === "force_reset") {
+    pageState.lastTransitionMode = mode;
+    pageState.isolationFallback = undefined;
+    pageState.isolationFallbackExperimentId = undefined;
+  }
+  state.pageActivation.set(rule.id, pageState);
+
+  const experiments = state.config?.experiments ?? [];
+  syncAssignmentPageActive(state.assignments, experiments);
+  state.lastAssignmentSignature = assignmentSignature(state.assignments);
+  reconcileArtifacts(
+    desiredArtifactSet(state.assignments),
+    typeof location !== "undefined" ? location.href : undefined,
+  );
+  if (matched && state.analyticsStarted && state.config) {
+    trackViewedAssignments(state.config);
+  }
+  notifyQaAssistantRuntimeListeners();
+
+  if (!matched && !options.fromPoll && rule.trigger?.pollOnRules === true) {
+    startPageRulePoll(rule, detector);
+  }
+
+  return active !== previousActive;
+}
+
+export function startPageRulePoll(
+  rule: PageTargetingRule,
+  detector?: PageDetectorMode,
+): void {
+  if (
+    typeof window === "undefined" ||
+    runtimeSharedState.pageRulePollControllers.has(rule.id)
+  ) return;
+  const { intervalMs, windowMs } = pageRulePollSettings();
+  const maxAttempts = Math.max(1, Math.ceil(windowMs / intervalMs));
+  const startedAt = Date.now();
+  let attempts = 0;
+  const intervalId = window.setInterval(() => {
+    attempts += 1;
+    const elapsedMs = Date.now() - startedAt;
+    const pageState = state.pageActivation.get(rule.id);
+    if (elapsedMs > windowMs) {
+      cancelPageRulePoll(rule.id);
+      if (pageState) {
+        pageState.triggerPollAttempts = attempts;
+        pageState.triggerElapsedMs = elapsedMs;
+        pageState.triggerOutcome = "window_expired";
+      }
+      notifyQaAssistantRuntimeListeners();
+      return;
+    }
+    const context = currentPageMatchContext(location.href);
+    const matched = matchPageTargetingRule(rule, context);
+    if (matched) {
+      cancelPageRulePoll(rule.id);
+      reconcileTriggeredPageMatch(rule, true, detector, {
+        elapsedMs,
+        fromPoll: true,
+        pollAttempts: attempts,
+      });
+      reevaluateAssignments("dom", false, false, {
+        triggeredPageIds: new Set([rule.id]),
+        includeImmediate: false,
+      });
+      return;
+    }
+    if (pageState) {
+      pageState.triggerPollAttempts = attempts;
+      pageState.triggerElapsedMs = elapsedMs;
+    }
+    if (attempts >= maxAttempts) {
+      cancelPageRulePoll(rule.id);
+      if (pageState) pageState.triggerOutcome = "window_expired";
+      notifyQaAssistantRuntimeListeners();
+    }
+  }, intervalMs);
+  runtimeSharedState.pageRulePollControllers.set(rule.id, { intervalId, startedAt });
+}
+
+export function firePageDetector(
+  detector: PageDetectorMode,
+  resolvedUrl: string,
+): Set<string> {
+  const rules = runtimeSharedState.pageDetectorRules.get(detector) ?? [];
+  const triggeredPageIds = new Set<string>();
+  for (const rule of rules) {
+    if (detector !== "dom" && runtimeSharedState.pageDetectorLastUrls.get(rule.id) === resolvedUrl) {
+      continue;
+    }
+    if (detector !== "dom") runtimeSharedState.pageDetectorLastUrls.set(rule.id, resolvedUrl);
+    triggeredPageIds.add(rule.id);
+    cancelPageRulePoll(rule.id);
+    const matched = matchPageTargetingRule(
+      rule,
+      currentPageMatchContext(resolvedUrl),
+    );
+    reconcileTriggeredPageMatch(rule, matched, detector);
+  }
+  return triggeredPageIds;
+}
+
+export function activePageIds(): Set<string> {
+  return new Set(
+    Array.from(state.pageActivation.entries())
+      .filter(
+        ([pageId, pageState]) =>
+          !pageId.startsWith(GLOBAL_PAGE_PREFIX) && pageState.active,
+      )
+      .map(([pageId]) => pageId),
+  );
+}
+
+export function experimentHasActivePage(experiment: Experiment | undefined): boolean {
+  if (!experiment) return false;
+  const rules = includedPageRules(experiment);
+  if (!rules.length) {
+    return state.pageActivation.get(GLOBAL_PAGE_PREFIX + experiment.id)?.active === true;
+  }
+  return rules.some(
+    (rule) =>
+      !rule.disabled &&
+      !rule.trigger?.disabled &&
+      state.pageActivation.get(rule.id)?.active === true,
+  );
+}
+
+export function syncAssignmentPageActive(
+  assignments: Assignment[],
+  experiments: Experiment[],
+): Assignment[] {
+  const byId = experimentById(experiments);
+  for (const assignment of assignments) {
+    assignment.pageActive = experimentHasActivePage(
+      byId.get(assignment.experimentId),
+    );
+  }
+  return assignments;
+}
+
+export function assignmentPageIds(assignment: Assignment): string[] {
+  const experiment = state.config?.experiments?.find(
+    (candidate) => candidate.id === assignment.experimentId,
+  );
+  const rules = includedPageRules(experiment);
+  if (!rules.length) return [GLOBAL_PAGE_PREFIX + assignment.experimentId];
+  return Array.from(
+    new Set(
+      rules
+        .filter(
+          (rule) =>
+            !rule.disabled &&
+            !rule.trigger?.disabled &&
+            state.pageActivation.get(rule.id)?.active === true,
+        )
+        .map((rule) => rule.id),
+    ),
+  );
+}
+
+export function stableArtifactJson(value: unknown): string {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableArtifactJson).join(",")}]`;
+  }
+  const record = value as Record<string, unknown>;
+  return `{${Object.keys(record)
+    .filter((key) => record[key] !== undefined)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${stableArtifactJson(record[key])}`)
+    .join(",")}}`;
+}
+
+export function artifactContentHash(assignment: Assignment): string {
+  const content = stableArtifactJson({
+    mutations: assignment.mutations,
+    css: assignment.css ?? null,
+    experimentCss: assignment.experimentCss ?? null,
+    js: assignment.js ?? null,
+    experimentJs: assignment.experimentJs ?? null,
+    externalCssUrl: assignment.externalCssUrl ?? null,
+    externalJsUrl: assignment.externalJsUrl ?? null,
+  });
+  let first = 0x811c9dc5;
+  let second = 0x9e3779b9;
+  for (let index = 0; index < content.length; index += 1) {
+    const code = content.charCodeAt(index);
+    first = Math.imul(first ^ code, 0x01000193);
+    second = Math.imul(second ^ code, 0x85ebca6b);
+  }
+  return (first >>> 0).toString(16).padStart(8, "0") +
+    (second >>> 0).toString(16).padStart(8, "0");
+}
+
+export function baseArtifactApplicationKey(assignment: Assignment): ArtifactId {
+  return `${assignment.experimentId}\u0000${assignment.variationId}\u0000${assignment.activeUrlBlockId ?? "flat"}\u0000${artifactContentHash(assignment)}` as ArtifactId;
+}
+
+export function artifactApplicationKey(
+  assignment: Assignment,
+  pageId: string,
+): string {
+  return `${pageId}\u0000${baseArtifactApplicationKey(assignment)}`;
+}
+
+export function artifactIdFromApplicationKey(applicationKey: string): ArtifactId {
+  const separator = applicationKey.indexOf("\u0000");
+  return (separator < 0 ? applicationKey : applicationKey.slice(separator + 1)) as ArtifactId;
+}
+
+export function assignmentRuntimeKeys(assignments: Assignment[]): Set<string> {
+  return new Set(assignments.map((assignment) => [
+    assignment.experimentId,
+    assignment.variationId,
+    assignment.activeUrlBlockId ?? "flat",
+    assignment.pageActive ? "active" : "inactive",
+  ].join("\u0000")));
+}
+
+export function artifactOwnerId(applicationKey: string): string {
+  const separator = applicationKey.indexOf("\u0000");
+  return separator < 0 ? applicationKey : applicationKey.slice(0, separator);
+}
+
+export function redirectCarryAssignmentKey(
+  experimentId: string,
+  variationId: string,
+  epoch: number,
+): string {
+  return `${experimentId}:${variationId}:${epoch}`;
+}
+
+export function shouldPreserveOffTargetRedirectAssignment(
+  assignment: Assignment,
+): boolean {
+  return isAssignmentArtifactInactive(assignment) ||
+    state.carryImportedAssignmentKeys.has(
+    redirectCarryAssignmentKey(
+      assignment.experimentId,
+      assignment.variationId,
+      Math.max(
+        1,
+        Number.isSafeInteger(assignment.assignmentEpoch)
+          ? assignment.assignmentEpoch!
+          : 1,
+      ),
+    ),
+  );
+}
+
+export function isAssignmentArtifactInactive(
+  assignment: Assignment,
+): boolean {
+  if (!renderable(assignment)) return true;
+  if (!assignment.redirectUrl) return false;
+  if (typeof location === "undefined") return false;
+  const destination = buildRedirectDestination(
+    location.href,
+    assignment.redirectUrl,
+    assignment,
+    "",
+    undefined,
+    false,
+  );
+  if (destination && isRedirectLoop(location.href, destination)) return true;
+  return false;
+}
+
+export /** Page plane: this assignment may drive DOM, CSS, JS, and commerce display. */
+function renderable(assignment: Assignment): boolean {
+  return assignment.pageActive &&
+    !state.contaminatedAssignmentKeys.has(exposureAssignmentKey(assignment));
+}
+
+export /**
+ * Exposure plane: rendered assignments become analytics-visible only after
+ * mutation delivery resolves. This predicate is also the shared identity
+ * gate for pageviews, page exits, and generic analytics events.
+ */
+function exposable(assignment: Assignment): boolean {
+  return renderable(assignment) &&
+    !state.mutationPendingAssignmentKeys.has(exposureAssignmentKey(assignment));
+}
+
+export /**
+ * Goal/charge plane: identity survives page deactivation, but never precedes
+ * mutation delivery. A mutation-bearing treatment becomes attributable only
+ * after its delivery tracker resolves cleanly.
+ */
+function attributable(assignment: Assignment): boolean {
+  const key = exposureAssignmentKey(assignment);
+  return assignment.experimentId.length > 0 && assignment.variationId.length > 0 &&
+    !state.mutationPendingAssignmentKeys.has(key) &&
+    !state.contaminatedAssignmentKeys.has(key);
+}
+
+export function recordAttributableAssignments(assignments: Assignment[]): void {
+  for (const assignment of assignments) {
+    if (attributable(assignment)) {
+      // Copy: page recompute mutates live Assignment objects (pageActive) and
+      // the ledger must keep the snapshot that earned attribution.
+      runtimeSharedState.attributionLedger.set(assignment.experimentId, { ...assignment });
+    }
+  }
+}
+
+export function attributionLedgerAssignments(): Assignment[] {
+  const currentExperimentIds = new Set(
+    state.assignments.map((assignment) => assignment.experimentId),
+  );
+  const assignments: Assignment[] = [];
+  for (const assignment of runtimeSharedState.attributionLedger.values()) {
+    const key = exposureAssignmentKey(assignment);
+    if (state.contaminatedAssignmentKeys.has(key)) {
+      runtimeSharedState.attributionLedger.delete(assignment.experimentId);
+      continue;
+    }
+    if (
+      state.mutationPendingAssignmentKeys.has(key) ||
+      currentExperimentIds.has(assignment.experimentId)
+    ) continue;
+    assignments.push(assignment);
+  }
+  return assignments;
+}
+
+export function artifactRenderableAssignments(
+  assignments: Assignment[],
+): Assignment[] {
+  return assignments
+    .filter(renderable)
+    .filter((assignment) => !isAssignmentArtifactInactive(assignment));
+}
+
+export /**
+ * Render plane: `state.assignments` intersected with `state.pageActivation`.
+ * Single source for every global runtime that renders, observes, or wires a
+ * treatment, so no caller can hand a subsystem a hand-picked subset.
+ */
+function activeRenderableAssignments(): Assignment[] {
+  return artifactRenderableAssignments(state.assignments);
+}
+
+export /**
+ * Charge plane: deliberately page-independent. Deactivating a page stops
+ * rendering, but Shopify still charges this cart's pinned commerce arms, so
+ * the cohort stamp and its cart listener must outlive a display teardown.
+ */
+function chargeAffectingAssignments(): Assignment[] {
+  return withCommercePriceAssignments(state.assignments).filter(attributable);
+}
+
+export function loadPersistedAssignments(
+  experiments: Experiment[],
+): PersistedAssignmentMap | undefined {
+  if (!persistentStorageAllowed() || state.qaMode || state.screenshotMode) {
+    return undefined;
+  }
+  return prunePersistedAssignments(experiments);
+}
+
+export function buildPersistedAssignmentResult(
+  experiment: Experiment,
+  persisted: NonNullable<ReturnType<typeof findPersistedVariation>>,
+  hashId: string,
+  gates: ActivationGateDiagnostic[],
+  targetingConditions: ConditionDiagnostic[],
+  url: string,
+  reason: "persisted_assignment" | "persisted_assignment_off_target",
+): { assignment: Assignment; diagnostic: ExperimentActivationDiagnostic } {
+  const assignment = buildAssignment(
+    experiment,
+    persisted.variation,
+    persisted.index,
+    hashId,
+    url,
+  );
+  if (reason === "persisted_assignment_off_target") {
+    assignment.pageActive = experimentHasActivePage(experiment);
+  }
+  gates.push(
+    {
+      id: "traffic",
+      label: "Traffic allocation",
+      status: "skipped",
+      reason: "persisted_assignment",
+    },
+    {
+      id: "assignment",
+      label: "Variation assignment",
+      status: "passed",
+      reason,
+      detail: {
+        variationId: persisted.variation.id,
+        index: persisted.index,
+        epoch: persisted.record.epoch,
+      },
+    },
+  );
+  for (const gate of gates.slice(-2)) __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gate);
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Reused persisted variation ${persisted.variation.id}`, {
+    experimentId: experiment.id,
+    index: persisted.index,
+    epoch: persisted.record.epoch,
+    offTarget: reason === "persisted_assignment_off_target",
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: persisted → variation ${persisted.index}`, {
+    variationId: persisted.variation.id,
+    epoch: persisted.record.epoch,
+    offTarget: reason === "persisted_assignment_off_target",
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: persisted → var ${persisted.index}`, {
+    variationId: persisted.variation.id,
+    epoch: persisted.record.epoch,
+    offTarget: reason === "persisted_assignment_off_target",
+  });
+  return {
+    assignment,
+    diagnostic: experimentDiagnostic(
+      experiment,
+      gates,
+      assignment,
+      reason,
+      false,
+      targetingConditions,
+    ),
+  };
+}
+
+export function withAssignmentEpochData(
+  data: Record<string, unknown> | undefined,
+  experimentId?: string,
+  variationId?: string,
+): Record<string, unknown> | undefined {
+  if (!experimentId || !variationId) return data;
+  const assignment = state.assignments.find(
+    (item) =>
+      item.experimentId === experimentId && item.variationId === variationId,
+  );
+  if (!assignment?.assignmentEpoch) return data;
+  if (assignment.kind && assignment.kind !== "experiment") return data;
+  return { ...(data ?? {}), assignment_epoch: assignment.assignmentEpoch };
+}
+
+export function usesStickyAssignmentPersistence(experiment: Experiment): boolean {
+  return !experiment.kind || experiment.kind === "experiment";
+}
+
+export function persistActiveExperimentAssignments(experiments: Experiment[]): void {
+  if (!persistentStorageAllowed()) return;
+  // QA traffic must never write to or read from a real visitor's sticky
+  // bucket; screenshot mode is short-circuited earlier.
+  if (state.qaMode) return;
+  const byId = experimentById(experiments);
+  for (const assignment of state.assignments) {
+    // Off-target restores already came from this exact validated store record.
+    // Keep their original assignedAt while on-target revisits refresh it.
+    if (isOffTargetPersistedAssignment(assignment)) continue;
+    if (assignment.kind && assignment.kind !== "experiment") continue;
+    if (state.forceMap?.[assignment.experimentId]) continue;
+    const experiment = byId.get(assignment.experimentId);
+    if (!experiment || !usesStickyAssignmentPersistence(experiment)) continue;
+    const variationExists = experiment.variations.some(
+      (variation) => variation.id === assignment.variationId,
+    );
+    if (!variationExists) continue;
+    persistAssignmentForExperiment(experiment, assignment.variationId);
+  }
+}
+
+export function experimentDiagnostic(
+  experiment: Experiment,
+  gates: ActivationGateDiagnostic[],
+  assignment: Assignment | null,
+  reason?: string,
+  forced = false,
+  targetingConditions?: ConditionDiagnostic[],
+): ExperimentActivationDiagnostic {
+  const failed = gates.find((gate) => gate.status === "failed");
+  return {
+    experimentId: experiment.id,
+    experimentName: experiment.name,
+    status: assignment ? "passed" : "failed",
+    reason: reason ?? failed?.reason,
+    assignedVariationId: assignment?.variationId,
+    assignedVariationIndex: assignment?.index,
+    forced,
+    gates,
+    ...(targetingConditions ? { targetingConditions } : {}),
+  };
+}
+
+
+export function evaluateExperimentDetailed(
+  experiment: Experiment,
+  ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+    storeOrigin?: string | string[];
+    persistedAssignments?: PersistedAssignmentMap;
+    holdout?: { enabled?: boolean; percentage?: number };
+  },
+): { assignment: Assignment | null; diagnostic: ExperimentActivationDiagnostic } {
+  const gates: ActivationGateDiagnostic[] = [];
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Initiated experiment ${traceName(experiment.id, experiment.name)}`, {
+    kind: experiment.kind ?? "experiment",
+    status: experiment.status ?? "running",
+    variations: experiment.variations.length,
+  });
+
+  if (!experiment.variations.length) {
+    gates.push({ id: "assignment", label: "Variation assignment", status: "failed", reason: "no_variations" });
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: skip (no variations)`);
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: skip (no variations)`);
+    return { assignment: null, diagnostic: experimentDiagnostic(experiment, gates, null, "no_variations") };
+  }
+
+  const forcedVarId = state.forceMap?.[experiment.id];
+  const forcedIdx = forcedVarId
+    ? experiment.variations.findIndex((v) => v.id === forcedVarId)
+    : -1;
+  const forcedVariation = forcedIdx >= 0 ? experiment.variations[forcedIdx] : null;
+
+  const statusOk = isExperimentServable(experiment, { qaMode: state.qaMode || state.screenshotMode, environment: state.config?.environments?.activeKey || "production" });
+  gates.push({
+    id: "environment",
+    label: "Experiment status",
+    status: forcedVariation ? "skipped" : statusOk ? "passed" : "failed",
+    reason: forcedVariation ? "forced_variation" : statusOk ? "running" : `status_${experiment.status}`,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gates[gates.length - 1]);
+  if ((!forcedVariation || experiment.runtime_disabled === true) && !statusOk) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: skip (status=${experiment.status})`);
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: skip (status=${experiment.status})`);
+    return { assignment: null, diagnostic: experimentDiagnostic(experiment, gates, null, `status_${experiment.status}`) };
+  }
+
+  const weekdayAllowed = !weekdayScheduleBlocksDelivery(
+    experiment.weekdaySchedule,
+    new Date(),
+  );
+  gates.push({
+    id: "weekday",
+    label: "Weekday schedule",
+    status: forcedVariation ? "skipped" : weekdayAllowed ? "passed" : "failed",
+    reason: forcedVariation
+      ? "forced_variation"
+      : weekdayAllowed
+        ? "active_weekday"
+        : "excluded_weekday",
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gates[gates.length - 1]);
+  if (!forcedVariation && !weekdayAllowed) {
+    return {
+      assignment: null,
+      diagnostic: experimentDiagnostic(
+        experiment,
+        gates,
+        null,
+        "excluded_weekday",
+      ),
+    };
+  }
+
+  const hashId = getHashId(experiment, ctx.userId, ctx.attributes);
+  const persisted =
+    ctx.persistedAssignments && usesStickyAssignmentPersistence(experiment)
+      ? findPersistedVariation(experiment, ctx.persistedAssignments)
+      : null;
+  const carryImportedDestination =
+    persisted &&
+    experiment.experimentType === "redirect" &&
+    state.carryImportedAssignmentKeys.has(
+      redirectCarryAssignmentKey(
+        experiment.id,
+        persisted.variation.id,
+        persisted.record.epoch,
+      ),
+    ) &&
+    (() => {
+      if (!persisted.variation.redirectUrl) return false;
+      const destination = buildRedirectDestination(
+        ctx.url,
+        persisted.variation.redirectUrl,
+        {
+          experimentId: experiment.id,
+          variationId: persisted.variation.id,
+          assignmentEpoch: persisted.record.epoch,
+        },
+        "",
+        undefined,
+        false,
+      );
+      return Boolean(destination && isRedirectLoop(ctx.url, destination));
+    })();
+  if (carryImportedDestination) {
+    // The signed carry proves that the visitor qualified on the source page.
+    // Destination hosts can lack the source's segment, attribute, or DOM
+    // signals, so rechecking any targeting gate here would discard a verified
+    // cross-origin assignment. Ordinary same-origin sticky assignments do not
+    // receive this bypass and remain subject to the audience-only recheck.
+    return buildPersistedAssignmentResult(
+      experiment,
+      persisted,
+      hashId,
+      gates,
+      [],
+      ctx.url,
+      "persisted_assignment_off_target",
+    );
+  }
+
+  const targeting = evaluateTargetingGatesDetailed(experiment.targeting, {
+    url: ctx.url,
+    attributes: ctx.attributes,
+    hostAgnosticIncludeOrigin:
+      experiment.experimentType === "redirect"
+        ? ctx.storeOrigin
+        : undefined,
+  });
+  gates.push(...targeting.gates);
+  for (const gate of targeting.gates) __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gate);
+  let forcedOffTarget = false;
+  if (!targeting.matched) {
+    const pageMismatch = targeting.gates.some(
+      (gate) => gate.id === "page" && gate.status === "failed",
+    );
+    const previewForceOffTarget = Boolean(
+      forcedVariation && (state.qaMode || state.screenshotMode) && pageMismatch,
+    );
+    const otherwiseEligible = (persisted || previewForceOffTarget) && pageMismatch
+      ? evaluateTargetingGatesDetailed(
+          {
+            ...experiment.targeting,
+            url: [],
+            pageRules: [],
+            // Legacy experiments carry URL rules in `rules`; blank them too so
+            // this recheck is audience-only (see normalizeRuntimeUrlRules).
+            rules: [],
+          } as Targeting,
+          {
+            url: ctx.url,
+            attributes: ctx.attributes,
+            hostAgnosticIncludeOrigin:
+              experiment.experimentType === "redirect"
+                ? ctx.storeOrigin
+                : undefined,
+          },
+        ).matched
+      : false;
+    if (previewForceOffTarget && otherwiseEligible) {
+      forcedOffTarget = true;
+    } else if (persisted && otherwiseEligible) {
+      return buildPersistedAssignmentResult(
+        experiment,
+        persisted,
+        hashId,
+        gates,
+        targeting.conditions,
+        ctx.url,
+        "persisted_assignment_off_target",
+      );
+    }
+    if (!forcedOffTarget) {
+      const reason = targeting.gates.find((gate) => gate.status === "failed")?.reason ?? "targeting_mismatch";
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: skip (targeting mismatch)`);
+      __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: skip (targeting mismatch)`);
+      return { assignment: null, diagnostic: experimentDiagnostic(experiment, gates, null, reason, false, targeting.conditions) };
+    }
+  }
+
+  if (forcedVariation) {
+    const assignment = buildAssignment(experiment, forcedVariation, forcedIdx, ctx.userId, ctx.url);
+    if (forcedOffTarget) assignment.pageActive = false;
+    gates.push(
+      { id: "traffic", label: "Traffic allocation", status: "skipped", reason: "forced_variation" },
+      { id: "assignment", label: "Variation assignment", status: "passed", reason: "forced_variation" },
+    );
+    for (const gate of gates.slice(-2)) __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gate);
+    __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Initiated variation ${forcedVarId}`, {
+      experimentId: experiment.id,
+      index: forcedIdx,
+      forced: true,
+    });
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: FORCED → variation ${forcedIdx}`, { variationId: forcedVarId });
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: FORCED → var ${forcedIdx}`, { variationId: forcedVarId });
+    return { assignment, diagnostic: experimentDiagnostic(experiment, gates, assignment, "forced_variation", true, targeting.conditions) };
+  }
+  if (persisted) {
+    return buildPersistedAssignmentResult(
+      experiment,
+      persisted,
+      hashId,
+      gates,
+      targeting.conditions,
+      ctx.url,
+      "persisted_assignment",
+    );
+  }
+
+  const predecidedVariationId = runtimeSharedState.initialPredecidedByExperiment?.get(experiment.id);
+  const predecidedIndex = predecidedVariationId
+    ? experiment.variations.findIndex((variation) => variation.id === predecidedVariationId)
+    : -1;
+  if (predecidedIndex >= 0) {
+    const assignment = buildAssignment(
+      experiment,
+      experiment.variations[predecidedIndex],
+      predecidedIndex,
+      hashId,
+      ctx.url,
+    );
+    gates.push(
+      { id: "traffic", label: "Traffic allocation", status: "skipped", reason: "persisted_assignment" },
+      { id: "assignment", label: "Variation assignment", status: "passed", reason: "persisted_assignment", detail: { variationId: predecidedVariationId, index: predecidedIndex } },
+    );
+    return { assignment, diagnostic: experimentDiagnostic(experiment, gates, assignment, "persisted_assignment", false, targeting.conditions) };
+  }
+  const hashValue = hashToFloat(experiment.id, hashId);
+  const inAllocation = inTrafficAllocation(hashValue, experiment.trafficAllocation ?? 1);
+  gates.push({
+    id: "traffic",
+    label: "Traffic allocation",
+    status: inAllocation ? "passed" : "failed",
+    reason: inAllocation ? "included" : "outside_allocation",
+    detail: { hashValue, allocation: experiment.trafficAllocation ?? 1 },
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gates[gates.length - 1]);
+  if (!inAllocation) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: skip (outside traffic allocation)`, { hashValue, allocation: experiment.trafficAllocation });
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: skip (traffic allocation)`, { hashValue, allocation: experiment.trafficAllocation });
+    return { assignment: null, diagnostic: experimentDiagnostic(experiment, gates, null, "outside_allocation", false, targeting.conditions) };
+  }
+
+  const assignment = decideAssignments({
+        experiments: [experiment],
+        holdout: ctx.holdout,
+        visitorId: hashId,
+        storedAssignments: {},
+        now: Date.now(),
+        url: ctx.url,
+      })[0];
+  if (!assignment) {
+    gates.push({ id: "assignment", label: "Variation assignment", status: "failed", reason: "invalid_weighting" });
+    return { assignment: null, diagnostic: experimentDiagnostic(experiment, gates, null, "invalid_weighting", false, targeting.conditions) };
+  }
+
+  const variation = experiment.variations[assignment.index];
+  if (persistentStorageAllowed() && !state.qaMode && usesStickyAssignmentPersistence(experiment)) {
+    persistAssignmentForExperiment(experiment, variation.id);
+  }
+  gates.push({
+    id: "assignment",
+    label: "Variation assignment",
+    status: "passed",
+    reason: "assigned",
+    detail: { variationId: variation.id, index: assignment.index },
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceGate(experiment, gates[gates.length - 1]);
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Initiated variation ${variation.id}`, {
+    experimentId: experiment.id,
+    index: assignment.index,
+    hashValue,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `${experiment.id}: assigned → variation ${assignment.index}`, { variationId: variation.id, hashValue });
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("eval", `${experiment.id}: → var ${assignment.index} (${variation.id})`, { variationId: variation.id, hashValue });
+  return { assignment, diagnostic: experimentDiagnostic(experiment, gates, assignment, "assigned", false, targeting.conditions) };
+}
+
+export function evaluateExperiment(
+  experiment: Experiment,
+  ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+    storeOrigin?: string | string[];
+    persistedAssignments?: PersistedAssignmentMap;
+  },
+): Assignment | null {
+  return evaluateExperimentDetailed(experiment, ctx).assignment;
+}
+
+export function stoppedPersonalizationDiagnostic(
+  diagnostic: ExperimentActivationDiagnostic,
+): ExperimentActivationDiagnostic {
+  const { assignedVariationId: _assignedVariationId, assignedVariationIndex: _assignedVariationIndex, ...rest } = diagnostic;
+  return {
+    ...rest,
+    status: "failed",
+    reason: "personalization_stopped_after_prior_match",
+    gates: [
+      ...diagnostic.gates,
+      {
+        id: "personalization_priority",
+        label: "Personalization priority",
+        status: "failed",
+        reason: "stopped_after_prior_match",
+      },
+    ],
+  };
+}
+
+export function enforcePersonalizationStopAfterMatch(
+  assignments: Assignment[],
+  diagnostics?: ExperimentActivationDiagnostic[],
+): { assignments: Assignment[]; diagnostics?: ExperimentActivationDiagnostic[] } {
+  const stoppedKeys = new Set<string>();
+  const suppressedExperimentIds = new Set<string>();
+  const filtered: Assignment[] = [];
+
+  for (const assignment of assignments) {
+    const key = assignment.personalization?.key;
+    if (key && stoppedKeys.has(key)) {
+      suppressedExperimentIds.add(assignment.experimentId);
+      continue;
+    }
+    filtered.push(assignment);
+    if (key && assignment.personalization?.stopAfterMatch !== false) {
+      stoppedKeys.add(key);
+    }
+  }
+
+  if (!diagnostics || suppressedExperimentIds.size === 0) {
+    return { assignments: filtered, diagnostics };
+  }
+
+  return {
+    assignments: filtered,
+    diagnostics: diagnostics.map((diagnostic) =>
+      suppressedExperimentIds.has(diagnostic.experimentId)
+        ? stoppedPersonalizationDiagnostic(diagnostic)
+        : diagnostic
+    ),
+  };
+}
+
+export function excludedByGroupDiagnostic(
+  diagnostic: ExperimentActivationDiagnostic,
+  decision: ExclusionGroupDecision,
+): ExperimentActivationDiagnostic {
+  const { assignedVariationId: _assignedVariationId, assignedVariationIndex: _assignedVariationIndex, ...rest } = diagnostic;
+  const reason = decision.sticky
+    ? "exclusion_group_sticky_other"
+    : "exclusion_group_overlap_lost";
+  return {
+    ...rest,
+    status: "failed",
+    reason,
+    gates: [
+      ...diagnostic.gates,
+      {
+        id: "exclusion_group",
+        label: "Exclusion group",
+        status: "failed",
+        reason,
+        detail: {
+          groupId: decision.groupId,
+          winnerExperimentId: decision.winnerExperimentId,
+        },
+      },
+    ],
+  };
+}
+
+export function keptByGroupDiagnostic(
+  diagnostic: ExperimentActivationDiagnostic,
+  reason: "exclusion_group_no_overlap" | "exclusion_group_overlap_winner" | "exclusion_group_sticky_winner",
+  detail: { groupId: string; conflictingExperimentIds: string[] },
+): ExperimentActivationDiagnostic {
+  return {
+    ...diagnostic,
+    gates: [
+      ...diagnostic.gates,
+      {
+        id: "exclusion_group",
+        label: "Exclusion group",
+        status: "passed",
+        reason,
+        detail,
+      },
+    ],
+  };
+}
+
+export function applyExclusionAndPersonalization(
+  assignments: Assignment[],
+  context: {
+    userId: string;
+    exclusionGroups?: ExclusionGroupConfig[];
+    storedGroupSelections?: CompactGroupSelections;
+  },
+  diagnostics?: ExperimentActivationDiagnostic[],
+): {
+  assignments: Assignment[];
+  diagnostics?: ExperimentActivationDiagnostic[];
+  decisions: ExclusionGroupDecision[];
+} {
+  const bootstrapStore = context.storedGroupSelections
+    ? {
+        read: (groupId: string) => {
+          const value = context.storedGroupSelections?.[groupId];
+          return value ? { experimentId: value[0], epoch: value[1] } : null;
+        },
+        write: (groupId: string, selection: PersistedGroupSelection) =>
+          browserGroupStickyStore.write(groupId, selection),
+      }
+    : undefined;
+  const { assignments: afterGroups, decisions } = resolveExclusionGroups(
+    assignments,
+    context.exclusionGroups,
+    {
+      userId: context.userId,
+      forcedExperimentIds: state.forceMap ? Object.keys(state.forceMap) : [],
+      persist: persistentStorageAllowed() && !state.qaMode,
+      store: bootstrapStore,
+    },
+  );
+
+  let nextDiagnostics = diagnostics;
+  if (diagnostics && context.exclusionGroups?.length) {
+    const suppressed = new Map<string, ExclusionGroupDecision>();
+    const decisionsByWinner = new Map<string, ExclusionGroupDecision>();
+    for (const decision of decisions) {
+      if (decision.winnerExperimentId) {
+        decisionsByWinner.set(decision.winnerExperimentId, decision);
+      }
+      for (const experimentId of decision.suppressedExperimentIds) {
+        suppressed.set(experimentId, decision);
+      }
+    }
+    const provisionalIds = new Set(assignments.map((assignment) => assignment.experimentId));
+    const forcedIds = new Set(state.forceMap ? Object.keys(state.forceMap) : []);
+    nextDiagnostics = diagnostics.map((diagnostic) => {
+      const losingDecision = suppressed.get(diagnostic.experimentId);
+      if (losingDecision) return excludedByGroupDiagnostic(diagnostic, losingDecision);
+
+      const winningDecision = decisionsByWinner.get(diagnostic.experimentId);
+      if (winningDecision) {
+        return keptByGroupDiagnostic(
+          diagnostic,
+          winningDecision.sticky ? "exclusion_group_sticky_winner" : "exclusion_group_overlap_winner",
+          {
+            groupId: winningDecision.groupId,
+            conflictingExperimentIds: winningDecision.conflictingExperimentIds,
+          },
+        );
+      }
+
+      const group = context.exclusionGroups?.find((candidate) =>
+        candidate.members.some((member) => member.experimentId === diagnostic.experimentId)
+      );
+      if (!group || !provisionalIds.has(diagnostic.experimentId) || forcedIds.has(diagnostic.experimentId)) {
+        return diagnostic;
+      }
+      const eligibleIds = group.members
+        .map((member) => member.experimentId)
+        .filter((experimentId) => provisionalIds.has(experimentId) && !forcedIds.has(experimentId));
+      return eligibleIds.length === 1
+        ? keptByGroupDiagnostic(diagnostic, "exclusion_group_no_overlap", {
+            groupId: group.id,
+            conflictingExperimentIds: eligibleIds,
+          })
+        : diagnostic;
+    });
+  }
+
+  const personalization = enforcePersonalizationStopAfterMatch(afterGroups, nextDiagnostics);
+  return {
+    assignments: personalization.assignments,
+    diagnostics: personalization.diagnostics ?? nextDiagnostics,
+    decisions,
+  };
+}
+
+export function evaluate(
+  experiments: Experiment[],
+  context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+    persistSignals?: boolean;
+    storeOrigin?: string | string[];
+    exclusionGroups?: ExclusionGroupConfig[];
+  },
+): Assignment[] {
+  const url = context?.url ?? location.href;
+  const attributes = buildTargetingAttributes(context?.attributes ?? {}, url, {
+    persistSignals: context?.persistSignals,
+  });
+  const userId = getUserId(context?.userId);
+  const assignments: Assignment[] = [];
+  const persistedAssignments = loadPersistedAssignments(experiments);
+  for (const experiment of experiments) {
+    const assignment = evaluateExperiment(experiment, {
+      url,
+      attributes,
+      userId,
+      storeOrigin: context?.storeOrigin,
+      persistedAssignments,
+    });
+    if (assignment) assignments.push(assignment);
+  }
+  return applyExclusionAndPersonalization(assignments, {
+    userId,
+    exclusionGroups: context?.exclusionGroups,
+  }).assignments;
+}
+
+export function evaluateWithDiagnostics(
+  experiments: Experiment[],
+  context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+    persistSignals?: boolean;
+    storeOrigin?: string | string[];
+    exclusionGroups?: ExclusionGroupConfig[];
+    storedGroupSelections?: CompactGroupSelections;
+    persistedAssignments?: PersistedAssignmentMap | null;
+    holdout?: { enabled?: boolean; percentage?: number };
+    targetingPass?: TargetingEvaluationPass;
+  },
+): { assignments: Assignment[]; diagnostics: ExperimentActivationDiagnostic[] } {
+  const url = context?.url ?? location.href;
+  const sourceAttributes = context?.attributes ?? EMPTY_TARGETING_ATTRIBUTES;
+  const persistSignals = context?.persistSignals !== false;
+  const attributes = targetingAttributesForPass(
+    context?.targetingPass,
+    sourceAttributes,
+    url,
+    persistSignals,
+  );
+  const userId = getUserId(context?.userId);
+  const assignments: Assignment[] = [];
+  const diagnostics: ExperimentActivationDiagnostic[] = [];
+  const persistedAssignments = context && "persistedAssignments" in context
+    ? context.persistedAssignments ?? undefined
+    : loadPersistedAssignments(experiments);
+  for (const experiment of experiments) {
+    const result = evaluateExperimentDetailed(experiment, {
+      url,
+      attributes,
+      userId,
+      storeOrigin: context?.storeOrigin,
+      persistedAssignments,
+      holdout: context?.holdout,
+    });
+    diagnostics.push(result.diagnostic);
+    if (result.assignment) assignments.push(result.assignment);
+  }
+  const resolved = applyExclusionAndPersonalization(
+    assignments,
+    { userId, exclusionGroups: context?.exclusionGroups, storedGroupSelections: context?.storedGroupSelections },
+    diagnostics,
+  );
+  return {
+    assignments: syncAssignmentPageActive(resolved.assignments, experiments),
+    diagnostics: resolved.diagnostics ?? diagnostics,
+  };
+}
+
+export function evaluateEdgeRuntimeAssignments(
+  experiments: Experiment[],
+  context: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+  },
+  eligibleAssignments?: Assignment[],
+  eligibleDiagnostics?: ExperimentActivationDiagnostic[],
+) {
+  const authoritative = readEdgeRuntimeAssignments();
+  if (!authoritative) return null;
+  const assignments: Assignment[] = [];
+  const diagnostics: ExperimentActivationDiagnostic[] = [];
+  const eligibleByExperiment = eligibleAssignments
+    ? new Map(eligibleAssignments.map((assignment) => [assignment.experimentId, assignment]))
+    : null;
+  const eligibleDiagnosticsByExperiment = eligibleDiagnostics
+    ? new Map(eligibleDiagnostics.map((diagnostic) => [diagnostic.experimentId, diagnostic]))
+    : null;
+  for (const experiment of experiments) {
+    const edgeAssignment = authoritative.get(experiment.id);
+    if (!edgeAssignment) {
+      if (authoritative.size === 0) {
+        diagnostics.push(experimentDiagnostic(
+          experiment,
+          [{ id: "assignment", label: "Variation assignment", status: "failed", reason: "edge_runtime_assignment_missing" }],
+          null,
+          "edge_runtime_assignment_missing",
+        ));
+      }
+      continue;
+    }
+    const variationIndex = experiment.variations.findIndex(
+      (variation) => variation.id === edgeAssignment.variationId,
+    );
+    if (variationIndex < 0 || variationIndex !== edgeAssignment.index) {
+      diagnostics.push(experimentDiagnostic(
+        experiment,
+        [{ id: "assignment", label: "Variation assignment", status: "failed", reason: "edge_runtime_assignment_invalid" }],
+        null,
+        "edge_runtime_assignment_invalid",
+      ));
+      continue;
+    }
+    const eligibleAssignment = eligibleByExperiment?.get(experiment.id);
+    if (eligibleByExperiment && !eligibleAssignment) {
+      const diagnostic = eligibleDiagnosticsByExperiment?.get(experiment.id);
+      if (diagnostic) diagnostics.push(diagnostic);
+      continue;
+    }
+    const assignment = buildAssignment(
+      experiment,
+      experiment.variations[variationIndex],
+      variationIndex,
+      getHashId(experiment, context.userId, context.attributes),
+      context.url,
+    );
+    if (eligibleAssignment) assignment.pageActive = eligibleAssignment.pageActive;
+    assignments.push(assignment);
+    diagnostics.push(experimentDiagnostic(
+      experiment,
+      [{
+        id: "assignment",
+        label: "Variation assignment",
+        status: "passed",
+        reason: "edge_runtime_assignment",
+        detail: { variationId: assignment.variationId, index: assignment.index },
+      }],
+      assignment,
+      "edge_runtime_assignment",
+    ));
+  }
+  return { assignments, diagnostics, experimentIds: authoritative };
+}
+
+export function resolveCombinedEdgeEvaluation(
+  edgeAssignments: Assignment[],
+  fallbackAssignments: Assignment[],
+  diagnostics: ExperimentActivationDiagnostic[],
+  context: {
+    userId: string;
+    exclusionGroups?: ExclusionGroupConfig[];
+  },
+): { assignments: Assignment[]; diagnostics: ExperimentActivationDiagnostic[] } {
+  const preferredIds = new Set(edgeAssignments.map((assignment) => assignment.experimentId));
+  const combined = [...edgeAssignments, ...fallbackAssignments];
+  const assignedIds = new Set(combined.map((assignment) => assignment.experimentId));
+  const suppressed = new Map<string, ExclusionGroupDecision>();
+
+  for (const group of context.exclusionGroups ?? []) {
+    const winner = group.members.find(
+      (member) => preferredIds.has(member.experimentId) && assignedIds.has(member.experimentId),
+    );
+    if (!winner) continue;
+    const conflictingExperimentIds = group.members
+      .map((member) => member.experimentId)
+      .filter((experimentId) => assignedIds.has(experimentId));
+    const suppressedExperimentIds = conflictingExperimentIds.filter(
+      (experimentId) => experimentId !== winner.experimentId && !preferredIds.has(experimentId),
+    );
+    if (!suppressedExperimentIds.length) continue;
+    const decision: ExclusionGroupDecision = {
+      groupId: group.id,
+      conflictingExperimentIds,
+      winnerExperimentId: winner.experimentId,
+      suppressedExperimentIds,
+      sticky: false,
+    };
+    for (const experimentId of suppressedExperimentIds) {
+      suppressed.set(experimentId, decision);
+    }
+  }
+
+  const preferred = suppressed.size
+    ? combined.filter((assignment) => !suppressed.has(assignment.experimentId))
+    : combined;
+  const preferredDiagnostics = suppressed.size
+    ? diagnostics.map((diagnostic) => {
+        const decision = suppressed.get(diagnostic.experimentId);
+        return decision ? excludedByGroupDiagnostic(diagnostic, decision) : diagnostic;
+      })
+    : diagnostics;
+  const resolved = applyExclusionAndPersonalization(
+    preferred,
+    context,
+    preferredDiagnostics,
+  );
+  return {
+    assignments: resolved.assignments,
+    diagnostics: resolved.diagnostics ?? preferredDiagnostics,
+  };
+}
+
+export function escapeDeliveryRegex(value: string): string {
+  return value.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+}
+
+export function matchSimpleDeliveryPattern(pattern: string, url: string): boolean {
+  if (!pattern) return false;
+  try {
+    const current = new URL(url, location.href);
+    const cleanPattern = pattern.includes("://")
+      ? pattern
+      : (pattern.startsWith("/") ? pattern : "/" + pattern);
+    const re = new RegExp("^" + escapeDeliveryRegex(cleanPattern) + "$");
+    return pattern.includes("://")
+      ? re.test(current.href)
+      : re.test(current.pathname + current.search) || re.test(current.pathname);
+  } catch {
+    return false;
+  }
+}
+
+export function matchRegexDeliveryPattern(pattern: string, url: string): boolean {
+  try {
+    const current = new URL(url, location.href);
+    const re = new RegExp(pattern);
+    return re.test(current.href) || re.test(current.pathname + current.search) || re.test(current.pathname);
+  } catch {
+    return false;
+  }
+}
+
+export function matchesDeliveryUrlRules(rules: SnippetDeliveryUrlRule[] | undefined, url: string): boolean {
+  if (!rules?.length) return true;
+  let hasInclude = false;
+  let includeHit = false;
+  for (const rule of rules) {
+    if (!rule || typeof rule.pattern !== "string") continue;
+    const matched = rule.type === "regex"
+      ? matchRegexDeliveryPattern(rule.pattern, url)
+      : matchSimpleDeliveryPattern(rule.pattern, url);
+    if (rule.include === false && matched) return false;
+    if (rule.include !== false) {
+      hasInclude = true;
+      if (matched) includeHit = true;
+    }
+  }
+  return !hasInclude || includeHit;
+}
+
+export function expandCriticalMutation(raw: SnippetCriticalMutation): Mutation | null {
+  const [selector, action, value] = raw;
+  if (typeof selector !== "string" || !selector || typeof action !== "string") return null;
+  const base = { selector, action } as Mutation;
+  switch (action) {
+    case "text":
+    case "setText":
+      return typeof value === "string" ? { ...base, text: value } : null;
+    case "html":
+    case "insertBefore":
+    case "insertAfter":
+      return typeof value === "string" ? { ...base, html: value } : null;
+    case "attribute":
+      if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+      if ("name" in value) return { ...base, attribute: value as Mutation["attribute"] };
+      return { ...base, attributes: value as Record<string, string | null> };
+    case "style":
+    case "setStyle":
+      return value && typeof value === "object" && !Array.isArray(value)
+        ? { ...base, styles: value as Record<string, string> }
+        : null;
+    case "remove":
+      return base;
+    default:
+      return null;
+  }
+}
+
+export function buildCriticalPathAssignments(
+  experiments: Experiment[],
+  plan: SnippetCriticalMutationPlanItem[] | undefined,
+  ctx: { url: string; attributes: Record<string, unknown>; userId: string },
+): {
+  assignments: Assignment[];
+  plannedExperimentIds: Set<string>;
+  skippedDiagnostics: ExperimentActivationDiagnostic[];
+} {
+  const plannedExperimentIds = new Set<string>();
+  const assignments: Assignment[] = [];
+  const skippedDiagnostics: ExperimentActivationDiagnostic[] = [];
+  if (!plan?.length || state.forceMap) {
+    return { assignments, plannedExperimentIds, skippedDiagnostics };
+  }
+
+  const experimentsById = new Map(experiments.map((experiment) => [experiment.id, experiment]));
+  for (const item of plan) {
+    if (!item?.e || !Array.isArray(item.v)) continue;
+    const experiment = experimentsById.get(item.e);
+    if (!experiment || !isExperimentServable(experiment, { qaMode: false, environment: state.config?.environments?.activeKey || "production" })) continue;
+    plannedExperimentIds.add(experiment.id);
+    if (
+      !state.forceMap?.[experiment.id] &&
+      weekdayScheduleBlocksDelivery(experiment.weekdaySchedule, new Date())
+    ) {
+      skippedDiagnostics.push(experimentDiagnostic(
+        experiment,
+        [{ id: "weekday", label: "Weekday schedule", status: "failed", reason: "excluded_weekday" }],
+        null,
+        "excluded_weekday",
+      ));
+      continue;
+    }
+    if (!matchesDeliveryUrlRules(item.r, ctx.url)) {
+      skippedDiagnostics.push(experimentDiagnostic(
+        experiment,
+        [
+          { id: "page", label: "Page check", status: "failed", reason: "url_mismatch" },
+          // Critical-path plans only contain campaigns without non-URL
+          // targeting, so the truthful audience result is "all visitors".
+          { id: "audience", label: "Audience check", status: "skipped", reason: "no_audience_rules" },
+        ],
+        null,
+        "url_mismatch",
+      ));
+      continue;
+    }
+
+    const hashId = getHashId(experiment, ctx.userId, ctx.attributes);
+    const hashValue = hashToFloat(experiment.id, hashId);
+    if (!inTrafficAllocation(hashValue, experiment.trafficAllocation ?? 1)) {
+      skippedDiagnostics.push(experimentDiagnostic(
+        experiment,
+        [
+          { id: "page", label: "Page check", status: "passed", reason: "precompiled_delivery_match" },
+          { id: "audience", label: "Audience check", status: "skipped", reason: "no_audience_rules" },
+          {
+            id: "traffic",
+            label: "Traffic allocation",
+            status: "failed",
+            reason: "outside_allocation",
+            detail: { hashValue, allocation: experiment.trafficAllocation ?? 1 },
+          },
+        ],
+        null,
+        "outside_allocation",
+      ));
+      continue;
+    }
+
+    const allocation = experiment.trafficAllocation ?? 1;
+    const variationHashValue =
+      allocation >= 1 ? hashValue : variationHashToFloat(experiment.id, hashId);
+    const planIndex = chooseVariation(variationHashValue, item.v.map((variation) => variation.w));
+    const plannedVariation = planIndex >= 0 ? item.v[planIndex] : null;
+    if (!plannedVariation) continue;
+    const fullIndex = experiment.variations.findIndex((variation) => variation.id === plannedVariation.id);
+    if (fullIndex < 0) continue;
+    const fullVariation = experiment.variations[fullIndex];
+    const mutations = plannedVariation.m
+      .map(expandCriticalMutation)
+      .filter((mutation): mutation is Mutation => Boolean(mutation));
+
+    assignments.push({
+      experimentId: experiment.id,
+      experimentName: experiment.name,
+      variationId: fullVariation.id,
+      pageActive: true,
+      index: fullIndex,
+      mutations,
+      value: fullVariation.value,
+      featureFlag: experiment.featureFlag,
+      personalization: experiment.personalization,
+      kind: experiment.kind ?? (experiment.personalization ? "personalization" : experiment.featureFlag ? "feature_flag" : "experiment"),
+      experimentCss: experiment.css,
+      experimentJs: experiment.js,
+      experimentResetJs: experiment.resetJs,
+      css: fullVariation.css,
+      js: fullVariation.js,
+      resetJs: fullVariation.resetJs,
+      externalCssUrl: fullVariation.externalCssUrl,
+      externalJsUrl: fullVariation.externalJsUrl,
+      harnessSession: fullVariation.harnessSession,
+      artifactSource: fullVariation.artifactSource,
+      isControl: Boolean(fullVariation.isControl || plannedVariation.c),
+      hashValue: hashId,
+    });
+  }
+  return { assignments, plannedExperimentIds, skippedDiagnostics };
+}
+
+export function runPostRevealReassert(): void {
+  try {
+    if (!state.config || !resolveDomPageTrigger(state.config, state.pageTriggerMode)) return;
+    if (!state.assignments.length) return;
+    reassertAssignmentMutations(state.assignments);
+  } catch {}
+}
+
+export function schedulePostRevealReassert(): void {
+  try {
+    const first = () => runPostRevealReassert();
+    if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+      window.requestAnimationFrame(first);
+    } else if (typeof window !== "undefined") {
+      window.setTimeout(first, 0);
+    } else {
+      setTimeout(first, 0);
+    }
+
+    const debounceMs = state.config?.spa?.debounceMs ?? 250;
+    if (typeof window !== "undefined") {
+      window.setTimeout(runPostRevealReassert, debounceMs);
+    } else {
+      setTimeout(runPostRevealReassert, debounceMs);
+    }
+  } catch {}
+}
+
+export function revealExperimentContent(options: { postRevealReassert?: boolean } = {}): void {
+  const revealAt = markDripPerf("reveal_at");
+  markCwvReveal();
+  updateLoadDiagnostics({ stage: "revealed", revealAt });
+  revealAll();
+  removeAntiFlicker();
+  if (options.postRevealReassert !== false) {
+    schedulePostRevealReassert();
+  }
+}
+
+export function applyAssignmentCode(
+  assignment: Assignment,
+  applyEpoch: number,
+  appliedExperimentCode: Set<string>,
+  ownerKeys: readonly string[],
+  ownerIds: readonly string[],
+  runCustomJs = true,
+  onCustomJsRun?: () => void,
+): void {
+  const artifactId = baseArtifactApplicationKey(assignment);
+  if (assignment.experimentCss && !appliedExperimentCode.has(assignment.experimentId)) {
+    __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: Applying experiment CSS`, {
+      bytes: assignment.experimentCss.length,
+    });
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: injecting experiment CSS`);
+    injectExperimentCss(
+      assignment.experimentCss,
+      assignment.experimentId,
+      ownerIds,
+      artifactId,
+      applyEpoch,
+    );
+  }
+  if (assignment.css) {
+    __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: Applying CSS`, {
+      variationId: assignment.variationId,
+      bytes: assignment.css.length,
+    });
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: injecting CSS`);
+    injectCss(
+      assignment.css,
+      assignment.experimentId,
+      assignment.variationId,
+      ownerIds,
+      artifactId,
+      applyEpoch,
+    );
+  }
+
+  if (
+    (!runCustomJs || !assignment.experimentJs) &&
+    !assignment.externalCssUrl &&
+    !assignment.externalJsUrl &&
+    (!runCustomJs || !assignment.js)
+  ) {
+    appliedExperimentCode.add(assignment.experimentId);
+    return;
+  }
+
+  runWhenDomReady(() => {
+    if (!artifactEpochCurrent(ownerKeys, applyEpoch)) return;
+    const label = assignment.experimentId + "-" + assignment.variationId;
+    if (
+      runCustomJs &&
+      assignment.experimentJs &&
+      !appliedExperimentCode.has(assignment.experimentId)
+    ) {
+      __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: Applying experiment JS`, {
+        bytes: assignment.experimentJs.length,
+      });
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: executing experiment JS`);
+      runMuted(() => execJs(assignment.experimentJs!, assignment.experimentId + "-experiment-js"));
+      onCustomJsRun?.();
+    }
+    appliedExperimentCode.add(assignment.experimentId);
+    const cssReady = assignment.externalCssUrl
+      ? injectExternalCss(
+          assignment.externalCssUrl,
+          assignment.experimentId,
+          assignment.variationId,
+          ownerIds,
+          artifactId,
+          applyEpoch,
+        )
+          .then(() => {
+            __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: External CSS loaded`, {
+              variationId: assignment.variationId,
+              url: assignment.externalCssUrl,
+            });
+            __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: external CSS loaded`);
+            __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "external CSS loaded", { url: assignment.externalCssUrl });
+          })
+          .catch((error) => {
+            __DRIP_FEATURE_DEVTOOLS__ && debugWarn("apply", error instanceof Error ? error.message : String(error));
+            __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "external CSS failed", { url: assignment.externalCssUrl });
+          })
+      : Promise.resolve();
+
+    cssReady.then(() => {
+      if (!artifactEpochCurrent(ownerKeys, applyEpoch)) return;
+      const jsReady = assignment.externalJsUrl
+        ? loadExternalJs(assignment.externalJsUrl, label, ownerIds, artifactId, applyEpoch)
+            .then(() => {
+              __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: External JS loaded`, {
+                variationId: assignment.variationId,
+                url: assignment.externalJsUrl,
+              });
+              __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: external JS loaded`);
+              __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "external JS loaded", { url: assignment.externalJsUrl });
+            })
+            .catch((error) => {
+              __DRIP_FEATURE_DEVTOOLS__ && debugWarn("apply", error instanceof Error ? error.message : String(error));
+              __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "external JS failed", { url: assignment.externalJsUrl });
+            })
+        : Promise.resolve();
+
+      jsReady.then(() => {
+        if (!artifactEpochCurrent(ownerKeys, applyEpoch)) return;
+        if (runCustomJs && assignment.js) {
+          __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: Applying JS`, {
+            variationId: assignment.variationId,
+            bytes: assignment.js.length,
+          });
+          __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: executing JS`);
+          runMuted(() => execJs(assignment.js!, label));
+          onCustomJsRun?.();
+        }
+      });
+    });
+  });
+}
+
+export function recordAppliedAssignment(
+  assignment: Assignment,
+  pageIds: readonly string[],
+): string[] {
+  return pageIds.map((pageId) => {
+    const key = artifactApplicationKey(assignment, pageId);
+    const pageState = state.pageActivation.get(pageId) ?? {
+      active: true,
+      appliedKeys: new Set<string>(),
+    };
+    pageState.appliedKeys.add(key);
+    state.pageActivation.set(pageId, pageState);
+    appliedAssignmentsByKey.set(key, assignment);
+    artifactEpochs.set(key, applyPassEpoch);
+    return key;
+  });
+}
+
+export function appliedOwnerKeysForAssignment(assignment: Assignment): string[] {
+  const baseKey = baseArtifactApplicationKey(assignment);
+  return Array.from(appliedAssignmentsByKey.entries())
+    .filter(([, applied]) => baseArtifactApplicationKey(applied) === baseKey)
+    .map(([ownerKey]) => ownerKey);
+}
+
+export function applyAssignments(
+  assignments: Assignment[],
+  activationMode: ActivationMode,
+  options: { pageIds?: ReadonlySet<string>; goalUrl?: string } = {},
+): void {
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Applying assignment set`, {
+    assignments: assignments.length,
+    activationMode,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `Applying ${assignments.length} assignment(s)`);
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("apply", `Applying ${assignments.length} assignment(s)`);
+  const applyGeneration = ++applyPassEpoch;
+  const appliedExperimentCode = new Set<string>();
+  const customJsRan = new Set<string>();
+  // Keep destination redirect assignments active for attribution, goals, and
+  // exposure dedupe, but render only assignments whose artifacts belong to
+  // the current (source) page.
+  const ownerPageIdsByAssignment = new Map<Assignment, string[]>();
+  const existingOwnerKeysByAssignment = new Map<Assignment, string[]>();
+  const renderableAssignments = artifactRenderableAssignments(assignments).filter(
+    (assignment) => {
+      const pageIds = assignmentPageIds(assignment).filter(
+        (pageId) => !options.pageIds || options.pageIds.has(pageId),
+      );
+      ownerPageIdsByAssignment.set(assignment, pageIds);
+      existingOwnerKeysByAssignment.set(
+        assignment,
+        appliedOwnerKeysForAssignment(assignment),
+      );
+      return pageIds.length > 0;
+    },
+  );
+  const offersDisplayWithheld = (assignment: Assignment): boolean =>
+    !isOffersDisplayAssignmentAuthorized(assignment);
+
+  // Delivery state is assignment-scoped. A page-limited SPA pass may replace
+  // the tracker for assignments it is about to deliver, but must not promote
+  // an unrelated page's still-pending assignment into the attribution plane.
+  for (const assignment of renderableAssignments) {
+    const exposureKey = exposureAssignmentKey(assignment);
+    state.mutationPendingAssignmentKeys.delete(exposureKey);
+    if (
+      assignment.mutations.length > 0 &&
+      !offersDisplayWithheld(assignment) &&
+      (existingOwnerKeysByAssignment.get(assignment)?.length ?? 0) === 0
+    ) {
+      state.mutationPendingAssignmentKeys.add(exposureKey);
+      // Same prune-hole as contamination: pending keys for removed assignments
+      // are dropped on re-init, so an undelivered treatment must leave the
+      // ledger now and re-enter only through clean delivery.
+      runtimeSharedState.attributionLedger.delete(assignment.experimentId);
+    }
+  }
+
+  const commerce = state.config?.commerce;
+  const commerceActive = Boolean(commerce?.price || commerce?.shipping || commerce?.offers);
+  const renderableCommerceAssignments = commerceActive
+    ? artifactRenderableAssignments(
+        withCommercePriceAssignments(renderableAssignments).filter(renderable),
+      )
+    : renderableAssignments;
+  // The charge plane is reconciled before the price gate below reads the cart
+  // stamp; the pass therefore skips the cart step of syncGlobalRuntimes().
+  reconcileCartSync();
+  if (state.config?.holdout_v1_enabled === true && assignments.length === 0) {
+    // Cohort identity must cross the storefront -> checkout boundary even
+    // when this page has no assignments. Held-out visitors additionally need
+    // a privilege-reducing clear that cannot be gated on analytics consent.
+    syncActiveAssignmentToShopifyCart({ holdoutCartClear: state.holdout });
+  }
+
+  // Offers-enforced assignments render nothing until their cart stamp is
+  // authorized: a companion treatment shown before the signed envelope lands
+  // could advertise an offer Shopify never charges. Identity, goal wiring,
+  // and cart-sync behavior are unchanged — only DOM application (mutations,
+  // CSS/JS) is withheld; the display-authorization callback re-applies.
+  // Count total mutations to know when all have been applied
+  let pendingMutations = 0;
+  for (const a of renderableAssignments) {
+    if (offersDisplayWithheld(a)) continue;
+    if ((existingOwnerKeysByAssignment.get(a)?.length ?? 0) > 0) continue;
+    pendingMutations += a.mutations.length;
+  }
+  // Counts a price treatment whose activation is still PENDING (Shopify has not yet
+  // published product metadata), so the reveal cannot flash the original price. The
+  // anti-flicker timeout still bounds how long content may stay hidden.
+  const pricePending = commerce?.price && isCommercePriceWorkPending(
+    commerce.price,
+    renderableCommerceAssignments,
+    isPriceDisplayAssignmentAuthorized,
+  ) ? 1 : 0;
+  pendingMutations += pricePending;
+  let priceResolved = 0;
+  const mutationKey = (assignment: Assignment, index: number) => (
+    `${assignment.experimentId}\u0000${assignment.variationId}\u0000${index}`
+  );
+  const deliveryTrackers = new Map<string, DeliveryHealthTracker>();
+  const deliveryKey = (assignment: Assignment) => `${assignment.experimentId}\u0000${assignment.variationId}`;
+  for (const assignment of renderableAssignments) {
+    if (offersDisplayWithheld(assignment)) continue;
+    if ((existingOwnerKeysByAssignment.get(assignment)?.length ?? 0) > 0) {
+      continue;
+    }
+    deliveryTrackers.set(deliveryKey(assignment), {
+      assignment,
+      expected: assignment.mutations.length,
+      applied: new Set<number>(),
+      missed: new Set<number>(),
+      emitted: false,
+    });
+  }
+  const contaminateAssignment = (tracker: DeliveryHealthTracker): void => {
+    const assignment = tracker.assignment;
+    const exposureKey = exposureAssignmentKey(assignment);
+    if (state.contaminatedAssignmentKeys.has(exposureKey)) return;
+    state.mutationPendingAssignmentKeys.delete(exposureKey);
+    state.contaminatedAssignmentKeys.add(exposureKey);
+    // Evict rather than rely on the read-time contamination check: a later
+    // re-init prunes orphaned contamination keys for removed assignments, and
+    // a surviving ledger entry would re-enter cart labels fail-open.
+    runtimeSharedState.attributionLedger.delete(assignment.experimentId);
+    const artifactId = baseArtifactApplicationKey(assignment);
+    invalidatedArtifactIds.add(artifactId);
+    invalidateArtifact(artifactId);
+    const ownerKeys = appliedOwnerKeysForAssignment(assignment);
+    for (const ownerKey of ownerKeys) unregisterArtifactOwner(ownerKey);
+    for (const pageId of new Set([
+      ...(ownerPageIdsByAssignment.get(assignment) ?? []),
+      ...ownerKeys.map(artifactOwnerId),
+    ])) {
+      rollbackArtifactOwner(pageId, artifactId);
+    }
+    const authorizationKey = priceAssignmentAuthorizationKey(assignment);
+    state.authorizedPriceAssignmentKeys?.delete(authorizationKey);
+    state.authorizedShippingAssignmentKeys?.delete(authorizationKey);
+    state.authorizedOffersAssignmentKeys?.delete(authorizationKey);
+    // Observer delivery can run variation JS before its selector tracker
+    // expires. Reset unconditionally: reset scripts are idempotent cleanup and
+    // execJs contains failures so a broken customer reset cannot abort rollback.
+    runAssignmentResetJs([assignment]);
+    reconcileGoals();
+    // Authorization revocation and visible commerce rollback are one
+    // transaction: never leave a contaminated price/shipping/offer rendered
+    // until the next global pass.
+    reconcileCommercePrice();
+    reconcileCommerceShipping();
+    reconcileCartSync();
+    scheduleShopifyAssignmentSync();
+    const event: TrackEvent = {
+      type: "variant_contamination_rollback",
+      data: {
+        missed_selector_count: tracker.missed.size,
+        expected_mutations: tracker.expected,
+        applied_mutations: tracker.applied.size,
+        apply_generation: applyGeneration,
+        activation_mode: activationMode,
+      },
+      url: cleanUrl(),
+      experimentId: assignment.experimentId,
+      variationId: assignment.variationId,
+    };
+    if (state.tracker && !trackingBlocked()) state.tracker.track(event);
+    else state.pendingDeliveryHealth.push(event);
+  };
+  const maybeEmitDeliveryHealth = (tracker: DeliveryHealthTracker): void => {
+    if (tracker.emitted) return;
+    if (tracker.expected > 0 && tracker.applied.size + tracker.missed.size < tracker.expected) return;
+    tracker.emitted = true;
+    if (tracker.missed.size > 0) {
+      contaminateAssignment(tracker);
+    } else {
+      const exposureKey = exposureAssignmentKey(tracker.assignment);
+      const wasPending = state.mutationPendingAssignmentKeys.delete(exposureKey);
+      recordAttributableAssignments([tracker.assignment]);
+      // The assignment was deliberately excluded from every runtime while its
+      // selectors were unresolved. Promote every goal/identity/charge plane in
+      // this same turn rather than waiting for a route change or re-init.
+      if (wasPending) {
+        reconcileGoals();
+        reconcileCommercePrice();
+        reconcileCommerceShipping();
+        reconcileCartSync();
+        scheduleShopifyAssignmentSync();
+      }
+    }
+    queueDeliveryHealthEvent(tracker.assignment, {
+      expectedMutations: tracker.expected,
+      appliedMutations: tracker.applied.size,
+      selectorMisses: tracker.missed.size,
+      applyGeneration,
+      activationMode,
+    });
+    if (tracker.missed.size === 0 && state.analyticsStarted && state.config && !trackingBlocked()) {
+      trackViewedAssignments(state.config, [tracker.assignment]);
+    }
+  };
+  updateLoadDiagnostics({
+    stage: "mutations_scheduled",
+    pendingMutations,
+    appliedMutations: 0,
+    missedMutations: 0,
+  });
+
+  const appliedMutationKeys = new Set<string>();
+  const missedMutationKeys = new Set<string>();
+  let revealed = false;
+  const maybeRevealResolvedMutations = (): void => {
+    if (!revealed && appliedMutationKeys.size + missedMutationKeys.size + priceResolved >= pendingMutations) {
+      revealed = true;
+      revealExperimentContent();
+    }
+  };
+  if (appliedMutationKeys.size > 0) maybeRevealResolvedMutations();
+  const onMutationApplied = pendingMutations > 0
+      ? (
+          assignment: Assignment,
+          ownerKeys: readonly string[],
+          mutation: Mutation,
+          element: Element,
+          index: number,
+          journalSeq?: number,
+        ) => {
+        if (activationMode === "observer") {
+          trackAppliedMutation(
+            element,
+            mutation,
+            {
+              experimentId: assignment.experimentId,
+              variationId: assignment.variationId,
+              journalSeq,
+              artifactId: baseArtifactApplicationKey(assignment),
+              ownerKeys,
+            },
+            (target, appliedMutation) => applyToElement(appliedMutation, target),
+          );
+        }
+        const key = mutationKey(assignment, index);
+        if (appliedMutationKeys.has(key)) return;
+        appliedMutationKeys.add(key);
+        missedMutationKeys.delete(key);
+        const tracker = deliveryTrackers.get(deliveryKey(assignment));
+        if (tracker) {
+          tracker.applied.add(index);
+          tracker.missed.delete(index);
+          maybeEmitDeliveryHealth(tracker);
+        }
+        const firstMutationAt = markDripPerf("first_mutation_at");
+        updateLoadDiagnostics({
+          stage: "mutation_applied",
+          firstMutationAt,
+          pendingMutations,
+          appliedMutations: appliedMutationKeys.size,
+          missedMutations: missedMutationKeys.size,
+        });
+        __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `Mutation applied (${appliedMutationKeys.size}/${pendingMutations})`, {
+          selector: mutation.selector,
+        });
+        maybeRevealResolvedMutations();
+      }
+    : null;
+  const onMutationMissed = pendingMutations > 0
+    ? (assignment: Assignment, mutation: Mutation, index: number) => {
+        const key = mutationKey(assignment, index);
+        if (appliedMutationKeys.has(key) || missedMutationKeys.has(key)) return;
+        missedMutationKeys.add(key);
+        const tracker = deliveryTrackers.get(deliveryKey(assignment));
+        if (tracker) {
+          tracker.missed.add(index);
+          maybeEmitDeliveryHealth(tracker);
+        }
+        updateLoadDiagnostics({
+          stage: "mutation_missed",
+          pendingMutations,
+          appliedMutations: appliedMutationKeys.size,
+          missedMutations: missedMutationKeys.size,
+        });
+        __DRIP_FEATURE_DEVTOOLS__ && debugWarn("apply", `${assignment.experimentId}: selector did not match before expiry`, {
+          variationId: assignment.variationId,
+          selector: mutation.selector,
+        });
+        maybeRevealResolvedMutations();
+      }
+    : null;
+
+  for (const assignment of renderableAssignments) {
+    if (offersDisplayWithheld(assignment)) continue;
+    // A manual mutation earlier in this pass may have contaminated the
+    // assignment after the renderable set was built.
+    if (!renderable(assignment)) continue;
+    const ownerPageIds = ownerPageIdsByAssignment.get(assignment) ?? [];
+    const artifactId = baseArtifactApplicationKey(assignment);
+    const ownerKeys = assignmentHasRenderableArtifacts(assignment)
+      ? recordAppliedAssignment(assignment, ownerPageIds)
+      : [];
+    const existingOwnerKeys = new Set(
+      existingOwnerKeysByAssignment.get(assignment) ?? [],
+    );
+    const existingOwnerIds = new Set(
+      Array.from(existingOwnerKeys, artifactOwnerId),
+    );
+    const ownershipOnly = existingOwnerKeys.size > 0;
+    if (ownershipOnly) {
+      addAppliedMutationOwners(existingOwnerIds, ownerPageIds, artifactId);
+      addWaitEntryOwners(existingOwnerIds, ownerPageIds, artifactId);
+    } else if (assignment.mutations.length) {
+      __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${assignment.experimentId}: Applying mutations`, {
+        variationId: assignment.variationId,
+        count: assignment.mutations.length,
+        activationMode,
+      });
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("apply", `${assignment.experimentId}: ${assignment.mutations.length} mutation(s)`, { activationMode });
+      if (activationMode === "manual") {
+        applyMutations(assignment.mutations, {
+          artifactId: baseArtifactApplicationKey(assignment),
+          epoch: applyGeneration,
+          ownerKeys: ownerPageIds,
+          preservePrices: assignment.artifactSource === "operator_chat",
+          onPricePreservationViolation: ({ selector, originalPriceTokens }) => {
+            if (!state.config) return;
+            sendRuntimeEventNow(state.config, "sdk_price_preservation_blocked", {
+              experiment_id: assignment.experimentId,
+              variation_id: assignment.variationId,
+              selector,
+              original_price_tokens: originalPriceTokens.map((token) => token.raw),
+            });
+          },
+          onApplied: onMutationApplied
+            ? (mutation, element, index, journalSeq) => onMutationApplied(
+                assignment,
+                ownerPageIds,
+                mutation,
+                element,
+                index,
+                journalSeq,
+              )
+            : undefined,
+          onMiss: onMutationMissed
+            ? (mutation, index) => onMutationMissed(assignment, mutation, index)
+            : undefined,
+        });
+      } else {
+        // DOM mutations via MutationObserver-backed waitForElement
+        assignment.mutations.forEach((m, i) => applyMutationWithWait(
+          m,
+          i,
+          onMutationApplied
+            ? (mutation, element, index, journalSeq) => onMutationApplied(
+                assignment,
+                ownerPageIds,
+                mutation,
+                element,
+                index,
+                journalSeq,
+              )
+            : undefined,
+          onMutationMissed
+            ? (mutation, index) => onMutationMissed(assignment, mutation, index)
+            : undefined,
+          ownerPageIds,
+          baseArtifactApplicationKey(assignment),
+          applyGeneration,
+          assignment.artifactSource === "operator_chat" ? {
+            enabled: true,
+            onViolation: ({ selector, originalPriceTokens }) => {
+              if (!state.config) return;
+              sendRuntimeEventNow(state.config, "sdk_price_preservation_blocked", {
+                experiment_id: assignment.experimentId,
+                variation_id: assignment.variationId,
+                selector,
+                original_price_tokens: originalPriceTokens.map((token) => token.raw),
+              });
+            },
+          } : undefined,
+        ));
+      }
+    } else {
+      const tracker = deliveryTrackers.get(deliveryKey(assignment));
+      if (tracker) maybeEmitDeliveryHealth(tracker);
+    }
+    // Manual mutation delivery can contaminate and roll back this assignment
+    // synchronously. Re-check immediately before every remaining artifact
+    // surface so CSS and custom JS cannot be re-injected in the same pass.
+    if (!renderable(assignment)) continue;
+    applyAssignmentCode(
+      assignment,
+      applyGeneration,
+      appliedExperimentCode,
+      ownerKeys,
+      ownerPageIds,
+      !ownershipOnly,
+      () => customJsRan.add(exposureAssignmentKey(assignment)),
+    );
+    if (!ownershipOnly) invalidatedArtifactIds.delete(artifactId);
+  }
+
+  pendingCommercePriceResolve = () => {
+    priceResolved = pricePending;
+    if (pricePending) maybeRevealResolvedMutations();
+  };
+  // Goals, harness polling and commerce price/shipping clean up before they
+  // render, so they reconcile from the full active set — never this pass's
+  // page subset.
+  syncGlobalRuntimes({ goalUrl: options.goalUrl, skipCartSync: true });
+
+  // If there were no mutations (or manual mode), reveal immediately.
+  if (pendingMutations === 0 || activationMode === "manual") {
+    revealExperimentContent();
+  }
+}
+
+export function reassertAssignmentMutations(assignments: Assignment[]): void {
+  const mutations = artifactRenderableAssignments(assignments).reduce<Assignment["mutations"]>((all, assignment) => {
+    all.push(...assignment.mutations);
+    return all;
+  }, []);
+  if (!mutations.length) return;
+  reassertNonStructuralMutations(mutations);
+}
+
+export type TeardownPage = {
+  pageId: string;
+  mode: PageDeactivationMode;
+};
+
+export type TeardownRuntimeOptions = {
+  goalUrl?: string;
+  skipCartSync?: boolean;
+};
+
+export type TeardownSelection = Map<string, {
+  artifactIds: Set<ArtifactId>;
+  mode: PageDeactivationMode;
+}>;
+
+export function runAssignmentResetJs(assignments: Iterable<Assignment>): void {
+  const resetExperimentIds = new Set<string>();
+  const resetAssignmentKeys = new Set<string>();
+  for (const assignment of assignments) {
+    const assignmentKey = assignment.experimentId + "\u0000" + assignment.variationId;
+    if (assignment.resetJs && !resetAssignmentKeys.has(assignmentKey)) {
+      resetAssignmentKeys.add(assignmentKey);
+      execJs(assignment.resetJs, assignment.experimentId + "-reset");
+    }
+    if (
+      assignment.experimentResetJs &&
+      !resetExperimentIds.has(assignment.experimentId)
+    ) {
+      resetExperimentIds.add(assignment.experimentId);
+      execJs(
+        assignment.experimentResetJs,
+        assignment.experimentId + "-experiment-reset",
+      );
+    }
+  }
+}
+
+export /**
+ * Reveal hook for a price activation that is still resolving. The latest
+ * `applyAssignments` pass owns it; `applyCommercePrice` keeps calling the
+ * stable wrapper, so a late resolution still reveals the current pass.
+ */
+let pendingCommercePriceResolve: (() => void) | null = null;
+
+export function resolveCommercePricePending(): void {
+  pendingCommercePriceResolve?.();
+}
+
+export function unwireGoals(): void {
+  state.wiredGoalKeys = new Set();
+  cleanupGoals();
+}
+
+export function goalWiringEligible(): boolean {
+  return state.analyticsStarted &&
+    !trackingBlocked() &&
+    state.trackingPrerequisiteMet;
+}
+
+export /**
+ * Diff the wired goal set against the assigned plane. Removing one page's goals
+ * therefore never removes the document listener while other goals live, and a
+ * teardown that changes nothing still leaves the surviving goals wired.
+ */
+function reconcileGoals(url?: string): void {
+  if (!goalWiringEligible()) return;
+  const experiments = state.config?.experiments ?? [];
+  const activePageIdsForGoals = activePageIds();
+  const desired = goalWiringKeys(
+    state.assignments.filter(attributable),
+    experiments,
+    activePageIdsForGoals,
+  );
+  if (sameStringSet(desired, state.wiredGoalKeys)) {
+    if (url) state.wiredGoalUrl = url;
+    return;
+  }
+  setupGoalTracking(experiments, url, activePageIdsForGoals);
+}
+
+export function reconcileHarnessPolling(): void {
+  startHarnessPolling(activeRenderableAssignments());
+}
+
+export function reconcileCommercePrice(): void {
+  try {
+    applyCommercePrice(
+      state.config?.commerce?.price,
+      artifactRenderableAssignments(
+        withCommercePriceAssignments(activeRenderableAssignments()).filter(renderable),
+      ),
+      isCohortStampedOnCart,
+      resolveCommercePricePending,
+      isPriceDisplayAssignmentAuthorized,
+    );
+  } catch {
+    resolveCommercePricePending();
+  }
+}
+
+export function reconcileCommerceShipping(): void {
+  applyCommerceShipping(
+    state.config?.commerce?.shipping,
+    activeRenderableAssignments().filter(isShippingDisplayAssignmentAuthorized),
+    trackViewedAssignmentsAfterShippingEligibility,
+  );
+}
+
+export function reconcileCartSync(): void {
+  const commerce = state.config?.commerce;
+  if (commerce?.price || commerce?.shipping || commerce?.offers) {
+    configureChargeCorrectnessCartSync(chargeAffectingAssignments());
+    return;
+  }
+  // No commerce planes remain, so no cart sync will run — but an earlier
+  // GWP insertion may still sit on the persistent cart with its Function
+  // authorization gone. The manager exits instantly without insertion
+  // records, so this is free for every non-commerce shop.
+  void syncGiftWithPurchase(commerce?.offers, withCommercePriceAssignments(state.assignments).filter(attributable));
+}
+
+export /**
+ * Reconcile every global runtime singleton from runtime state. No page-scoped
+ * path may call a global cleanup: teardown and apply change state, this
+ * function decides what the document should hold afterwards.
+ *
+ * `skipCartSync` is for callers that already reconciled the charge plane in
+ * the same pass (`applyAssignments`, which must stamp the cart before the
+ * price gate is computed) and for the commerce callbacks that run *inside*
+ * the cart-sync completion path, where re-entering it would recurse.
+ */
+function syncGlobalRuntimes(
+  options: { goalUrl?: string; skipCartSync?: boolean } = {},
+): void {
+  if (!options.skipCartSync) reconcileCartSync();
+  reconcileGoals(options.goalUrl);
+  reconcileHarnessPolling();
+  reconcileCommercePrice();
+  reconcileCommerceShipping();
+}
+
+export function configuredPageDeactivationModes(): Map<string, PageDeactivationMode> {
+  const modes = new Map<string, PageDeactivationMode>();
+  for (const experiment of state.config?.experiments ?? []) {
+    const rules = includedPageRules(experiment);
+    if (rules.length === 0) {
+      modes.set(GLOBAL_PAGE_PREFIX + experiment.id, targetingLifecycleMode(experiment));
+      continue;
+    }
+    for (const rule of rules) {
+      if (!modes.has(rule.id)) {
+        modes.set(rule.id, effectiveDeactivationMode(experiment, rule));
+      }
+    }
+  }
+  return modes;
+}
+
+export function allAppliedPagesWithModes(): TeardownPage[] {
+  const configuredModes = configuredPageDeactivationModes();
+  return Array.from(state.pageActivation.entries())
+    .filter(([, pageState]) => pageState.appliedKeys.size > 0)
+    .map(([pageId, pageState]) => ({
+      pageId,
+      mode:
+        configuredModes.get(pageId) ??
+        pageState.configuredMode ??
+        pageState.lastTransitionMode ??
+        "reset",
+    }));
+}
+
+export function rollbackArtifactOwner(pageId: string, artifactId: ArtifactId): void {
+  resetWaitEntriesForOwner(pageId, artifactId);
+  resetAppliedMutationsForOwner(pageId, artifactId, {
+    preserveReplacementTargets: true,
+  });
+  removeCssForOwner(pageId, artifactId);
+  removeExternalJsForOwner(pageId, artifactId);
+}
+
+export function unregisterArtifactOwner(ownerKey: string): void {
+  artifactEpochs.delete(ownerKey);
+  appliedAssignmentsByKey.delete(ownerKey);
+  state.pageActivation.get(artifactOwnerId(ownerKey))?.appliedKeys.delete(ownerKey);
+}
+
+export /**
+ * Run one teardown as an ordered document transaction. The reset closure is
+ * complete before merchant code runs: all artifacts of every resetting
+ * experiment are invalidated, selected owners are unregistered, reset JS runs
+ * once, selected owners roll back, and surviving artifacts replay.
+ */
+function executeTeardownTransaction(
+  selection: TeardownSelection,
+  runtimeOptions: TeardownRuntimeOptions = {},
+): void {
+  const liveBefore = liveArtifactInventory();
+  const selectedOwnerKeys = new Set<string>();
+  for (const [pageId, selected] of selection) {
+    for (const artifactId of selected.artifactIds) {
+      const ownerKey = `${pageId}\u0000${artifactId}`;
+      if (appliedAssignmentsByKey.has(ownerKey)) selectedOwnerKeys.add(ownerKey);
+    }
+  }
+
+  const resettingExperimentIds = new Set<string>();
+  for (const ownerKey of selectedOwnerKeys) {
+    const selected = selection.get(artifactOwnerId(ownerKey));
+    const assignment = appliedAssignmentsByKey.get(ownerKey);
+    if (
+      selected &&
+      (selected.mode === "reset" || selected.mode === "force_reset") &&
+      assignment &&
+      (assignment.resetJs || assignment.experimentResetJs)
+    ) {
+      resettingExperimentIds.add(assignment.experimentId);
+    }
+  }
+
+  const closureArtifactIds = new Set<ArtifactId>();
+  const closureAssignments = new Map<ArtifactId, Assignment>();
+  const closurePageIds = new Set<string>();
+  const closureOwnerKeysByExperiment = new Map<string, Set<string>>();
+  for (const [artifactId, live] of liveBefore) {
+    if (!resettingExperimentIds.has(live.assignment.experimentId)) continue;
+    closureArtifactIds.add(artifactId);
+    closureAssignments.set(artifactId, live.assignment);
+    const ownerKeys = closureOwnerKeysByExperiment.get(live.assignment.experimentId)
+      ?? new Set<string>();
+    live.ownerKeys.forEach((ownerKey) => {
+      ownerKeys.add(ownerKey);
+      closurePageIds.add(artifactOwnerId(ownerKey));
+    });
+    closureOwnerKeysByExperiment.set(live.assignment.experimentId, ownerKeys);
+  }
+
+  const configuredModes = configuredPageDeactivationModes();
+  const modeForPage = (pageId: string): PageDeactivationMode =>
+    selection.get(pageId)?.mode ??
+    configuredModes.get(pageId) ??
+    state.pageActivation.get(pageId)?.configuredMode ??
+    state.pageActivation.get(pageId)?.lastTransitionMode ??
+    "reset";
+  const resetSuppressedExperimentIds = new Set<string>();
+  const isolationFallbackExperimentIds = new Set<string>();
+  for (const [experimentId, ownerKeys] of closureOwnerKeysByExperiment) {
+    if (Array.from(ownerKeys).some((ownerKey) => modeForPage(artifactOwnerId(ownerKey)) === "deactivate")) {
+      resetSuppressedExperimentIds.add(experimentId);
+    }
+    if (Array.from(ownerKeys).some((ownerKey) => !selectedOwnerKeys.has(ownerKey))) {
+      isolationFallbackExperimentIds.add(experimentId);
+    }
+  }
+
+  const fallbackExperimentId = isolationFallbackExperimentIds.values().next().value as string | undefined;
+  if (fallbackExperimentId) {
+    for (const pageId of closurePageIds) {
+      const pageState = state.pageActivation.get(pageId);
+      if (!pageState) continue;
+      pageState.isolationFallback = "whole_experiment";
+      pageState.isolationFallbackExperimentId = fallbackExperimentId;
+    }
+  }
+
+  // D6 serializes nested reconciles, but the registry and every journal must
+  // already describe invalid state before merchant reset JS can trigger one.
+  for (const artifactId of closureArtifactIds) {
+    invalidatedArtifactIds.add(artifactId);
+    invalidateArtifact(artifactId);
+  }
+  for (const ownerKeys of closureOwnerKeysByExperiment.values()) {
+    ownerKeys.forEach((ownerKey) => artifactEpochs.delete(ownerKey));
+  }
+  for (const ownerKey of selectedOwnerKeys) unregisterArtifactOwner(ownerKey);
+
+  runAssignmentResetJs(
+    Array.from(closureAssignments.values()).filter(
+      (assignment) => !resetSuppressedExperimentIds.has(assignment.experimentId),
+    ),
+  );
+
+  for (const ownerKey of selectedOwnerKeys) {
+    rollbackArtifactOwner(
+      artifactOwnerId(ownerKey),
+      artifactIdFromApplicationKey(ownerKey),
+    );
+  }
+
+  const liveAfterRollback = liveArtifactInventory();
+  const desired = desiredArtifactSet(state.assignments);
+  const replay = Array.from(closureArtifactIds)
+    .filter((artifactId) => liveAfterRollback.has(artifactId) && desired.has(artifactId))
+    .map((artifactId) => desired.get(artifactId)!);
+  replayDesiredArtifacts(replay);
+  for (const artifactId of closureArtifactIds) {
+    if (!liveArtifactInventory().has(artifactId)) invalidatedArtifactIds.delete(artifactId);
+  }
+
+  revealExperimentContent({ postRevealReassert: false });
+  syncGlobalRuntimes(runtimeOptions);
+}
+
+export function teardownTransaction(
+  pages: TeardownPage[],
+  runtimeOptions: TeardownRuntimeOptions = {},
+): void {
+  pages.forEach((page) => cancelPageRulePoll(page.pageId));
+  const selection: TeardownSelection = new Map();
+  for (const page of pages) {
+    const pageState = state.pageActivation.get(page.pageId);
+    if (!pageState || pageState.appliedKeys.size === 0) continue;
+    const existing = selection.get(page.pageId);
+    const artifactIds = existing?.artifactIds ?? new Set<ArtifactId>();
+    pageState.appliedKeys.forEach((ownerKey) =>
+      artifactIds.add(artifactIdFromApplicationKey(ownerKey)));
+    selection.set(page.pageId, { artifactIds, mode: page.mode });
+  }
+  executeTeardownTransaction(selection, runtimeOptions);
+}
+
+export function teardownArtifactsTransaction(
+  artifactIds: ReadonlySet<ArtifactId>,
+  runtimeOptions: TeardownRuntimeOptions = {},
+): void {
+  const configuredModes = configuredPageDeactivationModes();
+  const selection: TeardownSelection = new Map();
+  const live = liveArtifactInventory();
+  for (const artifactId of artifactIds) {
+    const artifact = live.get(artifactId);
+    if (!artifact) continue;
+    for (const pageId of artifact.ownerPageIds) {
+      const pageState = state.pageActivation.get(pageId);
+      const existing = selection.get(pageId);
+      const selectedArtifactIds = existing?.artifactIds ?? new Set<ArtifactId>();
+      selectedArtifactIds.add(artifactId);
+      selection.set(pageId, {
+        artifactIds: selectedArtifactIds,
+        mode:
+          configuredModes.get(pageId) ??
+          pageState?.configuredMode ??
+          pageState?.lastTransitionMode ??
+          "reset",
+      });
+    }
+  }
+  executeTeardownTransaction(selection, runtimeOptions);
+}
+
+export type DesiredArtifact = {
+  id: ArtifactId;
+  assignment: Assignment;
+  ownerPageIds: Set<string>;
+};
+
+export type LiveArtifact = DesiredArtifact & {
+  ownerKeys: Set<string>;
+};
+
+export type ArtifactReconcileResult = {
+  applied: number;
+  ownerUpdates: number;
+  removed: number;
+  replayed: number;
+};
+
+export function desiredArtifactSet(assignments: Assignment[]): Map<ArtifactId, DesiredArtifact> {
+  const desired = new Map<ArtifactId, DesiredArtifact>();
+  for (const assignment of artifactRenderableAssignments(assignments)) {
+    if (!isOffersDisplayAssignmentAuthorized(assignment)) continue;
+    if (!assignmentHasRenderableArtifacts(assignment)) continue;
+    const ownerPageIds = assignmentPageIds(assignment);
+    if (ownerPageIds.length === 0) continue;
+    const id = baseArtifactApplicationKey(assignment);
+    const existing = desired.get(id);
+    if (existing) {
+      ownerPageIds.forEach((pageId) => existing.ownerPageIds.add(pageId));
+      continue;
+    }
+    desired.set(id, { id, assignment, ownerPageIds: new Set(ownerPageIds) });
+  }
+  return desired;
+}
+
+export function liveArtifactInventory(): Map<ArtifactId, LiveArtifact> {
+  const live = new Map<ArtifactId, LiveArtifact>();
+  for (const [ownerKey, assignment] of appliedAssignmentsByKey) {
+    const id = artifactIdFromApplicationKey(ownerKey);
+    const pageId = artifactOwnerId(ownerKey);
+    const existing = live.get(id);
+    if (existing) {
+      existing.ownerKeys.add(ownerKey);
+      existing.ownerPageIds.add(pageId);
+      continue;
+    }
+    live.set(id, {
+      id,
+      assignment,
+      ownerKeys: new Set([ownerKey]),
+      ownerPageIds: new Set([pageId]),
+    });
+  }
+  return live;
+}
+
+export function removeArtifactOwner(artifactId: ArtifactId, pageId: string): void {
+  const ownerKey = `${pageId}\u0000${artifactId}`;
+  unregisterArtifactOwner(ownerKey);
+  rollbackArtifactOwner(pageId, artifactId);
+}
+
+export function registerDesiredOwners(
+  desired: DesiredArtifact,
+  live: LiveArtifact,
+): { ownerKeys: string[]; added: boolean; epoch: number } {
+  const liveEpoch = Array.from(live.ownerKeys)
+    .map((ownerKey) => artifactEpochs.get(ownerKey) ?? 0)
+    .reduce((highest, epoch) => Math.max(highest, epoch), 0);
+  let added = false;
+  const ownerKeys: string[] = [];
+  for (const pageId of desired.ownerPageIds) {
+    const ownerKey = `${pageId}\u0000${desired.id}`;
+    ownerKeys.push(ownerKey);
+    const pageState = state.pageActivation.get(pageId) ?? {
+      active: true,
+      appliedKeys: new Set<string>(),
+    };
+    if (!appliedAssignmentsByKey.has(ownerKey)) added = true;
+    pageState.appliedKeys.add(ownerKey);
+    state.pageActivation.set(pageId, pageState);
+    appliedAssignmentsByKey.set(ownerKey, desired.assignment);
+    if (!artifactEpochs.has(ownerKey)) artifactEpochs.set(ownerKey, liveEpoch);
+  }
+  addAppliedMutationOwners(live.ownerPageIds, Array.from(desired.ownerPageIds), desired.id);
+  addWaitEntryOwners(live.ownerPageIds, Array.from(desired.ownerPageIds), desired.id);
+  addCssOwners(live.ownerPageIds, Array.from(desired.ownerPageIds), desired.id);
+  addExternalJsOwners(live.ownerPageIds, Array.from(desired.ownerPageIds), desired.id);
+  return { ownerKeys, added, epoch: liveEpoch };
+}
+
+export function replayDesiredArtifacts(artifacts: DesiredArtifact[]): void {
+  if (artifacts.length === 0) return;
+  const replayEpoch = ++applyPassEpoch;
+  const appliedExperimentCode = new Set<string>();
+  for (const desired of artifacts) {
+    const live = liveArtifactInventory().get(desired.id);
+    if (!live) continue;
+    const registered = registerDesiredOwners(desired, live);
+    for (const ownerKey of registered.ownerKeys) artifactEpochs.set(ownerKey, replayEpoch);
+    replayArtifact(desired.id);
+    for (const pageId of desired.ownerPageIds) {
+      removeExternalJsForOwner(pageId, desired.id);
+    }
+    applyAssignmentCode(
+      desired.assignment,
+      replayEpoch,
+      appliedExperimentCode,
+      registered.ownerKeys,
+      Array.from(desired.ownerPageIds),
+      true,
+    );
+    invalidatedArtifactIds.delete(desired.id);
+  }
+}
+
+export function invalidateLiveArtifactsForReplay(): void {
+  teardownTransaction(allAppliedPagesWithModes());
+}
+
+export function reconcileArtifacts(
+  desired: Map<ArtifactId, DesiredArtifact>,
+  goalUrl?: string,
+): ArtifactReconcileResult {
+  const result: ArtifactReconcileResult = {
+    applied: 0,
+    ownerUpdates: 0,
+    removed: 0,
+    replayed: 0,
+  };
+
+  const removedArtifactIds = new Set(
+    Array.from(liveArtifactInventory().keys()).filter(
+      (artifactId) => !desired.has(artifactId),
+    ),
+  );
+  if (removedArtifactIds.size > 0) {
+    teardownArtifactsTransaction(removedArtifactIds, { goalUrl });
+    result.removed = removedArtifactIds.size;
+  }
+
+  let live = liveArtifactInventory();
+  for (const [artifactId, liveArtifact] of live) {
+    const wanted = desired.get(artifactId);
+    if (!wanted) continue;
+    for (const pageId of liveArtifact.ownerPageIds) {
+      if (wanted.ownerPageIds.has(pageId)) continue;
+      removeArtifactOwner(artifactId, pageId);
+      result.ownerUpdates += 1;
+    }
+  }
+
+  live = liveArtifactInventory();
+  const missing: DesiredArtifact[] = [];
+  const replay: DesiredArtifact[] = [];
+  for (const wanted of desired.values()) {
+    const existing = live.get(wanted.id);
+    if (!existing) {
+      missing.push(wanted);
+      continue;
+    }
+    if (invalidatedArtifactIds.has(wanted.id)) {
+      replay.push(wanted);
+      continue;
+    }
+    const registered = registerDesiredOwners(wanted, existing);
+    if (registered.added) result.ownerUpdates += 1;
+  }
+
+  replayDesiredArtifacts(replay);
+  result.replayed = replay.length;
+  if (missing.length > 0) {
+    const pageIds = new Set(missing.flatMap((artifact) => Array.from(artifact.ownerPageIds)));
+    applyAssignments(
+      missing.map((artifact) => artifact.assignment),
+      state.activationMode,
+      { pageIds, goalUrl },
+    );
+    result.applied = missing.length;
+  }
+  if (missing.length === 0) syncGlobalRuntimes({ goalUrl });
+  if (replay.length > 0 && missing.length === 0) revealExperimentContent();
+  return result;
+}
+