@mmstack/worker 21.0.0 → 21.2.0

package/fesm2022/mmstack-worker.mjs

@@ -1,7 +1,8 @@
 import { generateId, deserializeError, closePort, takeTransferables } from '@mmstack/worker/protocol';
 export * from '@mmstack/worker/protocol';
 import { inject, Injector, runInInjectionContext, PLATFORM_ID, signal, DestroyRef, computed, effect, untracked } from '@angular/core';
-import { injectTransitionScope, toStore, applyOps, diffOps } from '@mmstack/primitives';
+import { injectTransitionScope, toStore, opSync } from '@mmstack/primitives';
+import { createWatch } from '@angular/core/primitives/signals';
 
 /** Thrown into a task/write promise when it is aborted. `name` is `'AbortError'` (DOM convention). */
 class WorkerAbortError extends Error {
@@ -43,16 +44,16 @@ function build$2(spawn, opt) {
     let attempt = 0;
     let runIdSeq = 0;
     let destroyed = false;
-    let crashed = false; // between a crash and the next successful handshake
+    let crashed = false;
     let port = null;
     const send = (msg, transfer) => {
         if (port)
-            port.postMessage(msg, transfer); // no-op on the server / between crash and respawn
+            port.postMessage(msg, transfer);
     };
     const onMessage = (msg) => {
         switch (msg.type) {
             case 'ready':
-                attempt = 0; // a successful handshake resets the backoff
+                attempt = 0;
                 crashed = false;
                 manifest.set({
                     hostId: msg.hostId,
@@ -81,10 +82,9 @@ function build$2(spawn, opt) {
                 return;
             }
             case 'task:aborted':
-                taskPending.delete(msg.runId); // caller already rejected at abort
+                taskPending.delete(msg.runId);
                 return;
             default:
-                // store:* traffic → replicas
                 for (const h of storeHandlers)
                     h(msg);
         }
@@ -94,7 +94,6 @@ function build$2(spawn, opt) {
             return;
         crashed = true;
         connected.set(false);
-        // in-flight tasks can't survive a crash; store replicas hold their value and re-hydrate on reconnect
         for (const [, p] of taskPending)
             p.reject(new WorkerCrashedError());
         taskPending.clear();
@@ -109,14 +108,11 @@ function build$2(spawn, opt) {
         }, delay);
     };
     const openPort = () => {
-        // terminate the previous worker before respawning, so a transient/manual restart never orphans
-        // a live thread (a genuine crash already killed it; terminate() is then a harmless no-op)
         if (port)
             closePort(port);
         port = spawn();
         port.onmessage = (ev) => onMessage(ev.data);
-        // duck-typed crash detection via property setters (NOT addEventListener — that perturbs a node
-        // MessagePort's onmessage delivery). A real `Worker` has onerror; onmessageerror where present.
+        // crash detection via property setters, not addEventListener (perturbs node MessagePort delivery)
         const evt = port;
         if ('onerror' in evt)
             evt.onerror = handleCrash;
@@ -124,7 +120,6 @@ function build$2(spawn, opt) {
             evt.onmessageerror = handleCrash;
         send({ type: 'hello', proto: 1, clientId });
     };
-    // no workers on the server — connected stays false, runTask rejects, replicas render their default
     if (!isServer)
         openPort();
     inject(DestroyRef).onDestroy(() => teardown());
@@ -134,8 +129,6 @@ function build$2(spawn, opt) {
         for (const [, p] of taskPending)
             p.reject(new WorkerAbortError('worker connection destroyed'));
         taskPending.clear();
-        // same contract as a crash: anything pending on the connection (replica writes) settles NOW
-        // rather than dangling — a destroyed port can never deliver the echo that would resolve them
         for (const fn of disconnectHooks)
             fn();
         if (port)
@@ -150,9 +143,6 @@ function build$2(spawn, opt) {
                 return Promise.reject(new WorkerCrashedError('no worker on the server'));
             if (destroyed)
                 return Promise.reject(new WorkerAbortError('worker connection destroyed'));
-            // between a crash and the respawned handshake the port is dead — a message posted into it
-            // vanishes and the promise would never settle. Reject honestly; the caller retries/reloads.
-            // (Before the FIRST handshake this is false: a starting worker buffers messages, so we send.)
             if (crashed)
                 return Promise.reject(new WorkerCrashedError('worker is restarting'));
             if (o?.signal?.aborted)
@@ -207,7 +197,7 @@ function build$1(params, options) {
     const { worker, task } = options;
     const runTask = (input, signal) => worker.runTask(task, input, { signal });
     const value = signal(options.defaultValue, { ...(ngDevMode ? { debugName: "value" } : /* istanbul ignore next */ {}), equal: userEqual
-            ? (a, b) => (a === undefined || b === undefined ? a === b : userEqual(a, b))
+            ? (a, b) => a === undefined || b === undefined ? a === b : userEqual(a, b)
             : undefined });
     const status = signal('idle', ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
     const error = signal(undefined, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
@@ -233,7 +223,7 @@ function build$1(params, options) {
             if (inFlight === ac)
                 inFlight = null;
             if (myEpoch !== epoch)
-                return; // superseded — discard
+                return;
             value.set(result);
             status.set('resolved');
         }, (err) => {
@@ -241,7 +231,8 @@ function build$1(params, options) {
                 inFlight = null;
             if (myEpoch !== epoch)
                 return;
-            if (err instanceof WorkerAbortError || err?.name === 'AbortError')
+            if (err instanceof WorkerAbortError ||
+                err?.name === 'AbortError')
                 return;
             error.set(err);
             status.set('error');
@@ -251,10 +242,9 @@ function build$1(params, options) {
     const ref = effect(() => {
         const i = input();
         if (isServer || i === PAUSED)
-            return; // server: never run · paused: hold
+            return;
         if (i === undefined)
-            return; // disabled — keep current value/status
-        // dedup: a resume to the same input (e.g. after a pause) does not re-run
+            return;
         if (Object.is(i, lastInput) && hasRun && untracked(status) !== 'error')
             return;
         untracked(() => start(i));
@@ -277,11 +267,11 @@ function build$1(params, options) {
         },
         abort: () => {
             if (!inFlight)
-                return; // nothing in flight (a scope's abortPending must not disturb a settled value)
+                return;
             epoch++;
             inFlight.abort();
             inFlight = null;
-            status.set('local'); // value kept
+            status.set('local');
         },
         destroy: () => {
             epoch++;
@@ -292,105 +282,133 @@ function build$1(params, options) {
     if (options.register) {
         const scope = injectTransitionScope();
         scope.add(self, { suspends: options.register === 'suspend' });
-        inject(DestroyRef).onDestroy(() => scope.remove(self));
+        let removed = false;
+        const remove = () => {
+            if (removed)
+                return;
+            removed = true;
+            scope.remove(self);
+        };
+        inject(DestroyRef).onDestroy(remove);
+        const destroy = self.destroy;
+        self.destroy = () => {
+            remove();
+            destroy();
+        };
     }
     return self;
 }
 
+// An injector-free opLog driver (schedules emission off the microtask queue via `createWatch`), so
+// the replica's `opSync` emits without depending on an application tick. Writes force a synchronous
+// `flush()` at the call site; between writes, owner envelopes drive apply, never local emission.
+const microtaskDriver = () => (run) => {
+    let scheduled = false;
+    const watch = createWatch(() => run(), (w) => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        queueMicrotask(() => {
+            scheduled = false;
+            w.run();
+        });
+    }, false);
+    watch.notify();
+    return { destroy: () => watch.destroy() };
+};
 function workerStore(worker, key, opt) {
     const injector = opt?.injector ?? inject(Injector);
     return runInInjectionContext(injector, () => build(worker, key, opt));
 }
 function build(worker, key, opt) {
-    const injector = inject(Injector); // captured for use in write() (called outside injection context)
+    const injector = inject(Injector);
     const root = signal(opt?.defaultValue, ...(ngDevMode ? [{ debugName: "root" }] : /* istanbul ignore next */ []));
-    // shape-adaptive: the store reflects `root` even as it goes undefined → object on first snapshot
-    const replica = toStore(root, {
+    const s = toStore(root, {
         injector,
     });
+    // The replica runs its own opSync over the worker transport: local writes emit stamped envelopes
+    // routed to the owner, owner envelopes fold in convergently. A driver (not the injector) so
+    // emission stays synchronous under an explicit `flush()`, matching the DI-free worker model.
+    const sync = opSync(root, {
+        writer: worker.clientId,
+        driver: microtaskDriver(),
+        onGap: () => resync(),
+    });
     const status = signal('loading', ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
     const error = signal(undefined, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
     const isLoading = computed(() => {
-        const s = status();
-        return s === 'loading' || s === 'reloading';
+        const st = status();
+        return st === 'loading' || st === 'reloading';
     }, ...(ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []));
     let hasSnapshot = false;
-    let resyncing = false; // awaiting a fresh snapshot after a detected gap
-    let lastVersion = 0;
-    let writeSeq = 0;
+    let lastEmitted = 0; // highest own-origin version emitted; the write() ack key
+    // own writes awaiting the owner's echo (resolve), plus the raw envelopes to resend after a resync
     const writePending = new Map();
+    const unacked = new Map();
     const hasValue = () => hasSnapshot;
-    // resolve any write whose acked authoritative version has now been applied to this replica
-    const settleWrites = () => {
-        for (const [id, p] of writePending) {
-            if (p.version !== null && lastVersion >= p.version) {
-                writePending.delete(id);
+    const isOwned = () => worker.manifest()?.stores.includes(key) ?? false;
+    const ackUpTo = (version) => {
+        for (const [v, p] of writePending) {
+            if (v <= version) {
+                writePending.delete(v);
                 p.resolve();
             }
         }
+        for (const v of [...unacked.keys()])
+            if (v <= version)
+                unacked.delete(v);
     };
+    const shipUnsub = sync.subscribe((env) => {
+        lastEmitted = env.version;
+        unacked.set(env.version, env);
+        if (isOwned() && untracked(worker.connected)) {
+            worker._send({ type: 'store:sync', store: key, env });
+        }
+    });
     const onStoreMessage = (msg) => {
         if (!('store' in msg) || msg.store !== key)
             return;
         switch (msg.type) {
-            case 'store:snapshot': {
-                root.set(msg.value);
-                lastVersion = msg.version;
+            case 'store:checkpoint': {
+                // rebase from the full unacked outbox, not opSync's bounded recent-local ring, so a burst
+                // of writes larger than that ring is never dropped from the local rebase on re-hydrate
+                sync.hydrate(msg.checkpoint, [
+                    ...unacked.values(),
+                ]);
                 hasSnapshot = true;
-                resyncing = false; // a fresh snapshot ends any resync
                 status.set('resolved');
                 error.set(undefined);
-                settleWrites();
-                return;
-            }
-            case 'store:ops': {
-                if (!hasSnapshot || resyncing)
-                    return; // pre-hydration, or dropping until a fresh snapshot
-                if (msg.batch.version <= lastVersion)
-                    return; // stale/duplicate (at-least-once transport)
-                if (msg.batch.version > lastVersion + 1) {
-                    // GAP: a batch was lost — re-hydrate from a fresh snapshot rather than apply out of order
-                    resync();
-                    return;
+                // writes the owner already applied are covered by the checkpoint watermark; resolve them,
+                // then resend any still-unacked tail so a write made before the (re)hydrate is never lost
+                ackUpTo(msg.checkpoint.wm?.[sync.origin] ?? 0);
+                if (isOwned() && untracked(worker.connected)) {
+                    for (const env of [...unacked.values()].sort((a, b) => a.version - b.version)) {
+                        worker._send({ type: 'store:sync', store: key, env });
+                    }
                 }
-                root.set(applyOps(untracked(root), msg.batch.ops));
-                lastVersion = msg.batch.version;
-                settleWrites();
                 return;
             }
-            case 'store:write:ack': {
-                const p = writePending.get(msg.writeId);
-                if (!p)
+            case 'store:sync': {
+                const env = msg.env;
+                if (env.origin === sync.origin) {
+                    ackUpTo(env.version); // the owner echoed our own write back: acknowledgement
                     return;
-                if (lastVersion >= msg.version) {
-                    writePending.delete(msg.writeId);
-                    p.resolve(); // the authoritative batch already landed (FIFO: ops precede the ack)
-                }
-                else {
-                    p.version = msg.version; // resolve once a batch reaches this version
-                }
-                return;
-            }
-            case 'store:write:error': {
-                const p = writePending.get(msg.writeId);
-                if (p) {
-                    writePending.delete(msg.writeId);
-                    p.reject(deserializeError(msg.error));
                 }
+                sync.receive(env); // owner or peer envelope; a version gap triggers onGap -> resync
                 return;
             }
             case 'store:status': {
-                // rung 3: a published derivation's remote status → this replica's status, so an in-flight
-                // worker computation shows as pending on the main thread (holding the last value)
                 switch (msg.status) {
                     case 'error':
-                        error.set(msg.error ? deserializeError(msg.error) : new Error('remote computation error'));
+                        error.set(msg.error
+                            ? deserializeError(msg.error)
+                            : new Error('remote computation error'));
                         status.set('error');
                         return;
                     case 'loading':
                     case 'reloading':
                         error.set(undefined);
-                        status.set(hasSnapshot ? 'reloading' : 'loading'); // hold the value while recomputing
+                        status.set(hasSnapshot ? 'reloading' : 'loading');
                         return;
                     case 'resolved':
                         error.set(undefined);
@@ -405,29 +423,33 @@ function build(worker, key, opt) {
     };
     const subscribe = () => {
         if (hasSnapshot)
-            status.set('reloading'); // holding stale while the fresh snapshot lands
-        worker._send({ type: 'store:subscribe', store: key, clientId: worker.clientId });
+            status.set('reloading');
+        worker._send({
+            type: 'store:subscribe',
+            store: key,
+            clientId: worker.clientId,
+        });
     };
-    // a lost batch left a version gap — hold the stale value and re-subscribe for a fresh snapshot
     const resync = () => {
-        resyncing = true;
         status.set('reloading');
-        worker._send({ type: 'store:subscribe', store: key, clientId: worker.clientId });
+        worker._send({
+            type: 'store:subscribe',
+            store: key,
+            clientId: worker.clientId,
+        });
     };
     const unsub = worker._subscribe(onStoreMessage);
-    // subscribe on each `ready` — the first connection and every auto-restart re-hydration; if the
-    // connection is ALREADY up (created post-handshake), `_onReady` won't fire, so subscribe now
     const offReady = worker._onReady(subscribe);
     if (untracked(worker.connected))
-        subscribe();
-    // a crash can't be delivered — pending writes reject (the caller holds the value + recipe to retry)
+        subscribe(); // already up (created post-handshake): _onReady won't fire
     const offDisconnect = worker._onDisconnect(() => {
         for (const [, p] of writePending)
             p.reject(new WorkerCrashedError());
         writePending.clear();
+        unacked.clear();
     });
     const self = {
-        store: replica,
+        store: s,
         value: root.asReadonly(),
         status,
         error,
@@ -438,54 +460,58 @@ function build(worker, key, opt) {
             const base = untracked(root);
             if (base === undefined)
                 return Promise.reject(new Error('[@mmstack/worker] cannot write before the replica has hydrated'));
-            // hydrated but disconnected = the worker crashed (or is restarting) — a write posted now
-            // vanishes into a dead port and its echo can never arrive. Reject; the caller retries.
             if (!untracked(worker.connected))
                 return Promise.reject(new WorkerCrashedError('worker is not connected'));
-            // fork-diff: a scratch store seeded with the CURRENT value (same ref → copy-on-write keeps
-            // untouched subtrees shared), so diffOps against the base is O(changed paths)
-            const scratch = signal(base, ...(ngDevMode ? [{ debugName: "scratch" }] : /* istanbul ignore next */ []));
-            const scratchStore = toStore(scratch, {
-                injector,
-            });
-            recipe(scratchStore);
-            const ops = diffOps(base, untracked(scratch));
-            if (!ops.length)
-                return Promise.resolve();
-            const writeId = ++writeSeq;
+            if (!isOwned())
+                return Promise.reject(new Error(`[@mmstack/worker] store is read-only (published): ${key}`));
+            recipe(s);
+            const before = lastEmitted;
+            sync.flush(); // emit the routed write synchronously (driver-backed opSync)
+            if (lastEmitted === before)
+                return Promise.resolve(); // no-op recipe: nothing shipped
+            const version = lastEmitted;
             return new Promise((resolve, reject) => {
-                writePending.set(writeId, { resolve, reject, version: null });
-                worker._send({
-                    type: 'store:write',
-                    store: key,
-                    writeId,
-                    clientId: worker.clientId,
-                    ops,
-                });
+                writePending.set(version, { resolve, reject });
             });
         },
         destroy: () => {
+            shipUnsub();
+            sync.destroy();
             unsub();
             offReady();
             offDisconnect();
-            // acks can no longer be received — settle any in-flight write instead of dangling it
             for (const [, p] of writePending)
                 p.reject(new WorkerAbortError('worker store destroyed'));
             writePending.clear();
-            worker._send({ type: 'store:unsubscribe', store: key, clientId: worker.clientId });
+            unacked.clear();
+            worker._send({
+                type: 'store:unsubscribe',
+                store: key,
+                clientId: worker.clientId,
+            });
         },
     };
     inject(DestroyRef).onDestroy(() => self.destroy());
     if (opt?.register) {
         const scope = injectTransitionScope();
         scope.add(self, { suspends: opt.register === 'suspend' });
-        inject(DestroyRef).onDestroy(() => scope.remove(self));
+        let removed = false;
+        const remove = () => {
+            if (removed)
+                return;
+            removed = true;
+            scope.remove(self);
+        };
+        inject(DestroyRef).onDestroy(remove);
+        const destroy = self.destroy;
+        self.destroy = () => {
+            remove();
+            destroy();
+        };
     }
     return self;
 }
 
-// shared wire types, re-exported so main-thread consumers import only from '@mmstack/worker'
-
 /**
  * Generated bundle index. Do not edit.
  */