tinybase 8.5.0 → 9.0.0-beta.0

package/@types/_internal/queries/with-schemas/index.d.ts

@@ -12,8 +12,7 @@ import type {
 export type JoinedCellIdOrId<
   Schema extends OptionalTablesSchema = NoTablesSchema,
   JoinedTableId extends TableIdFromSchema<Schema> | Id =
-    | TableIdFromSchema<Schema>
-    | Id,
+    TableIdFromSchema<Schema> | Id,
 > =
   JoinedTableId extends TableIdFromSchema<Schema>
     ? CellIdFromSchema<Schema, JoinedTableId>

package/@types/_internal/ui/with-schemas/index.d.ts

@@ -15,33 +15,25 @@ import type {
 import type {Synchronizer} from '../../../synchronizers/with-schemas/index.d.ts';
 
 export type StoreOrStoreId<Schemas extends OptionalSchemas> =
-  | Store<Schemas>
-  | Id;
+  Store<Schemas> | Id;
 
 export type MetricsOrMetricsId<Schemas extends OptionalSchemas> =
-  | Metrics<Schemas>
-  | Id;
+  Metrics<Schemas> | Id;
 
 export type IndexesOrIndexesId<Schemas extends OptionalSchemas> =
-  | Indexes<Schemas>
-  | Id;
+  Indexes<Schemas> | Id;
 
 export type RelationshipsOrRelationshipsId<Schemas extends OptionalSchemas> =
-  | Relationships<Schemas>
-  | Id;
+  Relationships<Schemas> | Id;
 
 export type QueriesOrQueriesId<Schemas extends OptionalSchemas> =
-  | Queries<Schemas>
-  | Id;
+  Queries<Schemas> | Id;
 
 export type CheckpointsOrCheckpointsId<Schemas extends OptionalSchemas> =
-  | Checkpoints<Schemas>
-  | Id;
+  Checkpoints<Schemas> | Id;
 
 export type PersisterOrPersisterId<Schemas extends OptionalSchemas> =
-  | Persister<Schemas, Persists.StoreOrMergeableStore>
-  | Id;
+  Persister<Schemas, Persists.StoreOrMergeableStore> | Id;
 
 export type SynchronizerOrSynchronizerId<Schemas extends OptionalSchemas> =
-  | Synchronizer<Schemas>
-  | Id;
+  Synchronizer<Schemas> | Id;

package/@types/persisters/index.d.ts

@@ -205,10 +205,10 @@ export type PersistedChanges<
  * neither are present, the content will be loaded using the Persister's load
  * method. Prior to v5.0, these parameters were callbacks and the overall type
  * was non-generic.
- * @param content If provided, this is a Content object from the Persister
- * that will be used to immediately wholesale update the Store.
- * @param changes If provided, this is a Changes object from the Persister
- * that will be used to immediately incrementally update the Store. This takes
+ * @param content If provided, this is a Content object from the Persister that
+ * will be used to immediately wholesale update the Store.
+ * @param changes If provided, this is a Changes object from the Persister that
+ * will be used to immediately incrementally update the Store. This takes
  * priority over the content argument above if present.
  * @category Creation
  * @since v4.0.0
@@ -801,12 +801,15 @@ export type DpcTabularSave = {
  * Note that both loading and saving of Values from and to the database are
  * disabled by default.
  *
+ * The `load` and `save` properties can be set to `true` to persist all Values,
+ * or to a DpcTabularValuesIn array to persist just a subset of Value Ids.
+ *
  * The 'Dpc' prefix indicates that this type is used within the
  * DatabasePersisterConfig type.
  * @example
  * When applied to a database Persister, this DatabasePersisterConfig will load
- * and save the data of a Store's Values into a database
- * table called 'my_tinybase_values'.
+ * and save the data of two Store Values into a database table called
+ * 'my_tinybase_values'.
  *
  * ```js
  * import type {DatabasePersisterConfig} from 'tinybase';
@@ -814,8 +817,8 @@ export type DpcTabularSave = {
  * export const databasePersisterConfig: DatabasePersisterConfig = {
  *   mode: 'tabular',
  *   values: {
- *     load: true,
- *     save: true,
+ *     load: ['selectedPet', 'open'],
+ *     save: ['selectedPet', 'open'],
  *     tableName: 'my_tinybase_values',
  *   },
  * };
@@ -825,17 +828,19 @@ export type DpcTabularSave = {
  */
 export type DpcTabularValues = {
   /**
-   * Whether Store Values will be loaded from a database table.
+   * Whether Store Values will be loaded from a database table, or the subset of
+   * Value Ids that will be loaded.
    * @category Configuration
    * @since v4.0.0
    */
-  load?: boolean;
+  load?: boolean | DpcTabularValuesIn;
   /**
-   * Whether Store Values will be saved to a database table.
+   * Whether Store Values will be saved to a database table, or the subset of
+   * Value Ids that will be saved.
    * @category Configuration
    * @since v4.0.0
    */
-  save?: boolean;
+  save?: boolean | DpcTabularValuesIn;
   /**
    * The optional name of the database table from and to which the Store Values
    * should be loaded or saved, defaulting to `tinybase_values`.
@@ -845,6 +850,21 @@ export type DpcTabularValues = {
   tableName?: string;
 };
 
+/**
+ * The DpcTabularValuesIn type describes the subset of Store Values that are
+ * persisted by the DpcTabularValues type.
+ *
+ * When used as the DpcTabularValues `load` or `save` property, only the listed
+ * Value Ids will be loaded from or saved to the database table. Unlisted
+ * database columns are ignored on load and left untouched on save.
+ *
+ * The 'Dpc' prefix indicates that this type is used within the
+ * DatabasePersisterConfig type.
+ * @category Configuration
+ * @since v9.0.0
+ */
+export type DpcTabularValuesIn = Id[];
+
 /**
  * A Persister object lets you save and load Store data to and from different
  * locations, or underlying storage types.

package/@types/persisters/persister-durable-object-sql-storage/index.d.ts

@@ -30,10 +30,10 @@ import type {DpcJson, Persister, Persists} from '../index.d.ts';
  * The DpcFragmented type represents the configuration for fragmented
  * persistence mode in a DurableObjectSqlStoragePersister.
  *
- * This mode stores each table, row, cell, and value as separate database rows,
- * avoiding Cloudflare's 2MB row limit that can be hit with large stores in JSON
- * mode. While this creates more database writes, it provides better scalability
- * for larger datasets.
+ * This mode stores each table's metadata, row data, and values as separate
+ * database rows, avoiding Cloudflare's 2MB row limit that can be hit with
+ * large stores in JSON mode. While this creates more database writes than JSON
+ * mode, it provides better scalability for larger datasets.
  * @example
  * This example shows how to configure a DurableObjectSqlStoragePersister to use
  * fragmented mode with a custom storage prefix.
@@ -220,10 +220,11 @@ export interface DurableObjectSqlStoragePersister extends Persister<Persists.Mer
  *   database row. This is efficient for smaller stores but may hit Cloudflare's
  *   2MB row limit for very large stores and uses fewer database writes.
  *
- * - **Fragmented Mode**: Stores each table, row, cell, and value as separate
- *   database rows. Use this mode if you're concerned about hitting Cloudflare's
- *   2MB row limit with large stores in JSON mode. This mode creates more
- *   database writes but avoids row size limitations.
+ * - **Fragmented Mode**: Stores each table's metadata, row data, and values as
+ *   separate database rows. Use this mode if you're concerned about hitting
+ *   Cloudflare's 2MB row limit with large stores in JSON mode. This mode
+ *   creates more database writes than JSON mode but avoids row size
+ *   limitations.
  *
  * The third argument is a DatabasePersisterConfig object that configures which
  * of those modes to use, and settings for each. If the third argument is simply

package/@types/persisters/persister-durable-object-sql-storage/with-schemas/index.d.ts

@@ -38,10 +38,10 @@ import type {
  * The DpcFragmented type represents the configuration for fragmented
  * persistence mode in a DurableObjectSqlStoragePersister.
  *
- * This mode stores each table, row, cell, and value as separate database rows,
- * avoiding Cloudflare's 2MB row limit that can be hit with large stores in JSON
- * mode. While this creates more database writes, it provides better scalability
- * for larger datasets.
+ * This mode stores each table's metadata, row data, and values as separate
+ * database rows, avoiding Cloudflare's 2MB row limit that can be hit with
+ * large stores in JSON mode. While this creates more database writes than JSON
+ * mode, it provides better scalability for larger datasets.
  * @example
  * This example shows how to configure a DurableObjectSqlStoragePersister to use
  * fragmented mode with a custom storage prefix.
@@ -250,10 +250,11 @@ export interface DurableObjectSqlStoragePersister<
  *   database row. This is efficient for smaller stores but may hit Cloudflare's
  *   2MB row limit for very large stores and uses fewer database writes.
  *
- * - **Fragmented Mode**: Stores each table, row, cell, and value as separate
- *   database rows. Use this mode if you're concerned about hitting Cloudflare's
- *   2MB row limit with large stores in JSON mode. This mode creates more
- *   database writes but avoids row size limitations.
+ * - **Fragmented Mode**: Stores each table's metadata, row data, and values as
+ *   separate database rows. Use this mode if you're concerned about hitting
+ *   Cloudflare's 2MB row limit with large stores in JSON mode. This mode
+ *   creates more database writes than JSON mode but avoids row size
+ *   limitations.
  *
  * The third argument is a DatabasePersisterConfig object that configures which
  * of those modes to use, and settings for each. If the third argument is simply
@@ -379,8 +380,7 @@ export function createDurableObjectSqlStoragePersister<
   store: Store<Schemas> | MergeableStore<Schemas>,
   sqlStorage: SqlStorage,
   configOrStoreTableName?:
-    | DurableObjectSqlDatabasePersisterConfig<Schemas>
-    | string,
+    DurableObjectSqlDatabasePersisterConfig<Schemas> | string,
   onSqlCommand?: (sql: string, params?: any[]) => void,
   onIgnoredError?: (error: any) => void,
 ): DurableObjectSqlStoragePersister<Schemas>;

package/@types/persisters/with-schemas/index.d.ts

@@ -55,7 +55,10 @@
  * @module persisters
  * @since v1.0.0
  */
-import type {TableIdFromSchema} from '../../_internal/store/with-schemas/index.d.ts';
+import type {
+  TableIdFromSchema,
+  ValueIdFromSchema,
+} from '../../_internal/store/with-schemas/index.d.ts';
 import type {
   MergeableChanges,
   MergeableContent,
@@ -66,6 +69,7 @@ import type {
   Content,
   OptionalSchemas,
   OptionalTablesSchema,
+  OptionalValuesSchema,
   Store,
 } from '../../store/with-schemas/index.d.ts';
 import type {Id} from '../../with-schemas/index.d.ts';
@@ -260,10 +264,10 @@ export type PersistedChanges<
  * neither are present, the content will be loaded using the Persister's load
  * method. Prior to v5.0, these parameters were callbacks and the overall type
  * was non-generic.
- * @param content If provided, this is a Content object from the Persister
- * that will be used to immediately wholesale update the Store.
- * @param changes If provided, this is a Changes object from the Persister
- * that will be used to immediately incrementally update the Store. This takes
+ * @param content If provided, this is a Content object from the Persister that
+ * will be used to immediately wholesale update the Store.
+ * @param changes If provided, this is a Changes object from the Persister that
+ * will be used to immediately incrementally update the Store. This takes
  * priority over the content argument above if present.
  * @category Creation
  * @since v4.0.0
@@ -394,8 +398,7 @@ export type PersisterStats = {
  * @since v4.0.0
  */
 export type DatabasePersisterConfig<Schemas extends OptionalSchemas> =
-  | DpcJson
-  | DpcTabular<Schemas[0]>;
+  DpcJson | DpcTabular<Schemas[0], Schemas[1]>;
 
 /**
  * The DpcJson type describes the configuration of a database-oriented Persister
@@ -552,7 +555,10 @@ export type DpcJson = {
  * @category Configuration
  * @since v4.0.0
  */
-export type DpcTabular<Schema extends OptionalTablesSchema> = {
+export type DpcTabular<
+  TablesSchema extends OptionalTablesSchema,
+  ValuesSchema extends OptionalValuesSchema = OptionalValuesSchema,
+> = {
   /**
    * The mode to be used for persisting the Store to the database, in this case
    * tabular mapping. See the DpcJson type for the alternative JSON
@@ -573,21 +579,21 @@ export type DpcTabular<Schema extends OptionalTablesSchema> = {
      * @category Configuration
      * @since v4.0.0
      */
-    load?: DpcTabularLoad<Schema>;
+    load?: DpcTabularLoad<TablesSchema>;
     /**
      * The settings for how the Store Tables are mapped out to the database
      * tables when saving.
      * @category Configuration
      * @since v4.0.0
      */
-    save?: DpcTabularSave<Schema>;
+    save?: DpcTabularSave<TablesSchema>;
   };
   /**
    * The settings for how the Store Values are mapped to and from the database.
    * @category Configuration
    * @since v4.0.0
    */
-  values?: DpcTabularValues;
+  values?: DpcTabularValues<ValuesSchema>;
   /**
    * How often the Persister should poll the database for any changes made to it
    * by other clients, defaulting to 1 second.
@@ -876,12 +882,15 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * Note that both loading and saving of Values from and to the database are
  * disabled by default.
  *
+ * The `load` and `save` properties can be set to `true` to persist all Values,
+ * or to a DpcTabularValuesIn array to persist just a subset of Value Ids.
+ *
  * The 'Dpc' prefix indicates that this type is used within the
  * DatabasePersisterConfig type.
  * @example
  * When applied to a database Persister, this DatabasePersisterConfig will load
- * and save the data of a Store's Values into a database
- * table called 'my_tinybase_values'.
+ * and save the data of two Store Values into a database table called
+ * 'my_tinybase_values'.
  *
  * ```js
  * import type {DatabasePersisterConfig} from 'tinybase';
@@ -889,8 +898,8 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * export const databasePersisterConfig: DatabasePersisterConfig = {
  *   mode: 'tabular',
  *   values: {
- *     load: true,
- *     save: true,
+ *     load: ['selectedPet', 'open'],
+ *     save: ['selectedPet', 'open'],
  *     tableName: 'my_tinybase_values',
  *   },
  * };
@@ -898,19 +907,23 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * @category Configuration
  * @since v4.0.0
  */
-export type DpcTabularValues = {
+export type DpcTabularValues<
+  Schema extends OptionalValuesSchema = OptionalValuesSchema,
+> = {
   /**
-   * Whether Store Values will be loaded from a database table.
+   * Whether Store Values will be loaded from a database table, or the subset of
+   * Value Ids that will be loaded.
    * @category Configuration
    * @since v4.0.0
    */
-  load?: boolean;
+  load?: boolean | DpcTabularValuesIn<Schema>;
   /**
-   * Whether Store Values will be saved to a database table.
+   * Whether Store Values will be saved to a database table, or the subset of
+   * Value Ids that will be saved.
    * @category Configuration
    * @since v4.0.0
    */
-  save?: boolean;
+  save?: boolean | DpcTabularValuesIn<Schema>;
   /**
    * The optional name of the database table from and to which the Store Values
    * should be loaded or saved, defaulting to `tinybase_values`.
@@ -920,6 +933,29 @@ export type DpcTabularValues = {
   tableName?: string;
 };
 
+/**
+ * The DpcTabularValuesIn type describes the subset of Store Values that are
+ * persisted by the DpcTabularValues type.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Id[];
+ * ```
+ *
+ * When used as the DpcTabularValues `load` or `save` property, only the listed
+ * Value Ids will be loaded from or saved to the database table. Unlisted
+ * database columns are ignored on load and left untouched on save.
+ *
+ * The 'Dpc' prefix indicates that this type is used within the
+ * DatabasePersisterConfig type.
+ * @category Configuration
+ * @since v9.0.0
+ */
+export type DpcTabularValuesIn<
+  Schema extends OptionalValuesSchema = OptionalValuesSchema,
+> = ValueIdFromSchema<Schema>[];
+
 /**
  * A Persister object lets you save and load Store data to and from different
  * locations, or underlying storage types.

package/@types/queries/index.d.ts

@@ -42,13 +42,7 @@ import type {
  * @since v7.2.0
  */
 export type ParamValue =
-  | string
-  | number
-  | boolean
-  | null
-  | string[]
-  | number[]
-  | boolean[];
+  string | number | boolean | null | string[] | number[] | boolean[];
 
 /**
  * The ParamValues type describes an object of param values, keyed by param Id,

package/@types/queries/with-schemas/index.d.ts

@@ -53,13 +53,7 @@ import type {
  * @since v7.2.0
  */
 export type ParamValue =
-  | string
-  | number
-  | boolean
-  | null
-  | string[]
-  | number[]
-  | boolean[];
+  string | number | boolean | null | string[] | number[] | boolean[];
 
 /**
  * The ParamValues type describes an object of param values, keyed by param Id,
@@ -1482,8 +1476,7 @@ export type Join<
    */
   <
     IntermediateJoinedTableId extends TableIdFromSchema<Schema> | Id =
-      | TableIdFromSchema<Schema>
-      | Id,
+      TableIdFromSchema<Schema> | Id,
     IntermediateJoinedCellId extends JoinedCellIdOrId<
       Schema,
       IntermediateJoinedTableId
@@ -1511,8 +1504,7 @@ export type Join<
    */
   <
     IntermediateJoinedTableId extends TableIdFromSchema<Schema> | Id =
-      | TableIdFromSchema<Schema>
-      | Id,
+      TableIdFromSchema<Schema> | Id,
     IntermediateJoinedCellId extends JoinedCellIdOrId<
       Schema,
       IntermediateJoinedTableId
@@ -1542,8 +1534,7 @@ export type Join<
    */
   <
     IntermediateJoinedTableId extends TableIdFromSchema<Schema> | Id =
-      | TableIdFromSchema<Schema>
-      | Id,
+      TableIdFromSchema<Schema> | Id,
   >(
     joinedTableId: TableIdFromSchema<Schema>,
     fromIntermediateJoinedTableId: IntermediateJoinedTableId,
@@ -1576,8 +1567,7 @@ export type Join<
    */
   <
     IntermediateJoinedTableId extends TableIdFromSchema<Schema> | Id =
-      | TableIdFromSchema<Schema>
-      | Id,
+      TableIdFromSchema<Schema> | Id,
   >(
     asQuery: true,
     joinedQueryId: Id,

package/@types/store/index.d.ts

@@ -1521,8 +1521,7 @@ export type InvalidValues = {[valueId: Id]: any[]};
 export type Changes = [
   changedTables: {
     [tableId: Id]:
-      | {[rowId: Id]: {[cellId: Id]: CellOrUndefined} | undefined}
-      | undefined;
+      {[rowId: Id]: {[cellId: Id]: CellOrUndefined} | undefined} | undefined;
   },
   changedValues: {[valueId: Id]: ValueOrUndefined},
   isChanges: 1,

package/@types/store/with-schemas/index.d.ts

@@ -711,9 +711,8 @@ export type ValueCallback<
   Schema extends OptionalValuesSchema,
   Params extends any[] = ValueIdFromSchema<Schema> extends infer ValueId
     ? ValueId extends ValueIdFromSchema<Schema>
-      ?
-          | [valueId: ValueId, value: Value<Schema, ValueId>]
-          | [valueId: never, value: never]
+      ? | [valueId: ValueId, value: Value<Schema, ValueId>]
+        | [valueId: never, value: never]
       : never
     : never,
   Params2 extends any[] = Params | [valueId: never, value: never],
@@ -957,8 +956,7 @@ export type SortedRowIdsArgs<
   Schema extends OptionalTablesSchema,
   TableId extends TableIdFromSchema<Schema>,
   CellIdOrUndefined extends CellIdFromSchema<Schema, TableId> | undefined =
-    | CellIdFromSchema<Schema, TableId>
-    | undefined,
+    CellIdFromSchema<Schema, TableId> | undefined,
 > = {
   /**
    * The Id of the Table in the Store, required.
@@ -1246,8 +1244,7 @@ export type TableCellIdsListener<
       : never
     : never,
   Params3 extends any[] =
-    | Params
-    | [store: never, tableId: never, getIdChanges: never],
+    Params | [store: never, tableId: never, getIdChanges: never],
   Params2 extends any[] = Truncate<Params3>,
   // Params1 extends any[] = Truncate<Params2>,
 > = Params extends any
@@ -1314,8 +1311,7 @@ export type HasTableCellListener<
       : never
     : never,
   Params4 extends any[] =
-    | Params
-    | [store: never, tableId: never, cellId: never, hasTableCell: never],
+    Params | [store: never, tableId: never, cellId: never, hasTableCell: never],
   Params3 extends any[] = Truncate<Params4>,
   //  Params2 extends any[] = Truncate<Params3>,
   // Params1 extends any[] = Truncate<Params2>,
@@ -1595,8 +1591,7 @@ export type CellIdsListener<
       : never
     : never,
   Params4 extends any[] =
-    | Params
-    | [store: never, tableId: never, rowId: never, getIdChanges: never],
+    Params | [store: never, tableId: never, rowId: never, getIdChanges: never],
   Params3 extends any[] = Truncate<Params4>,
   // Params2 extends any[] = Truncate<Params3>,
   // Params1 extends any[] = Truncate<Params2>,
@@ -1783,11 +1778,10 @@ export type CellListener<
   // Params2 extends any[] = Truncate<Params3>,
   // Params1 extends any[] = Truncate<Params2>,
 > = Params extends any
-  ?
-      | ((...params: Params7) => void)
-      | ((...params: Params6) => void)
-      | ((...params: Params5) => void)
-      | ((...params: Params4) => void)
+  ? | ((...params: Params7) => void)
+    | ((...params: Params6) => void)
+    | ((...params: Params5) => void)
+    | ((...params: Params4) => void)
   : // The unions may no longer be discriminatory with fewer parameters, and
     // TypeScript fails to resolve callback signatures in some cases.
     // | ((...params: Params3) => void)
@@ -2002,11 +1996,10 @@ export type ValueListener<
   Params2 extends any[] = Truncate<Params3>,
   //  Params1 extends any[] = Truncate<Params2>,
 > = Params extends any
-  ?
-      | ((...params: Params5) => void)
-      | ((...params: Params4) => void)
-      | ((...params: Params3) => void)
-      | ((...params: Params2) => void)
+  ? | ((...params: Params5) => void)
+    | ((...params: Params4) => void)
+    | ((...params: Params3) => void)
+    | ((...params: Params2) => void)
   : // | ((...params: Params1) => void)
     never;
 
@@ -2411,8 +2404,7 @@ export type InvalidValues = {[valueId: Id]: any[]};
  * [
  *   changedTables: {
  *     [tableId: Id]:
- *       | {[rowId: Id]: {[cellId: Id]: CellOrUndefined} | undefined}
- *       | undefined;
+ *       {[rowId: Id]: {[cellId: Id]: CellOrUndefined} | undefined} | undefined;
  *   },
  *   changedValues: {[valueId: Id]: ValueOrUndefined},
  *   isChanges: 1,
@@ -2470,10 +2462,9 @@ export type Changes<Schemas extends OptionalSchemas> = [
       | {
           [rowId: Id]:
             | {
-                [CellId in CellIdFromSchema<
-                  Schemas[0],
-                  TableId
-                >]?: CellOrUndefined<Schemas[0], TableId, CellId>;
+                [
+                  CellId in CellIdFromSchema<Schemas[0], TableId>
+                ]?: CellOrUndefined<Schemas[0], TableId, CellId>;
               }
             | undefined;
         }
@@ -4601,8 +4592,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     rowId: Id,
     cellId: CellId,
     cell:
-      | Cell<Schemas[0], TableId, CellId>
-      | MapCell<Schemas[0], TableId, CellId>,
+      Cell<Schemas[0], TableId, CellId> | MapCell<Schemas[0], TableId, CellId>,
   ): this;
 
   /**

package/@types/synchronizers/synchronizer-ws-client/index.d.ts

@@ -79,7 +79,9 @@ export interface WsSynchronizer<
  * via WebSockets facilitated by a WsServer.
  *
  * As well as providing a reference to the MergeableStore to persist, you must
- * provide a configured WebSocket to send synchronization messages over.
+ * provide a configured WebSocket to send synchronization messages over. The
+ * path in the WebSocket URL is used by a WsServer as the path that the client
+ * joins. The MergeableStore Id does not select the server path.
  *
  * Instead of the raw browser implementation of WebSocket, you may prefer to use
  * the [Reconnecting
@@ -107,6 +109,9 @@ export interface WsSynchronizer<
  * @param onIgnoredError An optional handler for the errors that the
  * Synchronizer would otherwise ignore when trying to synchronize data. This is
  * suitable for debugging synchronization issues in a development environment.
+ * @param fragmentSize An optional maximum size for each WebSocket message
+ * fragment. When set, larger synchronization payloads are split into fragments
+ * and reassembled by the receiving WsSynchronizer, since v9.0.
  * @returns A reference to the new WsSynchronizer object.
  * @example
  * This example creates two WsSynchronizer objects to synchronize one
@@ -125,11 +130,11 @@ export interface WsSynchronizer<
  *
  * const synchronizer1 = await createWsSynchronizer(
  *   store1,
- *   new WebSocket('ws://localhost:8047'),
+ *   new WebSocket('ws://localhost:8047/petShop'),
  * );
  * const synchronizer2 = await createWsSynchronizer(
  *   store2,
- *   new WebSocket('ws://localhost:8047'),
+ *   new WebSocket('ws://localhost:8047/petShop'),
  * );
  *
  * await synchronizer1.startSync();
@@ -159,4 +164,5 @@ export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
   onSend?: Send,
   onReceive?: Receive,
   onIgnoredError?: (error: any) => void,
+  fragmentSize?: number,
 ): Promise<WsSynchronizer<WebSocketType>>;

package/@types/synchronizers/synchronizer-ws-client/with-schemas/index.d.ts

@@ -90,11 +90,14 @@ export interface WsSynchronizer<
  *   onSend?: Send,
  *   onReceive?: Receive,
  *   onIgnoredError?: (error: any) => void,
+ *   fragmentSize?: number,
  * ): Promise<WsSynchronizer<WebSocketType>>;
  * ```
  *
  * As well as providing a reference to the MergeableStore to persist, you must
- * provide a configured WebSocket to send synchronization messages over.
+ * provide a configured WebSocket to send synchronization messages over. The
+ * path in the WebSocket URL is used by a WsServer as the path that the client
+ * joins. The MergeableStore Id does not select the server path.
  *
  * Instead of the raw browser implementation of WebSocket, you may prefer to use
  * the [Reconnecting
@@ -122,6 +125,9 @@ export interface WsSynchronizer<
  * @param onIgnoredError An optional handler for the errors that the
  * Synchronizer would otherwise ignore when trying to synchronize data. This is
  * suitable for debugging synchronization issues in a development environment.
+ * @param fragmentSize An optional maximum size for each WebSocket message
+ * fragment. When set, larger synchronization payloads are split into fragments
+ * and reassembled by the receiving WsSynchronizer, since v9.0.
  * @returns A reference to the new WsSynchronizer object.
  * @example
  * This example creates two WsSynchronizer objects to synchronize one
@@ -140,11 +146,11 @@ export interface WsSynchronizer<
  *
  * const synchronizer1 = await createWsSynchronizer(
  *   store1,
- *   new WebSocket('ws://localhost:8047'),
+ *   new WebSocket('ws://localhost:8047/petShop'),
  * );
  * const synchronizer2 = await createWsSynchronizer(
  *   store2,
- *   new WebSocket('ws://localhost:8047'),
+ *   new WebSocket('ws://localhost:8047/petShop'),
  * );
  *
  * await synchronizer1.startSync();
@@ -177,4 +183,5 @@ export function createWsSynchronizer<
   onSend?: Send,
   onReceive?: Receive,
   onIgnoredError?: (error: any) => void,
+  fragmentSize?: number,
 ): Promise<WsSynchronizer<Schemas, WebSocketType>>;