@genlook/storefront 0.1.0

package/dist/create-client.js

@@ -0,0 +1,131 @@
+import { TryOnClient } from "./client";
+import { createFetchTransport } from "./fetch-transport";
+import { defaultStorage } from "./storage-adapters";
+import { getAnonymousId, uuid } from "./anonymous-id";
+import { FLUSH_INTERVAL_MS, Tracker } from "./tracker";
+import { createDefaultPageContext, staticConsent } from "./default-tracking";
+import { fetchSettings, loadSettings, saveSettings } from "./settings";
+import { SDK_VERSION } from "./version";
+export function createTryOnClient(options) {
+    const { publishableKey, baseUrl, apiPath, customerId, customerEmail, widgetVersion, getFingerprint, fetchImpl, transport, storage, anonymousId, tracker, now, netInfo, tracking = "granted", integration = "tryon_core", integrationVersion = SDK_VERSION, screen, flushIntervalMs, ...config } = options;
+    const resolvedStorage = storage ?? defaultStorage();
+    const resolvedAnonymousId = anonymousId ?? getAnonymousId(resolvedStorage);
+    let resolvedTransport = transport;
+    if (!resolvedTransport) {
+        if (!publishableKey) {
+            throw new Error("[Genlook] createTryOnClient requires either `publishableKey` or a `transport`.");
+        }
+        resolvedTransport = createFetchTransport({
+            publishableKey,
+            baseUrl,
+            apiPath,
+            anonymousId: resolvedAnonymousId,
+            customerId: customerId ?? config.loggedInCustomerId ?? null,
+            customerEmail,
+            widgetVersion,
+            getFingerprint,
+            fetchImpl,
+        });
+    }
+    const wiring = tracker
+        ? { sink: tracker, stop: undefined }
+        : wireDefaultTracker({
+            transport: resolvedTransport,
+            storage: resolvedStorage,
+            tracking,
+            integration,
+            integrationVersion,
+            screen,
+            widgetVersion,
+            pinnedAnonymousId: anonymousId,
+            storeId: config.storeId ?? null,
+            flushIntervalMs: flushIntervalMs ?? FLUSH_INTERVAL_MS,
+        });
+    const clock = now ?? Date.now;
+    const storeIdKey = config.storeId ?? "";
+    const pinned = pinnedFields(config);
+    const cached = loadSettings(resolvedStorage, storeIdKey, clock());
+    const client = new TryOnClient({
+        config: cached ? withSettings(config, unpinned(cached.settings, pinned)) : config,
+        transport: resolvedTransport,
+        storage: resolvedStorage,
+        tracker: wiring.sink,
+        ...(now ? { now } : {}),
+        ...(netInfo ? { netInfo } : {}),
+        ...(wiring.stop ? { onDispose: wiring.stop } : {}),
+    });
+    if (!cached?.fresh) {
+        fetchSettings(resolvedTransport)
+            .then((settings) => {
+            if (!settings)
+                return;
+            saveSettings(resolvedStorage, storeIdKey, settings, clock());
+            client.applySettings(unpinned(settings, pinned));
+        })
+            .catch((error) => {
+            console.warn("[Genlook] settings refresh failed:", error);
+        });
+    }
+    return client;
+}
+function pinnedFields(config) {
+    return {
+        maxGenerations: config.limits?.maxGenerations != null,
+        emailCollectionStep: config.limits?.emailCollectionStep != null,
+        period: config.limits?.period != null,
+        loggedInCustomersOnly: config.loggedInCustomersOnly != null,
+    };
+}
+function unpinned(settings, pins) {
+    const out = {};
+    if (!pins.maxGenerations && settings.maxGenerations !== undefined) {
+        out.maxGenerations = settings.maxGenerations;
+    }
+    if (!pins.emailCollectionStep && settings.emailCollectionStep !== undefined) {
+        out.emailCollectionStep = settings.emailCollectionStep;
+    }
+    if (!pins.period && settings.period !== undefined)
+        out.period = settings.period;
+    if (!pins.loggedInCustomersOnly && settings.loggedInCustomersOnly !== undefined) {
+        out.loggedInCustomersOnly = settings.loggedInCustomersOnly;
+    }
+    return out;
+}
+function withSettings(config, settings) {
+    const { loggedInCustomersOnly, ...limits } = settings;
+    if (loggedInCustomersOnly === undefined && Object.keys(limits).length === 0)
+        return config;
+    return {
+        ...config,
+        ...(loggedInCustomersOnly !== undefined ? { loggedInCustomersOnly } : {}),
+        limits: { ...config.limits, ...limits },
+    };
+}
+function wireDefaultTracker(args) {
+    const denied = args.tracking === "denied";
+    const consent = typeof args.tracking === "string" ? staticConsent(args.tracking) : args.tracking;
+    const instance = new Tracker({
+        transport: args.transport,
+        consent,
+        pageContext: createDefaultPageContext({
+            storage: args.storage,
+            storeId: args.storeId,
+            integration: args.integration,
+            integrationVersion: args.integrationVersion,
+            ...(args.pinnedAnonymousId ? { anonymousId: args.pinnedAnonymousId } : {}),
+            ...(args.widgetVersion?.startsWith("wv_") ? { widgetVersion: args.widgetVersion } : {}),
+            ...(args.screen ? { screen: args.screen } : {}),
+        }),
+        uuid,
+    });
+    const sink = {
+        capture: (event, props) => instance.capture(event, props),
+        flush: (opts) => instance.flush(opts),
+        ...(denied ? {} : { grantWidgetScopeConsent: () => instance.grantWidgetScopeConsent() }),
+    };
+    const handle = setInterval(() => {
+        instance.flush().catch(() => { });
+    }, args.flushIntervalMs);
+    handle?.unref?.();
+    return { sink, stop: () => clearInterval(handle) };
+}

package/dist/default-tracking.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Default tracking ports, so the core {@link Tracker} — the one real pipeline
+ * (queue, batching, consent gate, context assembly, `/events` wire format) — can
+ * be instantiated without a browser host.
+ *
+ * There is no second tracker here: this file only supplies the two host-shaped
+ * inputs the Tracker asks for on a runtime that has neither a CMP nor a DOM.
+ */
+import type { ConsentSource, IntegrationName, KVStorage, PageContext } from "./ports";
+/** Fixed consent posture for the SDK channel. */
+export type TrackingConsentMode = "granted" | "denied";
+/**
+ * A {@link ConsentSource} pinned to one state, never changing.
+ *
+ * Posture on this channel: the integrator embeds the SDK in their OWN product
+ * and owns the consent UX there, so the core cannot discover a verdict on its
+ * own — and the pipeline it gates is already PiiFree and pseudonymous (an
+ * `anon_` device id, no email, no address). `"granted"` is the default;
+ * `"denied"` cuts the channel entirely. An integrator with a real CMP passes a
+ * live ConsentSource instead.
+ */
+export declare function staticConsent(state: TrackingConsentMode): ConsentSource;
+/** Screen size, when the host can report one (React Native `Dimensions`, an
+ *  Electron display). Read per batch so a rotation is reflected. */
+export type ScreenSize = {
+    width: number;
+    height: number;
+};
+export interface DefaultPageContextOptions {
+    /** Device storage the anonymous id is read from (and purged from on deny). */
+    storage: KVStorage;
+    /** Pin the anonymous id instead of reading it from storage. Must match the id
+     *  the transport sends as `x-genlook-anonymous-id`, or try-ons and events land
+     *  on two different shoppers in the warehouse. */
+    anonymousId?: string;
+    /** Store the events belong to. */
+    storeId?: string | null;
+    /** Host platform label. Free-form; defaults to "sdk". */
+    platform?: string;
+    /** Client build id. BACKEND CONTRACT: must start with `wv_` or the batch is
+     *  rejected. Defaults to "wv_sdk". */
+    widgetVersion?: string;
+    /** Which surface this host is. Defaults to "tryon_core"; null sends an
+     *  unnamed batch. */
+    integration?: IntegrationName | null;
+    /** Version of that surface. Defaults to this package's semver — the core is
+     *  what runs here whatever the host calls itself. */
+    integrationVersion?: string | null;
+    /** Screen size if the host knows one; omitted means "unknown". */
+    screen?: ScreenSize | (() => ScreenSize | null | undefined);
+}
+/**
+ * A neutral, honest {@link PageContext} for a host with no page.
+ *
+ * Every browser field reports null rather than a plausible-looking stand-in;
+ * only what the runtime genuinely knows is filled in (timezone, the configured
+ * platform / store / build id, and the screen when the host supplies one).
+ *
+ * SESSION: there is one session per client instance, lasting as long as the
+ * process. `getIdentityContext` returns an empty `session_id` on purpose and
+ * lets the Tracker mint its own `sess_…` fallback once — duplicating that here
+ * would be a second source of truth for the same id.
+ */
+export declare function createDefaultPageContext(opts: DefaultPageContextOptions): PageContext;

package/dist/default-tracking.js

@@ -0,0 +1,101 @@
+import { getAnonymousId, GENLOOK_ANONYMOUS_ID_STORAGE_KEY } from "./anonymous-id";
+import { SDK_VERSION } from "./version";
+const SDK_CONSENT_SOURCE = "sdk-static";
+const GRANTED_SNAPSHOT = {
+    source: SDK_CONSENT_SOURCE,
+    available: true,
+    analytics: "yes",
+    marketing: "yes",
+    preferences: "yes",
+    sale_of_data: "yes",
+    analytics_allowed: true,
+    marketing_allowed: true,
+    preferences_allowed: true,
+    sale_of_data_allowed: true,
+    should_show_banner: false,
+    region: null,
+};
+const DENIED_SNAPSHOT = {
+    ...GRANTED_SNAPSHOT,
+    analytics: "no",
+    marketing: "no",
+    preferences: "no",
+    sale_of_data: "no",
+    analytics_allowed: false,
+    marketing_allowed: false,
+    preferences_allowed: false,
+    sale_of_data_allowed: false,
+};
+export function staticConsent(state) {
+    const snapshot = state === "denied" ? DENIED_SNAPSHOT : GRANTED_SNAPSHOT;
+    return {
+        getSnapshot: () => snapshot,
+        onChange: () => { },
+    };
+}
+function resolveTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    }
+    catch {
+        return "UTC";
+    }
+}
+export function createDefaultPageContext(opts) {
+    const { storage, anonymousId, storeId = null, platform = "sdk", widgetVersion = "wv_sdk", integration = "tryon_core", integrationVersion = SDK_VERSION, screen, } = opts;
+    const readScreen = () => {
+        try {
+            const value = typeof screen === "function" ? screen() : screen;
+            return value ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        isBot: () => false,
+        getPathname: () => null,
+        getBaseContext() {
+            const size = readScreen();
+            return {
+                $current_url: null,
+                $pathname: null,
+                $host: null,
+                $screen_width: size?.width ?? 0,
+                $screen_height: size?.height ?? 0,
+                $viewport_width: null,
+                $viewport_height: null,
+                $raw_user_agent: null,
+                $browser_language: null,
+                $timezone: resolveTimezone(),
+                widget_enabled: true,
+                platform,
+                store_id: storeId,
+                product_id: null,
+                variant_id: null,
+                widget_version: widgetVersion,
+                app_version: null,
+                page_type: null,
+                collection_id: null,
+                integration,
+                integration_version: integrationVersion,
+            };
+        },
+        getIdentityContext() {
+            return {
+                $referrer: null,
+                $referring_domain: null,
+                session_id: "",
+                anonymous_id: anonymousId ?? getAnonymousId(storage),
+                first_touch: null,
+            };
+        },
+        resetSessionId: () => { },
+        purgeTrackingStorage: () => {
+            try {
+                storage.removeItem(GENLOOK_ANONYMOUS_ID_STORAGE_KEY);
+            }
+            catch { }
+        },
+    };
+}

package/dist/email.d.ts

@@ -0,0 +1,5 @@
+import type { Transport } from "./ports";
+import type { CollectEmailRequest, CollectEmailResponse } from "./types";
+/** Collect user email and create/update customer record. Errors are logged then
+ *  rethrown (callers treat it as fire-and-forget). */
+export declare function collectEmail(transport: Transport, request: CollectEmailRequest): Promise<CollectEmailResponse>;

package/dist/email.js

@@ -0,0 +1,24 @@
+export async function collectEmail(transport, request) {
+    try {
+        const endpoint = "/shopper/email";
+        console.log("Collecting email at:", endpoint);
+        const response = await transport.fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to collect email: ${response.status} ${response.statusText}. ${errorText}`);
+        }
+        const result = (await response.json());
+        console.log("Email collected:", result.message);
+        return result;
+    }
+    catch (error) {
+        console.error("Failed to collect email:", error);
+        if (error instanceof Error)
+            throw error;
+        throw new Error(`Unexpected error: ${error}`);
+    }
+}

package/dist/entities.d.ts

@@ -0,0 +1,186 @@
+import type { UploadResult } from "./types";
+import type { TryOnResult } from "./history";
+export type PhotoId = string;
+export type GenId = string;
+export type UploadSource = "gallery" | "mirror";
+/** DOM-read image dimensions, or a sentinel the host passes when it did not read
+ *  them: "skipped" (HEIC-like — most browsers can't decode it for a preview read)
+ *  or "unreadable" (the browser image decode failed). The core validates against
+ *  these; the sentinels short-circuit the dimension check to a skip / reject. */
+export type UploadDimensions = {
+    width: number;
+    height: number;
+} | "unreadable" | "skipped";
+/** Upload metadata the headless core cannot derive from the opaque MediaInput —
+ *  the host reads it off the browser File and passes it in for the funnel events
+ *  and the pre-upload validation. */
+export interface UploadMeta {
+    fileSize: number;
+    mimeType: string;
+    uploadSource: UploadSource;
+    skipClientDimensionCheck: boolean;
+    /** Whole seconds between the file's `lastModified` and pick time. ~0 means the
+     *  photo was taken inside the chooser (camera path) — the only observable
+     *  signal separating "took one just now" from "dug one out of the roll".
+     *  Optional: hosts without a real File omit it. */
+    photoAgeSeconds?: number;
+    /** `lastModified` fell inside the OS chooser's open→resolve window — the photo
+     *  was taken via the chooser's camera path. Host-observed; omit when unknown. */
+    capturedInPicker?: boolean;
+    /** OS chooser open → file returned, in whole ms. Host-observed; omit when
+     *  unknown. */
+    pickerDurationMs?: number;
+    /** The page was backgrounded while the OS chooser was open — on Android the
+     *  chooser's camera path backgrounds the page; app switches do too.
+     *  Host-observed; omit when unknown. */
+    pickerBackgrounded?: boolean;
+    /** CORE-stamped (flushStagedPhoto), never host-set: how long the photo waited
+     *  at the consent gate before release. Presence = this upload was held. */
+    heldDurationMs?: number;
+    /** Original file name — used for HEIC-by-extension detection in validation.
+     *  Optional: an older host that predates core-side validation omits it, and the
+     *  core degrades the type check to mime-only rather than throwing. */
+    fileName?: string;
+    /** Host-supplied dimensions (or a sentinel). Optional: absent for an older host,
+     *  in which case the core skips the dimension check it cannot perform. */
+    dimensions?: UploadDimensions;
+}
+/** Photo upload lifecycle. The prepare→PUT→complete chain is synchronous; `ready`
+ *  carries the cropped result the widget chains generation off. */
+export type PhotoUpload = {
+    id: PhotoId;
+    status: "uploading";
+    progress: number;
+    createdAt: number;
+} | {
+    id: PhotoId;
+    status: "ready";
+    result: UploadResult;
+    createdAt: number;
+} | {
+    id: PhotoId;
+    status: "failed";
+    error: string;
+    createdAt: number;
+};
+export type GenErrorCode = "credits-expired" | "rate-limited" | "server-overloaded" | "upload-failed" | "network";
+export interface GenError {
+    code: GenErrorCode;
+    retryable: boolean;
+    /** Raw backend code (e.g. GENERATION_FAILED, FITTING_ROOM_WEEKLY_LIMIT_EXCEEDED)
+     *  so the host can preserve its exact error routing. Never rendered directly. */
+    backendCode?: string;
+}
+interface GenerationBase {
+    id: GenId;
+    photoId: PhotoId;
+    productId: string;
+    variantId?: string;
+    createdAt: number;
+    /** false until the host surfaces this result to the shopper (acknowledge()). */
+    seen: boolean;
+    /** true once this job's funnel event has been emitted; persisted so it fires
+     *  exactly once across refreshes/rehydrations. */
+    reported: boolean;
+    /** The exact quota-window timestamp (limits.tryOns entry) counted for THIS job
+     *  when it was accepted, so a terminal-error refund can remove precisely that
+     *  entry (not merely "the latest"). Persisted so the refund survives a reload.
+     *  undefined only for a legacy rehydrated job that predates usage tracking — such
+     *  a job cannot be refunded through its entry. */
+    usageAt?: number;
+    /** true once this job's counted use has been refunded (it reached a terminal
+     *  error). Persisted alongside the job so a resume-after-reload that re-drives
+     *  the same job never double-refunds. */
+    usageRefunded?: boolean;
+}
+/** Generation job lifecycle. */
+export type GenerationJob = (GenerationBase & {
+    status: "requested";
+}) | (GenerationBase & {
+    status: "generating";
+}) | (GenerationBase & {
+    status: "done";
+    resultImageUrl: string;
+    resultImageKey?: string;
+}) | (GenerationBase & {
+    status: "error";
+    error: GenError;
+});
+export type LimitPeriod = "daily" | "weekly";
+/** Limits config (from widget config) + runtime counters. Policy derives from this. */
+export interface LimitsState {
+    maxGenerations: number;
+    emailCollectionStep: number;
+    period: LimitPeriod;
+    loggedInCustomersOnly: boolean;
+    /** Legal-consent gate, seeded from `TryOnClientConfig.requireLegalConsent`
+     *  (default false). When true, `can("upload")` and `can("generate")` block with
+     *  `consent-required` until `legalConsent` is on record. */
+    requireLegalConsent: boolean;
+    /** Opt-in concurrency guard: when set to a finite number, blocks a new
+     *  generation while that many are already in-flight. Unset (the default)
+     *  disables the gate entirely. */
+    maxConcurrent?: number;
+    /** Timestamps of recent try-ons (windowed rate limit). Mirrors persisted StoredLimits. */
+    tryOns: number[];
+    /** Refund tombstones: `tryOns` timestamps refunded on a terminal generation
+     *  failure. Kept (and persisted) so a merge with another tab's copy can't
+     *  resurrect a refunded entry. Pruned on the same 7-day window as `tryOns`. */
+    refunded: number[];
+    /** Lifetime counter (email-collection step). */
+    totalTryOns: number;
+    /** null = not yet checked. */
+    creditsAllowed: boolean | null;
+}
+export interface IdentityState {
+    email: string | null;
+    loggedInCustomerId: string | null;
+}
+/** Shopper acceptance of the legal-consent gate. `version` is the wording version
+ *  the host presented (UI-owned constant); `acceptedAt` is an ISO-8601 timestamp.
+ *  Shape is byte-identical to the pre-headless mobile-sheet persisted record so an
+ *  already-consented shopper is recognized (see consent.ts STORAGE COMPAT). */
+export interface LegalConsent {
+    version: string;
+    acceptedAt: string;
+}
+export interface CoreState {
+    photos: Record<PhotoId, PhotoUpload>;
+    /** The current upload entity id (supersede-latest). Set at entity creation to
+     *  the newest upload; a superseded (older) upload's later transition never
+     *  rewrites it. Read `selectCurrentUpload` to render the current upload — a
+     *  superseded upload's ready/failed state is deliberately not surfaced there.
+     *  null = no upload registered (or the host cleared the selected photo). */
+    latestPhotoId: PhotoId | null;
+    generations: Record<GenId, GenerationJob>;
+    /** Shopper-facing result list, newest-first. Scripted entries (no backing
+     *  generations[id] job) are first-class members. */
+    history: TryOnResult[];
+    limits: LimitsState;
+    identity: IdentityState;
+    /** Shopper's legal-consent acceptance, loaded from storage at client boot;
+     *  null = never accepted (a UI may show a consent screen). The policy layer
+     *  reads it ONLY when `limits.requireLegalConsent` is on (host opt-in); every
+     *  other host keeps consent as a purely UI-side decision. */
+    legalConsent: LegalConsent | null;
+}
+export declare const GENERATION_TERMINAL_STATUSES: readonly ["done", "error"];
+export declare function isGenerationTerminal(job: GenerationJob): boolean;
+/**
+ * The current (latest-registered) upload entity, or null. Supersede-latest: a
+ * newer upload becomes current; a superseded (older) upload's later transition
+ * never rewrites `latestPhotoId`, so its ready/failed state is NOT surfaced here.
+ * The promise analog is the client's PendingUpload (what `generate({ userImage:
+ * "latest" })` awaits). A white-label host renders upload progress from this +
+ * subscribe(), mirroring how it renders generation progress from `generations`.
+ */
+export declare function selectCurrentUpload(state: CoreState): PhotoUpload | null;
+/** Completed jobs not yet surfaced to the shopper (completed-while-away results). */
+export declare function selectUnseenResults(state: CoreState): GenerationJob[];
+export declare function isGenerationInFlight(job: GenerationJob): boolean;
+export declare function windowMs(period: LimitPeriod): number;
+/** Count try-on timestamps inside the rate-limit window ending at `now`. */
+export declare function countInWindow(tryOns: number[], period: LimitPeriod, now: number): number;
+export declare function defaultLimitsState(): LimitsState;
+export declare function initialCoreState(): CoreState;
+export {};

package/dist/entities.js

@@ -0,0 +1,47 @@
+export const GENERATION_TERMINAL_STATUSES = ["done", "error"];
+export function isGenerationTerminal(job) {
+    return job.status === "done" || job.status === "error";
+}
+export function selectCurrentUpload(state) {
+    return state.latestPhotoId ? (state.photos[state.latestPhotoId] ?? null) : null;
+}
+export function selectUnseenResults(state) {
+    return Object.values(state.generations)
+        .filter((j) => j.status === "done" && !j.seen)
+        .sort((a, b) => a.createdAt - b.createdAt);
+}
+export function isGenerationInFlight(job) {
+    return job.status === "requested" || job.status === "generating";
+}
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function windowMs(period) {
+    return period === "daily" ? DAY_MS : 7 * DAY_MS;
+}
+export function countInWindow(tryOns, period, now) {
+    const cutoff = now - windowMs(period);
+    return tryOns.filter((ts) => ts > cutoff).length;
+}
+export function defaultLimitsState() {
+    return {
+        maxGenerations: 6,
+        emailCollectionStep: 1,
+        period: "weekly",
+        loggedInCustomersOnly: false,
+        requireLegalConsent: false,
+        tryOns: [],
+        refunded: [],
+        totalTryOns: 0,
+        creditsAllowed: null,
+    };
+}
+export function initialCoreState() {
+    return {
+        photos: {},
+        latestPhotoId: null,
+        generations: {},
+        history: [],
+        limits: defaultLimitsState(),
+        identity: { email: null, loggedInCustomerId: null },
+        legalConsent: null,
+    };
+}

package/dist/erasure.d.ts

@@ -0,0 +1,36 @@
+import type { Transport } from "./ports";
+/**
+ * Send the shopper "delete my data" request to the Genlook proxy. It is a DELETE
+ * with no body — the proxy injects the shopper-identity headers, so the backend
+ * already knows whose data to erase. Throws on a non-2xx response (mirrors
+ * createShareLink's error style). Returns nothing: the backend replies
+ * `{ success: true }`, which the core never needs to read.
+ */
+export declare function deleteMyData(transport: Transport): Promise<void>;
+export interface ErasureEngineDeps {
+    transport: Transport;
+    /** Clear the shopper-facing history slice (bound to client.clearHistory). */
+    clearHistory: () => void;
+    /** Drop the tracked/pending upload (bound to client.clearPendingUpload). */
+    clearPendingUpload: () => void;
+    /** Emit tryon:data_erased — fired ONLY after a successful backend erasure. */
+    emitDataErased: () => void;
+}
+/**
+ * Drive a shopper "delete my data" request: erase server-side, then wipe the
+ * local shopper state.
+ *
+ *  - SUCCESS: the backend erase resolves, `tryon:data_erased` fires, then the
+ *    local history + pending upload are cleared.
+ *  - FAILURE: the local history + pending upload are STILL cleared (preserving
+ *    the pre-wiring UX — the shopper's screen empties either way), but the event
+ *    does NOT fire and the error is swallowed after logging.
+ *
+ * Never rejects — same best-effort contract as rateResult. Rationale: erasure is
+ * best-effort from the widget's side (the backend also purges on its own
+ * schedule), and blocking the shopper on a transient proxy error would strand
+ * them on a screen still showing the photos they just asked to delete. The clear
+ * runs in `finally` so it happens on both paths; the emit runs only in the try,
+ * after a confirmed success.
+ */
+export declare function runDataErasure(deps: ErasureEngineDeps): Promise<void>;

package/dist/erasure.js

@@ -0,0 +1,23 @@
+export async function deleteMyData(transport) {
+    const endpoint = "/shopper";
+    const response = await transport.fetch(endpoint, {
+        method: "DELETE",
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to delete data: ${response.status} ${response.statusText}. ${errorText}`);
+    }
+}
+export async function runDataErasure(deps) {
+    try {
+        await deleteMyData(deps.transport);
+        deps.emitDataErased();
+    }
+    catch (error) {
+        console.error("[Genlook] shopper erasure failed:", error);
+    }
+    finally {
+        deps.clearHistory();
+        deps.clearPendingUpload();
+    }
+}