@zseven-w/dsh-openpencil 0.1.0-rc.1

package/lib/client/editor-recovery.js

@@ -0,0 +1,83 @@
+/** Same-origin client controls for durable managed-editor recovery. */
+import { editorControlUrl } from './editor-bridge.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function editorRecoverySummaryOf(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.id !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(value.id)
+        || typeof value.capturedAt !== 'number' || !Number.isSafeInteger(value.capturedAt) || value.capturedAt <= 0
+        || typeof value.bytes !== 'number' || !Number.isSafeInteger(value.bytes) || value.bytes <= 0
+        || typeof value.sourceName !== 'string' || value.sourceName.length <= 0 || value.sourceName.length > 512
+        || typeof value.sourceChangedSinceCapture !== 'boolean'
+        || typeof value.cacheLabel !== 'string' || !value.cacheLabel.startsWith('dsh-openpencil/recovery/'))
+        return undefined;
+    return value;
+}
+export function editorRecoveryItemUrl(launch, recoveryId) {
+    if (launch.recoveryUrl === undefined)
+        throw new Error('OpenPencil recovery control is unavailable');
+    if (!/^[A-Za-z0-9_-]{43}$/.test(recoveryId))
+        throw new Error('OpenPencil recovery id is invalid');
+    return `${editorControlUrl(launch.recoveryUrl)}/${recoveryId}`;
+}
+async function checkedJson(response, action) {
+    if (!response.ok)
+        throw new Error(`${action} failed (${response.status})`);
+    return response.json();
+}
+/** Capture the authoritative daemon document; never serializes the iframe from React. */
+export async function captureManagedEditorRecovery(launch, fetcher = fetch) {
+    if (launch.recoveryUrl === undefined)
+        return undefined;
+    const value = await checkedJson(await fetcher(editorControlUrl(launch.recoveryUrl), {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId: launch.sessionId }),
+        keepalive: true,
+    }), 'OpenPencil recovery capture');
+    if (!isRecord(value) || value.ok !== true)
+        throw new Error('OpenPencil recovery capture returned an invalid result');
+    if (value.recovery === null)
+        return undefined;
+    const recovery = editorRecoverySummaryOf(value.recovery);
+    if (recovery === undefined)
+        throw new Error('OpenPencil recovery capture omitted recovery metadata');
+    return recovery;
+}
+/** Explicitly restore into the live daemon. The user must still press Save to update `.op`. */
+export async function restoreManagedEditorRecovery(launch, recovery, fetcher = fetch) {
+    const value = await checkedJson(await fetcher(editorRecoveryItemUrl(launch, recovery.id), {
+        method: 'POST', credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId: launch.sessionId }),
+    }), 'OpenPencil recovery restore');
+    if (!isRecord(value) || value.ok !== true || typeof value.docJson !== 'string') {
+        throw new Error('OpenPencil recovery restore returned an invalid result');
+    }
+    return value.docJson;
+}
+export async function discardManagedEditorRecovery(launch, recovery, fetcher = fetch) {
+    const value = await checkedJson(await fetcher(editorRecoveryItemUrl(launch, recovery.id), {
+        method: 'DELETE', credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId: launch.sessionId }),
+    }), 'OpenPencil recovery discard');
+    if (!isRecord(value) || value.ok !== true)
+        throw new Error('OpenPencil recovery discard returned an invalid result');
+}
+const COPY = {
+    'zh-CN': {
+        available: sourceName => `发现 ${sourceName} 的未保存恢复稿。是否恢复？恢复后仍需点击“保存”才会写入源文件。`,
+        conflict: sourceName => `发现 ${sourceName} 的未保存恢复稿，但源文件之后已被修改。仍要将恢复稿载入画布吗？恢复不会自动覆盖源文件。`,
+    },
+    'en-US': {
+        available: sourceName => `An unsaved recovery draft for ${sourceName} is available. Restore it? You must still select Save to write the source file.`,
+        conflict: sourceName => `An unsaved recovery draft for ${sourceName} is available, but the source changed later. Load the draft into the canvas anyway? Recovery will not overwrite the source automatically.`,
+    },
+};
+export function editorRecoveryCopy(locale) {
+    return COPY[locale];
+}

package/lib/client/editor-successor.d.ts

@@ -0,0 +1,28 @@
+/** Session-scoped successor capabilities for reopening a saved editor card. */
+export interface EditorSuccessorGrant {
+    enabled: true;
+    launchUrl: string;
+    refreshUrl?: string;
+}
+export interface EditorSessionStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface SuccessorOptions {
+    storage?: EditorSessionStorage | null;
+    baseUrl?: string;
+}
+/** The original Tool grant scopes one successor chain for the life of this tab. */
+export declare function editorSuccessorStorageKey(originalLaunchUrl: string, baseUrl?: string): string;
+/** Parse only the successor grant from a successful save response. */
+export declare function editorSuccessorFromSave(value: unknown, baseUrl?: string): EditorSuccessorGrant | undefined;
+/**
+ * Persist the newest save successor under the immutable Tool grant. Invalid or
+ * absent successors clear an older value so a later reopen cannot use a stale
+ * source capability. Storage denial is intentionally non-fatal to saving.
+ */
+export declare function rememberEditorSuccessor(originalLaunchUrl: string, saveResponse: unknown, options?: SuccessorOptions): EditorSuccessorGrant | undefined;
+/** Resolve a saved successor, falling back to the original Tool grant safely. */
+export declare function editorGrantForBoot(original: EditorSuccessorGrant, options?: SuccessorOptions): EditorSuccessorGrant;
+export {};

package/lib/client/editor-successor.js

@@ -0,0 +1,109 @@
+/** Session-scoped successor capabilities for reopening a saved editor card. */
+import { editorControlUrl } from './editor-bridge.js';
+const STORAGE_PREFIX = 'dsh-openpencil:editor-successor:v1:';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function browserStorage() {
+    try {
+        return window.sessionStorage;
+    }
+    catch {
+        return undefined;
+    }
+}
+function storageOf(options) {
+    return options.storage === undefined ? browserStorage() : options.storage ?? undefined;
+}
+function baseUrlOf(options) {
+    return options.baseUrl ?? window.location.href;
+}
+/** The original Tool grant scopes one successor chain for the life of this tab. */
+export function editorSuccessorStorageKey(originalLaunchUrl, baseUrl = window.location.href) {
+    return `${STORAGE_PREFIX}${editorControlUrl(originalLaunchUrl, baseUrl)}`;
+}
+function persistedSuccessorOf(value, baseUrl) {
+    if (!isRecord(value))
+        return undefined;
+    const launchUrl = value.launchUrl;
+    const refreshUrl = value.refreshUrl;
+    if (typeof launchUrl !== 'string' || launchUrl.length === 0
+        || typeof refreshUrl !== 'string' || refreshUrl.length === 0)
+        return undefined;
+    try {
+        return {
+            launchUrl: editorControlUrl(launchUrl, baseUrl),
+            refreshUrl: editorControlUrl(refreshUrl, baseUrl),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Parse only the successor grant from a successful save response. */
+export function editorSuccessorFromSave(value, baseUrl = window.location.href) {
+    if (!isRecord(value) || !isRecord(value.editor) || value.editor.enabled !== true)
+        return undefined;
+    const persisted = persistedSuccessorOf(value.editor, baseUrl);
+    return persisted === undefined ? undefined : { enabled: true, ...persisted };
+}
+/**
+ * Persist the newest save successor under the immutable Tool grant. Invalid or
+ * absent successors clear an older value so a later reopen cannot use a stale
+ * source capability. Storage denial is intentionally non-fatal to saving.
+ */
+export function rememberEditorSuccessor(originalLaunchUrl, saveResponse, options = {}) {
+    const baseUrl = baseUrlOf(options);
+    const successor = editorSuccessorFromSave(saveResponse, baseUrl);
+    const storage = storageOf(options);
+    if (storage === undefined)
+        return successor;
+    try {
+        const key = editorSuccessorStorageKey(originalLaunchUrl, baseUrl);
+        if (successor === undefined || successor.refreshUrl === undefined) {
+            storage.removeItem(key);
+            return undefined;
+        }
+        // Deliberately persist no document path/JSON, daemon token, or response fields.
+        storage.setItem(key, JSON.stringify({
+            launchUrl: successor.launchUrl,
+            refreshUrl: successor.refreshUrl,
+        }));
+    }
+    catch {
+        // sessionStorage can be denied or full; the original Tool grant remains usable.
+    }
+    return successor;
+}
+/** Resolve a saved successor, falling back to the original Tool grant safely. */
+export function editorGrantForBoot(original, options = {}) {
+    const storage = storageOf(options);
+    if (storage === undefined)
+        return original;
+    const baseUrl = baseUrlOf(options);
+    let key;
+    try {
+        key = editorSuccessorStorageKey(original.launchUrl, baseUrl);
+    }
+    catch {
+        return original;
+    }
+    try {
+        const raw = storage.getItem(key);
+        if (raw === null)
+            return original;
+        const successor = persistedSuccessorOf(JSON.parse(raw), baseUrl);
+        if (successor !== undefined)
+            return { enabled: true, ...successor };
+    }
+    catch {
+        // Corrupt JSON and denied reads both fall through to best-effort cleanup.
+    }
+    try {
+        storage.removeItem(key);
+    }
+    catch {
+        // Ignore cleanup failures and keep using the original grant.
+    }
+    return original;
+}

package/lib/client/presentation-hydration.d.ts

@@ -0,0 +1,36 @@
+/** Recover browser-only presentation metadata omitted from nested Tool results. */
+export declare const PRESENTATION_HYDRATION_ENDPOINT = "/_dsh/dsh-openpencil/presentation";
+export declare const PRESENTATION_HYDRATION_META_KEY = "$dshOpenPencil";
+export interface PresentationHydrationRequest {
+    sessionId: string;
+    callId: string;
+    documentSha256: string;
+}
+export interface PresentationHydrationCandidate {
+    block: unknown;
+    toolName: string;
+    sessionId: string;
+    callId: string;
+    embeddedGrant: unknown;
+}
+export type PresentationHydrationFetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface PresentationHydrationOptions {
+    fetcher?: PresentationHydrationFetcher;
+    signal?: AbortSignal;
+}
+type PresentationMetaParser<Grant> = (meta: unknown) => Grant | undefined;
+/**
+ * Read only the immutable document fingerprint from one canonical text result.
+ * Paths, image data, and every other model-visible result field are ignored.
+ */
+export declare function documentSha256FromCanonicalResult(block: unknown): string | undefined;
+/** Select only canonical nested render results that actually need hydration. */
+export declare function presentationHydrationRequestOf(candidate: PresentationHydrationCandidate): PresentationHydrationRequest | undefined;
+/**
+ * Exchange a non-secret result fingerprint for a same-origin presentation
+ * grant. Concurrent subscribers share one request; an unmounted subscriber
+ * can abort independently, and the network request is cancelled once nobody
+ * is waiting for it.
+ */
+export declare function requestPresentationGrant<Grant>(request: PresentationHydrationRequest, parseMeta: PresentationMetaParser<Grant>, options?: PresentationHydrationOptions): Promise<Grant | undefined>;
+export {};

package/lib/client/presentation-hydration.js

@@ -0,0 +1,168 @@
+/** Recover browser-only presentation metadata omitted from nested Tool results. */
+import { OPENPENCIL_RENDER_TOOL_NAME } from '../tool-names.js';
+export const PRESENTATION_HYDRATION_ENDPOINT = '/_dsh/dsh-openpencil/presentation';
+export const PRESENTATION_HYDRATION_META_KEY = '$dshOpenPencil';
+const MAX_CANONICAL_RESULT_CHARS = 1024 * 1024;
+const MAX_SESSION_ID_CHARS = 256;
+const MAX_CALL_ID_CHARS = 512;
+const pendingByFetcher = new WeakMap();
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRequest(value) {
+    return value.sessionId.length > 0
+        && value.sessionId.length <= MAX_SESSION_ID_CHARS
+        && value.callId.length > 0
+        && value.callId.length <= MAX_CALL_ID_CHARS
+        && /^[a-f0-9]{64}$/iu.test(value.documentSha256);
+}
+function requestKey(value) {
+    return `${value.sessionId}\n${value.callId}\n${value.documentSha256.toLowerCase()}`;
+}
+function pendingEnvelope(request, fetcher) {
+    let pending = pendingByFetcher.get(fetcher);
+    if (pending === undefined) {
+        pending = new Map();
+        pendingByFetcher.set(fetcher, pending);
+    }
+    const key = requestKey(request);
+    const existing = pending.get(key);
+    if (existing !== undefined)
+        return existing;
+    const controller = new AbortController();
+    const entry = {
+        subscribers: 0,
+        settled: false,
+        cancelIfUnused: () => { },
+        promise: Promise.resolve(undefined),
+    };
+    entry.cancelIfUnused = () => {
+        if (entry.subscribers !== 0 || entry.settled)
+            return;
+        if (pending?.get(key) === entry)
+            pending.delete(key);
+        controller.abort();
+    };
+    entry.promise = (async () => {
+        const response = await fetcher(PRESENTATION_HYDRATION_ENDPOINT, {
+            method: 'POST',
+            credentials: 'same-origin',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(request),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return undefined;
+        try {
+            return await response.json();
+        }
+        catch {
+            return undefined;
+        }
+    })().catch(() => undefined).finally(() => {
+        entry.settled = true;
+        if (pending?.get(key) === entry)
+            pending.delete(key);
+    });
+    pending.set(key, entry);
+    return entry;
+}
+/**
+ * Read only the immutable document fingerprint from one canonical text result.
+ * Paths, image data, and every other model-visible result field are ignored.
+ */
+export function documentSha256FromCanonicalResult(block) {
+    if (!isRecord(block) || block.isError !== false || !Array.isArray(block.content) || block.content.length !== 1) {
+        return undefined;
+    }
+    const content = block.content[0];
+    if (!isRecord(content) || content.type !== 'text' || typeof content.text !== 'string')
+        return undefined;
+    if (content.text.length > MAX_CANONICAL_RESULT_CHARS)
+        return undefined;
+    let result;
+    try {
+        result = JSON.parse(content.text);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(result) || !isRecord(result.document))
+        return undefined;
+    const fingerprint = result.document.sha256;
+    return typeof fingerprint === 'string' && /^[a-f0-9]{64}$/iu.test(fingerprint)
+        ? fingerprint.toLowerCase()
+        : undefined;
+}
+/** Select only canonical nested render results that actually need hydration. */
+export function presentationHydrationRequestOf(candidate) {
+    if (candidate.embeddedGrant !== undefined || candidate.toolName !== OPENPENCIL_RENDER_TOOL_NAME) {
+        return undefined;
+    }
+    const documentSha256 = documentSha256FromCanonicalResult(candidate.block);
+    if (documentSha256 === undefined
+        || candidate.sessionId.length === 0
+        || candidate.sessionId.length > MAX_SESSION_ID_CHARS
+        || candidate.callId.length === 0
+        || candidate.callId.length > MAX_CALL_ID_CHARS) {
+        return undefined;
+    }
+    return {
+        sessionId: candidate.sessionId,
+        callId: candidate.callId,
+        documentSha256,
+    };
+}
+/**
+ * Exchange a non-secret result fingerprint for a same-origin presentation
+ * grant. Concurrent subscribers share one request; an unmounted subscriber
+ * can abort independently, and the network request is cancelled once nobody
+ * is waiting for it.
+ */
+export function requestPresentationGrant(request, parseMeta, options = {}) {
+    if (!isRequest(request) || options.signal?.aborted === true)
+        return Promise.resolve(undefined);
+    const fetcher = options.fetcher ?? globalThis.fetch;
+    if (typeof fetcher !== 'function')
+        return Promise.resolve(undefined);
+    const entry = pendingEnvelope(request, fetcher);
+    entry.subscribers += 1;
+    return new Promise(resolve => {
+        let finished = false;
+        const release = () => {
+            entry.subscribers = Math.max(0, entry.subscribers - 1);
+            entry.cancelIfUnused();
+        };
+        const finish = (value) => {
+            if (finished)
+                return;
+            finished = true;
+            options.signal?.removeEventListener('abort', abort);
+            release();
+            resolve(value);
+        };
+        const abort = () => { finish(undefined); };
+        options.signal?.addEventListener('abort', abort, { once: true });
+        entry.promise.then(value => {
+            if (finished || options.signal?.aborted === true) {
+                finish(undefined);
+                return;
+            }
+            if (!isRecord(value) || !Object.hasOwn(value, PRESENTATION_HYDRATION_META_KEY)) {
+                finish(undefined);
+                return;
+            }
+            try {
+                finish(parseMeta({
+                    [PRESENTATION_HYDRATION_META_KEY]: value[PRESENTATION_HYDRATION_META_KEY],
+                }));
+            }
+            catch {
+                finish(undefined);
+            }
+        }, () => { finish(undefined); });
+    });
+}

package/lib/client/selection-polling.d.ts

@@ -0,0 +1,24 @@
+/** Lifecycle-safe polling for the optional OpenPencil live-selection endpoint. */
+export interface SelectionPollTimer {
+    schedule(callback: () => void, delayMs: number): unknown;
+    cancel(handle: unknown): void;
+}
+export interface EditorSelectionPollingOptions {
+    url: string;
+    onValue(value: unknown): void;
+    onStop(): void;
+    fetcher?: typeof fetch;
+    intervalMs?: number;
+    timer?: SelectionPollTimer;
+}
+/** Client failures other than retry-oriented HTTP statuses cannot recover by polling. */
+export declare function isTerminalEditorSelectionStatus(status: number): boolean;
+/**
+ * Start one immediate poll followed by non-overlapping delayed polls.
+ *
+ * The returned cleanup is idempotent, aborts an in-flight request, cancels the
+ * pending timer, and invokes `onStop` exactly once. Terminal HTTP responses
+ * use the same cleanup path; network errors and retryable statuses schedule a
+ * later attempt without disrupting the editor itself.
+ */
+export declare function startEditorSelectionPolling(options: EditorSelectionPollingOptions): () => void;

package/lib/client/selection-polling.js

@@ -0,0 +1,79 @@
+/** Lifecycle-safe polling for the optional OpenPencil live-selection endpoint. */
+const DEFAULT_INTERVAL_MS = 400;
+const DEFAULT_TIMER = {
+    schedule: (callback, delayMs) => setTimeout(callback, delayMs),
+    cancel: handle => { clearTimeout(handle); },
+};
+/** Client failures other than retry-oriented HTTP statuses cannot recover by polling. */
+export function isTerminalEditorSelectionStatus(status) {
+    return status >= 400 && status < 500 && status !== 408 && status !== 425 && status !== 429;
+}
+/**
+ * Start one immediate poll followed by non-overlapping delayed polls.
+ *
+ * The returned cleanup is idempotent, aborts an in-flight request, cancels the
+ * pending timer, and invokes `onStop` exactly once. Terminal HTTP responses
+ * use the same cleanup path; network errors and retryable statuses schedule a
+ * later attempt without disrupting the editor itself.
+ */
+export function startEditorSelectionPolling(options) {
+    const fetcher = options.fetcher ?? fetch;
+    const timer = options.timer ?? DEFAULT_TIMER;
+    const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    let stopped = false;
+    let timerHandle;
+    let requestAbort;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (timerHandle !== undefined) {
+            timer.cancel(timerHandle);
+            timerHandle = undefined;
+        }
+        requestAbort?.abort();
+        requestAbort = undefined;
+        options.onStop();
+    };
+    const schedule = () => {
+        if (stopped)
+            return;
+        timerHandle = timer.schedule(() => {
+            timerHandle = undefined;
+            void poll();
+        }, intervalMs);
+    };
+    const poll = async () => {
+        if (stopped)
+            return;
+        const abort = new AbortController();
+        requestAbort = abort;
+        try {
+            const response = await fetcher(options.url, {
+                credentials: 'same-origin',
+                signal: abort.signal,
+            });
+            if (stopped)
+                return;
+            if (isTerminalEditorSelectionStatus(response.status)) {
+                stop();
+                return;
+            }
+            if (response.ok) {
+                const value = await response.json();
+                if (!stopped)
+                    options.onValue(value);
+            }
+        }
+        catch {
+            // Selection is an enhancement. Transient transport failures retry later.
+        }
+        finally {
+            if (requestAbort === abort)
+                requestAbort = undefined;
+            schedule();
+        }
+    };
+    void poll();
+    return stop;
+}

package/lib/client/selection-store.d.ts

@@ -0,0 +1,26 @@
+/** Page-local live selection store shared by the sidebar and conversation. */
+export interface OpenPencilNodeSelection {
+    id: string;
+    type?: string;
+    name?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+export interface OpenPencilLiveSelection {
+    sourcePath: string;
+    activePageId: string;
+    selectedIds: string[];
+    nodes: OpenPencilNodeSelection[];
+    updatedAt: number;
+}
+export interface OpenPencilSelectionStoreSnapshot {
+    revision: number;
+    selection?: OpenPencilLiveSelection;
+}
+export declare function liveSelectionOf(value: unknown): OpenPencilLiveSelection | undefined;
+export declare function publishOpenPencilSelection(sessionId: string, selection: OpenPencilLiveSelection): void;
+export declare function clearOpenPencilSelection(sessionId: string, sourcePath?: string): void;
+export declare function subscribeOpenPencilSelection(sessionId: string, listener: () => void): () => void;
+export declare function getOpenPencilSelectionSnapshot(sessionId: string): OpenPencilSelectionStoreSnapshot;

package/lib/client/selection-store.js

@@ -0,0 +1,85 @@
+/** Page-local live selection store shared by the sidebar and conversation. */
+const stores = new Map();
+const listeners = new Map();
+const EMPTY_SELECTION_STORE_SNAPSHOT = Object.freeze({ revision: 0 });
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function nodeOf(value) {
+    if (!isRecord(value) || typeof value.id !== 'string' || value.id.length === 0)
+        return undefined;
+    return {
+        id: value.id,
+        ...(typeof value.type === 'string' && value.type.length > 0 ? { type: value.type } : {}),
+        ...(typeof value.name === 'string' && value.name.length > 0 ? { name: value.name } : {}),
+        ...(finite(value.x) === undefined ? {} : { x: finite(value.x) }),
+        ...(finite(value.y) === undefined ? {} : { y: finite(value.y) }),
+        ...(finite(value.width) === undefined ? {} : { width: finite(value.width) }),
+        ...(finite(value.height) === undefined ? {} : { height: finite(value.height) }),
+    };
+}
+export function liveSelectionOf(value) {
+    if (!isRecord(value) || typeof value.sourcePath !== 'string' || value.sourcePath.length === 0)
+        return undefined;
+    return {
+        sourcePath: value.sourcePath,
+        activePageId: typeof value.activePageId === 'string' ? value.activePageId : '',
+        selectedIds: Array.isArray(value.selectedIds)
+            ? value.selectedIds.filter((id) => typeof id === 'string' && id.length > 0)
+            : [],
+        nodes: Array.isArray(value.nodes)
+            ? value.nodes.map(nodeOf).filter((node) => node !== undefined)
+            : [],
+        updatedAt: finite(value.updatedAt) ?? Date.now(),
+    };
+}
+function sameSelection(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    return a.sourcePath === b.sourcePath
+        && a.activePageId === b.activePageId
+        && JSON.stringify(a.selectedIds) === JSON.stringify(b.selectedIds)
+        && JSON.stringify(a.nodes) === JSON.stringify(b.nodes);
+}
+export function publishOpenPencilSelection(sessionId, selection) {
+    const current = stores.get(sessionId) ?? { revision: 0 };
+    if (sameSelection(current.selection, selection))
+        return;
+    stores.set(sessionId, { revision: current.revision + 1, selection });
+    for (const listener of listeners.get(sessionId) ?? [])
+        listener();
+}
+export function clearOpenPencilSelection(sessionId, sourcePath) {
+    const current = stores.get(sessionId);
+    if (current === undefined)
+        return;
+    if (current.selection === undefined)
+        return;
+    if (sourcePath !== undefined && current.selection.sourcePath !== sourcePath)
+        return;
+    stores.set(sessionId, { revision: current.revision + 1 });
+    for (const listener of listeners.get(sessionId) ?? [])
+        listener();
+}
+export function subscribeOpenPencilSelection(sessionId, listener) {
+    let scoped = listeners.get(sessionId);
+    if (scoped === undefined) {
+        scoped = new Set();
+        listeners.set(sessionId, scoped);
+    }
+    scoped.add(listener);
+    return () => {
+        scoped?.delete(listener);
+        if (scoped?.size === 0)
+            listeners.delete(sessionId);
+    };
+}
+export function getOpenPencilSelectionSnapshot(sessionId) {
+    // useSyncExternalStore requires referentially stable snapshots while the
+    // underlying state is unchanged. Returning a new empty object here causes
+    // React to enter an update loop before the first selection poll completes.
+    return stores.get(sessionId) ?? EMPTY_SELECTION_STORE_SNAPSHOT;
+}