@procedures/store 0.2.2 → 0.3.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/store",
-  "version": "0.2.2",
-  "description": "A program store for procedure-as-data: save the programs that procedure.define makes, load them back after a restart, in memory, a JSON file or a remote collection storage.",
+  "version": "0.3.0",
+  "description": "A program store for procedure-as-data: save the programs that procedure.define makes, load them back after a restart, in memory, a JSON file, IndexedDB or a remote collection storage.",
   "keywords": [
     "program-store",
     "procedures",
@@ -37,6 +37,14 @@
     "./register": {
       "types": "./dist/register.d.ts",
       "import": "./dist/register.js"
+    },
+    "./file-queue": {
+      "types": "./dist/storage/file-queue.d.ts",
+      "import": "./dist/storage/file-queue.js"
+    },
+    "./indexeddb": {
+      "types": "./dist/indexeddb.d.ts",
+      "import": "./dist/indexeddb.js"
     }
   },
   "files": [
@@ -61,14 +69,16 @@
     "procedures": "./dist/register.js"
   },
   "dependencies": {
-    "@procedures/client": "0.2.2",
-    "@procedures/collections": "0.2.2",
+    "@procedures/client": "0.3.0",
+    "@procedures/collections": "0.3.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "typescript": "^7.0.2",
-    "@types/node": "^22.0.0",
     "@mark1russell7/cue": "^1.0.0",
+    "@types/node": "^22.0.0",
+    "fake-indexeddb": "^6.2.5",
+    "fast-check": "^4.10.2",
+    "typescript": "^7.0.2",
     "vitest": "^5.0.3"
   },
   "scripts": {

package/src/indexeddb/idb.ts

@@ -0,0 +1,190 @@
+/**
+ * The part of IndexedDB that the stores of `@procedures/store/indexeddb` use (roadmap R45).
+ *
+ * The package compiles without the DOM types, so this module declares the shapes that it uses.
+ * The `indexedDB` of a browser fits them, and the `IDBFactory` of `fake-indexeddb` too. Nothing in
+ * this module reads a global value when it loads: Node can import it.
+ */
+
+// The event handlers take `any`: the DOM handlers take their own event types, and a parameter of
+// the type `unknown` does not accept them.
+
+/** A request of IndexedDB. */
+export interface IdbRequestLike<R = unknown> {
+  readonly result: R;
+  readonly error: unknown;
+  onsuccess: ((event: any) => void) | null;
+  onerror: ((event: any) => void) | null;
+}
+
+/** The request that opens a database. */
+export interface IdbOpenRequestLike extends IdbRequestLike<IdbDatabaseLike> {
+  onupgradeneeded: ((event: any) => void) | null;
+}
+
+/** The factory of the databases: `indexedDB` in a browser. */
+export interface IdbFactoryLike {
+  open(name: string, version?: number): IdbOpenRequestLike;
+}
+
+/** An open database. */
+export interface IdbDatabaseLike {
+  readonly objectStoreNames: { contains(name: string): boolean };
+  createObjectStore(name: string, options?: { keyPath?: string; autoIncrement?: boolean }): unknown;
+  transaction(names: string, mode?: "readonly" | "readwrite"): IdbTransactionLike;
+  close(): void;
+  onversionchange: ((event: any) => void) | null;
+}
+
+/** A transaction. */
+export interface IdbTransactionLike {
+  readonly error: unknown;
+  objectStore(name: string): IdbObjectStoreLike;
+  abort(): void;
+  oncomplete: ((event: any) => void) | null;
+  onerror: ((event: any) => void) | null;
+  onabort: ((event: any) => void) | null;
+}
+
+/** An object store in a transaction. */
+export interface IdbObjectStoreLike {
+  get(key: string): IdbRequestLike<unknown>;
+  getAll(): IdbRequestLike<unknown[]>;
+  count(key?: string): IdbRequestLike<number>;
+  put(value: unknown, key?: string): IdbRequestLike<unknown>;
+  add(value: unknown, key?: string): IdbRequestLike<unknown>;
+  delete(key: string): IdbRequestLike<unknown>;
+  clear(): IdbRequestLike<unknown>;
+}
+
+/** The options of the IndexedDB stores. */
+export interface IndexedDbOptions {
+  /**
+   * The factory of the databases. The tests give the one of `fake-indexeddb`.
+   * @default the `indexedDB` of the global scope
+   */
+  indexedDB?: IdbFactoryLike;
+}
+
+/** The `indexedDB` of the global scope, or undefined (Node, an old browser, some private windows). */
+function globalFactory(): IdbFactoryLike | undefined {
+  return (globalThis as { indexedDB?: IdbFactoryLike }).indexedDB ?? undefined;
+}
+
+/**
+ * This function gives true when the global scope has IndexedDB. A browser can still refuse to open a database,
+ * for example in some private windows: the first operation of a store then fails.
+ */
+export function hasIndexedDb(): boolean {
+  return globalFactory() !== undefined;
+}
+
+/** The error of a request or a transaction, as an `Error`. */
+function errorOf(cause: unknown, message: string): Error {
+  return cause instanceof Error ? cause : new Error(message, { cause });
+}
+
+/**
+ * One object store in its own database, version 1. The connection opens at the first operation,
+ * and a failed open tries again at the next operation.
+ */
+export class IdbStoreConnection {
+  private connection: Promise<IdbDatabaseLike> | undefined;
+  private closed = false;
+
+  constructor(
+    /** The name of the database. */
+    readonly database: string,
+    /** The name of the object store. */
+    readonly store: string,
+    private readonly storeOptions: { keyPath?: string; autoIncrement?: boolean },
+    private readonly factory: IdbFactoryLike | undefined,
+  ) {}
+
+  /**
+   * This method runs work in one transaction. The work makes the requests, and it gives a function that reads
+   * their results. The promise resolves after the transaction commits, so a write is durable when
+   * the promise resolves. An error of a request aborts the transaction: each request is undone.
+   */
+  async run<R>(mode: "readonly" | "readwrite", work: (store: IdbObjectStoreLike) => () => R): Promise<R> {
+    const db = await this.open();
+    return new Promise<R>((resolve, reject) => {
+      let transaction: IdbTransactionLike;
+      let read: () => R;
+      try {
+        transaction = db.transaction(this.store, mode);
+        read = work(transaction.objectStore(this.store));
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      transaction.oncomplete = () => {
+        try {
+          resolve(read());
+        } catch (error) {
+          reject(error);
+        }
+      };
+      transaction.onerror = () => reject(errorOf(transaction.error, `The IndexedDB transaction on ${this.database} failed`));
+      transaction.onabort = () => reject(errorOf(transaction.error, `The IndexedDB transaction on ${this.database} was aborted`));
+    });
+  }
+
+  /** This method closes the connection. A later operation throws. */
+  async close(): Promise<void> {
+    this.closed = true;
+    const connection = this.connection;
+    this.connection = undefined;
+    if (!connection) return;
+    try {
+      (await connection).close();
+    } catch {
+      // The open failed: there is nothing to close
+    }
+  }
+
+  private open(): Promise<IdbDatabaseLike> {
+    if (this.closed) return Promise.reject(new Error(`The IndexedDB store ${this.database} is closed`));
+    if (!this.connection) {
+      const connection = this.connect();
+      this.connection = connection;
+      connection.catch(() => {
+        if (this.connection === connection) this.connection = undefined;
+      });
+    }
+    return this.connection;
+  }
+
+  private connect(): Promise<IdbDatabaseLike> {
+    const factory = this.factory ?? globalFactory();
+    if (!factory) return Promise.reject(new Error("IndexedDB is not available in this environment"));
+    return new Promise<IdbDatabaseLike>((resolve, reject) => {
+      let request: IdbOpenRequestLike;
+      try {
+        request = factory.open(this.database, 1);
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.store)) db.createObjectStore(this.store, this.storeOptions);
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.store)) {
+          db.close();
+          reject(new Error(`The IndexedDB database ${this.database} exists, and it has no object store ${this.store}`));
+          return;
+        }
+        // Another tab wants a new version: close this connection, so the upgrade can run
+        db.onversionchange = () => {
+          db.close();
+          this.connection = undefined;
+        };
+        resolve(db);
+      };
+      request.onerror = () => reject(errorOf(request.error, `IndexedDB could not open the database ${this.database}`));
+    });
+  }
+}

package/src/indexeddb/program-store.ts

@@ -0,0 +1,80 @@
+/**
+ * A program store in IndexedDB, for a browser (roadmap R45).
+ *
+ * The programs are in the object store `programs` of one database, with the key of each program
+ * as the key of its record. IndexedDB keeps a structured clone of each record, so a caller that
+ * changes a result does not change the store. The store checks each record that it reads: the
+ * database of a browser can hold records of an older version or of another application.
+ */
+
+import { byKey, checkStoredProgram, keyMatches, type ProgramStore, type StoredProgram } from "../program-store/types.js";
+import { IdbStoreConnection, type IndexedDbOptions } from "./idb.js";
+
+/** The default name of the database of the programs. */
+export const DEFAULT_PROGRAM_DATABASE = "procedures-programs";
+
+/**
+ * A program store in IndexedDB.
+ *
+ * @example
+ * ```typescript
+ * import { IndexedDbProgramStore } from "@procedures/store/indexeddb";
+ *
+ * const store = new IndexedDbProgramStore("my-app-programs");
+ * await store.put({ key: "reports.weekly", path: ["reports", "weekly"], program, storedAt: Date.now() });
+ * const programs = await store.list("reports");
+ * ```
+ */
+export class IndexedDbProgramStore implements ProgramStore {
+  readonly kind = "indexeddb";
+  private readonly connection: IdbStoreConnection;
+
+  /**
+   * @param name - The name of the database. The store makes it at the first operation.
+   * @param options - The IndexedDB factory. The default is the `indexedDB` of the global scope.
+   */
+  constructor(name: string = DEFAULT_PROGRAM_DATABASE, options: IndexedDbOptions = {}) {
+    this.connection = new IdbStoreConnection(name, "programs", { keyPath: "key" }, options.indexedDB);
+  }
+
+  /** The name of the database. */
+  get name(): string {
+    return this.connection.database;
+  }
+
+  get(key: string): Promise<StoredProgram | undefined> {
+    return this.connection.run("readonly", (store) => {
+      const request = store.get(key);
+      return () => (request.result === undefined ? undefined : checkStoredProgram(request.result));
+    });
+  }
+
+  list(prefix?: string): Promise<StoredProgram[]> {
+    return this.connection.run("readonly", (store) => {
+      const request = store.getAll();
+      return () => byKey(request.result.map((record) => checkStoredProgram(record)).filter((program) => keyMatches(program.key, prefix)));
+    });
+  }
+
+  async put(program: StoredProgram): Promise<void> {
+    const checked = checkStoredProgram(structuredClone(program));
+    await this.connection.run("readwrite", (store) => {
+      store.put(checked);
+      return () => undefined;
+    });
+  }
+
+  delete(key: string): Promise<boolean> {
+    return this.connection.run("readwrite", (store) => {
+      // The requests of one transaction run in order: the count sees the record before the delete
+      const count = store.count(key);
+      store.delete(key);
+      return () => count.result > 0;
+    });
+  }
+
+  /** This method closes the database. The programs stay in it. */
+  close(): Promise<void> {
+    return this.connection.close();
+  }
+}

package/src/indexeddb/queue-store.ts

@@ -0,0 +1,80 @@
+/**
+ * A queue store in IndexedDB, for the `HybridStorage` of a browser (roadmap R28, R45).
+ *
+ * The operations are in the object store `operations` of one database, under keys that IndexedDB
+ * makes in increasing order. `load` gives them in the order of the keys: the oldest first. A
+ * `replace` clears the store and adds the operations in one transaction, so a reader never sees a
+ * part of it. Give each storage its own database.
+ */
+
+import { isQueuedOperation, type QueuedOperation, type QueueStore } from "../storage/queue.js";
+import { IdbStoreConnection, type IndexedDbOptions } from "./idb.js";
+
+/**
+ * A queue store in IndexedDB.
+ *
+ * @example
+ * ```typescript
+ * import { HybridStorage } from "@procedures/store";
+ * import { IndexedDbQueueStore } from "@procedures/store/indexeddb";
+ *
+ * const users = new HybridStorage(remote, { mode: "write-back", queueStore: new IndexedDbQueueStore("users-queue") });
+ * ```
+ */
+export class IndexedDbQueueStore implements QueueStore {
+  private readonly connection: IdbStoreConnection;
+
+  /**
+   * @param name - The name of the database: one database for each storage. The store makes it at the first operation.
+   * @param options - The IndexedDB factory. The default is the `indexedDB` of the global scope.
+   */
+  constructor(name: string, options: IndexedDbOptions = {}) {
+    if (typeof name !== "string" || name === "") throw new TypeError("IndexedDbQueueStore needs the name of a database");
+    this.connection = new IdbStoreConnection(name, "operations", { autoIncrement: true }, options.indexedDB);
+  }
+
+  /** The name of the database. */
+  get name(): string {
+    return this.connection.database;
+  }
+
+  load(): Promise<QueuedOperation[]> {
+    return this.connection.run("readonly", (store) => {
+      const request = store.getAll();
+      return () =>
+        request.result.map((value, index) => {
+          if (!isQueuedOperation(value)) {
+            throw new Error(`The queue database ${this.name} has a record that is not a queued operation (record ${index + 1})`);
+          }
+          return value;
+        });
+    });
+  }
+
+  async append(operation: QueuedOperation): Promise<void> {
+    await this.connection.run("readwrite", (store) => {
+      store.add(operation);
+      return () => undefined;
+    });
+  }
+
+  async replace(operations: QueuedOperation[]): Promise<void> {
+    await this.connection.run("readwrite", (store) => {
+      store.clear();
+      for (const operation of operations) store.add(operation);
+      return () => undefined;
+    });
+  }
+
+  async clear(): Promise<void> {
+    await this.connection.run("readwrite", (store) => {
+      store.clear();
+      return () => undefined;
+    });
+  }
+
+  /** This method closes the database. The operations stay in it. */
+  close(): Promise<void> {
+    return this.connection.close();
+  }
+}

package/src/indexeddb.ts

@@ -0,0 +1,19 @@
+/**
+ * The entry `@procedures/store/indexeddb`: the stores of a browser (roadmap R45).
+ *
+ * - `IndexedDbProgramStore` keeps programs in IndexedDB.
+ * - `IndexedDbQueueStore` keeps the queue of a `HybridStorage` in IndexedDB.
+ * - `MemoryProgramStore` and `MemoryQueueStore` are the fallbacks for a browser without
+ *   IndexedDB. `hasIndexedDb()` tells which one to use.
+ *
+ * The package root does not import this entry, and this entry does not import the client or zod:
+ * a page that loads it gets only these stores.
+ */
+
+export { IndexedDbProgramStore, DEFAULT_PROGRAM_DATABASE } from "./indexeddb/program-store.js";
+export { IndexedDbQueueStore } from "./indexeddb/queue-store.js";
+export { hasIndexedDb, type IdbFactoryLike, type IndexedDbOptions } from "./indexeddb/idb.js";
+export { MemoryProgramStore } from "./program-store/memory.js";
+export { MemoryQueueStore } from "./storage/queue.js";
+export type { ProgramStore, StoredProgram } from "./program-store/types.js";
+export type { QueuedOperation, QueueStore } from "./storage/queue.js";

package/src/program-store/file.ts

@@ -34,8 +34,11 @@ function isContention(error: unknown): boolean {
 
 const pause = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
-/** Run a file operation again while Windows holds the file for a moment. */
-async function retryOnContention<T>(operation: () => Promise<T>): Promise<T> {
+/**
+ * This function runs a file operation again while Windows holds the file for a moment. `FileQueueStore` uses it
+ * too.
+ */
+export async function retryOnContention<T>(operation: () => Promise<T>): Promise<T> {
   for (let attempt = 1; ; attempt++) {
     try {
       return await operation();

package/src/program-store/procedures.ts

@@ -43,10 +43,13 @@ function toPath(path: ProcedurePath | string): ProcedurePath {
   return typeof path === "string" ? keyToPath(path) : path;
 }
 
-/** The metadata to store: the procedure's metadata without the program (the store keeps that). */
+/**
+ * The metadata to store: the procedure's metadata without the program (the store keeps that)
+ * and without the effects (procedure.define sets them).
+ */
 function storedMetadata(metadata: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
   if (!metadata) return undefined;
-  const { aggregation: _aggregation, generatedFrom: _generatedFrom, ...rest } = metadata;
+  const { aggregation: _aggregation, generatedFrom: _generatedFrom, effects: _effects, ...rest } = metadata;
   return Object.keys(rest).length > 0 ? rest : undefined;
 }
 

package/src/storage/api.ts

@@ -7,10 +7,11 @@
  * This is the KEY integration between Collections and Universal Client!
  */
 
-import type { CollectionStorage, StorageMetadata } from "@procedures/collections";
+import type { CollectionStorage, StorageChanges, StorageMetadata } from "@procedures/collections";
 import type { Client } from "@procedures/client";
 import type { Method } from "@procedures/client";
 import type { CallOptions } from "@procedures/client/client";
+import { optionalMs, type Duration } from "@procedures/client";
 
 /**
  * API storage configuration options.
@@ -42,6 +43,8 @@ export interface ApiStorageOptions {
   operations?: {
     get?: string;
     getAll?: string;
+    entries?: string;
+    changes?: string;
     find?: string;
     has?: string;
     size?: string;
@@ -54,10 +57,10 @@ export interface ApiStorageOptions {
   };
 
   /**
-   * Request timeout in milliseconds. A call that takes longer fails. 0: no timeout.
-   * @default 30000 (30 seconds)
+   * Request timeout, for example `seconds(30)`. A call that takes longer fails. 0: no timeout.
+   * @default 30 seconds
    */
-  timeout?: number;
+  timeout?: Duration;
 
   /**
    * Retry a call that fails with a retryable error: true (3 attempts), false (1 attempt), or the
@@ -67,10 +70,10 @@ export interface ApiStorageOptions {
   retry?: boolean | number;
 
   /**
-   * The first delay between attempts in milliseconds. Each later delay is two times longer.
-   * @default 100
+   * The first delay between attempts. Each later delay is two times longer.
+   * @default 100 milliseconds
    */
-  retryDelay?: number;
+  retryDelay?: Duration;
 
   /**
    * AbortSignal for cancelling requests
@@ -165,6 +168,8 @@ export class ApiStorage<T> implements CollectionStorage<T> {
       operations: {
         get: "get",
         getAll: "getAll",
+        entries: "entries",
+        changes: "changes",
         find: "find",
         has: "has",
         size: "size",
@@ -176,10 +181,10 @@ export class ApiStorage<T> implements CollectionStorage<T> {
         getBatch: "getBatch",
         ...options.operations,
       },
-      timeout: options.timeout ?? 30000,
+      timeout: optionalMs(options.timeout, "timeout") ?? 30000,
       attempts:
         options.retry === false ? 1 : options.retry === true || options.retry === undefined ? 3 : Math.max(1, options.retry),
-      retryDelay: options.retryDelay ?? 100,
+      retryDelay: optionalMs(options.retryDelay, "retryDelay") ?? 100,
       ...(options.signal !== undefined && { signal: options.signal }),
       closeClient: options.closeClient ?? false,
     };
@@ -202,6 +207,39 @@ export class ApiStorage<T> implements CollectionStorage<T> {
     return values;
   }
 
+  /** Every item with its id, from the `entries` procedure of the collection (roadmap R2). */
+  async getEntries(): Promise<Array<[string, T]>> {
+    const entries = await this.call<Array<{ id: string; value: T }>>("entries", {});
+    if (!Array.isArray(entries)) {
+      throw new Error(`${this.options.service}.entries did not return an array`);
+    }
+    return entries.map((entry) => [entry.id, entry.value]);
+  }
+
+  /**
+   * The changes after a version, from the `changes` procedure of the collection (roadmap R28).
+   * A server without the procedure answers `NOT_FOUND`, and `HybridStorage` then uses
+   * `getEntries()`.
+   */
+  async getChangesSince(since?: string): Promise<StorageChanges<T>> {
+    const result = await this.call<{ version: string; full: boolean; changed: Array<{ id: string; value: T }>; deleted: string[] }>(
+      "changes",
+      since === undefined ? {} : { since },
+    );
+    if (
+      typeof result !== "object" || result === null || typeof result.version !== "string" ||
+      typeof result.full !== "boolean" || !Array.isArray(result.changed) || !Array.isArray(result.deleted)
+    ) {
+      throw new Error(`${this.options.service}.changes did not return { version, full, changed, deleted }`);
+    }
+    return {
+      version: result.version,
+      full: result.full,
+      changed: result.changed.map((entry) => [entry.id, entry.value]),
+      deleted: result.deleted,
+    };
+  }
+
   async find(predicate: (item: T) => boolean): Promise<T[]> {
     // A predicate cannot go over the network: read all items, then filter here
     const all = await this.getAll();
@@ -323,7 +361,9 @@ export class ApiStorage<T> implements CollectionStorage<T> {
 
     // The signal goes in the call options, so the transport can stop the request too. (Before,
     // it went into the metadata, and the timeout was dropped: deep dive CORE-9.)
-    const callOptions: CallOptions<unknown> = {};
+    // The storage retries itself: one attempt for a retry middleware of the client, so 3 attempts
+    // here and 4 there cannot make 12 calls (roadmap R12)
+    const callOptions: CallOptions<unknown> = { context: { retry: { maxAttempts: 1 } } };
     if (signal) callOptions.signal = signal;
     const call = this.client.call<unknown, TRes>(method, payload, callOptions);
     return untilAborted(call, signal, () =>

package/src/storage/factory.ts

@@ -9,7 +9,7 @@ import type { CollectionStorage } from "@procedures/collections";
 import { InMemoryStorage } from "@procedures/collections";
 import { ApiStorage } from "./api.js";
 import { HybridStorage } from "./hybrid.js";
-import type { HybridStorageOptions } from "./hybrid.js";
+import type { HybridMode, HybridStorageOptions } from "./hybrid.js";
 import { ProcedureRegistry, PROCEDURE_REGISTRY } from "@procedures/client";
 import type { SerializedProcedure, SyncedRegistryOptions, HandlerLoader } from "./types.js";
 import { SyncedProcedureRegistry } from "./synced-registry.js";
@@ -49,6 +49,14 @@ export interface CreateSyncedRegistryConfig {
    */
   service?: string | undefined;
 
+  /**
+   * The first mode of the hybrid storage (roadmap R28): `local-only`, `write-through`,
+   * `write-back` or `remote-only`. `setMode()` of the registry changes it later. Only the type
+   * "hybrid" has modes.
+   * @default "write-through"
+   */
+  mode?: HybridMode | undefined;
+
   /**
    * Additional options for hybrid storage.
    */
@@ -99,11 +107,15 @@ export interface CreateSyncedRegistryConfig {
  *   type: 'hybrid',
  *   client: myClient,
  *   service: 'procedures',
+ *   mode: 'write-through',
  *   hybridOptions: {
- *     writeStrategy: 'write-through',
  *     conflictResolution: 'remote',
  *   },
  * });
+ *
+ * // Offline, then online again: the switch sends the queued records
+ * await registry.setMode('local-only');
+ * await registry.setMode('write-through');
  * ```
  */
 export function createSyncedRegistry(config: CreateSyncedRegistryConfig): SyncedProcedureRegistry {
@@ -112,6 +124,7 @@ export function createSyncedRegistry(config: CreateSyncedRegistryConfig): Synced
     client,
     collection = "procedures",
     service,
+    mode,
     hybridOptions,
     registryOptions = {},
     baseRegistry = PROCEDURE_REGISTRY,
@@ -124,6 +137,9 @@ export function createSyncedRegistry(config: CreateSyncedRegistryConfig): Synced
   if ((type === "api" || type === "hybrid") && !client) {
     throw new Error(`Client is required for storage type: ${type}`);
   }
+  if (mode !== undefined && type !== "hybrid") {
+    throw new Error(`Only the storage type "hybrid" has modes, not "${type}"`);
+  }
 
   // Create the appropriate storage backend
   let storage: CollectionStorage<SerializedProcedure>;
@@ -145,14 +161,15 @@ export function createSyncedRegistry(config: CreateSyncedRegistryConfig): Synced
         collection,
         ...(service !== undefined && { service }),
       });
+      const { mode: optionMode, writeStrategy, ...otherOptions } = hybridOptions ?? {};
       storage = new HybridStorage<SerializedProcedure>(
         remoteStorage,
         {
-          writeStrategy: hybridOptions?.writeStrategy ?? "write-through",
           conflictResolution: hybridOptions?.conflictResolution ?? "local",
           // A procedure record has no id: its key is its path (deep dive DATA-9)
           keyOf: getSerializedKey,
-          ...hybridOptions,
+          ...otherOptions,
+          mode: mode ?? optionMode ?? writeStrategy ?? "write-through",
         }
       );
       break;