@drip-apex/sdk 0.1.0 → 0.3.0

package/dist/types/exclusion-groups.d.ts

@@ -1,9 +1,7 @@
 import type { Assignment, ExclusionGroupConfig } from "./types";
+import { type PersistedGroupSelection } from "./persistence-decoders";
+export { decodePersistedGroupSelections, type PersistedGroupSelection } from "./persistence-decoders";
 /** A remembered group decision: which member won and at what group epoch. */
-export type PersistedGroupSelection = {
-    experimentId: string;
-    epoch: number;
-};
 /** Pluggable persistence so the runtime uses browser storage and tests use memory. */
 export interface GroupStickyStore {
     read(groupId: string): PersistedGroupSelection | null;
@@ -12,7 +10,7 @@ export interface GroupStickyStore {
 type CompactSelection = [string, number];
 type CompactStore = Record<string, CompactSelection>;
 declare function normalizeEpoch(epoch: number | null | undefined): number;
-declare function parseStore(raw: string | null): CompactStore;
+export declare function decodeCompactGroupStore(raw: string | null): CompactStore;
 /** Browser-backed store (localStorage + cookie mirror) used by the live runtime. */
 export declare const browserGroupStickyStore: GroupStickyStore;
 /** Remove consent-gated group stickiness from both browser persistence planes. */
@@ -53,7 +51,6 @@ export declare function resolveExclusionGroups(assignments: Assignment[], groups
 export declare const __exclusionGroupInternals: {
     STORAGE_KEY: string;
     COOKIE_NAME: string;
-    parseStore: typeof parseStore;
+    parseStore: typeof decodeCompactGroupStore;
     normalizeEpoch: typeof normalizeEpoch;
 };
-export {};

package/dist/types/flags.d.ts

@@ -21,6 +21,8 @@ export interface FlagContext {
     url?: string;
     attributes?: Record<string, unknown>;
     userId?: string;
+    /** QA variation overrides use the same weekday bypass as assignment delivery. */
+    forceMap?: Record<string, string>;
 }
 /**
  * Evaluate whether a feature flag is enabled.

package/dist/types/goal-eligibility.d.ts

@@ -0,0 +1,4 @@
+export declare function goalIsEligible(goal: {
+    pageId?: string | null;
+    urlPattern?: string | null;
+}, pageActiveIds: ReadonlySet<string>, href: string): boolean;

package/dist/types/goals.d.ts

@@ -1,9 +1,18 @@
 import { Goal, Assignment } from "./types";
 type GoalCallback = (goalId: string, assignment: Assignment, data?: Record<string, unknown>) => void;
+/**
+ * Identity of the goal wiring the given inputs would produce. The runtime
+ * diffs this set to decide whether a re-wire is needed, so wiring stays
+ * idempotent across repeated reconciliation passes.
+ */
+export declare function goalWiringKeys(assignments: Assignment[], experiments: {
+    id: string;
+    goals?: Goal[];
+}[], pageActiveIds?: ReadonlySet<string>): Set<string>;
 export declare function setupGoals(assignments: Assignment[], experiments: {
     id: string;
     goals?: Goal[];
-}[], callback: GoalCallback): void;
+}[], callback: GoalCallback, pageActiveIds?: ReadonlySet<string>): void;
 export declare function triggerGoal(goalId: string, assignments: Assignment[], experiments: {
     id: string;
     goals?: Goal[];

package/dist/types/guards.d.ts

@@ -6,18 +6,18 @@ export declare function isOptedOut(options?: {
 }): boolean;
 export declare function isScreenshotMode(): boolean;
 declare function parseForceParams(params: URLSearchParams): Record<string, string> | null;
-export declare function parseForceParam(options?: {
-    cookieFallback?: boolean;
-}): Record<string, string> | null;
+export declare function hasExplicitForceParam(): boolean;
+export declare function clearQaForceFromUrl(): boolean;
+export declare function parseForceParam(): Record<string, string> | null;
 declare function parseForceString(value: string): Record<string, string> | null;
-export declare function isQaMode(options?: {
-    cookieFallback?: boolean;
-}): boolean;
+export declare function isQaMode(): boolean;
 /**
  * Persist the force map in a cookie so QA sessions survive navigation.
- * Cookie expires after 30 minutes.
+ * Cookie expires at most 30 minutes after the latest QA page load or assistant force.
  */
 export declare function persistQaForce(forceMap: Record<string, string>): void;
+/** Persist an explicit URL force or renew an existing cookie-backed force. */
+export declare function persistUrlQaForce(forceMap: Record<string, string>): void;
 declare function sanitizeQaSessionId(value: string | null): string | null;
 export declare function getQaSessionId(fallback: () => string, options?: {
     storageAllowed?: boolean;

package/dist/types/handover.d.ts

@@ -2,9 +2,20 @@ import type { Assignment, ExternalTrackingSettings } from "./types";
 export type HandoverData = {
     visitorId?: string;
     forceMap?: Record<string, string>;
+    redirectAttribution?: {
+        experimentId: string;
+        variationId: string;
+        destinationUrl: string;
+        issuedAt: number;
+        token: string;
+    };
 };
 export declare function handoverMintTimeoutMs(settings?: ExternalTrackingSettings): number;
+/** Decode a handover token carried by another runtime transport. */
+export declare function readBucketingHandoverPayload(value: string): HandoverData | null;
+export declare function bucketingHandoverExpiresAtMs(value: string): number | null;
 export declare function readBucketingHandover(settings: ExternalTrackingSettings | undefined, shopId: string, verifyToken: (token: string) => Promise<unknown>): Promise<HandoverData | null>;
+export declare function verifyBucketingHandoverToken(value: string, shopId: string, verifyToken: (token: string) => Promise<unknown>): Promise<HandoverData | null>;
 export declare function hasBucketingHandover(settings?: ExternalTrackingSettings): boolean;
-export declare function createBucketingHandoverPayload(visitorId: string, assignments: Assignment[], settings?: ExternalTrackingSettings): string;
+export declare function createBucketingHandoverPayload(visitorId: string, assignments: Array<Pick<Assignment, "experimentId" | "variationId">>, settings?: ExternalTrackingSettings): string;
 export declare function installBucketingHandover(settings: ExternalTrackingSettings | undefined, getPayload: () => string | null, mintPayload?: () => Promise<string | null>): () => void;

package/dist/types/hash.d.ts

@@ -1,7 +1,10 @@
+export { hashToFloat, murmurhash3_32_gc, variationHashToFloat } from "@drip/shared-runtime/bucketing";
 type StorageMode = "localStorage" | "sessionStorage" | "cookie" | "memory";
-export declare function murmurhash3_32_gc(key: string, seed?: number): number;
-export declare function hashToFloat(seed: string, value: string): number;
-export declare function variationHashToFloat(experimentId: string, value: string): number;
+export declare function isHoldoutVisitor(config: {
+    holdout_v1_enabled?: unknown;
+    holdout_pct?: unknown;
+}, visitorId: string): boolean;
+export declare function applyHoldoutGate<T>(config: Parameters<typeof isHoldoutVisitor>[0], visitorId: string, values: T[]): T[];
 export declare function configureIdentityStorage(settings?: {
     storageMode?: StorageMode;
     encodeStorageValues?: boolean;
@@ -14,6 +17,7 @@ export declare function configureIdentityStorage(settings?: {
  */
 export declare function lifetimeIdentityStorage(): Storage | null;
 export declare function getUserId(provided?: string): string;
+/** Reads an existing durable identity without minting or persisting a new one. */
+export declare function getPersistedUserId(): string | null;
 export declare function getEphemeralUserId(provided?: string): string;
 export declare function adoptUserId(value: string): void;
-export {};

package/dist/types/hydration.d.ts

@@ -6,6 +6,7 @@ export declare function hasMutationHold(): boolean;
 export declare function signalHydrated(): void;
 export declare function awaitHydration(timeoutMs: number, options?: {
     waitForHydration?: boolean;
-}): Promise<void>;
+    recordMetrics?: boolean;
+}, outerStarted?: number): Promise<void>;
 export declare function resetHydrationState(): void;
 export declare function assignmentsHaveVisualWork(assignments: Assignment[], priceSettings?: CommercePriceSettings): boolean;

package/dist/types/index.d.ts

@@ -1,144 +1,40 @@
-import { type CartAttributeEntry } from "./shopify-cart";
-import { type ApexRuntimeTools } from "./runtime-tools";
-import { ActivationMode, AntiFlickerMode, Assignment, ActivationDiagnostics, ConfigProfile, ConsentModeSettings, CustomJsPolicy, DebugSettings, ExecutionMode, Experiment, ExclusionGroupConfig, ExclusionGroupMemberConfig, Goal, InitConfig, PageTargetingRule, PageTriggerMode, PageTriggerSettings, PerfFeatureFlag, PerfFeatureFlags, PlatformHint, ProjectPrerequisites, RouterMode, SpaSettings, ExternalTrackingSettings, ProjectCodeSettings, RuntimeEnvironmentSettings, SdkDiagnostics, BucketingCleanupSettings, DataProtectionSettings, TrackEvent, TrackingStart, Variation } from "./types";
-type FetchAttemptInfo = {
-    attempt: number;
-    elapsedMs: number;
-    error?: string;
-    status?: number;
-    timedOut?: boolean;
-};
-type FetchRetryOptions = {
-    timeoutMs?: number;
-    firstAttemptTimeoutMs?: number;
-    slowMs?: number;
-    onAttemptStart?: (attempt: number) => void;
-    onAttemptEnd?: (info: FetchAttemptInfo) => void;
-    onSlow?: (info: {
-        attempt: number;
-        elapsedMs: number;
-    }) => void;
-};
-declare function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response>;
-declare function fetchWithRetry(url: string, retries?: number, delayMs?: number, options?: FetchRetryOptions): Promise<Response>;
-declare function normalizePageApiName(value: unknown): string;
-declare function triggerPage(apiName: unknown, active?: unknown): void;
-declare function installPageTriggerRule(rule: PageTargetingRule, onChange: () => void): () => void;
-type OrderIdentityPlatform = "shopify" | "shopware" | "woocommerce" | "centra" | "custom";
-type QaAssistantRuntimeSnapshot = {
-    config: InitConfig | null;
-    assignments: Assignment[];
-    activationDiagnostics: ActivationDiagnostics;
-    forceMap: Record<string, string> | null;
-    platform: PlatformHint;
-    qaMode: boolean;
-    orderIdentity: {
-        platform: OrderIdentityPlatform;
-        platformOrderId: string | null;
-        orderNumber: string | null;
-    } | null;
-};
-declare function getConfigCacheKey(shopId: string, environmentKey?: string): string;
-declare function withRuntimeSettings(config: InitConfig, runtime: unknown, profile?: InitConfig["profile"]): InitConfig;
-export declare function evaluate(experiments: Experiment[], context?: {
-    url?: string;
-    attributes?: Record<string, unknown>;
-    userId?: string;
-    persistSignals?: boolean;
-    exclusionGroups?: ExclusionGroupConfig[];
-}): Assignment[];
-export declare function __getQaAssistantRuntimeSnapshot(): QaAssistantRuntimeSnapshot;
-export declare function __subscribeQaAssistantRuntime(listener: () => void): () => void;
-export declare function __forceQaAssistantVariation(experimentId: string, variationId: string): void;
-export declare function __resetQaAssistantForce(experimentId?: string): void;
-export declare function init(config: InitConfig): Assignment[];
-export declare function track(type: string, data?: Record<string, unknown>, experimentId?: string, variationId?: string): void;
-/**
- * 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 declare function trackStep(name: string, data?: Record<string, unknown>): void;
-export declare function trackGoal(goalId: string, data?: Record<string, unknown>): void;
-export declare function setConsent(granted: boolean): void;
-export declare function hold(): number;
-export declare function release(): number;
-export declare function hydrated(): void;
-export declare function recheckPrerequisites(): void;
-export declare function reInit(forceReapply?: boolean): Assignment[];
-/**
- * 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 declare function trackRevenue(revenue: number, data?: RevenueEventData): void;
-export declare function flush(): Promise<void>;
-export declare function getAssignments(): Assignment[];
-export declare function getCartAttributes(): CartAttributeEntry[];
-/**
- * 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 declare function getSignedCartAttributes(cartToken?: string): Promise<CartAttributeEntry[]>;
-/**
- * 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 declare function confirmCartAttributesWritten(cartToken?: string): boolean;
-export declare function getExperiments(): Experiment[];
-export declare function getRuntimeValue(key: string): unknown;
-export declare function getRuntimeTools(): ApexRuntimeTools;
-export declare function evaluateFlag(flagId: string, context?: {
-    url?: string;
-    attributes?: Record<string, unknown>;
-    userId?: string;
-}): boolean;
-export declare function evaluateFlagAssignment(flagId: string, context?: {
-    url?: string;
-    attributes?: Record<string, unknown>;
-    userId?: string;
-}): Assignment | null;
-export declare function evaluateFlagValue<T = unknown>(flagId: string, fallback?: T, context?: {
-    url?: string;
-    attributes?: Record<string, unknown>;
-    userId?: string;
-}): T | unknown;
-export declare function getDiagnostics(): SdkDiagnostics;
+import { ActivationMode, AntiFlickerMode, Assignment, ConfigProfile, ConsentModeSettings, CustomJsPolicy, DebugSettings, ExecutionMode, Experiment, ExclusionGroupConfig, ExclusionGroupMemberConfig, Goal, InitConfig, PageTriggerMode, PageTriggerSettings, PerfFeatureFlag, PerfFeatureFlags, PlatformHint, ProjectPrerequisites, RouterMode, SpaSettings, ExternalTrackingSettings, ProjectCodeSettings, RuntimeEnvironmentSettings, SdkDiagnostics, BucketingCleanupSettings, DataProtectionSettings, TrackEvent, TrackingStart, Variation } from "./types";
+import { fetchWithTimeout, fetchWithRetry, collectScopedSelectors, normalizePageApiName, triggerPage, installActivateJsTrigger, installPageTriggerRule } from "./config-runtime";
+import { sendRuntimeEventNow, getConfigCacheKey, withRuntimeSettings } from "./analytics-runtime";
+import { ArtifactId, reconcilePageActivation, baseArtifactApplicationKey, artifactRenderableAssignments, evaluate, buildCriticalPathAssignments } from "./assignment-runtime";
+import { buildActiveCartAttributeSyncInput, __getQaAssistantRuntimeSnapshot, __subscribeQaAssistantRuntime, __forceQaAssistantVariation, __resetQaAssistantForce } from "./activation-runtime";
+import { init, track, trackStep, trackGoal, setConsent, hold, release, hydrated, recheckPrerequisites, reInit, RevenueEventData, trackRevenue, flush, getAssignments, getCartAttributes, getCartMetafields, getCartMetafieldStaleKeys, mergeCartAttributes, getSignedCartAttributes, confirmCartAttributesWritten, getExperiments, getRuntimeValue, getRuntimeTools, evaluateFlag, evaluateFlagAssignment, evaluateFlagValue, getDiagnostics } from "./public-api";
 export { defineExperiment, defineExperiments } from "./define";
 export { defineFlagExperiment } from "./flags";
 export { getSignals, rememberProduct, setCartSignals, setSearchSignal, setSignal, } from "./signals";
 export { createApexRuntimeTools } from "./runtime-tools";
 export declare const __test: {
+    attributionLedgerHas: (experimentId: string) => boolean;
+    artifactInventory: () => {
+        id: ArtifactId;
+        ownerKeys: string[];
+        ownerPageIds: string[];
+    }[];
+    artifactRenderableAssignments: typeof artifactRenderableAssignments;
+    baseArtifactApplicationKey: typeof baseArtifactApplicationKey;
+    buildActiveCartAttributeSyncInput: typeof buildActiveCartAttributeSyncInput;
+    buildCriticalPathAssignments: typeof buildCriticalPathAssignments;
+    collectScopedSelectors: typeof collectScopedSelectors;
     fetchWithTimeout: typeof fetchWithTimeout;
     fetchWithRetry: typeof fetchWithRetry;
     getConfigCacheKey: typeof getConfigCacheKey;
+    installActivateJsTrigger: typeof installActivateJsTrigger;
     installPageTriggerRule: typeof installPageTriggerRule;
     normalizePageApiName: typeof normalizePageApiName;
+    reconcilePageActivation: typeof reconcilePageActivation;
     triggerPage: typeof triggerPage;
+    sendRuntimeEventNow: typeof sendRuntimeEventNow;
     withRuntimeSettings: typeof withRuntimeSettings;
-};
+} | undefined;
 export type { ActivationMode, AntiFlickerMode, Assignment, ConfigProfile, ConsentModeSettings, CustomJsPolicy, ExecutionMode, Experiment, ExclusionGroupConfig, ExclusionGroupMemberConfig, Goal, InitConfig, PageTriggerMode, PageTriggerSettings, PerfFeatureFlag, PerfFeatureFlags, PlatformHint, RouterMode, TrackEvent, TrackingStart, Variation, DebugSettings, ProjectPrerequisites, SpaSettings, ExternalTrackingSettings, ProjectCodeSettings, RuntimeEnvironmentSettings, SdkDiagnostics, BucketingCleanupSettings, DataProtectionSettings, };
 export type { ExperimentDefinition, VariationDefinition, GoalDefinition } from "./define";
 export type { FlagDefinition, FlagContext } from "./flags";
-export type { CartAttributeEntry } from "./shopify-cart";
+export type { CartAttributeEntry, CartMetafieldInput } from "./shopify-cart";
 export type { ApexRuntimeTools, DataLayerOptions, DomChangedOptions, ElementInViewOptions, WaitForElementOptions, } from "./runtime-tools";
+export { evaluate, __getQaAssistantRuntimeSnapshot, __subscribeQaAssistantRuntime, __forceQaAssistantVariation, __resetQaAssistantForce, init, track, trackStep, trackGoal, setConsent, hold, release, hydrated, recheckPrerequisites, reInit, trackRevenue, flush, getAssignments, getCartAttributes, getCartMetafields, getCartMetafieldStaleKeys, mergeCartAttributes, getSignedCartAttributes, confirmCartAttributesWritten, getExperiments, getRuntimeValue, getRuntimeTools, evaluateFlag, evaluateFlagAssignment, evaluateFlagValue, getDiagnostics };
+export type { RevenueEventData };

package/dist/types/init-test-helpers.d.ts

@@ -0,0 +1,48 @@
+import { vi } from "vitest";
+export declare const RECENT_MONDAY_NOON: Date;
+export declare function makeStorage(): {
+    getItem: (key: string) => string | null;
+    key: (index: number) => string;
+    removeItem: (key: string) => void;
+    setItem: (key: string, value: string) => void;
+    readonly length: number;
+};
+export declare function makeClassList(): {
+    add: (...tokens: string[]) => void;
+    remove: (...tokens: string[]) => void;
+    contains: (token: string) => boolean;
+};
+export declare function appendedAntiFlickerStyle(): {
+    id: string;
+    remove: ReturnType<typeof vi.fn>;
+    textContent: string;
+} | undefined;
+export declare function readCookieValue(name: string): string | null;
+export declare function readDecodedDripContext(): string | null;
+export declare function installCookieJar(initial?: string): string[];
+export declare function installMutationObserverStub(): {
+    observe: import("vitest").Mock<(...args: any[]) => any>;
+    disconnect: import("vitest").Mock<(...args: any[]) => any>;
+    takeRecords: import("vitest").Mock<() => never[]>;
+};
+export declare function flushDynamicImports(): Promise<void>;
+export declare function configPayloadHash(experiments: unknown[]): string;
+export declare function decodeTestHandover(token: string): Record<string, unknown>;
+export declare function verifiedHandoverResponse(input: RequestInfo | URL, init: RequestInit | undefined, shopId?: string): Response | null;
+export declare let windowListeners: Record<string, Array<() => void>>;
+export declare let documentListeners: Record<string, Array<(...args: any[]) => void>>;
+export declare const originalWindow: any;
+export declare const originalDocument: any;
+export declare const originalHistory: any;
+export declare const originalLocation: any;
+export declare const originalNavigator: PropertyDescriptor | undefined;
+export declare const originalRequestIdleCallback: PropertyDescriptor | undefined;
+export declare const originalCancelIdleCallback: PropertyDescriptor | undefined;
+export declare const originalLocalStorage: any;
+export declare const originalSessionStorage: any;
+export declare const originalCustomEvent: any;
+export declare const originalMutationObserver: any;
+export declare const originalElement: any;
+export declare const originalNode: any;
+export declare const originalFetch: typeof fetch;
+export declare function registerInitTestLifecycle(): void;

package/dist/types/inline-bootstrap.d.ts

@@ -0,0 +1,26 @@
+import { type CompactGroupSelections } from "./persistence-decoders";
+import type { Experiment } from "./types";
+export type PredecidedAssignments = {
+    decision: Array<[experimentId: string, variationId: string]>;
+    configRevision: number;
+    visitorId: string;
+    groups: CompactGroupSelections;
+    consentAllowed: boolean;
+};
+/** Synchronous, read-only bootstrap entrypoint. Bundled into the Worker snippet. */
+export declare function computePredecided(input: {
+    experiments: Experiment[];
+    holdout?: {
+        enabled?: boolean;
+        percentage?: number;
+    };
+    configRevision: number;
+    url: string;
+    provisionalVisitorId: string;
+    requireConsent?: boolean;
+    hasConsent?: boolean;
+    consentModeEnabled?: boolean;
+    consentProvider?: "custom" | "onetrust" | "usercentrics" | "cookiebot" | "ccm19" | "pandectes" | "cookiescript" | "borlabs";
+    consentRequiredGroup?: string;
+    respectDoNotTrack?: boolean;
+}): PredecidedAssignments;

package/dist/types/js.d.ts

@@ -2,5 +2,7 @@ import type { CustomJsPolicy } from "./types";
 export declare function setJsPolicy(policy: CustomJsPolicy): void;
 export declare function isStrictJsPolicy(): boolean;
 export declare function execJs(code: string, sourceLabel?: string): void;
-export declare function loadExternalJs(url: string, sourceLabel: string): Promise<void>;
+export declare function loadExternalJs(url: string, sourceLabel: string, ownerKeys?: readonly string[], artifactId?: string, epoch?: number): Promise<void>;
+export declare function removeExternalJsForOwner(ownerKey: string, artifactId?: string): void;
+export declare function addExternalJsOwners(existingOwnerKeys: ReadonlySet<string>, ownerKeys: readonly string[], artifactId?: string): void;
 export declare function removeAllExternalJs(): void;

package/dist/types/money.d.ts

@@ -10,5 +10,17 @@ export type DisplayedMoney = {
     start: number;
     end: number;
 };
+export type CurrencyToken = {
+    symbol: string;
+    cents: number;
+    raw: string;
+};
+/** Extract marked displayed prices without treating ordinary numbers as money. */
+export declare function extractCurrencyTokens(text: string): CurrencyToken[];
+export declare const ISO_4217_CURRENCY_CODES: string[];
+/** Returns whether a code is currently active in ISO 4217. */
+export declare function isIso4217CurrencyCode(currencyCode: string): boolean;
+/** Authoritative ISO-4217 minor-unit exponent for editor-supported currencies. */
+export declare function currencyExponent(currencyCode: string): number;
 export declare function parseDisplayedCents(text: string, minorUnits?: number): DisplayedMoney | null;
 export declare function formatCentsLike(cents: number, convention: MoneyConvention): string;

package/dist/types/mutate.d.ts

@@ -1,34 +1,73 @@
 import { Mutation, MutationAction } from "./types";
+import { type CurrencyToken } from "./money";
 export type ApplyOptions = {
     root?: Document | HTMLElement;
-    onApplied?: (mutation: Mutation, element: Element, index: number) => void;
+    artifactId?: string;
+    epoch?: number;
+    ownerKeys?: readonly string[];
+    onApplied?: (mutation: Mutation, element: Element, index: number, journalSeq?: number) => void;
     onMiss?: (mutation: Mutation, index: number) => void;
+    preservePrices?: boolean;
+    priceTestExempt?: boolean;
+    onPricePreservationViolation?: (input: {
+        mutation: Mutation;
+        selector: string;
+        originalPriceTokens: CurrencyToken[];
+    }) => void;
 };
-export declare function isSafeMutationAttribute(name: string, value: string | null): boolean;
+type ElementReference = {
+    deref: () => Element | undefined;
+};
+export type MutationJournalEntry = {
+    seq: number;
+    artifactId: string;
+    owners: Set<string>;
+    target: {
+        selector: string;
+        index: number;
+        el: ElementReference;
+    };
+    mutation: Mutation;
+    epoch: number;
+    kind: "mutation" | "insert" | "adopt-insert";
+    insertKey?: string;
+    nodes?: Node[];
+    state: "applied" | "invalidated";
+};
+export { isSafeMutationAttribute } from "./sanitize";
 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 applyTrackedMutation(mutation: Mutation, element: Element, key?: string, ownerKeys?: readonly string[], artifactId?: string, onJournal?: (entry: MutationJournalEntry) => void, epoch?: number): Element | null;
+/** Reject a just-applied guarded mutation without disturbing earlier treatments. */
+export declare function rejectTrackedMutation(entry: MutationJournalEntry | undefined, element: Element, innerHTML: string): void;
 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 declare function resetAppliedMutationsForOwner(ownerKey: string, artifactId?: string, options?: {
+    preserveReplacementTargets?: boolean;
+}): void;
+export declare function addAppliedMutationOwners(existingOwnerKeys: ReadonlySet<string>, ownerKeys: readonly string[], artifactId?: string): void;
+export declare function invalidateArtifact(artifactId: string): void;
+export declare function replayArtifact(artifactId: string): void;
+export declare function replayForOwner(ownerKey: string): 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.
+ * Owns only the journal entries created through this context. Rollback
+ * restores its baseline without touching shopper assignment entries.
  */
 export declare function createMutationApplicationContext(): MutationApplicationContext;
 /** @internal — exposed for unit testing only. Tree-shaken from production build. */
 export declare const __test: {
+    baselineAttributeNames(element: Element): string[];
     normalizeCssPropertyName: typeof normalizeCssPropertyName;
 };
 export declare function observeSpaNavigation(onChange: () => void): () => void;

package/dist/types/performance.d.ts

@@ -0,0 +1,2 @@
+export declare function roundPerformance(value: number, precision?: number): number;
+export declare function navigationEntry(): PerformanceNavigationTiming | undefined;

package/dist/types/persistence-decoders.d.ts

@@ -0,0 +1,12 @@
+export type PersistedAssignmentRecord = {
+    variationId: string;
+    epoch: number;
+    assignedAt: number;
+};
+export type PersistedGroupSelection = {
+    experimentId: string;
+    epoch: number;
+};
+export type CompactGroupSelections = Record<string, [string, number]>;
+export declare function decodePersistedAssignments(local: string | null, cookie: string | null): Record<string, PersistedAssignmentRecord>;
+export declare function decodePersistedGroupSelections(local: string | null, cookie: string | null): CompactGroupSelections;