@drip-apex/sdk 0.1.0 → 0.2.0

package/dist/sri.json

@@ -1,27 +1,32 @@
 {
   "drip.js": {
-    "sha384": "sha384-Um2aSsOgGy30oXzHq054QWAey3e6xnQhUpxi6t0DoBLN/vl7L34IluEEDsVDUvy+",
-    "bytes": 327176,
-    "gzipBytes": 95380
+    "sha384": "sha384-QcviG2yudwcp21+saOzRBTao3iCw9Klvg0E6tn+8WtZSj59rtG+pYDPisLayylr2",
+    "bytes": 441764,
+    "gzipBytes": 132087
   },
   "drip.live.js": {
-    "sha384": "sha384-dP//F37IbyzbnWQ7W/PYVmQVKp+ByihrHT15tpQFISCO10M2C7GI/tmAu7WRmCwi",
-    "bytes": 238320,
-    "gzipBytes": 69619
+    "sha384": "sha384-SWfJun6EaNrR6EGydboVMqywr1cWkg6wn68hxAhS9qDRadAm2INiQX6+wp97p0Ih",
+    "bytes": 343553,
+    "gzipBytes": 102995
   },
   "drip.heatmap.js": {
-    "sha384": "sha384-h6Jx5DkyjsdiU0XzIc/2AlH2Xu4qQppeOY6cfVQxrRzrFkYl6VP/g6NDFTdwGppy",
-    "bytes": 243757,
-    "gzipBytes": 71115
+    "sha384": "sha384-XJaQw2UA07kiwX/QOolq/OD/VZwp1qS+XKSkVxaz9lgl9RG9tZb4mW3VayRaQ0NB",
+    "bytes": 350002,
+    "gzipBytes": 104619
   },
   "drip.debug.js": {
-    "sha384": "sha384-eaOKabQEMuuTio8GrmAj5B1sn4qlTqhw3gO+0u9gTKeWBtYmo0LXfTxBN2nEYsEg",
-    "bytes": 327182,
-    "gzipBytes": 95383
+    "sha384": "sha384-2URcohbse0uBuvenzE65vNNDop+upfeAEI5CoAJEMa9u3wQFwisZ+EKwhPDBK8ov",
+    "bytes": 441770,
+    "gzipBytes": 132090
   },
   "editor.js": {
-    "sha384": "sha384-WBLo4reMW+GBBHxLB6TpXCsJa2mukHmYMuyqlQpGeMR4OqPSNvNbRgqMXLLDYnr6",
-    "bytes": 106433,
-    "gzipBytes": 31127
+    "sha384": "sha384-OB10jEeM+Ci1L3cmdhp4MJyqko/f7lM+mcLfShixNRz145ucf9ZJaldhXCs++of5",
+    "bytes": 121189,
+    "gzipBytes": 36534
+  },
+  "drip.replay-recorder.js": {
+    "sha384": "sha384-oEkvAAksGbMrF+9k82zSulOTcBK2YIeo+2fiv7dYN03Su6dlTK98ikspp7muSbjN",
+    "bytes": 191115,
+    "gzipBytes": 60056
   }
 }

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

@@ -0,0 +1,91 @@
+import { readBucketingHandover } from "./handover";
+import { redirectPlanForAssignment } from "./redirect";
+import type { VerifiedRedirectCarry } from "./redirect";
+import { syncShopifyCartAttributes, type CartAssignment, type CartAttributeSyncInput } from "./shopify-cart";
+import { Assignment, Experiment, InitConfig } from "./types";
+import { QaAssistantRuntimeSnapshot } from "./runtime-state";
+import { ConfigSource, InitPerfContext, PageRuleReconcileScope } from "./config-runtime";
+export declare function generateQaSessionId(): string;
+export declare const SHOPIFY_ASSIGNMENT_SYNC_DELAYS_MS: number[];
+export declare let shopifyAssignmentSyncTimers: number[];
+export type CommerceOnlyAdoptionState = {
+    applying: boolean;
+    assignments: Assignment[];
+    context: string | null;
+};
+export declare let commercePriceAdoptionState: CommerceOnlyAdoptionState | null;
+export declare function ensureCommercePriceAdoptionState(): CommerceOnlyAdoptionState;
+export declare function currentCommercePriceContext(): string | null;
+export declare function withCommercePriceAssignments(assignments?: Assignment[]): Assignment[];
+export declare function clearShopifyAssignmentSyncTimers(): void;
+export declare function adoptAuthoritativePriceAssignments(assignments: CartAssignment[]): boolean;
+export type OffersAdoptionPlan = {
+    configuredOffersExperimentIds: Set<string>;
+    replacements: Map<string, Assignment>;
+    nextCommercePriceOnlyAssignments: Assignment[];
+};
+export declare function planAuthoritativeOffersAdoption(assignments: CartAssignment[]): OffersAdoptionPlan | null;
+export declare function canAdoptAuthoritativeOffersAssignments(assignments: CartAssignment[]): boolean;
+export declare function adoptAuthoritativeOffersAssignments(assignments: CartAssignment[]): boolean;
+export declare function sdkCartMintAllowed(): boolean;
+export declare function buildSdkCartMintInput(): CartAttributeSyncInput | null;
+export declare function buildScopedCartAttributeSyncInput(): CartAttributeSyncInput | null;
+export declare function buildActiveCartAttributeSyncInput(functionalCartWrite?: boolean): CartAttributeSyncInput | null;
+export declare let sdkCartMintSync: ReturnType<typeof syncShopifyCartAttributes> | null;
+export declare function syncSdkCartMint(): void;
+export declare const removeSdkCartMintTrigger: () => void;
+export declare function onSdkCartMintClick(): void;
+export declare function installSdkCartMintTrigger(): void;
+export type HeadlessCartAuthorizationState = {
+    generation: number;
+    confirmationPending: boolean;
+    pending: {
+        generation: number;
+        cartToken: string;
+        priceAssignments: CartAssignment[];
+        shippingAssignments: CartAssignment[];
+        offersAssignments: CartAssignment[];
+        offersAdoptionAssignments: CartAssignment[] | null;
+    } | null;
+};
+export declare let headlessCartAuthorizationState: HeadlessCartAuthorizationState | null;
+export declare function ensureHeadlessCartAuthorizationState(): HeadlessCartAuthorizationState;
+export declare function hasChargeAffectingCommerceAssignment(assignments?: Assignment[]): boolean;
+export declare function hasActiveAuthorizationPlane(plane: "price" | "shipping" | "offers"): boolean;
+export declare const hasActivePriceAuthorizationPlane: () => boolean;
+export declare const hasActiveShippingAuthorizationPlane: () => boolean;
+export declare const hasActiveOffersAuthorizationPlane: () => boolean;
+export declare function hasActiveCommerceAuthorizationPlane(): boolean;
+export declare function requiresCommerceCohortPin(assignments?: Assignment[]): boolean;
+export declare function getChargeAffectingCommerceExperimentIds(assignments?: Assignment[]): Set<string>;
+export declare function isCohortStampedOnCart(): boolean | "pending";
+export declare function syncActiveAssignmentToShopifyCart(options?: {
+    chargeCorrectness?: boolean;
+    force?: boolean;
+    holdoutCartClear?: boolean;
+}): void;
+export declare function configureChargeCorrectnessCartSync(assignments: Assignment[]): void;
+export declare function holdoutConfigEpoch(config: InitConfig | null | undefined): number | undefined;
+export declare function publishAssignmentsToShopify(): void;
+export declare function scheduleShopifyAssignmentSync(): void;
+export declare function variationsAllowed(config: InitConfig): boolean;
+export declare function updateProjectActivationDiagnostics(config: InitConfig): void;
+export declare function trackingAllowed(config: InitConfig): boolean;
+export declare function experimentById(experiments: Experiment[]): Map<string, Experiment>;
+export declare function targetingLifecycleMode(experiment: Experiment | undefined): "reset" | "deactivate" | "force_reset" | "persistent";
+export declare function preservePersistentAssignments(previous: Assignment[], next: Assignment[], experiments: Experiment[]): Assignment[];
+export declare function stopAnalyticsStage(): void;
+export declare function canMintVerifiedRedirectCarry(config: InitConfig): boolean;
+export declare function planRedirectAssignment(config: InitConfig, experiments: Experiment[], assignments: Assignment[]): ReturnType<typeof redirectPlanForAssignment>;
+export declare function navigateForRedirectAssignment(config: InitConfig, experiments: Experiment[], assignments: Assignment[]): boolean;
+export declare const RECONCILE_MAX_DRAINS = 3;
+export declare function reevaluateAssignments(reason: "url" | "dom" | "manual" | "prerequisite", forceReapply?: boolean, skipHoldGate?: boolean, pageRuleScope?: PageRuleReconcileScope): Assignment[];
+export declare function reevaluateAssignmentsPass(reason: "url" | "dom" | "manual" | "prerequisite", forceReapply: boolean, skipHoldGate: boolean, pageRuleScope?: PageRuleReconcileScope): Assignment[];
+export declare function reapplyQaAssistantForceMap(): void;
+export declare function reconcileForcedUnavailable(config: InitConfig): void;
+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 clearQaForceFromCurrentUrl(): boolean;
+export declare function initWithExperiments(config: InitConfig, initialExperiments: Experiment[], configSource?: ConfigSource, perfContext?: InitPerfContext, parsedRedirectCarry?: VerifiedRedirectCarry | null, verifiedHandover?: Awaited<ReturnType<typeof readBucketingHandover>>): Assignment[];

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

@@ -0,0 +1,166 @@
+import { type CartAssignment } from "./shopify-cart";
+import { type GiftSyncOptions } from "./commerce-gift";
+import { ActivationMode, Assignment, Experiment, ExclusionGroupConfig, InitConfig, RuntimeSignalDefinition, ExposureDestinationsSettings, TrackEvent } from "./types";
+import { OrderIdentityPlatform } from "./runtime-state";
+import { PendingPerfEvent, InitPhaseKey, DeliveryHealthStatus, ExposureDestinationDiagnostic, RuntimeLoadDiagnostic } from "./config-runtime";
+export declare function scheduleDeferredRouteReevaluation(): void;
+export declare function installDataLayerTriggers(config: InitConfig): (() => void) | null;
+export declare function experimentsUseSurfaceSignals(experiments: Experiment[]): boolean;
+export declare function rememberExposureDestination(result: ExposureDestinationDiagnostic): void;
+export declare let clarityUpgradeSent: boolean;
+export declare function clarityTagKey(prefix: string, name: string): string;
+export declare function pushExposureToQueue(destination: NonNullable<ExposureDestinationsSettings["queues"]>[number], payload: Record<string, unknown>): void;
+export declare function emitExposureDestinations(assignment: Assignment, config: InitConfig): void;
+export declare function ensureTrackerStarted(config: InitConfig): void;
+export declare function exposureAssignmentKey(assignment: Assignment): string;
+export declare function priceAssignmentAuthorizationKey(assignment: {
+    experimentId: string;
+    variationId: string;
+    assignmentEpoch?: number;
+}): string;
+export declare function isPriceDisplayAssignmentAuthorized(assignment: Assignment): boolean;
+export declare function isShippingDisplayAssignmentAuthorized(assignment: Assignment): boolean;
+export declare function isOffersDisplayAssignmentAuthorized(assignment: Assignment): boolean;
+export declare function giftSyncOptions(extra?: Partial<GiftSyncOptions>): GiftSyncOptions;
+export declare function assignmentHasRenderableArtifacts(assignment: Assignment): boolean;
+export declare function authorizeOffersDisplayAndRender(authorizedAssignments: CartAssignment[]): void;
+export declare function revokeOffersDisplayAuthorization(): void;
+export declare function exposureEligibleAssignments(config: InitConfig): Assignment[];
+export declare function isShippingExposureCartEligible(config: InitConfig, assignment: Assignment): boolean;
+export declare function trackViewedAssignmentsAfterShippingEligibility(): void;
+export declare const EMPTY_TARGETING_ATTRIBUTES: Record<string, unknown>;
+export type TargetingEvaluationPass = {
+    attributes?: Record<string, unknown>;
+    persistSignals: boolean;
+    sourceAttributes: Record<string, unknown>;
+    url: string;
+};
+export declare let activeTargetingEvaluationPass: TargetingEvaluationPass | undefined;
+export declare function createTargetingEvaluationPass(sourceAttributes: Record<string, unknown>, url: string, persistSignals: boolean): TargetingEvaluationPass;
+export declare function targetingAttributesForPass(pass: TargetingEvaluationPass | undefined, sourceAttributes: Record<string, unknown>, url: string, persistSignals: boolean): Record<string, unknown>;
+export declare function trackViewedAssignments(config: InitConfig, onlyAssignments?: Assignment[], targetingPass?: TargetingEvaluationPass): void;
+export declare function sameStringSet(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean;
+export declare function setupGoalTracking(experiments: Experiment[], url?: string, activePageIdsForGoals?: Set<string>): void;
+export declare function setupHeatmapTracking(assignments: Assignment[], experiments: Experiment[]): void;
+export declare function cleanupHeatmapTracking(): void;
+export declare function setupReplayTracking(assignments: Assignment[], experiments: Experiment[]): void;
+export declare function cleanupReplayTracking(): void;
+export declare function setupSemanticTracking(config: InitConfig): void;
+export declare function cleanupSemanticTracking(): void;
+export declare function buildExperimentBehaviorEvents(type: "experiment_pageview" | "experiment_page_exit", data?: Record<string, unknown>): TrackEvent[];
+export declare function buildPageExitEvents(type: string, data?: Record<string, unknown>): TrackEvent[];
+export declare function analyticsTrack(type: string, data?: Record<string, unknown>): void;
+export declare function syncLoadDiagnosticsToPerf(): void;
+export declare function updateLoadDiagnostics(patch: Partial<RuntimeLoadDiagnostic> & {
+    stage: string;
+}): void;
+export declare function resetLoadDiagnostics(stage?: string): void;
+export declare function queuePerfEvent(data: PendingPerfEvent): void;
+export type RuntimeInstallClaim = {
+    installSurface: string;
+    sdkVersion: string;
+    runtimeProfile: string;
+};
+export declare const RUNTIME_INSTALL_CLAIM_KEY = "__dripRuntimeInstallClaim";
+export declare const RUNTIME_INSTALL_CONFLICT_KEY = "__dripRuntimeInstallConflictEmitted";
+export declare function telemetryLabel(value: unknown, fallback?: string): string;
+export declare function readRuntimeInstallClaim(): RuntimeInstallClaim | null;
+export declare function rememberRuntimeInstallClaim(config: InitConfig): RuntimeInstallClaim;
+export declare function claimInstallConflictEmission(): boolean;
+export declare function sdkAttributionData(config: InitConfig): Record<string, unknown>;
+export declare function sendRuntimeEventNow(config: InitConfig, type: string, data: Record<string, unknown>, userId?: string | null): void;
+export declare function sendRuntimePerfNow(config: InitConfig, data: Record<string, unknown>, userId?: string | null): void;
+export declare function readDripPerf(): Record<string, unknown>;
+export declare function markDripPerf(name: string): number;
+export declare function numberPerf(perf: Record<string, unknown>, name: string): number | undefined;
+export declare function coexistencePerfFields(perf: Record<string, unknown>): Partial<PendingPerfEvent>;
+export declare function buildPerfEvent(config: InitConfig, timing: {
+    eventKind: "init" | "route_change";
+    assignmentReadyMs: number;
+    initTotalMs?: number;
+    phases?: Partial<Record<InitPhaseKey, number>>;
+    includesConfigFetch?: boolean;
+    predecisionMismatches?: number;
+    blankScreenMs: number;
+    assignmentReadyAt?: number;
+}): PendingPerfEvent;
+export declare function flushPendingPerf(): void;
+export declare function orderIdentityEndpoint(config: InitConfig): string | null;
+export declare const ORDER_EXPOSURE_STORAGE_KEY = "drip_exposures";
+export declare const ORDER_EXPOSURE_MAX_ENTRIES = 50;
+export declare const ORDER_EXPOSURE_TTL_MS: number;
+export type StoredOrderExposure = {
+    e: string;
+    v: string;
+    t: number;
+};
+export declare function pruneStoredOrderExposures(exposures: StoredOrderExposure[], now?: number): StoredOrderExposure[];
+export declare function readStoredOrderExposures(): StoredOrderExposure[];
+export declare function writeStoredOrderExposures(exposures: StoredOrderExposure[]): void;
+export declare function clearIdentityContextCookie(): void;
+export declare function recentIdentityContextExposures(): StoredOrderExposure[];
+export declare function buildIdentityContextCookieValue(visitorId: string, sessionId: string, exposures: StoredOrderExposure[]): string | null;
+export declare function generateSessionId(): string;
+export declare function getIdentityContextSessionId(): string;
+export declare function writeIdentityContextCookie(): StoredOrderExposure[];
+export declare function isOffTargetPersistedAssignment(assignment: Assignment): boolean;
+export declare function restoreRecordedExposureDedup(exposures: StoredOrderExposure[]): void;
+export declare function rememberOrderExposure(assignment: Assignment): void;
+export declare function mergedOrderIdentityAssignments(): Array<{
+    experimentId: string;
+    variationId: string;
+}>;
+export declare function cleanOrderIdentityText(value: unknown): string | null;
+export declare function resolveOrderIdentityPlatform(): OrderIdentityPlatform;
+export declare function detectOrderIdentity(): {
+    platform: OrderIdentityPlatform;
+    platformOrderId: string | null;
+    orderNumber: string | null;
+} | null;
+export declare function orderIdentityDedupeKey(identity: {
+    platform: string;
+    platformOrderId: string | null;
+    orderNumber: string | null;
+}, assignments: Array<{
+    experimentId: string;
+    variationId: string;
+}>): string;
+export declare function scheduleOrderIdentityBeacon(config: InitConfig): void;
+export declare function deliveryStatus(expected: number, applied: number, missed: number, isControl: boolean): DeliveryHealthStatus;
+export declare function queueDeliveryHealthEvent(assignment: Assignment, data: {
+    expectedMutations: number;
+    appliedMutations: number;
+    selectorMisses: number;
+    applyGeneration: number;
+    activationMode: ActivationMode;
+}): void;
+export declare function flushPendingDeliveryHealth(): void;
+export declare function startAnalyticsStage(config: InitConfig, experiments: Experiment[], initialExposureAssignments?: Assignment[], targetingPass?: TargetingEvaluationPass | undefined): void;
+export declare function scheduleAnalyticsStart(config: InitConfig, experiments: Experiment[], targetingPass?: TargetingEvaluationPass): void;
+export declare function startAnalyticsIfReady(): void;
+export declare function getConfigCacheKey(shopId: string, environmentKey?: string): string;
+export declare function storageAvailable(kind: "localStorage" | "sessionStorage"): boolean;
+export declare function getConfigCacheTtlMs(config: InitConfig): number;
+export declare function configuredStoreOrigins(config: Pick<InitConfig, "storeOrigin" | "storeOrigins">): string | string[] | undefined;
+export declare function readCachedExperiments(shopId: string, ttlMs: number, environmentKey?: string): {
+    experiments: Experiment[];
+    storeOrigin?: string;
+    storeOrigins?: string[];
+    exclusionGroups?: ExclusionGroupConfig[];
+    profile?: InitConfig["profile"];
+    runtime?: unknown;
+    signals?: RuntimeSignalDefinition[];
+    commerce?: InitConfig["commerce"];
+    geo?: {
+        country?: string;
+    };
+    holdout?: [enabled?: boolean, pct?: number, configUpdatedAt?: string | null];
+    hash: string;
+} | null;
+export declare function hashConfigPayload(experiments: Experiment[], storeOrigin?: string, storeOrigins?: string[], exclusionGroups?: ExclusionGroupConfig[], profile?: InitConfig["profile"], runtime?: unknown, signals?: RuntimeSignalDefinition[], commerce?: InitConfig["commerce"], holdout_v1_enabled?: boolean, holdout_pct?: number, holdout_config_updated_at?: string | null): string;
+export declare function writeCachedExperiments(shopId: string, experiments: Experiment[], storeOrigin?: string, storeOrigins?: string[], exclusionGroups?: ExclusionGroupConfig[], profile?: InitConfig["profile"], runtime?: unknown, signals?: RuntimeSignalDefinition[], commerce?: InitConfig["commerce"], holdout_v1_enabled?: boolean, holdout_pct?: number, holdout_config_updated_at?: string | null, geo?: {
+    country?: string;
+}, environmentKey?: string): void;
+export declare function withRuntimeSettings(config: InitConfig, runtime: unknown, profile?: InitConfig["profile"]): InitConfig;
+export declare function serializeForceMap(forceMap: Record<string, string> | null): string;
+export declare function getHashId(exp: Experiment, userId: string, attrs: Record<string, unknown>): string;

package/dist/types/antiflicker.d.ts

@@ -7,8 +7,14 @@ export declare function resolveAntiFlickerCss(mode?: AntiFlickerMode, scopedSele
  * - "off": no-op.
  * Scoped mode is a no-op when no selectors are available.
  *
- * Progressive reveal: at 80% of timeout, begins a CSS transition to fade
- * content in gradually rather than a sudden flash at timeout expiry.
+ * Progressive reveal: at 80% of timeout, scoped mode reveals its selectors.
+ * Full mode stays hidden and only pre-arms its opacity transition.
  */
-export declare function applyAntiFlicker(mode?: AntiFlickerMode, timeoutMs?: number, scopedSelectors?: string[], customCss?: string): void;
+export declare function applyAntiFlicker(mode?: AntiFlickerMode, timeoutMs?: number, scopedSelectors?: string[], customCss?: string, bootedTooLate?: boolean): boolean;
+/**
+ * Runtime-loaded SDKs must not introduce a hiding barrier after the browser
+ * has likely painted. Inline edge bootstrap callers deliberately do not opt
+ * into this guard because their barrier is installed synchronously pre-paint.
+ */
+export declare function bootedTooLateForAntiFlicker(): boolean;
 export declare function removeAntiFlicker(): void;

package/dist/types/assignment-cookie-sync.d.ts

@@ -0,0 +1,31 @@
+export declare const ASSIGNMENT_SYNC_COOKIE_NAME = "drip_assignment_sync_v1";
+export declare const ASSIGNMENT_SYNC_COOKIE_MAX_AGE_SECONDS = 7200;
+export declare const ASSIGNMENT_SYNC_COOKIE_MAX_BYTES = 3800;
+export type AssignmentSyncPayload = {
+    visitorId: string | null;
+    sessionId: string;
+    cartToken?: string;
+    qaMode: boolean;
+    qaSessionId: string;
+    cohort?: "holdout" | "active";
+    holdoutConfigEpoch?: number;
+    assignments: Array<{
+        experimentId: string;
+        variationId: string;
+        assignmentEpoch?: number;
+    }>;
+};
+export type AssignmentSyncCookieWriteResult = {
+    written: boolean;
+    assignmentCount: number;
+    truncatedAssignmentCount: number;
+    encodedBytes: number;
+    domain?: string;
+    reason?: "document_unavailable" | "visitor_id_missing" | "cookie_too_large" | "cookie_write_failed";
+};
+type CookieDocument = Pick<Document, "cookie">;
+export declare function encodeStoredAssignment(data: AssignmentSyncPayload): string;
+export declare function discoverRegistrableDomain(hostname: string, documentRef: CookieDocument): string | undefined;
+export declare function writeAssignmentSyncCookie(payload: AssignmentSyncPayload): AssignmentSyncCookieWriteResult;
+export declare function clearAssignmentSyncCookie(): void;
+export {};

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

@@ -0,0 +1,257 @@
+import { findPersistedVariation, prunePersistedAssignments } from "./assignment-store";
+import { type ExclusionGroupDecision } from "./exclusion-groups";
+import type { CompactGroupSelections } from "./persistence-decoders";
+import { ActivationMode, Assignment, ActivationGateDiagnostic, ConditionDiagnostic, Experiment, ExperimentActivationDiagnostic, ExclusionGroupConfig, PageTargetingRule, PageActivationDiagnostic, PageDeactivationMode, SnippetCriticalMutation, SnippetCriticalMutationPlanItem, SnippetDeliveryUrlRule, Mutation } from "./types";
+import { PageActivationRuntimeState } from "./runtime-state";
+import { PageDetectorMode, PageRuleReconcileScope } from "./config-runtime";
+import { TargetingEvaluationPass } from "./analytics-runtime";
+export type PersistedAssignmentMap = ReturnType<typeof prunePersistedAssignments>;
+export declare const GLOBAL_PAGE_PREFIX = "\u0001experiment:";
+export declare const appliedAssignmentsByKey: Map<string, Assignment>;
+export type ArtifactId = string & {
+    readonly __artifactId: unique symbol;
+};
+export declare const invalidatedArtifactIds: Set<ArtifactId>;
+export declare const artifactEpochs: Map<string, number>;
+export declare let applyPassEpoch: number;
+export declare function artifactEpochCurrent(ownerKeys: readonly string[], epoch: number): boolean;
+export type PageActivationTransition = {
+    pageId: string;
+    mode: PageDeactivationMode;
+    previousActive: boolean;
+    active: boolean;
+    teardown: boolean;
+    reapply: boolean;
+};
+export declare function normalizePageDeactivationMode(rule: PageTargetingRule): PageDeactivationMode;
+export declare function effectiveDeactivationMode(experiment: Experiment, rule: PageTargetingRule): PageDeactivationMode;
+export declare function includedPageRules(experiment: Experiment | undefined): PageTargetingRule[];
+export declare function currentPageMatchContext(url: string, targetingPass?: TargetingEvaluationPass): {
+    url: string;
+    attributes: Record<string, unknown>;
+};
+export declare function pageActivationDiagnosticRows(options?: {
+    includePageNames?: boolean;
+}): PageActivationDiagnostic[];
+export declare function reconcilePageActivation(experiments: Experiment[], url: string, options?: {
+    previous?: ReadonlyMap<string, PageActivationRuntimeState>;
+    persistedAssignments?: PersistedAssignmentMap;
+    targetingPass?: TargetingEvaluationPass;
+    pageRuleScope?: PageRuleReconcileScope;
+}): {
+    transitions: PageActivationTransition[];
+    next: Map<string, PageActivationRuntimeState>;
+    pollRules: PageTargetingRule[];
+};
+export declare function cancelPageRulePoll(pageId: string): void;
+export declare function cancelAllPageRulePolls(): void;
+export declare function pageRulePollSettings(): {
+    intervalMs: number;
+    windowMs: number;
+};
+export declare function deactivationModeForTriggeredRule(rule: PageTargetingRule): PageDeactivationMode;
+export declare function reconcileTriggeredPageMatch(rule: PageTargetingRule, matched: boolean, detector?: PageDetectorMode, options?: {
+    elapsedMs?: number;
+    fromPoll?: boolean;
+    pollAttempts?: number;
+}): boolean;
+export declare function startPageRulePoll(rule: PageTargetingRule, detector?: PageDetectorMode): void;
+export declare function firePageDetector(detector: PageDetectorMode, resolvedUrl: string): Set<string>;
+export declare function activePageIds(): Set<string>;
+export declare function experimentHasActivePage(experiment: Experiment | undefined): boolean;
+export declare function syncAssignmentPageActive(assignments: Assignment[], experiments: Experiment[]): Assignment[];
+export declare function assignmentPageIds(assignment: Assignment): string[];
+export declare function stableArtifactJson(value: unknown): string;
+export declare function artifactContentHash(assignment: Assignment): string;
+export declare function baseArtifactApplicationKey(assignment: Assignment): ArtifactId;
+export declare function artifactApplicationKey(assignment: Assignment, pageId: string): string;
+export declare function artifactIdFromApplicationKey(applicationKey: string): ArtifactId;
+export declare function assignmentRuntimeKeys(assignments: Assignment[]): Set<string>;
+export declare function artifactOwnerId(applicationKey: string): string;
+export declare function redirectCarryAssignmentKey(experimentId: string, variationId: string, epoch: number): string;
+export declare function shouldPreserveOffTargetRedirectAssignment(assignment: Assignment): boolean;
+export declare function isAssignmentArtifactInactive(assignment: Assignment): boolean;
+export declare function renderable(assignment: Assignment): boolean;
+export declare function exposable(assignment: Assignment): boolean;
+export declare function attributable(assignment: Assignment): boolean;
+export declare function recordAttributableAssignments(assignments: Assignment[]): void;
+export declare function attributionLedgerAssignments(): Assignment[];
+export declare function artifactRenderableAssignments(assignments: Assignment[]): Assignment[];
+export declare function activeRenderableAssignments(): Assignment[];
+export declare function chargeAffectingAssignments(): Assignment[];
+export declare function loadPersistedAssignments(experiments: Experiment[]): PersistedAssignmentMap | undefined;
+export declare function buildPersistedAssignmentResult(experiment: Experiment, persisted: NonNullable<ReturnType<typeof findPersistedVariation>>, hashId: string, gates: ActivationGateDiagnostic[], targetingConditions: ConditionDiagnostic[], url: string, reason: "persisted_assignment" | "persisted_assignment_off_target"): {
+    assignment: Assignment;
+    diagnostic: ExperimentActivationDiagnostic;
+};
+export declare function withAssignmentEpochData(data: Record<string, unknown> | undefined, experimentId?: string, variationId?: string): Record<string, unknown> | undefined;
+export declare function usesStickyAssignmentPersistence(experiment: Experiment): boolean;
+export declare function persistActiveExperimentAssignments(experiments: Experiment[]): void;
+export declare function experimentDiagnostic(experiment: Experiment, gates: ActivationGateDiagnostic[], assignment: Assignment | null, reason?: string, forced?: boolean, targetingConditions?: ConditionDiagnostic[]): ExperimentActivationDiagnostic;
+export declare function evaluateExperimentDetailed(experiment: Experiment, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+    storeOrigin?: string | string[];
+    persistedAssignments?: PersistedAssignmentMap;
+    holdout?: {
+        enabled?: boolean;
+        percentage?: number;
+    };
+}): {
+    assignment: Assignment | null;
+    diagnostic: ExperimentActivationDiagnostic;
+};
+export declare function evaluateExperiment(experiment: Experiment, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+    storeOrigin?: string | string[];
+    persistedAssignments?: PersistedAssignmentMap;
+}): Assignment | null;
+export declare function stoppedPersonalizationDiagnostic(diagnostic: ExperimentActivationDiagnostic): ExperimentActivationDiagnostic;
+export declare function enforcePersonalizationStopAfterMatch(assignments: Assignment[], diagnostics?: ExperimentActivationDiagnostic[]): {
+    assignments: Assignment[];
+    diagnostics?: ExperimentActivationDiagnostic[];
+};
+export declare function excludedByGroupDiagnostic(diagnostic: ExperimentActivationDiagnostic, decision: ExclusionGroupDecision): ExperimentActivationDiagnostic;
+export declare function keptByGroupDiagnostic(diagnostic: ExperimentActivationDiagnostic, reason: "exclusion_group_no_overlap" | "exclusion_group_overlap_winner" | "exclusion_group_sticky_winner", detail: {
+    groupId: string;
+    conflictingExperimentIds: string[];
+}): ExperimentActivationDiagnostic;
+export declare function applyExclusionAndPersonalization(assignments: Assignment[], context: {
+    userId: string;
+    exclusionGroups?: ExclusionGroupConfig[];
+    storedGroupSelections?: CompactGroupSelections;
+}, diagnostics?: ExperimentActivationDiagnostic[]): {
+    assignments: Assignment[];
+    diagnostics?: ExperimentActivationDiagnostic[];
+    decisions: ExclusionGroupDecision[];
+};
+export declare function evaluate(experiments: Experiment[], context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+    persistSignals?: boolean;
+    storeOrigin?: string | string[];
+    exclusionGroups?: ExclusionGroupConfig[];
+}): Assignment[];
+export declare function evaluateWithDiagnostics(experiments: Experiment[], context?: {
+    url?: string;
+    attributes?: Record<string, unknown>;
+    userId?: string;
+    persistSignals?: boolean;
+    storeOrigin?: string | string[];
+    exclusionGroups?: ExclusionGroupConfig[];
+    storedGroupSelections?: CompactGroupSelections;
+    persistedAssignments?: PersistedAssignmentMap | null;
+    holdout?: {
+        enabled?: boolean;
+        percentage?: number;
+    };
+    targetingPass?: TargetingEvaluationPass;
+}): {
+    assignments: Assignment[];
+    diagnostics: ExperimentActivationDiagnostic[];
+};
+export declare function evaluateEdgeRuntimeAssignments(experiments: Experiment[], context: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+}, eligibleAssignments?: Assignment[], eligibleDiagnostics?: ExperimentActivationDiagnostic[]): {
+    assignments: Assignment[];
+    diagnostics: ExperimentActivationDiagnostic[];
+    experimentIds: Map<string, import("./edge-runtime").EdgeRuntimeAssignment>;
+} | null;
+export declare function resolveCombinedEdgeEvaluation(edgeAssignments: Assignment[], fallbackAssignments: Assignment[], diagnostics: ExperimentActivationDiagnostic[], context: {
+    userId: string;
+    exclusionGroups?: ExclusionGroupConfig[];
+}): {
+    assignments: Assignment[];
+    diagnostics: ExperimentActivationDiagnostic[];
+};
+export declare function escapeDeliveryRegex(value: string): string;
+export declare function matchSimpleDeliveryPattern(pattern: string, url: string): boolean;
+export declare function matchRegexDeliveryPattern(pattern: string, url: string): boolean;
+export declare function matchesDeliveryUrlRules(rules: SnippetDeliveryUrlRule[] | undefined, url: string): boolean;
+export declare function expandCriticalMutation(raw: SnippetCriticalMutation): Mutation | null;
+export declare function buildCriticalPathAssignments(experiments: Experiment[], plan: SnippetCriticalMutationPlanItem[] | undefined, ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    userId: string;
+}): {
+    assignments: Assignment[];
+    plannedExperimentIds: Set<string>;
+    skippedDiagnostics: ExperimentActivationDiagnostic[];
+};
+export declare function runPostRevealReassert(): void;
+export declare function schedulePostRevealReassert(): void;
+export declare function revealExperimentContent(options?: {
+    postRevealReassert?: boolean;
+}): void;
+export declare function applyAssignmentCode(assignment: Assignment, applyEpoch: number, appliedExperimentCode: Set<string>, ownerKeys: readonly string[], ownerIds: readonly string[], runCustomJs?: boolean, onCustomJsRun?: () => void): void;
+export declare function recordAppliedAssignment(assignment: Assignment, pageIds: readonly string[]): string[];
+export declare function appliedOwnerKeysForAssignment(assignment: Assignment): string[];
+export declare function applyAssignments(assignments: Assignment[], activationMode: ActivationMode, options?: {
+    pageIds?: ReadonlySet<string>;
+    goalUrl?: string;
+}): void;
+export declare function reassertAssignmentMutations(assignments: Assignment[]): void;
+export type TeardownPage = {
+    pageId: string;
+    mode: PageDeactivationMode;
+};
+export type TeardownRuntimeOptions = {
+    goalUrl?: string;
+    skipCartSync?: boolean;
+};
+export type TeardownSelection = Map<string, {
+    artifactIds: Set<ArtifactId>;
+    mode: PageDeactivationMode;
+}>;
+export declare function runAssignmentResetJs(assignments: Iterable<Assignment>): void;
+export declare let pendingCommercePriceResolve: (() => void) | null;
+export declare function resolveCommercePricePending(): void;
+export declare function unwireGoals(): void;
+export declare function goalWiringEligible(): boolean;
+export declare function reconcileGoals(url?: string): void;
+export declare function reconcileHarnessPolling(): void;
+export declare function reconcileCommercePrice(): void;
+export declare function reconcileCommerceShipping(): void;
+export declare function reconcileCartSync(): void;
+export declare function syncGlobalRuntimes(options?: {
+    goalUrl?: string;
+    skipCartSync?: boolean;
+}): void;
+export declare function configuredPageDeactivationModes(): Map<string, PageDeactivationMode>;
+export declare function allAppliedPagesWithModes(): TeardownPage[];
+export declare function rollbackArtifactOwner(pageId: string, artifactId: ArtifactId): void;
+export declare function unregisterArtifactOwner(ownerKey: string): void;
+export declare function executeTeardownTransaction(selection: TeardownSelection, runtimeOptions?: TeardownRuntimeOptions): void;
+export declare function teardownTransaction(pages: TeardownPage[], runtimeOptions?: TeardownRuntimeOptions): void;
+export declare function teardownArtifactsTransaction(artifactIds: ReadonlySet<ArtifactId>, runtimeOptions?: TeardownRuntimeOptions): void;
+export type DesiredArtifact = {
+    id: ArtifactId;
+    assignment: Assignment;
+    ownerPageIds: Set<string>;
+};
+export type LiveArtifact = DesiredArtifact & {
+    ownerKeys: Set<string>;
+};
+export type ArtifactReconcileResult = {
+    applied: number;
+    ownerUpdates: number;
+    removed: number;
+    replayed: number;
+};
+export declare function desiredArtifactSet(assignments: Assignment[]): Map<ArtifactId, DesiredArtifact>;
+export declare function liveArtifactInventory(): Map<ArtifactId, LiveArtifact>;
+export declare function removeArtifactOwner(artifactId: ArtifactId, pageId: string): void;
+export declare function registerDesiredOwners(desired: DesiredArtifact, live: LiveArtifact): {
+    ownerKeys: string[];
+    added: boolean;
+    epoch: number;
+};
+export declare function replayDesiredArtifacts(artifacts: DesiredArtifact[]): void;
+export declare function invalidateLiveArtifactsForReplay(): void;
+export declare function reconcileArtifacts(desired: Map<ArtifactId, DesiredArtifact>, goalUrl?: string): ArtifactReconcileResult;

package/dist/types/assignment-store.d.ts

@@ -1,13 +1,10 @@
 import type { Experiment, Variation } from "./types";
-export type PersistedAssignmentRecord = {
-    variationId: string;
-    epoch: number;
-    assignedAt: number;
-};
+import { type PersistedAssignmentRecord } from "./persistence-decoders";
+export { decodePersistedAssignments, type PersistedAssignmentRecord } from "./persistence-decoders";
 type CompactRecord = [string, number, number];
 type CompactStore = Record<string, CompactRecord>;
 declare function assignmentEpoch(experiment: Experiment): number;
-declare function parseStore(raw: string | null): CompactStore;
+export declare function decodeCompactAssignmentStore(raw: string | null): CompactStore;
 declare function serializeStore(store: CompactStore, maxEntries?: number): string;
 export declare function readPersistedAssignments(): Record<string, PersistedAssignmentRecord>;
 export declare function writePersistedAssignments(records: Record<string, PersistedAssignmentRecord>): void;
@@ -24,7 +21,6 @@ export declare const __assignmentStoreInternals: {
     STORAGE_KEY: string;
     COOKIE_NAME: string;
     assignmentEpoch: typeof assignmentEpoch;
-    parseStore: typeof parseStore;
+    parseStore: typeof decodeCompactAssignmentStore;
     serializeStore: typeof serializeStore;
 };
-export {};

package/dist/types/bucket.d.ts

@@ -1,2 +1 @@
-export declare function inTrafficAllocation(hashValue: number, allocation?: number): boolean;
-export declare function chooseVariation(hashValue: number, weights: number[]): number;
+export { chooseVariation, inTrafficAllocation } from "@drip/shared-runtime/bucketing";

package/dist/types/compact-store.d.ts

@@ -0,0 +1 @@
+export declare function decodeCompactStore(raw: string | null, width: 2 | 3): Record<string, unknown[]>;