@drip-apex/sdk 0.1.0

package/dist/types/mutate.d.ts

@@ -0,0 +1,34 @@
+import { Mutation, MutationAction } from "./types";
+export type ApplyOptions = {
+    root?: Document | HTMLElement;
+    onApplied?: (mutation: Mutation, element: Element, index: number) => void;
+    onMiss?: (mutation: Mutation, index: number) => void;
+};
+export declare function isSafeMutationAttribute(name: string, value: string | null): boolean;
+export declare function normalizeCssPropertyName(name: string): string;
+export declare function getMutationKey(mutation: Mutation, index: number): string;
+export declare function isInsertAction(action: MutationAction): boolean;
+export declare function applyToElement(mutation: Mutation, element: Element): void;
+export declare function isInsertDuplicate(element: Element, key: string): boolean;
+export declare function markInserted(el: Element, key: string): void;
+export declare function applyTrackedMutation(mutation: Mutation, element: Element, key?: string): Element | null;
+export declare function matchesOriginalInnerHtmlSnapshot(element: Element, current: string): boolean;
+export declare function applyMutations(mutations: Mutation[], options?: ApplyOptions): void;
+export declare function reassertNonStructuralMutations(mutations: Mutation[], options?: ApplyOptions): void;
+export declare function resetAppliedMutations(): void;
+export type MutationApplicationContext = {
+    apply: (mutations: Mutation[], options?: ApplyOptions) => void;
+    rollback: () => void;
+    readonly snapshotCount: number;
+};
+/**
+ * Owns only the DOM snapshots created through this context. Rolling it back
+ * restores the state that existed immediately before its mutations, without
+ * touching shopper assignment mutations tracked by the main SDK runtime.
+ */
+export declare function createMutationApplicationContext(): MutationApplicationContext;
+/** @internal — exposed for unit testing only. Tree-shaken from production build. */
+export declare const __test: {
+    normalizeCssPropertyName: typeof normalizeCssPropertyName;
+};
+export declare function observeSpaNavigation(onChange: () => void): () => void;

package/dist/types/observer-mute.d.ts

@@ -0,0 +1,3 @@
+export declare function registerMutedObserver(observer: MutationObserver, callback?: MutationCallback): void;
+export declare function unregisterMutedObserver(observer: MutationObserver): void;
+export declare function runMuted<T>(fn: () => T): T;

package/dist/types/pii-keys.d.ts

@@ -0,0 +1 @@
+export declare function containsPiiToken(key: string): boolean;

package/dist/types/prerequisites.d.ts

@@ -0,0 +1,12 @@
+import type { InitConfig } from "./types";
+type PrerequisiteContext = {
+    type: "show_variations" | "start_tracking";
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string | null;
+    consentRequired: boolean;
+    consentGranted: boolean;
+};
+export declare function evaluateProjectPrerequisite(rule: string | undefined, context: PrerequisiteContext, fallback: boolean): boolean;
+export declare function buildPrerequisiteContext(config: InitConfig, userId: string | null, consentRequired: boolean, consentGranted: boolean, type: PrerequisiteContext["type"]): PrerequisiteContext;
+export {};

package/dist/types/qa-assistant-state.d.ts

@@ -0,0 +1,68 @@
+export type QaExperimentModel = {
+    id: string;
+    name: string;
+    variationId: string | null;
+    variationName: string | null;
+    applied: boolean;
+    forced: boolean;
+    subline: string;
+    triggerPill: "accepted" | "rejected" | "not evaluated" | "all pages";
+    segmentPill: "accepted" | "rejected" | "not evaluated" | "all visitors";
+    displayFrequencyPill: "accepted" | "outside traffic %" | "personalization stop" | "excluded by overlap" | "not running" | "not evaluated" | "forced";
+    conditions: Array<{
+        id: string;
+        group: "pages" | "audience";
+        state: "pass" | "fail" | "skip" | "error";
+        text: string;
+        detail: string | null;
+        rawCode: string | null;
+    }>;
+    variations: Array<{
+        id: string;
+        name: string;
+        isControl: boolean;
+        isCurrent: boolean;
+        isReal: boolean;
+    }>;
+};
+export type QaEventModel = {
+    at: number;
+    type: "exposure" | "goal" | "revenue" | "pageview";
+    label: string;
+    value: string | null;
+    duplicateOf?: number;
+};
+export type QaTransactionsModel = {
+    kind: "unsupported";
+} | {
+    kind: "shopify";
+    cartStamped: boolean;
+    variationName: string | null;
+    stampedAt: number | null;
+    attribution: Array<{
+        experimentName: string;
+        variationName: string | null;
+    }>;
+} | {
+    kind: "order";
+    orderNumber: string | null;
+    attribution: Array<{
+        experimentName: string;
+        variationName: string | null;
+    }>;
+    serverReceipt: "pending" | "confirmed" | "unknown";
+};
+export type QaAssistantState = {
+    experiments: QaExperimentModel[];
+    events: QaEventModel[];
+    transactions: QaTransactionsModel;
+    forcedSummary: string | null;
+};
+export type QaAssistantStore = {
+    getState(): QaAssistantState;
+    subscribe(listener: (s: QaAssistantState) => void): () => void;
+    forceVariation(experimentId: string, variationId: string): void;
+    resetForce(experimentId?: string): void;
+    exitQa(): void;
+};
+export declare function createQaAssistantStore(): QaAssistantStore;

package/dist/types/qa-assistant-view.d.ts

@@ -0,0 +1,6 @@
+import type { QaAssistantStore } from "./qa-assistant-state";
+export declare const QA_ASSISTANT_HOST_ID = "drip-qa-assistant-host";
+export type QaAssistantView = {
+    destroy(): void;
+};
+export declare function mountQaAssistantView(store: QaAssistantStore): QaAssistantView;

package/dist/types/qa-assistant.d.ts

@@ -0,0 +1,9 @@
+import { type QaAssistantStore } from "./qa-assistant-state";
+import { type QaAssistantView } from "./qa-assistant-view";
+/**
+ * Mounts the QA Assistant panel (store + shadow-DOM view). QA-only module:
+ * live/heatmap builds stub this file out entirely (see build.mjs), and the
+ * caller in index.ts additionally gates on QA mode.
+ */
+export declare function mountQaAssistant(): QaAssistantView | null;
+export declare function getQaAssistantStore(): QaAssistantStore;

package/dist/types/qa-toolbar.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QA Toolbar — floating in-page toolbar for QA preview sessions.
+ *
+ * Renders inside a Shadow DOM to avoid style interference with the host page.
+ * Shows active experiments, variation switcher, and exit QA button.
+ */
+import { Assignment, Experiment } from "./types";
+export interface QaToolbarOptions {
+    experiments: Experiment[];
+    assignments: Assignment[];
+    forceMap: Record<string, string> | null;
+    qaSessionId?: string;
+    onSwitchVariation: (experimentId: string, variationId: string) => void;
+    onExitQa: () => void;
+    onReloadLatest?: () => void;
+    onExitHarness?: () => void;
+}
+export declare function mountQaToolbar(options: QaToolbarOptions): void;
+export declare function unmountQaToolbar(): void;

package/dist/types/react/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * React bindings for Drip SDK.
+ *
+ * Usage:
+ *   import { DripProvider, useExperiment, useVariation, useFeatureFlag, useFeatureFlagValue, useTrackGoal } from "@drip-apex/sdk/react";
+ *
+ *   function App() {
+ *     return (
+ *       <DripProvider shopId="shop_xxx" endpoint="https://events.drip-apex.com">
+ *         <HeroSection />
+ *       </DripProvider>
+ *     );
+ *   }
+ *
+ *   function HeroSection() {
+ *     const assignment = useExperiment("hero-test");
+ *     const variation = useVariation("hero-test");
+ *     const isDarkMode = useFeatureFlag("dark-mode-rollout");
+ *     const offerCopy = useFeatureFlagValue("offer-copy", "Default offer");
+ *     const trackGoal = useTrackGoal();
+ *
+ *     return (
+ *       <div>
+ *         <h1>{variation?.id === "variant-a" ? "New headline" : "Default headline"}</h1>
+ *         <button onClick={() => trackGoal("cta-click")}>CTA</button>
+ *       </div>
+ *     );
+ *   }
+ */
+import { type ReactNode } from "react";
+import type { Assignment, InitConfig, Variation } from "../types";
+export interface DripProviderProps extends Omit<InitConfig, "onExperimentViewed"> {
+    children: ReactNode;
+    /** Callback when an experiment is viewed (assignment applied). */
+    onExperimentViewed?: (assignment: Assignment) => void;
+}
+/**
+ * Drip SDK provider for React applications.
+ *
+ * Initializes the SDK, fetches experiment config (if shopId provided),
+ * and provides assignment context to child components.
+ */
+export declare function DripProvider({ children, onExperimentViewed, ...config }: DripProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Get the assignment for a specific experiment by ID or slug.
+ * Returns `null` if the user is not assigned to this experiment.
+ */
+export declare function useExperiment(experimentId: string): Assignment | null;
+/**
+ * Get the assigned variation for a specific experiment.
+ * Returns `null` if the user is not assigned.
+ */
+export declare function useVariation(experimentId: string): Pick<Variation, "id" | "isControl"> | null;
+/**
+ * Evaluate a feature flag (experiment-backed).
+ * Returns `true` if the user is bucketed into a non-control variation.
+ */
+export declare function useFeatureFlag(flagId: string): boolean;
+/**
+ * Read the typed value assigned by a feature flag.
+ * Returns the fallback when the visitor is not assigned or the flag is missing.
+ */
+export declare function useFeatureFlagValue<T = unknown>(flagId: string, fallback: T): T | unknown;
+/**
+ * Returns a function to track goals.
+ */
+export declare function useTrackGoal(): (goalId: string, data?: Record<string, unknown>) => void;
+/**
+ * Returns a function to track custom events.
+ */
+export declare function useTrack(): (type: string, data?: Record<string, unknown>) => void;
+/**
+ * Returns a function to track revenue.
+ */
+export declare function useTrackRevenue(): (revenue: number, data?: Record<string, unknown>) => void;
+/**
+ * Get all current assignments.
+ */
+export declare function useAssignments(): Assignment[];
+/**
+ * Whether the SDK is still loading experiment config.
+ */
+export declare function useLoading(): boolean;
+export type { Assignment, Experiment, Variation, InitConfig } from "../types";

package/dist/types/reassert-sentinel.d.ts

@@ -0,0 +1,6 @@
+import type { Mutation } from "./types";
+export declare function trackAppliedMutation(element: Element, mutation: Mutation, context: {
+    experimentId?: string;
+    variationId?: string;
+}, apply: (element: Element, mutation: Mutation) => void): void;
+export declare function resetReassertSentinel(): void;

package/dist/types/router.d.ts

@@ -0,0 +1,9 @@
+import { RouterMode } from "./types";
+export type RouteChangeEvent = {
+    previousUrl: string;
+    nextUrl: string;
+    reason: "pushState" | "replaceState" | "popstate" | "hashchange" | "navigation";
+};
+type RouteObserver = (event: RouteChangeEvent) => void;
+export declare function observeRouteChanges(mode: RouterMode, observer: RouteObserver): () => void;
+export {};

package/dist/types/runtime-tools.d.ts

@@ -0,0 +1,50 @@
+type Cleanup = () => void;
+type DataLayerEntry = Record<string, unknown>;
+type DataLayerMatcher = Record<string, unknown> | Array<[string, unknown]>;
+type RuntimeToolsEnvironment = {
+    document?: Document;
+    window?: Window & typeof globalThis;
+    location?: Location;
+    track?: (type: string, data?: Record<string, unknown>) => void;
+    trackGoal?: (goalId: string, data?: Record<string, unknown>) => void;
+    signal?: (key: string, value: unknown, ttlDays?: number) => void;
+    reInit?: (forceReapply?: boolean) => unknown;
+    get?: (key: string) => unknown;
+};
+export type WaitForElementOptions = {
+    root?: ParentNode;
+    once?: boolean;
+    timeoutMs?: number;
+};
+export type DomChangedOptions = {
+    root?: Node;
+    subtree?: boolean;
+    debounceMs?: number;
+};
+export type ElementInViewOptions = {
+    root?: Element | Document | null;
+    rootMargin?: string;
+    threshold?: number;
+    once?: boolean;
+    timeoutMs?: number;
+};
+export type DataLayerOptions = {
+    layerName?: string;
+    once?: boolean;
+    timeoutMs?: number;
+};
+export type ApexRuntimeTools = {
+    waitForElement: (selector: string, callback: (element: Element) => void, options?: WaitForElementOptions) => Cleanup;
+    elementIsInView: (selector: string, callback: (element: Element) => void, options?: ElementInViewOptions | boolean) => Cleanup;
+    domChanged: (callback: (mutations: MutationRecord[]) => void, options?: DomChangedOptions) => Cleanup;
+    domLoaded: (callback: () => void) => Cleanup;
+    waitForDataLayer: (matcher: DataLayerMatcher, callback: (entry: DataLayerEntry) => void, options?: DataLayerOptions) => Cleanup;
+    track: (type: string, data?: Record<string, unknown>) => void;
+    trackGoal: (goalId: string, data?: Record<string, unknown>) => void;
+    signal: (key: string, value: unknown, ttlDays?: number) => void;
+    redirect: (target: string) => void;
+    reInit: (forceReapply?: boolean) => unknown;
+    get: (key: string) => unknown;
+};
+export declare function createApexRuntimeTools(env?: RuntimeToolsEnvironment): ApexRuntimeTools;
+export {};

package/dist/types/runtime.d.ts

@@ -0,0 +1,22 @@
+import type { ActivationMode, Assignment, Experiment, InitConfig, PerfFeatureFlag, PlatformHint, RouterMode } from "./types";
+type UrlDiffNeeds = {
+    path: boolean;
+    search: boolean;
+    hash: boolean;
+};
+export type PerfFlagState = Record<PerfFeatureFlag, boolean>;
+/**
+ * Browser-side validation for a server-compiled empty-project profile. The
+ * browser may reject the profile, but never upgrades a full profile itself.
+ */
+export declare function canUseEmptyProjectProfile(config: InitConfig, experiments: Experiment[], platform?: PlatformHint): boolean;
+export declare function detectRuntimePlatform(): PlatformHint;
+export declare function resolvePlatform(config: InitConfig): PlatformHint;
+export declare function resolveRouterMode(config: InitConfig, platform: PlatformHint): RouterMode;
+export declare function resolveActivationMode(config: InitConfig): ActivationMode;
+export declare function readPerfFlags(config: InitConfig): PerfFlagState;
+export declare function computeUrlDiffNeeds(experiments: Experiment[], signals?: InitConfig["signals"]): UrlDiffNeeds;
+export declare function shouldReevaluateForUrlChange(previousUrl: string, nextUrl: string, deps: UrlDiffNeeds): boolean;
+export declare function assignmentSignature(assignments: Assignment[]): string;
+export declare function getBlankScreenMs(): number;
+export {};

package/dist/types/safe-regex.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Safe wrapper around RegExp construction and testing.
+ * Prevents crashes from invalid patterns and guards against
+ * extremely long patterns that could cause ReDoS.
+ */
+export declare function safeRegexTest(pattern: string, input: string): boolean;

package/dist/types/sanitize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Lightweight HTML sanitizer using the browser's DOMParser.
+ * Strips <script> tags, on* event handlers, and javascript: URLs.
+ */
+export declare function sanitizeHtml(html: string): string;

package/dist/types/semantic.d.ts

@@ -0,0 +1,7 @@
+import type { SemanticTrackingSettings } from "./types";
+type TrackFn = (type: string, data?: Record<string, unknown>) => void;
+type Controller = {
+    stop: () => void;
+};
+export declare function startSemanticCapture(settings: SemanticTrackingSettings | undefined, track: TrackFn): Controller | null;
+export {};

package/dist/types/shopify-cart-events.d.ts

@@ -0,0 +1,7 @@
+export type ShopifyCartMutationHandler = () => void;
+export declare function onShopifyCartMutation(handler: ShopifyCartMutationHandler): () => void;
+/**
+ * Use for Apex's own cart-attribute write so it does not recursively look like
+ * a shopper/theme mutation to subscribers of the shared fetch wrapper.
+ */
+export declare function fetchWithoutShopifyCartMutationNotification(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;

package/dist/types/shopify-cart.d.ts

@@ -0,0 +1,62 @@
+export type CartAssignment = {
+    experimentId: string;
+    variationId: string;
+    assignmentEpoch?: number;
+    commercePriceOnly?: boolean;
+};
+export type CartAttributeSyncInput = {
+    assignments: CartAssignment[];
+    requiredAssignments?: CartAssignment[];
+    visitorId: string;
+    sessionId: string;
+    shopId?: string;
+    endpoint?: string;
+    ingestSignature?: string;
+    url?: string;
+    environment?: string;
+    cartToken?: string;
+    offersAuthorizationRevision?: number;
+    offersExperimentIds?: string[];
+    shippingAuthorizationRevision?: number;
+    shippingExperimentIds?: string[];
+    priceAuthorizationRevision?: number;
+    priceExperimentIds?: string[];
+    adoptOffersAssignments?: (assignments: CartAssignment[]) => boolean;
+    /** Pre-write feasibility check; must not apply anything. */
+    canAdoptOffersAssignments?: (assignments: CartAssignment[]) => boolean;
+    /** Headless capture hook: stage a validated offers adoption for {@link confirmCartAttributesWritten}. */
+    stageOffersAdoptionAssignments?: (assignments: CartAssignment[]) => void;
+    adoptPriceAssignments?: (assignments: CartAssignment[]) => boolean;
+    authorizePriceDisplayAssignments?: (assignments: CartAssignment[]) => void;
+    authorizeShippingDisplayAssignments?: (assignments: CartAssignment[]) => void;
+    authorizeOffersDisplayAssignments?: (assignments: CartAssignment[]) => void;
+    /** Receives the parsed /cart/update.js response body after a successful stamp write. */
+    onCartSnapshot?: (cart: unknown) => void;
+    exclusionGroupSelections?: Array<{
+        groupId: string;
+        experimentId: string;
+        epoch: number;
+    }>;
+};
+export type CartAttributeEntry = {
+    key: string;
+    value: string;
+};
+export type CartAttributeSyncResult = {
+    status: "sent" | "skipped" | "failed";
+    reason?: string;
+};
+export type CartAttributeSyncOptions = {
+    /** Re-write after a real cart mutation even if this assignment was stamped earlier. */
+    force?: boolean;
+};
+/** Prevent an obsolete authorization response from reaching the cart write. */
+export declare function invalidateShopifyCartAttributeSync(): void;
+export declare function cannotRequestRequiredCommerceAuthorization(input: CartAttributeSyncInput): boolean;
+export declare function isShopifyStorefront(): boolean;
+/** Validated locale-aware storefront root ("/fr/" on localized markets, "/" otherwise). */
+export declare function shopifyRoutesRoot(): string;
+export declare function shopifyCartPath(): string;
+export declare function syncShopifyCartAttributes(input: CartAttributeSyncInput, options?: CartAttributeSyncOptions): Promise<CartAttributeSyncResult>;
+export declare function buildSignedCartAttributeEntries(input: CartAttributeSyncInput): Promise<CartAttributeEntry[]>;
+export declare function buildCartAttributeEntries(input: CartAttributeSyncInput, commerceAuthorization?: string | null): CartAttributeEntry[];

package/dist/types/signals.d.ts

@@ -0,0 +1,31 @@
+type SignalValue = string | number | boolean | string[] | Record<string, unknown> | null;
+export type ProductSignalInput = {
+    id?: string | number | null;
+    handle?: string | null;
+    title?: string | null;
+    type?: string | null;
+    vendor?: string | null;
+    tags?: string[] | null;
+    price?: number | string | null;
+};
+export declare function configureSignalPersistenceAllowed(predicate?: () => boolean): void;
+export declare function setSignal(key: string, value: unknown, ttlDays?: number, source?: string): void;
+export declare function getSignals(options?: {
+    markVisitorSeen?: boolean;
+}): Record<string, SignalValue>;
+export declare function clearStoredSignals(): void;
+export declare function setRuntimeSignal(key: string, value: unknown, source?: string): void;
+export declare function clearRuntimeSignal(key: string): void;
+export declare function getSignalDiagnostics(options?: {
+    markVisitorSeen?: boolean;
+}): {
+    values: Record<string, SignalValue>;
+    sources: Record<string, string>;
+};
+export declare function rememberProduct(product: ProductSignalInput, ttlDays?: number): void;
+export declare function setCartSignals(args: {
+    itemCount?: number;
+    productIds?: string[];
+}, ttlDays?: number): void;
+export declare function setSearchSignal(query: string, ttlDays?: number): void;
+export {};

package/dist/types/surface-signals.d.ts

@@ -0,0 +1,6 @@
+export declare const CART_DRAWER_OPEN_SIGNAL = "surface.cart_drawer.open";
+export declare const CART_DRAWER_SELECTORS: string[];
+export declare function findCartDrawerContainer(root?: ParentNode): Element | null;
+export declare function detectCartDrawerOpen(root?: ParentNode): boolean;
+export declare function installCartDrawerOpenListener(onChange: (open: boolean) => void): () => void;
+export declare function installSurfaceSignals(onChange: () => void): () => void;

package/dist/types/targeting-diagnostics.d.ts

@@ -0,0 +1,5 @@
+import type { Targeting, TargetingDiagnostics } from "./types";
+export declare function evaluateTargetingGatesWithConditionDiagnostics(targeting: Targeting | undefined, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): TargetingDiagnostics;

package/dist/types/targeting.d.ts

@@ -0,0 +1,50 @@
+import { AttributeRule, ActivationGateDiagnostic, Experiment, PageTargetingRule, SegmentCondition, Targeting, TargetingDiagnostics, UrlRule } from "./types";
+export declare function evalUrlRule(url: string, rule: UrlRule): boolean;
+export declare function normalizeRuntimeUrlRules(targeting: Targeting | undefined): UrlRule[];
+export declare function matchUrlRules(url: string, rules: UrlRule[]): boolean;
+type BooleanDiagnosticResult = {
+    matched: boolean;
+    reason?: string;
+    error?: unknown;
+};
+export declare function evaluatePageAdvancedConditionResult(rule: PageTargetingRule, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): BooleanDiagnosticResult;
+export declare function pageManualTriggerMatches(rule: PageTargetingRule, ctx: {
+    attributes: Record<string, unknown>;
+}): boolean;
+export declare function matchAttributeRule(attrs: Record<string, unknown>, rule: AttributeRule): boolean;
+export declare function buildTargetingAttributes(baseAttributes?: Record<string, unknown>, currentUrl?: string, options?: {
+    persistSignals?: boolean;
+}): Record<string, unknown>;
+export declare function resolveNamedConditionActual(condition: SegmentCondition, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): unknown;
+export declare function resolveNamedConditionExpected(condition: SegmentCondition): SegmentCondition["value"];
+export declare function evaluateJsTriggerResult(condition: SegmentCondition, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): {
+    actual: unknown;
+    reason?: string;
+};
+export declare function matchSegmentConditionValues(condition: SegmentCondition, actual: unknown, expected: SegmentCondition["value"]): boolean;
+export declare function matchesTargeting(targeting: Targeting | undefined, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): boolean;
+export declare function targetingHasJsTriggers(experiments: Experiment[]): boolean;
+export declare function evaluateTargetingGatesDetailed(targeting: Targeting | undefined, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): TargetingDiagnostics;
+export declare function evaluateTargetingGates(targeting: Targeting | undefined, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+}): {
+    matched: boolean;
+    gates: ActivationGateDiagnostic[];
+};
+export {};

package/dist/types/test-fixtures/commerce.d.ts

@@ -0,0 +1,12 @@
+import type { Experiment, InitConfig } from "../types";
+export declare const commercePriceFixture: NonNullable<InitConfig["commerce"]>;
+export declare const priceExperimentsFixture: Experiment[];
+export declare const commerceAssignmentResponseFixture: {
+    assignments: {
+        experiment_id: string;
+        variation_id: string;
+        assignment_epoch: number;
+    }[];
+    commerce_authorization: string;
+};
+export declare function installCommerceProductPage(): void;

package/dist/types/track.d.ts

@@ -0,0 +1,79 @@
+import { TrackEvent } from "./types";
+type TrackerOptions = {
+    endpoint: string;
+    shopId?: string;
+    ingestShopId?: string;
+    ingestSignature?: string;
+    visitorId?: string;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    /** Returns the active experiment/variation at unload time for page_exit attribution. */
+    getActiveAssignment?: () => {
+        experimentId: string;
+        variationId: string;
+    } | null;
+    /** Builds global and experiment-scoped page-exit events without flushing during unload. */
+    buildPageExitEvents?: (type: string, data?: Record<string, unknown>) => TrackEvent[];
+    /** When true, all events are tagged as QA traffic. */
+    qaMode?: boolean;
+    /** Unique QA session identifier for grouping QA events. */
+    qaSessionId?: string;
+    /** Active Apex environment stamped onto every outgoing event. */
+    environment?: string;
+};
+export declare class Tracker {
+    private endpoint;
+    private shopId;
+    private ingestShopId;
+    private ingestSignature;
+    private visitorId;
+    private sessionId;
+    private visitorSessions;
+    private flushIntervalMs;
+    private maxBatchSize;
+    private queue;
+    private activeBatch;
+    private timer;
+    private flushInFlight;
+    private flushPromise;
+    private nextFlushAt;
+    private backoffMs;
+    private readonly maxQueueSize;
+    private getActiveAssignment;
+    private buildPageExitEvents;
+    private qaMode;
+    private qaSessionId;
+    private environment;
+    private pagehideHandler;
+    private beforeUnloadHandler;
+    private pageshowHandler;
+    private beforeUnloadResetTimer;
+    private visibilityHandler;
+    private pageLifecycleFlushed;
+    private pageTeardownStarted;
+    constructor(options: TrackerOptions);
+    private getOrCreateSessionId;
+    /** Public accessor for the session ID (used by the Shopify pixel bridge). */
+    getSessionId(): string;
+    start(): void;
+    stop(): void;
+    track(event: TrackEvent): void;
+    private enrichEvent;
+    private scheduleBackoff;
+    private resetBackoff;
+    private parseRetryAfterSeconds;
+    flush(): Promise<void>;
+    private drainQueue;
+    private buildPayload;
+    private buildHeaders;
+    private recoveryEventKey;
+    private readRecovery;
+    private saveRecovery;
+    private removeRecovery;
+    private queuePageExitEvents;
+    private flushForPageLifecycle;
+    private recoverEvents;
+    private resetPageLifecycle;
+    private listenUnload;
+}
+export {};