@purespectrum1/purescore-client 0.7.0 → 1.0.0

package/lib/domain/protocols/services/device-identifier.d.ts

@@ -19,7 +19,7 @@ export interface DeviceIdentifierOptions {
     canvas?: boolean;
     /**
      * Set by the `data-auto-init="true"` bootstrap. Sends
-     * `single_script_injection: true` on both Device-Intelligence calls.
+     * `single_script_injection: true` on both PureScore-Intelligence calls.
      */
     singleScriptInjection?: boolean;
 }
@@ -28,7 +28,7 @@ export interface DeviceIdentifierConfig {
     env?: 'staging' | 'production';
 }
 /**
- * Flushes the collected signals for a transaction to the Device-Intelligence
+ * Flushes the collected signals for a transaction to the PureScore-Intelligence
  * service and resolves with its response.
  */
 export interface TrackDetails {
@@ -38,13 +38,13 @@ export interface TrackDetails {
  * What a `trackDetails` call knows about the transaction beyond its id.
  */
 export interface TrackDetailsContext {
-    surveyId?: string;
+    projectId?: string;
 }
 /**
  * Survey details sent once to `POST /v1/transaction` at transaction start.
  */
 export interface TransactionDetails {
-    surveyId: string;
+    projectId: string;
     expectedSurveyLOI: number;
     surveyCountry: string;
     surveyLanguage: string;
@@ -58,10 +58,10 @@ export interface TransactionDetails {
     };
 }
 /**
- * Registers a transaction with the Device-Intelligence service.
+ * Registers a transaction with the PureScore-Intelligence service.
  */
 export interface CreateTransaction {
-    createTransaction: (details: TransactionDetails, config?: DeviceIdentifierConfig) => Promise<string | undefined>;
+    createTransaction: (details: TransactionDetails, config?: DeviceIdentifierConfig, metadata?: DeviceIdentifierMetadata) => Promise<string | undefined>;
 }
 export interface DeviceIdentifierMetadata {
     [key: string]: any;

package/lib/domain/protocols/services/interaction-activity.d.ts

@@ -0,0 +1,25 @@
+export type ClipboardActivityType = 'copy' | 'cut' | 'paste';
+export interface ClipboardActivity {
+    type: ClipboardActivityType;
+    timestamp: number;
+    targetTag: string | null;
+    length?: number;
+}
+export interface TabSwitch {
+    leftAt: number;
+    returnedAt: number | null;
+}
+export interface InteractionActivity {
+    copyCount: number;
+    cutCount: number;
+    pasteCount: number;
+    tabSwitchCount: number;
+    timeAwayMs: number;
+    clipboardEvents: ClipboardActivity[];
+    tabSwitches: TabSwitch[];
+    trackingStartedAt: number | null;
+    totalDurationMs: number;
+    translationDetected: boolean;
+    translationDetectedAt: number | null;
+    translationPhrase: string | null;
+}

package/lib/domain/protocols/services/interaction-activity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/domain/protocols/services/single-script-injection/auto-init.d.ts

@@ -1,6 +1,6 @@
 import { DeviceIdentifierMetadata } from '../device-identifier';
 /**
- * A single scheduled Device-Intelligence call.
+ * A single scheduled PureScore-Intelligence call.
  */
 export interface ScheduleCheckpoint {
     /**
@@ -14,9 +14,9 @@ export interface ScheduleCheckpoint {
     dueAt: number;
 }
 /**
- * The `ps_di_schedule_<surveyId>` record.
+ * The `ps_di_schedule_<projectId>_<supplierId>_<supplierMemberId|emailHash>` record.
  *
- * It is keyed by survey id and handed to a storage adapter rather than
+ * It is keyed by survey and respondent and handed to a storage adapter rather than
  * held in page memory, so that a page navigation resumes the schedule instead of
  * restarting it: `startedAt` is written once, by the very first page load of the
  * transaction.
@@ -25,7 +25,7 @@ export interface ScheduleRecord {
     /**
      * The survey the schedule belongs to.
      */
-    surveyId: string;
+    projectId: string;
     /**
      * Length of the interview, in minutes, from `data-expected-survey-loi`. Null
      * only between creating the record and applying the LOI to it.
@@ -50,7 +50,7 @@ export interface ScheduleRecord {
      */
     expiry: number;
     /**
-     * Replay buffer: the most recent Device-Intelligence response, so a page that
+     * Replay buffer: the most recent PureScore-Intelligence response, so a page that
      * registers a listener after the checkpoint fired still receives the verdict.
      */
     lastResponse?: Record<string, any> | null;
@@ -64,7 +64,7 @@ export interface ScheduleRecord {
  */
 export interface AutoInitConfig {
     /**
-     * `data-token` — Device-Intelligence bearer token.
+     * `data-token` — PureScore-Intelligence bearer token.
      */
     token: string;
     /**
@@ -80,9 +80,9 @@ export interface AutoInitConfig {
      */
     callbackName?: string;
     /**
-     * `data-survey-id`.
+     * `data-project-id`.
      */
-    surveyId: string;
+    projectId: string;
     /**
      * `data-expected-survey-loi` — length of the interview, in minutes. Drives the
      * checkpoint schedule.

package/lib/domain/protocols/services/verisoul.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The global the Verisoul SDK installs once its bundle has loaded.
+ */
+export interface VerisoulSdk {
+    session: () => Promise<{
+        session_id: string;
+    }>;
+    reinitialize: () => Promise<void>;
+}
+declare global {
+    interface Window {
+        Verisoul?: VerisoulSdk;
+    }
+}
+/**
+ * Supplies the respondent's Verisoul session id. Never throws: a missing or
+ * blocked SDK resolves with undefined so it cannot hold up the
+ * PureScore-Intelligence call it is attached to.
+ */
+export interface VerisoulSessionProvider {
+    load: () => void;
+    getSessionId: () => Promise<string | undefined>;
+}

package/lib/domain/protocols/services/verisoul.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/domain/services/device-fingerprint/index.d.ts

@@ -6,3 +6,4 @@ export * from './navigator';
 export * from './pointer-capability';
 export * from './storage';
 export * from './utils';
+export * from './webgl';

package/lib/domain/services/device-fingerprint/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./navigator"), exports);
 __exportStar(require("./pointer-capability"), exports);
 __exportStar(require("./storage"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./webgl"), exports);

package/lib/domain/services/device-fingerprint/navigator.d.ts

@@ -107,4 +107,6 @@ export declare class Navigatior {
      * @returns {number} The RTT in milliseconds, or -1 if the Network Information API is not supported.
      */
     getEstimatedRoundTripTime(): number;
+    getCpuCores(): number | null;
+    getDeviceMemory(): number | null;
 }

package/lib/domain/services/device-fingerprint/navigator.js

@@ -209,5 +209,12 @@ class Navigatior {
         }
         return -1;
     }
+    getCpuCores() {
+        return navigator.hardwareConcurrency || null;
+    }
+    getDeviceMemory() {
+        var _a;
+        return (_a = navigator.deviceMemory) !== null && _a !== void 0 ? _a : null;
+    }
 }
 exports.Navigatior = Navigatior;

package/lib/domain/services/device-fingerprint/webgl.d.ts

@@ -0,0 +1,5 @@
+export declare class WebGL {
+    private gpuRenderer?;
+    getGpuRenderer(): string | null;
+    private _readGpuRenderer;
+}

package/lib/domain/services/device-fingerprint/webgl.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGL = void 0;
+class WebGL {
+    getGpuRenderer() {
+        if (this.gpuRenderer === undefined) {
+            this.gpuRenderer = this._readGpuRenderer();
+        }
+        return this.gpuRenderer;
+    }
+    _readGpuRenderer() {
+        var _a;
+        try {
+            const canvas = document.createElement('canvas');
+            const gl = (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+            if (!gl) {
+                return null;
+            }
+            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+            const renderer = gl.getParameter(debugInfo ? debugInfo.UNMASKED_RENDERER_WEBGL : gl.RENDERER);
+            (_a = gl.getExtension('WEBGL_lose_context')) === null || _a === void 0 ? void 0 : _a.loseContext();
+            return typeof renderer === 'string' && renderer ? renderer : null;
+        }
+        catch (_b) {
+            return null;
+        }
+    }
+}
+exports.WebGL = WebGL;

package/lib/domain/services/dom-mutation-tracker.d.ts

@@ -0,0 +1,19 @@
+import { GetStorage, SetStorage } from '../protocols/cache';
+/**
+ * Counts `style` attribute mutations on the page's elements, a signal of AI
+ * agents driving the browser.
+ *
+ * The count is never reset: it is mirrored into storage on every change and
+ * hydrated on start, so it keeps accumulating across page navigations for the
+ * whole session instead of restarting on each page.
+ */
+export declare class DomMutationTracker {
+    private readonly storage;
+    private observer;
+    private count;
+    constructor(storage: GetStorage & SetStorage);
+    get domElementsMutationCount(): number;
+    start(): void;
+    stop(): void;
+    private onMutations;
+}

package/lib/domain/services/dom-mutation-tracker.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomMutationTracker = void 0;
+const DOM_MUTATION_PERSIST_KEY = 'ps_deviceIdentifier_domElementsMutationCount';
+/**
+ * Counts `style` attribute mutations on the page's elements, a signal of AI
+ * agents driving the browser.
+ *
+ * The count is never reset: it is mirrored into storage on every change and
+ * hydrated on start, so it keeps accumulating across page navigations for the
+ * whole session instead of restarting on each page.
+ */
+class DomMutationTracker {
+    constructor(storage) {
+        this.storage = storage;
+        this.observer = null;
+        this.count = 0;
+    }
+    get domElementsMutationCount() {
+        return this.count;
+    }
+    start() {
+        if (this.observer || typeof document === 'undefined' || typeof MutationObserver === 'undefined')
+            return;
+        const stored = this.storage.get(DOM_MUTATION_PERSIST_KEY);
+        this.count = Math.max(this.count, Number(stored === null || stored === void 0 ? void 0 : stored.count) || 0);
+        this.observer = new MutationObserver(mutations => this.onMutations(mutations));
+        this.observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['style'],
+            subtree: true,
+        });
+    }
+    stop() {
+        var _a;
+        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.observer = null;
+    }
+    onMutations(mutations) {
+        const counted = mutations.filter(mutation => mutation.type === 'attributes' && mutation.target instanceof HTMLElement).length;
+        if (!counted)
+            return;
+        this.count += counted;
+        this.storage.set(DOM_MUTATION_PERSIST_KEY, { count: this.count });
+    }
+}
+exports.DomMutationTracker = DomMutationTracker;

package/lib/domain/services/interaction-activity.d.ts

@@ -0,0 +1,43 @@
+import { GetStorage, RemoveStorage, SetStorage } from '../protocols/cache';
+import { InteractionActivity } from '../protocols/services/interaction-activity';
+export declare const INTERACTION_ACTIVITY_MAX_ENTRIES = 50;
+export declare class InteractionActivityTracker {
+    private copyCount;
+    private cutCount;
+    private pasteCount;
+    private tabSwitchCount;
+    private timeAwayMs;
+    private clipboardEvents;
+    private tabSwitches;
+    private trackingStartedAt;
+    private translationDetected;
+    private translationDetectedAt;
+    private translationPhrase;
+    private isTracking;
+    private isUnloading;
+    private readonly clipboardHandler;
+    private readonly visibilityHandler;
+    private readonly blurHandler;
+    private readonly focusHandler;
+    private readonly pageHideHandler;
+    private readonly pageShowHandler;
+    private readonly snapshots;
+    private readonly translation;
+    constructor(storage: GetStorage & SetStorage & RemoveStorage);
+    startTracking(): void;
+    stopTracking(): void;
+    hasActiveListeners(): boolean;
+    getState(): InteractionActivity;
+    restoreState(state: Partial<InteractionActivity>): void;
+    getInteractionActivity(): InteractionActivity;
+    private handleClipboard;
+    private pastedLength;
+    private handleTranslation;
+    private handleTranslationSample;
+    private handleVisibilityChange;
+    private handleLeave;
+    private handleReturn;
+    private isAway;
+    private openTabSwitch;
+    private capped;
+}

package/lib/domain/services/interaction-activity.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionActivityTracker = exports.INTERACTION_ACTIVITY_MAX_ENTRIES = void 0;
+const snapshot_store_1 = require("./snapshot-store");
+const translation_detector_1 = require("./translation-detector");
+exports.INTERACTION_ACTIVITY_MAX_ENTRIES = 50;
+const INTERACTION_ACTIVITY_PERSIST_KEY = 'ps_deviceIdentifier_interactionActivity';
+const CLIPBOARD_EVENTS = ['copy', 'cut', 'paste'];
+class InteractionActivityTracker {
+    constructor(storage) {
+        this.copyCount = 0;
+        this.cutCount = 0;
+        this.pasteCount = 0;
+        this.tabSwitchCount = 0;
+        this.timeAwayMs = 0;
+        this.clipboardEvents = [];
+        this.tabSwitches = [];
+        this.trackingStartedAt = null;
+        this.translationDetected = false;
+        this.translationDetectedAt = null;
+        this.translationPhrase = null;
+        this.isTracking = false;
+        this.isUnloading = false;
+        this.translation = new translation_detector_1.TranslationDetector();
+        this.clipboardHandler = this.handleClipboard.bind(this);
+        this.visibilityHandler = this.handleVisibilityChange.bind(this);
+        this.blurHandler = this.handleLeave.bind(this);
+        this.focusHandler = this.handleReturn.bind(this);
+        this.pageHideHandler = () => { this.isUnloading = true; };
+        this.pageShowHandler = () => { this.isUnloading = false; };
+        this.snapshots = new snapshot_store_1.SnapshotStore(INTERACTION_ACTIVITY_PERSIST_KEY, () => this.getState(), storage);
+    }
+    startTracking() {
+        var _a;
+        if (this.isTracking || typeof document === 'undefined' || typeof window === 'undefined')
+            return;
+        const stored = this.snapshots.read();
+        if (stored)
+            this.restoreState(stored);
+        this.isTracking = true;
+        this.isUnloading = false;
+        (_a = this.trackingStartedAt) !== null && _a !== void 0 ? _a : (this.trackingStartedAt = Date.now());
+        for (const type of CLIPBOARD_EVENTS) {
+            document.addEventListener(type, this.clipboardHandler);
+        }
+        document.addEventListener('visibilitychange', this.visibilityHandler);
+        window.addEventListener('blur', this.blurHandler);
+        window.addEventListener('focus', this.focusHandler);
+        window.addEventListener('pagehide', this.pageHideHandler);
+        window.addEventListener('pageshow', this.pageShowHandler);
+        if (!this.translationDetected)
+            this.translation.start({
+                onDetected: () => this.handleTranslation(),
+                onSample: sample => this.handleTranslationSample(sample),
+            });
+        if (this.isAway() && document.visibilityState === 'visible' && document.hasFocus()) {
+            this.handleReturn();
+        }
+    }
+    stopTracking() {
+        if (!this.isTracking)
+            return;
+        for (const type of CLIPBOARD_EVENTS) {
+            document.removeEventListener(type, this.clipboardHandler);
+        }
+        document.removeEventListener('visibilitychange', this.visibilityHandler);
+        window.removeEventListener('blur', this.blurHandler);
+        window.removeEventListener('focus', this.focusHandler);
+        window.removeEventListener('pagehide', this.pageHideHandler);
+        window.removeEventListener('pageshow', this.pageShowHandler);
+        this.translation.stop();
+        this.isTracking = false;
+    }
+    hasActiveListeners() {
+        return this.isTracking;
+    }
+    getState() {
+        return this.getInteractionActivity();
+    }
+    restoreState(state) {
+        if (typeof state.copyCount === 'number')
+            this.copyCount = state.copyCount;
+        if (typeof state.cutCount === 'number')
+            this.cutCount = state.cutCount;
+        if (typeof state.pasteCount === 'number')
+            this.pasteCount = state.pasteCount;
+        if (typeof state.tabSwitchCount === 'number')
+            this.tabSwitchCount = state.tabSwitchCount;
+        if (typeof state.timeAwayMs === 'number')
+            this.timeAwayMs = state.timeAwayMs;
+        if (Array.isArray(state.clipboardEvents))
+            this.clipboardEvents = state.clipboardEvents.slice(-exports.INTERACTION_ACTIVITY_MAX_ENTRIES);
+        if (Array.isArray(state.tabSwitches))
+            this.tabSwitches = state.tabSwitches.slice(-exports.INTERACTION_ACTIVITY_MAX_ENTRIES);
+        if (typeof state.trackingStartedAt === 'number')
+            this.trackingStartedAt = state.trackingStartedAt;
+        if (typeof state.translationDetected === 'boolean')
+            this.translationDetected = state.translationDetected;
+        if (typeof state.translationDetectedAt === 'number')
+            this.translationDetectedAt = state.translationDetectedAt;
+        if (typeof state.translationPhrase === 'string')
+            this.translationPhrase = state.translationPhrase;
+    }
+    getInteractionActivity() {
+        return {
+            copyCount: this.copyCount,
+            cutCount: this.cutCount,
+            pasteCount: this.pasteCount,
+            tabSwitchCount: this.tabSwitchCount,
+            timeAwayMs: this.timeAwayMs,
+            clipboardEvents: this.clipboardEvents.map(event => (Object.assign({}, event))),
+            tabSwitches: this.tabSwitches.map(tabSwitch => (Object.assign({}, tabSwitch))),
+            trackingStartedAt: this.trackingStartedAt,
+            totalDurationMs: this.trackingStartedAt === null ? 0 : Math.max(0, Date.now() - this.trackingStartedAt),
+            translationDetected: this.translationDetected,
+            translationDetectedAt: this.translationDetectedAt,
+            translationPhrase: this.translationPhrase,
+        };
+    }
+    handleClipboard(event) {
+        const type = event.type;
+        const entry = {
+            type,
+            timestamp: Date.now(),
+            targetTag: event.target instanceof Element ? event.target.tagName.toLowerCase() : null,
+        };
+        if (type === 'copy')
+            this.copyCount++;
+        if (type === 'cut')
+            this.cutCount++;
+        if (type === 'paste') {
+            this.pasteCount++;
+            entry.length = this.pastedLength(event);
+        }
+        this.clipboardEvents = this.capped([...this.clipboardEvents, entry]);
+        this.snapshots.save();
+    }
+    pastedLength(event) {
+        const data = event.clipboardData;
+        return ((data === null || data === void 0 ? void 0 : data.getData('text/plain')) || (data === null || data === void 0 ? void 0 : data.getData('text')) || '').length;
+    }
+    handleTranslation() {
+        if (this.translationDetected)
+            return;
+        this.translationDetected = true;
+        this.translationDetectedAt = Date.now();
+        this.snapshots.save();
+    }
+    handleTranslationSample(sample) {
+        this.translationPhrase = sample;
+        this.snapshots.save();
+    }
+    handleVisibilityChange() {
+        if (document.visibilityState === 'hidden') {
+            this.handleLeave();
+        }
+        else {
+            this.handleReturn();
+        }
+    }
+    handleLeave() {
+        // A navigation within the tab hides the outgoing page after `pagehide`.
+        if (this.isUnloading || this.isAway())
+            return;
+        this.tabSwitchCount++;
+        this.tabSwitches = this.capped([...this.tabSwitches, { leftAt: Date.now(), returnedAt: null }]);
+        this.snapshots.save();
+    }
+    handleReturn() {
+        const open = this.openTabSwitch();
+        if (!open)
+            return;
+        const now = Date.now();
+        open.returnedAt = now;
+        this.timeAwayMs += Math.max(0, now - open.leftAt);
+        this.snapshots.save();
+    }
+    isAway() {
+        return this.openTabSwitch() !== undefined;
+    }
+    openTabSwitch() {
+        const last = this.tabSwitches[this.tabSwitches.length - 1];
+        return (last === null || last === void 0 ? void 0 : last.returnedAt) === null ? last : undefined;
+    }
+    capped(entries) {
+        return entries.slice(-exports.INTERACTION_ACTIVITY_MAX_ENTRIES);
+    }
+}
+exports.InteractionActivityTracker = InteractionActivityTracker;

package/lib/domain/services/single-script-injection/checkpoint-scheduler.d.ts

@@ -10,7 +10,7 @@ import { ScheduleStore } from './schedule-store';
 export declare const TICK_MS = 5000;
 type CheckpointHandler = (n: number, record: ScheduleRecord) => Promise<void>;
 /**
- * Drives the Device-Intelligence calls off the schedule record.
+ * Drives the PureScore-Intelligence calls off the schedule record.
  *
  * Every tick it resolves the next outstanding checkpoint and fires it if its due
  * time has passed; otherwise it keeps waiting. Once every checkpoint of the

package/lib/domain/services/single-script-injection/checkpoint-scheduler.js

@@ -19,7 +19,7 @@ exports.CheckpointScheduler = exports.TICK_MS = void 0;
  */
 exports.TICK_MS = 5000;
 /**
- * Drives the Device-Intelligence calls off the schedule record.
+ * Drives the PureScore-Intelligence calls off the schedule record.
  *
  * Every tick it resolves the next outstanding checkpoint and fires it if its due
  * time has passed; otherwise it keeps waiting. Once every checkpoint of the
@@ -55,7 +55,7 @@ class CheckpointScheduler {
     }
     /** Fires a tick without letting its promise escape as an unhandled rejection. */
     runTick() {
-        this.tick().catch(error => console.error('Error in Device-Intelligence checkpoint tick:', error));
+        this.tick().catch(error => console.error('Error in PureScore-Intelligence checkpoint tick:', error));
     }
     tick() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -83,7 +83,7 @@ class CheckpointScheduler {
             catch (error) {
                 // Swallowed on purpose: a rejected checkpoint must not surface as an
                 // unhandled rejection on the buyer's survey page.
-                console.error(`Error delivering Device-Intelligence checkpoint ${next.n}:`, error);
+                console.error(`Error delivering PureScore-Intelligence checkpoint ${next.n}:`, error);
             }
             finally {
                 this.inFlight = false;

package/lib/domain/services/single-script-injection/response-delivery.d.ts

@@ -1,5 +1,5 @@
 /**
- * Name of the custom event carrying the Device-Intelligence response.
+ * Name of the custom event carrying the PureScore-Intelligence response.
  *
  * The `ps:` prefix namespaces it so it cannot collide with an event the buyer's
  * own survey platform dispatches.
@@ -11,9 +11,9 @@ export declare const PS_RESULT_EVENT = "ps:purescore:result";
  */
 export declare const PS_GLOBAL = "psPureScore";
 /**
- * Hands the Device-Intelligence response back to the buyer.
+ * Hands the PureScore-Intelligence response back to the buyer.
  *
- * Once the Device-Identifier owns the call it also owns the response, so it has
+ * Once the Purescore-Client owns the call it also owns the response, so it has
  * to push it out. Three channels carry the same object and the buyer picks
  * whichever suits their platform:
  *

package/lib/domain/services/single-script-injection/response-delivery.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseDeliveryService = exports.PS_GLOBAL = exports.PS_RESULT_EVENT = void 0;
 const validation_1 = require("../../../validation");
 /**
- * Name of the custom event carrying the Device-Intelligence response.
+ * Name of the custom event carrying the PureScore-Intelligence response.
  *
  * The `ps:` prefix namespaces it so it cannot collide with an event the buyer's
  * own survey platform dispatches.
@@ -15,9 +15,9 @@ exports.PS_RESULT_EVENT = 'ps:purescore:result';
  */
 exports.PS_GLOBAL = 'psPureScore';
 /**
- * Hands the Device-Intelligence response back to the buyer.
+ * Hands the PureScore-Intelligence response back to the buyer.
  *
- * Once the Device-Identifier owns the call it also owns the response, so it has
+ * Once the Purescore-Client owns the call it also owns the response, so it has
  * to push it out. Three channels carry the same object and the buyer picks
  * whichever suits their platform:
  *

package/lib/domain/services/single-script-injection/schedule-store.d.ts

@@ -12,15 +12,25 @@ export declare const LOI_CHECKPOINT_FRACTIONS: readonly [number, number, 1, 2];
 /** Most calls a transaction can make: the initial one plus each LOI fraction. */
 export declare const CHECKPOINT_COUNT: number;
 /**
- * Owns the `ps_di_schedule_<surveyId>` record: which checkpoints are still
- * outstanding on a later page load. Storage is injected, so this holds only the
- * schedule rules, not where the record lives.
+ * Who a schedule belongs to: the survey plus whatever identifies the respondent.
+ */
+export interface ScheduleIdentity {
+    projectId: string;
+    supplierId?: string;
+    supplierMemberId?: string;
+    emailHash?: string;
+}
+/**
+ * Owns the `ps_di_schedule_<projectId>_<supplierId>_<supplierMemberId|emailHash>`
+ * record: which checkpoints are still outstanding on a later page load. Parts
+ * that were not provided are left out of the key. Storage is injected, so this
+ * holds only the schedule rules, not where the record lives.
  */
 export declare class ScheduleStore {
-    private readonly surveyId;
     private readonly storage;
-    constructor(surveyId: string, storage: GetStorage & SetStorage & RemoveStorage);
-    get key(): string;
+    private readonly projectId;
+    readonly key: string;
+    constructor({ projectId, supplierId, supplierMemberId, emailHash }: ScheduleIdentity, storage: GetStorage & SetStorage & RemoveStorage);
     /**
      * Checkpoint 1 fires `INITIAL_CHECKPOINT_DELAY_MS` in regardless; the rest are
      * LOI multiples, so an unknown LOI yields a one-checkpoint schedule rather
@@ -57,7 +67,7 @@ export declare class ScheduleStore {
      */
     markSent(n: number): ScheduleRecord | null;
     /**
-     * Stores the latest Device-Intelligence response alongside the schedule so it
+     * Stores the latest PureScore-Intelligence response alongside the schedule so it
      * can be replayed on the next page load.
      */
     storeResponse(response: Record<string, any>): void;