@drip-apex/sdk 0.1.0 → 0.3.0

package/src/public-api.ts

@@ -0,0 +1,1828 @@
+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 { 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";
+
+
+export function loadQaToolbar(experiments: Experiment[]): void {
+  if (!FEATURE_QA) return;
+  try {
+    import("./qa-toolbar").then(({ mountQaToolbar }) => {
+      mountQaToolbar({
+        experiments,
+        assignments: state.assignments,
+        forceMap: state.forceMap,
+        qaSessionId: state.qaSessionId,
+        onSwitchVariation: (experimentId: string, variationId: string) => {
+          if (!state.forceMap) state.forceMap = {};
+          state.forceMap[experimentId] = variationId;
+          persistQaForce(state.forceMap);
+          // Re-evaluate with new force map
+          if (state.config) {
+            const exps = state.config.experiments ?? [];
+            teardownTransaction(allAppliedPagesWithModes());
+            const evaluation = evaluateWithDiagnostics(exps, {
+              url: location.href,
+              attributes: state.config.attributes ?? {},
+              userId: state.userId!,
+              persistSignals: persistentStorageAllowed(),
+              storeOrigin: configuredStoreOrigins(state.config),
+              exclusionGroups: state.config.exclusionGroups,
+            });
+            state.assignments = evaluation.assignments;
+            state.activationDiagnostics.experiments = evaluation.diagnostics;
+            applyAssignments(state.assignments, state.activationMode);
+            state.lastAssignmentSignature = assignmentSignature(state.assignments);
+          }
+        },
+        onExitQa: () => {
+          exitQaMode();
+          location.reload();
+        },
+        onReloadLatest: () => {
+          const assignment = activeHarnessAssignment(state.assignments);
+          if (assignment?.harnessSession?.manifestUrl) {
+            pollHarnessManifest(assignment.harnessSession.manifestUrl);
+          }
+        },
+        onExitHarness: () => {
+          const url = new URL(location.href);
+          url.searchParams.delete("drip_harness");
+          history.replaceState(null, "", url.toString());
+          location.reload();
+        },
+      });
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("qa", "QA toolbar mounted");
+    }).catch(() => {
+      __DRIP_FEATURE_DEVTOOLS__ && debugWarn("qa", "QA toolbar module not available");
+    });
+  } catch {
+    // Dynamic import not supported — skip toolbar
+  }
+}
+
+export function loadQaAssistant(onUnavailable?: () => void): void {
+  if (!FEATURE_QA) {
+    onUnavailable?.();
+    return;
+  }
+  try {
+    import("./qa-assistant")
+      .then(({ mountQaAssistant }) => {
+        const view = mountQaAssistant();
+        if (!view) onUnavailable?.();
+      })
+      .catch(() => onUnavailable?.());
+  } catch {
+    // Dynamic import not supported — fall back to the legacy toolbar.
+    onUnavailable?.();
+  }
+}
+
+export function loadDevtoolsIfEnabled(experiments: Experiment[]): void {
+  if (!FEATURE_DEVTOOLS || state.screenshotMode || !persistentStorageAllowed()) return;
+  try {
+    import("./devtools").then(({ isDevtoolsEnabled }) => {
+      if (isDevtoolsEnabled()) loadDevtools(experiments);
+    }).catch(() => {});
+  } catch {
+    // Dynamic import not supported.
+  }
+}
+
+export function loadDevtools(experiments: Experiment[]): void {
+  if (!FEATURE_DEVTOOLS) return;
+  try {
+    import("./devtools").then(({ mountDevtools }) => {
+      mountDevtools({
+        experiments,
+        assignments: state.assignments,
+        diagnostics: getDiagnostics(),
+        forceMap: state.forceMap,
+        onForceVariation: (experimentId: string, variationId: string) => {
+          if (!state.forceMap) state.forceMap = {};
+          state.forceMap[experimentId] = variationId;
+          // Re-evaluate with new force map
+          if (state.config) {
+            const exps = state.config.experiments ?? [];
+            teardownTransaction(allAppliedPagesWithModes());
+            const evaluation = evaluateWithDiagnostics(exps, {
+              url: location.href,
+              attributes: state.config.attributes ?? {},
+              userId: state.userId!,
+              persistSignals: persistentStorageAllowed(),
+              storeOrigin: configuredStoreOrigins(state.config),
+              exclusionGroups: state.config.exclusionGroups,
+            });
+            state.assignments = evaluation.assignments;
+            state.activationDiagnostics.experiments = evaluation.diagnostics;
+            applyAssignments(state.assignments, state.activationMode);
+            state.lastAssignmentSignature = assignmentSignature(state.assignments);
+            // Re-mount devtools with updated state
+            import("./devtools").then(({ mountDevtools: remount }) => {
+              remount({
+                experiments: exps,
+                assignments: state.assignments,
+                diagnostics: getDiagnostics(),
+                forceMap: state.forceMap,
+                onForceVariation: () => {}, // Will be replaced on next full load
+              });
+            }).catch(() => {});
+          }
+        },
+      });
+      __DRIP_FEATURE_DEVTOOLS__ && debugLog("init", "Devtools overlay mounted");
+      __DRIP_FEATURE_DEVTOOLS__ && dtLog("init", "Devtools overlay mounted");
+    }).catch(() => {
+      __DRIP_FEATURE_DEVTOOLS__ && debugWarn("init", "Devtools module not available");
+    });
+  } catch {
+    // Dynamic import not supported — skip devtools
+  }
+}
+
+export function init(config: InitConfig): Assignment[] {
+  installGlobalApi();
+  markDripPerf("sdk_init_start");
+  runtimeSharedState.runtimeBootedTooLateForAntiFlicker ??= bootedTooLateForAntiFlicker();
+  if (
+    (config.runtimeFeatures?.sdkVariant === "live" || config.runtimeFeatures?.sdkVariant === "heatmap")
+    && loadDebugBuild(config.debug, config.snippetUrl ?? SDK_SCRIPT_SRC, () => init(config))
+  ) return [];
+  // `drip_force=clear` is an escape hatch and must run before cookie-backed QA
+  // detection so a poisoned reference tab cannot silently re-enter QA mode.
+  clearQaForceFromCurrentUrl();
+  // Remove redirect carry from the visible URL before any guard can return.
+  // Keep the original URL in memory so the normal init path can still validate
+  // and import the carry after consent and runtime guards have passed.
+  const initialPageUrl =
+    typeof location !== "undefined" ? location.href : undefined;
+  if (initialPageUrl) stripRedirectAssignmentCarry(initialPageUrl);
+
+  if (typeof window !== "undefined" && isEditorDevicePreview(window)) {
+    revealAll();
+    removeAntiFlicker();
+    return [];
+  }
+  if (interceptEditorLaunch({
+    configuredBundleUrl: config.editorBundleUrl,
+    scriptSrc: SDK_SCRIPT_SRC,
+    pageUrl: typeof location !== "undefined" ? location.href : undefined,
+    onBeforeLoad: () => {
+      revealAll();
+      removeAntiFlicker();
+    },
+    onFailure: () => {
+      init(config);
+    },
+  })) {
+    return [];
+  }
+
+  const perfContext = createInitPerfContext();
+  const earlyConsentRequired = resolveConsentRequired(config);
+  const earlyConsentGranted = resolveConsentGranted(config, earlyConsentRequired);
+  const earlyTrackingDisabledByDnt = doNotTrackEnabled(config);
+  const earlyStorageAllowed = storageAllowed(earlyConsentRequired, earlyConsentGranted, earlyTrackingDisabledByDnt);
+  configureIdentityStorage(earlyStorageAllowed ? config.dataProtection : { ...(config.dataProtection ?? {}), storageMode: "memory" });
+  const earlyUserId = config.userId ?? null;
+  configureDebug(config.debug, earlyUserId, { storageAllowed: earlyStorageAllowed });
+  // Guards
+  if (isDuplicate()) {
+    state.consentRequired = earlyConsentRequired;
+    state.consentGranted = earlyConsentGranted;
+    state.trackingDisabledByDnt = earlyTrackingDisabledByDnt;
+    state.screenshotMode = isScreenshotMode();
+    const firstInstall = readRuntimeInstallClaim();
+    const attemptedInstallSurface = telemetryLabel(config.installSurface, "direct_script");
+    if (
+      firstInstall
+      && firstInstall.installSurface !== attemptedInstallSurface
+      && claimInstallConflictEmission()
+    ) {
+      sendRuntimeEventNow(config, "sdk_install_conflict", {
+        first_install_surface: firstInstall.installSurface,
+        attempted_install_surface: attemptedInstallSurface,
+      }, earlyUserId);
+    }
+    return [];
+  }
+  rememberRuntimeInstallClaim(config);
+  if (isBot()) { __DRIP_FEATURE_DEVTOOLS__ && debugLog("guard", "Blocked: bot detected"); __DRIP_FEATURE_DEVTOOLS__ && dtLog("guard", "Blocked: bot detected"); return []; }
+  if (!config.spa?.allowIframes && isIframe()) { __DRIP_FEATURE_DEVTOOLS__ && debugLog("guard", "Blocked: iframe detected"); __DRIP_FEATURE_DEVTOOLS__ && dtLog("guard", "Blocked: iframe detected"); return []; }
+  if (isOptedOut({ storageAllowed: earlyStorageAllowed })) { __DRIP_FEATURE_DEVTOOLS__ && debugLog("guard", "Blocked: opted out"); __DRIP_FEATURE_DEVTOOLS__ && dtLog("guard", "Blocked: opted out"); return []; }
+
+  resetLoadDiagnostics("boot");
+  const runtimeConfig = resolveRuntimeConfig(config);
+  addInitPhase(perfContext, "guard_resolve_ms", perfContext.startedAt);
+
+  if (config.geo?.country) {
+    setRuntimeSignal("geo.country", config.geo.country, "edge");
+  }
+
+  // In edge-only mode, the client SDK should not evaluate or mutate.
+  if (runtimeConfig.executionMode === "edge") {
+    if (!edgeRuntimeActive() && typeof console !== "undefined") {
+      console.warn("[drip] executionMode='edge' but no edge runtime detected; skipping client init");
+    }
+    return [];
+  }
+
+  // Only a committed re-init resets the session attribution ledger. A guarded
+  // no-op init (bot, iframe, duplicate, edge) must not wipe labels the session
+  // already earned.
+  runtimeSharedState.attributionLedger.clear();
+
+  // Parse once before the visible URL is cleaned. A cached config may predate
+  // the redirect experiment or its assignment epoch, so the parsed carry must
+  // remain available to the authoritative network refresh.
+  const urlRedirectCarry = initialPageUrl
+    ? parseRedirectAssignmentCarry(initialPageUrl)
+    : null;
+  if (earlyStorageAllowed) {
+    persistPendingRedirectAssignmentCarry(urlRedirectCarry);
+  } else {
+    clearPendingRedirectAssignmentCarry();
+  }
+  const parsedRedirectCarry = urlRedirectCarry
+    ?? (earlyStorageAllowed ? readPendingRedirectAssignmentCarry() : null);
+  const verifiedRedirectCarryPromise =
+    parsedRedirectCarry && config.shopId && config.endpoint
+      ? verifyRedirectAssignmentCarry(
+          parsedRedirectCarry,
+          config.shopId,
+          (token) => verifyBucketingHandoverToken(config, token),
+        )
+      : Promise.resolve(null);
+
+  // If experiments are provided inline, use them directly. An empty array is a
+  // valid published project state and still needs analytics for install checks.
+  if (Array.isArray(config.experiments)) {
+    if (
+      (parsedRedirectCarry && config.shopId && config.endpoint) ||
+      (config.shopId && hasBucketingHandover(config.externalTracking))
+    ) {
+      const handoverPromise = config.shopId
+        ? readBucketingHandover(
+            config.externalTracking,
+            config.shopId,
+            (token) => verifyBucketingHandoverToken(config, token),
+          )
+        : Promise.resolve(null);
+      void Promise.all([
+        verifiedRedirectCarryPromise,
+        handoverPromise,
+      ]).then(([verifiedRedirectCarry, handover]) => {
+        initWithExperiments(
+          config,
+          config.experiments!,
+          "inline",
+          perfContext,
+          verifiedRedirectCarry,
+          handover,
+        );
+      });
+      return [];
+    }
+    const assignments = initWithExperiments(
+      config,
+      config.experiments,
+      "inline",
+      perfContext,
+    );
+    return assignments;
+  }
+
+  // If shopId is provided, fetch experiments from the API
+  if (config.shopId && config.endpoint) {
+    state.consentRequired = earlyConsentRequired;
+    state.consentGranted = earlyConsentGranted;
+    state.trackingDisabledByDnt = earlyTrackingDisabledByDnt;
+    const forceMap = parseForceParam();
+    const qaMode = isQaMode();
+    const screenshotMode = isScreenshotMode();
+    const serializedForceMap = serializeForceMap(forceMap);
+    const environmentKey = config.environments?.activeKey || "production";
+    const configUrl = new URL(normalizeEndpoint(config.endpoint) + "/config");
+    configUrl.searchParams.set("shopId", config.shopId);
+    if (environmentKey !== "production") {
+      configUrl.searchParams.set("env", environmentKey);
+    }
+    const qaRequested = qaMode || screenshotMode;
+    if (qaRequested) {
+      configUrl.searchParams.set("drip_qa", "1");
+      if (serializedForceMap) {
+        configUrl.searchParams.set("drip_force", serializedForceMap);
+        const harnessToken = new URLSearchParams(location.search).get("drip_harness");
+        if (harnessToken) {
+          configUrl.searchParams.set("drip_harness", harnessToken);
+        }
+      }
+    }
+    // QA responses are request-scoped and can contain diagnostics omitted from
+    // the ordinary cached config, so interactive QA always fetches fresh data.
+    const useConfigCache = earlyStorageAllowed && config.configCache !== false && !qaRequested;
+    const cacheTtlMs = getConfigCacheTtlMs(config);
+    const cached = useConfigCache
+      ? readCachedExperiments(config.shopId, cacheTtlMs, environmentKey)
+      : null;
+    let navigateDeferredCachedRedirect: (() => boolean) | null = null;
+    const handoverPromise = readBucketingHandover(
+      config.externalTracking,
+      config.shopId,
+      (token) => verifyBucketingHandoverToken(config, token),
+    );
+
+    if (cached) {
+      updateLoadDiagnostics({
+        stage: "config_cache_hit",
+        configFetchStatus: "idle",
+      });
+      const cachedConfig = cached.runtime
+        ? withRuntimeSettings(config, cached.runtime, cached.profile)
+        : { ...config, profile: cached.profile ?? config.profile };
+      if (cached.geo?.country && !config.geo?.country) {
+        setRuntimeSignal("geo.country", cached.geo.country, "edge");
+      }
+      // Cached applies used to be effectively instant, making flicker cover
+      // pointless — but under after_hydration (or a pre-init hold) the apply
+      // is deferred, so the configured anti-flicker must stay on or repeat
+      // visitors see the original DOM until the gate resolves.
+      const cachedApplyDeferred =
+        cachedConfig.spa?.applyTiming === "after_hydration" || hasMutationHold();
+      const initCachedConfig = (
+        verifiedHandover: Awaited<ReturnType<typeof readBucketingHandover>>,
+      ) => {
+        initWithExperiments(
+          {
+            ...cachedConfig,
+            storeOrigin: cached.storeOrigin ?? cachedConfig.storeOrigin,
+            storeOrigins: cached.storeOrigins ?? cachedConfig.storeOrigins,
+            antiFlickerMode: cachedApplyDeferred ? cachedConfig.antiFlickerMode : "off",
+            exclusionGroups: cached.exclusionGroups,
+            signals: cached.signals ?? config.signals,
+            commerce: cached.commerce,
+            geo: cached.geo ?? cachedConfig.geo,
+            holdout_v1_enabled: cached.holdout?.[0],
+            holdout_pct: cached.holdout?.[1],
+            holdout_config_updated_at: cached.holdout?.[2],
+          },
+          cached.experiments,
+          "cache",
+          perfContext,
+          cachedVerifiedRedirectCarry,
+          verifiedHandover,
+        );
+        const cachedRuntimeConfig = state.config;
+        const cachedRuntimeExperiments =
+          cachedRuntimeConfig?.experiments ?? cached.experiments;
+        if (!cachedRuntimeConfig) return;
+        const cachedRedirectPlan = planRedirectAssignment(
+          cachedRuntimeConfig,
+          cachedRuntimeExperiments,
+          state.assignments,
+        );
+        if (!cachedRedirectPlan) return;
+        // Cached init deliberately defers redirects until the authoritative
+        // refresh confirms them. Hold a full-page SDK guard for that bounded
+        // wait so the snippet's independent safety timeout cannot paint the
+        // source page before confirmation. Explicitly replace any shorter
+        // cached-init guard: applyAntiFlicker otherwise preserves its live
+        // timer rather than extending it.
+        removeAntiFlicker();
+        applyRuntimeAntiFlicker(
+          "full",
+          CACHED_REDIRECT_HIDE_TIMEOUT_MS,
+        );
+        navigateDeferredCachedRedirect = () => {
+          if (
+            state.config !== cachedRuntimeConfig ||
+            state.configSource !== "cache"
+          ) {
+            return false;
+          }
+          return navigateForRedirectAssignment(
+            cachedRuntimeConfig,
+            cachedRuntimeExperiments,
+            state.assignments,
+          );
+        };
+      };
+      let cachedVerifiedRedirectCarry: VerifiedRedirectCarry | null = null;
+      if (parsedRedirectCarry && config.shopId && config.endpoint) {
+        void Promise.all([
+          verifiedRedirectCarryPromise,
+          handoverPromise,
+        ]).then(([verifiedRedirectCarry, verifiedHandover]) => {
+          cachedVerifiedRedirectCarry = verifiedRedirectCarry;
+          initCachedConfig(verifiedHandover);
+        });
+      } else if (hasBucketingHandover(config.externalTracking)) {
+        void handoverPromise.then(initCachedConfig);
+      } else {
+        initCachedConfig(null);
+      }
+    }
+
+    // Always apply anti-flicker during async fetch to prevent FOUC. Forced QA
+    // fetches may not have scoped selectors until the fresh config arrives, so
+    // use a QA-only full-page guard instead of letting the page paint stale UI.
+    const asyncFetchAntiFlickerIntended = !cached && runtimeConfig.antiFlickerMode !== "off";
+    if (asyncFetchAntiFlickerIntended) {
+      const asyncFetchAntiFlickerMode =
+        runtimeConfig.antiFlickerMode === "scoped" && (qaMode || screenshotMode) && serializedForceMap
+          ? "full"
+          : runtimeConfig.antiFlickerMode;
+      applyRuntimeAntiFlicker(
+        asyncFetchAntiFlickerMode,
+        runtimeConfig.antiFlickerTimeoutMs,
+        undefined,
+        runtimeConfig.antiFlickerCustomCss,
+      );
+    }
+
+    const configFetchStartedAt = Date.now();
+    if (!cached) perfContext.includesConfigFetch = true;
+    const antiFlickerFetchBudgetMs = asyncFetchAntiFlickerIntended
+      ? Math.max(runtimeConfig.antiFlickerTimeoutMs, 300)
+      : null;
+    const hardRevealDeadline = antiFlickerFetchBudgetMs !== null
+      ? configFetchStartedAt + antiFlickerFetchBudgetMs
+      : null;
+    updateLoadDiagnostics({
+      stage: "config_fetch_started",
+      configFetchStartedAt,
+      configFetchAttempts: 0,
+      configFetchStatus: "loading",
+    });
+
+    fetchWithRetry(configUrl.toString(), CONFIG_FETCH_RETRY_COUNT, CONFIG_FETCH_RETRY_DELAY_MS, {
+      timeoutMs: DEFAULT_CONFIG_FETCH_TIMEOUT_MS,
+      firstAttemptTimeoutMs: antiFlickerFetchBudgetMs !== null
+        ? Math.min(DEFAULT_CONFIG_FETCH_TIMEOUT_MS, antiFlickerFetchBudgetMs)
+        : DEFAULT_CONFIG_FETCH_TIMEOUT_MS,
+      slowMs: DEFAULT_CONFIG_FETCH_SLOW_MS,
+      onAttemptStart: (attempt) => {
+        updateLoadDiagnostics({
+          stage: "config_fetch_attempt",
+          configFetchStartedAt,
+          configFetchAttempts: attempt,
+          configFetchStatus: attempt === 1 ? "loading" : state.load.configFetchStatus,
+        });
+      },
+      onSlow: ({ attempt, elapsedMs }) => {
+        updateLoadDiagnostics({
+          stage: "config_fetch_slow",
+          configFetchStartedAt,
+          configFetchAttempts: attempt,
+          configFetchMs: Date.now() - configFetchStartedAt,
+          configFetchStatus: "slow",
+        });
+        __DRIP_FEATURE_DEVTOOLS__ && debugWarn("init", `Config fetch attempt ${attempt} is slow after ${elapsedMs}ms`);
+      },
+      onAttemptEnd: (info) => {
+        updateLoadDiagnostics({
+          stage: "config_fetch_attempt_complete",
+          configFetchStartedAt,
+          configFetchAttempts: info.attempt,
+          configFetchMs: Date.now() - configFetchStartedAt,
+          configFetchStatus: info.timedOut ? "timeout" : state.load.configFetchStatus,
+          configFetchStatusCode: info.status,
+          configFetchError: info.error,
+        });
+      },
+    })
+      .then((res) => {
+        if (!res.ok) throw new Error("Failed to fetch config: " + res.status);
+        return res.json();
+      })
+      .then(async (data: {
+        experiments?: Experiment[];
+        storeOrigin?: string;
+        storeOrigins?: string[];
+        exclusionGroups?: ExclusionGroupConfig[];
+        profile?: InitConfig["profile"];
+        runtime?: unknown;
+        signals?: RuntimeSignalDefinition[];
+        commerce?: InitConfig["commerce"];
+        qa_warnings?: InitConfig["qa_warnings"];
+        holdout_v1_enabled?: boolean;
+        holdout_pct?: number;
+        holdout_config_updated_at?: string | null;
+        geo?: { country?: string };
+      }) => {
+        const [verifiedRedirectCarry, verifiedHandover] = await Promise.all([
+          verifiedRedirectCarryPromise,
+          handoverPromise,
+        ]);
+        const configFetchCompletedAt = Date.now();
+        updateLoadDiagnostics({
+          stage: "config_fetch_complete",
+          configFetchStartedAt,
+          configFetchCompletedAt,
+          configFetchMs: configFetchCompletedAt - configFetchStartedAt,
+          configFetchStatus: "ok",
+        });
+        const experiments = data.experiments ?? [];
+        const storeOrigin =
+          typeof data.storeOrigin === "string"
+            ? data.storeOrigin
+            : config.storeOrigin;
+        const storeOrigins = Array.isArray(data.storeOrigins)
+          ? data.storeOrigins.filter(
+              (origin): origin is string => typeof origin === "string",
+            )
+          : config.storeOrigins;
+        const exclusionGroups = Array.isArray(data.exclusionGroups)
+          ? data.exclusionGroups
+          : undefined;
+        const profile = data.profile;
+        const runtime = data.runtime;
+        const signals = Array.isArray(data.signals) ? data.signals : config.signals;
+        // Omission is authoritative: it represents an empty commerce plane and
+        // must clear any cached/active treatment rather than inherit init input.
+        const commerce = data.commerce;
+        const geo = data.geo;
+        const countryChanged = Boolean(
+          geo?.country && getStoredSignals({ markVisitorSeen: false })["geo.country"] !== geo.country,
+        );
+        if (geo?.country) setRuntimeSignal("geo.country", geo.country, "edge");
+        const configWithRuntime = {
+          ...withRuntimeSettings(config, runtime, profile),
+          storeOrigin,
+          storeOrigins,
+          exclusionGroups,
+          signals,
+          commerce,
+          qa_warnings: data.qa_warnings,
+          holdout_v1_enabled: data.holdout_v1_enabled,
+          holdout_pct: data.holdout_pct,
+          holdout_config_updated_at: data.holdout_config_updated_at,
+        };
+        const runtimeConsentRequired = resolveConsentRequired(configWithRuntime);
+        const runtimeStorageAllowed = storageAllowed(
+          runtimeConsentRequired,
+          resolveConsentGranted(configWithRuntime, runtimeConsentRequired),
+          doNotTrackEnabled(configWithRuntime),
+        );
+        if (useConfigCache && runtimeStorageAllowed) {
+          writeCachedExperiments(
+            config.shopId!,
+            experiments,
+            storeOrigin,
+            storeOrigins,
+            exclusionGroups,
+            profile,
+            runtime,
+            signals,
+            commerce,
+            data.holdout_v1_enabled,
+            data.holdout_pct,
+            data.holdout_config_updated_at,
+            geo,
+            environmentKey,
+          );
+        }
+        const incomingHash = hashConfigPayload(
+          experiments,
+          storeOrigin,
+          storeOrigins,
+          exclusionGroups,
+          profile,
+          runtime,
+          signals,
+          commerce,
+          data.holdout_v1_enabled,
+          data.holdout_pct,
+          data.holdout_config_updated_at,
+        );
+        const cacheUnchanged = cached && cached.hash && cached.hash === incomingHash && !countryChanged;
+        if (cacheUnchanged && !verifiedHandover) {
+          // The cached apply may still be gated behind hydration; revealing
+          // now would undo the anti-flicker kept for exactly that window.
+          // The gated applyAssignments() reveals when it runs.
+          const navigated = navigateDeferredCachedRedirect?.() ?? false;
+          if (!state.pendingInitialApply && !navigated) removeAntiFlicker();
+          return;
+        }
+        const lateConfigPolicy = ((qaMode || screenshotMode) && serializedForceMap)
+          ? "apply"
+          : config.lateConfigPolicy ?? "skip";
+        const arrivedAfterReveal = hardRevealDeadline !== null && configFetchCompletedAt > hardRevealDeadline;
+        if (arrivedAfterReveal && lateConfigPolicy === "skip") {
+          const elapsedMs = configFetchCompletedAt - configFetchStartedAt;
+          updateLoadDiagnostics({
+            stage: "late_config_skip",
+            configFetchStartedAt,
+            configFetchCompletedAt,
+            configFetchMs: elapsedMs,
+            configFetchStatus: "ok",
+          });
+          __DRIP_FEATURE_DEVTOOLS__ && dtLog("init", "late_config_skip", { elapsedMs });
+          removeAntiFlicker();
+          return;
+        }
+        // Remove the initial barrier before re-init. Preserve the configured
+        // mode so fetched non-commerce mutations get the same scoped hiding as
+        // inline mutations; commerce modules can add selectors to that scope.
+        removeAntiFlicker();
+        initWithExperiments(
+          configWithRuntime,
+          experiments,
+          "network",
+          cached ? createInitPerfContext() : perfContext,
+          verifiedRedirectCarry,
+          verifiedHandover,
+        );
+      })
+      .catch((err) => {
+        const configFetchCompletedAt = Date.now();
+        const error = err instanceof Error ? err.message : String(err);
+        updateLoadDiagnostics({
+          stage: "config_fetch_failed",
+          configFetchStartedAt,
+          configFetchCompletedAt,
+          configFetchMs: configFetchCompletedAt - configFetchStartedAt,
+          configFetchStatus: state.load.configFetchStatus === "timeout" ? "timeout" : "failed",
+          configFetchError: error,
+        });
+        if (typeof console !== "undefined") {
+          console.error("[drip] Failed to fetch experiments:", err);
+        }
+        sendRuntimePerfNow(config, {
+          perf_event_kind: "init",
+          assignment_ready_ms: 0,
+          // domContentLoadedEventStart - navigationStart. Keep the old alias
+          // for one release while Tinybird consumers move to the clear name.
+          dom_content_loaded_ms: getBlankScreenMs(),
+          blank_screen_ms: getBlankScreenMs(),
+          ...collectDeliveryTiming(numberPerf(readDripPerf(), "sdk_init_start"), SDK_SCRIPT_SRC),
+          sdk_variant: telemetryLabel(config.runtimeFeatures?.sdkVariant, "live"),
+          platform: resolvePlatform(config),
+          config_source: cached ? "cache" : "none",
+          config_fetch_status: state.load.configFetchStatus,
+          config_fetch_ms: state.load.configFetchMs,
+          config_fetch_attempts: state.load.configFetchAttempts,
+          config_fetch_error: error,
+          activation_mode: resolveActivationMode(config),
+          delivery_state: typeof config.deliveryState === "string" ? config.deliveryState : undefined,
+          script_cache_source: typeof config.scriptCacheSource === "string" ? config.scriptCacheSource : undefined,
+        }, earlyUserId);
+        // A cached treatment can still be waiting behind hydration. Keep its
+        // barrier on fetch failure; the gated apply reveals when it completes.
+        const navigated = navigateDeferredCachedRedirect?.() ?? false;
+        if (!state.pendingInitialApply && !navigated) removeAntiFlicker();
+      });
+
+    return []; // Assignments will be applied async
+  }
+
+  // No experiments and no shopId – just initialize tracker
+  const assignments = initWithExperiments(
+    config,
+    [],
+    "none",
+    perfContext,
+  );
+  return assignments;
+}
+
+export function trackEvent(
+  type: string,
+  data?: Record<string, unknown>,
+  experimentId?: string,
+  variationId?: string,
+  eventId?: string,
+  forceUnassigned = false,
+  timestamp?: number,
+): void {
+  if (state.screenshotMode) return;
+  if (trackingBlocked()) return;
+  if (state.pendingInitialApply) {
+    // A held SPA route still has the previous route's assignments in state.
+    // Replay every event after the gate, even when the tracker is already
+    // running, so attribution and goal evaluation use the refreshed route.
+    void state.pendingInitialApply.then(() => {
+      trackEvent(type, data, experimentId, variationId, eventId, forceUnassigned, timestamp);
+    });
+    return;
+  }
+  captureEventPropertySignals(type, data);
+  startAnalyticsIfReady();
+  if (!state.tracker) {
+    return;
+  }
+  const activeAssignment = forceUnassigned
+    ? undefined
+    : state.assignments.find(exposable) ?? state.assignments.find(attributable);
+  const resolvedExperimentId = forceUnassigned ? undefined : experimentId ?? activeAssignment?.experimentId;
+  const resolvedVariationId = forceUnassigned ? undefined : variationId ?? activeAssignment?.variationId;
+  // Empty types keep their existing quarantine path; normalizing them would
+  // silently invent a "custom_event" the customer never sent.
+  const wireType =
+    EVENT_TYPE_PATTERN.test(type) || !type.trim() ? type : normalizeEventName(type);
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("track", `${type}`, { experimentId: resolvedExperimentId, variationId: resolvedVariationId, data });
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("track", `${type}`, { experimentId: resolvedExperimentId, variationId: resolvedVariationId, ...data });
+  const event: TrackEvent = {
+    type: wireType,
+    data: withAssignmentEpochData(data, resolvedExperimentId, resolvedVariationId),
+    url: cleanUrl(),
+    experimentId: resolvedExperimentId,
+    variationId: resolvedVariationId,
+    event_id: eventId,
+    ts: timestamp,
+  };
+  state.tracker.track(event);
+  if (wireType !== "goal" && state.config) {
+    triggerGoalsForEvent(
+      wireType,
+      state.assignments.filter(attributable),
+      state.config.experiments ?? [],
+      data,
+    );
+  }
+}
+
+export function track(
+  type: string,
+  data?: Record<string, unknown>,
+  experimentId?: string,
+  variationId?: string,
+): void {
+  trackEvent(type, data, experimentId, variationId);
+}
+
+export function funnelStepStorageKey(stepName: string): string {
+  const path =
+    typeof location !== "undefined"
+      ? `${location.origin ?? ""}${location.pathname ?? ""}`
+      : "unknown";
+  return `drip:funnel_step:${path}:${stepName}`.slice(0, 240);
+}
+
+export function shouldTrackFunnelStep(stepName: string, oncePerSession: boolean): boolean {
+  if (!oncePerSession || typeof sessionStorage === "undefined") return true;
+  const key = funnelStepStorageKey(stepName);
+  try {
+    if (sessionStorage.getItem(key) === "1") return false;
+    sessionStorage.setItem(key, "1");
+  } catch {
+    return true;
+  }
+  return true;
+}
+
+/**
+ * Track a virtual funnel step that has no reliable browser event by default,
+ * such as a postcode form submit, embedded quiz step, or third-party handoff.
+ */
+export function trackStep(name: string, data?: Record<string, unknown>): void {
+  const stepName = name.trim().slice(0, 160);
+  if (!stepName) return;
+  if (state.screenshotMode || trackingBlocked()) return;
+  if (state.pendingInitialApply) {
+    // Virtual funnel steps can fire from data layers before the hydration
+    // gate creates the tracker. Replay after apply so the step is preserved
+    // and attributed to the refreshed assignment set.
+    void state.pendingInitialApply.then(() => {
+      trackStep(stepName, data);
+    });
+    return;
+  }
+  if (!state.tracker) return;
+  const oncePerSession = data?.oncePerSession !== false;
+  if (!shouldTrackFunnelStep(stepName, oncePerSession)) return;
+  const payload = { ...(data ?? {}) };
+  delete payload.oncePerSession;
+  track("funnel_step", {
+    ...payload,
+    source: "virtual_step",
+    step_name: stepName,
+    path: typeof location !== "undefined" ? location.pathname : undefined,
+  });
+}
+
+export function trackGoal(goalId: string, data?: Record<string, unknown>): void {
+  if (state.screenshotMode) return;
+  if (trackingBlocked()) return;
+  if (!state.config) return;
+  if (state.pendingInitialApply) {
+    // Goal wiring is installed after the gated initial apply; firing now
+    // would be a silent no-op. Replay once the gate opens, like track().
+    void state.pendingInitialApply.then(() => {
+      trackGoal(goalId, data);
+    });
+    return;
+  }
+  __DRIP_FEATURE_DEVTOOLS__ && debugLog("goal", `Triggering goal: ${goalId}`, data);
+  __DRIP_FEATURE_DEVTOOLS__ && dtLog("goal", `Goal: ${goalId}`, data as Record<string, unknown> | undefined);
+  triggerGoal(
+    goalId,
+    state.assignments.filter(attributable),
+    state.config.experiments ?? [],
+    data,
+  );
+}
+
+export function setConsent(granted: boolean): void {
+  state.consentGranted = Boolean(granted);
+  writeConsentCookie(state.consentGranted);
+  if (!state.consentGranted) {
+    clearEarlyInteractions();
+  }
+
+  if (!state.config) {
+    if (!state.consentGranted) clearConsentStorage();
+    return;
+  }
+  applyConsentStorageMode();
+  recheckPrerequisites();
+  // Stop live capture before the purge so discard teardown cannot restore replay progress.
+  if (!state.consentGranted) clearConsentStorage();
+  if (state.consentGranted) {
+    removeSdkCartMintTrigger();
+    syncActiveAssignmentToShopifyCart();
+    scheduleShopifyAssignmentSync();
+  }
+}
+
+export function hold(): number {
+  return holdMutations();
+}
+
+export function release(): number {
+  return releaseMutations();
+}
+
+export function hydrated(): void {
+  signalHydrated();
+}
+
+export function recheckPrerequisites(): void {
+  if (!state.config) return;
+  const experiments = state.config.experiments ?? [];
+  const emptyProjectFastPath = state.config.runtimeProfile === "empty_project"
+    && state.perfFlags.perf_empty_project_v1;
+  state.trackingPrerequisiteMet = emptyProjectFastPath || trackingAllowed(state.config);
+  syncStorefrontVitals();
+  if (!emptyProjectFastPath) updateProjectActivationDiagnostics(state.config);
+  reevaluateAssignments("prerequisite");
+
+  if (trackingBlocked() || !state.trackingPrerequisiteMet) {
+    stopAnalyticsStage();
+    return;
+  }
+
+  if (state.trackingStart === "idle") {
+    scheduleAnalyticsStart(state.config, experiments);
+  } else {
+    startAnalyticsStage(state.config, experiments);
+  }
+}
+
+export function reInit(forceReapply = false): Assignment[] {
+  if (!runtimeSharedState.clearingQaForceFromRoute) {
+    runtimeSharedState.clearingQaForceFromRoute = true;
+    try {
+      if (clearQaForceFromUrl()) {
+        location.reload();
+        return state.assignments;
+      }
+    } finally {
+      runtimeSharedState.clearingQaForceFromRoute = false;
+    }
+  }
+  const assignments = reevaluateAssignments("manual", forceReapply);
+  state.orderIdentityDetectionUrl = "";
+  state.orderIdentityDetection = undefined;
+  if (state.config) scheduleOrderIdentityBeacon(state.config);
+  return assignments;
+}
+
+/**
+ * Track a revenue/purchase event. Convenience method that fires a "purchase" event
+ * with revenue data for all active experiments.
+ *
+ * Usage: drip.trackRevenue(49.99) or drip.trackRevenue(49.99, { orderId: "123", currency: "EUR" })
+ */
+export type RevenueEventData = Record<string, unknown> & { currency?: string };
+
+export function normalizeRevenueCurrency(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const currency = value.trim().toUpperCase();
+  return /^[A-Z]{3}$/.test(currency) ? currency : undefined;
+}
+
+export function trackRevenue(revenue: number, data?: RevenueEventData): void {
+  if (typeof revenue !== "number" || !Number.isFinite(revenue) || revenue < 0) {
+    if (typeof console !== "undefined") {
+      console.warn("[drip] trackRevenue ignored invalid revenue; expected a finite, non-negative number");
+    }
+    return;
+  }
+  if (state.screenshotMode) return;
+  if (trackingBlocked()) return;
+  if (state.pendingInitialApply) {
+    // Initial and route hydration gates defer tracker creation/assignment
+    // refresh. Replay purchases after the gate so early checkout data-layer
+    // events are not dropped or attributed to stale assignments.
+    void state.pendingInitialApply.then(() => {
+      trackRevenue(revenue, data);
+    });
+    return;
+  }
+  if (!state.tracker) return;
+  const eventData: Record<string, unknown> = { ...data, revenue };
+  if (data && "currency" in data) {
+    const currency = normalizeRevenueCurrency(data.currency);
+    if (currency) {
+      eventData.currency = currency;
+    } else {
+      delete eventData.currency;
+      eventData.currency_raw = data.currency;
+      eventData.money_error = "invalid_currency";
+    }
+  }
+  // A purchase is one semantic event even though attribution fans it out to
+  // every active assignment. Sharing its ID lets program-level analytics
+  // collapse the fanout while assignment-scoped analytics retains each copy.
+  const eventId = createEventId();
+  // Fire for each clean, delivery-resolved experiment assignment. Preserve
+  // the purchase as an unassigned shop-level event while mutation delivery is
+  // pending rather than attaching it to a variant that may still roll back.
+  const attributableAssignments = state.assignments.filter(attributable);
+  if (attributableAssignments.length === 0) {
+    // Keep purchases that occurred while a real assignment was suppressed,
+    // plus both holdout-v1 cohorts, at shop scope. A visitor with no assignment
+    // under ordinary non-holdout bucketing remains silent as before.
+    if (state.assignments.length > 0 || state.config?.holdout_v1_enabled === true) {
+      trackEvent("goal", { ...eventData, goalId: "__revenue__" }, undefined, undefined, eventId, true);
+    }
+    return;
+  }
+  for (const a of attributableAssignments) {
+    trackEvent("goal", { ...eventData, goalId: "__revenue__" }, a.experimentId, a.variationId, eventId);
+  }
+}
+
+export function flush(): Promise<void> {
+  if (state.screenshotMode) return Promise.resolve();
+  const pendingApply = state.pendingInitialApply;
+  if (pendingApply) {
+    // Deferred public tracking callbacks are registered before the caller's
+    // flush(). Wait for the gate, then recurse so every replayed event has
+    // entered the tracker queue before the returned promise resolves.
+    return pendingApply.then(() => flush());
+  }
+  startAnalyticsIfReady();
+  return state.tracker ? state.tracker.flush() : Promise.resolve();
+}
+
+export function getAssignments(): Assignment[] {
+  return state.assignments;
+}
+
+export function buildCurrentCartAttributes(scopedInput: CartAttributeSyncInput | null): CartAttributeEntry[] {
+  if (scopedInput) {
+    return buildCartAttributeEntries(scopedInput)
+      .filter(({ key }) => key === "apex_assignments");
+  }
+  const input = buildSdkCartMintInput()
+    ?? buildActiveCartAttributeSyncInput();
+  return input ? buildCartAttributeEntries(input) : [];
+}
+
+export function getCartAttributes(): CartAttributeEntry[] {
+  return buildCurrentCartAttributes(buildScopedCartAttributeSyncInput());
+}
+
+export function getCartMetafields(options?: { namespace?: string }): CartMetafieldInput[] {
+  const input = buildActiveCartAttributeSyncInput();
+  if (!input) return [];
+  const namespace = normalizeCartMetafieldNamespace(options?.namespace);
+  return buildCartMetafieldInputs(input, namespace);
+}
+
+/** Return cart-metafield keys that must be deleted to clear the previous mirror. */
+export function getCartMetafieldStaleKeys(options?: { namespace?: string }): string[] {
+  const namespace = normalizeCartMetafieldNamespace(options?.namespace);
+  return collectCartMetafieldStaleKeys(getCartMetafields({ namespace }), namespace);
+}
+
+/** Replace entries supplied by the fresh Apex stamp while preserving valid cart attributes. */
+export function mergeCartAttributes(existing: unknown): CartAttributeEntry[] {
+  const scopedInput = buildScopedCartAttributeSyncInput();
+  const scopedActive = scopedInput !== null;
+  const fresh = buildCurrentCartAttributes(scopedInput);
+  const freshKeys = new Set(fresh.map((entry) => entry.key));
+  const replacedKeys = sdkCartMintAllowed() || scopedActive
+    ? APEX_CART_ATTRIBUTE_KEYS
+    : freshKeys;
+  const preserved: CartAttributeEntry[] = [];
+
+  for (const entry of Array.isArray(existing) ? existing : []) {
+    if (!entry || typeof entry !== "object") continue;
+    const { key, value } = entry as { key?: unknown; value?: unknown };
+    if (typeof key !== "string" || typeof value !== "string" || replacedKeys.has(key)) continue;
+    preserved.push({ key, value });
+  }
+
+  return [...preserved, ...fresh];
+}
+
+export function normalizedHeadlessCartToken(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const withoutQuery = value.trim().split("?", 1)[0] ?? "";
+  const token = withoutQuery.startsWith("gid://shopify/Cart/")
+    ? withoutQuery.slice("gid://shopify/Cart/".length)
+    : withoutQuery;
+  return token.length > 0 && token.length <= 4096 ? token : null;
+}
+
+/**
+ * Build cart attributes for a headless Shopify Storefront API cart.
+ *
+ * Integrator contract: pass the cart's full Storefront Cart GID (including its
+ * `?key=` secret), write every returned entry to that same cart, and verify the
+ * Storefront API mutation succeeded with no `userErrors`. Only then call
+ * {@link confirmCartAttributesWritten} with the same Cart GID. Returning signed
+ * attributes does not authorize treatment display or exposure by itself. An
+ * empty result is fail-closed and must not be replaced with unsigned attributes.
+ * Theme storefronts use the SDK-managed `/cart/update.js` path and do not call
+ * either headless API.
+ */
+export async function getSignedCartAttributes(
+  cartToken?: string,
+): Promise<CartAttributeEntry[]> {
+  const requiresCohortPin = requiresCommerceCohortPin();
+  const input = buildActiveCartAttributeSyncInput(requiresCohortPin);
+  if (!input) return [];
+  const headless = ensureHeadlessCartAuthorizationState();
+  const generation = ++headless.generation;
+  // A public headless write takes ownership from any SDK-managed theme sync
+  // that was still resolving when the integrator selected this cart.
+  runtimeSharedState.shopifyCartSyncGeneration += 1;
+  headless.confirmationPending = requiresCohortPin;
+  headless.pending = null;
+  if (requiresCohortPin) {
+    state.authorizedPriceAssignmentKeys?.clear();
+    state.authorizedShippingAssignmentKeys?.clear();
+    // A headless generation for a (possibly different) cart revokes the
+    // previous cart's offer grant and retires its rendered treatment — cart
+    // B was never stamped, so keeping cart A's offer DOM would show an offer
+    // Shopify will not charge if B's authorization or write fails.
+    revokeOffersDisplayAuthorization();
+    state.lastShopifyCartSync = {
+      at: Date.now(),
+      status: "pending",
+      assignmentCount: state.assignments.length,
+    };
+    cleanupCommercePrice();
+    cleanupCommerceShipping();
+  }
+  let priceAssignments: CartAssignment[] = [];
+  let shippingAssignments: CartAssignment[] = [];
+  let offersAssignments: CartAssignment[] = [];
+  let offersAdoptionAssignments: CartAssignment[] | null = null;
+  const entries = await buildSignedCartAttributeEntries({
+    ...input,
+    cartToken,
+    authorizePriceDisplayAssignments: (assignments) => {
+      priceAssignments = assignments;
+    },
+    authorizeShippingDisplayAssignments: (assignments) => {
+      shippingAssignments = assignments;
+    },
+    authorizeOffersDisplayAssignments: (assignments) => {
+      offersAssignments = assignments;
+    },
+    stageOffersAdoptionAssignments: (assignments) => {
+      offersAdoptionAssignments = assignments;
+    },
+  });
+  if (generation !== headless.generation) return [];
+  const normalizedCartToken = normalizedHeadlessCartToken(cartToken);
+  if (entries.length === 0 && requiresCohortPin) {
+    headless.confirmationPending = false;
+    state.lastShopifyCartSync = {
+      at: Date.now(),
+      status: "failed",
+      reason: "authorization_failed",
+      assignmentCount: state.assignments.length,
+    };
+    // Reconcile from the render plane instead of a hand-picked list; the cart
+    // step is skipped because this runs inside the cart-authorization path.
+    syncGlobalRuntimes({ skipCartSync: true });
+    return [];
+  }
+  if (entries.length > 0 && requiresCohortPin && normalizedCartToken) {
+    headless.pending = {
+      generation,
+      cartToken: normalizedCartToken,
+      priceAssignments,
+      shippingAssignments,
+      offersAssignments,
+      offersAdoptionAssignments,
+    };
+    // Authorization/adoption may rebuild commerce render state while the proof
+    // request resolves; keep the generated-but-unacknowledged state published.
+    // Reconcile from the render plane instead of a hand-picked list; the cart
+    // step is skipped because this runs inside the cart-authorization path.
+    syncGlobalRuntimes({ skipCartSync: true });
+  }
+  return entries;
+}
+
+/**
+ * Acknowledge that the latest signed headless cart attributes were persisted.
+ *
+ * Call this only after the Storefront API cart-attributes mutation succeeded
+ * and returned no `userErrors`. The Cart GID must match the one passed to the
+ * latest {@link getSignedCartAttributes} call. Stale-generation, mismatched,
+ * or repeated acknowledgements are no-ops and cannot grant or change display
+ * and exposure authorization. When a staged offer adoption can no longer
+ * apply, the acknowledgement is rejected (`false`) with retryable pending
+ * state and no authorization is granted.
+ *
+ * @returns `true` only when the latest matching acknowledgement was accepted.
+ */
+export function confirmCartAttributesWritten(cartToken?: string): boolean {
+  const normalizedCartToken = normalizedHeadlessCartToken(cartToken);
+  const headless = headlessCartAuthorizationState;
+  const pending = headless?.pending;
+  if (
+    !normalizedCartToken ||
+    !headless ||
+    !pending ||
+    pending.generation !== headless.generation ||
+    pending.cartToken !== normalizedCartToken
+  ) return false;
+
+  // The integrator has confirmed the stamped cart write — only now may a
+  // staged offers adoption reach display, persistence, and tracking. When the
+  // adoption can no longer apply (config changed between generation and
+  // acknowledgement), keep the pending state retryable, withhold every
+  // authorization grant, and tell the integrator the acknowledgement was NOT
+  // accepted so stale local assignments cannot be exposed as confirmed.
+  if (
+    pending.offersAdoptionAssignments &&
+    !adoptAuthoritativeOffersAssignments(pending.offersAdoptionAssignments)
+  ) {
+    state.lastShopifyCartSync = {
+      at: Date.now(),
+      status: "failed",
+      reason: "offers_adoption_failed",
+      assignmentCount: state.assignments.length,
+    };
+    return false;
+  }
+  headless.pending = null;
+  headless.confirmationPending = false;
+  state.authorizedPriceAssignmentKeys = new Set(
+    pending.priceAssignments.map(priceAssignmentAuthorizationKey),
+  );
+  state.authorizedShippingAssignmentKeys = new Set(
+    pending.shippingAssignments.map(priceAssignmentAuthorizationKey),
+  );
+  // Same render path as the theme flow: withheld offer companion DOM must
+  // appear once the integrator's write is acknowledged, or exposure could
+  // record a treatment whose DOM never rendered while Shopify charges it.
+  authorizeOffersDisplayAndRender(pending.offersAssignments);
+  state.lastShopifyCartSync = {
+    at: Date.now(),
+    status: "sent",
+    assignmentCount: state.assignments.length,
+  };
+  // Same rule as the authorization path: the acknowledged write republishes
+  // the render plane, never a page-independent assignment list.
+  syncGlobalRuntimes({ skipCartSync: true });
+  if (state.analyticsStarted && state.config && !trackingBlocked()) {
+    trackViewedAssignments(state.config);
+  }
+  return true;
+}
+
+export function getExperiments(): Experiment[] {
+  return state.config?.experiments ?? [];
+}
+
+export function getGoals(): Goal[] {
+  const seen = new Set<string>();
+  const goals: Goal[] = [];
+  for (const experiment of getExperiments()) {
+    for (const goal of experiment.goals ?? []) {
+      if (seen.has(goal.id)) continue;
+      seen.add(goal.id);
+      goals.push(goal);
+    }
+  }
+  return goals;
+}
+
+export function getActiveExperimentIds(): Record<string, string> {
+  const ids: Record<string, string> = {};
+  for (const assignment of state.assignments) {
+    ids[assignment.experimentId] = assignment.variationId;
+  }
+  return ids;
+}
+
+export function getRuntimeValue(key: string): unknown {
+  switch (key) {
+    case "tools":
+      return getRuntimeTools();
+    case "experiments":
+      return getExperiments();
+    case "goals":
+      return getGoals();
+    case "assignments":
+      return getAssignments();
+    case "activeAssignments":
+      return getAssignments();
+    case "activeExperimentIds":
+      return getActiveExperimentIds();
+    case "orderAttribution":
+      // Same consent chokepoint as the order-identity beacon: while tracking
+      // is blocked, no identity or assignments leave the SDK on any surface.
+      if (state.screenshotMode || trackingBlocked()) {
+        return { visitorId: "", assignments: [] };
+      }
+      return {
+        visitorId: state.userId ?? "",
+        assignments: mergedOrderIdentityAssignments(),
+        ...(state.shopwareAttributionEnvelope ? { envelope: state.shopwareAttributionEnvelope } : {}),
+      };
+    case "signals":
+      return getPublicSignals({ markVisitorSeen: false });
+    case "diagnostics":
+      return getDiagnostics();
+    case "data":
+      return {
+        initialized: Boolean(state.config),
+        shopId: state.config?.shopId ?? null,
+        experimentsLoaded: state.config?.experiments?.length ?? 0,
+      };
+    default:
+      return undefined;
+  }
+}
+
+export function getRuntimeTools(): ApexRuntimeTools {
+  return createApexRuntimeTools({
+    document: typeof document !== "undefined" ? document : undefined,
+    window: typeof window !== "undefined" ? window : undefined,
+    location: typeof location !== "undefined" ? location : undefined,
+    track,
+    trackGoal,
+    signal: setPublicSignal,
+    reInit,
+    get: getRuntimeValue,
+  });
+}
+
+export function buildFlagContext(
+  context?: { url?: string; attributes?: Record<string, unknown>; userId?: string },
+) {
+  const url = context?.url ?? (typeof location !== "undefined" ? location.href : "");
+  return {
+    url,
+    attributes: buildTargetingAttributes(
+      { ...(state.config?.attributes ?? {}), ...(context?.attributes ?? {}) },
+      url,
+      { persistSignals: persistentStorageAllowed() },
+    ),
+    userId: context?.userId ?? state.userId ?? undefined,
+    forceMap: state.forceMap ?? undefined,
+  };
+}
+
+export function evaluateFlag(
+  flagId: string,
+  context?: { url?: string; attributes?: Record<string, unknown>; userId?: string },
+): boolean {
+  return evaluateFlagFromExperiments(flagId, getExperiments(), buildFlagContext(context));
+}
+
+export function evaluateFlagAssignment(
+  flagId: string,
+  context?: { url?: string; attributes?: Record<string, unknown>; userId?: string },
+): Assignment | null {
+  return evaluateFlagAssignmentFromExperiments(
+    flagId,
+    getExperiments(),
+    buildFlagContext(context),
+  );
+}
+
+export function evaluateFlagValue<T = unknown>(
+  flagId: string,
+  fallback?: T,
+  context?: { url?: string; attributes?: Record<string, unknown>; userId?: string },
+): T | unknown {
+  return evaluateFlagValueFromExperiments(
+    flagId,
+    getExperiments(),
+    buildFlagContext(context),
+    fallback,
+  );
+}
+
+export function getDiagnostics(): SdkDiagnostics {
+  const config = state.config;
+  const runtimeConfig = state.runtimeConfig;
+  const storageMode = config?.dataProtection?.storageMode ?? "localStorage";
+  const signalDiagnostics = getSignalDiagnostics({ markVisitorSeen: persistentStorageAllowed() });
+  const diagnostics: SdkDiagnostics = {
+    mode: "public",
+    initialized: Boolean(config),
+    shopId: config?.shopId ?? null,
+    userIdPresent: Boolean(state.userId),
+    assignments: state.assignments.map((assignment) => {
+      const kind =
+        assignment.kind ??
+        (assignment.personalization
+          ? "personalization"
+          : assignment.featureFlag
+            ? "feature_flag"
+            : "experiment");
+      return {
+        experimentId: assignment.experimentId,
+        variationId: assignment.variationId,
+        kind,
+        isControl: assignment.isControl,
+        mutationCount: assignment.mutations.length,
+        featureFlagKey: assignment.featureFlag?.key,
+        personalizationKey: assignment.personalization?.key,
+        personalizationRuleId: assignment.personalization?.ruleId,
+        personalizationExperienceId: assignment.personalization?.experienceId,
+        personalizationSurface: assignment.personalization?.surface,
+        personalizationTemplateKey: assignment.personalization?.templateKey,
+        personalizationPriority: assignment.personalization?.priority,
+        personalizationStopAfterMatch: assignment.personalization?.stopAfterMatch,
+        value: assignment.value,
+      };
+    }),
+    pageActivation: pageActivationDiagnosticRows({
+      includePageNames: isDebugEnabled(),
+    }),
+    experimentsLoaded: config?.experiments?.length ?? 0,
+    analyticsStarted: state.analyticsStarted,
+    trackerStarted: Boolean(state.tracker),
+    activation: state.activationDiagnostics,
+    qaMode: state.qaMode,
+    qaSessionId: state.qaSessionId,
+    screenshotMode: state.screenshotMode,
+    configSource: state.configSource,
+    load: { ...state.load },
+    platform: state.platform,
+    routerMode: state.routerMode,
+    activationMode: state.activationMode,
+    storage: {
+      mode: storageMode,
+      localStorageAvailable: storageAvailable("localStorage"),
+      sessionStorageAvailable: storageAvailable("sessionStorage"),
+      cookiesEnabled: typeof navigator !== "undefined" ? navigator.cookieEnabled !== false : false,
+    },
+    runtime: {
+      antiFlickerMode: runtimeConfig?.antiFlickerMode,
+      antiFlickerTimeoutMs: runtimeConfig?.antiFlickerTimeoutMs,
+      trackingStart: runtimeConfig?.trackingStart,
+      pageTriggerMode: state.pageTriggerMode,
+      customJsPolicy: runtimeConfig?.customJsPolicy,
+      externalHandoverDomains: config?.externalTracking?.domains ?? [],
+      handoverQueryParam: config?.externalTracking?.handoverQueryParam ?? "drip_bucket",
+      handoverMintTimeoutMs: config?.externalTracking?.handoverMintTimeoutMs,
+      runtimeDisabled: config?.runtimeControl?.disabled === true,
+      runtimeDisabledAt: config?.runtimeControl?.disabledAt,
+    },
+    spa: {
+      lastUrl: state.lastUrl,
+      lastRouteChange: state.lastRouteChange ?? undefined,
+      lastDataLayerTrigger: state.lastDataLayerTrigger ?? undefined,
+      observerErrors: state.observerErrors,
+      lastShopifyAssignmentSync: state.lastShopifyAssignmentSync ?? undefined,
+      lastShopifyCartSync: state.lastShopifyCartSync ?? undefined,
+    },
+    signals: {
+      values: signalDiagnostics.values,
+      sources: signalDiagnostics.sources,
+    },
+    integrations: {
+      exposureDestinations: state.exposureDestinationDiagnostics,
+    },
+  };
+
+  if (isDebugEnabled()) {
+    diagnostics.mode = "debug";
+    diagnostics.trackingBlocked = trackingBlocked();
+    diagnostics.trackingDisabledByDnt = state.trackingDisabledByDnt;
+    diagnostics.trackingPrerequisiteMet = state.trackingPrerequisiteMet;
+    diagnostics.consentRequired = state.consentRequired;
+    diagnostics.consentGranted = state.consentGranted;
+    diagnostics.consentModeEnabled = state.consentModeEnabled;
+  }
+
+  return diagnostics;
+}
+
+export // --- Command queue ---
+type QueueCommand =
+  | { type: "trackGoal"; goalId: string; data?: Record<string, unknown> }
+  | { type: "trackRevenue"; revenue: number; data?: RevenueEventData }
+  | { type: "track"; event: string; data?: Record<string, unknown> }
+  | { type: "step"; name: string; data?: Record<string, unknown> }
+  | { type: "signal"; key: string; value: unknown; ttlDays?: number }
+  | { type: "triggerPage"; apiName: string; active?: unknown }
+  | { type: "rememberProduct"; product: Parameters<typeof rememberProduct>[0]; ttlDays?: number }
+  | { type: "setCart"; itemCount?: number; productIds?: string[]; ttlDays?: number }
+  | { type: "setSearch"; query: string; ttlDays?: number }
+  | { type: "setConsent"; granted: boolean }
+  | { type: "hold" }
+  | { type: "release" }
+  | { type: "hydrated" }
+  | { type: "reInit"; force?: boolean }
+  | { type: "recheckPrerequisites" }
+  | { type: "init"; config: InitConfig };
+
+export function processCommand(cmd: QueueCommand): void {
+  switch (cmd.type) {
+    case "init":
+      init(cmd.config);
+      break;
+    case "track":
+      track(cmd.event, cmd.data);
+      break;
+    case "step":
+      trackStep(cmd.name, cmd.data);
+      break;
+    case "trackGoal":
+      trackGoal(cmd.goalId, cmd.data);
+      break;
+    case "trackRevenue":
+      trackRevenue(cmd.revenue, cmd.data);
+      break;
+    case "signal":
+      setPublicSignal(cmd.key, cmd.value, cmd.ttlDays);
+      break;
+    case "triggerPage":
+      triggerPage(cmd.apiName, cmd.active);
+      break;
+    case "rememberProduct":
+      rememberProduct(cmd.product, cmd.ttlDays);
+      break;
+    case "setCart":
+      setCartSignals({ itemCount: cmd.itemCount, productIds: cmd.productIds }, cmd.ttlDays);
+      break;
+    case "setSearch":
+      setSearchSignal(cmd.query, cmd.ttlDays);
+      break;
+    case "setConsent":
+      setConsent(cmd.granted);
+      break;
+    case "hold":
+      hold();
+      break;
+    case "release":
+      release();
+      break;
+    case "hydrated":
+      hydrated();
+      break;
+    case "reInit":
+      reInit(cmd.force === true);
+      break;
+    case "recheckPrerequisites":
+      recheckPrerequisites();
+      break;
+  }
+}
+
+export function processQueue(): void {
+  const w = globalThis as Record<string, unknown>;
+  const pending = w.drip;
+  if (Array.isArray(pending)) {
+    for (const cmd of pending) {
+      processCommand(cmd as QueueCommand);
+    }
+  }
+  installGlobalApi();
+}
+
+export let installedGlobalApi: ReturnType<typeof createGlobalApi> | undefined;
+
+export function createGlobalApi() {
+  return Object.assign((command: string) => {
+    if (command === "hold") return hold();
+    if (command === "release") return release();
+    if (command === "hydrated") return hydrated();
+    __DRIP_FEATURE_DEVTOOLS__ && debugWarn("api", `Unknown command: ${command}`);
+  }, {
+    init,
+    track,
+    step: trackStep,
+    trackGoal,
+    trackRevenue,
+    setConsent,
+    hold,
+    release,
+    hydrated,
+    reInit,
+    recheckPrerequisites,
+    flush,
+    evaluate,
+    evaluateFlag,
+    evaluateFlagAssignment,
+    evaluateFlagValue,
+    signal: setPublicSignal,
+    triggerPage,
+    rememberProduct,
+    setCart: setCartSignals,
+    setSearch: setSearchSignal,
+    getSignals: getPublicSignals,
+    getAssignments,
+    getCartAttributes,
+    getCartMetafields,
+    getCartMetafieldStaleKeys,
+    mergeCartAttributes,
+    getSignedCartAttributes,
+    confirmCartAttributesWritten,
+    getExperiments,
+    getTools: getRuntimeTools,
+    get: getRuntimeValue,
+    getDiagnostics,
+    getPendingGiftChoices,
+    selectGiftOption,
+    push(cmd: QueueCommand) {
+      processCommand(cmd);
+    },
+  });
+}
+
+export function installGlobalApi(): void {
+  const w = globalThis as Record<string, unknown>;
+  if (installedGlobalApi !== undefined && w.drip === installedGlobalApi) {
+    w.Apex = installedGlobalApi;
+    w.apexTools = getRuntimeTools();
+    return;
+  }
+  const api = installedGlobalApi ??= createGlobalApi();
+  w.drip = api;
+  w.Apex = api;
+  w.apexTools = getRuntimeTools();
+}
+