@drip-apex/sdk 0.1.0 → 0.3.0

package/src/analytics-runtime.ts

@@ -0,0 +1,2175 @@
+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 { cleanupBucketingStorage } from "./bucketing-cleanup";
+import { chooseVariation, inTrafficAllocation } from "./bucket";
+import { buildAssignment, decideAssignments } from "./decide-assignments";
+import { weekdayScheduleBlocksDelivery } from "./weekday-schedule";
+import { CONSENT_REQUIRED, DNT_BLOCKED, evaluateSynchronousConsent, readConfiguredConsent, readPath, resolveSynchronousConsentGranted } from "./consent-evaluation";
+import { clearEarlyInteractions, drainBootstrapEarlyInteractions, drainEarlyInteractions } from "./early-interaction-capture";
+import { getCwvMetrics, markCwvReveal, startCwvMeasurement, waitForCwvMetrics } from "./cwv";
+import { collectDeliveryTiming } from "./delivery-timing";
+import {
+  startStorefrontVitals,
+  stopStorefrontVitals,
+  type StorefrontVitalsContext,
+} from "./storefront-vitals";
+import {
+  browserGroupStickyStore,
+  clearBrowserGroupStickyStore,
+  resolveExclusionGroups,
+  type ExclusionGroupDecision,
+  type PersistedGroupSelection,
+} from "./exclusion-groups";
+import type { CompactGroupSelections } from "./persistence-decoders";
+import {
+  applyCommercePrice,
+  isCommercePriceWorkPending,
+  cleanupCommercePrice,
+  hasCommercePriceState,
+  COMMERCE_PRICE_SELECTORS,
+  isCommercePriceActive,
+  isCommercePriceExposureEligible,
+  notifyCommerceCartStampConfirmed,
+  setCommercePriceExposureListener,
+} from "./commerce-price";
+import {
+  applyCommerceShipping,
+  classifyShippingExposure,
+  cleanupCommerceShipping,
+  isShippingCartEligible,
+  isShippingCartEligibilityConfirmed,
+} from "./commerce-shipping";
+import {
+  addCssOwners,
+  injectCss,
+  injectExperimentCss,
+  injectExternalCss,
+  removeCssForOwner,
+} from "./css";
+import { configureDebug, debugLog, debugWarn, debugGroup, debugGroupEnd, isDebugEnabled } from "./debug";
+import { loadDebugBuild } from "./debug-loader";
+import { observeDomChanges } from "./dom-trigger";
+import { edgeRuntimeActive, readEdgeRuntimeAssignments } from "./edge-runtime";
+import { normalizeDataLayerEntry } from "./data-layer-normalize";
+import { interceptEditorLaunch, isEditorDevicePreview } from "./editor-bootstrap";
+import { cleanupGoals, goalWiringKeys, setupGoals, triggerGoal, triggerGoalsForEvent } from "./goals";
+import { clearQaForceFromUrl, isBot, isDuplicate, isIframe, isOptedOut, isQaMode, isScreenshotMode, parseForceParam, persistQaForce, persistUrlQaForce, exitQaMode, getQaSessionId } from "./guards";
+import { adoptUserId, applyHoldoutGate, configureIdentityStorage, getEphemeralUserId, getUserId, hashToFloat, isHoldoutVisitor, variationHashToFloat } from "./hash";
+import { createBucketingHandoverPayload, handoverMintTimeoutMs, hasBucketingHandover, installBucketingHandover, readBucketingHandover } from "./handover";
+import { revealAll } from "./hideflicker";
+import {
+  addExternalJsOwners,
+  execJs,
+  loadExternalJs,
+  removeExternalJsForOwner,
+  setJsPolicy,
+} from "./js";
+import {
+  addAppliedMutationOwners,
+  applyMutations,
+  applyToElement,
+  invalidateArtifact,
+  reassertNonStructuralMutations,
+  replayArtifact,
+  resetAppliedMutationsForOwner,
+} from "./mutate";
+import { registerMutedObserver, runMuted, unregisterMutedObserver } from "./observer-mute";
+import { assignmentsHaveVisualWork, awaitHydration, hasMutationHold, holdMutations, releaseMutations, signalHydrated } from "./hydration";
+import {
+  assignmentsHaveCustomJs,
+  assignmentsHaveStructuralMutations,
+  installEarlyReassert,
+  shouldUseEarlyReassert,
+} from "./early-reassert";
+import { trackAppliedMutation } from "./reassert-sentinel";
+import { observeRouteChanges, PAGE_URL_POLL_INTERVAL_MS } from "./router";
+import { buildExposureSignalContext } from "./exposure-signals";
+import {
+  buildRedirectDestination,
+  clearPendingRedirectAssignmentCarry,
+  finalizeRedirectAssignmentCarryHandover,
+  hasGeneratedRedirectAssignmentCarry,
+  filterUnsafeRedirectAssignments,
+  importRedirectAssignmentCarry,
+  isRedirectLoop,
+  markRedirectAssignmentCarryExposed,
+  parseRedirectAssignmentCarry,
+  persistPendingRedirectAssignmentCarry,
+  readPendingRedirectAssignmentCarry,
+  REDIRECT_ASSIGNMENT_PARAM,
+  redirectPlanForAssignment,
+  stripRedirectAssignmentCarry,
+  validateRedirectAssignmentCarry,
+  verifyRedirectAssignmentCarry,
+} from "./redirect";
+import type { VerifiedRedirectCarry } from "./redirect";
+import { buildPrerequisiteContext, evaluateProjectPrerequisite } from "./prerequisites";
+import {
+  REPLAY_PROGRESS_KEY_PREFIX,
+  REPLAY_SAMPLE_KEY_PREFIX,
+  resolveReplayRecorderUrl,
+  startReplayCapture,
+  type ReplayController,
+} from "./replay";
+import {
+  buildCartAttributeEntries,
+  buildCartMetafieldInputs,
+  buildSignedCartAttributeEntries,
+  APEX_CART_ATTRIBUTE_KEYS,
+  cannotRequestRequiredCommerceAuthorization,
+  getCartMetafieldStaleKeys as collectCartMetafieldStaleKeys,
+  invalidateShopifyCartAttributeSync,
+  normalizeCartMetafieldNamespace,
+  syncShopifyCartAttributes,
+  type CartAssignment,
+  type CartAttributeEntry,
+  type CartMetafieldInput,
+  type CartAttributeSyncInput,
+} from "./shopify-cart";
+import { onShopifyCartMutation } from "./shopify-cart-events";
+import {
+  getPendingGiftChoices,
+  noteCartSnapshotForGifts,
+  selectGiftOption,
+  syncGiftWithPurchase,
+  type GiftSyncOptions,
+} from "./commerce-gift";
+import { CART_DRAWER_OPEN_SIGNAL, installSurfaceSignals } from "./surface-signals";
+import {
+  assignmentSignature,
+  canUseEmptyProjectProfile,
+  computeUrlDiffNeeds,
+  getBlankScreenMs,
+  readPerfFlags,
+  resolveActivationMode,
+  resolvePlatform,
+  resolveRouterMode,
+  shouldReevaluateForUrlChange,
+} from "./runtime";
+import type { PerfFlagState } from "./runtime";
+import {
+  buildTargetingAttributes,
+  evaluateTargetingGatesDetailed,
+  matchPageTargetingRule,
+  readShopifySignal,
+  targetingHasJsTriggers,
+} from "./targeting";
+import { createApexRuntimeTools, type ApexRuntimeTools } from "./runtime-tools";
+import { createEventId, Tracker } from "./track";
+import {
+  clearStoredSignals,
+  configureSignalPersistenceAllowed,
+  clearRuntimeSignal,
+  getSignals as getStoredSignals,
+  getSignalDiagnostics,
+  rememberProduct,
+  setCartSignals,
+  setRuntimeSignal,
+  setSearchSignal,
+  setSignal as setStoredSignal,
+} from "./signals";
+import {
+  evaluateFlag as evaluateFlagFromExperiments,
+  evaluateFlagAssignment as evaluateFlagAssignmentFromExperiments,
+  evaluateFlagValue as evaluateFlagValueFromExperiments,
+} from "./flags";
+import {
+  ActivationMode,
+  AntiFlickerMode,
+  Assignment,
+  ActivationDiagnostics,
+  ActivationGateDiagnostic,
+  ConditionDiagnostic,
+  ConfigProfile,
+  ConsentModeSettings,
+  CustomJsPolicy,
+  DebugSettings,
+  ExecutionMode,
+  Experiment,
+  ExperimentActivationDiagnostic,
+  ExclusionGroupConfig,
+  ExclusionGroupMemberConfig,
+  Goal,
+  InitConfig,
+  PageTargetingRule,
+  PageActivationDiagnostic,
+  PageDeactivationMode,
+  PageTriggerMode,
+  PageTriggerSettings,
+  PerfFeatureFlag,
+  PerfFeatureFlags,
+  PlatformHint,
+  ProjectPrerequisites,
+  RouterMode,
+  SegmentCondition,
+  SpaSettings,
+  Targeting,
+  ExternalTrackingSettings,
+  ProjectCodeSettings,
+  RuntimeEnvironmentSettings,
+  RuntimeSignalDefinition,
+  SdkDiagnostics,
+  SnippetCriticalMutation,
+  SnippetCriticalMutationPlanItem,
+  SnippetDeliveryUrlRule,
+  BucketingCleanupSettings,
+  DataProtectionSettings,
+  DataLayerSignalMapping,
+  DataLayerTriggerSettings,
+  ExposureDestinationsSettings,
+  Mutation,
+  TrackEvent,
+  TrackingStart,
+  Variation,
+} from "./types";
+import {
+  addWaitEntryOwners,
+  applyMutationWithWait,
+  resetWaitEntriesForOwner,
+} from "./wait";import { OrderIdentityPlatform, SDKState, QaAssistantRuntimeSnapshot, PageActivationRuntimeState, PageRulePollController, state, runtimeSharedState } from "./runtime-state";
+import { applyRuntimeAntiFlicker, SDK_SCRIPT_SRC, HeatmapController, SemanticController, FetchAttemptInfo, FetchRetryOptions, DEFAULT_CONFIG_FETCH_TIMEOUT_MS, DEFAULT_CONFIG_FETCH_SLOW_MS, CONFIG_FETCH_RETRY_COUNT, CONFIG_FETCH_RETRY_DELAY_MS, CONFIG_FETCH_MAX_WAIT_MS, CACHED_REDIRECT_HIDE_TIMEOUT_MS, createFetchTimeoutError, fetchWithTimeout, fetchWithRetry, CONFIG_CACHE_KEY_PREFIX, DEFAULT_CONFIG_CACHE_TTL_MS, DEFAULT_ANTI_FLICKER_TIMEOUT_MS, DEFAULT_TRACKING_IDLE_TIMEOUT_MS, DEFAULT_EXECUTION_MODE, DEFAULT_TRACKING_START, DEFAULT_JS_POLICY, PAGE_RULE_POLL_WINDOW_MS, PAGE_RULE_POLL_INTERVAL_MS, CONSENT_COOKIE_NAME, IDENTITY_CONTEXT_COOKIE_NAME, IDENTITY_CONTEXT_COOKIE_MAX_AGE_SECONDS, IDENTITY_CONTEXT_COOKIE_MAX_ENCODED_BYTES, SESSION_STORAGE_KEY, collectScopedSelectors, ResolvedRuntimeConfig, UrlDiffNeeds, ConfigSource, PendingPerfEvent, InitPhaseKey, InitPerfContext, MAX_PERF_DURATION_MS, monotonicNow, boundedPerfDuration, createInitPerfContext, BootstrapPredecision, bootstrapPredecision, addInitPhase, DeliveryHealthStatus, DeliveryHealthTracker, RouteDiagnostic, DataLayerDiagnostic, ShopifySyncDiagnostic, ExposureDestinationDiagnostic, RuntimeLoadDiagnostic, DripPerfWindow, normalizeNumber, resolveRuntimeConfig, resolvePageTriggerMode, resolveDomPageTrigger, dtLog, traceName, traceStep, traceGate, browserDoNotTrackValue, trackingBlocked, storefrontVitalsGateOpen, syncStorefrontVitals, doNotTrackEnabled, storageAllowed, readWindowPath, configuredConsentGranted, syncConfiguredConsent, CUSTOM_CONSENT_POLL_INTERVAL_MS, CUSTOM_CONSENT_POLL_MAX_MS, MANUAL_CALLBACK_TRIGGER_RERUN_INTERVAL_MS, MANUAL_CALLBACK_TRIGGER_RERUN_MAX_MS, MANUAL_CALLBACK_TRIGGER_MAX_RERUNS, EVENT_DRIVEN_CONSENT_PROVIDERS, shouldPollConfiguredConsent, installConsentChangeListeners, resolveConsentRequired, resolveConsentGranted, persistentStorageAllowed, coerceSignalValue, captureUrlSignals, installClickSignalCaptures, captureEventPropertySignals, setCapturedSignal, setPublicSignal, getPublicSignals, normalizePageApiName, pageTriggerSignal, triggerPage, readElementCaptureValue, captureDomAndGlobalSignals, consentAwareDataProtection, writeConsentCookie, readConsentCookie, clearConsentStorage, applyConsentStorageMode, runWhenDomReady, applyProjectCode, resetProjectCode, runProjectStartupCode, collectJsTriggerConditions, collectPageTriggerRules, PageDetectorMode, PageRuleReconcileScope, collectPageDetectorRules, experimentsForGlobalRouteReevaluation, conditionUsesActivateTrigger, buildJsTriggerContext, runJsTriggerReset, normalizeActivationValue, installActivateJsTrigger, installPageTriggerRule, installJsTriggerObserver, notifyQaAssistantRuntimeListeners, HarnessManifest, harnessPollTimer, harnessPollKey, harnessVisibilityInstalled, activeHarnessAssignment, stopHarnessPolling, applyHarnessManifest, pollHarnessManifest, startHarnessPolling, getEventsEndpoint, mintBucketingHandoverPayload, verifyBucketingHandoverToken, clearScheduledAnalyticsStart, normalizeDataLayerTriggers, applyDataLayerMappings, readNumericPath, readStringPath, RESERVED_DATA_LAYER_REVENUE_KEYS, PendingDataLayerEvent, MAX_PENDING_DATA_LAYER_EVENTS, pendingDataLayerEvents, processedDataLayerEntries, isDataLayerEntryObject, markDataLayerEntryProcessed, trackDataLayerRevenue, trackDataLayerEvent, enqueuePendingDataLayerEvent, drainPendingDataLayerEvents, finishInitializingAssignments, handleDataLayerEvent, recordObserverError } from "./config-runtime";
+import { 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 { generateQaSessionId, SHOPIFY_ASSIGNMENT_SYNC_DELAYS_MS, shopifyAssignmentSyncTimers, CommerceOnlyAdoptionState, commercePriceAdoptionState, ensureCommercePriceAdoptionState, currentCommercePriceContext, withCommercePriceAssignments, clearShopifyAssignmentSyncTimers, adoptAuthoritativePriceAssignments, OffersAdoptionPlan, planAuthoritativeOffersAdoption, canAdoptAuthoritativeOffersAssignments, adoptAuthoritativeOffersAssignments, sdkCartMintAllowed, buildSdkCartMintInput, buildScopedCartAttributeSyncInput, buildActiveCartAttributeSyncInput, sdkCartMintSync, syncSdkCartMint, removeSdkCartMintTrigger, onSdkCartMintClick, installSdkCartMintTrigger, HeadlessCartAuthorizationState, headlessCartAuthorizationState, ensureHeadlessCartAuthorizationState, hasChargeAffectingCommerceAssignment, hasActiveAuthorizationPlane, hasActivePriceAuthorizationPlane, hasActiveShippingAuthorizationPlane, hasActiveOffersAuthorizationPlane, hasActiveCommerceAuthorizationPlane, requiresCommerceCohortPin, getChargeAffectingCommerceExperimentIds, isCohortStampedOnCart, syncActiveAssignmentToShopifyCart, configureChargeCorrectnessCartSync, holdoutConfigEpoch, publishAssignmentsToShopify, scheduleShopifyAssignmentSync, variationsAllowed, updateProjectActivationDiagnostics, trackingAllowed, experimentById, targetingLifecycleMode, preservePersistentAssignments, stopAnalyticsStage, canMintVerifiedRedirectCarry, planRedirectAssignment, navigateForRedirectAssignment, RECONCILE_MAX_DRAINS, reevaluateAssignments, reevaluateAssignmentsPass, reapplyQaAssistantForceMap, reconcileForcedUnavailable, __getQaAssistantRuntimeSnapshot, __subscribeQaAssistantRuntime, __forceQaAssistantVariation, __resetQaAssistantForce, clearQaForceFromCurrentUrl, initWithExperiments } from "./activation-runtime";
+import { loadQaToolbar, loadQaAssistant, loadDevtoolsIfEnabled, loadDevtools, init, trackEvent, track, funnelStepStorageKey, shouldTrackFunnelStep, trackStep, trackGoal, setConsent, hold, release, hydrated, recheckPrerequisites, reInit, RevenueEventData, normalizeRevenueCurrency, trackRevenue, flush, getAssignments, buildCurrentCartAttributes, getCartAttributes, getCartMetafields, getCartMetafieldStaleKeys, mergeCartAttributes, normalizedHeadlessCartToken, getSignedCartAttributes, confirmCartAttributesWritten, getExperiments, getGoals, getActiveExperimentIds, getRuntimeValue, getRuntimeTools, buildFlagContext, evaluateFlag, evaluateFlagAssignment, evaluateFlagValue, getDiagnostics, QueueCommand, processCommand, processQueue, installedGlobalApi, createGlobalApi, installGlobalApi } from "./public-api";
+
+
+export function scheduleDeferredRouteReevaluation(): void {
+  if (state.deferredRouteReevaluationTimer !== null) return;
+  state.deferredRouteReevaluationTimer = window.setTimeout(() => {
+    state.deferredRouteReevaluationTimer = null;
+    try {
+      reevaluateAssignments("dom", false, false, {
+        triggeredPageIds: new Set(),
+        includeImmediate: true,
+      });
+    } catch (error) {
+      recordObserverError("route", error);
+    }
+  }, 0);
+}
+
+export function installDataLayerTriggers(config: InitConfig): (() => void) | null {
+  const triggers = normalizeDataLayerTriggers(config);
+  if (!triggers.length || typeof window === "undefined") return null;
+
+  const byLayer = new Map<string, DataLayerTriggerSettings[]>();
+  for (const trigger of triggers) {
+    const layerName = trigger.dataLayerName || "dataLayer";
+    byLayer.set(layerName, [...(byLayer.get(layerName) ?? []), trigger]);
+  }
+
+  const cleanups: Array<() => void> = [];
+  for (const [layerName, layerTriggers] of byLayer.entries()) {
+    const w = window as unknown as Record<string, any>;
+    const layer = Array.isArray(w[layerName]) ? w[layerName] : [];
+    w[layerName] = layer;
+    const originalPush = layer.push;
+    let active = true;
+    const process = (item: unknown) => {
+      if (!active) return;
+      if (isDataLayerEntryObject(item) && processedDataLayerEntries.has(item)) return;
+      const payload = normalizeDataLayerEntry(item);
+      if (!payload) {
+        markDataLayerEntryProcessed(item);
+        return;
+      }
+      const eventName = typeof payload.event === "string" ? payload.event : "";
+      let matched = false;
+      for (const trigger of layerTriggers) {
+        if (eventName === trigger.eventName) {
+          matched = true;
+          handleDataLayerEvent(trigger, payload, layerName, item, payload !== item);
+        }
+      }
+      if (!matched) markDataLayerEntryProcessed(item);
+    };
+
+    const safelyProcess = (item: unknown) => {
+      try {
+        process(item);
+      } catch (error) {
+        recordObserverError("data_layer", error);
+      }
+    };
+    layer.slice(Math.max(0, layer.length - 50)).forEach(safelyProcess);
+    const wrappedPush = function (...items: unknown[]) {
+      const result = originalPush.apply(layer, items);
+      items.forEach(safelyProcess);
+      return result;
+    };
+    layer.push = wrappedPush as typeof layer.push;
+    cleanups.push(() => {
+      active = false;
+      if (layer.push === wrappedPush) layer.push = originalPush;
+    });
+  }
+
+  return () => cleanups.forEach((cleanup) => cleanup());
+}
+
+export function experimentsUseSurfaceSignals(experiments: Experiment[]): boolean {
+  return experiments.some((experiment) => {
+    try {
+      return JSON.stringify(experiment.targeting ?? {}).includes(CART_DRAWER_OPEN_SIGNAL);
+    } catch {
+      return false;
+    }
+  });
+}
+
+export function rememberExposureDestination(result: ExposureDestinationDiagnostic): void {
+  state.exposureDestinationDiagnostics = [result, ...state.exposureDestinationDiagnostics].slice(0, 20);
+}
+
+export let clarityUpgradeSent = false;
+
+export function clarityTagKey(prefix: string, name: string): string {
+  const key = `${prefix}${name}`
+    .replace(/[^A-Za-z0-9 _-]/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 80);
+  return key || "apex experiment";
+}
+
+export function pushExposureToQueue(destination: NonNullable<ExposureDestinationsSettings["queues"]>[number], payload: Record<string, unknown>): void {
+  const queue = readWindowPath(destination.globalName) as any;
+  if (!queue) throw new Error("queue_missing");
+  const eventName = destination.eventName || "Viewed an experiment";
+  if (Array.isArray(queue)) {
+    queue.push(destination.method
+      ? { method: destination.method, event_name: eventName, event_attributes: payload }
+      : { event: eventName, ...payload });
+    return;
+  }
+  if (typeof queue.push === "function") {
+    queue.push(destination.method
+      ? { method: destination.method, event_name: eventName, event_attributes: payload }
+      : { event: eventName, ...payload });
+    return;
+  }
+  throw new Error("queue_push_missing");
+}
+
+export function emitExposureDestinations(assignment: Assignment, config: InitConfig): void {
+  const destinations = config.exposureDestinations;
+  if (!destinations) return;
+  const payload = {
+    project_id: config.shopId ?? "",
+    experiment_id: assignment.experimentId,
+    variation_id: assignment.variationId,
+    experiment_name: assignment.experimentName ?? assignment.experimentId,
+    variation_index: assignment.index,
+    variation_name: assignment.variationId,
+    is_control: assignment.isControl,
+  };
+  const at = Date.now();
+
+  if (destinations.dataLayer?.enabled) {
+    try {
+      const dataLayerName = destinations.dataLayer.dataLayerName || "dataLayer";
+      const w = window as unknown as Record<string, any>;
+      const layer = Array.isArray(w[dataLayerName]) ? w[dataLayerName] : [];
+      w[dataLayerName] = layer;
+      layer.push({
+        event: destinations.dataLayer.eventName || "apex_experiment_viewed",
+        ...(destinations.dataLayer.includeMetadata === false ? {
+          experiment_id: assignment.experimentId,
+          variation_id: assignment.variationId,
+        } : payload),
+      });
+      rememberExposureDestination({ type: "dataLayer", status: "sent", at });
+    } catch (error) {
+      rememberExposureDestination({ type: "dataLayer", status: "failed", at, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  if (destinations.hotjar?.enabled) {
+    try {
+      const hj = (window as any).hj;
+      if (typeof hj !== "function") throw new Error("hotjar_missing");
+      if (destinations.hotjar.mode === "event") {
+        hj("event", destinations.hotjar.eventName || "apex_experiment_viewed");
+      } else {
+        hj("identify", null, { apex_ab_test: `${assignment.experimentId}-${assignment.variationId}` });
+      }
+      rememberExposureDestination({ type: "hotjar", status: "sent", at });
+    } catch (error) {
+      rememberExposureDestination({ type: "hotjar", status: "failed", at, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  if (destinations.clarity?.enabled) {
+    try {
+      const clarityFn = (window as any).clarity;
+      if (typeof clarityFn !== "function") throw new Error("clarity_missing");
+      const mode = destinations.clarity.mode === "event" || destinations.clarity.mode === "both"
+        ? destinations.clarity.mode
+        : "set";
+      if (mode === "set" || mode === "both") {
+        const key = clarityTagKey(
+          destinations.clarity.tagPrefix ?? "apex ",
+          assignment.experimentName ?? assignment.experimentId,
+        );
+        const value = assignment.isControl ? "control" : `variant-${assignment.index}`;
+        clarityFn("set", key, value);
+      }
+      if (mode === "event" || mode === "both") {
+        clarityFn("event", destinations.clarity.eventName || "apex_experiment_viewed");
+      }
+      if (destinations.clarity.upgrade && !clarityUpgradeSent) {
+        try {
+          clarityFn("upgrade", "apex_experiment");
+          clarityUpgradeSent = true;
+        } catch {
+          // Leave clarityUpgradeSent false so the upgrade retries on the next exposure.
+        }
+      }
+      rememberExposureDestination({ type: "clarity", status: "sent", at });
+    } catch (error) {
+      rememberExposureDestination({ type: "clarity", status: "failed", at, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  if (destinations.contentsquare?.enabled) {
+    try {
+      const w = window as any;
+      const uxa = (w._uxa = Array.isArray(w._uxa) || (w._uxa && typeof w._uxa.push === "function") ? w._uxa : []);
+      const key = clarityTagKey(
+        destinations.contentsquare.keyPrefix ?? "apex ",
+        assignment.experimentName ?? assignment.experimentId,
+      ).slice(0, 50);
+      uxa.push([
+        "trackDynamicVariable",
+        {
+          key,
+          value: assignment.isControl ? "control" : `variant-${assignment.index}`,
+        },
+      ]);
+      rememberExposureDestination({ type: "contentsquare", status: "sent", at });
+    } catch (error) {
+      rememberExposureDestination({ type: "contentsquare", status: "failed", at, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  if (destinations.posthog?.enabled) {
+    try {
+      const posthog = (window as any).posthog;
+      if (!posthog || (typeof posthog !== "object" && typeof posthog !== "function") || typeof posthog.capture !== "function") {
+        rememberExposureDestination({ type: "posthog", status: "failed", at, reason: "posthog_missing" });
+      } else {
+        const mode = destinations.posthog.mode === "capture" || destinations.posthog.mode === "register"
+          ? destinations.posthog.mode
+          : "both";
+        if (mode === "capture" || mode === "both") {
+          posthog.capture(destinations.posthog.eventName || "apex_experiment_viewed", payload);
+        }
+        if (mode === "register" || mode === "both") {
+          if (typeof posthog.register !== "function") {
+            rememberExposureDestination({ type: "posthog", status: "failed", at, reason: "posthog_register_missing" });
+          } else {
+            posthog.register({ [`apex_exp_${assignment.experimentId}`]: assignment.variationId });
+            rememberExposureDestination({ type: "posthog", status: "sent", at });
+          }
+        } else {
+          rememberExposureDestination({ type: "posthog", status: "sent", at });
+        }
+      }
+    } catch (error) {
+      rememberExposureDestination({ type: "posthog", status: "failed", at, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  for (const queue of destinations.queues ?? []) {
+    if (queue.enabled === false) continue;
+    try {
+      pushExposureToQueue(queue, payload);
+      rememberExposureDestination({ type: `queue:${queue.globalName}`, status: "sent", at });
+    } catch (error) {
+      rememberExposureDestination({
+        type: `queue:${queue.globalName}`,
+        status: "failed",
+        at,
+        reason: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}
+
+export function ensureTrackerStarted(config: InitConfig): void {
+  if (state.tracker) return;
+  if (state.screenshotMode) return;
+  if (state.trackingDisabledByDnt) return;
+  const eventsEndpoint = getEventsEndpoint(config);
+  if (!eventsEndpoint) return;
+
+  state.tracker = new Tracker({
+    endpoint: eventsEndpoint,
+    proxyEventDelivery: config.proxyEventDelivery,
+    assetFallback: config.assetFallback,
+    shopId: config.shopId,
+    ingestShopId: config.ingestShopId ?? config.shopId,
+    ingestSignature: config.ingestSignature,
+    visitorId: state.userId ?? undefined,
+    getActiveAssignment: () => {
+      const a = state.assignments.length > 0 ? state.assignments[0] : null;
+      return a ? { experimentId: a.experimentId, variationId: a.variationId } : null;
+    },
+    buildPageExitEvents: buildPageExitEvents,
+    qaMode: state.qaMode,
+    qaSessionId: state.qaSessionId,
+    environment: config.environments?.activeKey || "production",
+    cohort: config.holdout_v1_enabled === true ? (state.holdout ? "holdout" : "active") : undefined,
+    holdoutConfigEpoch: holdoutConfigEpoch(config),
+  });
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("tracker", "Tracker started", { endpoint: eventsEndpoint, qaMode: state.qaMode });
+  state.tracker.start();
+}
+
+export function exposureAssignmentKey(assignment: Assignment): string {
+  const entityId = assignment.kind === "personalization" && assignment.personalization
+    ? assignment.personalization.id
+    : assignment.experimentId;
+  return `${entityId}:${assignment.variationId}:${assignment.assignmentEpoch ?? ""}`;
+}
+
+export function priceAssignmentAuthorizationKey(assignment: {
+  experimentId: string;
+  variationId: string;
+  assignmentEpoch?: number;
+}): string {
+  return `${assignment.experimentId}:${assignment.variationId}:${assignment.assignmentEpoch ?? ""}`;
+}
+
+export function isPriceDisplayAssignmentAuthorized(assignment: Assignment): boolean {
+  const authorization = state.config?.commerce?.price?.authorization;
+  if (
+    authorization?.version !== 1 ||
+    !Number.isSafeInteger(authorization.revision) ||
+    authorization.revision <= 0 ||
+    !authorization.experimentIds?.includes(assignment.experimentId)
+  ) return true;
+  // Inside a mixed experiment, a variation without any charged adjustment is
+  // display-only: it needs no cart proof even though its experiment is on
+  // the authorization plane.
+  const adjustments = state.config?.commerce?.price?.experiments
+    .find((experiment) => experiment.experiment_id === assignment.experimentId)
+    ?.variants[assignment.variationId];
+  if (
+    adjustments &&
+    !adjustments.some((adjustment) => typeof adjustment.fixedPricePerUnit === "string")
+  ) return true;
+  return state.authorizedPriceAssignmentKeys?.has(
+    priceAssignmentAuthorizationKey(assignment),
+  ) === true;
+}
+
+export function isShippingDisplayAssignmentAuthorized(assignment: Assignment): boolean {
+  const authorization = state.config?.commerce?.shipping?.authorization;
+  if (
+    authorization?.version !== 1 ||
+    !Number.isSafeInteger(authorization.revision) ||
+    authorization.revision <= 0 ||
+    !authorization.experimentIds?.includes(assignment.experimentId)
+  ) return true;
+  return state.authorizedShippingAssignmentKeys?.has(
+    priceAssignmentAuthorizationKey(assignment),
+  ) === true;
+}
+
+export function isOffersDisplayAssignmentAuthorized(assignment: Assignment): boolean {
+  const authorization = state.config?.commerce?.offers?.authorization;
+  if (
+    authorization?.version !== 1 ||
+    !Number.isSafeInteger(authorization.revision) ||
+    authorization.revision <= 0 ||
+    !authorization.experimentIds?.includes(assignment.experimentId)
+  ) return true;
+  return state.authorizedOffersAssignmentKeys?.has(
+    priceAssignmentAuthorizationKey(assignment),
+  ) === true;
+}
+
+export function giftSyncOptions(extra?: Partial<GiftSyncOptions>): GiftSyncOptions {
+  return {
+    // Proof comes from the CURRENT stamped offers plane, not config: a
+    // shared price+offers assignment whose offers proof was refused must
+    // not insert (or keep) a gift the Function will not discount.
+    isArmProven: (assignment) =>
+      state.authorizedOffersAssignmentKeys?.has(
+        priceAssignmentAuthorizationKey(assignment),
+      ) === true,
+    ...extra,
+  };
+}
+
+export /** Every artifact applyAssignments/applyAssignmentCode can render. */
+function assignmentHasRenderableArtifacts(assignment: Assignment): boolean {
+  return !isAssignmentArtifactInactive(assignment) && !!(
+    assignment.mutations.length ||
+    assignment.css ||
+    assignment.js ||
+    assignment.experimentCss ||
+    assignment.experimentJs ||
+    assignment.externalCssUrl ||
+    assignment.externalJsUrl
+  );
+}
+
+export /** Install offers display keys and render any DOM they just unlocked. */
+function authorizeOffersDisplayAndRender(
+  authorizedAssignments: CartAssignment[],
+): void {
+  const previous = state.authorizedOffersAssignmentKeys;
+  const next = new Set(
+    authorizedAssignments.map(priceAssignmentAuthorizationKey),
+  );
+  state.authorizedOffersAssignmentKeys = next;
+  // Re-apply only when authorization just unlocked withheld DOM for an
+  // offers-enforced assignment; the identity guard breaks the
+  // apply -> sync -> already-stamped -> authorize loop.
+  const offersEnforcedIds = new Set(
+    state.config?.commerce?.offers?.authorization?.experimentIds ?? [],
+  );
+  const newlyRenderable = state.assignments.some((assignment) =>
+    offersEnforcedIds.has(assignment.experimentId) &&
+    next.has(priceAssignmentAuthorizationKey(assignment)) &&
+    !previous?.has(priceAssignmentAuthorizationKey(assignment)) &&
+    assignmentHasRenderableArtifacts(assignment));
+  if (newlyRenderable) {
+    // Full reapply behind the established cleanup (the adoption pattern):
+    // without it, parallel already-rendered assignments would duplicate
+    // structural insert mutations and re-run custom JS un-reset.
+    teardownTransaction(allAppliedPagesWithModes(), { skipCartSync: true });
+    applyAssignments(state.assignments, state.activationMode);
+  }
+}
+
+export /** Revoke the previous cart's offer grant and restore un-authorized DOM. */
+function revokeOffersDisplayAuthorization(): void {
+  const previous = state.authorizedOffersAssignmentKeys;
+  if (!previous || previous.size === 0) return;
+  const offersEnforcedIds = new Set(
+    state.config?.commerce?.offers?.authorization?.experimentIds ?? [],
+  );
+  const hadRenderable = state.assignments.some((assignment) =>
+    offersEnforcedIds.has(assignment.experimentId) &&
+    previous.has(priceAssignmentAuthorizationKey(assignment)) &&
+    assignmentHasRenderableArtifacts(assignment));
+  state.authorizedOffersAssignmentKeys = new Set();
+  if (hadRenderable) {
+    // The new cart holds no stamp for these arms; retire their treatment
+    // (cleanup + withheld reapply) until its authorization is confirmed.
+    teardownTransaction(allAppliedPagesWithModes(), { skipCartSync: true });
+    applyAssignments(state.assignments, state.activationMode);
+  }
+}
+
+export function exposureEligibleAssignments(config: InitConfig): Assignment[] {
+  return state.assignments
+    .filter(exposable)
+    .filter(
+      (assignment) =>
+        assignment.isControl ||
+        (isPriceDisplayAssignmentAuthorized(assignment) &&
+          isCommercePriceExposureEligible(config.commerce?.price, assignment)),
+    )
+    .filter(
+      (assignment) =>
+        isShippingDisplayAssignmentAuthorized(assignment) &&
+        isShippingExposureCartEligible(config, assignment),
+    )
+    .filter(isOffersDisplayAssignmentAuthorized);
+}
+
+export function isShippingExposureCartEligible(
+  config: InitConfig,
+  assignment: Assignment,
+): boolean {
+  const experiment = config.commerce?.shipping?.experiments.find(
+    (candidate) => candidate.experiment_id === assignment.experimentId,
+  );
+  if (!experiment) return true;
+  const exposure = classifyShippingExposure(
+    experiment.variants,
+    Boolean(assignment.isControl),
+    experiment.variants[assignment.variationId],
+  );
+  return (!exposure.needsTargetProof && !exposure.isCurrencyBound)
+    || isShippingCartEligibilityConfirmed(assignment.experimentId);
+}
+
+export function trackViewedAssignmentsAfterShippingEligibility(): void {
+  if (state.analyticsStarted && state.config && !trackingBlocked()) {
+    trackViewedAssignments(state.config);
+  }
+}
+
+setCommercePriceExposureListener(
+  trackViewedAssignmentsAfterShippingEligibility,
+);
+
+export const EMPTY_TARGETING_ATTRIBUTES: Record<string, unknown> = {};
+
+export type TargetingEvaluationPass = {
+  attributes?: Record<string, unknown>;
+  persistSignals: boolean;
+  sourceAttributes: Record<string, unknown>;
+  url: string;
+};
+
+export let activeTargetingEvaluationPass: TargetingEvaluationPass | undefined;
+
+export function createTargetingEvaluationPass(
+  sourceAttributes: Record<string, unknown>,
+  url: string,
+  persistSignals: boolean,
+): TargetingEvaluationPass {
+  return { persistSignals, sourceAttributes, url };
+}
+
+export function targetingAttributesForPass(
+  pass: TargetingEvaluationPass | undefined,
+  sourceAttributes: Record<string, unknown>,
+  url: string,
+  persistSignals: boolean,
+): Record<string, unknown> {
+  if (
+    pass &&
+    pass.url === url &&
+    pass.sourceAttributes === sourceAttributes
+  ) {
+    return pass.attributes ??= buildTargetingAttributes(sourceAttributes, url, {
+      persistSignals,
+    });
+  }
+  return buildTargetingAttributes(sourceAttributes, url, { persistSignals });
+}
+
+export function trackViewedAssignments(
+  config: InitConfig,
+  onlyAssignments?: Assignment[],
+  targetingPass?: TargetingEvaluationPass,
+): void {
+  if (config.autoTrack === false) return;
+  const eligibleAssignments = exposureEligibleAssignments(config);
+  const assignments = onlyAssignments
+    ? eligibleAssignments.filter((candidate) => onlyAssignments.some((assignment) =>
+        assignment.experimentId === candidate.experimentId && assignment.variationId === candidate.variationId))
+    : eligibleAssignments;
+  if (assignments.length === 0) return;
+  const url = config.url ?? (typeof location !== "undefined" ? location.href : "");
+  const sourceAttributes = config.attributes ?? EMPTY_TARGETING_ATTRIBUTES;
+  const persistSignals = persistentStorageAllowed();
+  const attributes = targetingAttributesForPass(
+    targetingPass,
+    sourceAttributes,
+    url,
+    persistSignals,
+  );
+  const exposureSignals = buildExposureSignalContext({
+    attributes,
+    customSignals: config.signals,
+  });
+  assignments.forEach((a) => {
+    const exposureKey = exposureAssignmentKey(a);
+    if (state.exposedAssignmentKeys.has(exposureKey)) return;
+    state.exposedAssignmentKeys.add(exposureKey);
+    if (a.kind === "personalization" && a.personalization) {
+      track(
+        "personalization_rendered",
+        {
+          index: a.index,
+          ...(exposureSignals ? { signals: exposureSignals } : {}),
+          entity_kind: "personalization",
+          personalization_id: a.personalization.id,
+          personalization_key: a.personalization.key,
+          personalization_rule_id: a.personalization.ruleId,
+          personalization_experience_id: a.personalization.experienceId,
+          personalization_surface: a.personalization.surface,
+          personalization_template_key: a.personalization.templateKey,
+        },
+        a.experimentId,
+        a.variationId,
+      );
+    } else {
+      track(
+        "experiment_viewed",
+        {
+          index: a.index,
+          ...(exposureSignals ? { signals: exposureSignals } : {}),
+        },
+        a.experimentId,
+        a.variationId,
+      );
+    }
+    emitExposureDestinations(a, config);
+    rememberOrderExposure(a);
+    config.onExperimentViewed?.(a);
+  });
+}
+
+export function sameStringSet(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean {
+  if (left.size !== right.size) return false;
+  for (const value of left) {
+    if (!right.has(value)) return false;
+  }
+  return true;
+}
+
+export function setupGoalTracking(
+  experiments: Experiment[],
+  url = state.wiredGoalUrl ?? state.config?.url ??
+    (typeof location !== "undefined" ? location.href : "https://_"),
+  activePageIdsForGoals = activePageIds(),
+): void {
+  // Goals listen on the assigned plane. Their own Page scope decides where
+  // they convert; exposure and commerce remain gated by the render plane.
+  const assignments = state.assignments.filter(attributable);
+  state.wiredGoalKeys = goalWiringKeys(
+    assignments,
+    experiments,
+    activePageIdsForGoals,
+  );
+  state.wiredGoalUrl = url;
+  cleanupGoals();
+  setupGoals(assignments, experiments, (goalId, assignment, data) => {
+    const originalTimestamp = typeof data?.early_interaction_timestamp === "number"
+      ? data.early_interaction_timestamp
+      : undefined;
+    const eventData: Record<string, unknown> = { goalId, ...data };
+    delete eventData.early_interaction_timestamp;
+    trackEvent("goal", eventData, assignment.experimentId, assignment.variationId, undefined, false, originalTimestamp);
+  }, activePageIdsForGoals);
+  drainBootstrapEarlyInteractions({
+    // Bootstrap interactions were captured before mutation delivery could
+    // resolve. Keep them available to the assignment that existed at click
+    // time; triggerGoal applies the normal count-once and goal validation.
+    assignments: state.assignments.filter((assignment) => {
+      const key = exposureAssignmentKey(assignment);
+      return assignment.experimentId.length > 0 && assignment.variationId.length > 0 &&
+        !state.contaminatedAssignmentKeys.has(key);
+    }),
+    experiments,
+    activePageIds: activePageIdsForGoals,
+    requireConsent: state.config?.requireConsent,
+    consentModeEnabled: state.config?.consentMode?.enabled,
+    consentProvider: state.config?.consentMode?.provider,
+    consentRequiredGroup: state.config?.consentMode?.requiredGroup,
+    consentGetter: state.config?.consentMode?.getter,
+    respectDoNotTrack: state.config?.dataProtection?.respectDoNotTrack,
+    consume: (goalId, assignment, timestamp, kind, pageUrl) => triggerGoal(
+      goalId,
+      [assignment],
+      experiments,
+      { early_interaction: true, early_page_url: pageUrl, early_interaction_kind: kind, early_interaction_timestamp: timestamp },
+    ),
+  });
+  if (state.tracker && state.config) {
+    drainEarlyInteractions({
+      configRevision: state.config.delivery?.revision,
+      sessionId: state.tracker.getSessionId(),
+      storageMode: state.config.dataProtection?.storageMode,
+      experiments,
+      requireConsent: state.config.requireConsent,
+      consentModeEnabled: state.config.consentMode?.enabled,
+      consentProvider: state.config.consentMode?.provider,
+      consentRequiredGroup: state.config.consentMode?.requiredGroup,
+      consentGetter: state.config.consentMode?.getter,
+      respectDoNotTrack: state.config.dataProtection?.respectDoNotTrack,
+      forcedExperimentIds: Object.keys(state.forceMap ?? {}),
+      consume: (entry) => {
+        // The origin stamp is authoritative across navigation, but still route
+        // through the normal goal implementation for count-once and callbacks.
+        triggerGoal(
+          entry.goalId,
+          [{ experimentId: entry.experimentId, variationId: entry.variationId } as Assignment],
+          experiments,
+          { ...entry.data, early_page_url: entry.pageUrl, early_interaction_kind: entry.kind },
+        );
+      },
+    });
+  }
+}
+
+export function setupHeatmapTracking(assignments: Assignment[], experiments: Experiment[]): void {
+  if (!FEATURE_HEATMAP) return;
+  if (!state.tracker || trackingBlocked()) return;
+  if (state.heatmapController) {
+    state.heatmapController.update(assignments, experiments);
+    return;
+  }
+  import("./heatmap").then(({ startHeatmapCapture }) => {
+    if (!state.tracker || trackingBlocked() || state.heatmapController) return;
+    state.heatmapController = startHeatmapCapture(assignments, experiments, track);
+  }).catch(() => {});
+}
+
+export function cleanupHeatmapTracking(): void {
+  if (!state.heatmapController) return;
+  state.heatmapController.stop();
+  state.heatmapController = null;
+}
+
+export function setupReplayTracking(assignments: Assignment[], experiments: Experiment[]): void {
+  if (!FEATURE_REPLAY) return;
+  if (!state.tracker || !state.config || trackingBlocked()) {
+    cleanupReplayTracking();
+    return;
+  }
+  if (state.replayController?.isStopped()) {
+    state.replayController = null;
+  }
+  if (state.replayController) {
+    state.replayController.update(assignments, experiments);
+    return;
+  }
+  if (state.replayStartPromise) return;
+
+  const generation = state.replayGeneration;
+  const config = state.config;
+  const tracker = state.tracker;
+  const replayBlocked = () =>
+    trackingBlocked()
+    || generation !== state.replayGeneration
+    || state.tracker !== tracker;
+  const recorderUrl = resolveReplayRecorderUrl({
+    configuredUrl: config.replayRecorderUrl,
+    scriptSrc: SDK_SCRIPT_SRC,
+    pageUrl: typeof location !== "undefined" ? location.href : undefined,
+  });
+  if (!config.endpoint || !recorderUrl) return;
+  let startPromise: Promise<void>;
+  startPromise = startReplayCapture({
+    assignments: state.assignments,
+    experiments: config.experiments ?? [],
+    recorderUrl,
+    endpoint: config.endpoint,
+    shopId: config.ingestShopId ?? config.shopId ?? "",
+    visitorId: state.userId ?? "",
+    sessionId: tracker.getSessionId(),
+    environment: config.environments?.activeKey || "production",
+    qaMode: state.qaMode,
+    qaSessionId: state.qaSessionId,
+    sdkVersion: config.sdkVersion || "unknown",
+    ingestSignature: config.ingestSignature,
+    isTrackingBlocked: replayBlocked,
+  })
+    .then((controller) => {
+      if (!controller) return;
+      if (replayBlocked()) {
+        controller.stop(true);
+        return;
+      }
+      controller.update(state.assignments, state.config?.experiments ?? []);
+      state.replayController = controller;
+    })
+    .catch(() => {})
+    .finally(() => {
+      if (state.replayStartPromise === startPromise) state.replayStartPromise = null;
+      if (
+        generation !== state.replayGeneration
+        && state.tracker
+        && state.config
+        && !trackingBlocked()
+      ) {
+        setupReplayTracking(state.assignments, state.config.experiments ?? []);
+      }
+    });
+  state.replayStartPromise = startPromise;
+}
+
+export function cleanupReplayTracking(): void {
+  state.replayGeneration += 1;
+  state.replayController?.stop(true);
+  state.replayController = null;
+}
+
+export function setupSemanticTracking(config: InitConfig): void {
+  if (!state.tracker || trackingBlocked()) return;
+  if (state.semanticController) return;
+  import("./semantic").then(({ startSemanticCapture }) => {
+    if (!state.tracker || trackingBlocked() || state.semanticController) return;
+    state.semanticController = startSemanticCapture(config.semanticTracking, track);
+  }).catch(() => {});
+}
+
+export function cleanupSemanticTracking(): void {
+  if (!state.semanticController) return;
+  state.semanticController.stop();
+  state.semanticController = null;
+}
+
+export function buildExperimentBehaviorEvents(
+  type: "experiment_pageview" | "experiment_page_exit",
+  data?: Record<string, unknown>,
+): TrackEvent[] {
+  return state.assignments.filter(exposable).map((assignment) => ({
+    type,
+    data: withAssignmentEpochData(data, assignment.experimentId, assignment.variationId),
+    url: cleanUrl(),
+    experimentId: assignment.experimentId,
+    variationId: assignment.variationId,
+  }));
+}
+
+export function buildPageExitEvents(type: string, data?: Record<string, unknown>): TrackEvent[] {
+  const a = state.assignments.find(exposable) ?? null;
+  return [
+    {
+      type,
+      data: withAssignmentEpochData(data, a?.experimentId, a?.variationId),
+      url: cleanUrl(),
+      experimentId: a?.experimentId,
+      variationId: a?.variationId,
+    },
+    ...buildExperimentBehaviorEvents("experiment_page_exit", data),
+  ];
+}
+
+export /** Track analytics events with legacy global events plus per-assignment behavior events. */
+function analyticsTrack(type: string, data?: Record<string, unknown>): void {
+  if (trackingBlocked()) return;
+  if (!state.tracker) return;
+  // Attach identity only when an assignment is exposable. The shop-level
+  // event stays unassigned while all held assignments remain ineligible.
+  const a = state.assignments.find(exposable) ?? null;
+  const event: TrackEvent = {
+    type,
+    data: withAssignmentEpochData(data, a?.experimentId, a?.variationId),
+    url: cleanUrl(),
+    experimentId: a?.experimentId,
+    variationId: a?.variationId,
+  };
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("track", type, {
+    experimentId: a?.experimentId,
+    variationId: a?.variationId,
+    ...data,
+  });
+  state.tracker.track(event);
+  if (type === "pageview") {
+    if (state.config) scheduleOrderIdentityBeacon(state.config);
+    for (const behaviorEvent of buildExperimentBehaviorEvents("experiment_pageview", data)) {
+      state.tracker.track(behaviorEvent);
+    }
+  } else if (type === "page_exit") {
+    for (const behaviorEvent of buildExperimentBehaviorEvents("experiment_page_exit", data)) {
+      state.tracker.track(behaviorEvent);
+    }
+  }
+}
+
+export function syncLoadDiagnosticsToPerf(): void {
+  if (typeof window === "undefined") return;
+  const perfWindow = window as DripPerfWindow;
+  const perf = perfWindow.__dripPerf = perfWindow.__dripPerf ?? {};
+  perf.load_stage = state.load.stage;
+  perf.config_fetch_status = state.load.configFetchStatus;
+  if (state.load.configFetchAttempts !== undefined) perf.config_fetch_attempts = state.load.configFetchAttempts;
+  if (state.load.configFetchMs !== undefined) perf.config_fetch_ms = state.load.configFetchMs;
+  if (state.load.assignmentReadyMs !== undefined) perf.assignment_ready_ms = state.load.assignmentReadyMs;
+  if (state.load.pendingMutations !== undefined) perf.pending_mutations = state.load.pendingMutations;
+  if (state.load.appliedMutations !== undefined) perf.applied_mutations = state.load.appliedMutations;
+  if (state.load.missedMutations !== undefined) perf.missed_mutations = state.load.missedMutations;
+}
+
+export function updateLoadDiagnostics(patch: Partial<RuntimeLoadDiagnostic> & { stage: string }): void {
+  state.load = {
+    ...state.load,
+    ...patch,
+    updatedAt: Date.now(),
+  };
+  syncLoadDiagnosticsToPerf();
+  try {
+    document.dispatchEvent(new CustomEvent("drip_runtime_status", { detail: { ...state.load } }));
+  } catch {
+    // ignore event dispatch failures
+  }
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("trace", `Runtime status: ${patch.stage}`, patch as Record<string, unknown>);
+}
+
+export function resetLoadDiagnostics(stage = "boot"): void {
+  const now = Date.now();
+  state.load = {
+    stage,
+    startedAt: now,
+    updatedAt: now,
+    configFetchStatus: "idle",
+    configFetchAttempts: 0,
+    appliedMutations: 0,
+    missedMutations: 0,
+  };
+  syncLoadDiagnosticsToPerf();
+}
+
+export function queuePerfEvent(data: PendingPerfEvent): void {
+  if (trackingBlocked()) return;
+  state.pendingPerf = {
+    ...data,
+    config_fetch_ms: state.load.configFetchMs,
+    config_fetch_attempts: state.load.configFetchAttempts,
+    config_fetch_status: state.load.configFetchStatus,
+    config_fetch_status_code: state.load.configFetchStatusCode,
+    mutation_apply_pending: state.load.pendingMutations,
+    mutation_apply_applied: state.load.appliedMutations,
+    mutation_apply_missed: state.load.missedMutations,
+  };
+}
+
+export type RuntimeInstallClaim = {
+  installSurface: string;
+  sdkVersion: string;
+  runtimeProfile: string;
+};
+
+export const RUNTIME_INSTALL_CLAIM_KEY = "__dripRuntimeInstallClaim";
+export const RUNTIME_INSTALL_CONFLICT_KEY = "__dripRuntimeInstallConflictEmitted";
+
+export function telemetryLabel(value: unknown, fallback = "unknown"): string {
+  if (typeof value !== "string") return fallback;
+  const cleaned = value.trim().slice(0, 120);
+  return cleaned || fallback;
+}
+
+export function readRuntimeInstallClaim(): RuntimeInstallClaim | null {
+  const value = (globalThis as Record<string, unknown>)[RUNTIME_INSTALL_CLAIM_KEY];
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  return {
+    installSurface: telemetryLabel(record.installSurface, "direct_script"),
+    sdkVersion: telemetryLabel(record.sdkVersion),
+    runtimeProfile: telemetryLabel(record.runtimeProfile, "full"),
+  };
+}
+
+export function rememberRuntimeInstallClaim(config: InitConfig): RuntimeInstallClaim {
+  const claim = {
+    installSurface: telemetryLabel(config.installSurface, "direct_script"),
+    sdkVersion: telemetryLabel(config.sdkVersion),
+    runtimeProfile: telemetryLabel(config.runtimeProfile, "full"),
+  };
+  const runtimeGlobal = globalThis as Record<string, unknown>;
+  runtimeGlobal[RUNTIME_INSTALL_CLAIM_KEY] = claim;
+  delete runtimeGlobal[RUNTIME_INSTALL_CONFLICT_KEY];
+  return claim;
+}
+
+export function claimInstallConflictEmission(): boolean {
+  const runtimeGlobal = globalThis as Record<string, unknown>;
+  if (runtimeGlobal[RUNTIME_INSTALL_CONFLICT_KEY] === true) return false;
+  runtimeGlobal[RUNTIME_INSTALL_CONFLICT_KEY] = true;
+  return true;
+}
+
+export function sdkAttributionData(config: InitConfig): Record<string, unknown> {
+  const firstInstall = readRuntimeInstallClaim();
+  const snippetRevision = config.delivery?.revision;
+  return {
+    sdk_version: telemetryLabel(config.sdkVersion),
+    sdk_delivery_mode: telemetryLabel(config.sdkDeliveryMode),
+    sdk_delivery_source: telemetryLabel(config.sdkDeliverySource),
+    sdk_policy_revision: telemetryLabel(config.sdkPolicyRevision),
+    snippet_revision: typeof snippetRevision === "number" && Number.isFinite(snippetRevision)
+      ? Math.max(0, Math.floor(snippetRevision))
+      : undefined,
+    runtime_profile: telemetryLabel(config.runtimeProfile, "full"),
+    sdk_variant: telemetryLabel(config.runtimeFeatures?.sdkVariant, "live"),
+    install_surface: telemetryLabel(config.installSurface, "direct_script"),
+    first_install_surface: firstInstall?.installSurface ?? telemetryLabel(config.installSurface, "direct_script"),
+  };
+}
+
+export function sendRuntimeEventNow(
+  config: InitConfig,
+  type: string,
+  data: Record<string, unknown>,
+  userId?: string | null,
+): void {
+  if (trackingBlocked()) return;
+  if (state.screenshotMode) return;
+  const hydratedConfig = state.config && state.config.shopId === config.shopId ? state.config : config;
+  const endpoint = getEventsEndpoint(config);
+  if (!endpoint || !config.shopId) return;
+  try {
+    const tracker = new Tracker({
+      endpoint,
+      proxyEventDelivery: hydratedConfig.proxyEventDelivery,
+      assetFallback: hydratedConfig.assetFallback,
+      shopId: config.shopId,
+      ingestShopId: config.ingestShopId ?? config.shopId,
+      ingestSignature: config.ingestSignature,
+      visitorId: userId ?? undefined,
+      flushIntervalMs: 60_000,
+      maxBatchSize: 1,
+      qaMode: state.qaMode,
+      qaSessionId: state.qaSessionId,
+      cohort: state.config?.holdout_v1_enabled === true ? (state.holdout ? "holdout" : "active") : undefined,
+      holdoutConfigEpoch: holdoutConfigEpoch(state.config),
+      environment: config.environments?.activeKey || "production",
+    });
+    tracker.track({
+      type,
+      data: { ...sdkAttributionData(config), ...data },
+      url: cleanUrl(),
+    });
+    void tracker.flush().finally(() => tracker.stop());
+  } catch {
+    // best-effort runtime telemetry
+  }
+}
+
+export function sendRuntimePerfNow(
+  config: InitConfig,
+  data: Record<string, unknown>,
+  userId?: string | null,
+): void {
+  sendRuntimeEventNow(config, "sdk_perf", data, userId);
+}
+
+export function readDripPerf(): Record<string, unknown> {
+  return ((window as DripPerfWindow).__dripPerf ?? {}) as Record<string, unknown>;
+}
+
+export function markDripPerf(name: string): number {
+  const perfWindow = window as DripPerfWindow;
+  const perf = perfWindow.__dripPerf = perfWindow.__dripPerf ?? {};
+  const current = perf[name];
+  if (typeof current === "number" && Number.isFinite(current)) return current;
+  const now = Date.now();
+  perf[name] = now;
+  return now;
+}
+
+export function numberPerf(perf: Record<string, unknown>, name: string): number | undefined {
+  const value = perf[name];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function coexistencePerfFields(perf: Record<string, unknown>): Partial<PendingPerfEvent> {
+  return {
+    ...getCwvMetrics(),
+    hydration_detected_at: numberPerf(perf, "hydration_detected_at"),
+    apply_delayed_ms: numberPerf(perf, "apply_delayed_ms"),
+    hydration_timeout: perf.hydration_timeout === true,
+    hold_timeout: perf.hold_timeout === true,
+    reapply_count: numberPerf(perf, "reapply_count") ?? 0,
+    reassert_loop_detected: perf.reassert_loop_detected === true,
+    early_apply_at: numberPerf(perf, "early_apply_at"),
+    reasserts_count: numberPerf(perf, "reasserts_count") ?? 0,
+    revert_loops_detected: numberPerf(perf, "revert_loops_detected") ?? 0,
+  };
+}
+
+export function buildPerfEvent(config: InitConfig, timing: {
+  eventKind: "init" | "route_change";
+  assignmentReadyMs: number;
+  initTotalMs?: number;
+  phases?: Partial<Record<InitPhaseKey, number>>;
+  includesConfigFetch?: boolean;
+  predecisionMismatches?: number;
+  blankScreenMs: number;
+  assignmentReadyAt?: number;
+}): PendingPerfEvent {
+  const perf = readDripPerf();
+  const assignmentReadyAt = timing.assignmentReadyAt ?? Date.now();
+  const antiFlickerInsertedAt = numberPerf(perf, "anti_flicker_inserted_at");
+  const revealAt = numberPerf(perf, "reveal_at");
+  const phases = timing.phases ?? {};
+  const measuredPhaseMs = Object.values(phases).reduce((total, value) => total + (value ?? 0), 0);
+  const configFetchMs = timing.includesConfigFetch ? state.load.configFetchMs ?? 0 : 0;
+  const unattributedInitMs = timing.initTotalMs === undefined
+    ? undefined
+    : boundedPerfDuration(timing.initTotalMs - measuredPhaseMs - configFetchMs);
+  const mutationCount = state.assignments.reduce(
+    (total, assignment) => total + assignment.mutations.length,
+    0,
+  );
+  const attribution = sdkAttributionData(config);
+  const deliveryTiming = collectDeliveryTiming(numberPerf(readDripPerf(), "sdk_init_start"), SDK_SCRIPT_SRC);
+  return {
+    perf_event_kind: timing.eventKind,
+    assignment_ready_ms: timing.assignmentReadyMs,
+    init_total_ms: timing.initTotalMs,
+    guard_resolve_ms: phases.guard_resolve_ms,
+    consent_identity_ms: phases.consent_identity_ms,
+    runtime_setup_ms: phases.runtime_setup_ms,
+    targeting_assignment_ms: phases.targeting_assignment_ms,
+    mutation_finalize_ms: phases.mutation_finalize_ms,
+    predecision_mismatch_count: timing.predecisionMismatches ?? 0,
+    unattributed_init_ms: unattributedInitMs,
+    // domContentLoadedEventStart - navigationStart. This is page readiness,
+    // not the Apex anti-flicker hold (hidden_duration_ms is that metric).
+    dom_content_loaded_ms: timing.blankScreenMs,
+    blank_screen_ms: timing.blankScreenMs,
+    platform: state.platform,
+    config_source: state.configSource,
+    activation_mode: state.activationMode,
+    sdk_version: String(attribution.sdk_version),
+    sdk_delivery_mode: String(attribution.sdk_delivery_mode),
+    sdk_delivery_source: String(attribution.sdk_delivery_source),
+    sdk_policy_revision: String(attribution.sdk_policy_revision),
+    snippet_revision: typeof attribution.snippet_revision === "number" ? attribution.snippet_revision : undefined,
+    runtime_profile: String(attribution.runtime_profile),
+    sdk_variant: String(attribution.sdk_variant),
+    ...deliveryTiming,
+    experiment_count: config.experiments?.length ?? 0,
+    assignment_count: state.assignments.length,
+    mutation_count: mutationCount,
+    script_exec_start: numberPerf(perf, "script_exec_start"),
+    anti_flicker_inserted_at: antiFlickerInsertedAt,
+    assignment_ready_at: assignmentReadyAt,
+    first_mutation_at: numberPerf(perf, "first_mutation_at"),
+    reveal_at: revealAt,
+    hidden_duration_ms: antiFlickerInsertedAt && revealAt ? Math.max(0, revealAt - antiFlickerInsertedAt) : undefined,
+    current_page_hide_selector_count: numberPerf(perf, "current_page_hide_selector_count"),
+    delivery_state: typeof config.deliveryState === "string" ? config.deliveryState : undefined,
+    script_cache_source: typeof config.scriptCacheSource === "string" ? config.scriptCacheSource : undefined,
+    install_surface: String(attribution.install_surface),
+    first_install_surface: String(attribution.first_install_surface),
+    ...coexistencePerfFields(perf),
+  };
+}
+
+export function flushPendingPerf(): void {
+  if (!state.pendingPerf || !state.tracker) return;
+  const pendingPerf = state.pendingPerf;
+  state.pendingPerf = null;
+  const a = state.assignments.length > 0 ? state.assignments[0] : null;
+  const perf = readDripPerf();
+  const event: TrackEvent = {
+    type: "sdk_perf",
+    data: withAssignmentEpochData({
+      ...pendingPerf,
+      ...coexistencePerfFields(perf),
+    }, a?.experimentId, a?.variationId),
+    url: cleanUrl(),
+    experimentId: a?.experimentId,
+    variationId: a?.variationId,
+  };
+  state.tracker.track(event);
+  const completion = waitForCwvMetrics();
+  const experimentId = a?.experimentId;
+  const variationId = a?.variationId;
+  const url = cleanUrl();
+  void completion.then((metrics) => {
+    if (!metrics || state.screenshotMode || trackingBlocked() || !state.tracker) return;
+    state.tracker.track({
+      type: "sdk_cwv",
+      data: withAssignmentEpochData({
+        ...metrics,
+        cwv_finalized: true,
+      }, experimentId, variationId),
+      url,
+      experimentId,
+      variationId,
+    });
+  });
+}
+
+export function orderIdentityEndpoint(config: InitConfig): string | null {
+  if (!config.endpoint) return null;
+  return normalizeEndpoint(config.endpoint) + "/v1/order-identity";
+}
+
+export const ORDER_EXPOSURE_STORAGE_KEY = "drip_exposures";
+export const ORDER_EXPOSURE_MAX_ENTRIES = 50;
+export const ORDER_EXPOSURE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+export type StoredOrderExposure = {
+  e: string;
+  v: string;
+  t: number;
+};
+
+export function pruneStoredOrderExposures(exposures: StoredOrderExposure[], now = Date.now()): StoredOrderExposure[] {
+  return exposures
+    .filter((entry) =>
+      typeof entry.e === "string" &&
+      entry.e &&
+      typeof entry.v === "string" &&
+      entry.v &&
+      typeof entry.t === "number" &&
+      Number.isFinite(entry.t) &&
+      now - entry.t <= ORDER_EXPOSURE_TTL_MS,
+    )
+    .sort((a, b) => a.t - b.t)
+    .slice(-ORDER_EXPOSURE_MAX_ENTRIES);
+}
+
+export function readStoredOrderExposures(): StoredOrderExposure[] {
+  if (!persistentStorageAllowed()) return [];
+  try {
+    const raw = globalThis.localStorage?.getItem(ORDER_EXPOSURE_STORAGE_KEY);
+    const parsed = raw ? JSON.parse(raw) : [];
+    if (!Array.isArray(parsed)) return [];
+    return pruneStoredOrderExposures(parsed as StoredOrderExposure[]);
+  } catch {
+    return [];
+  }
+}
+
+export function writeStoredOrderExposures(exposures: StoredOrderExposure[]): void {
+  if (!persistentStorageAllowed()) return;
+  try {
+    globalThis.localStorage?.setItem(
+      ORDER_EXPOSURE_STORAGE_KEY,
+      JSON.stringify(pruneStoredOrderExposures(exposures)),
+    );
+  } catch {}
+}
+
+export function clearIdentityContextCookie(): void {
+  if (!globalThis.document) return;
+  try {
+    globalThis.document.cookie = `${IDENTITY_CONTEXT_COOKIE_NAME}=; Max-Age=0; Path=/; SameSite=Lax`;
+  } catch {}
+}
+
+export function recentIdentityContextExposures(): StoredOrderExposure[] {
+  const deduped = new Map<string, StoredOrderExposure>();
+  const exposures = readStoredOrderExposures();
+  for (let index = exposures.length - 1; index >= 0; index--) {
+    const exposure = exposures[index];
+    if (deduped.has(exposure.e)) continue;
+    deduped.set(exposure.e, exposure);
+    if (deduped.size >= 10) break;
+  }
+  return Array.from(deduped.values()).reverse();
+}
+
+export function buildIdentityContextCookieValue(
+  visitorId: string,
+  sessionId: string,
+  exposures: StoredOrderExposure[],
+): string | null {
+  let remaining = exposures.slice();
+  while (true) {
+    // Public contract for in-process commerce platforms (WooCommerce now,
+    // Magento later): URL-encoded `1|visitorId|sessionId|expId:varId,...`.
+    const raw = `1|${visitorId}|${sessionId}|${remaining.map((entry) => `${entry.e}:${entry.v}`).join(",")}`;
+    const encoded = encodeURIComponent(raw);
+    if (encoded.length <= IDENTITY_CONTEXT_COOKIE_MAX_ENCODED_BYTES) return encoded;
+    if (remaining.length === 0) return null;
+    remaining = remaining.slice(1);
+  }
+}
+
+export function generateSessionId(): string {
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+export function getIdentityContextSessionId(): string {
+  const trackerSessionId = state.tracker?.getSessionId();
+  if (trackerSessionId) return trackerSessionId;
+  try {
+    const existing = globalThis.sessionStorage?.getItem(SESSION_STORAGE_KEY);
+    if (existing) return existing;
+    const created = generateSessionId();
+    globalThis.sessionStorage?.setItem(SESSION_STORAGE_KEY, created);
+    return created;
+  } catch {
+    return generateSessionId();
+  }
+}
+
+export function writeIdentityContextCookie(): StoredOrderExposure[] {
+  if (trackingBlocked()) {
+    clearIdentityContextCookie();
+    return [];
+  }
+  if (!globalThis.document || !state.userId) return [];
+  const exposures = recentIdentityContextExposures();
+  try {
+    const encoded = buildIdentityContextCookieValue(
+      state.userId,
+      getIdentityContextSessionId(),
+      exposures,
+    );
+    if (!encoded) {
+      clearIdentityContextCookie();
+      return exposures;
+    }
+    globalThis.document.cookie =
+      `${IDENTITY_CONTEXT_COOKIE_NAME}=${encoded}; Path=/; SameSite=Lax; Max-Age=${IDENTITY_CONTEXT_COOKIE_MAX_AGE_SECONDS}`;
+  } catch {
+    clearIdentityContextCookie();
+  }
+  return exposures;
+}
+
+export function isOffTargetPersistedAssignment(assignment: Assignment): boolean {
+  return state.activationDiagnostics.experiments.find(
+    (diagnostic) => diagnostic.experimentId === assignment.experimentId,
+  )?.reason === "persisted_assignment_off_target";
+}
+
+export function restoreRecordedExposureDedup(exposures: StoredOrderExposure[]): void {
+  if (!exposures.length) return;
+  const recorded = new Set(exposures.map((entry) => `${entry.e}:${entry.v}`));
+  for (const assignment of state.assignments) {
+    if (
+      isOffTargetPersistedAssignment(assignment) &&
+      recorded.has(`${assignment.experimentId}:${assignment.variationId}`)
+    ) {
+      state.exposedAssignmentKeys.add(exposureAssignmentKey(assignment));
+    }
+  }
+}
+
+export function rememberOrderExposure(assignment: Assignment): void {
+  if (!persistentStorageAllowed()) return;
+  const now = Date.now();
+  const exposures = readStoredOrderExposures()
+    .filter((entry) => entry.e !== assignment.experimentId);
+  exposures.push({ e: assignment.experimentId, v: assignment.variationId, t: now });
+  writeStoredOrderExposures(exposures);
+  writeIdentityContextCookie();
+}
+
+export function mergedOrderIdentityAssignments(): Array<{ experimentId: string; variationId: string }> {
+  const merged = new Map<string, { experimentId: string; variationId: string }>();
+  for (const exposure of readStoredOrderExposures()) {
+    merged.set(exposure.e, { experimentId: exposure.e, variationId: exposure.v });
+  }
+  for (const assignment of state.assignments) {
+    merged.set(assignment.experimentId, {
+      experimentId: assignment.experimentId,
+      variationId: assignment.variationId,
+    });
+  }
+  return Array.from(merged.values()).slice(0, ORDER_EXPOSURE_MAX_ENTRIES);
+}
+
+export function cleanOrderIdentityText(value: unknown): string | null {
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 255) : null;
+}
+
+export function resolveOrderIdentityPlatform(): OrderIdentityPlatform {
+  if (state.platform === "shopify" || state.platform === "shopware") return state.platform;
+  const w = globalThis as Record<string, unknown>;
+  if (w.__apexShopware) return "shopware";
+  if (w.Shopify) return "shopify";
+  if (w.wc || w.woocommerce_params) return "woocommerce";
+  return "custom";
+}
+
+export function detectOrderIdentity(): {
+  platform: OrderIdentityPlatform;
+  platformOrderId: string | null;
+  orderNumber: string | null;
+} | null {
+  if (typeof window === "undefined" || typeof document === "undefined") return null;
+  const currentUrl = typeof location !== "undefined" ? location.href : "";
+  if (state.orderIdentityDetectionUrl === currentUrl && state.orderIdentityDetection !== undefined) {
+    return state.orderIdentityDetection;
+  }
+  const w = window as unknown as Record<string, unknown>;
+  const explicit: unknown[] = [
+    w.__apexOrderIdentity,
+    readPath(w, "__apexShopware.orderIdentity"),
+    readPath(w, "__apexShopware.order"),
+  ];
+  const dataLayer = Array.isArray(w.dataLayer) ? w.dataLayer : [];
+  for (const item of dataLayer) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const eventName = cleanOrderIdentityText((item as Record<string, unknown>).event);
+    if (eventName !== "purchase" && eventName !== "transaction" && eventName !== "checkout_completed") continue;
+    explicit.push(readPath(item, "ecommerce.purchase"));
+    explicit.push(readPath(item, "ecommerce"));
+    explicit.push(item);
+  }
+
+  let platformOrderId: string | null = null;
+  let orderNumber: string | null = null;
+  let platform = resolveOrderIdentityPlatform();
+  let strongSignal = false;
+  for (const source of explicit) {
+    if (!source || typeof source !== "object" || Array.isArray(source)) continue;
+    strongSignal = true;
+    const record = source as Record<string, unknown>;
+    platformOrderId ||= cleanOrderIdentityText(
+      record.platformOrderId ?? record.orderId ?? record.order_id ?? record.transaction_id,
+    );
+    orderNumber ||= cleanOrderIdentityText(
+      record.orderNumber ?? record.order_number ?? record.number ?? record.transaction_id,
+    );
+    const hintedPlatform = cleanOrderIdentityText(record.platform);
+    if (
+      hintedPlatform === "shopify" ||
+      hintedPlatform === "shopware" ||
+      hintedPlatform === "woocommerce" ||
+      hintedPlatform === "centra" ||
+      hintedPlatform === "custom"
+    ) {
+      platform = hintedPlatform;
+    }
+  }
+
+  if (!strongSignal) {
+    const orderIdEl = document.querySelector<HTMLElement>("[data-apex-order-id]");
+    const orderNumberEl = document.querySelector<HTMLElement>("[data-apex-order-number]");
+    const domOrderId = cleanOrderIdentityText(orderIdEl?.dataset.apexOrderId);
+    const domOrderNumber = cleanOrderIdentityText(orderNumberEl?.dataset.apexOrderNumber);
+    if (domOrderId || domOrderNumber) {
+      strongSignal = true;
+      platformOrderId ||= domOrderId;
+      orderNumber ||= domOrderNumber;
+    }
+  }
+
+  if (strongSignal) {
+    try {
+      const params = new URLSearchParams(location.search);
+      platformOrderId ||= cleanOrderIdentityText(
+        params.get("platformOrderId") ?? params.get("orderId") ?? params.get("order_id"),
+      );
+      orderNumber ||= cleanOrderIdentityText(
+        params.get("orderNumber") ?? params.get("order_number") ?? params.get("transaction_id"),
+      );
+    } catch {}
+  }
+
+  const result = strongSignal && (platformOrderId || orderNumber)
+    ? { platform, platformOrderId, orderNumber }
+    : null;
+  state.orderIdentityDetectionUrl = currentUrl;
+  state.orderIdentityDetection = result;
+  return result;
+}
+
+export function orderIdentityDedupeKey(identity: {
+  platform: string;
+  platformOrderId: string | null;
+  orderNumber: string | null;
+}, assignments: Array<{ experimentId: string; variationId: string }>): string {
+  return [
+    "drip:order_identity",
+    identity.platform,
+    identity.platformOrderId || "",
+    identity.orderNumber || "",
+    assignments.map((assignment) => `${assignment.experimentId}:${assignment.variationId}`).join(",") || "none",
+  ].join(":").slice(0, 240);
+}
+
+export function scheduleOrderIdentityBeacon(config: InitConfig): void {
+  if (state.screenshotMode || trackingBlocked()) return;
+  if (!state.tracker) return;
+  const endpoint = orderIdentityEndpoint(config);
+  if (!endpoint || !config.shopId || !config.ingestSignature) return;
+
+  window.setTimeout(() => {
+    const identity = detectOrderIdentity();
+    if (!identity) return;
+    const assignments = mergedOrderIdentityAssignments();
+    if (assignments.length === 0) return;
+    const key = orderIdentityDedupeKey(identity, assignments);
+    try {
+      if (sessionStorage.getItem(key) === "1") return;
+    } catch {}
+    if (state.orderIdentityInFlight.has(key)) return;
+    state.orderIdentityInFlight.add(key);
+
+    const markDelivered = () => {
+      try {
+        sessionStorage.setItem(key, "1");
+      } catch {}
+    };
+    const markComplete = () => {
+      state.orderIdentityInFlight.delete(key);
+    };
+
+    const payload = {
+      _shopId: config.ingestShopId ?? config.shopId,
+      _signature: config.ingestSignature,
+      platform: identity.platform,
+      environmentKey: config.environments?.activeKey || "production",
+      platformOrderId: identity.platformOrderId,
+      orderNumber: identity.orderNumber,
+      visitorId: state.userId ?? "",
+      sessionId: state.tracker?.getSessionId() ?? "",
+      assignments,
+      url: cleanUrl(),
+    };
+    const body = JSON.stringify(payload);
+    const sendOnPagehide = () => {
+      // A queued beacon has no application-level acknowledgement. Do not set
+      // the session marker: the server dedupes the stable order/event identity.
+      try {
+        if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+          navigator.sendBeacon(endpoint, new Blob([body], { type: "application/json" }));
+        }
+      } catch {}
+    };
+    window.addEventListener("pagehide", sendOnPagehide, { once: true });
+    void fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      keepalive: true,
+    })
+      .then((response) => {
+        if (response.status >= 200 && response.status < 300) {
+          markDelivered();
+          // Only a verified delivery retires the pagehide fallback; after a
+          // failed or rejected fetch it stays armed as the last-chance send
+          // when the shopper leaves the page (server idempotency absorbs
+          // any duplicate).
+          window.removeEventListener("pagehide", sendOnPagehide);
+        }
+      })
+      .catch(() => {})
+      .finally(markComplete);
+  }, 0);
+}
+
+export function deliveryStatus(expected: number, applied: number, missed: number, isControl: boolean): DeliveryHealthStatus {
+  if (expected === 0) return isControl ? "control" : "no_mutations";
+  if (applied >= expected && missed === 0) return "applied";
+  if (applied > 0) return "partial";
+  return "miss";
+}
+
+export function queueDeliveryHealthEvent(
+  assignment: Assignment,
+  data: {
+    expectedMutations: number;
+    appliedMutations: number;
+    selectorMisses: number;
+    applyGeneration: number;
+    activationMode: ActivationMode;
+  },
+): void {
+  if (state.screenshotMode) return;
+  const event: TrackEvent = {
+    type: "delivery_health",
+    data: {
+      expected_mutations: data.expectedMutations,
+      applied_mutations: data.appliedMutations,
+      selector_misses: data.selectorMisses,
+      apply_status: deliveryStatus(
+        data.expectedMutations,
+        data.appliedMutations,
+        data.selectorMisses,
+        assignment.isControl,
+      ),
+      assignment_index: assignment.index,
+      is_control: assignment.isControl,
+      entity_kind: assignment.kind ?? "experiment",
+      activation_mode: data.activationMode,
+      config_source: state.configSource,
+      platform: state.platform,
+      apply_generation: data.applyGeneration,
+      delivery_state: typeof state.config?.deliveryState === "string" ? state.config.deliveryState : undefined,
+      assignment_epoch:
+        !assignment.kind || assignment.kind === "experiment"
+          ? assignment.assignmentEpoch
+          : undefined,
+    },
+    url: cleanUrl(),
+    experimentId: assignment.experimentId,
+    variationId: assignment.variationId,
+  };
+  if (state.tracker && !trackingBlocked()) {
+    state.tracker.track(event);
+    return;
+  }
+  state.pendingDeliveryHealth.push(event);
+  if (state.pendingDeliveryHealth.length > 50) {
+    state.pendingDeliveryHealth.splice(0, state.pendingDeliveryHealth.length - 50);
+  }
+}
+
+export function flushPendingDeliveryHealth(): void {
+  if (!state.tracker || trackingBlocked() || state.pendingDeliveryHealth.length === 0) return;
+  const events = state.pendingDeliveryHealth.splice(0);
+  for (const event of events) {
+    state.tracker.track(event);
+  }
+}
+
+export function startAnalyticsStage(
+  config: InitConfig,
+  experiments: Experiment[],
+  initialExposureAssignments?: Assignment[],
+  targetingPass = activeTargetingEvaluationPass,
+): void {
+  if (state.analyticsStarted) return;
+  if (state.pendingInitialApply) {
+    // Exposure (experiment_viewed) and goal wiring must not precede the
+    // gated initial apply (after_hydration / pre-init hold) — consent and
+    // route paths can reach this before the gate opens. Re-enter after;
+    // the analyticsStarted flag keeps queued re-entries idempotent, and a
+    // config replaced while queued (cached init superseded by the network
+    // fetch) must not start analytics with the stale experiment list.
+    void state.pendingInitialApply.then(() => {
+      if (state.config !== config) return;
+      startAnalyticsStage(
+        config,
+        experiments,
+        initialExposureAssignments,
+        targetingPass,
+      );
+    });
+    return;
+  }
+  if (state.screenshotMode) return;
+  if (trackingBlocked()) return;
+  if (!state.trackingPrerequisiteMet) return;
+
+  const emptyProjectFastPath = config.runtimeProfile === "empty_project"
+    && state.perfFlags.perf_empty_project_v1;
+  ensureTrackerStarted(config);
+  drainPendingDataLayerEvents();
+  if (!emptyProjectFastPath) syncActiveAssignmentToShopifyCart();
+  flushPendingPerf();
+  flushPendingDeliveryHealth();
+  const storedOrderExposures = writeIdentityContextCookie();
+  if (!emptyProjectFastPath) {
+    const previousTargetingPass = activeTargetingEvaluationPass;
+    activeTargetingEvaluationPass = targetingPass;
+    try {
+      restoreRecordedExposureDedup(storedOrderExposures);
+      trackViewedAssignments(config, initialExposureAssignments, targetingPass);
+      setupGoalTracking(experiments);
+      setupHeatmapTracking(state.assignments, experiments);
+      setupReplayTracking(state.assignments, experiments);
+      setupSemanticTracking(config);
+    } finally {
+      activeTargetingEvaluationPass = previousTargetingPass;
+    }
+  }
+  scheduleOrderIdentityBeacon(config);
+  state.analyticsStarted = true;
+  if (!emptyProjectFastPath) updateProjectActivationDiagnostics(config);
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("track", "Analytics stage started", { assignments: state.assignments.length });
+  onPageEnter(analyticsTrack);
+  if (state.consentRequired && !emptyProjectFastPath) {
+    scheduleShopifyAssignmentSync();
+  }
+}
+
+export function scheduleAnalyticsStart(
+  config: InitConfig,
+  experiments: Experiment[],
+  targetingPass?: TargetingEvaluationPass,
+): void {
+  clearScheduledAnalyticsStart();
+  const run = () => {
+    clearScheduledAnalyticsStart();
+    startAnalyticsStage(config, experiments, undefined, targetingPass);
+  };
+
+  const idleTimeout = state.trackingIdleTimeoutMs;
+
+  state.analyticsTimeoutId = window.setTimeout(run, idleTimeout);
+
+  const w = globalThis as Record<string, unknown>;
+  const requestIdle = w.requestIdleCallback;
+  if (typeof requestIdle === "function") {
+    state.analyticsIdleId = (requestIdle as (
+      cb: () => void,
+      opts?: { timeout?: number },
+    ) => number)(run, { timeout: idleTimeout });
+  }
+}
+
+export function startAnalyticsIfReady(): void {
+  if (state.tracker || !state.config) return;
+  if (trackingBlocked()) return;
+  if (!state.trackingPrerequisiteMet) return;
+
+  const experiments = state.config.experiments ?? [];
+  startAnalyticsStage(state.config, experiments);
+}
+
+export function getConfigCacheKey(shopId: string, environmentKey?: string): string {
+  const env = environmentKey || "production";
+  return CONFIG_CACHE_KEY_PREFIX + shopId + ":" + env;
+}
+
+export function storageAvailable(kind: "localStorage" | "sessionStorage"): boolean {
+  try {
+    const storage = globalThis[kind];
+    if (!storage) return false;
+    const key = "__drip_storage_probe__";
+    storage.setItem(key, "1");
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getConfigCacheTtlMs(config: InitConfig): number {
+  const ttl = config.configCacheTtlMs;
+  if (typeof ttl === "number" && Number.isFinite(ttl) && ttl > 0) return ttl;
+  return DEFAULT_CONFIG_CACHE_TTL_MS;
+}
+
+export function configuredStoreOrigins(
+  config: Pick<InitConfig, "storeOrigin" | "storeOrigins">,
+): string | string[] | undefined {
+  return config.storeOrigins?.length ? config.storeOrigins : config.storeOrigin;
+}
+
+export function readCachedExperiments(
+  shopId: string,
+  ttlMs: number,
+  environmentKey?: string,
+): { experiments: Experiment[]; storeOrigin?: string; storeOrigins?: string[]; exclusionGroups?: ExclusionGroupConfig[]; profile?: InitConfig["profile"]; runtime?: unknown; signals?: RuntimeSignalDefinition[]; commerce?: InitConfig["commerce"]; geo?: { country?: string }; holdout?: [enabled?: boolean, pct?: number, configUpdatedAt?: string | null]; hash: string } | null {
+  try {
+    const raw = localStorage.getItem(getConfigCacheKey(shopId, environmentKey));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as {
+      fetchedAt?: number;
+      hash?: string;
+      experiments?: Experiment[];
+      storeOrigin?: string;
+      storeOrigins?: string[];
+      exclusionGroups?: ExclusionGroupConfig[];
+      profile?: InitConfig["profile"];
+      runtime?: unknown;
+      signals?: RuntimeSignalDefinition[];
+      commerce?: InitConfig["commerce"];
+      geo?: { country?: unknown };
+      holdout?: [enabled?: boolean, pct?: number, configUpdatedAt?: string | null];
+    };
+    if (!parsed || typeof parsed.fetchedAt !== "number" || !Array.isArray(parsed.experiments)) {
+      return null;
+    }
+    if (Date.now() - parsed.fetchedAt > ttlMs) return null;
+    return {
+      experiments: parsed.experiments,
+      storeOrigin:
+        typeof parsed.storeOrigin === "string"
+          ? parsed.storeOrigin
+          : undefined,
+      storeOrigins: Array.isArray(parsed.storeOrigins)
+        ? parsed.storeOrigins.filter(
+            (origin): origin is string => typeof origin === "string",
+          )
+        : undefined,
+      exclusionGroups: Array.isArray(parsed.exclusionGroups)
+        ? parsed.exclusionGroups
+        : undefined,
+      profile: parsed.profile,
+      runtime: parsed.runtime,
+      signals: Array.isArray(parsed.signals) ? parsed.signals : undefined,
+      commerce: parsed.commerce,
+      geo: typeof parsed.geo?.country === "string"
+        ? { country: parsed.geo.country }
+        : undefined,
+      holdout: parsed.holdout,
+      hash: typeof parsed.hash === "string" ? parsed.hash : "",
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function hashConfigPayload(
+  experiments: Experiment[],
+  storeOrigin?: string,
+  storeOrigins?: string[],
+  exclusionGroups?: ExclusionGroupConfig[],
+  profile?: InitConfig["profile"],
+  runtime?: unknown,
+  signals?: RuntimeSignalDefinition[],
+  commerce?: InitConfig["commerce"],
+  holdout_v1_enabled?: boolean,
+  holdout_pct?: number,
+  holdout_config_updated_at?: string | null,
+): string {
+  try {
+    return JSON.stringify({
+      experiments,
+      ...(storeOrigin ? { storeOrigin } : {}),
+      ...(storeOrigins?.length ? { storeOrigins } : {}),
+      exclusionGroups: exclusionGroups ?? [],
+      profile: profile ?? null,
+      runtime: runtime ?? null,
+      signals: signals ?? [],
+      commerce: commerce ?? null,
+      holdout: [
+        holdout_v1_enabled ?? false,
+        holdout_pct ?? 0,
+        holdout_config_updated_at ?? null,
+      ],
+    });
+  } catch {
+    return "";
+  }
+}
+
+export function writeCachedExperiments(
+  shopId: string,
+  experiments: Experiment[],
+  storeOrigin?: string,
+  storeOrigins?: string[],
+  exclusionGroups?: ExclusionGroupConfig[],
+  profile?: InitConfig["profile"],
+  runtime?: unknown,
+  signals?: RuntimeSignalDefinition[],
+  commerce?: InitConfig["commerce"],
+  holdout_v1_enabled?: boolean,
+  holdout_pct?: number,
+  holdout_config_updated_at?: string | null,
+  geo?: { country?: string },
+  environmentKey?: string,
+): void {
+  try {
+    const payload = {
+      fetchedAt: Date.now(),
+      hash: hashConfigPayload(
+        experiments,
+        storeOrigin,
+        storeOrigins,
+        exclusionGroups,
+        profile,
+        runtime,
+        signals,
+        commerce,
+        holdout_v1_enabled,
+        holdout_pct,
+        holdout_config_updated_at,
+      ),
+      experiments,
+      storeOrigin,
+      storeOrigins,
+      exclusionGroups,
+      profile,
+      runtime,
+      signals,
+      commerce,
+      geo,
+      holdout: [
+        holdout_v1_enabled,
+        holdout_pct,
+        holdout_config_updated_at,
+      ],
+    };
+    localStorage.setItem(getConfigCacheKey(shopId, environmentKey), JSON.stringify(payload));
+  } catch {
+    // no-op on storage failures
+  }
+}
+
+export function withRuntimeSettings(
+  config: InitConfig,
+  runtime: unknown,
+  profile?: InitConfig["profile"],
+): InitConfig {
+  if (!runtime || typeof runtime !== "object") {
+    return profile ? { ...config, profile } : config;
+  }
+  const r = runtime as Record<string, any>;
+  const antiFlicker = r.antiFlicker && typeof r.antiFlicker === "object" ? r.antiFlicker : {};
+  const snippet = r.snippet && typeof r.snippet === "object" ? r.snippet : {};
+  const prerequisites = r.prerequisites && typeof r.prerequisites === "object" ? r.prerequisites : {};
+  const debug = r.debug && typeof r.debug === "object" ? r.debug : undefined;
+  const pageTrigger = r.pageTrigger && typeof r.pageTrigger === "object" ? r.pageTrigger : undefined;
+  const consentMode = r.consentMode && typeof r.consentMode === "object" ? r.consentMode : undefined;
+  const spa = r.spa && typeof r.spa === "object" ? r.spa : undefined;
+  const externalTracking = r.externalTracking && typeof r.externalTracking === "object" ? r.externalTracking : undefined;
+  const dataLayerTriggers = Array.isArray(r.dataLayerTriggers) ? r.dataLayerTriggers : undefined;
+  const exposureDestinations = r.exposureDestinations && typeof r.exposureDestinations === "object" ? r.exposureDestinations : undefined;
+  const projectCode = r.projectCode && typeof r.projectCode === "object" ? r.projectCode : undefined;
+  const environments = r.environments && typeof r.environments === "object" ? r.environments : undefined;
+  const bucketingCleanup = r.bucketingCleanup && typeof r.bucketingCleanup === "object" ? r.bucketingCleanup : undefined;
+  const dataProtection = r.dataProtection && typeof r.dataProtection === "object" ? r.dataProtection : undefined;
+  const semanticTracking = r.semanticTracking && typeof r.semanticTracking === "object" ? r.semanticTracking : undefined;
+  const runtimeControl = r.runtimeControl && typeof r.runtimeControl === "object" ? r.runtimeControl : undefined;
+  const commerce = r.commerce && typeof r.commerce === "object" ? r.commerce : undefined;
+
+  return {
+    ...config,
+    profile: profile ?? config.profile,
+    antiFlickerMode: antiFlicker.mode ?? config.antiFlickerMode,
+    antiFlickerTimeoutMs: antiFlicker.timeoutMs ?? config.antiFlickerTimeoutMs,
+    antiFlickerCustomCss: antiFlicker.customCss ?? config.antiFlickerCustomCss,
+    configCacheTtlMs: snippet.configCacheTtlMs ?? config.configCacheTtlMs,
+    projectPrerequisites: {
+      ...config.projectPrerequisites,
+      showVariationsRule: prerequisites.showVariationsRule ?? config.projectPrerequisites?.showVariationsRule,
+      startTrackingRule: prerequisites.startTrackingRule ?? config.projectPrerequisites?.startTrackingRule,
+    },
+    consentMode: consentMode ? { ...config.consentMode, ...consentMode } : config.consentMode,
+    debug: debug ? { ...config.debug, ...debug } : config.debug,
+    pageTrigger: pageTrigger ? { ...config.pageTrigger, ...pageTrigger } : config.pageTrigger,
+    spa: spa ? { ...config.spa, ...spa } : config.spa,
+    externalTracking: externalTracking ? { ...config.externalTracking, ...externalTracking } : config.externalTracking,
+    dataLayerTriggers: dataLayerTriggers ?? config.dataLayerTriggers,
+    exposureDestinations: exposureDestinations ? { ...config.exposureDestinations, ...exposureDestinations } : config.exposureDestinations,
+    projectCode: projectCode ? { ...config.projectCode, ...projectCode } : config.projectCode,
+    environments: environments ? { ...config.environments, ...environments } : config.environments,
+    bucketingCleanup: bucketingCleanup ? { ...config.bucketingCleanup, ...bucketingCleanup } : config.bucketingCleanup,
+    dataProtection: dataProtection ? { ...config.dataProtection, ...dataProtection } : config.dataProtection,
+    semanticTracking: semanticTracking ? { ...config.semanticTracking, ...semanticTracking } : config.semanticTracking,
+    runtimeControl: runtimeControl ? { ...config.runtimeControl, ...runtimeControl } : config.runtimeControl,
+    assignmentCookieSync: typeof r.assignmentCookieSync === "boolean"
+      ? r.assignmentCookieSync
+      : config.assignmentCookieSync,
+    aggregateMode: (r.aggregateMode as InitConfig["aggregateMode"]) ?? config.aggregateMode,
+    proxyEventDelivery: r.proxyEventDelivery?.enabled === true
+      ? { enabled: true }
+      : config.proxyEventDelivery,
+    cartAttributeWrite: commerce?.cartAttributeWrite === "external"
+      ? "external"
+      : commerce?.cartAttributeWrite === "sdk"
+        ? "sdk"
+        : commerce?.cartAttributeWrite == null && config.cartAttributeWrite === "external"
+          ? "external"
+          : "sdk",
+    cartAttributeScope: commerce?.cartAttributeScope === "all"
+      ? "all"
+      : commerce?.cartAttributeScope === "consented"
+        ? "consented"
+        : commerce?.cartAttributeScope == null && config.cartAttributeScope === "all"
+          ? "all"
+          : "consented",
+  };
+}
+
+export function serializeForceMap(forceMap: Record<string, string> | null): string {
+  if (!forceMap) return "";
+  return Object.entries(forceMap)
+    .map(([experimentId, variationId]) => `${experimentId}:${variationId}`)
+    .join(",");
+}
+
+export function getHashId(exp: Experiment, userId: string, attrs: Record<string, unknown>): string {
+  if (exp.hashAttribute && attrs[exp.hashAttribute] != null) {
+    return String(attrs[exp.hashAttribute]);
+  }
+  return userId;
+}
+