@lincyaw/workbench 0.1.0 → 0.2.0-rc.1

package/src/context.tsx

@@ -0,0 +1,27 @@
+import { createContext, useContext, useSyncExternalStore } from 'react'
+import type { ReactNode } from 'react'
+import { MESSAGES } from './messages.ts'
+import type { WorkbenchMessages } from './messages.ts'
+import type { Workbench, WorkbenchState } from './workbench.ts'
+
+const WORKBENCH = createContext<Workbench | undefined>(undefined)
+
+/** Gives the panels drawn in it one workbench. */
+export function WorkbenchProvider({ workbench, children }: { workbench: Workbench, children?: ReactNode }) {
+  return <WORKBENCH.Provider value={workbench}>{children}</WORKBENCH.Provider>
+}
+
+export function useWorkbench(): Workbench {
+  const workbench = useContext(WORKBENCH)
+  if (!workbench) throw new Error('a workbench panel is drawn outside WorkbenchProvider')
+  return workbench
+}
+
+export function useWorkbenchState<T>(select: (state: WorkbenchState) => T): T {
+  const workbench = useWorkbench()
+  return useSyncExternalStore(workbench.subscribe, () => select(workbench.getState()))
+}
+
+export function useMessages(): WorkbenchMessages {
+  return MESSAGES[useWorkbenchState(state => state.locale)]
+}

package/src/diagnostics.ts

@@ -0,0 +1,113 @@
+import { errorMessage } from '@lincyaw/kernel'
+import type { Diagnostic, DiagnosticSnapshot, PreviewDiagnostics } from '@lincyaw/kernel'
+import type { WorkbenchStore } from './workbench.ts'
+import type { WorkspaceClient } from './workspace-client.ts'
+
+type Repairer = (diagnostics: readonly Diagnostic[]) => void | Promise<void>
+
+/**
+ * The open document's current diagnostics: the snapshots the workspace server pushes (marked unavailable while the
+ * stream fails), the preview's runtime findings reported to it, and the repair the conversation is asked for.
+ */
+export class DocumentDiagnostics {
+  readonly #client: WorkspaceClient
+  readonly #store: WorkbenchStore
+  readonly #repairers = new Set<Repairer>()
+  #unsubscribe?: () => void
+  #scope = 0
+  #repairRequest = 0
+  #reporting: Promise<void> = Promise.resolve()
+
+  constructor(client: WorkspaceClient, store: WorkbenchStore) {
+    this.#client = client
+    this.#store = store
+  }
+
+  subscribe(dir: string): void {
+    if (this.#client.capabilities?.diagnostics === 'none') {
+      this.#unsubscribe?.(); this.#unsubscribe = undefined
+      // An unsupported producer is absent; it has not reported a successful check.
+      this.#store.set({ diagnostics: undefined, isDiagnosticsUnavailable: false })
+      return
+    }
+    const scope = this.#scope
+    let streamFailed = false
+    let liveReceived = false
+    const current = () => scope === this.#scope && this.#store.state.document === dir
+    const received = (diagnostics: DiagnosticSnapshot, live = false) => {
+      if (!current() || (!live && liveReceived)) return
+      if (live) {
+        liveReceived = true
+        streamFailed = false
+      }
+      this.#store.set({ diagnostics, isDiagnosticsUnavailable: streamFailed })
+    }
+    const failed = () => {
+      streamFailed = true
+      if (current() && !this.#store.state.isDiagnosticsUnavailable) this.#store.set({ isDiagnosticsUnavailable: true })
+    }
+    this.#unsubscribe = this.#client.subscribeDiagnostics(dir, snapshot => received(snapshot, true), failed)
+    void this.#client.readDiagnostics(dir).then(snapshot => received(snapshot), () => {
+      if (current() && !this.#store.state.diagnostics && !this.#store.state.isDiagnosticsUnavailable) this.#store.set({ isDiagnosticsUnavailable: true })
+    })
+  }
+
+  retry(): void {
+    const document = this.#store.state.document
+    if (document === undefined) return
+    this.#unsubscribe?.()
+    this.#scope++
+    this.subscribe(document)
+  }
+
+  /** Tells the workspace server a preview's runtime findings, one report at a time. */
+  reportPreview(report: PreviewDiagnostics): Promise<void> {
+    if (this.#client.capabilities?.diagnostics === 'none') return Promise.resolve()
+    const scope = this.#scope
+    this.#reporting = this.#reporting.then(async () => {
+      try {
+        await this.#client.reportDiagnostics(report)
+      } catch {
+        if (scope === this.#scope && this.#store.state.document === report.document && !this.#store.state.isDiagnosticsUnavailable) this.#store.set({ isDiagnosticsUnavailable: true })
+      }
+    })
+    return this.#reporting
+  }
+
+  onRepair(repairer: Repairer): () => void {
+    this.#repairers.add(repairer)
+    this.#store.set({ canRepairDiagnostics: true })
+    return () => {
+      this.#repairers.delete(repairer)
+      this.#store.set({ canRepairDiagnostics: this.#repairers.size > 0 })
+    }
+  }
+
+  async requestRepair(): Promise<void> {
+    const { state } = this.#store
+    const diagnostics = state.diagnostics?.diagnostics
+    if (!diagnostics?.length || this.#repairers.size === 0 || state.isRepairingDiagnostics || state.isDiagnosticsUnavailable) return
+    const request = ++this.#repairRequest
+    this.#store.set({ isRepairingDiagnostics: true, diagnosticsRepairFailure: undefined })
+    try {
+      await Promise.all([...this.#repairers].map(repairer => repairer(diagnostics)))
+    } catch (error) {
+      if (request === this.#repairRequest) this.#store.set({ diagnosticsRepairFailure: errorMessage(error) })
+    } finally {
+      if (request === this.#repairRequest) this.#store.set({ isRepairingDiagnostics: false })
+    }
+  }
+
+  /** Stops following the document; reports and repairs still under way no longer change the state. */
+  stop(): void {
+    this.#repairRequest++
+    this.#unsubscribe?.()
+    this.#unsubscribe = undefined
+    this.#scope++
+  }
+
+  dispose(): void {
+    this.stop()
+    this.#repairers.clear()
+  }
+}

package/src/document-draft-store.ts

@@ -0,0 +1,179 @@
+export type DraftStoreResult = 'committed' | 'superseded' | 'failed'
+export interface DraftStoreCommit { generation: number, done: Promise<DraftStoreResult> }
+interface Operation extends DraftStoreCommit {
+  key: string
+  raw?: string
+  markers: readonly [string, string][]
+  finish(result: DraftStoreResult): void
+}
+const DATABASE = 'presmium.document-drafts.v1'
+const ENTRIES = 'backups'
+
+/** One actor's latest snapshot replaces only its pending snapshot, never its in-flight transaction. */
+export class DocumentDraftStore {
+  #database?: Promise<IDBDatabase>
+  #channel?: BroadcastChannel
+  #closing = false
+  #generation = 0
+  #flight?: Operation
+  #pending?: Operation
+  readonly #confirmed = new Map<string, string>()
+  readonly #foreign = new Set<string>()
+  readonly #scope: string
+  readonly #writerOwner?: string
+  readonly #family?: 'comment' | 'component'
+
+  constructor(scope: string, changed?: () => void, notifications?: { owner?: string, family?: 'comment' | 'component' }) {
+    this.#scope = scope
+    const writerOwner = this.#writerOwner = notifications?.owner, family = this.#family = notifications?.family
+    if (typeof BroadcastChannel !== 'undefined') {
+      try {
+        this.#channel = new BroadcastChannel(DATABASE)
+        this.#channel.onmessage = event => { if (!this.#closing && event.data?.scope === scope && (!family || !event.data.family || event.data.family === family) && (!writerOwner || event.data.owner !== writerOwner)) changed?.() }
+      } catch { /* Reopening still reads actual storage when cross-tab notification is unavailable. */ }
+    }
+  }
+
+  conflicted(key: string): boolean { return this.#foreign.has(key) }
+  owns(key: string, raw: string): boolean { return this.#confirmed.get(key) === raw }
+  release(key: string): void { if (this.#flight?.key !== key && this.#pending?.key !== key) this.#confirmed.delete(key) }
+
+  #db(): Promise<IDBDatabase> {
+    if (!this.#database) {
+      const work = new Promise<IDBDatabase>((resolve, reject) => {
+        let finished = false
+        const request = indexedDB.open(DATABASE, 1)
+        request.onupgradeneeded = () => { if (!request.result.objectStoreNames.contains(ENTRIES)) request.result.createObjectStore(ENTRIES) }
+        request.onerror = () => { finished = true; reject(request.error) }
+        request.onblocked = () => { finished = true; reject(new Error('document-draft-storage-blocked')) }
+        request.onsuccess = () => {
+          const db = request.result
+          if (finished) { db.close(); return }
+          finished = true
+          const reset = () => { if (this.#database === work) this.#database = undefined }
+          db.onversionchange = () => { db.close(); reset() }
+          db.onclose = reset
+          resolve(db)
+        }
+      })
+      this.#database = work
+      void work.catch(() => { if (this.#database === work) this.#database = undefined })
+    }
+    return this.#database
+  }
+
+  async read(prefixes: readonly string[], signal?: AbortSignal, maxEntries?: number): Promise<Map<string, unknown>> {
+    if (this.#closing) throw new Error('document-draft-storage-closed')
+    if (maxEntries !== undefined && (!Number.isSafeInteger(maxEntries) || maxEntries < 1)) throw new Error('document-draft-read-limit')
+    signal?.throwIfAborted()
+    const db = await new Promise<IDBDatabase>((resolve, reject) => {
+      const cancel = () => { signal?.removeEventListener('abort', cancel); reject(signal?.reason) }
+      signal?.addEventListener('abort', cancel, { once: true })
+      this.#db().then(value => { signal?.removeEventListener('abort', cancel); resolve(value) }, error => { signal?.removeEventListener('abort', cancel); reject(error) })
+    })
+    signal?.throwIfAborted()
+    if (this.#closing) throw new Error('document-draft-storage-closed')
+    return new Promise((resolve, reject) => {
+      const values = new Map<string, unknown>(), tx = db.transaction(ENTRIES, 'readonly'), store = tx.objectStore(ENTRIES)
+      let exceeded = false
+      const cancel = () => { try { tx.abort() } catch { /* The readonly transaction may already have completed. */ } }
+      const stop = () => signal?.removeEventListener('abort', cancel)
+      signal?.addEventListener('abort', cancel, { once: true })
+      tx.oncomplete = () => { stop(); signal?.aborted ? reject(signal.reason) : resolve(values) }
+      tx.onabort = () => { stop(); reject(signal?.aborted ? signal.reason : exceeded ? new Error('document-draft-read-limit') : tx.error ?? new Error('document-draft-read-aborted')) }
+      tx.onerror = () => { stop(); reject(tx.error) }
+      for (const prefix of prefixes) {
+        const request = store.openCursor(IDBKeyRange.bound(prefix, `${prefix}\uffff`))
+        request.onsuccess = () => {
+          const cursor = request.result
+          if (cursor) {
+            const key = String(cursor.key)
+            if (maxEntries !== undefined && values.size >= maxEntries && !values.has(key)) { exceeded = true; tx.abort(); return }
+            values.set(key, cursor.value); cursor.continue()
+          }
+        }
+      }
+    })
+  }
+
+  #notify(): void { if (!this.#closing) this.#channel?.postMessage({ scope: this.#scope, ...this.#writerOwner ? { owner: this.#writerOwner } : {}, ...this.#family ? { family: this.#family } : {} }) }
+
+  async #commit(key: string | undefined, raw: string | undefined, markers: readonly [string, string][]): Promise<{ committed: boolean, foreign: boolean }> {
+    try {
+      const db = await this.#db()
+      return await new Promise(resolve => {
+        const tx = db.transaction(ENTRIES, 'readwrite', { durability: 'strict' }), store = tx.objectStore(ENTRIES)
+        let foreign = false
+        tx.oncomplete = () => resolve({ committed: true, foreign })
+        tx.onabort = () => resolve({ committed: false, foreign })
+        tx.onerror = () => { /* The abort event delivers the terminal transaction result. */ }
+        if (tx.durability !== 'strict') { tx.abort(); return }
+        const apply = () => {
+          for (const [marker, value] of markers) store.put(value, marker)
+        }
+        if (key === undefined) { apply(); return }
+        const request = store.get(key), expected = this.#confirmed.get(key)
+        request.onsuccess = () => {
+          foreign = request.result !== expected
+          if (raw !== undefined) {
+            if (foreign) { tx.abort(); return }
+            store.put(raw, key)
+          } else if (!foreign) store.delete(key)
+          apply()
+        }
+      })
+    } catch { return { committed: false, foreign: false } }
+  }
+
+  #stage(key: string, raw: string | undefined, markers: readonly [string, string][]): DraftStoreCommit | undefined {
+    if (this.#closing) return
+    let finish!: (result: DraftStoreResult) => void
+    const done = new Promise<DraftStoreResult>(resolve => finish = resolve)
+    const next: Operation = { generation: ++this.#generation, key, raw, markers, done, finish }
+    this.#pending?.finish('superseded')
+    this.#pending = next
+    void this.#drain()
+    return next
+  }
+
+  put(key: string, raw: string): DraftStoreCommit | undefined { return this.#stage(key, raw, []) }
+  remove(key: string, markers: readonly [string, string][]): DraftStoreCommit | undefined { return this.#stage(key, undefined, markers) }
+
+  async #drain(): Promise<void> {
+    if (this.#flight || !this.#pending) return
+    const operation = this.#pending
+    this.#pending = undefined; this.#flight = operation
+    const result = await this.#commit(operation.key, operation.raw, operation.markers)
+    if (result.foreign) { this.#foreign.add(operation.key); this.#confirmed.delete(operation.key) }
+    if (result.committed) {
+      if (operation.raw === undefined) this.#confirmed.delete(operation.key)
+      else this.#confirmed.set(operation.key, operation.raw)
+    }
+    this.#flight = undefined
+    operation.finish(result.committed ? 'committed' : 'failed')
+    if (result.committed) this.#notify()
+    if (this.#pending) void this.#drain()
+    else if (this.#closing) this.#closeDatabase()
+  }
+
+  /** A candidate copy must be strictly committed before the actor switches to it. */
+  async create(key: string, raw: string): Promise<boolean> {
+    if (this.#closing) return false
+    const result = await this.#commit(key, raw, [])
+    if (result.committed) { this.#confirmed.set(key, raw); this.#notify() }
+    return result.committed
+  }
+
+  async mark(markers: readonly [string, string][]): Promise<boolean> {
+    if (this.#closing) return false
+    const result = await this.#commit(undefined, undefined, markers)
+    if (result.committed) this.#notify()
+    return result.committed
+  }
+
+  #closeDatabase(): void { void this.#database?.then(db => db.close(), () => {}) }
+  close(): void {
+    this.#closing = true; this.#channel?.close()
+    if (!this.#flight && !this.#pending) this.#closeDatabase()
+  }
+}

package/src/document-drafts.ts

@@ -0,0 +1,178 @@
+import { isRecord, validateDocument } from '@lincyaw/kernel'
+import type { TeachingDocument } from '@lincyaw/kernel'
+import { DocumentDraftStore } from './document-draft-store.ts'
+import type { DraftStoreCommit } from './document-draft-store.ts'
+
+export interface DocumentDraftReference { id: string, revision: number, token: string }
+export interface DocumentDraft {
+  content: TeachingDocument
+  baseVersion: string
+  baseHash: string
+  input: number
+  pendingHash?: string
+  composing?: boolean
+  origins?: DocumentDraftReference[]
+}
+export interface StoredDocumentDraft extends DocumentDraft {
+  format: 2
+  identity: string
+  id: string
+  owner: string
+  revision: number
+  updatedAt: number
+}
+export interface RecoverableDocumentDraft extends StoredDocumentDraft { token: string, source: 'durable' | 'rescue', owned: boolean }
+export interface DocumentDraftChoice extends DocumentDraftReference { updatedAt: number, baseVersion: string, source: 'durable' | 'rescue' }
+export interface DocumentDraftCommit extends DraftStoreCommit { record: StoredDocumentDraft, clearing: boolean }
+
+const PREFIX = 'presmium.document.v2:'
+const SETTLED = 'presmium.document-settled.v1:'
+const MAX_CHARS = 8 << 20
+const prefix = (identity: string) => `${PREFIX}${JSON.stringify(identity)}:`
+const markerPrefix = (identity: string) => `${SETTLED}[${JSON.stringify(identity)},`
+const keyOf = (identity: string, id: string) => `${prefix(identity)}${id}`
+const settledKey = (identity: string, value: DocumentDraftReference) => `${SETTLED}${JSON.stringify([identity, value.id, value.revision, value.token])}`
+const idRevision = (value: unknown): value is Record<string, unknown> & { id: string, revision: number } => isRecord(value) && typeof value.id === 'string' && value.id.length > 0 && value.id.length <= 200 && Number.isSafeInteger(value.revision) && (value.revision as number) > 0
+const reference = (value: unknown): value is DocumentDraftReference => idRevision(value) && 'token' in value && typeof value.token === 'string' && /^[a-f0-9]{64}$/.test(value.token)
+const draftShape = (value: unknown): value is DocumentDraft => isRecord(value) && typeof value.baseVersion === 'string' && value.baseVersion.length > 0 && value.baseVersion.length <= 200 && typeof value.baseHash === 'string' && value.baseHash.length > 0
+  && Number.isSafeInteger(value.input) && (value.input as number) >= 0 && (value.pendingHash === undefined || typeof value.pendingHash === 'string')
+  && (value.composing === undefined || typeof value.composing === 'boolean') && (value.origins === undefined || Array.isArray(value.origins) && value.origins.length <= 1024 && value.origins.every(reference))
+
+function documentDraft(value: unknown, documentId: string): DocumentDraft | undefined {
+  if (!draftShape(value)) return
+  const checked = validateDocument(value.content)
+  if (!checked.document || checked.document.id !== documentId || checked.issues.some(issue => issue.severity === 'error')) return
+  return { content: checked.document, baseVersion: value.baseVersion, baseHash: value.baseHash, input: value.input,
+    pendingHash: value.pendingHash, composing: value.composing, origins: value.origins }
+}
+async function tokenOf(raw: string): Promise<string> {
+  const bytes = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(raw))
+  return [...new Uint8Array(bytes)].map(value => value.toString(16).padStart(2, '0')).join('')
+}
+
+/** Strictly committed document backups, with old localStorage copies identified as unconfirmed rescue material. */
+export class DocumentDrafts {
+  readonly #owner = crypto.randomUUID()
+  readonly #owned = new Map<string, { identity: string, revision: number, raw: string }>()
+  #store?: DocumentDraftStore
+  #identity?: string
+  #closed = false
+  readonly #changed?: () => void
+  constructor(changed?: () => void) { this.#changed = changed }
+
+  #storage(identity: string): DocumentDraftStore | undefined {
+    if (this.#closed || this.#identity !== undefined && this.#identity !== identity) return
+    this.#identity = identity
+    return this.#store ??= new DocumentDraftStore(identity, this.#changed)
+  }
+  matches(identity: string, key: string | null): boolean { return key === null || key.startsWith(prefix(identity)) || key.startsWith(markerPrefix(identity)) }
+
+  async read(identity: string, documentId: string): Promise<{ records: RecoverableDocumentDraft[], failed: boolean }> {
+    const store = this.#storage(identity), values: { key: string, raw: unknown, source: 'durable' | 'rescue' }[] = []
+    let failed = false, durable = new Map<string, unknown>()
+    if (!store) return { records: [], failed: true }
+    try {
+      durable = await store.read([prefix(identity), markerPrefix(identity)])
+      for (const [key, raw] of durable) if (key.startsWith(prefix(identity))) values.push({ key, raw, source: 'durable' })
+    } catch { failed = true }
+    // Existing localStorage input is never removed or silently treated as a strict commit.
+    try {
+      const keys: string[] = []
+      for (let index = 0; index < localStorage.length; index++) {
+        const key = localStorage.key(index)
+        if (key?.startsWith(prefix(identity))) keys.push(key)
+      }
+      for (const key of keys) {
+        const raw = localStorage.getItem(key)
+        if (raw !== null) values.push({ key, raw, source: 'rescue' })
+      }
+    } catch { failed = true }
+    const records = new Map<string, RecoverableDocumentDraft>()
+    for (const { key, raw, source } of values) {
+      try {
+        if (typeof raw !== 'string' || raw.length > MAX_CHARS) throw new Error('document-draft-size')
+        const value: unknown = JSON.parse(raw)
+        if (!isRecord(value) || value.format !== 2 || value.identity !== identity || !idRevision(value) || key !== keyOf(identity, value.id)
+          || typeof value.owner !== 'string' || !value.owner || value.owner.length > 200 || typeof value.updatedAt !== 'number' || !Number.isSafeInteger(value.updatedAt) || value.updatedAt < 0 || Number.isNaN(new Date(value.updatedAt).getTime())) throw new Error('document-draft-data')
+        const draft = documentDraft(value, documentId)
+        if (!draft) throw new Error('document-draft-document')
+        const token = await tokenOf(raw), marker = settledKey(identity, { id: value.id, revision: value.revision, token })
+        if (durable.get(marker) === token) continue
+        if (source === 'rescue' && localStorage.getItem(marker) === token) continue
+        const id = JSON.stringify([value.id, value.revision, token])
+        if (!records.has(id)) records.set(id, { ...draft, format: 2, identity, id: value.id, owner: value.owner, revision: value.revision, updatedAt: value.updatedAt, token, source,
+          owned: source === 'durable' && value.owner === this.#owner && (this.#owned.get(value.id)?.raw === raw || store.owns(key, raw)) })
+      } catch { failed = true }
+    }
+    return { records: [...records.values()], failed }
+  }
+
+  #record(identity: string, draft: DocumentDraft, previous?: StoredDocumentDraft): { record: StoredDocumentDraft, raw: string } | undefined {
+    const store = this.#storage(identity)
+    if (!store || !draftShape(draft)) return
+    const owned = previous && this.#owned.get(previous.id)
+    if (previous && (!owned || owned.identity !== identity || previous.owner !== this.#owner || previous.revision !== owned.revision)) return
+    const changed = previous && store.conflicted(keyOf(identity, previous.id))
+    const record: StoredDocumentDraft = { ...draft, format: 2, identity, id: !changed && previous ? previous.id : crypto.randomUUID(), owner: this.#owner, revision: changed ? 1 : (owned?.revision ?? 0) + 1, updatedAt: Date.now() }
+    if (!Number.isSafeInteger(record.revision)) return
+    try { const raw = JSON.stringify(record); return raw.length <= MAX_CHARS ? { record, raw } : undefined }
+    catch { return }
+  }
+
+  /** Admission is immediate; only done='committed' confirms a durable backup. */
+  write(identity: string, draft: DocumentDraft, previous?: StoredDocumentDraft): DocumentDraftCommit | undefined {
+    const next = this.#record(identity, draft, previous)
+    if (!next) return
+    const commit = this.#store!.put(keyOf(identity, next.record.id), next.raw)
+    if (!commit) return
+    this.#owned.set(next.record.id, { identity, revision: next.record.revision, raw: next.raw })
+    if (previous && previous.id !== next.record.id) this.archive(previous)
+    return { ...commit, record: next.record, clearing: false }
+  }
+
+  async fork(identity: string, draft: DocumentDraft): Promise<StoredDocumentDraft | undefined> {
+    const next = this.#record(identity, draft)
+    if (!next || !await this.#store!.create(keyOf(identity, next.record.id), next.raw)) return
+    this.#owned.set(next.record.id, { identity, revision: next.record.revision, raw: next.raw })
+    return next.record
+  }
+
+  /** Immutable, revision-specific markers never delete another tab's newer record. */
+  async settle(identity: string, values: readonly DocumentDraftReference[]): Promise<boolean> {
+    const store = this.#storage(identity)
+    return Boolean(store && await store.mark(values.map(value => [settledKey(identity, value), value.token])))
+  }
+
+  remove(identity: string, record: StoredDocumentDraft, origins: readonly DocumentDraftReference[]): DocumentDraftCommit | undefined {
+    const owned = this.#owned.get(record.id), store = this.#storage(identity)
+    if (!store || !owned || owned.identity !== identity || record.owner !== this.#owner || owned.revision !== record.revision) return
+    const commit = store.remove(keyOf(identity, record.id), origins.map(value => [settledKey(identity, value), value.token]))
+    if (!commit) return
+    void commit.done.then(result => { if (result === 'committed' && this.#owned.get(record.id)?.revision === record.revision) this.#owned.delete(record.id) })
+    return { ...commit, record, clearing: true }
+  }
+
+  /** The old tab-local snapshot is removed only after a validated strict copy exists. */
+  async migrate(identity: string, documentId: string, legacyKey: string): Promise<'read' | 'write' | undefined> {
+    let raw: string | null, draft: DocumentDraft | undefined
+    try {
+      raw = sessionStorage.getItem(legacyKey)
+      if (raw === null) return
+      if (raw.length > MAX_CHARS) return 'read'
+      draft = documentDraft(JSON.parse(raw), documentId)
+      if (!draft) return 'read'
+    } catch { return 'read' }
+    try {
+      const found = (await this.read(identity, documentId)).records.find(record => record.source === 'durable' && record.baseVersion === draft.baseVersion && record.baseHash === draft.baseHash
+        && record.input === draft.input && record.pendingHash === draft.pendingHash && Boolean(record.composing) === Boolean(draft.composing) && JSON.stringify(record.content) === JSON.stringify(draft.content))
+      const latest = sessionStorage.getItem(legacyKey)
+      if (latest !== raw) return latest === null ? undefined : 'read'
+      if (!found && !await this.fork(identity, draft)) return 'write'
+    } catch { return 'read' }
+    try { if (sessionStorage.getItem(legacyKey) === raw) sessionStorage.removeItem(legacyKey) }
+    catch { /* The strict copy exists; keep the old bytes if cleanup is unavailable. */ }
+  }
+
+  close(): void { this.#closed = true; this.#store?.close() }
+  archive(record: StoredDocumentDraft): void { this.#owned.delete(record.id); this.#store?.release(keyOf(record.identity, record.id)) }
+}