@mmstack/worker 22.0.0 → 22.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/worker",
-  "version": "22.0.0",
+  "version": "22.2.0",
   "keywords": [
     "angular",
     "signals",
@@ -19,7 +19,7 @@
   "peerDependencies": {
     "@angular/core": ">=22 <23",
     "@angular/common": ">=22 <23",
-    "@mmstack/primitives": ">=22.5.1 <23"
+    "@mmstack/primitives": ">=22.8 <23"
   },
   "sideEffects": false,
   "module": "fesm2022/mmstack-worker.mjs",

package/types/mmstack-worker-host.d.ts

@@ -41,6 +41,13 @@ type WorkerHost<M extends WorkerSchema = WorkerSchema> = HasSchema<M> & {
     readonly hostId: string;
     /** Serve an additional transport (multi-client / tests). Returns a disconnect handle. */
     connect(port: WorkerPortLike): () => void;
+    /**
+     * Apply an AUTHORITATIVE owner correction to an owned store: writes made inside `fn` are stamped
+     * at a bumped epoch, so they deterministically win the merge against any concurrent replica write
+     * (owner authority rides the epoch fold). Readers can gate effects on owner-settled values by the
+     * winning op's epoch. No-op for a read-only (published) or unknown store.
+     */
+    override(store: string, fn: () => void): void;
     /**
      * Synchronously emit any pending owned-store changes to subscribers NOW, instead of waiting for
      * the microtask driver. Makes the mirror deterministic (tests call it before asserting) and is

package/types/mmstack-worker-protocol.d.ts

@@ -1,4 +1,4 @@
-import { OpBatch, StoreOp } from '@mmstack/primitives';
+import { OpSyncCheckpoint, OpEnvelope } from '@mmstack/primitives';
 
 /**
  * A structured-clone-safe rendering of an `Error` for cross-thread propagation. A worker throw
@@ -24,7 +24,7 @@ type RemoteStatus = 'idle' | 'loading' | 'reloading' | 'resolved' | 'error';
 /**
  * Every message exchanged over a {@link WorkerPortLike}. One discriminated union shared by the
  * main-thread client and the worker host (and, later, `@mmstack/mesh`), so the two sides can never
- * drift. Grouped: lifecycle · tasks (rung 1) · stores (rung 2) · remote status (rung 3).
+ * drift.
  */
 type WorkerEnvelope = {
     type: 'hello';
@@ -64,30 +64,13 @@ type WorkerEnvelope = {
     store: string;
     clientId: string;
 } | {
-    type: 'store:snapshot';
+    type: 'store:checkpoint';
     store: string;
-    version: number;
-    value: unknown;
-} | {
-    type: 'store:ops';
-    store: string;
-    batch: OpBatch;
+    checkpoint: OpSyncCheckpoint;
 } | {
-    type: 'store:write';
+    type: 'store:sync';
     store: string;
-    writeId: number;
-    clientId: string;
-    ops: readonly StoreOp[];
-} | {
-    type: 'store:write:ack';
-    store: string;
-    writeId: number;
-    version: number;
-} | {
-    type: 'store:write:error';
-    store: string;
-    writeId: number;
-    error: SerializedError;
+    env: OpEnvelope;
 } | {
     type: 'store:unsubscribe';
     store: string;

package/types/mmstack-worker.d.ts

@@ -1,7 +1,7 @@
 import { WorkerSchema, HasSchema, TaskInput, TaskOutput, WorkerEnvelope, WorkerPortLike, SchemaOf, StoreKeys, StoreValueOf, IsWritableKey } from '@mmstack/worker/protocol';
 export * from '@mmstack/worker/protocol';
 import { Injector, Signal, ValueEqualityFn, ResourceStatus } from '@angular/core';
-import { SignalStore, WritableSignalStore } from '@mmstack/primitives';
+import { WritableSignalStore, SignalStore } from '@mmstack/primitives';
 
 /** What the worker advertised in its `ready` handshake. */
 type WorkerManifest = {
@@ -117,16 +117,21 @@ type WorkerStoreOptions<T> = {
 /** The write path — present only on OWNED (writable) subtrees; absent on published (read-only) ones. */
 type WorkerStoreWrite<T> = {
     /**
-     * Route a write to the OWNER: run `recipe` against a writable draft of the current replica, diff
-     * it to ops, ship them. Resolves once the owner's authoritative batch carrying this write has been
-     * applied to THIS replica (honest async — the value is not applied locally first; for optimistic
-     * UI, fork the replica and reconcile on resolve). Rejects if the owner reports a write error.
+     * Route a write to the OWNER: `recipe` applies optimistically to the store, its diff ships as a
+     * stamped op envelope, and the owner folds it in and echoes it back. Resolves once the owner has
+     * acknowledged it (its echo reconciles this replica). The owner can override with a higher-epoch
+     * correction that wins the merge. To hide the value until the owner confirms it, fork the store
+     * and reveal on resolve. Rejects if the worker is disconnected or the store is read-only.
      */
     write(recipe: (draft: WritableSignalStore<T>) => void): Promise<void>;
 };
 type WorkerStoreRef<T, W extends boolean = true> = {
-    /** The live, READ-ONLY replica — deep per-leaf reads, mirrored from the worker-owned subtree. */
-    readonly store: SignalStore<T>;
+    /**
+     * The live store. For an OWNED subtree it is a full {@link WritableSignalStore}: writes apply
+     * optimistically and route to the owner, and other op-log readers (`meshSync`, `persist`) can
+     * attach to it. For a PUBLISHED subtree it is a read-only {@link SignalStore} mirror.
+     */
+    readonly store: W extends true ? WritableSignalStore<T> : SignalStore<T>;
     /** The replica root value (undefined before hydration). */
     readonly value: Signal<T | undefined>;
     readonly status: Signal<ResourceStatus>;
@@ -138,11 +143,13 @@ type WorkerStoreRef<T, W extends boolean = true> = {
     destroy(): void;
 } & (W extends true ? WorkerStoreWrite<T> : object);
 /**
- * A live READ-ONLY replica of a store subtree OWNED by the worker. Subscribes over the
- * {@link WorkerRef}, hydrates from the owner's snapshot, then applies each authoritative op batch
- * into a main-thread `store` — one `set` per batch, so a batch of N ops is a single notification
- * wave. Satisfies `ResourceLike`/`UseSource`, so it participates in transition scopes and nests in
- * `latest()`/`use()`. Writes are not local: they route to the owner (added in the next step).
+ * A live replica of a store subtree OWNED by the worker. It runs its own `opSync` over the worker
+ * transport: it hydrates from the owner's checkpoint, then folds each owner (or peer) envelope into
+ * a main-thread `store` convergently. For an owned subtree the store is WRITABLE: a write applies
+ * optimistically and its stamped envelope routes to the owner (which folds it and echoes it back),
+ * and any op-log reader — `meshSync`, `persist` — can attach to the same store, so a persisted,
+ * meshed, worker-owned graph is just extra readers. Satisfies `ResourceLike`/`UseSource`, so it
+ * participates in transition scopes and nests in `latest()`/`use()`.
  */
 declare function workerStore<M extends WorkerSchema, K extends StoreKeys<M>>(worker: WorkerRef<M>, key: K, opt?: WorkerStoreOptions<StoreValueOf<M, K> & object>): WorkerStoreRef<StoreValueOf<M, K> & object, IsWritableKey<M, K>>;
 declare function workerStore<T extends object>(worker: WorkerRef, key: string, opt?: WorkerStoreOptions<T>): WorkerStoreRef<T, true>;