@drip-apex/sdk 0.1.0 → 0.3.0

package/src/activation-runtime.ts

@@ -0,0 +1,2737 @@
+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 {
+  applyAntiFlicker,
+  bootedTooLateForAntiFlicker,
+  removeAntiFlicker,
+} from "./antiflicker";
+import {
+  clearPersistedAssignments,
+  findPersistedVariation,
+  persistAssignmentForExperiment,
+  prunePersistedAssignments,
+  removePersistedAssignmentsForExperiments,
+  __assignmentStoreInternals,
+} from "./assignment-store";
+import {
+  writeAssignmentSyncCookie,
+  type AssignmentSyncPayload,
+} from "./assignment-cookie-sync";
+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,
+  mintShopwareAttributionEnvelope,
+  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 { attributionLedgerAssignments, PersistedAssignmentMap, GLOBAL_PAGE_PREFIX, appliedAssignmentsByKey, ArtifactId, invalidatedArtifactIds, artifactEpochs, applyPassEpoch, artifactEpochCurrent, PageActivationTransition, normalizePageDeactivationMode, effectiveDeactivationMode, includedPageRules, currentPageMatchContext, pageActivationDiagnosticRows, reconcilePageActivation, cancelPageRulePoll, cancelAllPageRulePolls, pageRulePollSettings, deactivationModeForTriggeredRule, reconcileTriggeredPageMatch, startPageRulePoll, firePageDetector, activePageIds, experimentHasActivePage, syncAssignmentPageActive, assignmentPageIds, stableArtifactJson, artifactContentHash, baseArtifactApplicationKey, artifactApplicationKey, artifactIdFromApplicationKey, assignmentRuntimeKeys, artifactOwnerId, redirectCarryAssignmentKey, shouldPreserveOffTargetRedirectAssignment, isAssignmentArtifactInactive, renderable, exposable, attributable, recordAttributableAssignments, artifactRenderableAssignments, activeRenderableAssignments, chargeAffectingAssignments, loadPersistedAssignments, buildPersistedAssignmentResult, withAssignmentEpochData, usesStickyAssignmentPersistence, persistActiveExperimentAssignments, experimentDiagnostic, evaluateExperimentDetailed, evaluateExperiment, stoppedPersonalizationDiagnostic, enforcePersonalizationStopAfterMatch, excludedByGroupDiagnostic, keptByGroupDiagnostic, applyExclusionAndPersonalization, evaluate, evaluateWithDiagnostics, evaluateEdgeRuntimeAssignments, resolveCombinedEdgeEvaluation, escapeDeliveryRegex, matchSimpleDeliveryPattern, matchRegexDeliveryPattern, matchesDeliveryUrlRules, expandCriticalMutation, buildCriticalPathAssignments, runPostRevealReassert, schedulePostRevealReassert, revealExperimentContent, applyAssignmentCode, recordAppliedAssignment, appliedOwnerKeysForAssignment, applyAssignments, reassertAssignmentMutations, TeardownPage, TeardownRuntimeOptions, TeardownSelection, runAssignmentResetJs, pendingCommercePriceResolve, resolveCommercePricePending, unwireGoals, goalWiringEligible, reconcileGoals, reconcileHarnessPolling, reconcileCommercePrice, reconcileCommerceShipping, reconcileCartSync, syncGlobalRuntimes, configuredPageDeactivationModes, allAppliedPagesWithModes, rollbackArtifactOwner, unregisterArtifactOwner, executeTeardownTransaction, teardownTransaction, teardownArtifactsTransaction, DesiredArtifact, LiveArtifact, ArtifactReconcileResult, desiredArtifactSet, liveArtifactInventory, removeArtifactOwner, registerDesiredOwners, replayDesiredArtifacts, invalidateLiveArtifactsForReplay, reconcileArtifacts } from "./assignment-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 function generateQaSessionId(): string {
+  return "qa_" + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+export const SHOPIFY_ASSIGNMENT_SYNC_DELAYS_MS = [0, 250, 1000, 2500];
+export let shopifyAssignmentSyncTimers: number[] = [];
+
+export type CommerceOnlyAdoptionState = {
+  applying: boolean;
+  assignments: Assignment[];
+  context: string | null;
+};
+
+export let commercePriceAdoptionState: CommerceOnlyAdoptionState | null = null;
+
+export function ensureCommercePriceAdoptionState(): CommerceOnlyAdoptionState {
+  return commercePriceAdoptionState ??= {
+    applying: false,
+    assignments: [],
+    context: null,
+  };
+}
+
+export function currentCommercePriceContext(): string | null {
+  return state.config && state.userId
+    ? `${state.config.shopId}\u0000${state.userId}`
+    : null;
+}
+
+export function withCommercePriceAssignments(assignments = state.assignments): Assignment[] {
+  const adoption = commercePriceAdoptionState;
+  if (
+    !adoption?.assignments.length ||
+    adoption.context !== currentCommercePriceContext()
+  ) return assignments;
+  const activeExperimentIds = new Set(assignments.map((assignment) => assignment.experimentId));
+  const configuredPriceExperimentIds = new Set(
+    state.config?.commerce?.price?.authorization?.experimentIds ?? [],
+  );
+  const configuredOffersExperimentIds = new Set(
+    state.config?.commerce?.offers?.authorization?.experimentIds ?? [],
+  );
+  const experiments = new Map(
+    (state.config?.experiments ?? []).map((experiment) => [experiment.id, experiment]),
+  );
+  const validCommerceOnly = adoption.assignments.filter((assignment) => {
+    if (activeExperimentIds.has(assignment.experimentId)) return false;
+    if (
+      !configuredPriceExperimentIds.has(assignment.experimentId) &&
+      !configuredOffersExperimentIds.has(assignment.experimentId)
+    ) return false;
+    const experiment = experiments.get(assignment.experimentId);
+    return !!experiment &&
+      __assignmentStoreInternals.assignmentEpoch(experiment) === assignment.assignmentEpoch &&
+      experiment.variations.some((variation) => variation.id === assignment.variationId);
+  });
+  return validCommerceOnly.length ? [...assignments, ...validCommerceOnly] : assignments;
+}
+
+export function clearShopifyAssignmentSyncTimers(): void {
+  for (const timer of shopifyAssignmentSyncTimers) {
+    window.clearTimeout(timer);
+  }
+  shopifyAssignmentSyncTimers = [];
+}
+
+export function adoptAuthoritativePriceAssignments(assignments: CartAssignment[]): boolean {
+  const config = state.config;
+  const price = config?.commerce?.price;
+  if (!config || !price || !state.userId) return false;
+  const configuredPriceExperimentIds = new Set(
+    price.authorization?.experimentIds ?? [],
+  );
+  if (configuredPriceExperimentIds.size === 0) return false;
+  const replacements = new Map<string, Assignment>();
+  const nextCommercePriceOnlyAssignments: Assignment[] = [];
+  const seenAuthoritativeExperimentIds = new Set<string>();
+  for (const authoritative of assignments) {
+    if (
+      seenAuthoritativeExperimentIds.has(authoritative.experimentId) ||
+      !configuredPriceExperimentIds.has(authoritative.experimentId) ||
+      !price.experiments.some(
+        (experiment) => experiment.experiment_id === authoritative.experimentId,
+      )
+    ) return false;
+    seenAuthoritativeExperimentIds.add(authoritative.experimentId);
+    const experiment = config.experiments?.find(
+      (candidate) => candidate.id === authoritative.experimentId,
+    );
+    const variationIndex = experiment?.variations.findIndex(
+      (variation) => variation.id === authoritative.variationId,
+    ) ?? -1;
+    if (!experiment || variationIndex < 0) return false;
+    if (
+      authoritative.assignmentEpoch !==
+        __assignmentStoreInternals.assignmentEpoch(experiment)
+    ) return false;
+    const existingAssignment = state.assignments.find(
+      (assignment) => assignment.experimentId === authoritative.experimentId,
+    );
+    const replacement = buildAssignment(
+      experiment,
+      experiment.variations[variationIndex],
+      variationIndex,
+      existingAssignment?.hashValue ?? state.userId,
+      typeof location !== "undefined" ? location.href : undefined,
+    );
+    replacement.pageActive = experimentHasActivePage(experiment);
+    if (authoritative.commercePriceOnly) {
+      nextCommercePriceOnlyAssignments.push(replacement);
+      // A cart-only arm can still replace an existing off-target attribution
+      // assignment. Keep one shared copy in runtime state so revenue and
+      // custom attribution survive while the adoption list marks its cart role.
+      if (existingAssignment) {
+        replacements.set(authoritative.experimentId, replacement);
+      }
+    } else {
+      replacements.set(authoritative.experimentId, replacement);
+    }
+  }
+
+  const nextAssignments = state.assignments
+    .filter((assignment) => !configuredPriceExperimentIds.has(assignment.experimentId));
+  for (const authoritative of assignments) {
+    const replacement = replacements.get(authoritative.experimentId);
+    if (replacement) nextAssignments.push(replacement);
+  }
+
+  const previousAssignments = state.assignments;
+  const adoption = ensureCommercePriceAdoptionState();
+  const previousCommercePriceOnlyAssignments = adoption.assignments;
+  const previousCommercePriceOnlyContext = adoption.context;
+  try {
+    teardownTransaction(allAppliedPagesWithModes(), { skipCartSync: true });
+    state.assignments = nextAssignments;
+    adoption.assignments = [
+      ...previousCommercePriceOnlyAssignments.filter(
+        (assignment) => !configuredPriceExperimentIds.has(assignment.experimentId),
+      ),
+      ...nextCommercePriceOnlyAssignments,
+    ];
+    adoption.context = currentCommercePriceContext();
+    adoption.applying = true;
+    applyAssignments(nextAssignments, state.activationMode);
+    if (assignments.length === 0) cleanupCommercePrice();
+    state.lastAssignmentSignature = assignmentSignature(nextAssignments);
+    if (persistentStorageAllowed() && !state.qaMode) {
+      removePersistedAssignmentsForExperiments(configuredPriceExperimentIds);
+      for (const authoritative of assignments) {
+        if (!replacements.has(authoritative.experimentId)) continue;
+        const experiment = config.experiments?.find(
+          (candidate) => candidate.id === authoritative.experimentId,
+        );
+        if (experiment) {
+          persistAssignmentForExperiment(experiment, authoritative.variationId);
+        }
+      }
+    }
+    if (state.analyticsStarted && !trackingBlocked() && state.trackingPrerequisiteMet) {
+      setupGoalTracking(config.experiments ?? []);
+      setupHeatmapTracking(nextAssignments, config.experiments ?? []);
+      setupReplayTracking(nextAssignments, config.experiments ?? []);
+      scheduleShopifyAssignmentSync();
+    }
+    notifyQaAssistantRuntimeListeners();
+    return true;
+  } catch {
+    state.assignments = previousAssignments;
+    adoption.assignments = previousCommercePriceOnlyAssignments;
+    adoption.context = previousCommercePriceOnlyContext;
+    return false;
+  } finally {
+    adoption.applying = false;
+  }
+}
+
+export type OffersAdoptionPlan = {
+  configuredOffersExperimentIds: Set<string>;
+  replacements: Map<string, Assignment>;
+  nextCommercePriceOnlyAssignments: Assignment[];
+};
+
+export // Pure validation/planning — must not mutate any runtime state, because the
+// cart-sync path runs it BEFORE the cart write to prove the arm is adoptable
+// while the actual adoption is deferred until the write is confirmed.
+function planAuthoritativeOffersAdoption(
+  assignments: CartAssignment[],
+): OffersAdoptionPlan | null {
+  const config = state.config;
+  const offers = config?.commerce?.offers;
+  if (!config || !offers || !state.userId) return null;
+  const configuredOffersExperimentIds = new Set(
+    offers.authorization?.experimentIds ?? [],
+  );
+  if (configuredOffersExperimentIds.size === 0) return null;
+  const replacements = new Map<string, Assignment>();
+  const nextCommercePriceOnlyAssignments: Assignment[] = [];
+  const seenAuthoritativeExperimentIds = new Set<string>();
+  for (const authoritative of assignments) {
+    if (
+      seenAuthoritativeExperimentIds.has(authoritative.experimentId) ||
+      !configuredOffersExperimentIds.has(authoritative.experimentId)
+    ) return null;
+    seenAuthoritativeExperimentIds.add(authoritative.experimentId);
+    const experiment = config.experiments?.find(
+      (candidate) => candidate.id === authoritative.experimentId,
+    );
+    const variationIndex = experiment?.variations.findIndex(
+      (variation) => variation.id === authoritative.variationId,
+    ) ?? -1;
+    if (!experiment || variationIndex < 0) return null;
+    if (
+      authoritative.assignmentEpoch !==
+        __assignmentStoreInternals.assignmentEpoch(experiment)
+    ) return null;
+    const existingAssignment = state.assignments.find(
+      (assignment) => assignment.experimentId === authoritative.experimentId,
+    );
+    const replacement = buildAssignment(
+      experiment,
+      experiment.variations[variationIndex],
+      variationIndex,
+      existingAssignment?.hashValue ?? state.userId,
+      typeof location !== "undefined" ? location.href : undefined,
+    );
+    replacement.pageActive = experimentHasActivePage(experiment);
+    if (authoritative.commercePriceOnly) {
+      nextCommercePriceOnlyAssignments.push(replacement);
+      if (existingAssignment) {
+        replacements.set(authoritative.experimentId, replacement);
+      }
+    } else {
+      replacements.set(authoritative.experimentId, replacement);
+    }
+  }
+  return { configuredOffersExperimentIds, replacements, nextCommercePriceOnlyAssignments };
+}
+
+export function canAdoptAuthoritativeOffersAssignments(assignments: CartAssignment[]): boolean {
+  return planAuthoritativeOffersAdoption(assignments) !== null;
+}
+
+export function adoptAuthoritativeOffersAssignments(assignments: CartAssignment[]): boolean {
+  const config = state.config;
+  const plan = planAuthoritativeOffersAdoption(assignments);
+  if (!config || !plan) return false;
+  const {
+    configuredOffersExperimentIds,
+    replacements,
+    nextCommercePriceOnlyAssignments,
+  } = plan;
+
+  const nextAssignments = state.assignments.filter(
+    (assignment) => !configuredOffersExperimentIds.has(assignment.experimentId),
+  );
+  for (const authoritative of assignments) {
+    const replacement = replacements.get(authoritative.experimentId);
+    if (replacement) nextAssignments.push(replacement);
+  }
+  const previousAssignments = state.assignments;
+  const adoption = ensureCommercePriceAdoptionState();
+  const previousCommercePriceOnlyAssignments = adoption.assignments;
+  const previousCommercePriceOnlyContext = adoption.context;
+  try {
+    teardownTransaction(allAppliedPagesWithModes(), { skipCartSync: true });
+    state.assignments = nextAssignments;
+    adoption.assignments = [
+      ...previousCommercePriceOnlyAssignments.filter(
+        (assignment) => !configuredOffersExperimentIds.has(assignment.experimentId),
+      ),
+      ...nextCommercePriceOnlyAssignments,
+    ];
+    adoption.context = currentCommercePriceContext();
+    adoption.applying = true;
+    applyAssignments(nextAssignments, state.activationMode);
+    state.lastAssignmentSignature = assignmentSignature(nextAssignments);
+    if (persistentStorageAllowed() && !state.qaMode) {
+      removePersistedAssignmentsForExperiments(configuredOffersExperimentIds);
+      for (const authoritative of assignments) {
+        if (!replacements.has(authoritative.experimentId)) continue;
+        const experiment = config.experiments?.find(
+          (candidate) => candidate.id === authoritative.experimentId,
+        );
+        if (experiment) persistAssignmentForExperiment(experiment, authoritative.variationId);
+      }
+    }
+    if (state.analyticsStarted && !trackingBlocked() && state.trackingPrerequisiteMet) {
+      setupGoalTracking(config.experiments ?? []);
+      setupHeatmapTracking(nextAssignments, config.experiments ?? []);
+      setupReplayTracking(nextAssignments, config.experiments ?? []);
+      scheduleShopifyAssignmentSync();
+    }
+    notifyQaAssistantRuntimeListeners();
+    return true;
+  } catch {
+    state.assignments = previousAssignments;
+    adoption.assignments = previousCommercePriceOnlyAssignments;
+    adoption.context = previousCommercePriceOnlyContext;
+    return false;
+  } finally {
+    adoption.applying = false;
+  }
+}
+
+export function sdkCartMintAllowed(): boolean {
+  // The union keeps the original "something to mint" contract for every
+  // consumer (click trigger, merge key-replacement) now that deactivated
+  // session assignments still mint through the attribution ledger.
+  const assignments = [
+    ...state.assignments.filter(attributable),
+    ...attributionLedgerAssignments(),
+  ];
+  return (
+    state.config?.cartAttributeWrite !== "external" &&
+    state.config?.cartAttributeScope === "all" &&
+    !!assignments[0] &&
+    trackingBlocked() !== state.trackingDisabledByDnt
+  );
+}
+
+export function buildSdkCartMintInput(): CartAttributeSyncInput | null {
+  const assignments = [
+    ...state.assignments.filter(attributable),
+    ...attributionLedgerAssignments(),
+  ];
+  if (!sdkCartMintAllowed() || !assignments[0]) return null;
+  return {
+    assignments,
+    // Empty identity values make the Shopify merge clear prior consented identity.
+    visitorId: "",
+    sessionId: "",
+  };
+}
+
+export function buildScopedCartAttributeSyncInput(): CartAttributeSyncInput | null {
+  const assignments = [
+    ...state.assignments.filter(attributable),
+    ...attributionLedgerAssignments(),
+  ];
+  if (
+    state.config?.cartAttributeWrite !== "external" ||
+    state.config?.cartAttributeScope !== "all" ||
+    !state.consentRequired ||
+    state.consentGranted ||
+    state.trackingDisabledByDnt ||
+    !assignments[0]
+  ) return null;
+  return {
+    assignments,
+    visitorId: "",
+    sessionId: "",
+  };
+}
+
+export function buildActiveCartAttributeSyncInput(functionalCartWrite = false): CartAttributeSyncInput | null {
+  if (!functionalCartWrite && (trackingBlocked() || !state.trackingPrerequisiteMet)) return null;
+  const controlStamp = state.holdout && state.assignments.length === 0;
+  const identityOnly = state.config?.holdout_v1_enabled === true
+    && !state.holdout
+    && state.assignments.length === 0
+    && !hasActiveCommerceAuthorizationPlane();
+  if (
+    (
+      !state.assignments.length &&
+      !hasActiveCommerceAuthorizationPlane() &&
+      !controlStamp &&
+      !identityOnly
+    ) ||
+    !state.userId
+  ) return null;
+
+  const activeCartAssignments = withCommercePriceAssignments(state.assignments).filter(attributable);
+  const chargeAffectingExperimentIds = getChargeAffectingCommerceExperimentIds(
+    activeCartAssignments.filter(renderable),
+  );
+  const adoption = commercePriceAdoptionState;
+  const assignments = activeCartAssignments.map((assignment) => ({
+    experimentId: assignment.experimentId,
+    variationId: assignment.variationId,
+    pageActive: assignment.pageActive,
+    assignmentEpoch:
+      !assignment.kind || assignment.kind === "experiment"
+        ? assignment.assignmentEpoch
+        : undefined,
+    ...(adoption?.context === currentCommercePriceContext() &&
+        adoption.assignments.includes(assignment)
+      ? { commercePriceOnly: true }
+      : {}),
+  }));
+  const assignedExperimentIds = new Set(
+    assignments.map((assignment) => assignment.experimentId),
+  );
+  const exclusionGroupSelections = state.config?.exclusionGroups
+    ?.map((group) => {
+      const winner = group.members.find((member) =>
+        assignedExperimentIds.has(member.experimentId)
+      );
+      return winner
+        ? {
+            groupId: group.id,
+            experimentId: winner.experimentId,
+            epoch: Number.isFinite(group.epoch)
+              ? Math.max(1, Math.floor(group.epoch ?? 1))
+              : 1,
+          }
+        : null;
+    })
+    .filter((selection): selection is NonNullable<typeof selection> =>
+      selection !== null
+    );
+
+  return {
+    assignments,
+    controlStamp: controlStamp || undefined,
+    identityOnly: identityOnly || undefined,
+    requiredAssignments: chargeAffectingExperimentIds.size > 0
+      ? assignments.filter((assignment) =>
+        chargeAffectingExperimentIds.has(assignment.experimentId))
+      : undefined,
+    visitorId: state.userId,
+    sessionId: state.tracker?.getSessionId() ?? "",
+    shopId: state.config?.ingestShopId ?? state.config?.shopId,
+    endpoint: state.config?.endpoint,
+    ingestSignature: state.config?.ingestSignature,
+    url: typeof location !== "undefined" ? location.href : undefined,
+    environment: state.config?.environments?.activeKey,
+    platform: state.platform,
+    onAttributionEnvelope: (envelope) => {
+      state.shopwareAttributionEnvelope = envelope;
+      if (typeof document !== "undefined") {
+        document.dispatchEvent(new CustomEvent("apex:attribution-envelope"));
+      }
+    },
+    offersAuthorizationRevision:
+      state.config?.commerce?.offers?.authorization?.revision,
+    offersExperimentIds:
+      state.config?.commerce?.offers?.authorization?.experimentIds,
+    shippingAuthorizationRevision:
+      state.config?.commerce?.shipping?.authorization?.revision,
+    shippingExperimentIds:
+      state.config?.commerce?.shipping?.authorization?.experimentIds,
+    priceAuthorizationRevision:
+      state.config?.commerce?.price?.authorization?.revision,
+    priceExperimentIds:
+      state.config?.commerce?.price?.authorization?.experimentIds,
+    onCartToken: (cartToken) => {
+      if (state.shopifyCartToken === cartToken) return;
+      state.shopifyCartToken = cartToken;
+      if (state.analyticsStarted) publishAssignmentsToShopify();
+    },
+    ...(state.config?.commerce?.offers?.authorization?.experimentIds?.length
+      ? {
+          adoptOffersAssignments: adoptAuthoritativeOffersAssignments,
+          canAdoptOffersAssignments: canAdoptAuthoritativeOffersAssignments,
+          authorizeOffersDisplayAssignments: authorizeOffersDisplayAndRender,
+        }
+      : {}),
+    // Every stamped cart write returns the full cart; marked GWP lines seen
+    // there seed durable insertion records so a fresh device or cleared
+    // storage over a persistent/customer-synced cart still reconciles gifts.
+    onCartSnapshot: (cart: unknown) => {
+      if (noteCartSnapshotForGifts(cart)) {
+        void syncGiftWithPurchase(
+          state.config?.commerce?.offers,
+          withCommercePriceAssignments(state.assignments).filter(attributable),
+          giftSyncOptions(),
+        );
+      }
+    },
+    ...(hasActivePriceAuthorizationPlane()
+      ? {
+          adoptPriceAssignments: adoptAuthoritativePriceAssignments,
+          authorizePriceDisplayAssignments: (authorizedAssignments: CartAssignment[]) => {
+            state.authorizedPriceAssignmentKeys = new Set(
+              authorizedAssignments.map(priceAssignmentAuthorizationKey),
+            );
+          },
+        }
+      : {}),
+    ...(hasActiveShippingAuthorizationPlane()
+      ? {
+          authorizeShippingDisplayAssignments: (authorizedAssignments: CartAssignment[]) => {
+            state.authorizedShippingAssignmentKeys = new Set(
+              authorizedAssignments.map(priceAssignmentAuthorizationKey),
+            );
+          },
+        }
+      : {}),
+    exclusionGroupSelections:
+      exclusionGroupSelections?.length ? exclusionGroupSelections : undefined,
+  };
+}
+
+export let sdkCartMintSync: ReturnType<typeof syncShopifyCartAttributes> | null = null;
+
+export function syncSdkCartMint(): void {
+  const input = !sdkCartMintSync && buildSdkCartMintInput();
+  if (!input) return;
+  const pending = sdkCartMintSync = syncShopifyCartAttributes(input);
+  const finish = () => {
+    if (sdkCartMintSync !== pending) return;
+    sdkCartMintSync = null;
+    if (!trackingBlocked()) syncActiveAssignmentToShopifyCart();
+  };
+  void pending.then(finish, finish);
+}
+
+export /**
+ * Mint on the first capture-phase click while Shopify identifies a product page.
+ * Capture starts the empty-cart write before an add-to-cart bubble handler runs.
+ */
+const removeSdkCartMintTrigger = () =>
+  document.removeEventListener("click", onSdkCartMintClick, true);
+
+export function onSdkCartMintClick(): void {
+  if (!sdkCartMintAllowed() || readShopifySignal("shopify.page_type") !== "product") return;
+  removeSdkCartMintTrigger();
+  syncSdkCartMint();
+}
+
+export function installSdkCartMintTrigger(): void {
+  removeSdkCartMintTrigger();
+  if (!sdkCartMintAllowed()) return;
+  document.addEventListener("click", onSdkCartMintClick, { capture: true, passive: true });
+}
+
+export type HeadlessCartAuthorizationState = {
+  generation: number;
+  confirmationPending: boolean;
+  pending: {
+    generation: number;
+    cartToken: string;
+    priceAssignments: CartAssignment[];
+    shippingAssignments: CartAssignment[];
+    offersAssignments: CartAssignment[];
+    offersAdoptionAssignments: CartAssignment[] | null;
+  } | null;
+};
+
+export let headlessCartAuthorizationState: HeadlessCartAuthorizationState | null = null;
+
+export function ensureHeadlessCartAuthorizationState(): HeadlessCartAuthorizationState {
+  return headlessCartAuthorizationState ??= {
+    generation: 0,
+    confirmationPending: false,
+    pending: null,
+  };
+}
+
+export function hasChargeAffectingCommerceAssignment(assignments = state.assignments): boolean {
+  return getChargeAffectingCommerceExperimentIds(assignments).size > 0;
+}
+
+export function hasActiveAuthorizationPlane(plane: "price" | "shipping" | "offers"): boolean {
+  const authorization = state.config?.commerce?.[plane]?.authorization;
+  return authorization?.version === 1
+    && Number.isSafeInteger(authorization.revision)
+    && authorization.revision > 0
+    && Array.isArray(authorization.experimentIds)
+    && authorization.experimentIds.length > 0;
+}
+
+export const hasActivePriceAuthorizationPlane = () => hasActiveAuthorizationPlane("price");
+export const hasActiveShippingAuthorizationPlane = () => hasActiveAuthorizationPlane("shipping");
+export const hasActiveOffersAuthorizationPlane = () => hasActiveAuthorizationPlane("offers");
+
+export function hasActiveCommerceAuthorizationPlane(): boolean {
+  if (hasActivePriceAuthorizationPlane() || hasActiveOffersAuthorizationPlane()) return true;
+  const authorization = state.config?.commerce?.shipping?.authorization;
+  return authorization?.version === 1
+    && Number.isSafeInteger(authorization.revision)
+    && authorization.revision > 0
+    && Array.isArray(authorization.experimentIds)
+    && authorization.experimentIds.length > 0;
+}
+
+export function requiresCommerceCohortPin(assignments = state.assignments): boolean {
+  return hasActivePriceAuthorizationPlane()
+    || hasActiveOffersAuthorizationPlane()
+    || hasChargeAffectingCommerceAssignment(withCommercePriceAssignments(assignments).filter(attributable));
+}
+
+export function getChargeAffectingCommerceExperimentIds(
+  assignments = state.assignments,
+): Set<string> {
+  const active = new Map(
+    assignments
+      .filter((assignment) => !assignment.isControl)
+      .map((assignment) => [assignment.experimentId, assignment.variationId]),
+  );
+  const chargeAffecting = new Set<string>();
+  state.config?.commerce?.price?.experiments.forEach((experiment) => {
+    const variationId = active.get(experiment.experiment_id);
+    const assignment = assignments.find(
+      (candidate) => candidate.experimentId === experiment.experiment_id,
+    );
+    if (variationId != null
+      && (experiment.assignment_epoch == null
+        || experiment.assignment_epoch === assignment?.assignmentEpoch)
+      && experiment.variants[variationId]?.some(
+        (adjustment) => typeof adjustment.fixedPricePerUnit === "string",
+      )) {
+      chargeAffecting.add(experiment.experiment_id);
+    }
+  });
+
+  const offerExperimentIds = new Set(
+    state.config?.commerce?.offers?.authorization?.experimentIds ?? [],
+  );
+  for (const experimentId of offerExperimentIds) {
+    if (active.has(experimentId)) chargeAffecting.add(experimentId);
+  }
+
+  const shipping = state.config?.commerce?.shipping;
+  const enforcedExperimentIds = new Set(shipping?.authorization?.experimentIds ?? []);
+  shipping?.experiments.forEach((experiment) => {
+    const variationId = active.get(experiment.experiment_id);
+    const assignment = assignments.find(
+      (candidate) => candidate.experimentId === experiment.experiment_id,
+    );
+    const variant = variationId == null ? undefined : experiment.variants[variationId];
+    if (enforcedExperimentIds.has(experiment.experiment_id)
+      && (experiment.assignment_epoch == null
+        || experiment.assignment_epoch === assignment?.assignmentEpoch)
+      && variant?.treatment !== "none"
+      && isShippingCartEligible(experiment.experiment_id)) {
+      chargeAffecting.add(experiment.experiment_id);
+    }
+  });
+  return chargeAffecting;
+}
+
+export function isCohortStampedOnCart(): boolean | "pending" {
+  if (headlessCartAuthorizationState?.confirmationPending) return false;
+  if (state.lastShopifyCartSync?.status === "pending") return "pending";
+  return state.lastShopifyCartSync?.status === "sent";
+}
+
+export function syncActiveAssignmentToShopifyCart(options: {
+  chargeCorrectness?: boolean;
+  force?: boolean;
+  holdoutCartClear?: boolean;
+} = {}): void {
+  if (state.platform === "shopware") {
+    if (!trackingBlocked()) {
+      const shopwareInput = buildActiveCartAttributeSyncInput();
+      if (shopwareInput) void mintShopwareAttributionEnvelope(shopwareInput);
+    }
+    return;
+  }
+  if (state.config?.cartAttributeWrite === "external") {
+    runtimeSharedState.shopifyCartSyncGeneration += 1;
+    invalidateShopifyCartAttributeSync();
+    return;
+  }
+  if (!trackingBlocked() && sdkCartMintSync) return;
+  const chargeCorrectness = options.chargeCorrectness === true
+    && requiresCommerceCohortPin();
+  const holdoutCartClear = options.holdoutCartClear === true
+    && state.holdout
+    && state.config?.holdout_v1_enabled === true
+    && state.assignments.length === 0;
+  const functionalCartWrite = chargeCorrectness || holdoutCartClear;
+  if (!functionalCartWrite && (trackingBlocked() || !state.trackingPrerequisiteMet)) return;
+  const input = buildActiveCartAttributeSyncInput(functionalCartWrite);
+  if (!input) return;
+  const generation = ++runtimeSharedState.shopifyCartSyncGeneration;
+  const authorizationUnavailable = cannotRequestRequiredCommerceAuthorization(input);
+  if (hasActivePriceAuthorizationPlane()) {
+    state.authorizedPriceAssignmentKeys?.clear();
+  }
+  if (hasActiveShippingAuthorizationPlane()) {
+    state.authorizedShippingAssignmentKeys?.clear();
+  }
+  // Offers display keys are deliberately NOT cleared at sync start: their
+  // renderer is applyAssignments itself, which triggers this sync — clearing
+  // here would revoke the authorization the re-apply is acting on. Applied
+  // DOM cannot be un-rendered by a key clear anyway; the keys are replaced
+  // wholesale by each completed authorization (exposure stays deduped).
+  state.lastShopifyCartSync = {
+    at: Date.now(),
+    status: authorizationUnavailable ? "failed" : "pending",
+    reason: authorizationUnavailable ? "authorization_failed" : undefined,
+    assignmentCount: state.assignments.length,
+  };
+  void syncShopifyCartAttributes(input, { force: options.force }).then((result) => {
+    if (generation !== runtimeSharedState.shopifyCartSyncGeneration) return;
+    state.lastShopifyCartSync = {
+      at: Date.now(),
+      status: result.status,
+      reason: result.reason,
+      assignmentCount: state.assignments.length,
+    };
+    if (result.status === "failed") {
+      // Fail-closed: the stamp refresh failed, so the Function may already
+      // refuse lines this cart still carries (e.g. the shopper dropped below
+      // the GWP threshold right before the failed sync). Run privilege-
+      // reducing gift cleanup — removals and normalization only, no inserts.
+      void syncGiftWithPurchase(
+        state.config?.commerce?.offers,
+        withCommercePriceAssignments(state.assignments).filter(attributable),
+        giftSyncOptions({ suppressInsertion: true }),
+      );
+    }
+    if (result.status === "sent") {
+      void syncGiftWithPurchase(
+        state.config?.commerce?.offers,
+        withCommercePriceAssignments(state.assignments).filter(attributable),
+        giftSyncOptions(),
+      );
+      notifyCommerceCartStampConfirmed();
+      // Render plane, not the raw assignment list: a deactivated page's
+      // shipping treatment must not come back on a cart-stamp callback.
+      reconcileCommerceShipping();
+      if (state.analyticsStarted && state.config && !trackingBlocked()) {
+        trackViewedAssignments(state.config);
+      }
+    } else if (hasActivePriceAuthorizationPlane()) {
+      cleanupCommercePrice();
+    }
+  });
+}
+
+export function configureChargeCorrectnessCartSync(assignments: Assignment[]): void {
+  state.stopShopifyCartMutationSync?.();
+  state.stopShopifyCartMutationSync = null;
+  if (!requiresCommerceCohortPin(assignments)) {
+    // Commerce planes exist but none is charge-affecting anymore, so the
+    // sync (and its post-"sent" gift pass) will not run; still give the gift
+    // manager its teardown-cleanup chance for an earlier insertion, and keep
+    // it subscribed to cart mutations — a login/customer-account cart merge
+    // can land an Apex-marked line long after the once-per-page check.
+    if (state.config?.commerce?.offers) {
+      state.stopShopifyCartMutationSync = onShopifyCartMutation(() => {
+        void syncGiftWithPurchase(
+          state.config?.commerce?.offers,
+          withCommercePriceAssignments(state.assignments).filter(attributable),
+          giftSyncOptions({ recheckTeardown: true }),
+        );
+      });
+    }
+    void syncGiftWithPurchase(state.config?.commerce?.offers, withCommercePriceAssignments(state.assignments).filter(attributable));
+    return;
+  }
+
+  state.stopShopifyCartMutationSync = onShopifyCartMutation(() => {
+    syncActiveAssignmentToShopifyCart({ chargeCorrectness: true, force: true });
+  });
+  if (commercePriceAdoptionState?.applying) return;
+  // This narrow consent/DNT exemption is charge-correctness, not analytics:
+  // the first-party cart attribute contains only assignment ids/epoch and must
+  // exist whenever a commerce treatment can change what the shopper is charged.
+  syncActiveAssignmentToShopifyCart({ chargeCorrectness: true });
+}
+
+export function holdoutConfigEpoch(config: InitConfig | null | undefined): number | undefined {
+  const raw = config?.holdout_config_updated_at;
+  const epoch = typeof raw === "string" ? Date.parse(raw) : Number.NaN;
+  return Number.isSafeInteger(epoch) && epoch > 0 ? epoch : undefined;
+}
+
+function buildShopifyAssignmentSyncPayload(
+  assignments: AssignmentSyncPayload["assignments"],
+): AssignmentSyncPayload {
+  return {
+    visitorId: state.userId,
+    sessionId: state.tracker?.getSessionId() ?? "",
+    ...(state.shopifyCartToken ? { cartToken: state.shopifyCartToken } : {}),
+    qaMode: state.qaMode,
+    qaSessionId: state.qaSessionId,
+    cohort: state.config?.holdout_v1_enabled === true
+      ? (state.holdout ? "holdout" : "active")
+      : undefined,
+    holdoutConfigEpoch: holdoutConfigEpoch(state.config),
+    assignments,
+  };
+}
+
+export /**
+ * Publish current experiment assignments to Shopify's analytics bus.
+ * The Drip Web Pixel subscribes to this custom event to attribute
+ * Shopify standard events (checkout, add_to_cart, etc.) to experiments.
+ *
+ * No-op on non-Shopify stores — guarded by the Shopify global check.
+ */
+function publishAssignmentsToShopify(): void {
+  if (trackingBlocked() || !state.trackingPrerequisiteMet) {
+    state.lastShopifyAssignmentSync = {
+      at: Date.now(),
+      status: "skipped",
+      reason: "tracking_blocked",
+      assignmentCount: state.assignments.length,
+    };
+    return;
+  }
+  try {
+    const assignments = state.assignments.filter(attributable).map((assignment) => ({
+      experimentId: assignment.experimentId,
+      variationId: assignment.variationId,
+      assignmentEpoch:
+        !assignment.kind || assignment.kind === "experiment"
+          ? assignment.assignmentEpoch
+          : undefined,
+    }));
+    const payload = buildShopifyAssignmentSyncPayload(assignments);
+    const publish = (window as any).Shopify?.analytics?.publish;
+    if (typeof publish !== "function") {
+      if (state.config?.assignmentCookieSync === false) {
+        state.lastShopifyAssignmentSync = {
+          at: Date.now(),
+          status: "skipped",
+          reason: "assignment_cookie_sync_disabled",
+          assignmentCount: state.assignments.length,
+        };
+        return;
+      }
+      const cookieResult = writeAssignmentSyncCookie(payload);
+      state.lastShopifyAssignmentSync = {
+        at: Date.now(),
+        status: cookieResult.written ? "cookie_fallback" : "skipped",
+        reason: cookieResult.written ? undefined : cookieResult.reason ?? "shopify_publish_missing",
+        assignmentCount: state.assignments.length,
+        truncatedAssignmentCount: cookieResult.truncatedAssignmentCount,
+      };
+      return;
+    }
+
+    publish("drip_assignment_sync", payload);
+    state.lastShopifyAssignmentSync = {
+      at: Date.now(),
+      status: "sent",
+      assignmentCount: state.assignments.length,
+    };
+  } catch (error) {
+    state.lastShopifyAssignmentSync = {
+      at: Date.now(),
+      status: "failed",
+      reason: error instanceof Error ? error.message : String(error),
+      assignmentCount: state.assignments.length,
+    };
+  }
+}
+
+export function scheduleShopifyAssignmentSync(): void {
+  clearShopifyAssignmentSyncTimers();
+  if (state.config?.runtimeProfile === "empty_project" && state.perfFlags.perf_empty_project_v1) {
+    return;
+  }
+  for (const delay of SHOPIFY_ASSIGNMENT_SYNC_DELAYS_MS) {
+    if (delay <= 0) {
+      publishAssignmentsToShopify();
+      continue;
+    }
+    shopifyAssignmentSyncTimers.push(
+      window.setTimeout(publishAssignmentsToShopify, delay),
+    );
+  }
+}
+
+export function variationsAllowed(config: InitConfig): boolean {
+  return evaluateProjectPrerequisite(
+    config.projectPrerequisites?.showVariationsRule,
+    buildPrerequisiteContext(
+      config,
+      state.userId,
+      state.consentRequired,
+      state.consentGranted,
+      "show_variations",
+    ),
+    true,
+  );
+}
+
+export function updateProjectActivationDiagnostics(config: InitConfig): void {
+  const variationGate: ActivationGateDiagnostic = {
+    id: "environment",
+    label: "Project variation gate",
+    status: state.variationPrerequisiteMet ? "passed" : "failed",
+    reason: state.variationPrerequisiteMet ? "show_variations_allowed" : "show_variations_blocked",
+  };
+  const trackingGate: ActivationGateDiagnostic = {
+    id: "tracking",
+    label: "Tracking gate",
+    status: trackingBlocked() || !state.trackingPrerequisiteMet ? "failed" : "passed",
+    reason: trackingBlocked()
+      ? "consent_or_dnt_blocked"
+      : state.trackingPrerequisiteMet
+        ? "start_tracking_allowed"
+        : "start_tracking_blocked",
+  };
+  const goalsGate: ActivationGateDiagnostic = {
+    id: "goals",
+    label: "Goal listeners",
+    status: state.analyticsStarted ? "passed" : "skipped",
+    reason: state.analyticsStarted ? "listeners_active" : "tracking_not_started",
+    detail: { goals: (config.experiments ?? []).reduce((count, experiment) => count + (experiment.goals?.length ?? 0), 0) },
+  };
+  state.activationDiagnostics.project = { gates: [variationGate, trackingGate, goalsGate] };
+}
+
+export function trackingAllowed(config: InitConfig): boolean {
+  return evaluateProjectPrerequisite(
+    config.projectPrerequisites?.startTrackingRule,
+    buildPrerequisiteContext(
+      config,
+      state.userId,
+      state.consentRequired,
+      state.consentGranted,
+      "start_tracking",
+    ),
+    true,
+  );
+}
+
+export function experimentById(experiments: Experiment[]): Map<string, Experiment> {
+  return new Map(experiments.map((experiment) => [experiment.id, experiment]));
+}
+
+export function targetingLifecycleMode(
+  experiment: Experiment | undefined,
+): "reset" | "deactivate" | "force_reset" | "persistent" {
+  const mode = experiment?.targeting?.lifecycle?.mode;
+  return mode === "reset" ||
+    mode === "deactivate" ||
+    mode === "force_reset" ||
+    mode === "persistent"
+    ? mode
+    : "reset";
+}
+
+export function preservePersistentAssignments(
+  previous: Assignment[],
+  next: Assignment[],
+  experiments: Experiment[],
+): Assignment[] {
+  if (!previous.length) return next;
+  const experimentsById = experimentById(experiments);
+  const nextExperimentIds = new Set(next.map((assignment) => assignment.experimentId));
+  const persistent = previous.filter(
+    (assignment) => {
+      if (nextExperimentIds.has(assignment.experimentId)) return false;
+      const experiment = experimentsById.get(assignment.experimentId);
+      if (!experiment) return false;
+      return targetingLifecycleMode(experiment) === "persistent" ||
+        includedPageRules(experiment).some(
+          (rule) =>
+            effectiveDeactivationMode(experiment, rule) === "persistent",
+        );
+    },
+  );
+  return persistent.length ? [...next, ...persistent] : next;
+}
+
+export function stopAnalyticsStage(): void {
+  clearScheduledAnalyticsStart();
+  clearShopifyAssignmentSyncTimers();
+  state.pendingPerf = null;
+  state.pendingDeliveryHealth = [];
+  unwireGoals();
+  cleanupHeatmapTracking();
+  cleanupReplayTracking();
+  cleanupSemanticTracking();
+  if (state.tracker) {
+    state.tracker.stop();
+    state.tracker = null;
+  }
+  state.analyticsStarted = false;
+  state.exposedAssignmentKeys.clear();
+  if (state.config && state.config.runtimeProfile !== "empty_project") {
+    updateProjectActivationDiagnostics(state.config);
+  }
+}
+
+export function canMintVerifiedRedirectCarry(config: InitConfig): boolean {
+  return Boolean(
+    config.shopId &&
+    config.endpoint &&
+    config.ingestSignature &&
+    config.externalTracking?.signed !== false,
+  );
+}
+
+export function planRedirectAssignment(
+  config: InitConfig,
+  experiments: Experiment[],
+  assignments: Assignment[],
+): ReturnType<typeof redirectPlanForAssignment> {
+  if (state.holdout) return null;
+  return !state.qaMode && !state.screenshotMode
+    ? redirectPlanForAssignment(
+        experiments,
+        assignments,
+        location.href,
+        state.userId ?? "",
+        config.externalTracking,
+        // Match the external-link handover chokepoint: consent-pending (and DNT)
+        // redirects still navigate, but cannot link attribution across origins.
+        // The destination intentionally mints an independent identity.
+        persistentStorageAllowed() && canMintVerifiedRedirectCarry(config),
+        configuredStoreOrigins(config),
+      )
+    : null;
+}
+
+export function navigateForRedirectAssignment(
+  config: InitConfig,
+  experiments: Experiment[],
+  assignments: Assignment[],
+): boolean {
+  const redirectPlan = planRedirectAssignment(config, experiments, assignments);
+  if (!redirectPlan) return false;
+
+  state.redirectNavigationPending = true;
+  // A fresh network config can replace a cached visual config while the
+  // cached after-hydration apply is still pending. Redirect navigation has no
+  // DOM apply to wait for, so detach that stale gate before emitting the
+  // redirect exposure; otherwise both analytics startup and track() queue
+  // behind a promise that cannot settle before location.replace unloads us.
+  state.pendingInitialApply = null;
+  if (state.analyticsStarted) {
+    // A DOM/manual/prerequisite recheck can discover the redirect after this
+    // pageload already exposed the assignment. Keep the pageload dedupe key:
+    // track only when it has not yet been recorded, and never contaminate the
+    // arm with a second exposure immediately before navigation.
+    trackViewedAssignments(config, [redirectPlan.assignment]);
+  } else {
+    startAnalyticsStage(config, experiments, [redirectPlan.assignment]);
+  }
+  // Start the keepalive request before navigation. The redirect assignment is
+  // now in the tracker queue and must not wait for the normal batch interval,
+  // because location.replace may tear down this document immediately.
+  void state.tracker?.flush();
+  if (
+    state.exposedAssignmentKeys.has(
+      exposureAssignmentKey(redirectPlan.assignment),
+    )
+  ) {
+    markRedirectAssignmentCarryExposed(redirectPlan.destination);
+  }
+  const canMintVerifiedCarry = canMintVerifiedRedirectCarry(config);
+  if (
+    canMintVerifiedCarry &&
+    hasGeneratedRedirectAssignmentCarry(redirectPlan.destination)
+  ) {
+    void mintBucketingHandoverPayload(
+      config,
+      state.userId ?? "",
+      [redirectPlan.assignment],
+    ).then((verifiedToken) => {
+      finalizeRedirectAssignmentCarryHandover(
+        redirectPlan.destination,
+        verifiedToken,
+      );
+      location.replace(redirectPlan.destination.href);
+    });
+    return true;
+  }
+  location.replace(redirectPlan.destination.href);
+  return true;
+}
+
+export /** Bounds the unwind drain below; a stuck reset-JS/pushState pair must not livelock. */
+const RECONCILE_MAX_DRAINS = 3;
+
+export /**
+ * Serialize reconciliation. A nested pass — merchant reset JS calling
+ * `history.pushState` (the router notifies synchronously), or `drip.reevaluate()`
+ * from variation JS — would read a page mid-teardown and let the outer pass
+ * delete artifacts the nested pass just applied. A nested call only records
+ * that another pass is due. The outer pass drains it on unwind and re-derives
+ * URL, targeting, and page activation from live state, so a nested navigation
+ * still lands; the drain runs the outer pass's own reason and force flag.
+ */
+function reevaluateAssignments(
+  reason: "url" | "dom" | "manual" | "prerequisite",
+  forceReapply = false,
+  skipHoldGate = false,
+  pageRuleScope?: PageRuleReconcileScope,
+): Assignment[] {
+  if (state.reconcileInProgress) {
+    state.reconcilePending = true;
+    return state.assignments;
+  }
+  for (let drain = 0; drain < RECONCILE_MAX_DRAINS; drain += 1) {
+    state.reconcilePending = false;
+    state.reconcileInProgress = true;
+    try {
+      // Every pass path leaves its result in state.assignments.
+      reevaluateAssignmentsPass(
+        reason,
+        forceReapply,
+        skipHoldGate,
+        pageRuleScope,
+      );
+    } finally {
+      state.reconcileInProgress = false;
+    }
+    if (!state.reconcilePending) break;
+  }
+  if (state.reconcilePending) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugWarn("eval", "Reconcile drain limit reached; dropped a queued re-evaluation");
+  }
+  state.reconcilePending = false;
+  return state.assignments;
+}
+
+export function reevaluateAssignmentsPass(
+  reason: "url" | "dom" | "manual" | "prerequisite",
+  forceReapply: boolean,
+  skipHoldGate: boolean,
+  pageRuleScope?: PageRuleReconcileScope,
+): Assignment[] {
+  if (!state.config || !state.userId) return state.assignments;
+  if (state.pendingInitialApply) {
+    // The initial apply is gated behind hydration (after_hydration / a
+    // pre-init hold). Running a recheck now — e.g. setConsent() before
+    // hydration settles — would apply mutations outside the gate; queue ONE
+    // coalesced recheck until the gate opens (mutation storms during a
+    // multi-second hydration window must not each schedule a full scan).
+    if (state.queuedRecheck) {
+      state.queuedRecheck.reason = reason;
+      state.queuedRecheck.forceReapply =
+        state.queuedRecheck.forceReapply || forceReapply;
+      if (state.queuedRecheck.pageRuleScope && pageRuleScope) {
+        state.queuedRecheck.pageRuleScope = {
+          triggeredPageIds: new Set([
+            ...state.queuedRecheck.pageRuleScope.triggeredPageIds,
+            ...pageRuleScope.triggeredPageIds,
+          ]),
+          includeImmediate:
+            state.queuedRecheck.pageRuleScope.includeImmediate ||
+            pageRuleScope.includeImmediate,
+        };
+      } else {
+        // A queued global pass must remain global.
+        state.queuedRecheck.pageRuleScope = undefined;
+      }
+    } else {
+      state.queuedRecheck = {
+        reason,
+        forceReapply,
+        pageRuleScope: pageRuleScope
+          ? {
+              triggeredPageIds: new Set(pageRuleScope.triggeredPageIds),
+              includeImmediate: pageRuleScope.includeImmediate,
+            }
+          : undefined,
+      };
+      void state.pendingInitialApply.then(() => {
+        const queued = state.queuedRecheck;
+        state.queuedRecheck = null;
+        if (queued) {
+          reevaluateAssignments(
+            queued.reason,
+            queued.forceReapply,
+            false,
+            queued.pageRuleScope,
+          );
+        }
+      });
+    }
+    return state.assignments;
+  }
+  if (!skipHoldGate && hasMutationHold()) {
+    // A framework hold (drip.hold()) during an SPA route hydration defers
+    // recheck applies exactly like the initial one. The gate fails open at
+    // the hydration timeout; skipHoldGate prevents re-gating after that.
+    const gate: Promise<void> = awaitHydration(
+      state.config.spa?.hydrationTimeoutMs ?? 3_000,
+      { waitForHydration: false },
+    ).then(() => {
+      if (state.pendingInitialApply === gate) state.pendingInitialApply = null;
+      reevaluateAssignments(
+        reason,
+        forceReapply,
+        true,
+        pageRuleScope,
+      );
+    });
+    state.pendingInitialApply = gate;
+    return state.assignments;
+  }
+  if (state.config.runtimeProfile === "empty_project" && state.perfFlags.perf_empty_project_v1) {
+    state.assignments = [];
+    state.variationPrerequisiteMet = true;
+    state.activationDiagnostics = { project: { gates: [] }, experiments: [] };
+    state.lastAssignmentSignature = "none";
+    reconcileArtifacts(new Map());
+    return state.assignments;
+  }
+  const exps = state.config.experiments ?? [];
+
+  captureUrlSignals(state.config);
+  captureDomAndGlobalSignals(state.config);
+  state.variationPrerequisiteMet = variationsAllowed(state.config);
+  updateProjectActivationDiagnostics(state.config);
+  if (!state.variationPrerequisiteMet) {
+    state.assignments = [];
+    state.activationDiagnostics.experiments = [];
+    state.lastAssignmentSignature = "none";
+    reconcileArtifacts(new Map());
+    revealAll();
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `Variations blocked by project prerequisite (${reason})`);
+    notifyQaAssistantRuntimeListeners();
+    return state.assignments;
+  }
+
+  const evaluationUrl = location.href;
+  const targetingSourceAttributes = state.config.attributes ??
+    EMPTY_TARGETING_ATTRIBUTES;
+  const targetingPass = createTargetingEvaluationPass(
+    targetingSourceAttributes,
+    evaluationUrl,
+    persistentStorageAllowed(),
+  );
+  const previousRuntimeKeys = assignmentRuntimeKeys(state.assignments);
+  const pageActivation = reconcilePageActivation(exps, evaluationUrl, {
+    targetingPass,
+    pageRuleScope,
+  });
+  const teardownPages = pageActivation.transitions
+    .filter((transition) => transition.teardown)
+    .map((transition) => ({ pageId: transition.pageId, mode: transition.mode }));
+  if (teardownPages.length > 0) {
+    teardownTransaction(teardownPages, { goalUrl: evaluationUrl });
+  }
+  state.pageActivation = pageActivation.next;
+  pageActivation.pollRules.forEach((rule) => startPageRulePoll(rule));
+  syncAssignmentPageActive(state.assignments, exps);
+  const edgeEligibility = state.config.userId == null && edgeRuntimeActive()
+    ? evaluateWithDiagnostics(exps, {
+        url: evaluationUrl,
+        attributes: targetingSourceAttributes,
+        userId: state.userId,
+        persistSignals: persistentStorageAllowed(),
+        storeOrigin: configuredStoreOrigins(state.config),
+        targetingPass,
+      })
+    : null;
+  const edgeEvaluation = edgeEligibility
+    ? evaluateEdgeRuntimeAssignments(
+        exps,
+        {
+          url: evaluationUrl,
+          attributes: targetingAttributesForPass(
+            targetingPass,
+            targetingSourceAttributes,
+            evaluationUrl,
+            persistentStorageAllowed(),
+          ),
+          userId: state.userId,
+        },
+        edgeEligibility.assignments,
+        edgeEligibility.diagnostics,
+      )
+    : null;
+  const fallbackExperiments = edgeEvaluation
+    ? edgeEvaluation.experimentIds.size > 0
+      ? exps.filter((experiment) => !edgeEvaluation.experimentIds.has(experiment.id))
+      : []
+    : exps;
+  const fallbackEvaluation = evaluateWithDiagnostics(fallbackExperiments, {
+    url: evaluationUrl,
+    attributes: targetingSourceAttributes,
+    userId: state.userId,
+    persistSignals: persistentStorageAllowed(),
+    storeOrigin: configuredStoreOrigins(state.config),
+    exclusionGroups: state.config.exclusionGroups,
+    targetingPass,
+  });
+  const evaluation = edgeEvaluation
+    ? resolveCombinedEdgeEvaluation(
+        edgeEvaluation.assignments,
+        fallbackEvaluation.assignments,
+        [...edgeEvaluation.diagnostics, ...fallbackEvaluation.diagnostics],
+        {
+          userId: state.userId,
+          exclusionGroups: state.config.exclusionGroups,
+        },
+      )
+    : fallbackEvaluation;
+  const preserved = preservePersistentAssignments(
+    edgeEvaluation
+      ? state.assignments.filter(
+          (assignment) => !edgeEvaluation.experimentIds.has(assignment.experimentId),
+        )
+      : state.assignments,
+    evaluation.assignments,
+    exps,
+  );
+  // A persistent targeting lifecycle may reintroduce a prior assignment after
+  // pass two. Re-run the group plane so that cannot resurrect a group loser.
+  const updated = syncAssignmentPageActive(filterUnsafeRedirectAssignments(
+    exps,
+    applyExclusionAndPersonalization(preserved, {
+      userId: state.userId,
+      exclusionGroups: state.config.exclusionGroups,
+    }).assignments,
+    evaluationUrl,
+    state.userId,
+    state.config.externalTracking,
+    shouldPreserveOffTargetRedirectAssignment,
+    configuredStoreOrigins(state.config),
+  ), exps);
+  state.activationDiagnostics.experiments = evaluation.diagnostics;
+  const nextSignature = assignmentSignature(updated);
+  const signatureChanged = nextSignature !== state.lastAssignmentSignature;
+  state.lastAssignmentSignature = nextSignature;
+  state.assignments = updated;
+  recordAttributableAssignments(updated);
+  if (forceReapply) invalidateLiveArtifactsForReplay();
+  const artifactResult = reconcileArtifacts(
+    desiredArtifactSet(updated),
+    evaluationUrl,
+  );
+  reassertAssignmentMutations(updated);
+  const runtimeAssignmentsChanged = !sameStringSet(
+    previousRuntimeKeys,
+    assignmentRuntimeKeys(updated),
+  );
+  if (runtimeAssignmentsChanged) installSdkCartMintTrigger();
+  if (
+    runtimeAssignmentsChanged &&
+    state.analyticsStarted &&
+    !trackingBlocked() &&
+    state.trackingPrerequisiteMet
+  ) {
+    setupHeatmapTracking(state.assignments, exps);
+    setupReplayTracking(state.assignments, exps);
+    syncActiveAssignmentToShopifyCart();
+    scheduleShopifyAssignmentSync();
+    if (reason !== "url") {
+      trackViewedAssignments(state.config, undefined, targetingPass);
+    }
+  }
+
+  if (navigateForRedirectAssignment(state.config, exps, state.assignments)) {
+    notifyQaAssistantRuntimeListeners();
+    return state.assignments;
+  }
+
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("eval", `Re-evaluated assignments (${reason})`, {
+    artifactResult,
+    count: state.assignments.length,
+    signatureChanged,
+  });
+  notifyQaAssistantRuntimeListeners();
+  return state.assignments;
+}
+
+export function reapplyQaAssistantForceMap(): void {
+  if (!state.config || !state.userId) {
+    try {
+      location.reload();
+    } catch {}
+    return;
+  }
+  reconcileForcedUnavailable(state.config);
+  reevaluateAssignments("manual", true);
+  notifyQaAssistantRuntimeListeners();
+}
+
+export function reconcileForcedUnavailable(config: InitConfig): void {
+  if (!state.qaMode) {
+    state.forcedUnavailable = [];
+    state.edgeDeviceAudienceUnsupported = [];
+    return;
+  }
+  const loadedExperimentIds = new Set((config.experiments ?? []).map((experiment) => experiment.id));
+  const warningsByExperimentId = new Map(
+    (config.qa_warnings ?? [])
+      .filter((warning) => warning.code === "forced_experiment_unavailable")
+      .flatMap((warning) => warning.reason ? [[warning.experiment_id, warning.reason] as const] : []),
+  );
+  state.forcedUnavailable = Object.keys(state.forceMap ?? {}).flatMap((experimentId) =>
+    loadedExperimentIds.has(experimentId)
+      ? []
+      : [{
+          experimentId,
+          reason: warningsByExperimentId.get(experimentId) ?? "not_in_config" as const,
+        }],
+  );
+  state.edgeDeviceAudienceUnsupported = (config.qa_warnings ?? []).flatMap((warning) =>
+    warning.code === "edge_device_audience_unsupported" && warning.audience_name
+      ? [{ experimentId: warning.experiment_id, audienceName: warning.audience_name }]
+      : [],
+  );
+}
+
+export function __getQaAssistantRuntimeSnapshot(): QaAssistantRuntimeSnapshot {
+  return {
+    config: state.config,
+    assignments: state.assignments.slice(),
+    activationDiagnostics: {
+      project: { gates: state.activationDiagnostics.project.gates.slice() },
+      experiments: state.activationDiagnostics.experiments.slice(),
+    },
+    pageActivation: pageActivationDiagnosticRows({ includePageNames: true }),
+    goalScopeUrl: state.wiredGoalUrl,
+    forceMap: state.forceMap ? { ...state.forceMap } : null,
+    forcedUnavailable: state.forcedUnavailable.map((entry) => ({ ...entry })),
+    edgeDeviceAudienceUnsupported: state.edgeDeviceAudienceUnsupported.map((entry) => ({ ...entry })),
+    platform: state.platform,
+    qaMode: state.qaMode,
+    orderIdentity: detectOrderIdentity(),
+  };
+}
+
+export function __subscribeQaAssistantRuntime(listener: () => void): () => void {
+  runtimeSharedState.qaAssistantRuntimeListeners.add(listener);
+  return () => {
+    runtimeSharedState.qaAssistantRuntimeListeners.delete(listener);
+  };
+}
+
+export function __forceQaAssistantVariation(experimentId: string, variationId: string): void {
+  if (!experimentId || !variationId) return;
+  state.forceMap = { ...(state.forceMap ?? {}), [experimentId]: variationId };
+  persistQaForce(state.forceMap);
+  reapplyQaAssistantForceMap();
+}
+
+export function __resetQaAssistantForce(experimentId?: string): void {
+  if (!experimentId) {
+    state.forceMap = null;
+  } else if (state.forceMap) {
+    const next = { ...state.forceMap };
+    delete next[experimentId];
+    state.forceMap = Object.keys(next).length ? next : null;
+  }
+  persistQaForce(state.forceMap ?? {});
+  reapplyQaAssistantForceMap();
+}
+
+export function clearQaForceFromCurrentUrl(): boolean {
+  if (!clearQaForceFromUrl()) return false;
+  state.forceMap = null;
+  state.qaMode = false;
+  state.qaSessionId = "";
+  if (state.config && state.userId) reapplyQaAssistantForceMap();
+  return true;
+}
+
+export function initWithExperiments(
+  config: InitConfig,
+  initialExperiments: Experiment[],
+  configSource: ConfigSource = "inline",
+  perfContext: InitPerfContext = createInitPerfContext(),
+  parsedRedirectCarry: VerifiedRedirectCarry | null = null,
+  verifiedHandover: Awaited<ReturnType<typeof readBucketingHandover>> = null,
+): Assignment[] {
+  removeSdkCartMintTrigger();
+  if (runtimeSharedState.earlyReassertTeardownTimer) clearTimeout(runtimeSharedState.earlyReassertTeardownTimer);
+  runtimeSharedState.stopEarlyReassert?.();
+  runtimeSharedState.stopEarlyReassert = null;
+  let experiments = initialExperiments;
+  const previousConfigSource = state.configSource;
+  const runtimeResolveStartedAt = monotonicNow();
+  const runtimeConfig = resolveRuntimeConfig(config);
+  const afMode = runtimeConfig.antiFlickerMode;
+  const afTimeout = runtimeConfig.antiFlickerTimeoutMs;
+  const trackStart = runtimeConfig.trackingStart;
+  const idleTimeout = runtimeConfig.trackingIdleTimeoutMs;
+  const jsPolicy = runtimeConfig.customJsPolicy;
+  const platform = resolvePlatform(config);
+  const perfFlags = readPerfFlags(config);
+  const emptyProjectProfileCandidate = canUseEmptyProjectProfile(config, experiments, platform);
+  const activationMode = resolveActivationMode(config);
+  const pageTriggerMode = resolvePageTriggerMode(config);
+  const detectorRules = collectPageDetectorRules(experiments);
+  const hasHistoryPageRules = (detectorRules.get("history")?.length ?? 0) > 0;
+  const hasPollingPageRules = (detectorRules.get("polling")?.length ?? 0) > 0;
+  const hasDomPageRules = (detectorRules.get("dom")?.length ?? 0) > 0;
+  const baseRouterMode = resolveRouterMode(config, platform);
+  const historyForcedRouterMode =
+    (pageTriggerMode === "url_change" || hasHistoryPageRules) &&
+    baseRouterMode === "none"
+      ? "history"
+      : baseRouterMode;
+  const routerMode = hasPollingPageRules &&
+      (historyForcedRouterMode === "none" || historyForcedRouterMode === "history")
+    ? "polling"
+    : historyForcedRouterMode;
+  const manualInitialTrigger = config.spa?.reinitOnly === true || pageTriggerMode === "manual";
+  const shopDomPageTrigger = resolveDomPageTrigger(config, pageTriggerMode);
+  const domPageTrigger = shopDomPageTrigger || hasDomPageRules;
+  const urlDiffNeeds = computeUrlDiffNeeds(
+    experimentsForGlobalRouteReevaluation(experiments),
+    config.signals,
+  );
+  addInitPhase(perfContext, "runtime_setup_ms", runtimeResolveStartedAt);
+  const assignmentStartedAt = monotonicNow();
+  const initStartedAt = Date.now();
+  updateLoadDiagnostics({
+    stage: "init_started",
+    startedAt: initStartedAt,
+    configFetchStatus: configSource === "network" ? state.load.configFetchStatus : state.load.configFetchStatus ?? "idle",
+  });
+  const consentIdentityStartedAt = monotonicNow();
+  const initialConsentRequired = resolveConsentRequired(config);
+  const initialConsentGranted = resolveConsentGranted(config, initialConsentRequired);
+  const initialTrackingDisabledByDnt = doNotTrackEnabled(config);
+  const initialStorageAllowed = storageAllowed(
+    initialConsentRequired,
+    initialConsentGranted,
+    initialTrackingDisabledByDnt,
+  );
+  // Only the exact baked inline payload may consume the handoff. Cache and
+  // network refreshes are authoritative re-evaluations (kill-switch path).
+  const predecided = configSource === "inline"
+    ? bootstrapPredecision(config, perfContext)
+    : null;
+  state.consentRequired = initialConsentRequired;
+  state.consentGranted = initialConsentGranted;
+  state.consentModeEnabled = config.consentMode?.enabled === true;
+  state.trackingDisabledByDnt = initialTrackingDisabledByDnt;
+  configureIdentityStorage(initialStorageAllowed ? config.dataProtection : { ...(config.dataProtection ?? {}), storageMode: "memory" });
+  if (!initialStorageAllowed) {
+    clearEarlyInteractions();
+    clearConsentStorage();
+  }
+  const redirectCarry = emptyProjectProfileCandidate || !initialStorageAllowed || config.userId
+    ? null
+    : validateRedirectAssignmentCarry(
+        experiments,
+        parsedRedirectCarry,
+        typeof location !== "undefined" ? location.href : undefined,
+      );
+  if (redirectCarry) {
+    adoptUserId(redirectCarry.visitorId);
+    clearPendingRedirectAssignmentCarry();
+  }
+  const handover = emptyProjectProfileCandidate ? null : verifiedHandover;
+  if (initialStorageAllowed && handover?.visitorId && !config.userId && !redirectCarry) {
+    adoptUserId(handover.visitorId);
+  }
+  const predecidedIdentityHint = config.userId == null
+    ? predecided?.visitorId
+    : undefined;
+  const identityHint = config.userId ?? predecidedIdentityHint;
+  const resolvedUserId = initialStorageAllowed
+    ? getUserId(identityHint)
+    : getEphemeralUserId(identityHint);
+  if (initialStorageAllowed && predecidedIdentityHint) {
+    adoptUserId(resolvedUserId);
+  }
+  if (predecided && resolvedUserId !== predecided.visitorId) perfContext.predecisionMismatches += 1;
+
+  // This gate is intentionally synchronous and precedes both applyProjectCode
+  // and assignment evaluation below. That ordering lets a cached config which
+  // already carries holdout settings prevent cached project/variation code
+  // without waiting for the network refresh. Operational sessions must always
+  // retain the complete experiment runtime; QA includes preview sessions.
+  state.qaMode = isQaMode();
+  state.screenshotMode = isScreenshotMode();
+  state.holdout = !state.qaMode && !state.screenshotMode && isHoldoutVisitor(config, resolvedUserId);
+  if (state.holdout) experiments = applyHoldoutGate(config, resolvedUserId, experiments);
+  if (
+    configSource === "network" &&
+    previousConfigSource === "cache" &&
+    state.holdout
+  ) {
+    // Cached direct/headless installs render before the network response. If
+    // the authoritative config moves this visitor into holdout, retire every
+    // cached treatment before replacing the assignment set.
+    resetProjectCode();
+  }
+
+  configureDebug(config.debug, resolvedUserId, { storageAllowed: initialStorageAllowed });
+  addInitPhase(perfContext, "consent_identity_ms", consentIdentityStartedAt);
+
+  const runtimeSetupStartedAt = monotonicNow();
+  __DRIP_FEATURE_DEVTOOLS__ && debugGroup("init");
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("init", `Initializing with ${experiments.length} experiment(s)`, {
+    executionMode: runtimeConfig.executionMode,
+    antiFlicker: afMode,
+    trackingStart: trackStart,
+    platform,
+    routerMode,
+    activationMode,
+    pageTrigger: pageTriggerMode,
+    configSource,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep("Initiated snippet runtime", {
+    revision: config.delivery?.revision,
+    sdkVariant: config.runtimeFeatures?.sdkVariant,
+    configSource,
+    deliveryState: config.delivery?.deliveryState ?? config.deliveryState,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep("Initiated project", {
+    shopId: config.shopId,
+    executionMode: runtimeConfig.executionMode,
+    platform,
+    routerMode,
+    activationMode,
+    pageTrigger: pageTriggerMode,
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("init", `Init: ${experiments.length} experiment(s)`, {
+    executionMode: runtimeConfig.executionMode,
+    antiFlicker: afMode,
+    platform,
+    routerMode,
+    activationMode,
+    pageTrigger: pageTriggerMode,
+    configSource,
+  });
+
+  // Apply custom JS policy
+  setJsPolicy(jsPolicy);
+  if (!emptyProjectProfileCandidate && !state.holdout) applyProjectCode(config);
+
+  const urlForceMap = parseForceParam();
+  const handoverForceMap = handover?.forceMap && Object.keys(handover.forceMap).length > 0
+    ? handover.forceMap
+    : null;
+  state.forceMap = handoverForceMap || urlForceMap
+    ? { ...(handoverForceMap ?? {}), ...(urlForceMap ?? {}) }
+    : null;
+
+  // QA and screenshot sessions retain the full runtime even if the published
+  // project is otherwise empty.
+  const emptyProjectFastPath = emptyProjectProfileCandidate
+    && !state.qaMode
+    && !state.screenshotMode;
+  const resolvedConfig = {
+    ...config,
+    experiments,
+    ...(state.holdout ? { commerce: undefined } : {}),
+    runtimeProfile: emptyProjectFastPath ? "empty_project" : "full",
+  };
+  if (
+    resolvedConfig.cartAttributeWrite === "external" &&
+    state.config?.cartAttributeWrite !== "external"
+  ) {
+    runtimeSharedState.shopifyCartSyncGeneration += 1;
+    invalidateShopifyCartAttributeSync();
+  }
+  if (state.config?.shopId && state.config.shopId !== resolvedConfig.shopId) {
+    state.shopifyCartToken = null;
+    state.shopwareAttributionEnvelope = null;
+  }
+  // A network refresh may remove the cached price plane while its display or
+  // cart authorization is still live. The empty-project/lazy path deliberately
+  // skips applyCommercePrice, so teardown must happen before replacing config.
+  const priorPriceSyncPending = hasActivePriceAuthorizationPlane()
+    && state.lastShopifyCartSync?.status === "pending";
+  if (
+    !resolvedConfig.commerce?.price &&
+    (hasCommercePriceState() || priorPriceSyncPending)
+  ) {
+    runtimeSharedState.shopifyCartSyncGeneration += 1;
+    invalidateShopifyCartAttributeSync();
+    cleanupCommercePrice();
+  }
+  state.config = resolvedConfig;
+  reconcileForcedUnavailable(state.config);
+  if (state.userId && state.userId !== resolvedUserId) {
+    // The envelope is signed for the previous visitor; a rotated identity must
+    // never sync a stale envelope before the next assign response replaces it.
+    state.shopwareAttributionEnvelope = null;
+  }
+  state.userId = resolvedUserId;
+  state.trackingStart = trackStart;
+  state.trackingIdleTimeoutMs = idleTimeout;
+  state.consentRequired = initialConsentRequired;
+  state.consentGranted = initialConsentGranted;
+  state.consentModeEnabled = config.consentMode?.enabled === true;
+  state.trackingDisabledByDnt = initialTrackingDisabledByDnt;
+  state.variationPrerequisiteMet = emptyProjectFastPath || variationsAllowed(resolvedConfig);
+  state.trackingPrerequisiteMet = emptyProjectFastPath || trackingAllowed(resolvedConfig);
+  state.analyticsStarted = false;
+  state.exposedAssignmentKeys.clear();
+  // Cache-to-network init is a delivery refresh, not proof that an equivalent
+  // assignment became healthy. Preserve its fail-closed state until the new
+  // assignment set is known, then prune keys for assignments no longer held.
+  state.authorizedPriceAssignmentKeys = null;
+  state.authorizedShippingAssignmentKeys = null;
+  state.authorizedOffersAssignmentKeys = null;
+  state.redirectNavigationPending = false;
+  if (headlessCartAuthorizationState) {
+    headlessCartAuthorizationState.generation += 1;
+    headlessCartAuthorizationState.confirmationPending = false;
+    headlessCartAuthorizationState.pending = null;
+  }
+  state.platform = platform;
+  state.routerMode = routerMode;
+  state.activationMode = activationMode;
+  state.perfFlags = perfFlags;
+  state.urlDiffNeeds = urlDiffNeeds;
+  state.configSource = configSource;
+  state.runtimeConfig = runtimeConfig;
+  state.pageTriggerMode = pageTriggerMode;
+  pendingDataLayerEvents.length = 0;
+  state.initializingAssignments = true;
+  const url = config.url ?? location.href;
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep("Initiated page", {
+    url,
+    experiments: experiments.length,
+    signals: resolvedConfig.signals?.length ?? 0,
+  });
+
+  // QA session persistence
+  if (state.qaMode) {
+    state.qaSessionId = getQaSessionId(generateQaSessionId, { storageAllowed: persistentStorageAllowed() });
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("qa", "QA mode active", { forceMap: state.forceMap, sessionId: state.qaSessionId });
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("qa", "QA mode active", { sessionId: state.qaSessionId });
+    if (state.forceMap) {
+      // This functional first-party merchant-QA cookie is written only after an explicit
+      // QA URL open and deliberately bypasses the consent gate.
+      persistUrlQaForce(state.forceMap);
+    }
+  } else {
+    state.qaSessionId = "";
+  }
+  if (state.screenshotMode) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog("qa", "Screenshot mode active");
+    __DRIP_FEATURE_DEVTOOLS__ && dtLog("qa", "Screenshot mode active");
+  }
+
+  // Cleanup previous init
+  if (state.stopObserver) {
+    state.stopObserver();
+    state.stopObserver = null;
+  }
+  if (state.deferredRouteReevaluationTimer !== null) {
+    window.clearTimeout(state.deferredRouteReevaluationTimer);
+    state.deferredRouteReevaluationTimer = null;
+  }
+  if (state.stopDomObserver) {
+    state.stopDomObserver();
+    state.stopDomObserver = null;
+  }
+  cancelAllPageRulePolls();
+  runtimeSharedState.pageDetectorLastUrls.clear();
+  runtimeSharedState.pageDetectorRules = detectorRules;
+  if (state.stopHandover) {
+    state.stopHandover();
+    state.stopHandover = null;
+  }
+  if (state.stopSignalCaptures) {
+    state.stopSignalCaptures();
+    state.stopSignalCaptures = null;
+  }
+  if (state.stopSurfaceSignals) {
+    state.stopSurfaceSignals();
+    state.stopSurfaceSignals = null;
+  }
+  if (state.stopJsTriggerSignals) {
+    state.stopJsTriggerSignals();
+    state.stopJsTriggerSignals = null;
+  }
+  if (state.stopDataLayerTriggers) {
+    state.stopDataLayerTriggers();
+    state.stopDataLayerTriggers = null;
+  }
+  if (state.stopConsentListeners) {
+    state.stopConsentListeners();
+    state.stopConsentListeners = null;
+  }
+  // Keep an in-flight consent-pending write attached across cache-to-network re-init.
+  // Its completion schedules the current consented stamp after the older write.
+  state.stopShopifyCartMutationSync?.();
+  state.stopShopifyCartMutationSync = null;
+  clearScheduledAnalyticsStart();
+  unwireGoals();
+  cleanupHeatmapTracking();
+  cleanupReplayTracking();
+  cleanupSemanticTracking();
+  if (state.tracker) {
+    state.tracker.stop();
+    state.tracker = null;
+  }
+  state.pendingDeliveryHealth = [];
+  // The authorized empty-project profile has no visual treatment to measure;
+  // reset any prior route measurement without constructing an observer.
+  startCwvMeasurement(emptyProjectFastPath);
+
+  state.stopConsentListeners = installConsentChangeListeners(resolvedConfig);
+  if (!emptyProjectFastPath) {
+    captureUrlSignals(resolvedConfig);
+    captureDomAndGlobalSignals(resolvedConfig);
+    state.stopSignalCaptures = installClickSignalCaptures(resolvedConfig);
+    state.stopSurfaceSignals = experimentsUseSurfaceSignals(experiments)
+      ? installSurfaceSignals(() => {
+          captureDomAndGlobalSignals(resolvedConfig);
+          reevaluateAssignments("dom");
+        })
+      : null;
+    state.stopJsTriggerSignals = installJsTriggerObserver(
+      experiments,
+      () => {
+        reevaluateAssignments("dom");
+      },
+      manualInitialTrigger,
+    );
+    state.stopDataLayerTriggers = installDataLayerTriggers(resolvedConfig);
+  }
+
+  // Evaluate and apply. For generated snippets, use the compact critical path
+  // plan first, then fall back to the general evaluator for complex/noncritical
+  // experiments that were not safely precompiled.
+  if (emptyProjectFastPath) {
+    state.activationDiagnostics = { project: { gates: [] }, experiments: [] };
+  } else {
+    updateProjectActivationDiagnostics(resolvedConfig);
+    for (const gate of state.activationDiagnostics.project.gates) {
+      __DRIP_FEATURE_DEVTOOLS__ && traceStep(`Project ${gate.label} is ${gate.status}`, {
+        reason: gate.reason,
+        ...(gate.detail && typeof gate.detail === "object" ? { detail: gate.detail } : {}),
+      });
+    }
+  }
+  addInitPhase(perfContext, "runtime_setup_ms", runtimeSetupStartedAt);
+  const targetingAssignmentStartedAt = monotonicNow();
+  state.carryImportedAssignmentKeys.clear();
+  if (redirectCarry && persistentStorageAllowed() && !state.qaMode && !state.screenshotMode) {
+    importRedirectAssignmentCarry(redirectCarry, location.href, !edgeRuntimeActive());
+    state.carryImportedAssignmentKeys.add(
+      redirectCarryAssignmentKey(
+        redirectCarry.experiment.id,
+        redirectCarry.variationId,
+        Math.max(
+          1,
+          Number.isSafeInteger(redirectCarry.experiment.assignmentEpoch)
+            ? redirectCarry.experiment.assignmentEpoch!
+            : 1,
+        ),
+      ),
+    );
+  }
+  const persistedAssignments = emptyProjectFastPath
+    ? undefined
+    : loadPersistedAssignments(experiments);
+  let initialTargetingPass =
+    !emptyProjectFastPath && !manualInitialTrigger && state.variationPrerequisiteMet
+      ? createTargetingEvaluationPass(
+          resolvedConfig.attributes ?? EMPTY_TARGETING_ATTRIBUTES,
+          url,
+          persistentStorageAllowed(),
+        )
+      : undefined;
+  const pageActivation = reconcilePageActivation(experiments, url, {
+    previous: state.pageActivation,
+    persistedAssignments,
+    targetingPass: initialTargetingPass,
+  });
+  const teardownPages = pageActivation.transitions
+    .filter((transition) => transition.teardown)
+    .map((transition) => ({ pageId: transition.pageId, mode: transition.mode }));
+  if (teardownPages.length > 0) {
+    teardownTransaction(teardownPages, { goalUrl: url });
+  }
+  state.pageActivation = pageActivation.next;
+  pageActivation.pollRules.forEach((rule) => startPageRulePoll(rule));
+  if (emptyProjectFastPath) {
+    state.assignments = [];
+  } else if (!manualInitialTrigger && state.variationPrerequisiteMet) {
+    const targetingSourceAttributes = resolvedConfig.attributes ??
+      EMPTY_TARGETING_ATTRIBUTES;
+    const targetingPass = initialTargetingPass ?? createTargetingEvaluationPass(
+      targetingSourceAttributes,
+      url,
+      persistentStorageAllowed(),
+    );
+    initialTargetingPass = targetingPass;
+    const attributes = targetingAttributesForPass(
+      targetingPass,
+      targetingSourceAttributes,
+      url,
+      persistentStorageAllowed(),
+    );
+    const usablePredecision = predecided && predecided.visitorId === state.userId
+      ? predecided
+      : null;
+    const edgeEligibility = config.userId == null && edgeRuntimeActive()
+      ? evaluateWithDiagnostics(experiments, {
+          url,
+          attributes: targetingSourceAttributes,
+          userId: state.userId,
+          persistSignals: false,
+          storeOrigin: configuredStoreOrigins(resolvedConfig),
+          persistedAssignments,
+          targetingPass,
+        })
+      : null;
+    const edgeEvaluation = edgeEligibility
+      ? evaluateEdgeRuntimeAssignments(
+          experiments,
+          {
+            url,
+            attributes,
+            userId: state.userId,
+          },
+          edgeEligibility.assignments,
+          edgeEligibility.diagnostics,
+        )
+      : null;
+    // Targeting runs before the real SDK exclusion resolver. The bootstrap
+    // deliberately hands over unfiltered per-experiment decisions.
+    if (state.holdout) {
+      runtimeSharedState.initialPredecidedByExperiment = null;
+      state.assignments = [];
+      state.activationDiagnostics.experiments = [];
+    } else if (edgeEvaluation || usablePredecision) {
+      const fallbackExperiments = edgeEvaluation
+        ? edgeEvaluation.experimentIds.size > 0
+          ? experiments.filter((experiment) => !edgeEvaluation.experimentIds.has(experiment.id))
+          : []
+        : experiments;
+      if (usablePredecision) {
+        runtimeSharedState.initialPredecidedByExperiment = new Map(usablePredecision.decision);
+      }
+      try {
+        const fallback = evaluateWithDiagnostics(fallbackExperiments, {
+          url,
+          attributes: targetingSourceAttributes,
+          userId: state.userId,
+          persistSignals: false,
+          targetingPass,
+          storeOrigin: configuredStoreOrigins(resolvedConfig),
+          persistedAssignments,
+          exclusionGroups: config.exclusionGroups,
+          storedGroupSelections: usablePredecision?.groups,
+          holdout: usablePredecision
+            ? { enabled: config.holdout_v1_enabled, percentage: config.holdout_pct }
+            : undefined,
+        });
+        if (edgeEvaluation) {
+          const combined = resolveCombinedEdgeEvaluation(
+            edgeEvaluation.assignments,
+            fallback.assignments,
+            [...edgeEvaluation.diagnostics, ...fallback.diagnostics],
+            {
+              userId: state.userId,
+              exclusionGroups: config.exclusionGroups,
+            },
+          );
+          state.assignments = combined.assignments;
+          state.activationDiagnostics.experiments = combined.diagnostics;
+        } else {
+          state.assignments = fallback.assignments;
+          state.activationDiagnostics.experiments = fallback.diagnostics;
+        }
+      } finally {
+        runtimeSharedState.initialPredecidedByExperiment = null;
+      }
+    } else if (config.exclusionGroups?.length) {
+      const evaluation = evaluateWithDiagnostics(experiments, {
+        url,
+        attributes: targetingSourceAttributes,
+        userId: state.userId,
+        persistSignals: false,
+        storeOrigin: configuredStoreOrigins(resolvedConfig),
+        exclusionGroups: config.exclusionGroups,
+        persistedAssignments,
+        targetingPass,
+      });
+      state.assignments = evaluation.assignments;
+      state.activationDiagnostics.experiments = evaluation.diagnostics;
+    } else {
+      const critical = buildCriticalPathAssignments(
+        experiments,
+        config.delivery?.criticalMutationPlan,
+        { url, attributes, userId: state.userId },
+      );
+      const fallbackExperiments = critical.plannedExperimentIds.size
+        ? experiments.filter(
+            (experiment) =>
+              !critical.plannedExperimentIds.has(experiment.id) ||
+              !critical.assignments.some(
+                (assignment) => assignment.experimentId === experiment.id,
+              ),
+          )
+        : experiments;
+      const fallback = evaluateWithDiagnostics(fallbackExperiments, {
+        url,
+        attributes: targetingSourceAttributes,
+        userId: state.userId,
+        persistSignals: false,
+        storeOrigin: configuredStoreOrigins(resolvedConfig),
+        persistedAssignments,
+        targetingPass,
+      });
+      state.assignments = [
+        ...critical.assignments,
+        ...fallback.assignments,
+      ];
+      const fallbackDiagnosticIds = new Set(
+        fallback.diagnostics.map((diagnostic) => diagnostic.experimentId),
+      );
+      state.activationDiagnostics.experiments = [
+        ...critical.skippedDiagnostics.filter(
+          (diagnostic) => !fallbackDiagnosticIds.has(diagnostic.experimentId),
+        ),
+        ...fallback.diagnostics,
+      ];
+      for (const assignment of critical.assignments) {
+        const experiment = experiments.find((candidate) => candidate.id === assignment.experimentId);
+        if (!experiment) continue;
+        state.activationDiagnostics.experiments.unshift(experimentDiagnostic(
+          experiment,
+          [
+            { id: "page", label: "Page check", status: "passed", reason: "precompiled_delivery_match" },
+            // Critical-plan invariant: only campaigns without non-URL
+            // targeting are precompiled — the truthful audience result is
+            // "all visitors", same as the skip-path diagnostics.
+            { id: "audience", label: "Audience check", status: "skipped", reason: "no_audience_rules" },
+            { id: "traffic", label: "Traffic allocation", status: "passed", reason: "included" },
+            { id: "assignment", label: "Variation assignment", status: "passed", reason: "precompiled_assignment" },
+          ],
+          assignment,
+          "precompiled_assignment",
+        ));
+      }
+    }
+  } else {
+    state.assignments = [];
+    state.activationDiagnostics.experiments = manualInitialTrigger
+      ? experiments.map((experiment) => experimentDiagnostic(
+          experiment,
+          [{ id: "activation", label: "Page trigger", status: "skipped", reason: "manual_initial_trigger" }],
+          null,
+          "manual_initial_trigger",
+        ))
+      : [];
+  }
+  if (state.assignments.length > 1) {
+    const filteredInitial = enforcePersonalizationStopAfterMatch(
+      state.assignments,
+      state.activationDiagnostics.experiments,
+    );
+    state.assignments = filteredInitial.assignments;
+    state.activationDiagnostics.experiments = filteredInitial.diagnostics ?? state.activationDiagnostics.experiments;
+  }
+  state.assignments = filterUnsafeRedirectAssignments(
+    experiments,
+    state.assignments,
+    location.href,
+    state.userId ?? "",
+    resolvedConfig.externalTracking,
+    shouldPreserveOffTargetRedirectAssignment,
+    configuredStoreOrigins(resolvedConfig),
+  );
+  const currentExposureKeys = new Set(state.assignments.map(exposureAssignmentKey));
+  for (const key of state.mutationPendingAssignmentKeys) {
+    if (!currentExposureKeys.has(key)) state.mutationPendingAssignmentKeys.delete(key);
+  }
+  for (const key of state.contaminatedAssignmentKeys) {
+    if (!currentExposureKeys.has(key)) state.contaminatedAssignmentKeys.delete(key);
+  }
+  syncAssignmentPageActive(state.assignments, experiments);
+  recordAttributableAssignments(state.assignments);
+  if (redirectCarry?.exposureSent) {
+    const importedAssignment = state.assignments.find((assignment) =>
+      assignment.experimentId === redirectCarry.experiment.id && assignment.variationId === redirectCarry.variationId);
+    if (importedAssignment) state.exposedAssignmentKeys.add(exposureAssignmentKey(importedAssignment));
+  }
+  if (!emptyProjectFastPath && afMode !== "off") {
+    const scopedSelectors = afMode === "scoped"
+      ? collectScopedSelectors(experiments, resolvedConfig, state.assignments)
+      : undefined;
+    applyRuntimeAntiFlicker(afMode, afTimeout, scopedSelectors, runtimeConfig.antiFlickerCustomCss);
+  }
+  // Assignment persistence belongs to bucketing, not tracking. In particular,
+  // a redirect must carry a durable assignment even when the source page's
+  // tracking prerequisite keeps analytics and exposure collection closed.
+  if (!emptyProjectFastPath) {
+    persistActiveExperimentAssignments(experiments);
+  }
+  if (
+    configSource !== "cache" &&
+    navigateForRedirectAssignment(
+      resolvedConfig,
+      experiments,
+      state.assignments,
+    )
+  ) {
+    addInitPhase(perfContext, "targeting_assignment_ms", targetingAssignmentStartedAt);
+    finishInitializingAssignments();
+    return state.assignments;
+  }
+  addInitPhase(perfContext, "targeting_assignment_ms", targetingAssignmentStartedAt);
+  const mutationFinalizeStartedAt = monotonicNow();
+  const applyOrReconcileInitialArtifacts = (goalUrl: string): void => {
+    if (appliedAssignmentsByKey.size === 0) {
+      applyAssignments(state.assignments, state.activationMode, { goalUrl });
+      return;
+    }
+    reconcileArtifacts(desiredArtifactSet(state.assignments), goalUrl);
+    reassertAssignmentMutations(state.assignments);
+  };
+  let initialApplyPromise: Promise<void> | null = null;
+  if (!emptyProjectFastPath) {
+    const earlyReassertEligible = shouldUseEarlyReassert({
+      applyTiming: resolvedConfig.spa?.applyTiming,
+      configSource,
+      hasTrustedPredecision: predecided !== null && resolvedUserId === predecided.visitorId,
+      consentGranted: initialConsentGranted,
+      dntBlocked: initialTrackingDisabledByDnt,
+    });
+    const earlyReassertAssignments = artifactRenderableAssignments(state.assignments);
+    // Structural operations cannot be safely reasserted without duplicating
+    // inserts or losing their original snapshots. Custom JS is never
+    // reassert-safe because replaying it can repeat arbitrary side effects.
+    // Route the whole assignment set through the hydration-delayed path.
+    const deferStructuralEarlyReassert = earlyReassertEligible && (
+      assignmentsHaveStructuralMutations(earlyReassertAssignments)
+      || assignmentsHaveCustomJs(earlyReassertAssignments)
+    );
+    const forcedPreviewSession = (state.qaMode || state.screenshotMode) && state.forceMap !== null;
+    const waitForHydration = resolvedConfig.spa?.applyTiming === "after_hydration"
+      || deferStructuralEarlyReassert
+      || (forcedPreviewSession && resolvedConfig.spa?.applyTiming === "early_reassert");
+    const earlyReassert = earlyReassertEligible && !deferStructuralEarlyReassert;
+    const deferForVisualWork = assignmentsHaveVisualWork(
+      earlyReassertAssignments,
+      resolvedConfig.commerce?.price,
+    );
+    if ((waitForHydration || hasMutationHold()) && deferForVisualWork) {
+      const scheduledConfig = resolvedConfig;
+      const scheduledUrl = location.href;
+      initialApplyPromise = awaitHydration(
+        resolvedConfig.spa?.hydrationTimeoutMs ?? 3_000,
+        { waitForHydration },
+      ).then(() => {
+        // A re-init (e.g. cached config superseded by the network config)
+        // replaces the pending gate; a stale promise must not clear the
+        // newer one and open the hydration gate early for rechecks.
+        if (state.pendingInitialApply === initialApplyPromise) {
+          state.pendingInitialApply = null;
+        }
+        if (state.config !== scheduledConfig) return;
+        if (location.href !== scheduledUrl) {
+          // The shopper navigated before the gate opened: applying the
+          // original route's assignments would flash the previous page's
+          // treatment. Re-evaluate for the current URL directly (forcing
+          // apply + reveal even when nothing was queued or the signature is
+          // unchanged), then run startup JS to preserve the ordering.
+          reevaluateAssignments("url", true, true);
+          runProjectStartupCode(scheduledConfig);
+          return;
+        }
+        applyOrReconcileInitialArtifacts(scheduledUrl);
+        // Preserve the immediate-mode ordering contract: project startup JS
+        // runs after assignment mutations, so it can read the variant DOM.
+        runProjectStartupCode(scheduledConfig);
+      });
+      state.pendingInitialApply = initialApplyPromise;
+    } else {
+      // Immediate apply supersedes any gate left by a previous init.
+      state.pendingInitialApply = null;
+      if (earlyReassert && deferForVisualWork) {
+        const diagnostics = readDripPerf();
+        diagnostics.early_apply_at = Date.now();
+        diagnostics.reasserts_count = 0;
+        diagnostics.revert_loops_detected = 0;
+        // The watcher never captures an assignment array: it resolves the live
+        // render plane on every fire, so a page teardown — which clears
+        // `pageActive` and drops the artifacts — silences it by construction.
+        const stop = installEarlyReassert({
+          diagnostics,
+          reapply: reassertAssignmentMutations,
+          resolveAssignments: () =>
+            activeRenderableAssignments().filter(isOffersDisplayAssignmentAuthorized),
+          timeoutMs: Math.max(3_000, resolvedConfig.spa?.hydrationTimeoutMs ?? 3_000),
+        });
+        runtimeSharedState.stopEarlyReassert = stop;
+        void awaitHydration(resolvedConfig.spa?.hydrationTimeoutMs ?? 3_000, {
+          waitForHydration: true,
+          // The variant was already applied synchronously. This second gate
+          // only controls watcher teardown and is not an apply delay.
+          recordMetrics: false,
+        })
+          .catch(() => debugWarn("hydration", "wait failed"))
+          .finally(() => {
+            if (runtimeSharedState.stopEarlyReassert !== stop) return;
+            runtimeSharedState.earlyReassertTeardownTimer = setTimeout(stop, 250);
+          });
+      }
+      applyOrReconcileInitialArtifacts(url);
+      runProjectStartupCode(resolvedConfig);
+    }
+    if (persistentStorageAllowed() && config.bucketingCleanup?.enabled !== false) {
+      cleanupBucketingStorage(experiments, {
+        shopId: config.shopId,
+        retentionDays: config.bucketingCleanup?.retentionDays,
+      });
+    }
+    state.stopHandover = installBucketingHandover(config.externalTracking, () => (
+      persistentStorageAllowed() && state.userId && state.assignments.length
+        ? createBucketingHandoverPayload(state.userId, state.assignments, config.externalTracking)
+        : null
+    ), () => (
+      persistentStorageAllowed() && state.userId && state.assignments.length
+        ? mintBucketingHandoverPayload(config, state.userId, state.assignments)
+        : Promise.resolve(null)
+    ));
+  } else {
+    // A cached visual config can leave a hydration promise pending when the
+    // authoritative network response resolves to the empty fast path. The
+    // stale promise is config-guarded, so detach it immediately instead of
+    // delaying install/pageview analytics until its timeout.
+    state.pendingInitialApply = null;
+    if (appliedAssignmentsByKey.size > 0) reconcileArtifacts(new Map(), url);
+  }
+  state.lastAssignmentSignature = assignmentSignature(state.assignments);
+  installSdkCartMintTrigger();
+  state.lastUrl = location.href;
+  addInitPhase(perfContext, "mutation_finalize_ms", mutationFinalizeStartedAt);
+  const assignmentReadyMonotonicAt = monotonicNow();
+  const assignmentReadyMs = boundedPerfDuration(assignmentReadyMonotonicAt - assignmentStartedAt);
+  const initTotalMs = boundedPerfDuration(assignmentReadyMonotonicAt - perfContext.startedAt);
+  const assignmentReadyAt = Date.now();
+  updateLoadDiagnostics({
+    stage: "assignments_ready",
+    assignmentReadyAt,
+    assignmentReadyMs,
+  });
+  queuePerfEvent(buildPerfEvent(resolvedConfig, {
+    eventKind: "init",
+    assignmentReadyMs,
+    initTotalMs,
+    phases: { ...perfContext.phases },
+    includesConfigFetch: perfContext.includesConfigFetch,
+    predecisionMismatches: perfContext.predecisionMismatches,
+    blankScreenMs: getBlankScreenMs(),
+    assignmentReadyAt,
+  }));
+  const storefrontPerf = readDripPerf();
+  const scriptExecStart = numberPerf(storefrontPerf, "script_exec_start");
+  runtimeSharedState.storefrontVitalsContext = {
+    endpoint: resolvedConfig.endpoint ? normalizeEndpoint(resolvedConfig.endpoint) : "",
+    proxyEventDelivery: resolvedConfig.proxyEventDelivery,
+    shopId: resolvedConfig.shopId ?? "",
+    ingestShopId: resolvedConfig.ingestShopId,
+    ingestSignature: resolvedConfig.ingestSignature,
+    visitorId: state.userId ?? undefined,
+    sampleRate: resolvedConfig.storefrontVitalsSampleRate,
+    experimentActive: state.assignments.some(exposable),
+    sdkBootToInitMs: scriptExecStart === undefined
+      ? undefined
+      : Math.max(0, assignmentReadyAt - initTotalMs - scriptExecStart),
+    getAntiFlickerInsertedToRevealMs: () => {
+      const livePerf = readDripPerf();
+      const insertedAt = numberPerf(livePerf, "anti_flicker_inserted_at");
+      if (insertedAt === undefined) return undefined;
+      const liveRevealAt = numberPerf(livePerf, "reveal_at") ?? Date.now();
+      return Math.max(0, liveRevealAt - insertedAt);
+    },
+    sdkInitStartToAssignmentReadyMs: initTotalMs,
+  };
+  syncStorefrontVitals();
+  writeIdentityContextCookie();
+
+  const beginTracking = () => {
+    if (state.config !== resolvedConfig) return;
+    finishInitializingAssignments();
+    if (!state.trackingPrerequisiteMet) {
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("track", "Tracking blocked by project prerequisite");
+    } else if (trackStart === "idle") {
+      scheduleAnalyticsStart(
+        resolvedConfig,
+        experiments,
+        initialApplyPromise ? undefined : initialTargetingPass,
+      );
+    } else {
+      startAnalyticsStage(
+        resolvedConfig,
+        experiments,
+        undefined,
+        initialApplyPromise ? undefined : initialTargetingPass,
+      );
+    }
+    // This callback is queued behind initialApplyPromise below, so Shopify
+    // never receives assignment attribution before the treatment is visible.
+    scheduleShopifyAssignmentSync();
+  };
+  if (initialApplyPromise) void initialApplyPromise.then(beginTracking);
+  else beginTracking();
+
+  if (FEATURE_AUDIT) {
+    import("./audit").then(({ runAuditIfRequested }) => {
+      runAuditIfRequested(resolvedConfig, {
+        configSource: state.configSource,
+        trackerStarted: Boolean(state.tracker),
+        platform: state.platform,
+      });
+    }).catch(() => {});
+  }
+
+  // Route observer (SPA fast path)
+  if (
+    !emptyProjectFastPath &&
+    (pageTriggerMode !== "manual" || hasHistoryPageRules || hasPollingPageRules)
+  ) {
+    state.stopObserver = observeRouteChanges(state.routerMode, ({ previousUrl, nextUrl, reason }) => {
+      if (runtimeSharedState.clearingQaForceFromRoute) return;
+      // A live runtime has already derived holdout, persistence, and tracker
+      // state from QA mode. Strip the sentinel first, then reload so every
+      // construction-time decision is rebuilt outside QA mode. Returning is
+      // also essential: exitQaMode() uses replaceState, which this observer
+      // wraps synchronously, and the outer callback must not continue with
+      // its stale pre-strip URL.
+      runtimeSharedState.clearingQaForceFromRoute = true;
+      try {
+        if (clearQaForceFromUrl()) {
+          location.reload();
+          return;
+        }
+      } finally {
+        runtimeSharedState.clearingQaForceFromRoute = false;
+      }
+      if (!state.config || !state.userId) return;
+      cancelAllPageRulePolls();
+      const detector = reason === "polling" ? "polling" : "history";
+      const triggeredPageIds = firePageDetector(detector, nextUrl);
+      const routeAnalyticsGeneration = ++state.routeAnalyticsGeneration;
+      // Finalize the prior route and start a fresh CLS window so SPA events
+      // never reuse the first route's reveal boundary or shift totals.
+      startCwvMeasurement();
+
+      // Fire page_exit for the page we're leaving
+      if (!state.screenshotMode && state.analyticsStarted) {
+        onPageExit(analyticsTrack);
+      }
+      const exps = state.config.experiments ?? [];
+      const routeStartedAt = Date.now();
+      const immediatePageRulesNeedReevaluation =
+        state.pageTriggerMode === "url_change" ||
+        shouldReevaluateForUrlChange(previousUrl, nextUrl, state.urlDiffNeeds);
+      const shouldReevaluate = triggeredPageIds.size > 0 ||
+        immediatePageRulesNeedReevaluation;
+      state.lastRouteChange = {
+        previousUrl,
+        nextUrl,
+        reason,
+        at: Date.now(),
+        reEvaluated: shouldReevaluate,
+      };
+
+      if (shouldReevaluate) {
+        reevaluateAssignments("url", false, false, {
+          triggeredPageIds,
+          includeImmediate: immediatePageRulesNeedReevaluation,
+        });
+        if (state.redirectNavigationPending) return;
+      }
+      if (reason !== "polling") scheduleDeferredRouteReevaluation();
+      if (!state.pendingInitialApply) {
+        // Routes with no visual re-apply still need a route-local reveal
+        // boundary; applyAssignments() marks it for gated/visual routes.
+        markCwvReveal();
+      }
+
+      state.lastUrl = nextUrl;
+      state.trackingPrerequisiteMet = trackingAllowed(state.config);
+      syncStorefrontVitals();
+      updateProjectActivationDiagnostics(state.config);
+      const assignmentReadyAt = Date.now();
+      queuePerfEvent(buildPerfEvent(state.config, {
+        eventKind: "route_change",
+        assignmentReadyMs: assignmentReadyAt - routeStartedAt,
+        blankScreenMs: 0,
+        assignmentReadyAt,
+      }));
+
+      const runRouteAnalytics = () => {
+        if (routeAnalyticsGeneration !== state.routeAnalyticsGeneration) return;
+        if (!state.config) return;
+        // Re-publish only after a held route recheck has refreshed assignments.
+        // The pixel can load after the SDK, so rebroadcast briefly instead of
+        // relying on one event.
+        scheduleShopifyAssignmentSync();
+        if (state.analyticsStarted && !state.trackingPrerequisiteMet) {
+          stopAnalyticsStage();
+        } else if (state.analyticsStarted) {
+          flushPendingPerf();
+          state.exposedAssignmentKeys.clear();
+          trackViewedAssignments(state.config);
+          setupGoalTracking(exps, nextUrl);
+          setupHeatmapTracking(state.assignments, exps);
+          setupReplayTracking(state.assignments, exps);
+          onPageEnter(analyticsTrack);
+        } else if (!state.screenshotMode && !trackingBlocked() && state.trackingPrerequisiteMet) {
+          if (state.trackingStart === "idle") {
+            scheduleAnalyticsStart(state.config, exps);
+          } else {
+            startAnalyticsStage(state.config, exps);
+          }
+        }
+      };
+      if (state.pendingInitialApply) {
+        // The URL recheck queued behind a hold/hydration gate; running the
+        // route analytics now would expose and wire goals for the previous
+        // route's stale assignments. The queued recheck registered first,
+        // so assignments are fresh by the time this runs.
+        void state.pendingInitialApply.then(runRouteAnalytics);
+      } else {
+        runRouteAnalytics();
+      }
+    }, {
+      ...(hasPollingPageRules
+        ? {
+            pollingIntervalMs: normalizeNumber(
+              config.pageTrigger?.urlPollIntervalMs,
+              PAGE_URL_POLL_INTERVAL_MS,
+            ),
+          }
+        : {}),
+      onObserverError: (error) => recordObserverError("route", error),
+    });
+  }
+
+  if (
+    !emptyProjectFastPath &&
+    domPageTrigger &&
+    (!manualInitialTrigger || hasDomPageRules)
+  ) {
+    state.stopDomObserver = observeDomChanges(() => {
+      try {
+        const triggeredPageIds = firePageDetector("dom", location.href);
+        if (shopDomPageTrigger || triggeredPageIds.size > 0) {
+          reevaluateAssignments("dom", false, false, {
+            triggeredPageIds,
+            includeImmediate: shopDomPageTrigger,
+          });
+        }
+      } catch (error) {
+        recordObserverError("dom", error);
+      }
+    }, config.spa?.debounceMs ?? 250);
+  }
+
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("init", `${state.assignments.length} assignment(s) active`, state.assignments.map(a => ({
+    experiment: a.experimentId,
+    variation: a.variationId,
+    isControl: a.isControl,
+  })));
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep("Execution cycle complete", {
+    assignments: state.assignments.map((assignment) => ({
+      experimentId: assignment.experimentId,
+      variationId: assignment.variationId,
+      isControl: assignment.isControl,
+    })),
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && debugGroupEnd();
+
+  // Lazy-load QA toolbar when in QA mode. Screenshot captures use QA forcing
+  // without any visible Apex UI in the captured page.
+  if (FEATURE_QA && state.qaMode && !state.screenshotMode) {
+    // The QA Assistant replaces the legacy toolbar; if its module is stubbed
+    // or fails to load, fall back to the toolbar/devtools path so QA mode
+    // never goes dark.
+    loadQaAssistant(() => {
+      loadQaToolbar(experiments);
+      loadDevtoolsIfEnabled(experiments);
+    });
+  }
+  notifyQaAssistantRuntimeListeners();
+
+  // Lazy-load devtools overlay when enabled
+  if (!state.qaMode) {
+    loadDevtoolsIfEnabled(experiments);
+  }
+
+  // Dispatch initialized event
+  document.dispatchEvent(new CustomEvent("drip_initialized"));
+
+  return state.assignments;
+}
+