P2-01: add SQLite WASM OPFS project worker

src/facade/projectStore.ts

@@ -0,0 +1,75 @@
+import type { DocumentSnapshot, PersistenceCapabilities, ProjectSaveResult } from './types'
+
+type WorkerRequest = { id: number; type: 'initialize' | 'dispose' } | { id: number; type: 'save-document'; document: DocumentSnapshot } | { id: number; type: 'load-document'; documentId: string }
+type WorkerInput = { type: 'initialize' | 'dispose' } | { type: 'save-document'; document: DocumentSnapshot } | { type: 'load-document'; documentId: string }
+type WorkerResponse = { id: number; ok: true; type: 'initialized'; capabilities: PersistenceCapabilities } | { id: number; ok: true; type: 'saved'; documentId: string; documentVersion: number; persistedAt: number; mode: PersistenceCapabilities['mode'] } | { id: number; ok: true; type: 'loaded'; document: DocumentSnapshot | null } | { id: number; ok: true; type: 'disposed' } | { id: number; ok: false; error: string }
+
+const unavailable: PersistenceCapabilities = { mode: 'unavailable', sqliteWasm: false, opfs: false, schemaVersion: 0, reason: 'Persistence Worker is unavailable in this environment.' }
+const cloneDocument = (document: DocumentSnapshot): DocumentSnapshot => ({ ...document, tree: document.tree.map((item) => ({ ...item, children: item.children ? [...item.children] : undefined })) })
+
+export interface ProjectPersistenceClient {
+  initialize(): Promise<PersistenceCapabilities>
+  capabilities(): PersistenceCapabilities
+  save(document: DocumentSnapshot): Promise<ProjectSaveResult>
+  load(documentId: string): Promise<DocumentSnapshot | null>
+  dispose(): Promise<void>
+}
+
+export class SqliteProjectPersistence implements ProjectPersistenceClient {
+  private readonly worker: Worker | null
+  private nextRequestId = 0
+  private currentCapabilities = unavailable
+  private initialized: Promise<PersistenceCapabilities> | null = null
+  private readonly fallbackSnapshots = new Map<string, DocumentSnapshot>()
+  private readonly pending = new Map<number, { resolve: (response: WorkerResponse) => void; reject: (error: Error) => void }>()
+
+  constructor() {
+    this.worker = typeof Worker === 'undefined' ? null : new Worker(new URL('./persistenceWorker.ts', import.meta.url), { type: 'module', name: 'bitbybit-persistence' })
+    if (!this.worker) this.currentCapabilities = { mode: 'sqlite-memory', sqliteWasm: false, opfs: false, schemaVersion: 0, reason: 'Worker is unavailable; using a transient in-memory project store.' }
+    if (this.worker) {
+      this.worker.onmessage = (event: MessageEvent<WorkerResponse>) => { const request = this.pending.get(event.data.id); if (!request) return; this.pending.delete(event.data.id); request.resolve(event.data) }
+      this.worker.onerror = (event) => { const error = new Error(event.message || 'Persistence Worker failed.'); this.currentCapabilities = { ...unavailable, reason: error.message }; this.initialized = null; for (const request of this.pending.values()) request.reject(error); this.pending.clear() }
+    }
+  }
+
+  capabilities() { return { ...this.currentCapabilities } }
+
+  initialize() {
+    if (!this.worker) return Promise.resolve(this.currentCapabilities)
+    if (!this.initialized) this.initialized = this.request({ type: 'initialize' }).then((response) => { if (!response.ok || response.type !== 'initialized') throw new Error(response.ok ? 'Unexpected persistence response.' : response.error); this.currentCapabilities = response.capabilities; return this.capabilities() })
+    return this.initialized
+  }
+
+  async save(document: DocumentSnapshot) {
+    await this.initialize()
+    if (!this.worker) { const snapshot = cloneDocument(document); this.fallbackSnapshots.set(snapshot.id, snapshot); return { documentId: snapshot.id, documentVersion: snapshot.version, persistedAt: Date.now(), mode: this.currentCapabilities.mode } }
+    const response = await this.request({ type: 'save-document', document })
+    if (!response.ok || response.type !== 'saved') throw new Error(response.ok ? 'Unexpected persistence response.' : response.error)
+    return { documentId: response.documentId, documentVersion: response.documentVersion, persistedAt: response.persistedAt, mode: response.mode }
+  }
+
+  async load(documentId: string) {
+    await this.initialize()
+    if (!this.worker) { const snapshot = this.fallbackSnapshots.get(documentId); return snapshot ? cloneDocument(snapshot) : null }
+    const response = await this.request({ type: 'load-document', documentId })
+    if (!response.ok || response.type !== 'loaded') throw new Error(response.ok ? 'Unexpected persistence response.' : response.error)
+    return response.document
+  }
+
+  async dispose() {
+    if (!this.worker) return
+    await this.request({ type: 'dispose' })
+    this.worker.terminate()
+  }
+
+  private request(input: WorkerInput) {
+    if (!this.worker) return Promise.reject<WorkerResponse>(new Error(this.currentCapabilities.reason))
+    const id = ++this.nextRequestId
+    return new Promise<WorkerResponse>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject })
+      this.worker?.postMessage({ ...input, id } satisfies WorkerRequest)
+    })
+  }
+}
+
+export const createSqliteProjectPersistence = () => new SqliteProjectPersistence()