@drip-apex/sdk 0.1.0 → 0.3.0

package/src/config-runtime.ts

@@ -0,0 +1,2071 @@
+declare const __DRIP_FEATURE_QA__: boolean;
+declare const __DRIP_FEATURE_DEVTOOLS__: boolean;
+declare const __DRIP_FEATURE_AUDIT__: boolean;
+declare const __DRIP_FEATURE_HEATMAP__: boolean;
+declare const __DRIP_FEATURE_REPLAY__: boolean;
+declare const __DRIP_FEATURE_HARNESS__: boolean;
+const FEATURE_QA = __DRIP_FEATURE_QA__;
+const FEATURE_DEVTOOLS = __DRIP_FEATURE_DEVTOOLS__;
+const FEATURE_AUDIT = __DRIP_FEATURE_AUDIT__;
+const FEATURE_HEATMAP = __DRIP_FEATURE_HEATMAP__;
+const FEATURE_REPLAY = __DRIP_FEATURE_REPLAY__;
+const FEATURE_HARNESS = __DRIP_FEATURE_HARNESS__;
+import { cleanUrl, onPageEnter, onPageExit } from "./analytics";
+import { normalizeEndpoint } from "./endpoint";
+import { EVENT_TYPE_PATTERN, normalizeEventName } from "@drip/event-schema/event-name";
+import { isExperimentServable } from "@drip/event-schema/experiment-servability";
+import {
+  applyAntiFlicker,
+  bootedTooLateForAntiFlicker,
+  removeAntiFlicker,
+} from "./antiflicker";
+import {
+  clearPersistedAssignments,
+  findPersistedVariation,
+  persistAssignmentForExperiment,
+  prunePersistedAssignments,
+  removePersistedAssignmentsForExperiments,
+  __assignmentStoreInternals,
+} from "./assignment-store";
+import {
+  clearAssignmentSyncCookie,
+} from "./assignment-cookie-sync";
+import { cleanupBucketingStorage } from "./bucketing-cleanup";
+import { chooseVariation, inTrafficAllocation } from "./bucket";
+import { buildAssignment, decideAssignments } from "./decide-assignments";
+import { weekdayScheduleBlocksDelivery } from "./weekday-schedule";
+import { CONSENT_REQUIRED, DNT_BLOCKED, evaluateSynchronousConsent, readConfiguredConsent, readPath, resolveSynchronousConsentGranted } from "./consent-evaluation";
+import { clearEarlyInteractions, drainBootstrapEarlyInteractions, drainEarlyInteractions } from "./early-interaction-capture";
+import { getCwvMetrics, markCwvReveal, startCwvMeasurement, waitForCwvMetrics } from "./cwv";
+import { collectDeliveryTiming } from "./delivery-timing";
+import {
+  startStorefrontVitals,
+  stopStorefrontVitals,
+  type StorefrontVitalsContext,
+} from "./storefront-vitals";
+import {
+  browserGroupStickyStore,
+  clearBrowserGroupStickyStore,
+  resolveExclusionGroups,
+  type ExclusionGroupDecision,
+  type PersistedGroupSelection,
+} from "./exclusion-groups";
+import type { CompactGroupSelections } from "./persistence-decoders";
+import {
+  applyCommercePrice,
+  isCommercePriceWorkPending,
+  cleanupCommercePrice,
+  hasCommercePriceState,
+  COMMERCE_PRICE_SELECTORS,
+  isCommercePriceActive,
+  isCommercePriceExposureEligible,
+  notifyCommerceCartStampConfirmed,
+  setCommercePriceExposureListener,
+} from "./commerce-price";
+import {
+  applyCommerceShipping,
+  classifyShippingExposure,
+  cleanupCommerceShipping,
+  isShippingCartEligible,
+  isShippingCartEligibilityConfirmed,
+} from "./commerce-shipping";
+import {
+  addCssOwners,
+  injectCss,
+  injectExperimentCss,
+  injectExternalCss,
+  removeCssForOwner,
+} from "./css";
+import { configureDebug, debugLog, debugWarn, debugGroup, debugGroupEnd, isDebugEnabled } from "./debug";
+import { loadDebugBuild } from "./debug-loader";
+import { observeDomChanges } from "./dom-trigger";
+import { edgeRuntimeActive, readEdgeRuntimeAssignments } from "./edge-runtime";
+import { normalizeDataLayerEntry } from "./data-layer-normalize";
+import { interceptEditorLaunch, isEditorDevicePreview } from "./editor-bootstrap";
+import { cleanupGoals, goalWiringKeys, setupGoals, triggerGoal, triggerGoalsForEvent } from "./goals";
+import { clearQaForceFromUrl, isBot, isDuplicate, isIframe, isOptedOut, isQaMode, isScreenshotMode, parseForceParam, persistQaForce, persistUrlQaForce, exitQaMode, getQaSessionId } from "./guards";
+import { adoptUserId, applyHoldoutGate, configureIdentityStorage, getEphemeralUserId, getPersistedUserId, 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 { scheduleDeferredRouteReevaluation, installDataLayerTriggers, experimentsUseSurfaceSignals, rememberExposureDestination, clarityUpgradeSent, clarityTagKey, pushExposureToQueue, emitExposureDestinations, ensureTrackerStarted, exposureAssignmentKey, priceAssignmentAuthorizationKey, isPriceDisplayAssignmentAuthorized, isShippingDisplayAssignmentAuthorized, isOffersDisplayAssignmentAuthorized, giftSyncOptions, assignmentHasRenderableArtifacts, authorizeOffersDisplayAndRender, revokeOffersDisplayAuthorization, exposureEligibleAssignments, isShippingExposureCartEligible, trackViewedAssignmentsAfterShippingEligibility, EMPTY_TARGETING_ATTRIBUTES, TargetingEvaluationPass, activeTargetingEvaluationPass, createTargetingEvaluationPass, targetingAttributesForPass, trackViewedAssignments, sameStringSet, setupGoalTracking, setupHeatmapTracking, cleanupHeatmapTracking, setupReplayTracking, cleanupReplayTracking, setupSemanticTracking, cleanupSemanticTracking, buildExperimentBehaviorEvents, buildPageExitEvents, analyticsTrack, syncLoadDiagnosticsToPerf, updateLoadDiagnostics, resetLoadDiagnostics, queuePerfEvent, RuntimeInstallClaim, RUNTIME_INSTALL_CLAIM_KEY, RUNTIME_INSTALL_CONFLICT_KEY, telemetryLabel, readRuntimeInstallClaim, rememberRuntimeInstallClaim, claimInstallConflictEmission, sdkAttributionData, sendRuntimeEventNow, sendRuntimePerfNow, readDripPerf, markDripPerf, numberPerf, coexistencePerfFields, buildPerfEvent, flushPendingPerf, orderIdentityEndpoint, ORDER_EXPOSURE_STORAGE_KEY, ORDER_EXPOSURE_MAX_ENTRIES, ORDER_EXPOSURE_TTL_MS, StoredOrderExposure, pruneStoredOrderExposures, readStoredOrderExposures, writeStoredOrderExposures, clearIdentityContextCookie, recentIdentityContextExposures, buildIdentityContextCookieValue, generateSessionId, getIdentityContextSessionId, writeIdentityContextCookie, isOffTargetPersistedAssignment, restoreRecordedExposureDedup, rememberOrderExposure, mergedOrderIdentityAssignments, cleanOrderIdentityText, resolveOrderIdentityPlatform, detectOrderIdentity, orderIdentityDedupeKey, scheduleOrderIdentityBeacon, deliveryStatus, queueDeliveryHealthEvent, flushPendingDeliveryHealth, startAnalyticsStage, scheduleAnalyticsStart, startAnalyticsIfReady, getConfigCacheKey, storageAvailable, getConfigCacheTtlMs, configuredStoreOrigins, readCachedExperiments, hashConfigPayload, writeCachedExperiments, withRuntimeSettings, serializeForceMap, getHashId } from "./analytics-runtime";
+import { 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 applyRuntimeAntiFlicker(
+  mode: AntiFlickerMode,
+  timeoutMs: number,
+  scopedSelectors?: string[],
+  customCss?: string,
+): boolean {
+  const bootedTooLate = runtimeSharedState.runtimeBootedTooLateForAntiFlicker ?? false;
+  const armed = applyAntiFlicker(mode, timeoutMs, scopedSelectors, customCss, bootedTooLate);
+  if (bootedTooLate && mode !== "off") {
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog(
+      "init",
+      "Anti-flicker skipped because the runtime loaded after the pre-paint window",
+    );
+  }
+  return armed;
+}
+
+export const SDK_SCRIPT_SRC =
+  typeof document !== "undefined"
+    ? (document.currentScript as HTMLScriptElement | null)?.src
+    : undefined;
+
+export type HeatmapController = {
+  stop: () => void;
+  update: (assignments: Assignment[], experiments: Experiment[]) => void;
+};
+
+export type SemanticController = {
+  stop: () => void;
+};
+
+export type FetchAttemptInfo = {
+  attempt: number;
+  elapsedMs: number;
+  error?: string;
+  status?: number;
+  timedOut?: boolean;
+};
+
+export type FetchRetryOptions = {
+  timeoutMs?: number;
+  firstAttemptTimeoutMs?: number;
+  slowMs?: number;
+  onAttemptStart?: (attempt: number) => void;
+  onAttemptEnd?: (info: FetchAttemptInfo) => void;
+  onSlow?: (info: { attempt: number; elapsedMs: number }) => void;
+};
+
+export const DEFAULT_CONFIG_FETCH_TIMEOUT_MS = 4500;
+export const DEFAULT_CONFIG_FETCH_SLOW_MS = 1500;
+export const CONFIG_FETCH_RETRY_COUNT = 2;
+export const CONFIG_FETCH_RETRY_DELAY_MS = 500;
+export const CONFIG_FETCH_MAX_WAIT_MS =
+  DEFAULT_CONFIG_FETCH_TIMEOUT_MS * (CONFIG_FETCH_RETRY_COUNT + 1)
+  + CONFIG_FETCH_RETRY_DELAY_MS
+    * (CONFIG_FETCH_RETRY_COUNT * (CONFIG_FETCH_RETRY_COUNT + 1) / 2);
+export // Keep the fail-open guard through the last abort/catch microtask. Without
+// this small settle allowance, the hard reveal timer can run before the final
+// fetch timeout confirms the cached redirect.
+const CACHED_REDIRECT_HIDE_TIMEOUT_MS = CONFIG_FETCH_MAX_WAIT_MS + 100;
+
+export function createFetchTimeoutError(): Error | DOMException {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("The operation was aborted.", "AbortError");
+  }
+  const error = new Error("The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+
+export function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  if (typeof AbortController === "undefined") {
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    return Promise.race([
+      fetch(url),
+      new Promise<Response>((_, reject) => {
+        timer = setTimeout(() => reject(createFetchTimeoutError()), timeoutMs);
+      }),
+    ]).finally(() => {
+      if (timer !== null) clearTimeout(timer);
+    });
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return fetch(url, { signal: controller.signal }).finally(() => {
+    clearTimeout(timer);
+  });
+}
+
+export async function fetchWithRetry(
+  url: string,
+  retries = 2,
+  delayMs = 500,
+  options: FetchRetryOptions = {},
+): Promise<Response> {
+  const timeoutMs = normalizeNumber(options.timeoutMs, DEFAULT_CONFIG_FETCH_TIMEOUT_MS);
+  const firstAttemptTimeoutMs = normalizeNumber(options.firstAttemptTimeoutMs, timeoutMs);
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const startedAt = Date.now();
+    let slowTimer: ReturnType<typeof setTimeout> | null = null;
+    let slowMarked = false;
+    options.onAttemptStart?.(attempt + 1);
+    if (options.onSlow) {
+      const slowMs = normalizeNumber(options.slowMs, DEFAULT_CONFIG_FETCH_SLOW_MS);
+      slowTimer = setTimeout(() => {
+        slowMarked = true;
+        options.onSlow?.({ attempt: attempt + 1, elapsedMs: Date.now() - startedAt });
+      }, slowMs);
+    }
+    try {
+      const attemptTimeoutMs = attempt === 0 ? firstAttemptTimeoutMs : timeoutMs;
+      const res = await fetchWithTimeout(url, attemptTimeoutMs);
+      if (slowTimer !== null) clearTimeout(slowTimer);
+      options.onAttemptEnd?.({
+        attempt: attempt + 1,
+        elapsedMs: Date.now() - startedAt,
+        status: res.status,
+      });
+      if (res.ok || attempt === retries) return res;
+    } catch (err) {
+      if (slowTimer !== null) clearTimeout(slowTimer);
+      const error = err instanceof Error ? err.message : String(err);
+      const timedOut = typeof DOMException !== "undefined" && err instanceof DOMException
+        ? err.name === "AbortError"
+        : /abort|timeout/i.test(error);
+      options.onAttemptEnd?.({
+        attempt: attempt + 1,
+        elapsedMs: Date.now() - startedAt,
+        error,
+        timedOut,
+      });
+      if (attempt === retries) throw err;
+    }
+    if (slowTimer !== null && !slowMarked) clearTimeout(slowTimer);
+    await new Promise((r) => setTimeout(r, delayMs * (attempt + 1)));
+  }
+  throw new Error("Failed to fetch after retries");
+}
+
+export const CONFIG_CACHE_KEY_PREFIX = "drip_cfg:";
+export const DEFAULT_CONFIG_CACHE_TTL_MS = 5 * 60 * 1000;
+export const DEFAULT_ANTI_FLICKER_TIMEOUT_MS = 1200;
+export const DEFAULT_TRACKING_IDLE_TIMEOUT_MS = 2000;
+export const DEFAULT_EXECUTION_MODE: ExecutionMode = "auto";
+export const DEFAULT_TRACKING_START: TrackingStart = "idle";
+export const DEFAULT_JS_POLICY: CustomJsPolicy = "hybrid";
+export const PAGE_RULE_POLL_WINDOW_MS = 2_000;
+export const PAGE_RULE_POLL_INTERVAL_MS = 50;
+export const CONSENT_COOKIE_NAME = "drip_consent";
+export const IDENTITY_CONTEXT_COOKIE_NAME = "drip_ctx";
+export const IDENTITY_CONTEXT_COOKIE_MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
+export const IDENTITY_CONTEXT_COOKIE_MAX_ENCODED_BYTES = 1024;
+export const SESSION_STORAGE_KEY = "drip_sid";
+
+export /** Collect unique CSS selectors from experiments for scoped anti-flicker. */
+function collectScopedSelectors(experiments: Experiment[], config?: InitConfig, assignments: Assignment[] = []): string[] {
+  const selectors = new Set<string>();
+  const pageInactiveExperimentIds = new Set(
+    assignments
+      .filter(isAssignmentArtifactInactive)
+      .map((assignment) => assignment.experimentId),
+  );
+  for (const exp of experiments) {
+    if (!isExperimentServable(exp, { qaMode: false, environment: config?.environments?.activeKey || "production" })) continue;
+    if (
+      !state.forceMap?.[exp.id] &&
+      weekdayScheduleBlocksDelivery(exp.weekdaySchedule, new Date())
+    ) continue;
+    // Redirect treatment artifacts are authored for the source page. The
+    // destination document is itself the treatment, so its preserved
+    // assignment must not hide source-only selectors before attribution
+    // startup.
+    if (pageInactiveExperimentIds.has(exp.id)) continue;
+    for (const v of exp.variations) {
+      v.antiFlickerSelectors?.forEach((selector) => selectors.add(selector));
+      for (const m of v.mutations) {
+        if (m.selector) selectors.add(m.selector);
+      }
+      for (const block of v.urlBlocks ?? []) {
+        for (const m of block.mutations) {
+          if (m.selector) selectors.add(m.selector);
+        }
+      }
+    }
+  }
+  if (isCommercePriceActive(config?.commerce?.price, assignments)) {
+    COMMERCE_PRICE_SELECTORS.forEach((selector) => selectors.add(selector));
+  }
+  return Array.from(selectors);
+}
+
+export type ResolvedRuntimeConfig = {
+  executionMode: ExecutionMode;
+  antiFlickerMode: AntiFlickerMode;
+  antiFlickerTimeoutMs: number;
+  antiFlickerCustomCss?: string;
+  trackingStart: TrackingStart;
+  trackingIdleTimeoutMs: number;
+  customJsPolicy: CustomJsPolicy;
+  proxyEventDelivery?: { enabled: boolean; path?: string };
+  assetFallback?: boolean;
+};
+
+export type UrlDiffNeeds = {
+  path: boolean;
+  search: boolean;
+  hash: boolean;
+};
+
+export type ConfigSource = "inline" | "cache" | "network" | "none";
+
+export type PendingPerfEvent = {
+  perf_event_kind: "init" | "route_change";
+  assignment_ready_ms: number;
+  init_total_ms?: number;
+  guard_resolve_ms?: number;
+  consent_identity_ms?: number;
+  runtime_setup_ms?: number;
+  targeting_assignment_ms?: number;
+  mutation_finalize_ms?: number;
+  predecision_mismatch_count?: number;
+  unattributed_init_ms?: number;
+  dom_content_loaded_ms: number;
+  /** @deprecated One-release alias for dom_content_loaded_ms. */
+  blank_screen_ms: number;
+  platform: PlatformHint;
+  config_source: ConfigSource;
+  activation_mode: ActivationMode;
+  sdk_version: string;
+  sdk_delivery_mode: string;
+  sdk_delivery_source: string;
+  sdk_policy_revision: string;
+  snippet_revision?: number;
+  runtime_profile: string;
+  sdk_variant: string;
+  snippet_fetch_ms: number;
+  snippet_transfer_size: number;
+  sdk_bundle_fetch_ms: number;
+  sdk_bundle_transfer_size: number;
+  time_to_sdk_ready_ms?: number;
+  experiment_count?: number;
+  assignment_count?: number;
+  mutation_count?: number;
+  script_exec_start?: number;
+  anti_flicker_inserted_at?: number;
+  assignment_ready_at?: number;
+  first_mutation_at?: number;
+  reveal_at?: number;
+  hidden_duration_ms?: number;
+  current_page_hide_selector_count?: number;
+  delivery_state?: string;
+  script_cache_source?: string;
+  install_surface?: string;
+  first_install_surface?: string;
+  config_fetch_ms?: number;
+  config_fetch_attempts?: number;
+  config_fetch_status?: RuntimeLoadDiagnostic["configFetchStatus"];
+  config_fetch_status_code?: number;
+  mutation_apply_pending?: number;
+  mutation_apply_applied?: number;
+  mutation_apply_missed?: number;
+  cls_total?: number;
+  cls_after_reveal?: number;
+  hydration_detected_at?: number;
+  apply_delayed_ms?: number;
+  hydration_timeout?: boolean;
+  hold_timeout?: boolean;
+  reapply_count?: number;
+  reassert_loop_detected?: boolean;
+  early_apply_at?: number;
+  reasserts_count?: number;
+  revert_loops_detected?: number;
+};
+
+
+export type InitPhaseKey =
+  | "guard_resolve_ms"
+  | "consent_identity_ms"
+  | "runtime_setup_ms"
+  | "targeting_assignment_ms"
+  | "mutation_finalize_ms";
+
+export type InitPerfContext = {
+  startedAt: number;
+  phases: Partial<Record<InitPhaseKey, number>>;
+  includesConfigFetch: boolean;
+  predecisionMismatches: number;
+};
+
+export const MAX_PERF_DURATION_MS = 60_000;
+
+export function monotonicNow(): number {
+  const value = globalThis.performance?.now?.();
+  return typeof value === "number" && Number.isFinite(value) ? value : Date.now();
+}
+
+export function boundedPerfDuration(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.round(Math.min(MAX_PERF_DURATION_MS, Math.max(0, value)) * 10) / 10;
+}
+
+export function createInitPerfContext(): InitPerfContext {
+  return { startedAt: monotonicNow(), phases: {}, includesConfigFetch: false, predecisionMismatches: 0 };
+}
+
+export type BootstrapPredecision = {
+  decision: Array<[experimentId: string, variationId: string]>;
+  configRevision: number;
+  visitorId: string;
+  groups: CompactGroupSelections;
+};
+
+export function bootstrapPredecision(config: InitConfig, perf: InitPerfContext): BootstrapPredecision | null {
+  const candidate = (globalThis as typeof globalThis & { __dripPredecided?: unknown }).__dripPredecided;
+  if (!candidate || typeof candidate !== "object") return null;
+  const value = candidate as Partial<BootstrapPredecision>;
+  const revision = config.delivery?.revision;
+  if (!Number.isSafeInteger(revision) || value.configRevision !== revision ||
+      typeof value.visitorId !== "string" || !value.visitorId || !Array.isArray(value.decision) ||
+      !value.groups || typeof value.groups !== "object") {
+    perf.predecisionMismatches += 1;
+    return null;
+  }
+  return value as BootstrapPredecision;
+}
+
+export function addInitPhase(context: InitPerfContext, phase: InitPhaseKey, startedAt: number): void {
+  const elapsed = boundedPerfDuration(monotonicNow() - startedAt);
+  context.phases[phase] = boundedPerfDuration((context.phases[phase] ?? 0) + elapsed);
+}
+
+export type DeliveryHealthStatus = "applied" | "partial" | "miss" | "control" | "no_mutations";
+
+export type DeliveryHealthTracker = {
+  assignment: Assignment;
+  expected: number;
+  applied: Set<number>;
+  missed: Set<number>;
+  emitted: boolean;
+};
+
+export type RouteDiagnostic = {
+  previousUrl: string;
+  nextUrl: string;
+  reason: string;
+  at: number;
+  reEvaluated: boolean;
+};
+
+export type DataLayerDiagnostic = {
+  eventName: string;
+  dataLayerName: string;
+  at: number;
+  mappedSignals: string[];
+  gtagNormalized?: boolean;
+};
+
+export type ShopifySyncDiagnostic = {
+  at: number;
+  status: "pending" | "sent" | "skipped" | "failed";
+  reason?: string;
+  assignmentCount: number;
+};
+
+export type ShopifyAssignmentSyncDiagnostic = Omit<ShopifySyncDiagnostic, "status"> & {
+  status: ShopifySyncDiagnostic["status"] | "cookie_fallback";
+  truncatedAssignmentCount?: number;
+};
+
+export type ExposureDestinationDiagnostic = {
+  type: string;
+  status: "sent" | "skipped" | "failed";
+  at: number;
+  reason?: string;
+};
+
+export type RuntimeLoadDiagnostic = SdkDiagnostics["load"];
+
+export type DripPerfWindow = Window & {
+  __dripPerf?: Record<string, unknown>;
+};
+
+export function normalizeNumber(value: unknown, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  return fallback;
+}
+
+export function resolveRuntimeConfig(config: InitConfig): ResolvedRuntimeConfig {
+  const executionMode = config.executionMode ?? DEFAULT_EXECUTION_MODE;
+
+  const antiFlickerMode = config.antiFlickerMode
+    ?? (config.antiFlicker === false ? "off" : config.antiFlicker === true ? "full" : "scoped");
+
+  const antiFlickerTimeoutMs = normalizeNumber(
+    config.antiFlickerTimeoutMs ?? config.antiFlickerTimeout,
+    DEFAULT_ANTI_FLICKER_TIMEOUT_MS,
+  );
+
+  const trackingStart = config.trackingStart
+    ?? (typeof config.deferTracking === "boolean"
+      ? (config.deferTracking ? "idle" : "immediate")
+      : DEFAULT_TRACKING_START);
+
+  const trackingIdleTimeoutMs = normalizeNumber(
+    config.trackingIdleTimeoutMs,
+    DEFAULT_TRACKING_IDLE_TIMEOUT_MS,
+  );
+
+  const customJsPolicy = config.customJsPolicy ?? DEFAULT_JS_POLICY;
+
+  return {
+    executionMode,
+    antiFlickerMode,
+    antiFlickerTimeoutMs,
+    antiFlickerCustomCss: config.antiFlickerCustomCss,
+    trackingStart,
+    trackingIdleTimeoutMs,
+    customJsPolicy,
+    proxyEventDelivery: config.proxyEventDelivery?.enabled === true
+      ? { enabled: true, ...(typeof config.proxyEventDelivery.path === "string" ? { path: config.proxyEventDelivery.path } : {}) }
+      : undefined,
+  };
+}
+
+export function resolvePageTriggerMode(config: InitConfig): PageTriggerMode {
+  // Shop defaults map to page overrides as follows: direct -> immediate,
+  // url_change -> history/polling, dom_change -> dom, manual -> manual-*.
+  // The enums stay separate because the shop mode is a default while each
+  // published Page can select its own detector.
+  const mode = config.pageTrigger?.defaultMode;
+  if (mode === "url_change" || mode === "dom_change" || mode === "manual") return mode;
+  return "direct";
+}
+
+export function resolveDomPageTrigger(config: InitConfig, pageTriggerMode: PageTriggerMode): boolean {
+  if (config.spa?.domChangeTrigger === false) return false;
+  return (
+    config.spa?.domChangeTrigger === true ||
+    pageTriggerMode === "dom_change" ||
+    pageTriggerMode === "url_change" ||
+    config.platformHint === "spa"
+  );
+}
+
+export /** Bridge: log to both debug console and devtools overlay */
+function dtLog(type: string, label: string, detail?: Record<string, unknown>): void {
+  if (!FEATURE_DEVTOOLS) return;
+  try {
+    import("./devtools").then(({ logDevtoolsEvent }) => {
+      logDevtoolsEvent(type, label, detail);
+    }).catch(() => {});
+  } catch {
+    // Dynamic import not supported.
+  }
+}
+
+export function traceName(id: string, name?: string): string {
+  return name && name !== id ? `"${name}" (${id})` : id;
+}
+
+export function traceStep(message: string, data?: Record<string, unknown>): void {
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("trace", message, data);
+}
+
+export function traceGate(experiment: Experiment, gate: ActivationGateDiagnostic): void {
+  const status = gate.status === "passed"
+    ? "matching"
+    : gate.status === "failed"
+      ? "not matching"
+      : "skipped";
+  __DRIP_FEATURE_DEVTOOLS__ && traceStep(`${experiment.id}: ${gate.label} is ${status}`, {
+    reason: gate.reason,
+    ...(gate.detail && typeof gate.detail === "object" ? { detail: gate.detail } : {}),
+  });
+}
+
+export function browserDoNotTrackValue(): string {
+  const nav = globalThis.navigator as Navigator & { msDoNotTrack?: string } | undefined;
+  const win = globalThis as unknown as Window & { doNotTrack?: string };
+  return nav?.doNotTrack ?? nav?.msDoNotTrack ?? win.doNotTrack ?? "";
+}
+
+export function trackingBlocked(): boolean {
+  return state.trackingDisabledByDnt || (state.consentRequired && !state.consentGranted);
+}
+
+export let storefrontVitalsGateOpen: boolean | null = null;
+
+export function syncStorefrontVitals(): void {
+  const config = state.config;
+  const gateOpen = Boolean(
+    runtimeSharedState.storefrontVitalsContext
+    && config
+    && !trackingBlocked()
+    && state.trackingPrerequisiteMet
+    && !state.screenshotMode
+    // Field vitals measure production customer traffic only; QA and preview
+    // sessions must not contaminate the baseline.
+    && !state.qaMode
+    && (config.environments?.activeKey ?? "production") === "production"
+  );
+  if (gateOpen === storefrontVitalsGateOpen) return;
+
+  const wasOpen = storefrontVitalsGateOpen;
+  storefrontVitalsGateOpen = gateOpen;
+  if (gateOpen && runtimeSharedState.storefrontVitalsContext) {
+    startStorefrontVitals(runtimeSharedState.storefrontVitalsContext);
+  } else if (wasOpen) {
+    stopStorefrontVitals();
+  }
+}
+
+export function doNotTrackEnabled(config: InitConfig): boolean {
+  return Boolean(evaluateSynchronousConsent({
+    consentCookieGranted: false,
+    respectDoNotTrack: config.dataProtection?.respectDoNotTrack,
+    doNotTrackValue: browserDoNotTrackValue(),
+  }) & DNT_BLOCKED);
+}
+
+export function storageAllowed(consentRequired: boolean, consentGranted: boolean, trackingDisabledByDnt: boolean): boolean {
+  return (!consentRequired || consentGranted) && !trackingDisabledByDnt;
+}
+
+export function readWindowPath(path: string | undefined): unknown {
+  return readPath(globalThis as Record<string, unknown>, path);
+}
+
+export function configuredConsentGranted(config: InitConfig): boolean | null {
+  const consent = config.consentMode;
+  return readConfiguredConsent(consent?.provider, consent?.requiredGroup, consent?.getter);
+}
+
+export function syncConfiguredConsent(config: InitConfig): void {
+  if (!state.consentRequired) return;
+  const configured = configuredConsentGranted(config);
+  if (configured == null || configured === state.consentGranted) return;
+  setConsent(configured);
+}
+
+export const CUSTOM_CONSENT_POLL_INTERVAL_MS = 1000;
+export const CUSTOM_CONSENT_POLL_MAX_MS = 10 * 60 * 1000;
+export const MANUAL_CALLBACK_TRIGGER_RERUN_INTERVAL_MS = 1000;
+export const MANUAL_CALLBACK_TRIGGER_RERUN_MAX_MS = 10_000;
+export const MANUAL_CALLBACK_TRIGGER_MAX_RERUNS = 10;
+export const EVENT_DRIVEN_CONSENT_PROVIDERS = new Set(["onetrust", "usercentrics", "cookiebot", "ccm19"]);
+
+export function shouldPollConfiguredConsent(config: InitConfig): boolean {
+  const consent = config.consentMode;
+  if (!consent?.enabled || state.consentGranted) return false;
+  if (consent.provider && EVENT_DRIVEN_CONSENT_PROVIDERS.has(consent.provider)) return false;
+  return consent.provider === "custom"
+    || consent.provider === "pandectes"
+    || consent.provider === "cookiescript"
+    || consent.provider === "borlabs"
+    || typeof consent.getter === "string";
+}
+
+export function installConsentChangeListeners(config: InitConfig): (() => void) | null {
+  if (!config.consentMode?.enabled || typeof window === "undefined") return null;
+  const events = [
+    "OneTrustGroupsUpdated",
+    "OptanonConsentChanged",
+    "CookiebotOnConsentReady",
+    "CookiebotOnAccept",
+    "CookiebotOnDecline",
+    "CookieConsentDeclaration",
+    "UC_UI_CMP_EVENT",
+    "ccm19EmbeddingAccepted",
+    "ccm19WidgetClosed",
+    "ccm19WidgetLoaded",
+    "PandectesInitialized",
+    "visitorConsentCollected",
+    "CookieScriptLoaded",
+    "CookieScriptAccept",
+    "CookieScriptAcceptAll",
+    "CookieScriptReject",
+    "CookieScriptClose",
+  ];
+  const handler = () => syncConfiguredConsent(config);
+  events.forEach((event) => window.addEventListener(event, handler));
+  const documentEvents = ["PandectesInitialized", "visitorConsentCollected"];
+  if (typeof document !== "undefined") {
+    documentEvents.forEach((event) => document.addEventListener(event, handler));
+  }
+
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+  let pollCapTimer: ReturnType<typeof setTimeout> | null = null;
+  const stopPolling = () => {
+    if (pollTimer !== null) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+    if (pollCapTimer !== null) {
+      clearTimeout(pollCapTimer);
+      pollCapTimer = null;
+    }
+  };
+
+  if (shouldPollConfiguredConsent(config)) {
+    pollTimer = setInterval(() => {
+      syncConfiguredConsent(config);
+      if (state.consentGranted) stopPolling();
+    }, CUSTOM_CONSENT_POLL_INTERVAL_MS);
+    pollCapTimer = setTimeout(stopPolling, CUSTOM_CONSENT_POLL_MAX_MS);
+  }
+
+  return () => {
+    stopPolling();
+    events.forEach((event) => window.removeEventListener(event, handler));
+    if (typeof document !== "undefined") {
+      documentEvents.forEach((event) => document.removeEventListener(event, handler));
+    }
+  };
+}
+
+export function resolveConsentRequired(config: InitConfig): boolean {
+  return Boolean(evaluateSynchronousConsent({
+    requireConsent: config.requireConsent,
+    hasConsent: config.hasConsent,
+    consentModeEnabled: config.consentMode?.enabled,
+    consentCookieGranted: false,
+  }) & CONSENT_REQUIRED);
+}
+
+export function resolveConsentGranted(config: InitConfig, consentRequired: boolean): boolean {
+  if (!consentRequired) return true;
+  const configured = configuredConsentGranted(config);
+  return resolveSynchronousConsentGranted({
+    requireConsent: config.requireConsent,
+    hasConsent: config.hasConsent,
+    consentModeEnabled: config.consentMode?.enabled,
+    provider: config.consentMode?.provider,
+    configuredConsentGranted: configured,
+    consentCookieGranted: readConsentCookie(),
+  });
+}
+
+export function persistentStorageAllowed(): boolean {
+  return storageAllowed(state.consentRequired, state.consentGranted, state.trackingDisabledByDnt);
+}
+
+configureSignalPersistenceAllowed(() => persistentStorageAllowed());
+
+export function coerceSignalValue(value: unknown, valueType?: RuntimeSignalDefinition["valueType"]): unknown {
+  if (value === undefined || value === null) return undefined;
+  if (valueType === "number") {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : undefined;
+  }
+  if (valueType === "boolean") {
+    if (typeof value === "boolean") return value;
+    const normalized = String(value).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) return true;
+    if (["0", "false", "no", "off"].includes(normalized)) return false;
+    return undefined;
+  }
+  if (valueType === "string_array") {
+    if (Array.isArray(value)) return value.map((item) => String(item).trim()).filter(Boolean);
+    return String(value).split(",").map((item) => item.trim()).filter(Boolean);
+  }
+  if (valueType === "json") return value;
+  return String(value);
+}
+
+export function captureUrlSignals(config: InitConfig): void {
+  const definitions = config.signals ?? [];
+  if (!definitions.length) return;
+  let parsed: URL | null = null;
+  try {
+    parsed = new URL(config.url ?? location.href, typeof location !== "undefined" ? location.origin : "https://_");
+  } catch {
+    parsed = null;
+  }
+  if (!parsed) return;
+
+  for (const definition of definitions) {
+    const capture = definition.capture;
+    if (!definition.key || capture?.mode !== "url_parameter" || !capture.parameter) continue;
+    const raw = parsed.searchParams.get(capture.parameter);
+    if (raw == null || raw === "") {
+      if (capture.persist === false) clearRuntimeSignal(definition.key);
+      continue;
+    }
+    const value = coerceSignalValue(raw, definition.valueType);
+    if (value !== undefined) {
+      setCapturedSignal(definition.key, value, {
+        ttlDays: definition.ttlDays,
+        persist: capture.persist,
+        source: "url_parameter",
+      });
+    }
+  }
+}
+
+export function installClickSignalCaptures(config: InitConfig): (() => void) | null {
+  const definitions = (config.signals ?? []).filter((definition) =>
+    definition.capture?.mode === "click_selector" && definition.capture.selector,
+  );
+  if (!definitions.length || typeof document === "undefined" || !document.addEventListener) {
+    return null;
+  }
+
+  const handler = (event: Event) => {
+    if (!persistentStorageAllowed()) return;
+    const target = event.target;
+    if (!target || typeof (target as Element).closest !== "function") return;
+    const targetElement = target as Element;
+
+    for (const definition of definitions) {
+      const capture = definition.capture!;
+      const selector = capture.selector;
+      if (!selector) continue;
+      let element: Element | null = null;
+      try {
+        element = targetElement.closest(selector);
+      } catch {
+        element = null;
+      }
+      if (!element) continue;
+
+      let raw: unknown = true;
+      if (capture.source === "text") raw = element.textContent?.trim() ?? "";
+      if (capture.source === "attribute" && capture.attribute) raw = element.getAttribute(capture.attribute);
+      if (capture.source === "dataset" && capture.attribute) {
+        const key = capture.attribute.replace(/^data-/, "").replace(/-([a-z])/g, (_, char: string) => char.toUpperCase());
+        raw = (element as HTMLElement).dataset?.[key];
+      }
+      if (capture.source === "constant") raw = capture.value ?? true;
+
+      const value = coerceSignalValue(raw, definition.valueType);
+      if (value !== undefined) setStoredSignal(definition.key, value, definition.ttlDays, "click_selector");
+    }
+  };
+
+  document.addEventListener("click", handler, true);
+  return () => document.removeEventListener?.("click", handler, true);
+}
+
+export function captureEventPropertySignals(type: string, data?: Record<string, unknown>): void {
+  if (!state.config || !persistentStorageAllowed()) return;
+  const definitions = state.config.signals ?? [];
+  if (!definitions.length || !data) return;
+
+  for (const definition of definitions) {
+    const capture = definition.capture;
+    if (capture?.mode !== "event_property") continue;
+    if (!capture.eventName || !capture.property || capture.eventName !== type) continue;
+    const value = coerceSignalValue(data[capture.property], definition.valueType);
+      if (value !== undefined) setStoredSignal(definition.key, value, definition.ttlDays, "event_property");
+  }
+}
+
+export function setCapturedSignal(
+  key: string,
+  value: unknown,
+  opts: { ttlDays?: number; persist?: boolean; source: string },
+): void {
+  if (!key) return;
+  if (opts.persist === false || !persistentStorageAllowed()) {
+    setRuntimeSignal(key, value, opts.source);
+    return;
+  }
+  setStoredSignal(key, value, opts.ttlDays, opts.source);
+  setRuntimeSignal(key, value, opts.source);
+}
+
+export function setPublicSignal(key: string, value: unknown, ttlDays?: number, source = "manual"): void {
+  if (persistentStorageAllowed()) {
+    setStoredSignal(key, value, ttlDays, source);
+  } else {
+    setRuntimeSignal(key, value, source);
+  }
+}
+
+export function getPublicSignals(options: { markVisitorSeen?: boolean } = {}): ReturnType<typeof getStoredSignals> {
+  return getStoredSignals({
+    ...options,
+    markVisitorSeen: options.markVisitorSeen === false ? false : persistentStorageAllowed(),
+  });
+}
+
+export function normalizePageApiName(value: unknown): string {
+  if (typeof value !== "string") return "";
+  const key = value
+    .trim()
+    .toLowerCase()
+    .replace(/['"`]/g, "")
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .replace(/_+/g, "_");
+  if (!key) return "";
+  return /^[a-z]/.test(key) ? key : `segment_${key}`;
+}
+
+export function pageTriggerSignal(normalizedApiName: string): string {
+  return `page.trigger.${normalizedApiName}`;
+}
+
+export function triggerPage(apiName: unknown, active: unknown = true): void {
+  const normalizedApiName = normalizePageApiName(apiName);
+  if (!normalizedApiName) return;
+  const nextActive =
+    active === false
+      ? false
+      : active && typeof active === "object" && "isActive" in active
+        ? Boolean((active as { isActive?: unknown }).isActive)
+        : true;
+  setRuntimeSignal(pageTriggerSignal(normalizedApiName), nextActive, "page_api");
+  try {
+    document.dispatchEvent(new CustomEvent("drip:signals-changed", {
+      detail: { source: "page_api", apiName: normalizedApiName, active: nextActive },
+    }));
+  } catch {}
+}
+
+export function readElementCaptureValue(element: Element, capture: NonNullable<RuntimeSignalDefinition["capture"]>): unknown {
+  if (capture.source === "attribute" && capture.attribute) return element.getAttribute(capture.attribute);
+  if (capture.source === "dataset" && capture.attribute) {
+    const key = capture.attribute.replace(/^data-/, "").replace(/-([a-z])/g, (_, char: string) => char.toUpperCase());
+    return (element as HTMLElement).dataset?.[key];
+  }
+  if (capture.source === "constant") return capture.value ?? true;
+  return element.textContent?.trim() ?? "";
+}
+
+export function captureDomAndGlobalSignals(config: InitConfig): void {
+  const definitions = config.signals ?? [];
+  for (const definition of definitions) {
+    const capture = definition.capture;
+    if (!capture) continue;
+    if (capture.mode === "dom_selector" && capture.selector && typeof document !== "undefined") {
+      let element: Element | null = null;
+      try {
+        element = document.querySelector(capture.selector);
+      } catch {
+        element = null;
+      }
+      if (!element) continue;
+      const value = coerceSignalValue(readElementCaptureValue(element, capture), definition.valueType);
+      if (value !== undefined) {
+        setCapturedSignal(definition.key, value, {
+          ttlDays: definition.ttlDays,
+          persist: capture.persist,
+          source: "dom_selector",
+        });
+      }
+    }
+    if (capture.mode === "global" && capture.path) {
+      const value = coerceSignalValue(readWindowPath(capture.path), definition.valueType);
+      if (value !== undefined) {
+        setCapturedSignal(definition.key, value, {
+          ttlDays: definition.ttlDays,
+          persist: capture.persist,
+          source: "global",
+        });
+      }
+    }
+  }
+}
+
+export function consentAwareDataProtection(config: InitConfig): DataProtectionSettings | undefined {
+  if (persistentStorageAllowed()) return config.dataProtection;
+  return { ...(config.dataProtection ?? {}), storageMode: "memory" };
+}
+
+export function writeConsentCookie(granted: boolean): void {
+  if (!globalThis.document) return;
+  try {
+    globalThis.document.cookie = granted
+      ? `${CONSENT_COOKIE_NAME}=1; Max-Age=31536000; Path=/; SameSite=Lax`
+      : `${CONSENT_COOKIE_NAME}=; Max-Age=0; Path=/; SameSite=Lax`;
+  } catch {
+    // ignore cookie failures
+  }
+}
+
+export function readConsentCookie(): boolean {
+  if (!globalThis.document?.cookie) return false;
+  try {
+    return new RegExp(`(?:^|;\\s*)${CONSENT_COOKIE_NAME}=1(?:;|$)`).test(globalThis.document.cookie);
+  } catch {
+    return false;
+  }
+}
+
+export function clearConsentStorage(): void {
+  clearPendingRedirectAssignmentCarry();
+  try {
+    const storage = globalThis.localStorage;
+    storage?.removeItem("drip_uid");
+    storage?.removeItem("drip_goals");
+    storage?.removeItem("drip_visitor_sessions_v1");
+    storage?.removeItem(ORDER_EXPOSURE_STORAGE_KEY);
+    clearStoredSignals();
+    if (storage) {
+      for (let i = storage.length - 1; i >= 0; i--) {
+        const key = storage.key(i);
+        if (key?.startsWith(CONFIG_CACHE_KEY_PREFIX)) storage.removeItem(key);
+      }
+    }
+  } catch {}
+  try {
+    const storage = globalThis.sessionStorage;
+    storage?.removeItem("drip_uid");
+    storage?.removeItem("drip_sid");
+    storage?.removeItem("drip_events");
+    storage?.removeItem("drip_utm");
+    if (storage) {
+      for (let i = storage.length - 1; i >= 0; i--) {
+        const key = storage.key(i);
+        if (
+          key?.startsWith("drip_hm:")
+          || key?.startsWith(REPLAY_SAMPLE_KEY_PREFIX)
+          || key?.startsWith(REPLAY_PROGRESS_KEY_PREFIX)
+        ) {
+          storage.removeItem(key);
+        }
+      }
+    }
+  } catch {}
+  clearIdentityContextCookie();
+  clearPersistedAssignments();
+  clearBrowserGroupStickyStore();
+  clearAssignmentSyncCookie();
+  if (globalThis.document) {
+    try {
+      globalThis.document.cookie = "drip_uid=; Max-Age=0; Path=/; SameSite=Lax";
+    } catch {}
+  }
+}
+
+export function applyConsentStorageMode(): void {
+  if (!state.config) return;
+  configureIdentityStorage(consentAwareDataProtection(state.config));
+  if (persistentStorageAllowed() && state.userId) {
+    const persistedUserId = getPersistedUserId();
+    state.userId = persistedUserId || state.userId;
+    adoptUserId(state.userId);
+  }
+}
+
+export function runWhenDomReady(callback: () => void): void {
+  if (!globalThis.document || document.readyState !== "loading") {
+    callback();
+    return;
+  }
+  document.addEventListener("DOMContentLoaded", callback, { once: true });
+}
+
+export function applyProjectCode(config: InitConfig): void {
+  const projectCode = config.projectCode;
+  if (!projectCode?.enabled) return;
+  if (projectCode.css && globalThis.document) {
+    const id = "drip-project-css";
+    let style = document.getElementById(id) as HTMLStyleElement | null;
+    if (!style) {
+      style = document.createElement("style");
+      style.id = id;
+      (document.head || document.documentElement).appendChild(style);
+    }
+    style.textContent = projectCode.css;
+  }
+  if (projectCode.helperJs) execJs(projectCode.helperJs, "project-helper");
+}
+
+export function resetProjectCode(): void {
+  // Project helper/startup JS has no general inverse. Run the same supported
+  // cleanup path as a runtime re-init first: variation/experiment reset JS,
+  // mutation restoration, commerce teardown, and injected artifact removal.
+  teardownTransaction(allAppliedPagesWithModes());
+  globalThis.document?.getElementById("drip-project-css")?.remove();
+}
+
+export function runProjectStartupCode(config: InitConfig): void {
+  const projectCode = config.projectCode;
+  const js = projectCode?.js;
+  if (!projectCode?.enabled || !js) return;
+  runWhenDomReady(() => {
+    // A cached config can be replaced before DOMContentLoaded. Never let its
+    // deferred project startup code run after an authoritative re-init.
+    if (state.config !== config || state.holdout) return;
+    execJs(js, "project-startup");
+  });
+}
+
+export function collectJsTriggerConditions(experiments: Experiment[]): SegmentCondition[] {
+  const seen = new Set<string>();
+  const conditions: SegmentCondition[] = [];
+  for (const experiment of experiments) {
+    for (const rule of experiment.targeting?.segmentRules ?? []) {
+      for (const condition of rule.rules?.conditions ?? []) {
+        const code = condition.js?.code?.trim();
+        if (!code) continue;
+        const key = `${condition.signal}:${code}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        conditions.push(condition);
+      }
+    }
+  }
+  return conditions;
+}
+
+export function collectPageTriggerRules(experiments: Experiment[]): PageTargetingRule[] {
+  const seen = new Set<string>();
+  const rules: PageTargetingRule[] = [];
+  for (const experiment of experiments) {
+    for (const pageRules of [
+      experiment.targeting?.pageRules ?? [],
+      experiment.goalPageRules ?? [],
+    ]) {
+      for (const rule of pageRules) {
+        const mode = rule.trigger?.mode;
+        if (mode !== "manual-callback" && mode !== "manual-api") continue;
+        const code = rule.trigger?.triggerJs?.trim();
+        const signal = rule.trigger?.signal;
+        if (!code || !signal) continue;
+        const key = `${signal}:${code}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        rules.push(rule);
+      }
+    }
+  }
+  return rules;
+}
+
+export type PageDetectorMode = "history" | "polling" | "dom";
+
+export type PageRuleReconcileScope = {
+  triggeredPageIds: ReadonlySet<string>;
+  includeImmediate: boolean;
+};
+
+export function collectPageDetectorRules(
+  experiments: Experiment[],
+): Map<PageDetectorMode, PageTargetingRule[]> {
+  const registry = new Map<PageDetectorMode, PageTargetingRule[]>([
+    ["history", []],
+    ["polling", []],
+    ["dom", []],
+  ]);
+  const seen = new Set<string>();
+  for (const experiment of experiments) {
+    for (const rules of [
+      experiment.targeting?.pageRules ?? [],
+      experiment.goalPageRules ?? [],
+    ]) {
+      for (const rule of rules) {
+        const mode = rule.trigger?.mode;
+        if (mode !== "history" && mode !== "polling" && mode !== "dom") continue;
+        const key = `${mode}:${rule.id}`;
+        if (!rule.id || seen.has(key)) continue;
+        seen.add(key);
+        registry.get(mode)!.push(rule);
+      }
+    }
+  }
+  return registry;
+}
+
+export function experimentsForGlobalRouteReevaluation(
+  experiments: Experiment[],
+): Experiment[] {
+  return experiments.map((experiment) => ({
+    ...experiment,
+    goalPageRules: experiment.goalPageRules?.filter((rule) => {
+      const mode = rule.trigger?.mode ?? "immediate";
+      return mode === "immediate";
+    }),
+    targeting: experiment.targeting
+      ? {
+          ...experiment.targeting,
+          pageRules: experiment.targeting.pageRules?.filter((rule) => {
+            const mode = rule.trigger?.mode ?? "immediate";
+            return mode === "immediate";
+          }),
+        }
+      : experiment.targeting,
+  }));
+}
+
+export function conditionUsesActivateTrigger(condition: SegmentCondition): boolean {
+  const code = condition.js?.code ?? "";
+  return condition.js?.mode === "activate" ||
+    /\bactivate\s*\(/.test(code) ||
+    /\bcallbackFn\b/.test(code);
+}
+
+export function buildJsTriggerContext(condition: SegmentCondition): Record<string, unknown> {
+  const href = typeof window !== "undefined" ? window.location.href : "https://_";
+  const apexTools = getRuntimeTools();
+  return {
+    apexTools,
+    attributes: buildTargetingAttributes({}, href),
+    document: typeof document !== "undefined" ? document : undefined,
+    location: typeof location !== "undefined" ? location : undefined,
+    signal: condition.signal,
+    url: new URL(href, "https://_"),
+    value: condition.value,
+    window: typeof window !== "undefined" ? window : undefined,
+  };
+}
+
+export function runJsTriggerReset(condition: SegmentCondition): void {
+  const resetCode = condition.js?.resetCode?.trim();
+  if (!resetCode || resetCode.length > 4000) return;
+  try {
+    const context = buildJsTriggerContext(condition);
+    const fn = new Function(
+      "context",
+      `"use strict";` +
+        `const attributes=context.attributes;` +
+        `const apexTools=context.apexTools;` +
+        `const document=context.document;` +
+        `const location=context.location;` +
+        `const signal=context.signal;` +
+        `const url=context.url;` +
+        `const value=context.value;` +
+        `const window=context.window;` +
+        `(function(){${resetCode}}).call(window);`,
+    );
+    fn(context);
+  } catch (error) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugWarn("JS trigger reset failed", error instanceof Error ? error.message : String(error));
+  }
+}
+
+export function normalizeActivationValue(next: unknown, hasArgument: boolean): boolean {
+  if (!hasArgument) return true;
+  if (next && typeof next === "object" && "isActive" in next) {
+    return Boolean((next as { isActive?: unknown }).isActive);
+  }
+  return Boolean(next);
+}
+
+export function installActivateJsTrigger(condition: SegmentCondition, onChange: () => void): () => void {
+  const source = condition.js?.code?.trim();
+  if (!source || source.length > 4000) return () => {};
+
+  let teardown: unknown;
+  let active = Boolean(getPublicSignals({ markVisitorSeen: false })[condition.signal]);
+  const options = { isActive: active };
+  function activate(next?: unknown) {
+    const nextActive = normalizeActivationValue(next, arguments.length > 0);
+    active = nextActive;
+    options.isActive = nextActive;
+    setRuntimeSignal(condition.signal, nextActive);
+    onChange();
+  }
+
+  try {
+    const context = buildJsTriggerContext(condition);
+    const fn = new Function(
+      "activate",
+      "options",
+      "context",
+      `"use strict";` +
+        `const attributes=context.attributes;` +
+        `const apexTools=context.apexTools;` +
+        `const document=context.document;` +
+        `const location=context.location;` +
+        `const signal=context.signal;` +
+        `const url=context.url;` +
+        `const value=context.value;` +
+        `const window=context.window;` +
+        `${source}\n` +
+        `if (typeof callbackFn === "function") return callbackFn(activate, options);`,
+    );
+    teardown = fn(activate, options, context);
+  } catch (error) {
+    __DRIP_FEATURE_DEVTOOLS__ && debugWarn("JS trigger activation failed", error instanceof Error ? error.message : String(error));
+    setRuntimeSignal(condition.signal, false);
+  }
+
+  return () => {
+    try {
+      if (typeof teardown === "function") teardown();
+    } catch (error) {
+      __DRIP_FEATURE_DEVTOOLS__ && debugWarn("JS trigger teardown failed", error instanceof Error ? error.message : String(error));
+    }
+    runJsTriggerReset(condition);
+    clearRuntimeSignal(condition.signal);
+    onChange();
+  };
+}
+
+export function installPageTriggerRule(
+  rule: PageTargetingRule,
+  onChange: () => void,
+  manualInitialTrigger = false,
+): () => void {
+  const mode = rule.trigger?.mode;
+  if (mode !== "manual-callback" && mode !== "manual-api") return () => {};
+  const source = rule.trigger?.triggerJs?.trim();
+  const signal = rule.trigger?.signal;
+  if (!source || source.length > 8000 || !signal) return () => {};
+  const triggerSignal = signal;
+
+  const teardowns: Array<() => void> = [];
+  let active = Boolean(getPublicSignals({ markVisitorSeen: false })[triggerSignal]);
+  const options = { isActive: active, pageId: rule.id, apiName: rule.trigger?.apiName };
+  let rerunObserverCleanup: (() => void) | null = null;
+  let rerunInterval: number | null = null;
+  let rerunCapTimer: number | null = null;
+  let rerunCount = 0;
+  let totalAttemptCount = 0;
+  let rerunsStarted = false;
+  let rerunsStopped = false;
+
+  const triggerIsActive = () => Boolean(
+    getPublicSignals({ markVisitorSeen: false })[triggerSignal],
+  );
+
+  const stopReruns = (
+    reason: "activated" | "attempt_limit" | "time_limit" | "teardown",
+  ) => {
+    if (rerunsStopped) return;
+    rerunsStopped = true;
+    if (rerunObserverCleanup) {
+      rerunObserverCleanup();
+      rerunObserverCleanup = null;
+    }
+    if (rerunInterval !== null) {
+      window.clearInterval(rerunInterval);
+      rerunInterval = null;
+    }
+    if (rerunCapTimer !== null) {
+      window.clearTimeout(rerunCapTimer);
+      rerunCapTimer = null;
+    }
+    if (rerunsStarted) {
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog(
+        "page-trigger",
+        "Manual callback re-runs stopped",
+        {
+          attempts: totalAttemptCount,
+          pageId: rule.id,
+          reason,
+          reruns: rerunCount,
+          signal: triggerSignal,
+        },
+      );
+    }
+  };
+
+  const runTrigger = (isRerun: boolean) => {
+    if (isRerun) {
+      if (rerunsStopped) return;
+      if (triggerIsActive()) {
+        stopReruns("activated");
+        return;
+      }
+      if (rerunCount >= MANUAL_CALLBACK_TRIGGER_MAX_RERUNS) {
+        stopReruns("attempt_limit");
+        return;
+      }
+      rerunCount += 1;
+    }
+    totalAttemptCount += 1;
+    let activatedThisRun = false;
+
+    function activate(next?: unknown) {
+      const nextActive = normalizeActivationValue(next, arguments.length > 0);
+      if (nextActive) activatedThisRun = true;
+      active = nextActive;
+      options.isActive = nextActive;
+      setRuntimeSignal(triggerSignal, nextActive, "page_trigger");
+      onChange();
+      if (nextActive) stopReruns("activated");
+    }
+
+    try {
+      const href = typeof window !== "undefined" ? window.location.href : "https://_";
+      const context = {
+        apexTools: getRuntimeTools(),
+        attributes: buildTargetingAttributes({}, href),
+        document: typeof document !== "undefined" ? document : undefined,
+        location: typeof location !== "undefined" ? location : undefined,
+        pageId: rule.id,
+        apiName: rule.trigger?.apiName,
+        signal: triggerSignal,
+        url: new URL(href, "https://_"),
+        window: typeof window !== "undefined" ? window : undefined,
+      };
+      const fn = new Function(
+        "activate",
+        "options",
+        "context",
+        `"use strict";` +
+          `const apexTools=context.apexTools;` +
+          `const attributes=context.attributes;` +
+          `const document=context.document;` +
+          `const location=context.location;` +
+          `const pageId=context.pageId;` +
+          `const apiName=context.apiName;` +
+          `const signal=context.signal;` +
+          `const url=context.url;` +
+          `const window=context.window;` +
+          `${source}\n`,
+      );
+      const teardown = fn(activate, options, context);
+      if (typeof teardown === "function") teardowns.push(teardown);
+    } catch (error) {
+      __DRIP_FEATURE_DEVTOOLS__ && debugWarn("Page trigger JS failed", error instanceof Error ? error.message : String(error));
+      if (!activatedThisRun) setRuntimeSignal(triggerSignal, false, "page_trigger");
+    }
+
+    if (triggerIsActive()) {
+      stopReruns("activated");
+    } else if (isRerun && rerunCount >= MANUAL_CALLBACK_TRIGGER_MAX_RERUNS) {
+      stopReruns("attempt_limit");
+    }
+  };
+
+  runTrigger(false);
+
+  if (
+    mode === "manual-callback" &&
+    !manualInitialTrigger &&
+    !rerunsStopped &&
+    !triggerIsActive() &&
+    typeof window !== "undefined" &&
+    typeof document !== "undefined"
+  ) {
+    rerunsStarted = true;
+    rerunObserverCleanup = observeDomChanges(() => runTrigger(true));
+    rerunInterval = window.setInterval(
+      () => runTrigger(true),
+      MANUAL_CALLBACK_TRIGGER_RERUN_INTERVAL_MS,
+    );
+    rerunCapTimer = window.setTimeout(
+      () => stopReruns("time_limit"),
+      MANUAL_CALLBACK_TRIGGER_RERUN_MAX_MS,
+    );
+    __DRIP_FEATURE_DEVTOOLS__ && debugLog(
+      "page-trigger",
+      "Manual callback re-runs started",
+      {
+        attempts: totalAttemptCount,
+        intervalMs: MANUAL_CALLBACK_TRIGGER_RERUN_INTERVAL_MS,
+        maxMs: MANUAL_CALLBACK_TRIGGER_RERUN_MAX_MS,
+        maxReruns: MANUAL_CALLBACK_TRIGGER_MAX_RERUNS,
+        pageId: rule.id,
+        signal: triggerSignal,
+      },
+    );
+  }
+
+  return () => {
+    stopReruns("teardown");
+    for (const teardown of teardowns) {
+      try {
+        teardown();
+      } catch (error) {
+        __DRIP_FEATURE_DEVTOOLS__ && debugWarn("Page trigger teardown failed", error instanceof Error ? error.message : String(error));
+      }
+    }
+    clearRuntimeSignal(triggerSignal);
+    onChange();
+  };
+}
+
+export function installJsTriggerObserver(
+  experiments: Experiment[],
+  onChange: () => void,
+  manualInitialTrigger: boolean,
+): () => void {
+  if (
+    !targetingHasJsTriggers(experiments) ||
+    typeof window === "undefined" ||
+    typeof document === "undefined"
+  ) {
+    return () => {};
+  }
+
+  const jsTriggerConditions = collectJsTriggerConditions(experiments);
+  const activateCleanups = jsTriggerConditions
+    .filter(conditionUsesActivateTrigger)
+    .map((condition) => installActivateJsTrigger(condition, onChange));
+  const pageTriggerCleanups = collectPageTriggerRules(experiments)
+    .map((rule) => installPageTriggerRule(rule, onChange, manualInitialTrigger));
+
+  let timeoutId: number | null = null;
+  const schedule = () => {
+    if (timeoutId !== null) return;
+    timeoutId = window.setTimeout(() => {
+      timeoutId = null;
+      onChange();
+    }, 80);
+  };
+
+  const listeners: Array<[EventTarget, string, EventListener, AddEventListenerOptions?]> = [
+    [document, "click", schedule, { capture: true, passive: true }],
+    [document, "input", schedule, { capture: true, passive: true }],
+    [document, "change", schedule, { capture: true, passive: true }],
+    [document, "keyup", schedule, { capture: true }],
+    [document, "drip:trigger", schedule],
+    [document, "drip:signals-changed", schedule],
+    [window, "resize", schedule, { passive: true }],
+    [window, "scroll", schedule, { passive: true }],
+  ];
+
+  let observer: MutationObserver | null = null;
+  if (typeof MutationObserver !== "undefined" && document.documentElement) {
+    observer = new MutationObserver(schedule);
+    registerMutedObserver(observer, schedule);
+    observer.observe(document.documentElement, {
+      attributes: true,
+      childList: true,
+      subtree: true,
+    });
+  }
+
+  listeners.forEach(([target, event, listener, options]) => {
+    target.addEventListener(event, listener, options);
+  });
+
+  return () => {
+    if (timeoutId !== null) window.clearTimeout(timeoutId);
+    if (observer) {
+      observer.disconnect();
+      unregisterMutedObserver(observer);
+    }
+    activateCleanups.forEach((cleanup) => cleanup());
+    pageTriggerCleanups.forEach((cleanup) => cleanup());
+    listeners.forEach(([target, event, listener, options]) => {
+      target.removeEventListener(event, listener, options);
+    });
+  };
+}
+
+export function notifyQaAssistantRuntimeListeners(): void {
+  for (const listener of runtimeSharedState.qaAssistantRuntimeListeners) {
+    try {
+      listener();
+    } catch {
+      // QA panel subscriptions must not affect storefront behavior.
+    }
+  }
+}
+
+export type HarnessManifest = {
+  version?: number;
+  expiresAt?: string;
+  externalJsUrl?: string | null;
+  externalCssUrl?: string | null;
+  manifestUrl?: string;
+  pollIntervalMs?: number;
+};
+
+export let harnessPollTimer: number | null = null;
+export let harnessPollKey = "";
+export let harnessVisibilityInstalled = false;
+
+export function activeHarnessAssignment(assignments: Assignment[]): Assignment | null {
+  if (!FEATURE_HARNESS) return null;
+  return artifactRenderableAssignments(assignments).find(
+    (assignment) => assignment.harnessSession?.manifestUrl,
+  ) ?? null;
+}
+
+export function stopHarnessPolling(): void {
+  if (harnessPollTimer !== null) {
+    window.clearInterval(harnessPollTimer);
+    harnessPollTimer = null;
+  }
+  harnessPollKey = "";
+}
+
+export function applyHarnessManifest(manifest: HarnessManifest): void {
+  if (!manifest.version || manifest.version <= 0) return;
+  const current = activeHarnessAssignment(state.assignments);
+  if (!current?.harnessSession?.manifestUrl) return;
+  if (current.harnessSession.version === manifest.version) return;
+
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("harness", `Reloading harness version ${manifest.version}`);
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "reload", { version: manifest.version });
+
+  teardownTransaction(allAppliedPagesWithModes());
+  state.assignments = state.assignments.map((assignment) => {
+    const sessionInfo = assignment.harnessSession;
+    if (!sessionInfo || sessionInfo.manifestUrl !== current.harnessSession?.manifestUrl) return assignment;
+    return {
+      ...assignment,
+      externalJsUrl: manifest.externalJsUrl ?? undefined,
+      externalCssUrl: manifest.externalCssUrl ?? undefined,
+      harnessSession: {
+        ...sessionInfo,
+        version: manifest.version,
+        expiresAt: manifest.expiresAt ?? sessionInfo.expiresAt,
+        manifestUrl: manifest.manifestUrl ?? sessionInfo.manifestUrl,
+        pollIntervalMs: manifest.pollIntervalMs ?? sessionInfo.pollIntervalMs,
+      },
+    };
+  });
+  applyAssignments(state.assignments, state.activationMode);
+  state.lastAssignmentSignature = assignmentSignature(state.assignments);
+}
+
+export function pollHarnessManifest(manifestUrl: string): void {
+  if (!FEATURE_HARNESS) return;
+  if (document.hidden) return;
+  fetch(manifestUrl, { cache: "no-store" })
+    .then((res) => {
+      if (!res.ok) throw new Error("Harness manifest failed: " + res.status);
+      return res.json() as Promise<HarnessManifest>;
+    })
+    .then(applyHarnessManifest)
+    .catch((error) => {
+      __DRIP_FEATURE_DEVTOOLS__ && debugWarn("harness", error instanceof Error ? error.message : String(error));
+      __DRIP_FEATURE_DEVTOOLS__ && dtLog("harness", "poll failed", {});
+    });
+}
+
+export function startHarnessPolling(assignments: Assignment[]): void {
+  if (!FEATURE_HARNESS) return;
+  const assignment = activeHarnessAssignment(assignments);
+  const manifestUrl = assignment?.harnessSession?.manifestUrl;
+  if (!manifestUrl) {
+    stopHarnessPolling();
+    return;
+  }
+
+  const intervalMs = Math.max(250, assignment.harnessSession?.pollIntervalMs ?? 750);
+  const nextKey = `${manifestUrl}:${intervalMs}`;
+  if (harnessPollKey === nextKey && harnessPollTimer !== null) return;
+
+  stopHarnessPolling();
+  harnessPollKey = nextKey;
+  pollHarnessManifest(manifestUrl);
+  harnessPollTimer = window.setInterval(() => pollHarnessManifest(manifestUrl), intervalMs);
+
+  if (!harnessVisibilityInstalled) {
+    harnessVisibilityInstalled = true;
+    document.addEventListener("visibilitychange", () => {
+      const current = activeHarnessAssignment(state.assignments);
+      if (!document.hidden && current?.harnessSession?.manifestUrl) {
+        pollHarnessManifest(current.harnessSession.manifestUrl);
+      }
+    });
+  }
+}
+
+
+export function getEventsEndpoint(config: InitConfig): string | undefined {
+  return config.endpoint
+    ? normalizeEndpoint(config.endpoint) + "/v1/events"
+    : undefined;
+}
+
+export async function mintBucketingHandoverPayload(
+  config: InitConfig,
+  visitorId: string,
+  assignments: Assignment[],
+): Promise<string | null> {
+  if (!config.shopId || !config.ingestSignature || config.externalTracking?.signed === false) {
+    return null;
+  }
+  if (!config.endpoint) return null;
+
+  const timeoutMs = handoverMintTimeoutMs(config.externalTracking);
+  const controller = new AbortController();
+  const timeoutId = window.setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${normalizeEndpoint(config.endpoint)}/v1/handover/mint`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Drip-Shop": config.ingestShopId || config.shopId,
+        "X-Drip-Signature": config.ingestSignature,
+      },
+      body: JSON.stringify({
+        visitorId,
+        ttlSeconds: config.externalTracking?.handoverTtlSeconds,
+        assignments: assignments.map((assignment) => ({
+          experimentId: assignment.experimentId,
+          variationId: assignment.variationId,
+        })),
+      }),
+      signal: controller.signal,
+      credentials: "omit",
+      keepalive: false,
+    });
+    if (!response.ok) return null;
+    const payload = await response.json() as { token?: unknown };
+    return typeof payload.token === "string" && payload.token ? payload.token : null;
+  } catch {
+    return null;
+  } finally {
+    window.clearTimeout(timeoutId);
+  }
+}
+
+export async function verifyBucketingHandoverToken(config: InitConfig, token: string): Promise<unknown> {
+  if (!config.shopId || !config.endpoint) return null;
+  const response = await fetch(`${normalizeEndpoint(config.endpoint)}/v1/handover/verify`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Drip-Shop": config.shopId,
+    },
+    body: JSON.stringify({ verifyToken: token }),
+    signal: AbortSignal.timeout(handoverMintTimeoutMs(config.externalTracking)),
+  });
+  if (!response.ok) return null;
+  return (await response.json() as { payload?: unknown }).payload;
+}
+
+export function clearScheduledAnalyticsStart(): void {
+  if (state.analyticsTimeoutId !== null) {
+    window.clearTimeout(state.analyticsTimeoutId);
+    state.analyticsTimeoutId = null;
+  }
+  const w = globalThis as Record<string, unknown>;
+  const cancelIdle = w.cancelIdleCallback;
+  if (state.analyticsIdleId !== null && typeof cancelIdle === "function") {
+    (cancelIdle as (id: number) => void)(state.analyticsIdleId);
+    state.analyticsIdleId = null;
+  }
+}
+
+export function normalizeDataLayerTriggers(config: InitConfig): DataLayerTriggerSettings[] {
+  return (config.dataLayerTriggers ?? []).filter((trigger) => trigger?.enabled !== false && Boolean(trigger.eventName));
+}
+
+export function applyDataLayerMappings(
+  eventPayload: Record<string, unknown>,
+  mappings: DataLayerSignalMapping[] | undefined,
+): string[] {
+  const mapped: string[] = [];
+  for (const mapping of mappings ?? []) {
+    if (!mapping?.from || !mapping.to) continue;
+    const value = coerceSignalValue(readPath(eventPayload, mapping.from), mapping.valueType);
+    if (value === undefined) continue;
+    setCapturedSignal(mapping.to, value, {
+      ttlDays: mapping.ttlDays,
+      persist: mapping.persist,
+      source: "data_layer",
+    });
+    mapped.push(mapping.to);
+  }
+  return mapped;
+}
+
+export function readNumericPath(payload: Record<string, unknown>, path: string | undefined): number | undefined {
+  const value = coerceSignalValue(readPath(payload, path), "number");
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function readStringPath(payload: Record<string, unknown>, path: string | undefined): string | undefined {
+  const value = coerceSignalValue(readPath(payload, path), "string");
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export const RESERVED_DATA_LAYER_REVENUE_KEYS = new Set([
+  "revenue",
+  "source",
+  "dataLayerEvent",
+  "orderId",
+  "currency",
+  "cost",
+  "profit",
+  "goalId",
+]);
+
+export type PendingDataLayerEvent = {
+  trigger: DataLayerTriggerSettings;
+  payload: Record<string, unknown>;
+  dataLayerName: string;
+  gtagNormalized: boolean;
+  rawItem: unknown;
+};
+
+export const MAX_PENDING_DATA_LAYER_EVENTS = 50;
+export const pendingDataLayerEvents: PendingDataLayerEvent[] = [];
+export const processedDataLayerEntries = new WeakSet<object>();
+
+export function isDataLayerEntryObject(item: unknown): item is object {
+  return item !== null && (typeof item === "object" || typeof item === "function");
+}
+
+export function markDataLayerEntryProcessed(item: unknown): void {
+  if (isDataLayerEntryObject(item)) processedDataLayerEntries.add(item);
+}
+
+export function trackDataLayerRevenue(trigger: DataLayerTriggerSettings, payload: Record<string, unknown>): void {
+  const settings = trigger.trackRevenue;
+  if (!settings || settings.enabled === false) return;
+
+  const revenue = readNumericPath(payload, settings.revenueFrom || "value");
+  if (revenue === undefined) return;
+
+  const eventData: Record<string, unknown> = {
+    source: "data_layer",
+    dataLayerEvent: trigger.eventName,
+  };
+  const orderId = readStringPath(payload, settings.orderIdFrom || "transaction_id");
+  const currency = readStringPath(payload, settings.currencyFrom || "currency");
+  const cost = readNumericPath(payload, settings.costFrom);
+  const profit = readNumericPath(payload, settings.profitFrom);
+  if (orderId) eventData.orderId = orderId;
+  if (currency) eventData.currency = currency;
+  if (cost !== undefined) eventData.cost = cost;
+  if (profit !== undefined) eventData.profit = profit;
+
+  for (const mapping of settings.properties ?? []) {
+    if (!mapping?.from || !mapping.to) continue;
+    if (RESERVED_DATA_LAYER_REVENUE_KEYS.has(mapping.to)) continue;
+    const value = coerceSignalValue(readPath(payload, mapping.from), mapping.valueType);
+    if (value !== undefined) eventData[mapping.to] = value;
+  }
+
+  trackRevenue(revenue, eventData);
+}
+
+export function trackDataLayerEvent(
+  trigger: DataLayerTriggerSettings,
+  payload: Record<string, unknown>,
+): void {
+  const trackEventName = typeof trigger.trackEventName === "string" && trigger.trackEventName.length > 0
+    ? trigger.trackEventName
+    : null;
+  if (trigger.trackPageview === true || trackEventName) {
+    track(trackEventName ?? "pageview", {
+      source: "data_layer",
+      dataLayerEvent: trigger.eventName,
+      ...payload,
+    });
+  }
+
+  trackDataLayerRevenue(trigger, payload);
+}
+
+export function enqueuePendingDataLayerEvent(event: PendingDataLayerEvent): void {
+  if (pendingDataLayerEvents.length >= MAX_PENDING_DATA_LAYER_EVENTS) {
+    pendingDataLayerEvents.shift();
+  }
+  pendingDataLayerEvents.push(event);
+}
+
+export function drainPendingDataLayerEvents(): void {
+  const queuedEvents = pendingDataLayerEvents.splice(0);
+  for (const event of queuedEvents) {
+    markDataLayerEntryProcessed(event.rawItem);
+    try {
+      trackDataLayerEvent(event.trigger, event.payload);
+      if (event.trigger.reEvaluate !== false) {
+        reevaluateAssignments("dom");
+      }
+    } catch (error) {
+      recordObserverError("data_layer", error);
+    }
+  }
+}
+
+export function finishInitializingAssignments(): void {
+  state.initializingAssignments = false;
+  if (state.tracker) drainPendingDataLayerEvents();
+}
+
+export function handleDataLayerEvent(
+  trigger: DataLayerTriggerSettings,
+  payload: Record<string, unknown>,
+  dataLayerName: string,
+  rawItem: unknown,
+  gtagNormalized = false,
+): void {
+  const mappedSignals = applyDataLayerMappings(payload, trigger.mappings);
+  state.lastDataLayerTrigger = {
+    eventName: trigger.eventName,
+    dataLayerName,
+    at: Date.now(),
+    mappedSignals,
+    ...(gtagNormalized ? { gtagNormalized: true } : {}),
+  };
+
+  if (state.initializingAssignments) {
+    enqueuePendingDataLayerEvent({
+      trigger,
+      payload,
+      dataLayerName,
+      gtagNormalized,
+      rawItem,
+    });
+    return;
+  }
+
+  markDataLayerEntryProcessed(rawItem);
+  trackDataLayerEvent(trigger, payload);
+
+  if (trigger.reEvaluate !== false) {
+    reevaluateAssignments("dom");
+  }
+}
+
+export function recordObserverError(source: "route" | "data_layer" | "dom", error: unknown): void {
+  const message = error instanceof Error ? error.message : String(error);
+  state.observerErrors = {
+    count: state.observerErrors.count + 1,
+    last: { source, message, at: Date.now() },
+  };
+  debugLog("spa", `${source} observer error`, { message });
+}
+