albex 0.3.0 → 0.6.1

package/src/worker-runtime.ts

@@ -36,8 +36,18 @@ async function dispatch(op: WorkerOp): Promise<unknown> {
     }
     case 'search':
       return ensureEngine().search(op.query, op.options);
+    case 'listChunks':
+      return ensureEngine().listChunks(op.docId);
     case 'removeDocument':
       return ensureEngine().removeDocument(op.id);
+    case 'replaceDocument': {
+      // Same File-like wrapping as indexFile; the engine's replaceDocument
+      // handles remove + re-index + auto-compact under its own lock.
+      const file = new File([op.buffer], op.fileName);
+      return ensureEngine().replaceDocument(op.name, file);
+    }
+    case 'takeDiagnostics':
+      return ensureEngine().takeDiagnostics();
     case 'compact':
       ensureEngine().compact();
       return undefined;
@@ -75,22 +85,37 @@ async function dispatch(op: WorkerOp): Promise<unknown> {
   }
 }
 
-self.onmessage = async (ev: MessageEvent<WorkerRequest>) => {
-  const { id, op } = ev.data;
+async function handle(req: WorkerRequest): Promise<void> {
+  const { id, op } = req;
   try {
     const result = await dispatch(op);
     const res: WorkerResponse = { id, ok: true, result };
     (self as unknown as Worker).postMessage(res);
   } catch (err) {
-    const e = err as Error & { kind?: string };
+    const e = err as Error & { kind?: string; limit?: string; max?: number };
     const res: WorkerResponse = {
       id, ok: false,
       error: {
         name:    e.name ?? 'Error',
         kind:    err instanceof AlbexError ? err.kind : undefined,
         message: e.message ?? String(err),
+        // Capacity metadata (which pool + its runtime limit) — plain data,
+        // survives structuredClone, lets the main side rehydrate a full
+        // AlbexCapacityError.
+        limit:   typeof e.limit === 'string' ? e.limit : undefined,
+        max:     typeof e.max === 'number' ? e.max : undefined,
       },
     };
     (self as unknown as Worker).postMessage(res);
   }
+}
+
+// Process messages strictly in arrival order. The engine guards its own
+// state, but a sync `search` arriving mid-`indexFile` await would otherwise
+// be rejected as "busy"; queueing keeps the worker's externally-observable
+// behaviour serial and matches the main-thread engine's serialization.
+let _queue: Promise<void> = Promise.resolve();
+self.onmessage = (ev: MessageEvent<WorkerRequest>) => {
+  const req = ev.data;
+  _queue = _queue.then(() => handle(req));
 };