@comfyorg/account-core 1.0.0-alpha.0

package/dist/core/billing/operationLifecycle.js

@@ -0,0 +1,547 @@
+/**
+ * The operation lifecycle every billing command sits on: adopt a
+ * `billing_op_id`, observe it to a terminal state, and reattach to it after a
+ * reload, a focus, or a return to the workspace — without ever creating a
+ * replacement operation. Commands issue the request; this owns everything
+ * that happens to the id afterwards.
+ *
+ * Framework-free by construction. Nothing here opens a URL, drives a
+ * payment-provider challenge, or listens to a document: a host renders the
+ * state (`actionUrl`, `challenge`), performs those effects itself, and
+ * reports back through `reportChallenge*` and `wake`.
+ *
+ * Behavior is ported from the cloud app's `billingOperationStore` — the
+ * cadence, the budgets, the parked-on-customer rules, the challenge echo
+ * suppression — and from the pending-checkout pointer's terminal rule; the
+ * wiring onto the scope source, the scope tracker, and the generated
+ * contract is new.
+ */
+import { zBillingOpStatusResponse } from '@comfyorg/ingest-types/zod';
+import { BILLING_OPERATION_TELEMETRY_EVENT } from '../../telemetry.js';
+import { createBillingScopeTracker } from './billingScope.js';
+import { NO_POINTER_STORE, createOperationPointerStore } from './operationPointer.js';
+import { hasExhaustedPollBudget, nextPollDelayMs } from './operationPolicy.js';
+import { isTerminal, reduceBillingOperation, validateActionUrl } from './operationState.js';
+import { selectBillingPresentation } from './presentation.js';
+import { readValidatedBillingResponse } from './sharedRead.js';
+export function operationRoute(operationId) {
+    return `/billing/ops/${encodeURIComponent(operationId)}`;
+}
+const NOT_AUTHENTICATED = {
+    status: 'error',
+    code: 'NOT_AUTHENTICATED'
+};
+const SUPERSEDED = {
+    status: 'error',
+    code: 'SUPERSEDED'
+};
+function continuationOf(issued) {
+    return {
+        ...(issued.actionUrl === undefined ? {} : { actionUrl: issued.actionUrl }),
+        ...(issued.clientSecret === undefined
+            ? {}
+            : { clientSecret: issued.clientSecret })
+    };
+}
+function pendingFromStatus(status) {
+    if (status.pending_billing_op_id === undefined)
+        return undefined;
+    return {
+        id: status.pending_billing_op_id,
+        kind: status.pending_billing_op_type === 'topup' ? 'topup' : 'subscription',
+        ...continuationOf({
+            actionUrl: status.action_url,
+            clientSecret: status.payment_intent_client_secret
+        })
+    };
+}
+function initialPendingState(input, observedAt, presentation) {
+    const actionUrl = validateActionUrl(input.actionUrl);
+    const challenge = input.clientSecret === undefined || input.presentation !== 'embedded'
+        ? undefined
+        : { clientSecret: input.clientSecret, status: 'required' };
+    return {
+        id: input.id,
+        kind: input.kind,
+        scope: input.context.scope,
+        ...presentation,
+        observedAt,
+        attemptStartedAt: input.attemptStartedAt,
+        phase: 'pending',
+        ...(actionUrl === undefined ? {} : { actionUrl }),
+        ...(challenge === undefined ? {} : { challenge }),
+        customerActionSeen: actionUrl !== undefined || input.clientSecret !== undefined
+    };
+}
+function failureCategoryFor(state) {
+    switch (state.phase) {
+        case 'succeeded':
+            return undefined;
+        case 'failed':
+            return state.kind === 'cancel' ? 'api_rejected' : 'provider_decline';
+        case 'timed_out':
+            return 'poll_timeout';
+        case 'reconciliation_needed':
+            return 'reconciliation_needed';
+        case 'superseded':
+            return 'stale_operation';
+    }
+}
+/** The pause is this tab's own challenge on screen; a hosted page never pauses. */
+function isDrivingChallenge(state) {
+    return (state.presentation === 'embedded' &&
+        state.challenge?.status === 'in_progress');
+}
+export function createBillingOperationLifecycle(options) {
+    const { transport, scopeSource, statusReader, embeddedCheckoutAvailable = () => false, hostedDestination = () => 'stripe', onTelemetry, now = Date.now } = options;
+    const pointers = options.pointerStorage === undefined
+        ? NO_POINTER_STORE
+        : createOperationPointerStore(options.pointerStorage, now);
+    const operations = new Map();
+    const inFlightCommands = new Map();
+    const listeners = new Set();
+    const lifetime = { disposed: false };
+    // Role is part of the scope, so a demotion mid-payment supersedes the
+    // operation and this tab stops observing it. The pointer key omits role on
+    // purpose: the charge still belongs to (user, workspace), so `recover` finds
+    // it again under the new role. Keying the pointer by role would strand it.
+    const scopeTracker = createBillingScopeTracker(scopeSource, () => {
+        for (const record of operations.values()) {
+            dispatch(record, { type: 'superseded' });
+        }
+    });
+    function isLive(context) {
+        return !lifetime.disposed && scopeTracker.isCurrent(context);
+    }
+    function publish(record) {
+        for (const listener of [...listeners])
+            listener(record.state);
+    }
+    function stopTimer(record) {
+        if (record.timer === undefined)
+            return;
+        clearTimeout(record.timer);
+        record.timer = undefined;
+    }
+    function emitTerminalTelemetry(record) {
+        const state = record.state;
+        if (!isTerminal(state))
+            return;
+        const category = failureCategoryFor(state);
+        onTelemetry?.({
+            name: state.phase === 'succeeded'
+                ? BILLING_OPERATION_TELEMETRY_EVENT.succeeded
+                : state.phase === 'timed_out'
+                    ? BILLING_OPERATION_TELEMETRY_EVENT.timeout
+                    : BILLING_OPERATION_TELEMETRY_EVENT.failed,
+            billing_op_id: state.id,
+            operation_type: state.kind,
+            presentation: state.presentation,
+            resumed: record.resumed,
+            ...(category === undefined ? {} : { failure_category: category }),
+            ...(state.phase === 'failed'
+                ? { decline_reason: state.declineReason }
+                : {}),
+            duration_ms: now() - state.attemptStartedAt
+        });
+    }
+    function dispatch(record, event) {
+        const next = reduceBillingOperation(record.state, event);
+        if (next === record.state)
+            return;
+        record.state = next;
+        if (isTerminal(next)) {
+            stopTimer(record);
+            pointers.clearIfTerminal(next);
+            emitTerminalTelemetry(record);
+            record.resolveSettled(next);
+        }
+        publish(record);
+    }
+    function schedule(record) {
+        if (record.state.phase !== 'pending')
+            return;
+        stopTimer(record);
+        const delayMs = nextPollDelayMs(record.state, record.delayMs);
+        record.delayMs = delayMs;
+        record.timer = setTimeout(() => void poll(record), delayMs);
+    }
+    // One request per record at a time: a wake arriving mid-poll joins the
+    // poll in flight instead of doubling the request rate. The request is
+    // bound to the record, not the id, so an id re-adopted after supersession
+    // starts its own observation instead of joining a poll that can no longer
+    // schedule it.
+    function poll(record) {
+        if (record.inFlightPoll !== undefined)
+            return record.inFlightPoll;
+        const request = pollOnce(record).finally(() => {
+            record.inFlightPoll = undefined;
+        });
+        record.inFlightPoll = request;
+        return request;
+    }
+    function writePointer(scope, state) {
+        pointers.write(scope, {
+            operationId: state.id,
+            kind: state.kind,
+            presentation: state.presentation,
+            attemptStartedAt: state.attemptStartedAt
+        });
+    }
+    function readOperation(operationId) {
+        return readValidatedBillingResponse(transport, { method: 'GET', route: operationRoute(operationId) }, (body) => zBillingOpStatusResponse.safeParse(body));
+    }
+    function continueOrExpire(record) {
+        if (record.state.phase !== 'pending')
+            return;
+        if (hasExhaustedPollBudget(record.state, now())) {
+            dispatch(record, { type: 'timed_out' });
+            return;
+        }
+        schedule(record);
+    }
+    async function pollOnce(record) {
+        const state = record.state;
+        if (state.phase !== 'pending')
+            return;
+        stopTimer(record);
+        if (isDrivingChallenge(state))
+            return;
+        if (!scopeTracker.isCurrent(record.context)) {
+            dispatch(record, { type: 'superseded' });
+            return;
+        }
+        if (hasExhaustedPollBudget(state, now())) {
+            dispatch(record, { type: 'timed_out' });
+            return;
+        }
+        const response = await readOperation(state.id);
+        if (record.state.phase !== 'pending')
+            return;
+        if (!isLive(record.context)) {
+            dispatch(record, { type: 'superseded' });
+            return;
+        }
+        applyPollResponse(record, response);
+    }
+    function applyPollResponse(record, response) {
+        if (response.status === 'ok') {
+            dispatch(record, { type: 'status_polled', status: response.value.data });
+            continueOrExpire(record);
+            return;
+        }
+        if (response.code === 'SUPERSEDED' ||
+            response.code === 'ACCESS_DENIED' ||
+            response.code === 'NOT_AUTHENTICATED') {
+            dispatch(record, { type: 'superseded' });
+        }
+        else if (response.code === 'NOT_FOUND') {
+            dispatch(record, { type: 'lost' });
+        }
+        else {
+            continueOrExpire(record);
+        }
+    }
+    /** Read at every adoption, so an operation recovered from the pointer lands on today's destination. */
+    function destinationFor(presentation) {
+        return presentation === 'hosted'
+            ? { presentation, hostedDestination: hostedDestination() }
+            : { presentation };
+    }
+    function adopt(input) {
+        const existing = operations.get(input.id);
+        if (existing !== undefined &&
+            existing.state.phase !== 'timed_out' &&
+            existing.state.phase !== 'superseded') {
+            return existing;
+        }
+        const state = initialPendingState(input, now(), destinationFor(input.presentation));
+        let resolveSettled = () => { };
+        const settled = new Promise((resolve) => {
+            resolveSettled = resolve;
+        });
+        const record = {
+            state,
+            context: input.context,
+            resumed: input.resumed,
+            delayMs: undefined,
+            timer: undefined,
+            inFlightPoll: undefined,
+            settled,
+            resolveSettled
+        };
+        operations.set(input.id, record);
+        writePointer(input.context.scope, state);
+        onTelemetry?.({
+            name: BILLING_OPERATION_TELEMETRY_EVENT.started,
+            billing_op_id: input.id,
+            operation_type: input.kind,
+            presentation: input.presentation,
+            resumed: input.resumed
+        });
+        publish(record);
+        if (input.initialStatus === undefined) {
+            void poll(record);
+        }
+        else {
+            dispatch(record, { type: 'status_polled', status: input.initialStatus });
+            continueOrExpire(record);
+        }
+        return record;
+    }
+    function routeFor(rail, issued) {
+        return selectBillingPresentation({
+            embeddedCheckoutAvailable: embeddedCheckoutAvailable(),
+            billingRail: rail,
+            ...(issued.actionUrl === undefined
+                ? {}
+                : { hostedUrl: issued.actionUrl }),
+            ...(issued.clientSecret === undefined
+                ? {}
+                : { clientSecret: issued.clientSecret })
+        });
+    }
+    async function beginOnce(kind, context, issue) {
+        // The backend's word on what is already pending comes first: a second
+        // charge attempt is never issued over one the server is still settling.
+        const status = await statusReader.read();
+        // A scope change outranks a failed read, as in recover().
+        if (!isLive(context))
+            return SUPERSEDED;
+        if (status.status === 'error')
+            return status;
+        const rail = status.value.status.billing_rail;
+        const pending = pendingFromStatus(status.value.status);
+        if (pending !== undefined && pending.kind === kind) {
+            const record = adopt({
+                ...pending,
+                context,
+                presentation: routeFor(rail, pending),
+                attemptStartedAt: now(),
+                resumed: true
+            });
+            return { status: 'ok', value: record.state };
+        }
+        const attemptStartedAt = now();
+        const issued = await issue(context.scope);
+        if (!isLive(context)) {
+            // The operation exists server-side under the scope this tab just left;
+            // the pointer waits there so a return recovers it rather than reissuing.
+            if (issued.status === 'ok') {
+                pointers.write(context.scope, {
+                    operationId: issued.value.operationId,
+                    kind,
+                    presentation: routeFor(rail, issued.value),
+                    attemptStartedAt
+                });
+            }
+            return SUPERSEDED;
+        }
+        if (issued.status === 'error')
+            return issued;
+        const record = adopt({
+            id: issued.value.operationId,
+            kind,
+            context,
+            presentation: routeFor(rail, issued.value),
+            ...continuationOf(issued.value),
+            attemptStartedAt,
+            resumed: false
+        });
+        return { status: 'ok', value: record.state };
+    }
+    function begin(kind, issue) {
+        if (lifetime.disposed)
+            return Promise.resolve(SUPERSEDED);
+        const context = scopeTracker.capture();
+        if (context === undefined)
+            return Promise.resolve(NOT_AUTHENTICATED);
+        // Single-flight holds only within a scope: an attempt the scope change
+        // already doomed to SUPERSEDED must not stand in for this caller's.
+        const inFlight = inFlightCommands.get(kind);
+        if (inFlight !== undefined && isLive(inFlight.context)) {
+            return inFlight.promise;
+        }
+        const attempt = beginOnce(kind, context, issue).finally(() => {
+            if (inFlightCommands.get(kind)?.promise === attempt) {
+                inFlightCommands.delete(kind);
+            }
+        });
+        inFlightCommands.set(kind, { context, promise: attempt });
+        return attempt;
+    }
+    // Unreachable is not "nothing pending": the pointer is the only evidence
+    // left, and observing it costs a poll while reissuing could cost a charge.
+    function recoverFromPointer(failure, pointer, context) {
+        if (failure.code !== 'REQUEST_FAILED' || pointer === undefined) {
+            return failure;
+        }
+        const record = adopt({
+            id: pointer.operationId,
+            kind: pointer.kind,
+            context,
+            presentation: pointer.presentation,
+            attemptStartedAt: pointer.attemptStartedAt,
+            resumed: true
+        });
+        return { status: 'ok', value: record.state };
+    }
+    function resumeServerPending(pending, rail, pointer, context) {
+        const known = pointer?.operationId === pending.id ? pointer : undefined;
+        const record = adopt({
+            ...pending,
+            context,
+            presentation: known?.presentation ?? routeFor(rail, pending),
+            attemptStartedAt: known?.attemptStartedAt ?? now(),
+            resumed: true
+        });
+        return { status: 'ok', value: record.state };
+    }
+    // The server reports nothing pending, so the pointed-at operation has
+    // either settled since this tab last saw it or never belonged to this
+    // scope. One read decides which; a stale pointer is dropped, never
+    // re-observed on a schedule.
+    async function probePointer(pointer, context) {
+        const probe = await readOperation(pointer.operationId);
+        if (!isLive(context))
+            return SUPERSEDED;
+        if (probe.status === 'error') {
+            if (probe.code !== 'NOT_FOUND')
+                return probe;
+            pointers.clear(context.scope, pointer.operationId);
+            return { status: 'ok', value: undefined };
+        }
+        const record = adopt({
+            id: pointer.operationId,
+            kind: pointer.kind,
+            context,
+            presentation: pointer.presentation,
+            attemptStartedAt: pointer.attemptStartedAt,
+            resumed: true,
+            initialStatus: probe.value.data
+        });
+        return { status: 'ok', value: record.state };
+    }
+    async function recover() {
+        if (lifetime.disposed)
+            return SUPERSEDED;
+        const context = scopeTracker.capture();
+        if (context === undefined)
+            return NOT_AUTHENTICATED;
+        const status = await statusReader.read();
+        if (!isLive(context))
+            return SUPERSEDED;
+        const pointer = pointers.read(context.scope);
+        if (status.status === 'error') {
+            return recoverFromPointer(status, pointer, context);
+        }
+        const pending = pendingFromStatus(status.value.status);
+        if (pending !== undefined) {
+            return resumeServerPending(pending, status.value.status.billing_rail, pointer, context);
+        }
+        if (pointer === undefined)
+            return { status: 'ok', value: undefined };
+        return probePointer(pointer, context);
+    }
+    function wake() {
+        for (const record of operations.values()) {
+            if (record.state.phase !== 'pending')
+                continue;
+            if (isDrivingChallenge(record.state))
+                continue;
+            void poll(record);
+        }
+    }
+    function refusedSwitch(state, presentation) {
+        if (state.presentation === presentation)
+            return 'unchanged';
+        if (presentation === 'hosted') {
+            return state.actionUrl === undefined ? 'no_hosted_url' : undefined;
+        }
+        return !embeddedCheckoutAvailable() || state.challenge === undefined
+            ? 'embedded_unavailable'
+            : undefined;
+    }
+    function switchEvent(presentation) {
+        return presentation === 'hosted'
+            ? {
+                type: 'presentation_switched',
+                presentation,
+                hostedDestination: hostedDestination()
+            }
+            : { type: 'presentation_switched', presentation };
+    }
+    function switchPresentation(operationId, presentation) {
+        const record = operations.get(operationId);
+        if (record === undefined)
+            return 'unknown_operation';
+        const state = record.state;
+        if (state.phase !== 'pending')
+            return 'not_pending';
+        const refusal = refusedSwitch(state, presentation);
+        if (refusal !== undefined)
+            return refusal;
+        dispatch(record, switchEvent(presentation));
+        writePointer(record.context.scope, record.state);
+        record.delayMs = undefined;
+        schedule(record);
+        return 'switched';
+    }
+    function reportChallengeStarted(operationId) {
+        const record = operations.get(operationId);
+        if (record === undefined)
+            return;
+        dispatch(record, { type: 'challenge_started' });
+        if (record.state.phase === 'pending' && isDrivingChallenge(record.state)) {
+            stopTimer(record);
+        }
+    }
+    function reportChallengeSettled(operationId, outcome) {
+        const record = operations.get(operationId);
+        if (record === undefined || record.state.phase !== 'pending')
+            return;
+        dispatch(record, { type: 'challenge_settled', outcome });
+        record.delayMs = undefined;
+        // A completed challenge is read back at once; a failed one is not a
+        // verdict on the payment — the server may have seen it succeed — so the
+        // operation stays observed on the parked cadence rather than stopping.
+        if (outcome === 'completed')
+            void poll(record);
+        else
+            schedule(record);
+    }
+    return {
+        begin,
+        recover,
+        wake,
+        switchPresentation,
+        reportChallengeStarted,
+        reportChallengeSettled,
+        get: (operationId) => operations.get(operationId)?.state,
+        getSnapshot: () => [...operations.values()].map((record) => record.state),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        settled: (operationId) => operations.get(operationId)?.settled,
+        dispose: () => {
+            lifetime.disposed = true;
+            // Every pending settlement resolves so no awaiting host hangs; this is
+            // the tab giving up observation, not an outcome, so no telemetry.
+            for (const record of operations.values()) {
+                stopTimer(record);
+                const next = reduceBillingOperation(record.state, {
+                    type: 'superseded'
+                });
+                if (next === record.state)
+                    continue;
+                record.state = next;
+                record.resolveSettled(next);
+            }
+            operations.clear();
+            inFlightCommands.clear();
+            listeners.clear();
+            scopeTracker.dispose();
+        }
+    };
+}

package/dist/core/billing/operationPointer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The tab-local pointer to an operation this tab is observing, so a reload
+ * reattaches to the same `billing_op_id` instead of starting a replacement
+ * charge. The host supplies the storage (origin-scoped `sessionStorage` in a
+ * browser); the SDK owns the key, the shape, and the rule for when the
+ * pointer may go.
+ *
+ * The pointer is keyed by scope, so a workspace switch neither reads nor
+ * clears another workspace's operation, and switching back finds it again.
+ */
+import { z } from 'zod';
+import type { BillingScope } from './billingScope.js';
+import type { BillingOperationState } from './operationState.js';
+export interface BillingOperationPointerStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}
+export declare const OPERATION_POINTER_MAX_AGE_MS: number;
+declare const PointerSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    kind: z.ZodEnum<["subscription", "topup", "cancel"]>;
+    presentation: z.ZodEnum<["embedded", "hosted"]>;
+    attemptStartedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "cancel" | "subscription" | "topup";
+    attemptStartedAt: number;
+    presentation: "embedded" | "hosted";
+    operationId: string;
+}, {
+    kind: "cancel" | "subscription" | "topup";
+    attemptStartedAt: number;
+    presentation: "embedded" | "hosted";
+    operationId: string;
+}>;
+export type BillingOperationPointer = z.infer<typeof PointerSchema>;
+export declare function operationPointerKey(scope: BillingScope): string;
+export interface OperationPointerStore {
+    read: (scope: BillingScope) => BillingOperationPointer | undefined;
+    write: (scope: BillingScope, pointer: BillingOperationPointer) => void;
+    /** Clears only when the stored pointer names `operationId`, or unconditionally without one. */
+    clear: (scope: BillingScope, operationId?: string) => void;
+    clearIfTerminal: (state: BillingOperationState) => void;
+}
+export declare function createOperationPointerStore(storage: BillingOperationPointerStorage, now?: () => number): OperationPointerStore;
+/** A store for hosts without tab-local storage: nothing is ever recovered. */
+export declare const NO_POINTER_STORE: OperationPointerStore;
+export {};

package/dist/core/billing/operationPointer.js

@@ -0,0 +1,89 @@
+/**
+ * The tab-local pointer to an operation this tab is observing, so a reload
+ * reattaches to the same `billing_op_id` instead of starting a replacement
+ * charge. The host supplies the storage (origin-scoped `sessionStorage` in a
+ * browser); the SDK owns the key, the shape, and the rule for when the
+ * pointer may go.
+ *
+ * The pointer is keyed by scope, so a workspace switch neither reads nor
+ * clears another workspace's operation, and switching back finds it again.
+ */
+import { z } from 'zod';
+const POINTER_KEY_PREFIX = 'comfy:billing:operation';
+export const OPERATION_POINTER_MAX_AGE_MS = 24 * 60 * 60_000;
+const PointerSchema = z.object({
+    operationId: z.string().min(1),
+    kind: z.enum(['subscription', 'topup', 'cancel']),
+    presentation: z.enum(['embedded', 'hosted']),
+    attemptStartedAt: z.number().finite()
+});
+/**
+ * A client-side timeout is this tab giving up, not the server finishing:
+ * an operation awaiting bank authentication stays pending for hours, so the
+ * pointer outlives it. A superseded operation belongs to a scope this tab
+ * left, and its pointer waits under that scope's key for a return.
+ * `reconciliation_needed` is terminal for polling, so retaining its pointer
+ * would re-poll a settled operation on every reload.
+ */
+const CLEARS_POINTER = {
+    pending: false,
+    timed_out: false,
+    superseded: false,
+    succeeded: true,
+    failed: true,
+    reconciliation_needed: true
+};
+export function operationPointerKey(scope) {
+    return `${POINTER_KEY_PREFIX}:${scope.userId}:${scope.workspaceId}`;
+}
+/** Storage that throws (private mode, quota) reads as empty and writes as a no-op. */
+function attempt(read, fallback) {
+    try {
+        return read();
+    }
+    catch {
+        return fallback;
+    }
+}
+function decodePointer(raw, now) {
+    if (raw === null)
+        return undefined;
+    const parsed = PointerSchema.safeParse(attempt(() => JSON.parse(raw), null));
+    if (!parsed.success)
+        return undefined;
+    const age = now - parsed.data.attemptStartedAt;
+    return age >= 0 && age <= OPERATION_POINTER_MAX_AGE_MS
+        ? parsed.data
+        : undefined;
+}
+export function createOperationPointerStore(storage, now = Date.now) {
+    const read = (scope) => {
+        const key = operationPointerKey(scope);
+        const pointer = decodePointer(attempt(() => storage.getItem(key), null), now());
+        if (pointer === undefined)
+            attempt(() => storage.removeItem(key), undefined);
+        return pointer;
+    };
+    const clear = (scope, operationId) => {
+        if (operationId !== undefined && read(scope)?.operationId !== operationId) {
+            return;
+        }
+        attempt(() => storage.removeItem(operationPointerKey(scope)), undefined);
+    };
+    return {
+        read,
+        write: (scope, pointer) => attempt(() => storage.setItem(operationPointerKey(scope), JSON.stringify(pointer)), undefined),
+        clear,
+        clearIfTerminal: (state) => {
+            if (CLEARS_POINTER[state.phase])
+                clear(state.scope, state.id);
+        }
+    };
+}
+/** A store for hosts without tab-local storage: nothing is ever recovered. */
+export const NO_POINTER_STORE = {
+    read: () => undefined,
+    write: () => { },
+    clear: () => { },
+    clearIfTerminal: () => { }
+};