@drip-apex/sdk 0.1.0 → 0.2.0

package/src/router.ts

@@ -3,29 +3,53 @@ import { RouterMode } from "./types";
 export type RouteChangeEvent = {
   previousUrl: string;
   nextUrl: string;
-  reason: "pushState" | "replaceState" | "popstate" | "hashchange" | "navigation";
+  reason: "pushState" | "replaceState" | "popstate" | "hashchange" | "navigation" | "polling";
 };
 
 type RouteObserver = (event: RouteChangeEvent) => void;
 
-function notifyIfChanged(
+export function notifyIfChanged(
   lastUrlRef: { value: string },
   reason: RouteChangeEvent["reason"],
   observer: RouteObserver,
+  onObserverError?: (error: unknown) => void,
 ): void {
   const next = location.href;
   if (next === lastUrlRef.value) return;
   const previous = lastUrlRef.value;
   lastUrlRef.value = next;
-  observer({ previousUrl: previous, nextUrl: next, reason });
+  try {
+    observer({ previousUrl: previous, nextUrl: next, reason });
+  } catch (error) {
+    onObserverError?.(error);
+  }
 }
 
-function observeHistoryChanges(observer: RouteObserver, lastUrlRef: { value: string }): () => void {
+export const PAGE_URL_POLL_INTERVAL_MS = 250;
+
+export function observePollingChanges(
+  observer: RouteObserver,
+  intervalMs = PAGE_URL_POLL_INTERVAL_MS,
+  lastUrlRef: { value: string } = { value: location.href },
+  onObserverError?: (error: unknown) => void,
+): () => void {
+  const timer = window.setInterval(
+    () => notifyIfChanged(lastUrlRef, "polling", observer, onObserverError),
+    intervalMs,
+  );
+  return () => window.clearInterval(timer);
+}
+
+function observeHistoryChanges(
+  observer: RouteObserver,
+  lastUrlRef: { value: string },
+  onObserverError?: (error: unknown) => void,
+): () => void {
   const wrap = (method: "pushState" | "replaceState") => {
     const original = history[method];
     history[method] = function (...args: Parameters<History["pushState"]>) {
       const ret = original.apply(this, args);
-      notifyIfChanged(lastUrlRef, method, observer);
+      notifyIfChanged(lastUrlRef, method, observer, onObserverError);
       return ret;
     };
     return () => {
@@ -35,8 +59,8 @@ function observeHistoryChanges(observer: RouteObserver, lastUrlRef: { value: str
 
   const restorePush = wrap("pushState");
   const restoreReplace = wrap("replaceState");
-  const popHandler = () => notifyIfChanged(lastUrlRef, "popstate", observer);
-  const hashHandler = () => notifyIfChanged(lastUrlRef, "hashchange", observer);
+  const popHandler = () => notifyIfChanged(lastUrlRef, "popstate", observer, onObserverError);
+  const hashHandler = () => notifyIfChanged(lastUrlRef, "hashchange", observer, onObserverError);
 
   window.addEventListener("popstate", popHandler);
   window.addEventListener("hashchange", hashHandler);
@@ -49,7 +73,11 @@ function observeHistoryChanges(observer: RouteObserver, lastUrlRef: { value: str
   };
 }
 
-function observeNavigationApi(observer: RouteObserver, lastUrlRef: { value: string }): () => void {
+function observeNavigationApi(
+  observer: RouteObserver,
+  lastUrlRef: { value: string },
+  onObserverError?: (error: unknown) => void,
+): () => void {
   const w = globalThis as Record<string, unknown>;
   const navigation = w.navigation as {
     addEventListener?: (type: string, listener: () => void) => void;
@@ -59,7 +87,7 @@ function observeNavigationApi(observer: RouteObserver, lastUrlRef: { value: stri
     return () => {};
   }
 
-  const listener = () => notifyIfChanged(lastUrlRef, "navigation", observer);
+  const listener = () => notifyIfChanged(lastUrlRef, "navigation", observer, onObserverError);
   navigation.addEventListener("navigate", listener);
 
   return () => {
@@ -72,6 +100,7 @@ function observeNavigationApi(observer: RouteObserver, lastUrlRef: { value: stri
 export function observeRouteChanges(
   mode: RouterMode,
   observer: RouteObserver,
+  options: { pollingIntervalMs?: number; onObserverError?: (error: unknown) => void } = {},
 ): () => void {
   if (mode === "none") return () => {};
 
@@ -79,11 +108,20 @@ export function observeRouteChanges(
   const cleanups: Array<() => void> = [];
 
   if (mode === "navigation") {
-    cleanups.push(observeNavigationApi(observer, lastUrlRef));
+    cleanups.push(observeNavigationApi(observer, lastUrlRef, options.onObserverError));
+  }
+
+  if (mode === "history" || mode === "navigation" || mode === "polling") {
+    cleanups.push(observeHistoryChanges(observer, lastUrlRef, options.onObserverError));
   }
 
-  if (mode === "history" || mode === "navigation") {
-    cleanups.push(observeHistoryChanges(observer, lastUrlRef));
+  if (mode === "polling" || options.pollingIntervalMs !== undefined) {
+    cleanups.push(observePollingChanges(
+      observer,
+      options.pollingIntervalMs ?? PAGE_URL_POLL_INTERVAL_MS,
+      lastUrlRef,
+      options.onObserverError,
+    ));
   }
 
   return () => {

package/src/runtime-state.ts

@@ -0,0 +1,507 @@
+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 type {
+  HeatmapController, SemanticController, UrlDiffNeeds, PendingPerfEvent, ConfigSource,
+  ResolvedRuntimeConfig, RouteDiagnostic, DataLayerDiagnostic, ShopifySyncDiagnostic,
+  ShopifyAssignmentSyncDiagnostic,
+  ExposureDestinationDiagnostic, PageRuleReconcileScope, RuntimeLoadDiagnostic, PageDetectorMode,
+} from "./config-runtime";
+
+// Shared runtime state. Owners: config, analytics, assignment, activation, and public API seams.
+export type OrderIdentityPlatform =
+  | "shopify"
+  | "shopware"
+  | "woocommerce"
+  | "centra"
+  | "custom";
+
+export type SDKState = {
+  config: InitConfig | null;
+  userId: string | null;
+  tracker: Tracker | null;
+  assignments: Assignment[];
+  pageActivation: Map<string, PageActivationRuntimeState>;
+  stopObserver: (() => void) | null;
+  stopDomObserver: (() => void) | null;
+  stopHandover: (() => void) | null;
+  heatmapController: HeatmapController | null;
+  replayController: ReplayController | null;
+  replayStartPromise: Promise<void> | null;
+  replayGeneration: number;
+  semanticController: SemanticController | null;
+  forceMap: Record<string, string> | null;
+  forcedUnavailable: Array<{
+    experimentId: string;
+    reason: "archived" | "runtime_disabled" | "not_found" | "environment_mismatch" | "not_in_config";
+  }>;
+  edgeDeviceAudienceUnsupported: Array<{
+    experimentId: string;
+    audienceName: string;
+  }>;
+  analyticsStarted: boolean;
+  trackingStart: TrackingStart;
+  trackingIdleTimeoutMs: number;
+  consentRequired: boolean;
+  consentGranted: boolean;
+  consentModeEnabled: boolean;
+  trackingPrerequisiteMet: boolean;
+  variationPrerequisiteMet: boolean;
+  activationDiagnostics: ActivationDiagnostics;
+  trackingDisabledByDnt: boolean;
+  holdout: boolean;
+  analyticsTimeoutId: number | null;
+  analyticsIdleId: number | null;
+  qaMode: boolean;
+  qaSessionId: string;
+  screenshotMode: boolean;
+  platform: PlatformHint;
+  routerMode: RouterMode;
+  activationMode: ActivationMode;
+  perfFlags: PerfFlagState;
+  urlDiffNeeds: UrlDiffNeeds;
+  lastUrl: string;
+  lastAssignmentSignature: string;
+  wiredGoalKeys: Set<string>;
+  wiredGoalUrl: string | null;
+  pendingPerf: PendingPerfEvent | null;
+  configSource: ConfigSource;
+  runtimeConfig: ResolvedRuntimeConfig | null;
+  pageTriggerMode: PageTriggerMode;
+  stopSignalCaptures: (() => void) | null;
+  stopSurfaceSignals: (() => void) | null;
+  stopJsTriggerSignals: (() => void) | null;
+  stopDataLayerTriggers: (() => void) | null;
+  stopConsentListeners: (() => void) | null;
+  stopShopifyCartMutationSync: (() => void) | null;
+  lastRouteChange: RouteDiagnostic | null;
+  lastDataLayerTrigger: DataLayerDiagnostic | null;
+  observerErrors: {
+    count: number;
+    last?: { source: "route" | "data_layer" | "dom"; message: string; at: number };
+  };
+  deferredRouteReevaluationTimer: number | null;
+  lastShopifyAssignmentSync: ShopifyAssignmentSyncDiagnostic | null;
+  lastShopifyCartSync: ShopifySyncDiagnostic | null;
+  shopifyCartToken: string | null;
+  shopwareAttributionEnvelope: string | null;
+  exposureDestinationDiagnostics: ExposureDestinationDiagnostic[];
+  exposedAssignmentKeys: Set<string>;
+  mutationPendingAssignmentKeys: Set<string>;
+  contaminatedAssignmentKeys: Set<string>;
+  authorizedPriceAssignmentKeys: Set<string> | null;
+  authorizedShippingAssignmentKeys: Set<string> | null;
+  authorizedOffersAssignmentKeys: Set<string> | null;
+  initializingAssignments: boolean;
+  pendingInitialApply: Promise<void> | null;
+  queuedRecheck: {
+    reason: "url" | "dom" | "manual" | "prerequisite";
+    forceReapply: boolean;
+    pageRuleScope?: PageRuleReconcileScope;
+  } | null;
+  redirectNavigationPending: boolean;
+  routeAnalyticsGeneration: number;
+  /** Re-entrancy guard and unwind-drain flag for `reevaluateAssignments`. */
+  reconcileInProgress: boolean;
+  reconcilePending: boolean;
+  pendingDeliveryHealth: TrackEvent[];
+  load: RuntimeLoadDiagnostic;
+  orderIdentityInFlight: Set<string>;
+  orderIdentityDetectionUrl: string;
+  orderIdentityDetection: {
+    platform: OrderIdentityPlatform;
+    platformOrderId: string | null;
+    orderNumber: string | null;
+  } | null | undefined;
+  carryImportedAssignmentKeys: Set<string>;
+};
+
+export type QaAssistantRuntimeSnapshot = {
+  config: InitConfig | null;
+  assignments: Assignment[];
+  activationDiagnostics: ActivationDiagnostics;
+  pageActivation: PageActivationDiagnostic[];
+  goalScopeUrl: string | null;
+  forceMap: Record<string, string> | null;
+  forcedUnavailable: Array<{
+    experimentId: string;
+    reason: "archived" | "runtime_disabled" | "not_found" | "environment_mismatch" | "not_in_config";
+  }>;
+  edgeDeviceAudienceUnsupported: Array<{
+    experimentId: string;
+    audienceName: string;
+  }>;
+  platform: PlatformHint;
+  qaMode: boolean;
+  orderIdentity: {
+    platform: OrderIdentityPlatform;
+    platformOrderId: string | null;
+    orderNumber: string | null;
+  } | null;
+};
+
+export type PageActivationRuntimeState = {
+  active: boolean;
+  appliedKeys: Set<string>;
+  /** Goal-scope state only; never participates in render transitions. */
+  scopeOnly?: boolean;
+  configuredMode?: PageDeactivationMode;
+  lastTransitionMode?: PageDeactivationMode;
+  isolationFallback?: "whole_experiment";
+  isolationFallbackExperimentId?: string;
+  triggerDetector?: PageDetectorMode;
+  triggerPollAttempts?: number;
+  triggerOutcome?: "activated" | "condition_failed" | "window_expired";
+  triggerElapsedMs?: number;
+};
+
+export type PageRulePollController = {
+  intervalId: number;
+  startedAt: number;
+};
+
+export const runtimeSharedState = {
+  runtimeBootedTooLateForAntiFlicker: null as boolean | null,
+  stopEarlyReassert: null as (() => void) | null,
+  earlyReassertTeardownTimer: null as ReturnType<typeof setTimeout> | null,
+  storefrontVitalsContext: null as StorefrontVitalsContext | null,
+  initialPredecidedByExperiment: null as Map<string, string> | null,
+  shopifyCartSyncGeneration: 0,
+  // Owners: config and activation seams.
+  pageDetectorRules: new Map<PageDetectorMode, PageTargetingRule[]>(),
+  pageDetectorLastUrls: new Map<string, string>(),
+  pageRulePollControllers: new Map<string, PageRulePollController>(),
+  // Owners: activation and public API seams.
+  qaAssistantRuntimeListeners: new Set<() => void>(),
+  clearingQaForceFromRoute: false,
+  // Owners: analytics and assignment seams.
+  attributionLedger: new Map<string, Assignment>(),
+};
+
+// Shared SDK lifecycle state. Owners: all runtime seams.
+export const state: SDKState = {
+  config: null,
+  userId: null,
+  tracker: null,
+  assignments: [],
+  pageActivation: new Map(),
+  stopObserver: null,
+  stopDomObserver: null,
+  stopHandover: null,
+  heatmapController: null,
+  replayController: null,
+  replayStartPromise: null,
+  replayGeneration: 0,
+  semanticController: null,
+  forceMap: null,
+  forcedUnavailable: [],
+  edgeDeviceAudienceUnsupported: [],
+  analyticsStarted: false,
+  trackingStart: "idle",
+  trackingIdleTimeoutMs: 2000,
+  consentRequired: false,
+  consentGranted: true,
+  consentModeEnabled: false,
+  trackingPrerequisiteMet: true,
+  variationPrerequisiteMet: true,
+  activationDiagnostics: {
+    project: { gates: [] },
+    experiments: [],
+  },
+  trackingDisabledByDnt: false,
+  holdout: false,
+  analyticsTimeoutId: null,
+  analyticsIdleId: null,
+  qaMode: false,
+  qaSessionId: "",
+  screenshotMode: false,
+  platform: "auto",
+  routerMode: "history",
+  activationMode: "observer",
+  perfFlags: readPerfFlags({}),
+  urlDiffNeeds: { path: false, search: false, hash: false },
+  lastUrl: "",
+  lastAssignmentSignature: "none",
+  wiredGoalKeys: new Set(),
+  wiredGoalUrl: null,
+  pendingPerf: null,
+  configSource: "none",
+  runtimeConfig: null,
+  pageTriggerMode: "direct",
+  stopSignalCaptures: null,
+  stopSurfaceSignals: null,
+  stopJsTriggerSignals: null,
+  stopDataLayerTriggers: null,
+  stopConsentListeners: null,
+  stopShopifyCartMutationSync: null,
+  lastRouteChange: null,
+  lastDataLayerTrigger: null,
+  observerErrors: { count: 0 },
+  deferredRouteReevaluationTimer: null,
+  lastShopifyAssignmentSync: null,
+  lastShopifyCartSync: null,
+  shopifyCartToken: null,
+  shopwareAttributionEnvelope: null,
+  exposureDestinationDiagnostics: [],
+  exposedAssignmentKeys: new Set(),
+  mutationPendingAssignmentKeys: new Set(),
+  contaminatedAssignmentKeys: new Set(),
+  authorizedPriceAssignmentKeys: null,
+  authorizedShippingAssignmentKeys: null,
+  authorizedOffersAssignmentKeys: null,
+  initializingAssignments: false,
+  pendingInitialApply: null,
+  queuedRecheck: null,
+  redirectNavigationPending: false,
+  routeAnalyticsGeneration: 0,
+  reconcileInProgress: false,
+  reconcilePending: false,
+  pendingDeliveryHealth: [],
+  load: { stage: "idle", configFetchStatus: "idle" },
+  orderIdentityInFlight: new Set(),
+  orderIdentityDetectionUrl: "",
+  orderIdentityDetection: undefined,
+  carryImportedAssignmentKeys: new Set(),
+};