@fanfare-io/fanfare-sdk-core 0.1.0

package/dist/test-utils/mock-sdk-vitest.d.ts

@@ -0,0 +1,80 @@
+import { JourneyHandle } from '../experiences/journey.types';
+/**
+ * Canonical vi.fn()-wrapped SDK object for adapter test files (react/solid).
+ *
+ * Lives in this dedicated subpath (not the main test-utils entry) so that
+ * `@fanfare-io/fanfare-sdk-core/test-utils` consumers without Vitest in their
+ * runtime (e.g. Playwright-only sdk-harness) don't take a hard dependency on
+ * vitest at import time. Import directly from
+ * `@fanfare-io/fanfare-sdk-core/test-utils/vitest`.
+ *
+ * All 4 use-experience-journey and experience-widget test files share this
+ * shape. The caller provides `journeyHandle` (from `createMockJourneyHandle`)
+ * so that `experiences.createJourney` and `journeys.get` return the same
+ * controllable handle.
+ *
+ * @example
+ * ```ts
+ * import { createMockJourneyHandle, makeReadySnapshot } from "@fanfare-io/fanfare-sdk-core/test-utils";
+ * import { createMockSDKObject } from "@fanfare-io/fanfare-sdk-core/test-utils/vitest";
+ *
+ * const mockJourney = createMockJourneyHandle({ initialSnapshot: makeReadySnapshot("exp_123") });
+ * const { sdk, events } = createMockSDKObject(mockJourney.handle);
+ * ```
+ */
+export declare function createMockSDKObject(journeyHandle: JourneyHandle): {
+    sdk: {
+        auth: {
+            check: import('vitest').Mock<() => {
+                isAuthenticated: boolean;
+            }>;
+            guest: import('vitest').Mock<(...args: any[]) => any>;
+            requestOtp: import('vitest').Mock<(...args: any[]) => any>;
+            verifyOtp: import('vitest').Mock<(...args: any[]) => any>;
+            login: import('vitest').Mock<(...args: any[]) => any>;
+            logout: import('vitest').Mock<(...args: any[]) => any>;
+            refresh: import('vitest').Mock<(...args: any[]) => any>;
+            getSession: import('vitest').Mock<() => null>;
+        };
+        challenges: {
+            initiate: import('vitest').Mock<(...args: any[]) => any>;
+            verify: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        queues: {
+            startPolling: import('vitest').Mock<(...args: any[]) => any>;
+            stopPolling: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        auctions: {
+            startWatching: import('vitest').Mock<(...args: any[]) => any>;
+            stopWatching: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        draws: {
+            scheduleResultCheck: import('vitest').Mock<(...args: any[]) => any>;
+            cancelScheduledCheck: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        waitlists: {};
+        timedReleases: {};
+        experiences: {
+            get: import('vitest').Mock<(...args: any[]) => any>;
+            createJourney: import('vitest').Mock<(...args: any[]) => any>;
+            getMe: import('vitest').Mock<(...args: any[]) => any>;
+            destroy: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        journeys: {
+            get: import('vitest').Mock<(...args: any[]) => any>;
+            list: import('vitest').Mock<(...args: any[]) => any>;
+            resumeAll: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        beacon: {
+            track: import('vitest').Mock<(...args: any[]) => any>;
+            trackBatch: import('vitest').Mock<(...args: any[]) => any>;
+            flush: import('vitest').Mock<(...args: any[]) => any>;
+        };
+        on: import('vitest').Mock<(event: string, handler: (data: Record<string, unknown>) => void) => () => void>;
+        destroy: import('vitest').Mock<(...args: any[]) => any>;
+    };
+    events: {
+        on: import('vitest').Mock<(event: string, handler: (data: Record<string, unknown>) => void) => () => void>;
+        emit: (event: string, data: Record<string, unknown>) => void;
+    };
+};

package/dist/test-utils/mock-sdk-vitest.js

@@ -0,0 +1 @@
+import{vi as e}from"vitest";function n(n){const o={},t=e.fn((e,n)=>(o[e]||(o[e]=[]),o[e].push(n),()=>{const t=o[e].indexOf(n);t>-1&&o[e].splice(t,1)}));return{sdk:{auth:{check:e.fn(()=>({isAuthenticated:!1})),guest:e.fn().mockResolvedValue({type:"guest",consumerId:"c_1"}),requestOtp:e.fn().mockResolvedValue(void 0),verifyOtp:e.fn().mockResolvedValue({session:"verified"}),login:e.fn().mockResolvedValue(void 0),logout:e.fn().mockResolvedValue(void 0),refresh:e.fn().mockResolvedValue(void 0),getSession:e.fn(()=>null)},challenges:{initiate:e.fn().mockResolvedValue({}),verify:e.fn().mockResolvedValue(void 0)},queues:{startPolling:e.fn(),stopPolling:e.fn()},auctions:{startWatching:e.fn(),stopWatching:e.fn()},draws:{scheduleResultCheck:e.fn(),cancelScheduledCheck:e.fn()},waitlists:{},timedReleases:{},experiences:{get:e.fn().mockResolvedValue({id:"exp_123",name:"Test"}),createJourney:e.fn().mockReturnValue(n),getMe:e.fn(),destroy:e.fn()},journeys:{get:e.fn().mockReturnValue(n),list:e.fn().mockReturnValue([]),resumeAll:e.fn().mockResolvedValue([])},beacon:{track:e.fn(),trackBatch:e.fn(),flush:e.fn()},on:t,destroy:e.fn()},events:{on:t,emit:(e,n)=>{o[e]?.forEach(e=>e(n))}}}}export{n as createMockSDKObject};

package/dist/test-utils/mock-sdk.d.ts

@@ -0,0 +1,22 @@
+import { AuctionDetails, AuctionStatus } from '../auctions/types';
+import { Draw, DrawConsumerState } from '../draws/types';
+import { ExperienceDetails, ExperienceSession } from '../experiences/types';
+import { Queue, QueueConsumerState } from '../queues/types';
+import { TimedRelease, TimedReleaseConsumerState } from '../timed-releases/types';
+import { FanfareSDK, InternalFanfareSDK } from '../types';
+import { WaitlistEntry, WaitlistStatus } from '../waitlists/types';
+export declare const mockQueue: Queue;
+export declare const mockQueueEnterResult: QueueConsumerState;
+export declare const mockQueueStatus: QueueConsumerState;
+export declare const mockAuction: AuctionDetails;
+export declare const mockAuctionStatus: AuctionStatus;
+export declare const mockDraw: Draw;
+export declare const mockDrawStatus: DrawConsumerState;
+export declare const mockWaitlistEntry: WaitlistEntry;
+export declare const mockWaitlistStatus: WaitlistStatus;
+export declare const mockTimedRelease: TimedRelease;
+export declare const mockTimedReleaseStatus: TimedReleaseConsumerState;
+export declare const mockExperience: ExperienceDetails;
+export declare const mockExperienceSession: ExperienceSession;
+export declare function createMockFanfareSDK(overrides?: Partial<FanfareSDK>): FanfareSDK;
+export declare function createMockInternalFanfareSDK(overrides?: Partial<InternalFanfareSDK>): InternalFanfareSDK;

package/dist/test-utils/mock-sdk.js

@@ -0,0 +1 @@
+import{createMockJourneyHandle as e,makeReadySnapshot as t}from"./mock-journey.js";const n={type:"guest",consumerId:"consumer_guest_123",guestId:"guest_123",email:void 0,expiresAt:new Date(Date.now()+36e5).toISOString()},s={type:"authenticated",consumerId:"consumer_auth_123",email:"test@example.com",expiresAt:new Date(Date.now()+36e5).toISOString()},i={id:"queue_test_123",experienceId:"experience_test_123",name:"Test Queue",status:"open",currentSize:0},a={position:1,estimatedWaitTimeInSeconds:60,status:"QUEUED"},o={status:"NOT_QUEUED"},c={id:"auction_test_123",openAt:/* @__PURE__ */(new Date).toISOString(),closeAt:new Date(Date.now()+6e4).toISOString(),settleAt:new Date(Date.now()+6e4).toISOString(),currencyCode:"USD",reservePrice:null,minBidIncrement:"1.00",autoExtendSeconds:null,timeZone:"UTC"},r={auctionId:"auction_test_123",status:"watching",highestBid:"0.00",timeRemaining:6e4},u={id:"draw_test_123",openAt:/* @__PURE__ */(new Date).toISOString(),closeAt:null,timeZone:"UTC",drawAt:new Date(Date.now()+6e4).toISOString(),capacity:null,continueSelectingUntilCompleted:null},d={status:"NOT_ENTERED"},y={id:"waitlist_entry_123",waitlistId:"waitlist_test_123",sequenceId:"sequence_test_123",consumerId:"consumer_test_123",enteredAt:/* @__PURE__ */(new Date).toISOString()},l={waitlistId:"waitlist_test_123",isEntered:!1},g={id:"timed_release_test_123",timeZone:"UTC",supportsGuest:!1},m={status:"NOT_ENTERED"},p={id:"experience_test_123",name:"Test Experience",createdAt:/* @__PURE__ */(new Date).toISOString(),updatedAt:/* @__PURE__ */(new Date).toISOString()},S={experienceId:"experience_test_123",enteredAt:/* @__PURE__ */(new Date).toISOString()};function _(){const i=e({initialSnapshot:t(p.id)}).handle;return{auth:{check:()=>({isAuthenticated:!1}),guest:async()=>n,requestOtp:async()=>{},verifyOtp:async()=>s,exchangeExternal:async()=>s,login:async()=>{},logout:async()=>{},getSession:()=>null,refresh:async()=>{}},challenges:{initiate:async()=>({}),verify:async()=>({status:"failed",attemptsRemaining:0})},journeys:{get:()=>i,list:()=>[],resumeAll:async()=>[]},beacon:{track:async()=>{},trackBatch:async()=>{},flush:async()=>{}},appointments:{get:async()=>({id:"appt_mock",type:"appointment"}),getSlots:async()=>[],getMe:async()=>null,book:async(e,t,n)=>({bookingId:"booking_mock",appointmentId:e,slotId:t,locationId:n,startTime:/* @__PURE__ */(new Date).toISOString(),endTime:/* @__PURE__ */(new Date).toISOString(),confirmationCode:"MOCK",consumerStatus:"booked"}),cancel:async()=>{},reschedule:async(e,t,n)=>({bookingId:"booking_mock",appointmentId:e,slotId:t,locationId:n,startTime:/* @__PURE__ */(new Date).toISOString(),endTime:/* @__PURE__ */(new Date).toISOString(),confirmationCode:"MOCK",consumerStatus:"booked"}),startMonitoring:()=>{},stopMonitoring:()=>{},isMonitoring:()=>!1,bumpMonitorGeneration:()=>{},destroy:()=>{}},on:()=>()=>{},use:()=>{},destroy:async()=>{}}}function I(e={}){return{..._(),...e}}function w(n={}){return{...{..._(),queues:{get:async()=>i,enter:async()=>a,leave:async()=>{},status:async()=>o,startMonitoring:()=>{},stopMonitoring:()=>{},isMonitoring:()=>!1},auctions:{get:async()=>c,bid:async()=>({status:"accepted",amount:"10.00",highestBid:"10.00",bidCount:1}),enter:async()=>{},leave:async()=>{},status:async()=>r,getBidHistory:async()=>[],enableAutoRebid:()=>{},disableAutoRebid:()=>{},getAutoRebidConfig:()=>{},startMonitoring:()=>{},stopMonitoring:()=>{},isMonitoring:()=>!1,destroy:()=>{}},draws:{get:async()=>u,enter:async()=>({status:"ENTERED"}),leave:async()=>{},status:async()=>d,startMonitoring:()=>{},stopMonitoring:()=>{},isMonitoring:()=>!1},waitlists:{enter:async()=>y,leave:async()=>{},getStatus:async()=>l,destroy:()=>{}},timedReleases:{get:async()=>g,enter:async()=>({status:"ENTERED",enteredAt:/* @__PURE__ */(new Date).toISOString()}),leave:async()=>{},complete:async()=>{},status:async()=>m,startMonitoring:()=>{},stopMonitoring:()=>{},isMonitoring:()=>!1},experiences:{get:async()=>p,enter:async()=>S,leave:async()=>{},findSequence:async()=>({outcome:"routed",selected:{sequence:{id:"sequence_test_123",name:"Test Sequence",experienceId:"experience_test_123",priority:1,color:"#000000"},status:"admissible",gates:[]},offers:[]}),validateSequenceAccess:async()=>({sequenceId:"sequence_test_123",hasAccess:!0,accessReasons:[],deniedReasons:[]}),selectSequence:async()=>{},getCurrentDistributions:async()=>({}),enterDistribution:async()=>{},getActiveSession:()=>null,isInExperience:()=>!1,getSelectedSequence:()=>null,getMe:async()=>({active:{journeys:[]}}),destroy:()=>{},createJourney:n=>e({initialSnapshot:t(n)}).handle,resumeJourneysFromMe:async()=>[]}},...n}}export{I as createMockFanfareSDK,w as createMockInternalFanfareSDK,c as mockAuction,r as mockAuctionStatus,u as mockDraw,d as mockDrawStatus,p as mockExperience,S as mockExperienceSession,i as mockQueue,a as mockQueueEnterResult,o as mockQueueStatus,g as mockTimedRelease,m as mockTimedReleaseStatus,y as mockWaitlistEntry,l as mockWaitlistStatus};

package/dist/test-utils/mock-server.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Mock Server for API interception and testing
+ *
+ * This class intercepts fetch requests and provides controlled responses
+ * for testing the Fanfare SDK without hitting real endpoints.
+ */
+export interface MockResponse {
+    status?: number;
+    statusText?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    delay?: number;
+    error?: Error | string;
+}
+export interface MockEndpoint {
+    method: string;
+    pathPattern: string | RegExp;
+    response: MockResponse | ((request: Request) => MockResponse | Promise<MockResponse>);
+}
+export interface MockServerConfig {
+    baseUrl: string;
+    defaultDelay?: number;
+    logRequests?: boolean;
+    fallbackToNetwork?: boolean;
+}
+export declare class MockServer {
+    private endpoints;
+    private interceptedRequests;
+    private isActive;
+    private config;
+    constructor(config: MockServerConfig);
+    /**
+     * Register a mock endpoint
+     */
+    mock(method: string, pathPattern: string | RegExp, response: MockResponse | ((request: Request) => MockResponse | Promise<MockResponse>)): this;
+    /**
+     * Convenience methods for common HTTP methods
+     */
+    get(pathPattern: string | RegExp, response: MockResponse | ((req: Request) => MockResponse | Promise<MockResponse>)): this;
+    post(pathPattern: string | RegExp, response: MockResponse | ((req: Request) => MockResponse | Promise<MockResponse>)): this;
+    put(pathPattern: string | RegExp, response: MockResponse | ((req: Request) => MockResponse | Promise<MockResponse>)): this;
+    patch(pathPattern: string | RegExp, response: MockResponse | ((req: Request) => MockResponse | Promise<MockResponse>)): this;
+    delete(pathPattern: string | RegExp, response: MockResponse | ((req: Request) => MockResponse | Promise<MockResponse>)): this;
+    /**
+     * Start intercepting requests
+     */
+    start(): void;
+    /**
+     * Stop intercepting requests
+     */
+    stop(): void;
+    /**
+     * Reset all mock endpoints and clear request history
+     */
+    reset(): void;
+    /**
+     * Get all intercepted requests
+     */
+    getRequests(): typeof this.interceptedRequests;
+    /**
+     * Get requests matching a specific pattern
+     */
+    getRequestsMatching(pathPattern: string | RegExp): typeof this.interceptedRequests;
+    /**
+     * Clear request history
+     */
+    clearHistory(): void;
+    /**
+     * Create the fetch interceptor
+     */
+    handle(input: RequestInfo | URL, init?: RequestInit): Promise<Response | null>;
+    /**
+     * Load a preset scenario
+     */
+    loadPreset(preset: MockPreset): void;
+}
+/**
+ * Mock preset for common scenarios
+ */
+export interface MockPreset {
+    name: string;
+    description: string;
+    endpoints: MockEndpoint[];
+}
+/**
+ * Helper to create dynamic responses
+ */
+export declare class ResponseBuilder {
+    private response;
+    static ok(body?: any): MockResponse;
+    static created(body?: any): MockResponse;
+    static noContent(): MockResponse;
+    static badRequest(message?: string): MockResponse;
+    static unauthorized(message?: string): MockResponse;
+    static forbidden(message?: string): MockResponse;
+    static notFound(message?: string): MockResponse;
+    static serverError(message?: string): MockResponse;
+    static error(message: string, status?: number): MockResponse;
+    static networkError(): MockResponse;
+    status(code: number, text?: string): ResponseBuilder;
+    body(data: any): ResponseBuilder;
+    headers(headers: Record<string, string>): ResponseBuilder;
+    delay(ms: number): ResponseBuilder;
+    build(): MockResponse;
+}

package/dist/test-utils/mock-server.js

@@ -0,0 +1 @@
+const t=/* @__PURE__ */new Set;let e=null;function s(t){window.fetch=t,globalThis.fetch=t,"undefined"!=typeof self&&(self.fetch=t)}class r{constructor(t){this.endpoints=[],this.interceptedRequests=[],this.isActive=!1,this.config=t}mock(t,e,s){return this.endpoints.push({method:t.toUpperCase(),pathPattern:e,response:s}),this}get(t,e){return this.mock("GET",t,e)}post(t,e){return this.mock("POST",t,e)}put(t,e){return this.mock("PUT",t,e)}patch(t,e){return this.mock("PATCH",t,e)}delete(t,e){return this.mock("DELETE",t,e)}start(){this.isActive||(this.isActive=!0,t.add(this),function(){if(e)return;e=window.fetch.bind(window),s(async(s,r)=>{for(const e of t){const t=await e.handle(s,r);if(t)return t}if(!e)throw new Error("MockServer dispatcher is missing original fetch.");return e(s,r)})}())}stop(){this.isActive&&(this.isActive=!1,t.delete(this),t.size>0||!e||(s(e),e=null))}reset(){this.endpoints=[],this.interceptedRequests=[]}getRequests(){return[...this.interceptedRequests]}getRequestsMatching(t){return this.interceptedRequests.filter(e=>{const s=new URL(e.url).pathname;return"string"==typeof t?s===t:t.test(s)})}clearHistory(){this.interceptedRequests=[]}async handle(t,s){const r=function(t){if(t instanceof Request)return new URL(t.url);if(t instanceof URL)return t;const e="undefined"!=typeof window?window.location.href:"http://localhost";return new URL(String(t),e)}(t);if(!r.href.startsWith(this.config.baseUrl))return null;const n=new Request(t,(t=>{if(!t)return;const{signal:e,...s}=t;return s})(s)),o=n.method.toUpperCase(),i=r.pathname;this.config.logRequests;const a={};let u;if(n.headers.forEach((t,e)=>{a[e]=t}),n.body)try{const t=n.clone(),e=await t.text();if(e)try{u=JSON.parse(e)}catch{u=e}}catch{u=void 0}this.interceptedRequests.push({timestamp:/* @__PURE__ */new Date,method:o,url:r.href,headers:a,body:u});const h=new URL(this.config.baseUrl).pathname.replace(/\/$/,""),c=h&&i.startsWith(h)?i.slice(h.length):i,d=this.endpoints.find(t=>t.method===o&&("string"==typeof t.pathPattern?c===t.pathPattern:t.pathPattern.test(c)));if(!d){if(this.config.fallbackToNetwork){if(!e)throw new Error("MockServer fallback requested without an original fetch.");return e(n)}return new Response(JSON.stringify({error:"Mock not found"}),{status:404,statusText:"Not Found",headers:{"Content-Type":"application/json"}})}const p="function"==typeof d.response?await d.response(n):d.response,f=p.delay??this.config.defaultDelay??0;if(f>0&&await new Promise(t=>setTimeout(t,f)),p.error){if("string"==typeof p.error)throw new Error(p.error);throw p.error}const l=void 0!==p.body?JSON.stringify(p.body):"";return new Response(l,{status:p.status??200,statusText:p.statusText??"OK",headers:{"Content-Type":"application/json",...p.headers}})}loadPreset(t){this.reset(),t.endpoints.forEach(t=>{this.mock(t.method,t.pathPattern,t.response)})}}class n{constructor(){this.response={}}static ok(t){return{status:200,statusText:"OK",body:t}}static created(t){return{status:201,statusText:"Created",body:t}}static noContent(){return{status:204,statusText:"No Content"}}static badRequest(t="Bad Request"){return{status:400,statusText:"Bad Request",body:{error:t,message:t}}}static unauthorized(t="Unauthorized"){return{status:401,statusText:"Unauthorized",body:{error:t,message:t}}}static forbidden(t="Forbidden"){return{status:403,statusText:"Forbidden",body:{error:t,message:t}}}static notFound(t="Not Found"){return{status:404,statusText:"Not Found",body:{error:t,message:t}}}static serverError(t="Internal Server Error"){return{status:500,statusText:"Internal Server Error",body:{error:t,message:t}}}static error(t,e=500){return{status:e,statusText:(s=e,{400:"Bad Request",401:"Unauthorized",403:"Forbidden",404:"Not Found",429:"Too Many Requests",500:"Internal Server Error",502:"Bad Gateway",503:"Service Unavailable",504:"Gateway Timeout"}[s]||"Error"),body:{error:t,message:t}};var s}static networkError(){return{error:new Error("Network request failed")}}status(t,e){return this.response.status=t,e&&(this.response.statusText=e),this}body(t){return this.response.body=t,this}headers(t){return this.response.headers={...this.response.headers,...t},this}delay(t){return this.response.delay=t,this}build(){return this.response}}export{r as MockServer,n as ResponseBuilder};

package/dist/test-utils/sdk-factory.d.ts

@@ -0,0 +1,3 @@
+export declare function createMockSDK(_opts: {
+    baseUrl: string;
+}): Promise<import('..').FanfareSDK>;

package/dist/test-utils/sdk-factory.js

@@ -0,0 +1 @@
+import{createMockFanfareSDK as o}from"./mock-sdk.js";async function r(r){return o()}export{r as createMockSDK};

package/dist/test-utils/verification-scenarios.d.ts

@@ -0,0 +1,43 @@
+import { HarnessScenarioKey } from './harness-scenarios';
+export type VerificationScenarioKey = "queue" | "admission-cycle" | "auth-queue" | "access-code-queue" | "draw" | "auth-draw" | "timed-release" | "auction";
+export type VerificationAction = {
+    type: "clickButton";
+    label: string;
+} | {
+    type: "fillCredential";
+    value: string;
+} | {
+    type: "fillOtp";
+    value: string;
+} | {
+    type: "fillAccessCode";
+    value: string;
+};
+export interface VerificationCheckpoint {
+    journeyStage: string;
+    sequencePhase?: string;
+    visibleTexts?: string[];
+    hiddenTexts?: string[];
+    visibleActions?: string[];
+    hiddenActions?: string[];
+    timerVisible?: boolean;
+}
+export interface VerificationStep {
+    key: string;
+    actions: VerificationAction[];
+    checkpoint: VerificationCheckpoint;
+}
+export interface VerificationScenarioDefinition {
+    key: VerificationScenarioKey;
+    initial: VerificationCheckpoint;
+    steps: VerificationStep[];
+}
+export declare const DEFAULT_VERIFICATION_EMAIL = "sdk-harness@example.com";
+export declare const DEFAULT_VERIFICATION_OTP = "424242";
+export declare const DEFAULT_INVALID_ACCESS_CODE = "WRONG1";
+export declare const DEFAULT_VALID_ACCESS_CODE = "VIP123";
+export declare const SHARED_HARNESS_VERIFICATION_SCENARIOS: VerificationScenarioKey[];
+export declare const ADAPTER_SMOKE_SCENARIOS: Array<Exclude<VerificationScenarioKey, "auth-draw">>;
+export declare const SDK_VERIFICATION_SCENARIOS: Record<VerificationScenarioKey, VerificationScenarioDefinition>;
+export declare function isVerificationScenarioKey(value: HarnessScenarioKey): value is VerificationScenarioKey;
+export declare function getVerificationScenario(key: VerificationScenarioKey): VerificationScenarioDefinition;

package/dist/test-utils/verification-scenarios.js

@@ -0,0 +1 @@
+const e="sdk-harness@example.com",t="424242",i="WRONG1",n="VIP123",s=["queue","admission-cycle","auth-queue","access-code-queue","draw","auth-draw","timed-release","auction"],u=["queue","admission-cycle","auth-queue","access-code-queue","draw","timed-release","auction"],o={queue:{key:"queue",initial:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Queue"]},steps:[{key:"entered-queue",actions:[{type:"clickButton",label:"Enter Queue"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You're in the Queue","Estimated wait"],hiddenTexts:["Continue to Shop"],visibleActions:["Leave Queue"]}}]},"admission-cycle":{key:"admission-cycle",initial:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Queue"]},steps:[{key:"granted",actions:[{type:"clickButton",label:"Enter Queue"}],checkpoint:{journeyStage:"routed",sequencePhase:"granted",visibleTexts:["You're in!","Continue to Shop"],visibleActions:["Continue to Shop"]}}]},"auth-queue":{key:"auth-queue",initial:{journeyStage:"gated",visibleTexts:["Sign In","Enter your email or phone to continue"],visibleActions:["Continue"]},steps:[{key:"submitted-auth-credential",actions:[{type:"fillCredential",value:e},{type:"clickButton",label:"Continue"}],checkpoint:{journeyStage:"gated",visibleTexts:["Enter your code"],visibleActions:["Verify"]}},{key:"verified-auth",actions:[{type:"fillOtp",value:t}],checkpoint:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Queue"]}},{key:"entered-queue",actions:[{type:"clickButton",label:"Enter Queue"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You're in the Queue","Estimated wait"],visibleActions:["Leave Queue"]}}]},"access-code-queue":{key:"access-code-queue",initial:{journeyStage:"gated",visibleTexts:["Enter Access Code","Enter your access code to continue"],visibleActions:["Submit"],hiddenActions:["Enter Queue"]},steps:[{key:"rejected-access-code",actions:[{type:"fillAccessCode",value:i},{type:"clickButton",label:"Submit"}],checkpoint:{journeyStage:"gated",hiddenActions:["Enter Queue"],visibleActions:["Submit"]}},{key:"unlocked-queue",actions:[{type:"fillAccessCode",value:n},{type:"clickButton",label:"Submit"}],checkpoint:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Queue"]}},{key:"entered-queue",actions:[{type:"clickButton",label:"Enter Queue"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You're in the Queue","Estimated wait"],visibleActions:["Leave Queue"]}}]},draw:{key:"draw",initial:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Draw"]},steps:[{key:"entered-draw",actions:[{type:"clickButton",label:"Enter Draw"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You've Entered","Good luck in the draw","Drawing in"],visibleActions:["Withdraw Entry"],timerVisible:!0}}]},"auth-draw":{key:"auth-draw",initial:{journeyStage:"gated",visibleTexts:["Sign In","Enter your email or phone to continue"],visibleActions:["Continue"]},steps:[{key:"submitted-auth-credential",actions:[{type:"fillCredential",value:e},{type:"clickButton",label:"Continue"}],checkpoint:{journeyStage:"gated",visibleTexts:["Enter your code"],visibleActions:["Verify"]}},{key:"verified-auth",actions:[{type:"fillOtp",value:t}],checkpoint:{journeyStage:"routed",sequencePhase:"enterable",visibleActions:["Enter Draw"]}},{key:"entered-draw",actions:[{type:"clickButton",label:"Enter Draw"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You've Entered","Good luck in the draw","Drawing in"],visibleActions:["Withdraw Entry"],timerVisible:!0}}]},"timed-release":{key:"timed-release",initial:{journeyStage:"routed",sequencePhase:"enterable",visibleTexts:["Flash Sale","Limited time access","Window closes in"],visibleActions:["Enter Sale"],timerVisible:!0},steps:[{key:"entered-sale",actions:[{type:"clickButton",label:"Enter Sale"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You're in!","Complete purchase in","Browse and complete your purchase before your session expires"],visibleActions:["Complete Purchase","Exit Sale"],timerVisible:!0}},{key:"completed-sale",actions:[{type:"clickButton",label:"Complete Purchase"}],checkpoint:{journeyStage:"routed",sequencePhase:"granted",visibleTexts:["You're in!","Continue to Shop"],visibleActions:["Continue to Shop"]}}]},auction:{key:"auction",initial:{journeyStage:"routed",sequencePhase:"enterable",visibleTexts:["Auction","Bid for exclusive access","Auction ends in"],visibleActions:["Bid"],timerVisible:!0},steps:[{key:"bid-auction",actions:[{type:"clickButton",label:"Bid"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["Auction","Current bid","Auction ends in"],visibleActions:["Bid","Leave"],timerVisible:!0}},{key:"placed-bid",actions:[{type:"clickButton",label:"Bid"}],checkpoint:{journeyStage:"routed",sequencePhase:"participating",visibleTexts:["You're Winning!","Your winning bid","$110.00"],visibleActions:["Bid"]}}]}};function a(e){return e in o}function c(e){return o[e]}export{u as ADAPTER_SMOKE_SCENARIOS,i as DEFAULT_INVALID_ACCESS_CODE,n as DEFAULT_VALID_ACCESS_CODE,e as DEFAULT_VERIFICATION_EMAIL,t as DEFAULT_VERIFICATION_OTP,o as SDK_VERIFICATION_SCENARIOS,s as SHARED_HARNESS_VERIFICATION_SCENARIOS,c as getVerificationScenario,a as isVerificationScenarioKey};

package/dist/test-utils/verification-state.d.ts

@@ -0,0 +1 @@
+export declare function resetVerificationState(): void;

package/dist/test-utils/verification-state.js

@@ -0,0 +1 @@
+import{resetSDKStore as t}from"../state/store.js";function o(){t()}export{o as resetVerificationState};

package/dist/theme.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Theme — single source of truth via `@fanfare-io/fanfare-sdk-contracts`.
+ *
+ * The schema, defaults, and merge helper live in `@fanfare-io/fanfare-sdk-contracts`
+ * to keep one definition shared between admin/server (`shared-models`) and the
+ * SDK family (sdk-core, sdk-react, sdk-solid).
+ */
+export { BrandThemeSchema, DefaultBrandTheme, WidgetVariantSchema, WidgetVariants, mergeBrandTheme, type BrandTheme, type ResolvedBrandTheme, type WidgetVariant, } from '@fanfare-io/fanfare-sdk-contracts/theme';

package/dist/theme.js

@@ -0,0 +1 @@
+import{BrandThemeSchema as r,DefaultBrandTheme as a,WidgetVariantSchema as e,WidgetVariants as f,mergeBrandTheme as o}from"@fanfare-io/fanfare-sdk-contracts/theme";export{r as BrandThemeSchema,a as DefaultBrandTheme,e as WidgetVariantSchema,f as WidgetVariants,o as mergeBrandTheme};

package/dist/timed-releases/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Timed Release module exports
+ */
+export { TimedReleaseManagementModule } from './timed-release.module';
+export { TimedReleaseDenyReason } from './types';
+export type { TimedRelease, TimedReleaseCompletedState, TimedReleaseConsumerState, TimedReleaseDeniedState, TimedReleaseEnteredState, TimedReleaseLeftState, TimedReleaseModule, TimedReleaseNotEnteredState, TimedReleaseParticipation, } from './types';

package/dist/timed-releases/public.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Public timed-release surface. The runtime `TimedReleaseManagementModule`/`TimedReleaseModule`/`TimedReleaseParticipation`
+ * symbols from `./types` are internal and not exported here.
+ */
+export { TimedReleaseDenyReason } from './types';
+export type { TimedRelease, TimedReleaseCompletedState, TimedReleaseConsumerState, TimedReleaseDeniedState, TimedReleaseEnteredState, TimedReleaseLeftState, TimedReleaseNotEnteredState, } from './types';

package/dist/timed-releases/public.js

@@ -0,0 +1 @@
+import{TimedReleaseDenyReason as o}from"./types.js";export{o as TimedReleaseDenyReason};

package/dist/timed-releases/timed-release.module.d.ts

@@ -0,0 +1,31 @@
+import { HttpClient, RequestOptions } from '../core/http';
+import { MonitorUpdate } from '../experiences/distribution-monitor.types';
+import { TimedRelease, TimedReleaseConsumerState, TimedReleaseModule } from './types';
+export declare class TimedReleaseManagementModule implements TimedReleaseModule {
+    private readonly http;
+    private readonly logger;
+    private readonly events;
+    private readonly monitorRuntime;
+    private readonly trackedParticipations;
+    private readonly monitorGenerations;
+    private readonly operationGenerations;
+    private destroyed;
+    private lifecycleGeneration;
+    private get store();
+    constructor(http: HttpClient);
+    get(timedReleaseId: string): Promise<TimedRelease>;
+    enter(timedReleaseId: string, variantId?: string, options?: RequestOptions): Promise<TimedReleaseConsumerState>;
+    leave(timedReleaseId: string, options?: RequestOptions): Promise<void>;
+    complete(timedReleaseId: string, options?: RequestOptions): Promise<string | undefined>;
+    status(timedReleaseId: string): Promise<TimedReleaseConsumerState>;
+    startMonitoring(id: string, context?: Record<string, unknown>, onUpdate?: (update: MonitorUpdate) => void): void;
+    stopMonitoring(id: string): void;
+    isMonitoring(id: string): boolean;
+    private bumpMonitorGeneration;
+    private getOperationGeneration;
+    private bumpOperationGeneration;
+    private canApplyAsyncResult;
+    private buildTransition;
+    private applyTransition;
+    destroy(): void;
+}

package/dist/timed-releases/timed-release.module.js

@@ -0,0 +1 @@
+import{createError as t}from"../core/errors.js";import{getLogger as e}from"../core/logger.js";import{DistributionMonitorRuntime as i}from"../experiences/distribution-monitor.runtime.js";import{getEventBus as s}from"../state/events.js";import{getSDKStore as r}from"../state/store.js";class n{constructor(t){this.logger=e(),this.events=s(),this.monitorRuntime=new i,this.trackedParticipations=/* @__PURE__ */new Map,this.monitorGenerations=/* @__PURE__ */new Map,this.operationGenerations=/* @__PURE__ */new Map,this.destroyed=!1,this.lifecycleGeneration=0,this.http=t}get store(){return r()}async get(t){try{return await this.http.get(`/timed-releases/${t}`)}catch(e){throw this.logger.error("Failed to get timed release",{timedReleaseId:t,error:e}),e}}async enter(e,i,s){const r=this.lifecycleGeneration,n=this.monitorGenerations.get(e);if(!this.store.session)throw t.unauthorized("Not authenticated. Call auth.guest() or auth.login() first");const o=this.bumpOperationGeneration(e);try{this.logger.info("Entering timed release",{timedReleaseId:e});const t=await this.http.post(`/timed-releases/${e}/enter`,{variantId:i},s),a=this.buildTransition(e,t,{source:"enter"});return this.canApplyAsyncResult(e,r,n,o)?(this.applyTransition(e,a),t):t}catch(a){if(!this.canApplyAsyncResult(e,r,n,o))throw a;throw this.logger.error("Failed to enter timed release",{timedReleaseId:e,error:a}),this.events.emit("timed_release:error",{timedReleaseId:e,error:a}),a}}async leave(t,e){const i=this.lifecycleGeneration,s=this.monitorGenerations.get(t),r=this.bumpOperationGeneration(t);try{this.logger.info("Leaving timed release",{timedReleaseId:t}),await this.http.post(`/timed-releases/${t}/leave`,{},e);const n=this.buildTransition(t,{status:"LEFT",leftAt:/* @__PURE__ */(new Date).toISOString()},{source:"leave"});if(!this.canApplyAsyncResult(t,i,s,r))return;this.applyTransition(t,n)}catch(n){if(!this.canApplyAsyncResult(t,i,s,r))throw n;throw this.logger.error("Failed to leave timed release",{timedReleaseId:t,error:n}),this.events.emit("timed_release:error",{timedReleaseId:t,error:n}),n}}async complete(t,e){const i=this.lifecycleGeneration,s=this.monitorGenerations.get(t),r=this.bumpOperationGeneration(t);try{this.logger.info("Completing timed release",{timedReleaseId:t});const n=(await this.http.post(`/timed-releases/${t}/complete`,{},e)).admissionGrant,o=this.buildTransition(t,{status:"COMPLETED",completedAt:/* @__PURE__ */(new Date).toISOString()},{source:"complete",grant:n});return this.canApplyAsyncResult(t,i,s,r)?(this.applyTransition(t,o),n):n}catch(n){if(!this.canApplyAsyncResult(t,i,s,r))throw n;throw this.logger.error("Failed to complete timed release",{timedReleaseId:t,error:n}),this.events.emit("timed_release:error",{timedReleaseId:t,error:n}),n}}async status(t){const e=this.lifecycleGeneration,i=this.monitorGenerations.get(t),s=this.bumpOperationGeneration(t);try{const r=await this.http.get(`/timed-releases/${t}/status`),n=this.buildTransition(t,r,{source:"status"});return this.canApplyAsyncResult(t,e,i,s)?(this.applyTransition(t,n),this.events.emit("timed_release:status-updated",{timedReleaseId:t,status:r.status}),r):r}catch(r){if(r&&"object"==typeof r&&"status"in r&&404===r.status){const r={status:"NOT_ENTERED"},n=this.buildTransition(t,r,{source:"status"});return this.canApplyAsyncResult(t,e,i,s)?(this.applyTransition(t,n),this.events.emit("timed_release:status-updated",{timedReleaseId:t,status:r.status}),r):r}if(!this.canApplyAsyncResult(t,e,i,s))return{status:"NOT_ENTERED"};throw this.logger.error("Failed to get timed release status",{timedReleaseId:t,error:r}),this.events.emit("timed_release:error",{timedReleaseId:t,error:r}),r}}startMonitoring(t,e,i){this.bumpMonitorGeneration(t),this.monitorRuntime.start(t,e,i);const s=this.monitorRuntime.getDisplayAtom(t);s&&s.set({type:"timed_release",enteredAt:this.trackedParticipations.get(t)?.enteredAt})}stopMonitoring(t){this.bumpMonitorGeneration(t),this.monitorRuntime.stop(t)}isMonitoring(t){return this.monitorRuntime.has(t)}bumpMonitorGeneration(t){const e=(this.monitorGenerations.get(t)??0)+1;return this.monitorGenerations.set(t,e),e}getOperationGeneration(t){return this.operationGenerations.get(t)??0}bumpOperationGeneration(t){const e=this.getOperationGeneration(t)+1;return this.operationGenerations.set(t,e),e}canApplyAsyncResult(t,e,i,s){return!this.destroyed&&this.lifecycleGeneration===e&&((void 0===i||this.monitorGenerations.get(t)===i)&&(void 0===s||this.getOperationGeneration(t)===s))}buildTransition(t,e,{source:i,grant:s}){switch(e.status){case"ENTERED":return{trackedParticipation:{timedReleaseId:t,enteredAt:e.enteredAt,selectedVariantId:e.selectedVariantId},events:"enter"===i?[{type:"timed_release:entered",payload:{timedReleaseId:t,enteredAt:e.enteredAt}}]:[],monitorUpdate:null,stopMonitoring:!1};case"COMPLETED":return{trackedParticipation:null,events:[{type:"timed_release:completed",payload:{timedReleaseId:t,completedAt:e.completedAt}}],monitorUpdate:"complete"===i&&s?{type:"granted",token:s}:null,stopMonitoring:"complete"===i||"status"===i};case"LEFT":return{trackedParticipation:null,events:[{type:"timed_release:left",payload:{timedReleaseId:t}}],monitorUpdate:"status"===i?{type:"ended",outcome:{type:"left"}}:null,stopMonitoring:"leave"===i||"status"===i};case"DENIED":return{trackedParticipation:null,events:[],monitorUpdate:"enter"===i||"status"===i?{type:"ended",outcome:{type:"denied",reason:e.reason}}:null,stopMonitoring:"enter"===i||"status"===i};case"NOT_ENTERED":return{trackedParticipation:null,events:[],monitorUpdate:"enter"===i||"status"===i?{type:"ended",outcome:{type:"closed",reason:"not_entered"}}:null,stopMonitoring:"enter"===i||"status"===i}}}applyTransition(t,e){e.trackedParticipation?this.trackedParticipations.set(t,e.trackedParticipation):this.trackedParticipations.delete(t);const i=this.monitorRuntime.getDisplayAtom(t);i&&(e.trackedParticipation?i.set({type:"timed_release",enteredAt:e.trackedParticipation.enteredAt}):i.set({type:"timed_release"}));for(const s of e.events)this.events.emit(s.type,s.payload);e.monitorUpdate&&this.monitorRuntime.notify(t,e.monitorUpdate),e.stopMonitoring&&this.stopMonitoring(t)}destroy(){this.destroyed=!0,this.lifecycleGeneration+=1,this.trackedParticipations.clear(),this.monitorGenerations.clear(),this.operationGenerations.clear(),this.monitorRuntime.clear()}}export{n as TimedReleaseManagementModule};

package/dist/timed-releases/types.d.ts

@@ -0,0 +1,70 @@
+import { RequestOptions } from '../core/http';
+/**
+ * Known timed release deny reasons.
+ *
+ * When a consumer is denied entry to a timed release, the `reason` field
+ * will contain one of these values (or a custom reason).
+ */
+export declare const TimedReleaseDenyReason: {
+    /** Consumer has exceeded their order limit for this experience */
+    readonly ORDER_LIMIT_EXCEEDED: "ORDER_LIMIT_EXCEEDED";
+    /** Timed release is closed */
+    readonly RELEASE_CLOSED: "RELEASE_CLOSED";
+    /** Bot detection triggered */
+    readonly BOT_DETECTED: "BOT_DETECTED";
+};
+export type TimedReleaseDenyReason = (typeof TimedReleaseDenyReason)[keyof typeof TimedReleaseDenyReason];
+/**
+ * Timed Release participation stored in state
+ */
+export interface TimedReleaseParticipation {
+    timedReleaseId: string;
+    enteredAt: string;
+    selectedVariantId?: string;
+}
+/**
+ * Timed Release consumer states (from backend)
+ */
+export type TimedReleaseConsumerState = TimedReleaseNotEnteredState | TimedReleaseEnteredState | TimedReleaseCompletedState | TimedReleaseLeftState | TimedReleaseDeniedState;
+export interface TimedReleaseNotEnteredState {
+    status: "NOT_ENTERED";
+}
+export interface TimedReleaseEnteredState {
+    status: "ENTERED";
+    enteredAt: string;
+    selectedVariantId?: string;
+}
+export interface TimedReleaseCompletedState {
+    status: "COMPLETED";
+    completedAt: string;
+    selectedVariantId?: string;
+}
+export interface TimedReleaseLeftState {
+    status: "LEFT";
+    leftAt: string;
+}
+export interface TimedReleaseDeniedState {
+    status: "DENIED";
+    reason: string;
+    deniedAt: string;
+}
+/**
+ * Timed Release module interface
+ */
+export interface TimedReleaseModule {
+    get(timedReleaseId: string): Promise<TimedRelease>;
+    enter(timedReleaseId: string, variantId?: string, options?: RequestOptions): Promise<TimedReleaseConsumerState>;
+    leave(timedReleaseId: string, options?: RequestOptions): Promise<void>;
+    complete(timedReleaseId: string, options?: RequestOptions): Promise<string | undefined>;
+    status(timedReleaseId: string): Promise<TimedReleaseConsumerState>;
+}
+/**
+ * Timed Release entity
+ */
+export interface TimedRelease {
+    id: string;
+    openAt?: string;
+    closeAt?: string;
+    timeZone: string;
+    supportsGuest: boolean;
+}

package/dist/timed-releases/types.js

@@ -0,0 +1 @@
+const E={ORDER_LIMIT_EXCEEDED:"ORDER_LIMIT_EXCEEDED",RELEASE_CLOSED:"RELEASE_CLOSED",BOT_DETECTED:"BOT_DETECTED"};export{E as TimedReleaseDenyReason};

package/dist/types/distribution-type.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Canonical SDK distribution-type union.
+ *
+ * Previously, the SDK spelled out `"queue" | "draw" | ... | "appointment"` in
+ * 8+ places across `experiences/types.ts`, `experiences/journey.types.ts`,
+ * `handoff/handoff.module.ts`, `state/capability-token-registry.ts`, and
+ * `state/events.ts`. Each variant included or excluded `appointment`,
+ * `waitlist`, and `timed_release` differently, and adding a new distribution
+ * type required a coordinated 8-place edit. Most divergence was unintended.
+ *
+ * Rather than keep redefining the same set, sites import {@link
+ * SdkDistributionType} (the full set) and narrow with `Exclude` /
+ * `Extract` when they legitimately need a subset (e.g. journey participation
+ * excludes `appointment`; handoff payload excludes `timed_release` because
+ * those distributions don't produce handoff tokens).
+ *
+ * The lowercase string values are an SDK-public contract — they appear in
+ * `JourneySnapshot.participation.type`, `Distribution.type`, etc. Server
+ * payloads use these lowercase public values at SDK boundaries.
+ *
+ */
+export type SdkDistributionType = "queue" | "draw" | "auction" | "appointment" | "timed_release" | "waitlist";
+/**
+ * The five "distribution-proper" types that have an open/active state and
+ * appear under `Distribution.type`, `DistributionContext.active.type`, etc.
+ * Excludes `waitlist` because waitlists are pre-distribution membership
+ * containers, not distributions themselves.
+ */
+export type SdkDistributionEntryType = Exclude<SdkDistributionType, "waitlist">;
+/**
+ * Distribution types that produce a handoff token on admission.
+ * Excludes `timed_release` (no admission handoff) and `waitlist` (pre-distribution).
+ */
+export type SdkHandoffDistributionType = Exclude<SdkDistributionType, "timed_release" | "waitlist">;
+/**
+ * Distribution types that participate in journey resume / participation tracking.
+ */
+export type SdkJourneyParticipationType = SdkDistributionType;
+/**
+ * Distribution types that produce admissions for journey resume.
+ * Excludes `appointment` (booking is the participation; there is no admission
+ * handoff — completion surfaces via display state) and `waitlist` (waitlists
+ * graduate into other distributions; the admission belongs to the downstream type).
+ */
+export type SdkJourneyAdmissionType = Exclude<SdkDistributionType, "appointment" | "waitlist">;