tinybase 9.4.0-beta.0 → 9.4.0-beta.2

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

@@ -1340,6 +1340,10 @@ export interface Persister<Persist extends Persists = Persists.StoreOnly> {
    * This simply runs the startAutoLoad and startAutoSave methods in sequence,
    * and returns a Promise that resolves when both have completed.
    *
+   * If the second method fails after either half has partially started, both
+   * halves are stopped again before this method rejects. The original startup
+   * error is preserved if that cleanup also fails.
+   *
    * This method can take `initialContent` to pass to the startAutoLoad method.
    * See its documentation for more details.
    *

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

@@ -78,8 +78,15 @@ export type DpcFragmented = {
    * This is useful when you have multiple stores or applications sharing the
    * same Durable Object SQL storage and want to avoid table name conflicts.
    *
-   * The prefix will be sanitized to only include alphanumeric characters and
-   * underscores. For example, a prefix of 'my-app!' becomes 'my_app_'.
+   * Empty prefixes and those containing only lower-case ASCII letters, digits,
+   * and underscores are used as-is. Other prefixes are encoded so that distinct
+   * prefixes cannot resolve to the same tables, including under SQLite's
+   * case-insensitive identifier rules.
+   *
+   * Tables created for prefixes that are now encoded, including uppercase
+   * prefixes and those previously changed by lossy sanitization, are not copied
+   * automatically because their names may legitimately belong to another
+   * prefix. Migrate those tables explicitly before using the new prefix.
    * @example
    * This example shows a configuration using the storagePrefix setting. With a
    * `storagePrefix` of 'user_data_', it creates `user_data_tinybase_tables` and

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

@@ -86,8 +86,15 @@ export type DpcFragmented = {
    * This is useful when you have multiple stores or applications sharing the
    * same Durable Object SQL storage and want to avoid table name conflicts.
    *
-   * The prefix will be sanitized to only include alphanumeric characters and
-   * underscores. For example, a prefix of 'my-app!' becomes 'my_app_'.
+   * Empty prefixes and those containing only lower-case ASCII letters, digits,
+   * and underscores are used as-is. Other prefixes are encoded so that distinct
+   * prefixes cannot resolve to the same tables, including under SQLite's
+   * case-insensitive identifier rules.
+   *
+   * Tables created for prefixes that are now encoded, including uppercase
+   * prefixes and those previously changed by lossy sanitization, are not copied
+   * automatically because their names may legitimately belong to another
+   * prefix. Migrate those tables explicitly before using the new prefix.
    * @example
    * This example shows a configuration using the storagePrefix setting. With a
    * `storagePrefix` of 'user_data_', it creates `user_data_tinybase_tables` and

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

@@ -1461,6 +1461,10 @@ export interface Persister<
    * This simply runs the startAutoLoad and startAutoSave methods in sequence,
    * and returns a Promise that resolves when both have completed.
    *
+   * If the second method fails after either half has partially started, both
+   * halves are stopped again before this method rejects. The original startup
+   * error is preserved if that cleanup also fails.
+   *
    * This method can take `initialContent` to pass to the startAutoLoad method.
    * See its documentation for more details.
    *

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

@@ -1011,6 +1011,142 @@ export type Select = {
   ): SelectedAs;
 };
 
+/**
+ * The CellIdMapper type describes a function used by a SelectAll clause to map
+ * a source Cell Id to a Cell Id in the query result.
+ * @param cellId The Id of a Cell in the source Row.
+ * @returns The Id to use for that Cell in the result Row.
+ * @category Callback
+ * @since v9.4.0
+ */
+export type CellIdMapper = (cellId: Id) => Id;
+
+/**
+ * The SelectAll type describes a function that lets you select every Cell
+ * present in a source Row.
+ *
+ * The SelectAll function is provided to the third `query` parameter of the
+ * setQueryDefinition method. Different source Rows can contain different Cell
+ * Ids, and each result Row will contain only the Cells present in its
+ * corresponding source Row. The result Table's Cell Ids are therefore the union
+ * of the Cells in its result Rows.
+ *
+ * Source Cell Ids are processed in lexical order, and selection clauses are
+ * processed in the order they are declared. If multiple selected Cells map to
+ * the same result Cell Id, the later one wins.
+ *
+ * When used in a grouped query, the current table-wide union of source Cell Ids
+ * is expanded into individual selections. The query is rebuilt if this union
+ * changes, and any selected Cell that is not grouped becomes a grouping
+ * dimension as usual.
+ *
+ * A cycle between query results is allowed when every SelectAll clause retains
+ * its source Cell Ids. A prefix or CellIdMapper callback in such a cycle is
+ * rejected because it could expand Cell Ids indefinitely.
+ * @category Definition
+ * @since v9.4.0
+ */
+export type SelectAll = {
+  /**
+   * Calling this function with no parameters will select every Cell present in
+   * each Row of the query's root Table, retaining the source Cell Ids.
+   * @example
+   * This example selects all the Cells from heterogeneous root Rows:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', color: 'brown'},
+   *   felix: {species: 'cat', indoor: true},
+   * });
+   * const queries = createQueries(store);
+   *
+   * queries.setQueryDefinition('query', 'pets', ({selectAll}) => selectAll());
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {color: 'brown', species: 'dog'}
+   * console.log(queries.getResultRow('query', 'felix'));
+   * // -> {indoor: true, species: 'cat'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  (): void;
+  /**
+   * Calling this function with a joined Table Id will select every Cell present
+   * in the joined Row.
+   *
+   * An optional second parameter can map each Cell Id with a prefix or
+   * callback.
+   * @param joinedTableId The Id of the joined Table. If the Table was joined
+   * 'as' a different Id, that should instead be used.
+   * @param cellIdPrefixOrMapper An optional prefix to prepend to every Cell Id,
+   * or a CellIdMapper callback that returns each result Cell Id.
+   * @example
+   * This example selects all the Cells from a joined Table, retaining their
+   * Cell Ids:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore()
+   *   .setTable('pets', {fido: {ownerId: '1'}})
+   *   .setTable('owners', {'1': {name: 'Alice', city: 'London'}});
+   * const queries = createQueries(store);
+   *
+   * queries.setQueryDefinition('query', 'pets', ({selectAll, join}) => {
+   *   selectAll('owners');
+   *   join('owners', 'ownerId');
+   * });
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {city: 'London', name: 'Alice'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  (joinedTableId: Id, cellIdPrefixOrMapper?: Id | CellIdMapper): void;
+  /**
+   * Calling this function with `true` and a joined query Id will select every
+   * Cell present in the joined result Row.
+   *
+   * An optional third parameter can map each Cell Id with a prefix or callback.
+   * @param asQuery A flag indicating that the next Id is a query Id.
+   * @param joinedQueryId The Id of the joined query result. If the query result
+   * was joined 'as' a different Id, that should instead be used.
+   * @param cellIdPrefixOrMapper An optional prefix to prepend to every Cell Id,
+   * or a CellIdMapper callback that returns each result Cell Id.
+   * @example
+   * This example selects all the Cells from a joined query result, prefixing
+   * each Cell Id:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore()
+   *   .setTable('pets', {fido: {ownerId: '1'}})
+   *   .setTable('owners', {'1': {name: 'Alice', city: 'London'}});
+   * const queries = createQueries(store)
+   *   .setQueryDefinition('owners', 'owners', ({selectAll}) => selectAll())
+   *   .setQueryDefinition('query', 'pets', ({selectAll, join}) => {
+   *     selectAll(true, 'owners', 'owner.');
+   *     join(true, 'owners', 'ownerId');
+   *   });
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {'owner.city': 'London', 'owner.name': 'Alice'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  (
+    asQuery: true,
+    joinedQueryId: Id,
+    cellIdPrefixOrMapper?: Id | CellIdMapper,
+  ): void;
+};
+
 /**
  * The SelectedAs type describes an object returned from calling a Select
  * function so that the selected Cell Id can be optionally aliased.
@@ -1257,8 +1393,8 @@ export type Join = {
   (joinedTableId: Id, on: Id): JoinedAs;
   /**
    * Calling this function with three parameters (where the first is `true`)
-   * will indicate that the join to a Row in an adjacent query result is made
-   * by finding its Id in a Cell of the query's root Table.
+   * will indicate that the join to a Row in an adjacent query result is made by
+   * finding its Id in a Cell of the query's root Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the query result to join to.
    * @param on The Id of the Cell in the root Table that contains the joined
@@ -1323,8 +1459,8 @@ export type Join = {
    */
   (joinedTableId: Id, fromIntermediateJoinedTableId: Id, on: Id): JoinedAs;
   /**
-   * Calling this function with four parameters (where the first is `true`)
-   * will indicate that the join to a Row in a distant query result is made by
+   * Calling this function with four parameters (where the first is `true`) will
+   * indicate that the join to a Row in a distant query result is made by
    * finding its Id in a Cell of an intermediately joined Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the distant query result to join to.
@@ -1371,9 +1507,9 @@ export type Join = {
   ): JoinedAs;
   /**
    * Calling this function with four parameters (where the first is `true` and
-   * the fourth is a function) will indicate that the join to a Row in a
-   * distant query result is made by calculating its Id from the Cells and the
-   * Row Id of an intermediately joined Table.
+   * the fourth is a function) will indicate that the join to a Row in a distant
+   * query result is made by calculating its Id from the Cells and the Row Id of
+   * an intermediately joined Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the query result to join to.
    * @param fromIntermediateJoinedTableId The Id of an intermediate Table (which
@@ -2102,6 +2238,7 @@ export interface Queries {
     tableId: Id,
     query: (keywords: {
       select: Select;
+      selectAll: SelectAll;
       join: Join;
       where: Where;
       group: Group;
@@ -2116,6 +2253,7 @@ export interface Queries {
     rootQueryId: Id,
     query: (keywords: {
       select: Select;
+      selectAll: SelectAll;
       join: Join;
       where: Where;
       group: Group;

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

@@ -1158,6 +1158,152 @@ export type Select<
   ): SelectedAs;
 };
 
+/**
+ * The CellIdMapper type describes a function used by a SelectAll clause to map
+ * a source Cell Id to a Cell Id in the query result.
+ * @param cellId The Id of a Cell in the source Row.
+ * @returns The Id to use for that Cell in the result Row.
+ * @category Callback
+ * @since v9.4.0
+ */
+export type CellIdMapper<CellId extends Id = Id> = (cellId: CellId) => Id;
+
+/**
+ * The SelectAll type describes a function that lets you select every Cell
+ * present in a source Row.
+ *
+ * The SelectAll function is provided to the third `query` parameter of the
+ * setQueryDefinition method. Different source Rows can contain different Cell
+ * Ids, and each result Row will contain only the Cells present in its
+ * corresponding source Row. The result Table's Cell Ids are therefore the union
+ * of the Cells in its result Rows.
+ *
+ * Source Cell Ids are processed in lexical order, and selection clauses are
+ * processed in the order they are declared. If multiple selected Cells map to
+ * the same result Cell Id, the later one wins.
+ *
+ * When used in a grouped query, the current table-wide union of source Cell Ids
+ * is expanded into individual selections. The query is rebuilt if this union
+ * changes, and any selected Cell that is not grouped becomes a grouping
+ * dimension as usual.
+ *
+ * A cycle between query results is allowed when every SelectAll clause retains
+ * its source Cell Ids. A prefix or CellIdMapper callback in such a cycle is
+ * rejected because it could expand Cell Ids indefinitely.
+ * @category Definition
+ * @since v9.4.0
+ */
+export type SelectAll<Schema extends OptionalTablesSchema> = {
+  /**
+   * Calling this function with no parameters will select every Cell present in
+   * each Row of the query's root Table, retaining the source Cell Ids.
+   * @example
+   * This example selects all the Cells from heterogeneous root Rows:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', color: 'brown'},
+   *   felix: {species: 'cat', indoor: true},
+   * });
+   * const queries = createQueries(store);
+   *
+   * queries.setQueryDefinition('query', 'pets', ({selectAll}) => selectAll());
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {color: 'brown', species: 'dog'}
+   * console.log(queries.getResultRow('query', 'felix'));
+   * // -> {indoor: true, species: 'cat'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  (): void;
+  /**
+   * Calling this function with a joined Table Id will select every Cell present
+   * in the joined Row.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * (joinedTableId: Id, cellIdPrefixOrMapper?: Id | CellIdMapper): void;
+   * ```
+   *
+   * An optional second parameter can map each Cell Id with a prefix or
+   * callback.
+   * @param joinedTableId The Id of the joined Table. If the Table was joined
+   * 'as' a different Id, that should instead be used.
+   * @param cellIdPrefixOrMapper An optional prefix to prepend to every Cell Id,
+   * or a CellIdMapper callback that returns each result Cell Id.
+   * @example
+   * This example selects all the Cells from a joined Table, retaining their
+   * Cell Ids:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore()
+   *   .setTable('pets', {fido: {ownerId: '1'}})
+   *   .setTable('owners', {'1': {name: 'Alice', city: 'London'}});
+   * const queries = createQueries(store);
+   *
+   * queries.setQueryDefinition('query', 'pets', ({selectAll, join}) => {
+   *   selectAll('owners');
+   *   join('owners', 'ownerId');
+   * });
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {city: 'London', name: 'Alice'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  <JoinedTableId extends TableIdFromSchema<Schema> | Id>(
+    joinedTableId: JoinedTableId,
+    cellIdPrefixOrMapper?:
+      Id | CellIdMapper<JoinedCellIdOrId<Schema, JoinedTableId>>,
+  ): void;
+  /**
+   * Calling this function with `true` and a joined query Id will select every
+   * Cell present in the joined result Row.
+   *
+   * An optional third parameter can map each Cell Id with a prefix or callback.
+   * @param asQuery A flag indicating that the next Id is a query Id.
+   * @param joinedQueryId The Id of the joined query result. If the query result
+   * was joined 'as' a different Id, that should instead be used.
+   * @param cellIdPrefixOrMapper An optional prefix to prepend to every Cell Id,
+   * or a CellIdMapper callback that returns each result Cell Id.
+   * @example
+   * This example selects all the Cells from a joined query result, prefixing
+   * each Cell Id:
+   *
+   * ```js
+   * import {createQueries, createStore} from 'tinybase';
+   *
+   * const store = createStore()
+   *   .setTable('pets', {fido: {ownerId: '1'}})
+   *   .setTable('owners', {'1': {name: 'Alice', city: 'London'}});
+   * const queries = createQueries(store)
+   *   .setQueryDefinition('owners', 'owners', ({selectAll}) => selectAll())
+   *   .setQueryDefinition('query', 'pets', ({selectAll, join}) => {
+   *     selectAll(true, 'owners', 'owner.');
+   *     join(true, 'owners', 'ownerId');
+   *   });
+   *
+   * console.log(queries.getResultRow('query', 'fido'));
+   * // -> {'owner.city': 'London', 'owner.name': 'Alice'}
+   * ```
+   * @category Definition
+   * @since v9.4.0
+   */
+  (
+    asQuery: true,
+    joinedQueryId: Id,
+    cellIdPrefixOrMapper?: Id | CellIdMapper,
+  ): void;
+};
+
 /**
  * The SelectedAs type describes an object returned from calling a Select
  * function so that the selected Cell Id can be optionally aliased.
@@ -1410,8 +1556,8 @@ export type Join<
   ): JoinedAs;
   /**
    * Calling this function with three parameters (where the first is `true`)
-   * will indicate that the join to a Row in an adjacent query result is made
-   * by finding its Id in a Cell of the query's root Table.
+   * will indicate that the join to a Row in an adjacent query result is made by
+   * finding its Id in a Cell of the query's root Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the query result to join to.
    * @param on The Id of the Cell in the root Table that contains the joined
@@ -1491,8 +1637,8 @@ export type Join<
     on: IntermediateJoinedCellId,
   ): JoinedAs;
   /**
-   * Calling this function with four parameters (where the first is `true`)
-   * will indicate that the join to a Row in a distant query result is made by
+   * Calling this function with four parameters (where the first is `true`) will
+   * indicate that the join to a Row in a distant query result is made by
    * finding its Id in a Cell of an intermediately joined Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the distant query result to join to.
@@ -1553,9 +1699,9 @@ export type Join<
   ): JoinedAs;
   /**
    * Calling this function with four parameters (where the first is `true` and
-   * the fourth is a function) will indicate that the join to a Row in a
-   * distant query result is made by calculating its Id from the Cells and the
-   * Row Id of an intermediately joined Table.
+   * the fourth is a function) will indicate that the join to a Row in a distant
+   * query result is made by calculating its Id from the Cells and the Row Id of
+   * an intermediately joined Table.
    * @param asQuery A flag indicating that the next Id is a query Id.
    * @param joinedQueryId The Id of the query result to join to.
    * @param fromIntermediateJoinedTableId The Id of an intermediate Table (which
@@ -2256,6 +2402,7 @@ export interface Queries<in out Schemas extends OptionalSchemas> {
    *   tableId: Id,
    *   query: (keywords: {
    *     select: Select;
+   *     selectAll: SelectAll;
    *     join: Join;
    *     where: Where;
    *     group: Group;
@@ -2270,6 +2417,7 @@ export interface Queries<in out Schemas extends OptionalSchemas> {
    *   rootQueryId: Id,
    *   query: (keywords: {
    *     select: Select;
+   *     selectAll: SelectAll;
    *     join: Join;
    *     where: Where;
    *     group: Group;
@@ -2348,6 +2496,7 @@ export interface Queries<in out Schemas extends OptionalSchemas> {
     tableId: RootTableId,
     query: (keywords: {
       select: Select<Schemas[0], RootTableId>;
+      selectAll: SelectAll<Schemas[0]>;
       join: Join<Schemas[0], RootTableId>;
       where: Where<Schemas[0], RootTableId>;
       group: Group;
@@ -2362,6 +2511,7 @@ export interface Queries<in out Schemas extends OptionalSchemas> {
     rootQueryId: Id,
     query: (keywords: {
       select: Select<any, any>;
+      selectAll: SelectAll<any>;
       join: Join<any, any>;
       where: Where<any, any>;
       group: Group;

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

@@ -177,7 +177,9 @@ export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
    * Construct the WebSocket with the `tinybase` subprotocol and provide a
    * channel Id as the third argument. The channel Id is appended to the
    * WebSocket URL path to form the server path; it is not taken from the
-   * MergeableStore Id.
+   * MergeableStore Id. It can contain at most 1,024 UTF-8 bytes, and one shared
+   * WebSocket can have at most 100 channels. Creating a 101st channel is
+   * rejected without closing the existing shared WebSocket.
    *
    * Destroying the WsSynchronizer unsubscribes its channel. The shared
    * WebSocket is closed only when the last WsSynchronizer using it is
@@ -188,8 +190,10 @@ export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
    * later. It is not supported by WsServerDurableObject.
    * @param store The MergeableStore to synchronize.
    * @param webSocket The shared WebSocket to send synchronization messages
-   * over, constructed with the `tinybase` subprotocol.
-   * @param channelId The channel Id to append to the WebSocket URL path.
+   * over, constructed with the `tinybase` subprotocol and shared by at most 100
+   * channels.
+   * @param channelId The channel Id to append to the WebSocket URL path, with
+   * at most 1,024 UTF-8 bytes.
    * @param requestTimeoutSeconds An optional time in seconds that the
    * Synchronizer will wait for responses to request messages, defaulting to 1.
    * @param onSend An optional handler for the messages that this Synchronizer

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

@@ -211,7 +211,9 @@ export function createWsSynchronizer<
    * Construct the WebSocket with the `tinybase` subprotocol and provide a
    * channel Id as the third argument. The channel Id is appended to the
    * WebSocket URL path to form the server path; it is not taken from the
-   * MergeableStore Id.
+   * MergeableStore Id. It can contain at most 1,024 UTF-8 bytes, and one shared
+   * WebSocket can have at most 100 channels. Creating a 101st channel is
+   * rejected without closing the existing shared WebSocket.
    *
    * Destroying the WsSynchronizer unsubscribes its channel. The shared
    * WebSocket is closed only when the last WsSynchronizer using it is
@@ -222,8 +224,10 @@ export function createWsSynchronizer<
    * later. It is not supported by WsServerDurableObject.
    * @param store The MergeableStore to synchronize.
    * @param webSocket The shared WebSocket to send synchronization messages
-   * over, constructed with the `tinybase` subprotocol.
-   * @param channelId The channel Id to append to the WebSocket URL path.
+   * over, constructed with the `tinybase` subprotocol and shared by at most 100
+   * channels.
+   * @param channelId The channel Id to append to the WebSocket URL path, with
+   * at most 1,024 UTF-8 bytes.
    * @param requestTimeoutSeconds An optional time in seconds that the
    * Synchronizer will wait for responses to request messages, defaulting to 1.
    * @param onSend An optional handler for the messages that this Synchronizer

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

@@ -519,7 +519,11 @@ export interface WsServer {
  * Since v9.3, multiple WsSynchronizer instances can share one WebSocket by
  * using channel Ids. Each channel Id is appended to the WebSocket URL path and
  * treated as an ordinary server path. This means a multiplexed channel can
- * interoperate with legacy clients connected directly to that full path.
+ * interoperate with legacy clients connected directly to that full path. A
+ * channel Id can contain at most 1,024 UTF-8 bytes, and each multiplexed
+ * WebSocket can have at most 100 subscribed channels. Pending setup and
+ * teardown resources are also bounded. Fragment reassembly and traffic
+ * buffered while paths start share limits across the physical WebSocket.
  *
  * The WsServer does not authenticate or authorize URL paths or channel Ids.
  * Once a client WebSocket is accepted on a base path, it can subscribe to any
@@ -608,7 +612,7 @@ export interface WsServer {
  * client connects, it picks up the data the previous two were using.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -616,6 +620,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) =>
@@ -679,7 +684,7 @@ export interface WsServer {
  * data once synchronization has started.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -687,6 +692,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) => [

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

@@ -548,7 +548,11 @@ export interface WsServer {
  * Since v9.3, multiple WsSynchronizer instances can share one WebSocket by
  * using channel Ids. Each channel Id is appended to the WebSocket URL path and
  * treated as an ordinary server path. This means a multiplexed channel can
- * interoperate with legacy clients connected directly to that full path.
+ * interoperate with legacy clients connected directly to that full path. A
+ * channel Id can contain at most 1,024 UTF-8 bytes, and each multiplexed
+ * WebSocket can have at most 100 subscribed channels. Pending setup and
+ * teardown resources are also bounded. Fragment reassembly and traffic
+ * buffered while paths start share limits across the physical WebSocket.
  *
  * The WsServer does not authenticate or authorize URL paths or channel Ids.
  * Once a client WebSocket is accepted on a base path, it can subscribe to any
@@ -637,7 +641,7 @@ export interface WsServer {
  * client connects, it picks up the data the previous two were using.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -645,6 +649,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) =>
@@ -708,7 +713,7 @@ export interface WsServer {
  * data once synchronization has started.
  *
  * ```js
- * import {rmSync} from 'fs';
+ * import {mkdirSync, rmSync} from 'fs';
  * import {createMergeableStore} from 'tinybase';
  * import {createFilePersister} from 'tinybase/persisters/persister-file';
  * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
@@ -716,6 +721,7 @@ export interface WsServer {
  * import {WebSocket, WebSocketServer} from 'ws';
  *
  * // Server
+ * mkdirSync('./tmp', {recursive: true});
  * const server = createWsServer(
  *   new WebSocketServer({port: 8047}),
  *   (pathId) => [

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

@@ -96,9 +96,12 @@ export interface WsServerSimple {
  * Since v9.3, it also supports multiple channel-based WsSynchronizer instances
  * sharing one WebSocket. Once a client WebSocket is accepted on a base path,
  * it can subscribe to any valid channel beneath that path: WsServerSimple does
- * not authenticate or authorize channel Ids. For untrusted clients, use a
- * separate authenticated WebSocket for each authorized path unless access to
- * all descendants is acceptable.
+ * not authenticate or authorize channel Ids. A channel Id can contain at most
+ * 1,024 UTF-8 bytes, and each multiplexed WebSocket can have at most 100
+ * subscribed channels. Pending channel cleanup is also bounded, and fragment
+ * reassembly limits are shared across the physical WebSocket. For untrusted
+ * clients, use a separate authenticated WebSocket for each authorized path
+ * unless access to all descendants is acceptable.
  * @param webSocketServer A WebSocketServer object from your server environment.
  * @returns A reference to the new WsServerSimple object.
  * @example

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

@@ -96,9 +96,12 @@ export interface WsServerSimple {
  * Since v9.3, it also supports multiple channel-based WsSynchronizer instances
  * sharing one WebSocket. Once a client WebSocket is accepted on a base path,
  * it can subscribe to any valid channel beneath that path: WsServerSimple does
- * not authenticate or authorize channel Ids. For untrusted clients, use a
- * separate authenticated WebSocket for each authorized path unless access to
- * all descendants is acceptable.
+ * not authenticate or authorize channel Ids. A channel Id can contain at most
+ * 1,024 UTF-8 bytes, and each multiplexed WebSocket can have at most 100
+ * subscribed channels. Pending channel cleanup is also bounded, and fragment
+ * reassembly limits are shared across the physical WebSocket. For untrusted
+ * clients, use a separate authenticated WebSocket for each authorized path
+ * unless access to all descendants is acceptable.
  * @param webSocketServer A WebSocketServer object from your server environment.
  * @returns A reference to the new WsServerSimple object.
  * @example