@storystick/preview 0.0.0-stage → 0.2.0-rc.1

package/dist/dev/suspicious-codeword-detector.js

@@ -0,0 +1,220 @@
+import { decodePreviewProvenanceText } from '../provenance/coded-text.js';
+const OVERLAY_ELEMENT = 'STORYSTICK-PREVIEW-FIELD-OVERLAYS';
+const PREVIEW_TRANSPORT_ATTRIBUTES = new Set(['data-ss-model']);
+let comparisonBlindSpotNoticeEmitted = false;
+/**
+ * Dev-only audit for coded text in sinks where the invisible payload is
+ * intrinsically dangerous. Rendered text is deliberately ignored: coded text
+ * is expected there, and treating it as suspicious would create false positives.
+ */
+export function observeSuspiciousPreviewCodewords(doc, onReports) {
+    const view = doc.defaultView;
+    if (view === null || doc.documentElement === null)
+        return () => undefined;
+    if (!comparisonBlindSpotNoticeEmitted) {
+        comparisonBlindSpotNoticeEmitted = true;
+        console.warn('[storystick] String comparisons on a coded value fail in preview — use clean().');
+    }
+    const reported = new Set();
+    const pendingReports = [];
+    const pendingMutations = [];
+    let initialAuditDone = false;
+    let cancelScheduled = null;
+    let disposed = false;
+    const sink = (kind, element, attribute, value) => {
+        const decoded = decodePreviewProvenanceText(value);
+        if (decoded.segments.length === 0)
+            return;
+        const markerIds = [...new Set(decoded.segments.map((segment) => segment.markerId))];
+        const key = `${kind}|${element?.tagName ?? ''}|${attribute ?? ''}|${markerIds.join(',')}|${decoded.text}`;
+        if (reported.has(key))
+            return;
+        reported.add(key);
+        pendingReports.push({
+            kind,
+            ...(element ? { element } : {}),
+            ...(attribute ? { attribute } : {}),
+            value,
+            cleaned: decoded.text,
+            markerIds,
+        });
+    };
+    const process = () => {
+        cancelScheduled = null;
+        if (disposed)
+            return;
+        if (!initialAuditDone) {
+            initialAuditDone = true;
+            auditDocument(doc, sink);
+        }
+        for (const mutation of pendingMutations.splice(0)) {
+            processMutation(doc, mutation, sink);
+        }
+        if (pendingReports.length > 0) {
+            onReports(pendingReports.splice(0));
+        }
+    };
+    const schedule = () => {
+        if (cancelScheduled !== null || disposed)
+            return;
+        cancelScheduled = scheduleIdle(view, process);
+    };
+    const observer = new view.MutationObserver((mutations) => {
+        pendingMutations.push(...mutations);
+        schedule();
+    });
+    observer.observe(doc.documentElement, {
+        attributes: true,
+        characterData: true,
+        childList: true,
+        subtree: true,
+    });
+    schedule();
+    return () => {
+        disposed = true;
+        observer.disconnect();
+        cancelScheduled?.();
+        cancelScheduled = null;
+    };
+}
+function auditDocument(doc, sink) {
+    if (doc.documentElement)
+        checkElementAttributes(doc.documentElement, false, sink);
+    if (doc.head)
+        auditTree(doc, doc.head, true, sink);
+    if (doc.body)
+        auditTree(doc, doc.body, false, sink);
+    const href = doc.location?.href;
+    if (!href)
+        return;
+    if (hasCodedText(href)) {
+        sink('url', undefined, undefined, href);
+        return;
+    }
+    try {
+        const decoded = decodeURIComponent(href);
+        if (hasCodedText(decoded))
+            sink('url', undefined, undefined, decoded);
+    }
+    catch {
+        // Malformed URLs are outside the detector's remit.
+    }
+}
+function auditTree(doc, root, inHead, sink) {
+    visitNode(doc, root, inHead, sink);
+    const nodeFilter = doc.defaultView?.NodeFilter;
+    if (!nodeFilter)
+        return;
+    const walker = doc.createTreeWalker(root, nodeFilter.SHOW_ELEMENT | nodeFilter.SHOW_TEXT, {
+        acceptNode: (node) => isOverlayElement(node)
+            ? nodeFilter.FILTER_REJECT
+            : nodeFilter.FILTER_ACCEPT,
+    });
+    let node;
+    while ((node = walker.nextNode()))
+        visitNode(doc, node, inHead, sink);
+}
+function visitNode(doc, node, inHead, sink) {
+    if (isElement(node)) {
+        if (!isOverlayElement(node))
+            checkElementAttributes(node, inHead, sink);
+        return;
+    }
+    if (node.nodeType === 3)
+        checkTextNode(node, inHead, sink);
+}
+function checkElementAttributes(element, inHead, sink) {
+    for (const attribute of Array.from(element.attributes)) {
+        if (PREVIEW_TRANSPORT_ATTRIBUTES.has(attribute.name))
+            continue;
+        if (!hasCodedText(attribute.value))
+            continue;
+        sink(inHead ? 'head' : 'attribute', element, attribute.name, attribute.value);
+    }
+}
+function checkTextNode(node, inHead, sink) {
+    const value = node.textContent;
+    if (!value || !hasCodedText(value))
+        return;
+    const parent = node.parentElement ?? undefined;
+    if (parent?.tagName.toUpperCase() === 'SCRIPT' && isNextFlightPayload(value)) {
+        return;
+    }
+    if (inHead) {
+        sink('head', parent, undefined, value);
+        return;
+    }
+    switch (parent?.tagName.toUpperCase()) {
+        case 'SCRIPT':
+            sink('script', parent, undefined, value);
+            return;
+        case 'STYLE':
+            sink('style', parent, undefined, value);
+            return;
+        case 'TEXTAREA':
+            sink('form-value', parent, undefined, value);
+            return;
+        default:
+        // Ordinary rendered text is the authored carrier, not a leak.
+    }
+}
+function isNextFlightPayload(value) {
+    const source = value.trimStart();
+    return (source.startsWith('self.__next_f.push(') ||
+        source.startsWith('(self.__next_f=self.__next_f||[]).push('));
+}
+function processMutation(doc, mutation, sink) {
+    const target = mutation.target;
+    if (!target.isConnected || isInsideOverlay(target))
+        return;
+    if (mutation.type === 'attributes') {
+        if (!isElement(target) || !mutation.attributeName)
+            return;
+        // `data-ss-model` is the intentional serialized slice carrier. Keep the
+        // mutation path aligned with the initial tree audit: React rewrites this
+        // attribute after every authored field edit, but those codewords have not
+        // reached a customer render sink.
+        if (PREVIEW_TRANSPORT_ATTRIBUTES.has(mutation.attributeName))
+            return;
+        const value = target.getAttributeNS(mutation.attributeNamespace, mutation.attributeName);
+        if (value && hasCodedText(value)) {
+            sink(isInsideHead(doc, target) ? 'head' : 'attribute', target, mutation.attributeName, value);
+        }
+        return;
+    }
+    if (mutation.type === 'characterData') {
+        checkTextNode(target, isInsideHead(doc, target), sink);
+        return;
+    }
+    for (const node of Array.from(mutation.addedNodes)) {
+        if (!node.isConnected || isInsideOverlay(node))
+            continue;
+        auditTree(doc, node, isInsideHead(doc, node), sink);
+    }
+}
+function isElement(node) {
+    return node.nodeType === 1;
+}
+function isOverlayElement(node) {
+    return isElement(node) && node.tagName.toUpperCase() === OVERLAY_ELEMENT;
+}
+function isInsideOverlay(node) {
+    const element = isElement(node) ? node : node.parentElement;
+    return element
+        ? element.closest(OVERLAY_ELEMENT.toLowerCase()) !== null
+        : false;
+}
+function isInsideHead(doc, node) {
+    return doc.head?.contains(node) ?? false;
+}
+function hasCodedText(value) {
+    return decodePreviewProvenanceText(value).segments.length > 0;
+}
+function scheduleIdle(view, callback) {
+    if (typeof view.requestIdleCallback === 'function') {
+        const id = view.requestIdleCallback(callback, { timeout: 1000 });
+        return () => view.cancelIdleCallback(id);
+    }
+    const id = view.setTimeout(callback, 0);
+    return () => view.clearTimeout(id);
+}

package/dist/dev/suspicious-codeword-detector.noop.d.ts

@@ -0,0 +1,3 @@
+import type { SuspiciousPreviewCodewordReport } from './suspicious-codeword-detector.js';
+/** Production target for the detector's conditional package export. */
+export declare function observeSuspiciousPreviewCodewords(_doc: Document, _onReports: (reports: readonly SuspiciousPreviewCodewordReport[]) => void): () => void;

package/dist/dev/suspicious-codeword-detector.noop.js

@@ -0,0 +1,4 @@
+/** Production target for the detector's conditional package export. */
+export function observeSuspiciousPreviewCodewords(_doc, _onReports) {
+    return () => undefined;
+}

package/dist/framework/browser-context.d.ts

@@ -0,0 +1,2 @@
+/** Initial browser gate; no storage writers, transport or authenticated runtime. */
+export { isPreviewBrowserContext } from '../identity/browser-context-gate.js';

package/dist/framework/browser-context.js

@@ -0,0 +1,2 @@
+/** Initial browser gate; no storage writers, transport or authenticated runtime. */
+export { isPreviewBrowserContext } from '../identity/browser-context-gate.js';

package/dist/framework/generation-refresh.d.ts

@@ -0,0 +1,23 @@
+import type { PreviewProjectionGenerationSignal } from './generation-signal.js';
+/** One view's server refresh cadence. No mounted-query registry is required. */
+export declare function createPreviewGenerationRefresh<TTimer>(options: {
+    readonly refresh: () => void;
+    readonly delayMs: number;
+    readonly setTimer: (callback: () => void, ms: number) => TTimer;
+    readonly clearTimer: (timer: TTimer) => void;
+    /** Sampled before this server render's content reads, within its context. */
+    readonly initialCheckpoint?: PreviewProjectionGenerationSignal | null;
+}): {
+    /** Only the adapter's accepted, installed render can cover this checkpoint.
+     * A later observed write remains pending; a router event alone is no proof. */
+    observeRenderedCheckpoint(signal: PreviewProjectionGenerationSignal | null | undefined): void;
+    observe(signal: PreviewProjectionGenerationSignal | null): void;
+    /** Recheck after a refresh was deferred behind a native navigation. */
+    dispatch(run: () => void): void;
+    /** The global framework adapter owns the transition, not customer components. */
+    observeTransition(pending: boolean): void;
+    /** Reconnect/context activation may have missed a checkpoint already observed. */
+    resynchronize(): void;
+    dispose(): void;
+};
+export type PreviewGenerationRefresh = ReturnType<typeof createPreviewGenerationRefresh>;

package/dist/framework/generation-refresh.js

@@ -0,0 +1,82 @@
+/** One view's server refresh cadence. No mounted-query registry is required. */
+export function createPreviewGenerationRefresh(options) {
+    let latest = null;
+    let requested = null;
+    let timer = null;
+    let busy = false;
+    let disposed = false;
+    const identity = (signal) => JSON.stringify([signal.generation, signal.projectedThroughSeq, signal.projectionHash, signal.lensHash]);
+    const ready = () => latest?.status === 'ready' &&
+        Number.isSafeInteger(latest.projectedThroughSeq) &&
+        latest.projectedThroughSeq >= 0;
+    const covers = (signal) => signal?.status === 'ready' && Number.isSafeInteger(signal.generation) && signal.generation >= 0 &&
+        Number.isSafeInteger(signal.projectedThroughSeq) && signal.projectedThroughSeq >= 0 &&
+        typeof signal.projectionHash === 'string' && signal.projectionHash.length > 0 &&
+        typeof signal.lensHash === 'string' && signal.lensHash.length > 0;
+    const initial = options.initialCheckpoint;
+    if (covers(initial))
+        requested = identity(initial);
+    function schedule() {
+        if (disposed || busy || timer !== null || !ready() || identity(latest) === requested)
+            return;
+        // First event owns the deadline. Later events replace the pending checkpoint,
+        // rather than postponing refresh indefinitely during concurrent editing.
+        timer = options.setTimer(() => {
+            timer = null;
+            if (disposed || busy || !ready() || identity(latest) === requested)
+                return;
+            requested = identity(latest);
+            busy = true;
+            options.refresh();
+        }, options.delayMs);
+    }
+    return {
+        /** Only the adapter's accepted, installed render can cover this checkpoint.
+         * A later observed write remains pending; a router event alone is no proof. */
+        observeRenderedCheckpoint(signal) {
+            if (!disposed && covers(signal))
+                requested = identity(signal);
+        },
+        observe(signal) {
+            if (disposed)
+                return;
+            latest = signal;
+            schedule();
+        },
+        /** Recheck after a refresh was deferred behind a native navigation. */
+        dispatch(run) {
+            if (disposed)
+                return;
+            if (!ready()) {
+                busy = false;
+                requested = null;
+                schedule();
+                return;
+            }
+            requested = identity(latest);
+            run();
+        },
+        /** The global framework adapter owns the transition, not customer components. */
+        observeTransition(pending) {
+            if (disposed)
+                return;
+            busy = pending;
+            if (!pending)
+                schedule();
+        },
+        /** Reconnect/context activation may have missed a checkpoint already observed. */
+        resynchronize() {
+            if (disposed)
+                return;
+            requested = null;
+            schedule();
+        },
+        dispose() {
+            disposed = true;
+            if (timer !== null)
+                options.clearTimer(timer);
+            timer = null;
+            latest = null;
+        },
+    };
+}

package/dist/framework/generation-signal.d.ts

@@ -0,0 +1,8 @@
+export interface PreviewProjectionGenerationSignal {
+    readonly generation: number;
+    readonly status: "ready" | "stale" | "rebuilding" | "error";
+    readonly projectedThroughSeq?: number;
+    readonly projectionHash?: string;
+    readonly lensHash?: string;
+}
+export declare function isPreviewProjectionGenerationSignal(value: unknown): value is PreviewProjectionGenerationSignal;

package/dist/framework/generation-signal.js

@@ -0,0 +1,17 @@
+export function isPreviewProjectionGenerationSignal(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const input = value;
+    return (Number.isSafeInteger(input.generation) &&
+        input.generation >= 0 &&
+        (input.status === "ready" ||
+            input.status === "stale" ||
+            input.status === "rebuilding" ||
+            input.status === "error") &&
+        (input.projectedThroughSeq === undefined ||
+            (Number.isSafeInteger(input.projectedThroughSeq) &&
+                input.projectedThroughSeq >= 0)) &&
+        (input.projectionHash === undefined ||
+            typeof input.projectionHash === "string") &&
+        (input.lensHash === undefined || typeof input.lensHash === "string"));
+}

package/dist/framework/projection-generation-watch.d.ts

@@ -0,0 +1,5 @@
+export interface PreviewProjectionGenerationWatch {
+    subscribe(listener: (value: unknown) => void, reconnected?: () => void): () => void;
+}
+/** Adapt Convex's watch shape without coupling the refresh policy to Convex. */
+export declare function createPreviewProjectionGenerationWatch(client: unknown, sessionId: string): PreviewProjectionGenerationWatch | null;

package/dist/framework/projection-generation-watch.js

@@ -0,0 +1,53 @@
+/** Adapt Convex's watch shape without coupling the refresh policy to Convex. */
+export function createPreviewProjectionGenerationWatch(client, sessionId) {
+    const watchQuery = client.watchQuery;
+    if (typeof watchQuery !== "function")
+        return null;
+    const watch = watchQuery.call(client, "sdkQueries:viewGeneration", {
+        sessionId,
+    });
+    if (!watch ||
+        typeof watch.onUpdate !== "function" ||
+        typeof watch.localQueryResult !== "function") {
+        return null;
+    }
+    return {
+        subscribe(listener, reconnected) {
+            let disconnected = false;
+            const publish = () => {
+                if (disconnected) {
+                    listener(null);
+                    return;
+                }
+                try {
+                    listener(watch.localQueryResult());
+                }
+                catch {
+                    // Failed/absent watch results cannot authorize a queued refresh.
+                    listener(null);
+                }
+            };
+            const connection = client;
+            disconnected = connection.connectionState?.().isWebSocketConnected === false;
+            const cleanupConnection = connection.subscribeToConnectionState?.((state) => {
+                if (!state.isWebSocketConnected) {
+                    disconnected = true;
+                    listener(null);
+                    return;
+                }
+                if (disconnected) {
+                    disconnected = false;
+                    reconnected?.();
+                    publish();
+                }
+            });
+            const cleanup = watch.onUpdate(publish);
+            publish();
+            return () => {
+                if (typeof cleanup === "function")
+                    cleanup();
+                cleanupConnection?.();
+            };
+        },
+    };
+}

package/dist/framework/render-receipt.d.ts

@@ -0,0 +1,8 @@
+import type { PreviewServerRenderReceipt } from '@storystick/preview/router-subscriber';
+import type { PreviewProjectionGenerationSignal } from './generation-signal.js';
+/** Framework-local proof; projection metadata never crosses the Studio envelope. */
+export interface PreviewFrameworkRenderReceipt extends PreviewServerRenderReceipt {
+    readonly projectionCheckpoint?: PreviewProjectionGenerationSignal;
+}
+export declare function readPreviewRenderReceipt(): PreviewServerRenderReceipt | null;
+export declare function commitPreviewRenderReceipt(receipt: PreviewServerRenderReceipt): () => void;

package/dist/framework/render-receipt.js

@@ -0,0 +1,10 @@
+// One framework render in this realm, not another preview context authority.
+// Receipt identity changes on each server request, even within one perspective.
+let current = null;
+export function readPreviewRenderReceipt() { return current; }
+export function commitPreviewRenderReceipt(receipt) {
+    const presentation = { readContext: receipt.readContext, renderId: receipt.renderId };
+    current = presentation;
+    return () => { if (current === presentation)
+        current = null; };
+}

package/dist/framework/runtime-adapter-store.d.ts

@@ -0,0 +1,30 @@
+import type { PreviewRuntime, PreviewRuntimeState } from "@storystick/preview/runtime/store";
+/** The only runtime fields that can change this React adapter's output. */
+export interface PreviewRuntimeAdapterSnapshot {
+    readonly state: PreviewRuntimeState["state"];
+    readonly client: PreviewRuntimeState["client"];
+    readonly previewToken: string | null;
+    readonly sessionId: string | null;
+    readonly variantId: string | null;
+    readonly releaseId: string | null;
+    readonly readContextStatus: "active" | "ended" | null;
+    readonly readContext: import('@storystick/types/preview-query-targeting').PreviewReadContext | null;
+    readonly renderedReadContext: PreviewRuntimeState['renderedReadContext'];
+    readonly readContextNotice: 'release-published' | 'release-archived' | null;
+    readonly standaloneStudioUrl: string | null;
+    readonly errorCode: string | null;
+}
+export declare const PREVIEW_RUNTIME_SERVER_SNAPSHOT: PreviewRuntimeAdapterSnapshot;
+/**
+ * Adapts the process-wide Preview runtime to a referentially stable React
+ * snapshot. The underlying store can keep publishing protocol telemetry and
+ * content revisions without rerendering the customer adapter when none of its
+ * consumed fields changed.
+ */
+export declare function createPreviewRuntimeAdapterStore(runtime: Pick<PreviewRuntime, "getState" | "subscribe">): {
+    readonly subscribe: PreviewRuntime["subscribe"];
+    readonly getSnapshot: () => PreviewRuntimeAdapterSnapshot;
+};
+/** Content invalidations belong to the context actually rendered in this realm.
+ * Studio alone commands a different context into an embedded presentation. */
+export declare function canRefreshPresentedPreviewContext(state: Pick<PreviewRuntimeAdapterSnapshot, 'readContext' | 'renderedReadContext'>, embedded: boolean): boolean;

package/dist/framework/runtime-adapter-store.js

@@ -0,0 +1,81 @@
+export const PREVIEW_RUNTIME_SERVER_SNAPSHOT = Object.freeze({
+    state: "idle",
+    client: null,
+    previewToken: null,
+    sessionId: null,
+    variantId: null,
+    releaseId: null,
+    readContext: null,
+    renderedReadContext: null,
+    readContextNotice: null,
+    readContextStatus: null,
+    standaloneStudioUrl: null,
+    errorCode: null,
+});
+function selectPreviewRuntimeAdapterSnapshot(state) {
+    return {
+        state: state.state,
+        client: state.client,
+        previewToken: state.previewToken,
+        sessionId: state.sessionId,
+        variantId: state.variantId,
+        releaseId: state.releaseId,
+        readContext: state.session?.readContext ?? null,
+        renderedReadContext: state.renderedReadContext ?? null,
+        readContextNotice: state.session?.readContextNotice ?? null,
+        readContextStatus: state.session?.readContextStatus ?? null,
+        standaloneStudioUrl: state.session?.standaloneStudioUrl ?? null,
+        errorCode: state.error?.code ?? null,
+    };
+}
+function previewRuntimeAdapterSnapshotsEqual(left, right) {
+    return (left.state === right.state &&
+        left.client === right.client &&
+        left.previewToken === right.previewToken &&
+        left.sessionId === right.sessionId &&
+        left.variantId === right.variantId &&
+        left.releaseId === right.releaseId &&
+        left.readContextStatus === right.readContextStatus &&
+        left.readContext?.contextId === right.readContext?.contextId &&
+        left.readContext?.revision === right.readContext?.revision &&
+        left.renderedReadContext?.contextId === right.renderedReadContext?.contextId &&
+        left.renderedReadContext?.revision === right.renderedReadContext?.revision &&
+        left.readContextNotice === right.readContextNotice &&
+        left.standaloneStudioUrl === right.standaloneStudioUrl &&
+        left.errorCode === right.errorCode);
+}
+/**
+ * Adapts the process-wide Preview runtime to a referentially stable React
+ * snapshot. The underlying store can keep publishing protocol telemetry and
+ * content revisions without rerendering the customer adapter when none of its
+ * consumed fields changed.
+ */
+export function createPreviewRuntimeAdapterStore(runtime) {
+    let lastSnapshot = null;
+    return {
+        subscribe: (listener) => runtime.subscribe(listener),
+        getSnapshot: () => {
+            let nextSnapshot = selectPreviewRuntimeAdapterSnapshot(runtime.getState());
+            // Retain only public return metadata through reconnection of the same
+            // view. A new view, deactivation or a fresh owner starts without it.
+            if (nextSnapshot.sessionId !== null && nextSnapshot.sessionId === lastSnapshot?.sessionId && !nextSnapshot.standaloneStudioUrl) {
+                nextSnapshot = { ...nextSnapshot, standaloneStudioUrl: lastSnapshot.standaloneStudioUrl };
+            }
+            if (lastSnapshot !== null &&
+                previewRuntimeAdapterSnapshotsEqual(lastSnapshot, nextSnapshot)) {
+                return lastSnapshot;
+            }
+            lastSnapshot = nextSnapshot;
+            return nextSnapshot;
+        },
+    };
+}
+/** Content invalidations belong to the context actually rendered in this realm.
+ * Studio alone commands a different context into an embedded presentation. */
+export function canRefreshPresentedPreviewContext(state, embedded) {
+    if (!embedded)
+        return true;
+    const { readContext: accepted, renderedReadContext: rendered } = state;
+    return accepted != null && rendered != null &&
+        accepted.contextId === rendered.contextId && accepted.revision === rendered.revision;
+}

package/dist/grant-coordinator.d.ts

@@ -0,0 +1,53 @@
+import { type PreviewGrantFailureCause, type PreviewGrantLifecycle } from "./grant-lifecycle.js";
+export declare const PREVIEW_TOKEN_ROUTE = "/api/storystick/preview/token";
+export declare const PREVIEW_GRANT_RETRY_BACKOFF_MS: readonly [1000, 2000, 5000, 10000, 30000];
+export interface PreviewBrowserGrant {
+    token: string;
+    expiresAt: number;
+    refreshAfter: number;
+    sessionId: string;
+    projectId: string;
+}
+export declare class PreviewGrantRequestError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs: number | null;
+    constructor(args: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        retryAfterMs?: number | null;
+    });
+}
+type FetchLike = typeof fetch;
+export declare function acquirePreviewBrowserGrant(args: {
+    sessionId: string;
+    projectId: string;
+    tokenRoute?: string;
+    signal: AbortSignal;
+    fetchFn?: FetchLike;
+}): Promise<PreviewBrowserGrant>;
+export interface PreviewGrantCoordinator {
+    start(): void;
+    stop(): void;
+    markReady(): void;
+    reportTransientFailure(cause: PreviewGrantFailureCause): void;
+    reportBlocked(code: string, message: string): void;
+    retryNow(): void;
+    getLifecycle(): PreviewGrantLifecycle;
+}
+export declare function createPreviewGrantCoordinator(args: {
+    sessionId: string;
+    projectId: string;
+    tokenRoute?: string;
+    generation: number;
+    acquire?: typeof acquirePreviewBrowserGrant;
+    onGrant: (grant: PreviewBrowserGrant) => void;
+    onLifecycle: (lifecycle: PreviewGrantLifecycle) => void;
+    now?: () => number;
+    random?: () => number;
+    setTimeoutFn?: typeof setTimeout;
+    clearTimeoutFn?: typeof clearTimeout;
+    windowRef?: Window;
+}): PreviewGrantCoordinator;
+export {};