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

package/dist/runtime/standalone-overlay-controller.js

@@ -0,0 +1,281 @@
+import { createPreviewRequestId } from './request-id.js';
+import { expectPreviewOverlayFocusEcho, consumePreviewOverlayFocusEcho, } from '../provenance/overlay-focus-echo.js';
+import { createPreviewV2SourceRegistry, } from '../provenance/source-registry.js';
+import { previewPaintRenderIdentityFromAnchorMap } from '../provenance/index.js';
+import { setInteractionMode } from '../interaction-mode.js';
+import { PREVIEW_PROVENANCE_ANCHOR_MAP_EVENT, findPreviewOverlayClickTarget, hasCompleteDirectLocatorCoverage, projectPreviewProvenanceOverlays, resolveDirectProvenanceOwnerMap, resolvePreviewOverlayClickItem, } from '../provenance/index.js';
+import { applyPreviewOverlayMap, clearPreviewOverlayPaint, revealPreviewV2SourceInIframe, } from './preview-overlay-painter.js';
+const STATE_KEY = Symbol.for('storystick.preview.standalone-overlays.v1');
+const serverState = createState();
+function createState() {
+    return {
+        mode: 'edit',
+        suspended: false,
+        focusEcho: null,
+        anchorMap: null,
+        ownerMap: null,
+        activePaint: null,
+        projection: null,
+        snapshot: { mode: 'edit', available: false, generation: null, rejections: [] },
+        subscribers: new Set(),
+        intentListeners: new Set(),
+        repaint: null,
+    };
+}
+function stateFor(win) {
+    const target = win ?? (typeof window === 'undefined' ? null : window);
+    if (target === null)
+        return serverState;
+    const existing = Reflect.get(target, STATE_KEY);
+    if (existing !== undefined)
+        return existing;
+    const state = createState();
+    Reflect.set(target, STATE_KEY, state);
+    return state;
+}
+export function readStandaloneOverlaySnapshot(win) {
+    return stateFor(win).snapshot;
+}
+export function subscribeStandaloneOverlaySnapshot(listener, win) {
+    const state = stateFor(win);
+    state.subscribers.add(listener);
+    return () => state.subscribers.delete(listener);
+}
+export function subscribeStandaloneOverlayIntent(listener, win) {
+    const state = stateFor(win);
+    state.intentListeners.add(listener);
+    return () => state.intentListeners.delete(listener);
+}
+export function setStandaloneOverlayMode(mode, win) {
+    const state = stateFor(win);
+    state.mode = mode;
+    setInteractionMode(mode);
+    publishSnapshot(state);
+    state.repaint?.();
+}
+/** Paint and route the same validated projection used by Studio. The active
+ * projection is re-read on every click; a stale generation cannot become an
+ * edit intent. */
+export function startStandaloneOverlayController(args) {
+    const win = args.win ?? window;
+    const state = stateFor(win);
+    const repaint = () => {
+        const projection = state.projection;
+        if (state.mode !== 'edit' ||
+            state.suspended ||
+            projection === null ||
+            projection.payload.items.length === 0) {
+            clearPreviewOverlayPaint();
+            return;
+        }
+        const payload = {
+            ...projection.payload,
+            display: 'hover',
+        };
+        applyPreviewOverlayMap(payload, win, {
+            onClick: (click) => emitIntent(state, click),
+        });
+    };
+    state.repaint = repaint;
+    const apply = (value) => {
+        const anchorMap = readAnchorMap(value, args.sessionId);
+        state.anchorMap = anchorMap;
+        const ownerMap = anchorMap ? resolveDirectProvenanceOwnerMap({ anchorMap }) : null;
+        state.ownerMap = ownerMap;
+        if (anchorMap === null || !hasCompleteDirectLocatorCoverage(anchorMap)) {
+            state.projection = null;
+            publishSnapshot(state);
+            repaint();
+            return;
+        }
+        state.projection = projectPreviewProvenanceOverlays({
+            generation: anchorMap.generation,
+            anchorMap,
+            ownerMap,
+            display: 'hover',
+        });
+        publishSnapshot(state);
+        repaint();
+    };
+    const onAnchorMap = (event) => {
+        apply(event instanceof CustomEvent ? event.detail : null);
+    };
+    win.addEventListener(PREVIEW_PROVENANCE_ANCHOR_MAP_EVENT, onAnchorMap);
+    setInteractionMode(state.mode);
+    apply(win.__ssMultiFrameAnchorMaps);
+    return () => {
+        win.removeEventListener(PREVIEW_PROVENANCE_ANCHOR_MAP_EVENT, onAnchorMap);
+        if (state.repaint === repaint)
+            state.repaint = null;
+        state.projection = null;
+        state.anchorMap = null;
+        state.ownerMap = null;
+        state.activePaint = null;
+        state.focusEcho = null;
+        // Mode/suspension belong to the host control, not this paint subscription.
+        // Restarting provenance must preserve the user's choice.
+        setInteractionMode('browse');
+        publishSnapshot(state);
+        clearPreviewOverlayPaint();
+    };
+}
+function emitIntent(state, click) {
+    if (state.suspended)
+        return;
+    const target = resolveStandaloneOverlayIntent({
+        mode: state.mode,
+        projection: state.projection,
+        click,
+    });
+    if (target === null)
+        return;
+    const renderIdentity = state.anchorMap && previewPaintRenderIdentityFromAnchorMap(state.anchorMap);
+    if (renderIdentity && target.sourceSetId && target.markerId) {
+        state.activePaint = {
+            documentId: target.documentId,
+            sourceSetId: target.sourceSetId,
+            markerId: target.markerId,
+            paintId: state.projection?.payload.items.find((item) => item.paintKey === click.paintKey)?.renderTargetId ?? '',
+            renderIdentity,
+        };
+        state.focusEcho = expectPreviewOverlayFocusEcho(state.activePaint);
+    }
+    for (const listener of [...state.intentListeners])
+        listener(target);
+}
+/** The click identity and its owner are resolved from one current projection.
+ * A host never receives an intent from stale paint or browse mode. */
+export function resolveStandaloneOverlayIntent(args) {
+    const { projection, click } = args;
+    if (args.mode !== 'edit' ||
+        projection === null ||
+        click.routeHash !== projection.payload.routeHash ||
+        click.codeVersion !== projection.payload.codeVersion ||
+        click.renderId !== projection.payload.renderId)
+        return null;
+    const item = resolvePreviewOverlayClickItem({
+        activeGeneration: projection.payload.generation,
+        itemsByPaintKey: new Map(projection.payload.items.map((candidate) => [
+            candidate.paintKey,
+            candidate,
+        ])),
+        payload: click,
+    });
+    if (item === null)
+        return null;
+    const target = findPreviewOverlayClickTarget(projection.clickTargets, item);
+    return target;
+}
+function publishSnapshot(state) {
+    const next = {
+        mode: state.mode,
+        available: state.projection !== null && state.projection.payload.items.length > 0,
+        generation: state.projection?.payload.generation ?? null,
+        rejections: state.ownerMap?.rejections ?? [],
+    };
+    if (next.mode === state.snapshot.mode &&
+        next.available === state.snapshot.available &&
+        next.generation === state.snapshot.generation &&
+        next.rejections.length === state.snapshot.rejections.length &&
+        next.rejections.every((rejection, index) => {
+            const previous = state.snapshot.rejections[index];
+            return rejection.reason === previous.reason &&
+                rejection.frameId === previous.frameId && rejection.markerId === previous.markerId;
+        }))
+        return;
+    state.snapshot = next;
+    for (const listener of [...state.subscribers])
+        listener();
+}
+function readAnchorMap(value, expectedSessionId) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const candidate = value;
+    if (candidate.sessionId !== expectedSessionId ||
+        !Number.isFinite(candidate.generation) ||
+        (candidate.generation ?? 0) <= 0 ||
+        candidate.pending !== false ||
+        candidate.valid !== true ||
+        typeof candidate.routeHash !== 'string' ||
+        candidate.routeHash.length === 0 ||
+        typeof candidate.codeVersion !== 'string' ||
+        candidate.codeVersion.length === 0 ||
+        !Array.isArray(candidate.maps)) {
+        return null;
+    }
+    const routeFrames = candidate.maps.filter((frame) => frame?.frameId === 'route');
+    if (routeFrames.length !== 1)
+        return null;
+    return candidate;
+}
+/** The same provenance resolver and painter as Studio, transported locally. */
+export function revealStandaloneSource(request, win = window) {
+    const state = stateFor(win);
+    if (state.mode !== 'edit' || state.suspended)
+        return false;
+    const registry = standaloneRegistry(state, win);
+    const resolution = registry.resolveRevealPayloadForStudioTarget({
+        request,
+        requestId: createPreviewRequestId(win.crypto),
+        behavior: {
+            scroll: request.behavior?.scroll ?? true,
+            flash: request.behavior?.flash ?? true,
+            durationMs: request.behavior?.durationMs ?? 900,
+        },
+    });
+    if (!resolution.ok)
+        return false;
+    if (resolution.selection.kind === 'active-paint' && state.activePaint) {
+        const echo = consumePreviewOverlayFocusEcho(state.focusEcho, resolution.selection.paintId, state.activePaint.renderIdentity);
+        state.focusEcho = echo.pending;
+        if (echo.consumed)
+            return true;
+    }
+    const result = revealPreviewV2SourceInIframe(resolution.payload, win);
+    return result.status === 'found' || result.status === 'multiple';
+}
+export function revealStandaloneSlice(request, win = window) {
+    const state = stateFor(win);
+    if (state.mode !== 'edit' || state.suspended)
+        return false;
+    const resolution = standaloneRegistry(state, win).resolveRevealPayloadForStudioSlice({
+        request,
+        requestId: createPreviewRequestId(win.crypto),
+        behavior: {
+            scroll: request.behavior?.scroll ?? true,
+            flash: request.behavior?.flash ?? true,
+            durationMs: request.behavior?.durationMs ?? 900,
+        },
+    });
+    if (!resolution.ok)
+        return false;
+    const result = revealPreviewV2SourceInIframe(resolution.payload, win);
+    return result.status === 'found' || result.status === 'multiple';
+}
+function standaloneRegistry(state, win) {
+    const anchorMap = !state.suspended && state.projection ? state.anchorMap : null;
+    return createPreviewV2SourceRegistry({
+        sessionId: anchorMap?.sessionId ?? null,
+        anchorMap,
+        ownerMap: anchorMap ? state.ownerMap : null,
+        sourceMapBytes: null,
+        currentViewport: () => ({
+            x: win.scrollX,
+            y: win.scrollY,
+            width: win.innerWidth,
+            height: win.innerHeight,
+        }),
+        activePaintFor: (documentId, sourceSetId) => state.activePaint?.documentId === documentId &&
+            state.activePaint.sourceSetId === sourceSetId
+            ? state.activePaint
+            : null,
+    });
+}
+/** Admission/render transitions suspend interaction without changing the user's mode. */
+export function setStandaloneOverlaySuspended(suspended, win) {
+    const state = stateFor(win);
+    if (state.suspended === suspended)
+        return;
+    state.suspended = suspended;
+    state.repaint?.();
+}

package/dist/runtime/store.d.ts

@@ -0,0 +1,307 @@
+import { type PreviewPerspectiveCommand } from '../context-command.js';
+import { type PreviewReadContext } from '@storystick/types/preview-query-targeting';
+import type { PreviewLifecyclePayload } from '@storystick/transport-allowlist';
+/**
+ * `previewRuntime` — module-level singleton (ADR-099 D11 + ADR-116).
+ *
+ * Five concerns the Provider used to handle, ported to imperative
+ * methods on this singleton (D11.1) :
+ *
+ *  1. Convergent grant lifecycle with a compatibility projection for
+ *     framework adapters that still consume the historical state field.
+ *
+ *  2. `httpClient` (ConvexReactClient) lifecycle. Built on first JWT
+ *     arrival ; disposed via `dispose()`. HMR resets on module reload.
+ *
+ *  3. In-place Convex auth fetcher fed only by the same-origin grant route.
+ *
+ *  4. Session subscription gated on token presence (NOT
+ *     lifecycle state). Survives the `authenticated → refreshing →
+ *     authenticated` cycle. (Provider's codex Lane D round 10 P1.)
+ *
+ *  5. `contentRevision` driver. Listeners observe forward jumps and
+ *     fire `router.refresh()` (the `<Storystick />` Client Component
+ *     holds the `useRouter()` reference ; the singleton stays
+ *     framework-agnostic).
+ *
+ * ADR-116 (PR4) — the identity resolver replaces `defaultDetectPreview`.
+ * Boot path :
+ *
+ *   init(opts)
+ *     → compare-and-set (D5 invariant 1 — set inFlightInitPromise
+ *        BEFORE notify so a synchronous-reentrant init() observes the
+ *        slot populated)
+ *     → resolver.start() resolves the identity via carrier chain
+ *        (broadcast > storage > URL — ADR-116 D3)
+ *     → on first identity (provisional or live), start the same-origin grant
+ *        coordinator and secret-free control plane for that sessionId
+ *
+ * Full runtime cell persists on `globalThis.__storystick_preview_runtime__`
+ * (D5 invariant 2 — codex R6 #3). Persisting only `state` is INSUFFICIENT :
+ * Next Fast Refresh re-evaluates the module body but does NOT remount
+ * every `useSyncExternalStore` consumer ; old consumers stay subscribed
+ * to the OLD module's `listeners` Set. The full cell (state + listeners +
+ * revisionListeners + inFlightInitPromise + cleanups + identity resolver
+ * handles) on `globalThis` keeps emissions and subscriptions aligned
+ * across HMR.
+ *
+ * Per CSO-PREVIEW-11 — per-tab in-memory only. Module-level `let` state
+ * (and the `globalThis` cell) ; no SharedWorker / ServiceWorker /
+ * BroadcastChannel / localStorage. The new sessionStorage carrier (PR2)
+ * is tier-2 identity persistence within the iframe origin partition —
+ * distinct from cross-tab/process IPC.
+ */
+import { ConvexReactClient } from "convex/react";
+import type { Client } from "@storystick/client";
+import { type PreviewGrantCoordinator } from "../grant-coordinator.js";
+import { type LegacyPreviewAuthState, type PreviewGrantLifecycle } from "../grant-lifecycle.js";
+import { type PreviewSessionData } from "../session-subscriber.js";
+import { type IdentityResolver, type PreviewIdentity } from "../identity/index.js";
+import { type PreviewContentRefreshEvent } from "./content-refresh.js";
+export interface PreviewRuntimeState {
+    /** Current state machine value (ADR-087 §3.4). */
+    state: LegacyPreviewAuthState;
+    /** Explicitly ended in this browsing context; old URL carriers cannot revive it. */
+    previewEnded?: boolean;
+    /** Canonical connectivity state. `state` above is a compatibility projection. */
+    lifecycle: PreviewGrantLifecycle | null;
+    /**
+     * Reactive Convex client. `null` until the token route delivers a
+     * JWT (preview mode) OR forever (non-preview mode). The
+     * `<StorystickQueryProvider>` consumes this via `reactiveClient()`.
+     */
+    client: ConvexReactClient | null;
+    /**
+     * Latest preview JWT. Read by the in-place setAuth fetcher when
+     * Convex calls `setAuth({forceRefreshToken: true})`. Updated on each
+     * refresh cycle.
+     */
+    previewToken: string | null;
+    /**
+     * HttpOnly preview-cookie lifecycle observed by the Next adapter.
+     * C3 consumes this plain data; token material never enters the shape.
+     */
+    cookieLifecycle: PreviewCookieLifecycleState | null;
+    /**
+     * Set on terminal error (state === 'error'). Surfaces a typed
+     * payload to consumers (`<Storystick />` renders the self-contained
+     * error UI ; `<StorystickQueryProvider>` propagates to in-flight
+     * subscribers per ADR-099 §5.6).
+     */
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    /**
+     * Live-preview content revision (ADR-096). Monotonic counter from
+     * the row sub. `null` until the first emission.
+     */
+    contentRevision: number | null;
+    /**
+     * Session id derived from the identity resolver (broadcast > storage
+     * > URL). `null` outside preview. Tracks `identity.sessionId` 1-1 ;
+     * Replace transitions update it atomically.
+     */
+    sessionId: string | null;
+    /** Latest session payload (full row from `getPreviewSession`). */
+    session: PreviewSessionData | null;
+    contextCommand?: PreviewLifecyclePayload['contextCommand'];
+    /** Accepted perspective actually rendered by every mounted occurrence. */
+    renderedReadContext?: PreviewReadContext | null;
+    /**
+     * Perspective projected from the authenticated shared read context.
+     * View URLs and navigation hints never write this authority.
+     */
+    variantId: string | null;
+    /** Explicit release read scope for this view. */
+    releaseId: string | null;
+    /**
+     * ADR-116 — full resolved identity (sessionId, projectId,
+     * parentOrigin, source, epoch). Consumers (PR5 — preview-nav,
+     * preview-mode-latch replacements) read identity directly instead of
+     * re-deriving from URL. `null` outside preview.
+     */
+    identity: PreviewIdentity | null;
+    /**
+     * ADR-131 Amendment 002 §5.1 — Pattern D HTTP client used by iframe
+     * runtime modules that need to call the gateway directly (e.g. the
+     * schema-store fetches `/api/q/schemas/current` through here).
+     *
+     * Set by `<StorystickQueryProvider>` in preview mode once the token
+     * arrives ; reset to `null` on provider unmount. `null` outside
+     * preview AND before the provider has built the configured client
+     * (the token may arrive after provider mount).
+     *
+     * Independent of the state machine — `setHttpClient` is a
+     * field-only updater that bypasses the sticky-error gate so cleanup
+     * (provider unmount) always runs even in terminal `'error'` state.
+     */
+    httpClient: Client | null;
+}
+export interface PreviewCookieLifecycleState {
+    mintedAt: number;
+    expiresAt: number;
+    lastRefreshOutcome: {
+        status: "success";
+        at: number;
+    } | {
+        status: "failure";
+        at: number;
+        code: string;
+    } | null;
+}
+export type PreviewCookieLifecycleEvent = {
+    type: "minted";
+    mintedAt: number;
+    expiresAt: number;
+} | {
+    type: "refresh-succeeded";
+    mintedAt: number;
+    expiresAt: number;
+} | {
+    type: "refresh-failed";
+    at: number;
+    code: string;
+};
+export interface InitOpts {
+    projectId: string;
+    /**
+     * Sub-gateway WebSocket origin. The Convex SDK derives the matching
+     * `ws://` / `wss://` and appends `/api/<sdk-version>/sync`.
+     */
+    gatewaySyncUrl: string;
+    /** Same-origin PreviewGrant access route, including any framework basePath. */
+    tokenRoute?: string;
+}
+interface PreviewRuntimeCell {
+    state: PreviewRuntimeState;
+    listeners: Set<() => void>;
+    revisionListeners: Set<(rev: number) => void>;
+    contentRefreshListeners: Set<(event: PreviewContentRefreshEvent) => void>;
+    identityListeners: Set<(identity: PreviewIdentity | null) => void>;
+    inFlightInitPromise: Promise<void> | null;
+    cleanupActivate: (() => void) | null;
+    grantCoordinator: PreviewGrantCoordinator | null;
+    grantGeneration: number;
+    sessionSnapshotReady: boolean;
+    signalSnapshotReady: boolean;
+    cleanupSubscription: (() => void) | null;
+    cleanupRenderObservation?: () => void;
+    subscriptionSessionId: string | null;
+    cleanupResolver: (() => void) | null;
+    lastObservedRevision: number | null;
+    lastQueryTargetingFingerprint: string | null;
+    pendingRevisionNotification: number | null;
+    pendingContentRefreshEvent: PreviewContentRefreshEvent | null;
+    /**
+     * Sticky-error Layer (a) — synchronous flag flipped the moment a
+     * literal `'error'` transition is requested. A racing thread that
+     * fires `_setState(...)` next already sees terminal=true.
+     */
+    terminal: boolean;
+    resolver: IdentityResolver | null;
+    /**
+     * Last identity passed through to `activate()`. Used to detect
+     * Replace transitions (different sessionId → re-handshake).
+     */
+    authedSessionId: string | null;
+}
+declare global {
+    var __storystick_preview_runtime__: PreviewRuntimeCell | undefined;
+}
+export interface PreviewRuntime {
+    /**
+     * Idempotent. Safe to call from React StrictMode double-mount.
+     * Returns a Promise that resolves when the boot path settles — i.e.
+     * the state machine transitions to `'authenticated'` or `'error'`.
+     * **Never rejects** (ADR-116 D5 + codex R6 #6) — failures surface as
+     * `state === 'error'`.
+     */
+    init(opts: InitOpts): Promise<void>;
+    /**
+     * Tear down the runtime. Closes the ConvexReactClient, unsubscribes
+     * the session sub, drops listeners. Called from `<Storystick />`
+     * cleanup. HMR triggers this implicitly via module reload.
+     */
+    dispose(): void;
+    /** After the adapter has cleared the authorized cookie, preserve native subscribers while stopping Preview. */
+    deactivate(): void;
+    /** Announce a confirmed shared-context exit before the adapter tears this view down. */
+    confirmContextEnded(context: PreviewReadContext): boolean;
+    /** Keep an ended view terminal when its local cookie could not be cleared. */
+    reportContextExitUnavailable(context: PreviewReadContext): boolean;
+    /** Revalidate the current cookie after another view changes the browser context. */
+    refreshGrant(): void;
+    /** Snapshot read for `useSyncExternalStore.getSnapshot`. */
+    getState(): PreviewRuntimeState;
+    getLifecycleSnapshot(): PreviewLifecyclePayload | null;
+    /** Subscribe for `useSyncExternalStore.subscribe`. */
+    subscribe(listener: () => void): () => void;
+    /** For `<StorystickQueryProvider>` : read the reactive Convex client. */
+    reactiveClient(): ConvexReactClient | null;
+    /**
+     * Subscribe to `contentRevision` forward jumps. The listener fires
+     * exactly once per forward jump (ADR-096) ; equal/older revisions
+     * are ignored.
+     */
+    subscribeContentRevision(cb: (n: number) => void): () => void;
+    /**
+     * Subscribe to typed content-refresh events. This is the canonical
+     * customer-router refresh contract: the signal originates from the
+     * preview-session `contentRevision` subscription, not from
+     * Studio→iframe postMessage.
+     */
+    subscribeContentRefresh(cb: (event: PreviewContentRefreshEvent) => void): () => void;
+    /**
+     * ADR-116 PR5 — subscribe to identity changes. Fires on every
+     * Confirm / Promote / Replace transition. Consumers (PR5 —
+     * preservePreviewSession, customer adapter URL composer) read
+     * identity here instead of re-deriving from window.location.
+     */
+    subscribeIdentity(cb: (identity: PreviewIdentity | null) => void): () => void;
+    /** Read the current resolved identity. `null` outside preview. */
+    getIdentity(): PreviewIdentity | null;
+    /** Read the effective variant scope. `null` means living document. */
+    getVariantId(): string | null;
+    /** Execute a user gesture against the context actually addressed by the cookie. */
+    changePerspective(command: PreviewPerspectiveCommand, route: string): Promise<PreviewReadContext | null>;
+    /**
+     * ADR-131 Amendment 002 §5.1.bis — publish the Pattern D HTTP client
+     * for iframe-runtime consumers (schema-store, future tier-2/3
+     * helpers). Called by `<StorystickQueryProvider>` in preview mode
+     * when the configured client is (re-)built after a token arrival.
+     * Calling with `null` clears it (provider unmount).
+     *
+     * Field-only update — bypasses the sticky-error gate that protects
+     * the state-machine `state` field, since httpClient lifecycle is
+     * provider-managed and should always reflect the provider's current
+     * intent (notably, cleanup on unmount must run even in `'error'`).
+     * No other state machine invariants are affected: this writes one
+     * independent field only.
+     */
+    setHttpClient(client: Client | null): void;
+    /** Record token-free cookie lifecycle observations for C3 convergence. */
+    observeCookieLifecycle(event: PreviewCookieLifecycleEvent): void;
+    /** Enter the existing sticky auth-error surface after cookie death. */
+    reportCookieTerminalFailure(error: {
+        code: string;
+        message: string;
+    }): void;
+    /**
+     * Test-only namespace.
+     */
+    __test: {
+        /** Reset to INITIAL_STATE ; drop listeners ; clear cleanups. */
+        reset(): void;
+        /** Inject a partial state. Bypasses sticky-error guards. */
+        set(partial: Partial<PreviewRuntimeState>): void;
+        /** Inject a custom resolver (for tests). */
+        setResolver(resolver: IdentityResolver): void;
+        /** Wire the session watcher through the production helper. */
+        wireSessionSubscription(sessionId: string, client: ConvexReactClient): void;
+        /** Read the session id currently owning the subscription cleanup. */
+        getSubscriptionSessionId(): string | null;
+    };
+}
+export declare const previewRuntime: PreviewRuntime;
+export {};