tinybase 6.2.1 → 6.3.1

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

@@ -0,0 +1,382 @@
+/**
+ * The persister-durable-object-sql-storage module of the TinyBase project lets
+ * you save and load Store data to and from Cloudflare Durable Object SQLite
+ * storage (in an appropriate environment).
+ *
+ * Cloudflare's SQLite storage backend for Durable Objects offers significantly
+ * better pricing compared to the key-value storage backend. The SQLite storage
+ * backend is Cloudflare's recommended storage option for new Durable Object
+ * namespaces.
+ *
+ * **Important:** Before using this persister, you must configure your Durable
+ * Object class to use SQLite storage by adding a migration to your
+ * `wrangler.toml` or `wrangler.json` configuration file. Use
+ * `new_sqlite_classes` in your migration configuration to enable SQLite storage
+ * for your Durable Object class.
+ *
+ * See [Cloudflare's
+ * documentation](https://developers.cloudflare.com/durable-objects/reference/durable-objects-migrations/)
+ * for more details.
+ * @see Cloudflare Durable Objects guide
+ * @see Persistence guides
+ * @packageDocumentation
+ * @module persister-durable-object-sql-storage
+ * @since v6.3.0
+ */
+import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.ts';
+import type {
+  OptionalSchemas,
+  Store,
+} from '../../../store/with-schemas/index.d.ts';
+import type {
+  DatabasePersisterConfig,
+  Persister,
+  Persists,
+} from '../../with-schemas/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.
+ * @example
+ * This example shows how to configure a DurableObjectSqlStoragePersister to use
+ * fragmented mode with a custom storage prefix.
+ *
+ * ```js yolo
+ * import {createMergeableStore} from 'tinybase';
+ * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+ * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+ *
+ * const config = {
+ *   mode: 'fragmented',
+ *   storagePrefix: 'my_app_',
+ * };
+ *
+ * export class MyDurableObject extends WsServerDurableObject {
+ *   createPersister() {
+ *     const store = createMergeableStore();
+ *     const persister = createDurableObjectSqlStoragePersister(
+ *       store,
+ *       this.ctx.storage.sql,
+ *       config,
+ *     );
+ *     return persister;
+ *   }
+ * }
+ * ```
+ * @category Configuration
+ * @since v6.3.0
+ */
+export type DpcFragmented = {
+  /**
+   * The mode property must be set to 'fragmented' to enable fragmented
+   * persistence mode.
+   * @category Configuration
+   * @since v6.3.0
+   */
+  mode: 'fragmented';
+  /**
+   * The storagePrefix property lets you specify an optional prefix for the
+   * database table names used in fragmented mode.
+   *
+   * 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_'.
+   * @example
+   * This example shows a configuration using the storagePrefix setting. With a
+   * `storagePrefix` of 'user_data_', it creates `user_data_tinybase_tables` and
+   * `user_data_tinybase_values` tables.
+   * ```json
+   * {
+   *   mode: 'fragmented',
+   *   storagePrefix: 'user_data_',
+   * };
+   * ```
+   * @category Configuration
+   * @since v6.3.0
+   */
+  storagePrefix?: string;
+};
+
+/**
+ * The DurableObjectSqlDatabasePersisterConfig type represents the union of all
+ * possible configuration types for a DurableObjectSqlStoragePersister.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * DpcJson | DpcFragmented;
+ * ```
+ *
+ * This allows the persister to support multiple persistence modes.
+ * - JSON mode (via DpcJson): Stores the entire Store as JSON in a single row.
+ * - Fragmented mode (via DpcFragmented): Stores each piece of data as separate
+ *   rows.
+ * @example
+ * These examples show some different configuration options.
+ * ```json
+ * // JSON mode (default)
+ * {
+ *   mode: 'json',
+ *   storeTableName: 'my_store',
+ * };
+ *
+ * // Fragmented mode
+ * {
+ *   mode: 'fragmented',
+ *   storagePrefix: 'app_',
+ * };
+ * ```
+ * @category Configuration
+ * @since v6.3.0
+ */
+export type DurableObjectSqlDatabasePersisterConfig<
+  Schemas extends OptionalSchemas,
+> = DatabasePersisterConfig<Schemas> | DpcFragmented;
+
+/**
+ * The DurableObjectSqlStoragePersister interface represents a Persister that
+ * lets you save and load Store data to and from Cloudflare Durable Object SQL
+ * storage.
+ *
+ * You should use the createDurableObjectSqlStoragePersister function to create
+ * a DurableObjectSqlStoragePersister object, most likely within the
+ * createPersister method of a WsServerDurableObject.
+ *
+ * It is a minor extension to the Persister interface and simply provides an
+ * extra getSqlStorage method for accessing a reference to the SQL storage that
+ * the Store is being persisted to.
+ * @category Persister
+ * @since v6.3.0
+ */
+export interface DurableObjectSqlStoragePersister<
+  Schemas extends OptionalSchemas,
+> extends Persister<Schemas, Persists.MergeableStoreOnly> {
+  /**
+   * The getSqlStorage method returns a reference to the SQL storage that the
+   * Store is being persisted to.
+   * @returns The reference to the SQL storage.
+   * @example
+   * This example creates a Persister object against a newly-created Store
+   * (within the createPersister method of a WsServerDurableObject instance) and
+   * then gets the SQL storage reference back out again.
+   *
+   * ```js yolo
+   * import {createMergeableStore} from 'tinybase';
+   * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+   * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+   *
+   * export class MyDurableObject extends WsServerDurableObject {
+   *   createPersister() {
+   *     const store = createMergeableStore();
+   *     const persister = createDurableObjectSqlStoragePersister(
+   *       store,
+   *       this.ctx.storage.sql,
+   *     );
+   *     console.log(persister.getSqlStorage() == this.ctx.storage.sql);
+   *     // -> true
+   *
+   *     return persister;
+   *   }
+   * }
+   * ```
+   * @category Getter
+   * @since v6.3.0
+   */
+  getSqlStorage(): SqlStorage;
+}
+
+/**
+ * The createDurableObjectSqlStoragePersister function creates a
+ * DurableObjectSqlStoragePersister object that can persist the Store to and
+ * from Cloudflare Durable Object SQLite storage.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createDurableObjectSqlStoragePersister(
+ *   store: MergeableStore,
+ *   sqlStorage: SqlStorage,
+ *   configOrStoreTableName?: DurableObjectSqlDatabasePersisterConfig | string,
+ *   onSqlCommand?: (sql: string, params?: any[]) => void,
+ *   onIgnoredError?: (error: any) => void,
+ * ): DurableObjectSqlStoragePersister;
+ * ```
+ *
+ * You will mostly use this within the createPersister method of a
+ * WsServerDurableObject.
+ *
+ * This persister uses Cloudflare's SQLite storage backend, which provides
+ * better pricing and performance compared to the legacy Key-value storage
+ * backend.
+ *
+ * **Important Prerequisites:** Before using this persister, you must configure
+ * your Durable Object class to use SQLite storage by adding a migration to your
+ * Wrangler configuration file. In your `wrangler.toml`, add the following.
+ * ```toml
+ * [[migrations]]
+ * tag = "v1"
+ * new_sqlite_classes = ["YourDurableObjectClass"]
+ * ```
+ *
+ * Or in your `wrangler.json`, add:
+ *
+ * ```json
+ * {
+ *   "migrations": [
+ *     {
+ *       "tag": "v1",
+ *       "new_sqlite_classes": ["YourDurableObjectClass"]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * For more details on Durable Object migrations, see the [Cloudflare
+ * documentation](https://developers.cloudflare.com/durable-objects/reference/durable-objects-migrations/).
+ *
+ * A database Persister uses one of two modes: either a JSON serialization of
+ * the whole Store stored in a single row of a table (the default), a fragmented
+ * mode that stores each piece of data separately to avoid Cloudflare's 2MB row
+ * limit.
+ *
+ * - **JSON Mode (Default)**: Stores the entire Store as JSON in a single
+ *   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.
+ *
+ * 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
+ * a string, it is used as the `storeTableName` property of the JSON
+ * serialization. If it is the string 'fragmented', it enables fragmented mode.
+ *
+ * See the documentation for the DpcJson, DpcFragmented, and DpcTabular types
+ * for more information on how all of those modes can be configured.
+ *
+ * As well as providing a reference to the Store or MergeableStore to persist,
+ * you must provide a `sqlStorage` parameter which identifies the Durable Object
+ * SQLite storage to persist it to.
+ * @param store The Store or MergeableStore to persist.
+ * @param sqlStorage The Durable Object SQL storage to persist the Store to.
+ * @param configOrStoreTableName A DatabasePersisterConfig to configure the
+ * persistence mode (or a string to set the `storeTableName` property of the
+ * JSON serialization).
+ * @param onSqlCommand An optional handler called every time the Persister
+ * executes a SQL command or query. This is suitable for logging persistence
+ * behavior in a development environment.
+ * @param onIgnoredError An optional handler for the errors that the Persister
+ * would otherwise ignore when trying to save or load data. This is suitable for
+ * debugging persistence issues in a development environment.
+ * @returns A reference to the new DurableObjectSqlStoragePersister object.
+ * @example
+ * This example creates a DurableObjectSqlStoragePersister object and persists
+ * the Store to Durable Object SQLite storage as a JSON serialization into the
+ * default `tinybase` table. It uses this within the createPersister method of a
+ * WsServerDurableObject instance.
+ *
+ * ```js yolo
+ * import {createMergeableStore} from 'tinybase';
+ * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+ * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+ *
+ * export class MyDurableObject extends WsServerDurableObject {
+ *   createPersister() {
+ *     const store = createMergeableStore();
+ *     const persister = createDurableObjectSqlStoragePersister(
+ *       store,
+ *       this.ctx.storage.sql,
+ *     );
+ *     return persister;
+ *   }
+ * }
+ * ```
+ * @example
+ * This example creates a DurableObjectSqlStoragePersister object with a custom
+ * table name and SQL command logging for debugging.
+ *
+ * ```js yolo
+ * import {createMergeableStore} from 'tinybase';
+ * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+ * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+ *
+ * export class MyDurableObject extends WsServerDurableObject {
+ *   createPersister() {
+ *     const store = createMergeableStore();
+ *     const persister = createDurableObjectSqlStoragePersister(
+ *       store,
+ *       this.ctx.storage.sql,
+ *       'my_app_store',
+ *       (sql, params) => console.log('SQL:', sql, params),
+ *       (error) => console.error('Persistence error:', error),
+ *     );
+ *     return persister;
+ *   }
+ * }
+ * ```
+ * @example
+ * This example creates a DurableObjectSqlStoragePersister object using
+ * fragmented mode to avoid Cloudflare's 2MB row limit for large stores.
+ *
+ * ```js yolo
+ * import {createMergeableStore} from 'tinybase';
+ * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+ * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+ *
+ * export class MyDurableObject extends WsServerDurableObject {
+ *   createPersister() {
+ *     const store = createMergeableStore();
+ *     const persister = createDurableObjectSqlStoragePersister(
+ *       store,
+ *       this.ctx.storage.sql,
+ *       {mode: 'fragmented'},
+ *     );
+ *     return persister;
+ *   }
+ * }
+ * ```
+ * @example
+ * This example creates a DurableObjectSqlStoragePersister object using
+ * fragmented mode with a custom storage prefix.
+ *
+ * ```js yolo
+ * import {createMergeableStore} from 'tinybase';
+ * import {createDurableObjectSqlStoragePersister} from 'tinybase/persisters/persister-durable-object-sql-storage';
+ * import {WsServerDurableObject} from 'tinybase/synchronizers/synchronizer-ws-server-durable-object';
+ *
+ * export class MyDurableObject extends WsServerDurableObject {
+ *   createPersister() {
+ *     const store = createMergeableStore();
+ *     const persister = createDurableObjectSqlStoragePersister(
+ *       store,
+ *       this.ctx.storage.sql,
+ *       {mode: 'fragmented', storagePrefix: 'my_app_'},
+ *     );
+ *     return persister;
+ *   }
+ * }
+ * ```
+ * @category Creation
+ * @essential Persisting stores
+ * @since v6.3.0
+ */
+export function createDurableObjectSqlStoragePersister<
+  Schemas extends OptionalSchemas,
+>(
+  store: Store<Schemas> | MergeableStore<Schemas>,
+  sqlStorage: SqlStorage,
+  configOrStoreTableName?:
+    | DurableObjectSqlDatabasePersisterConfig<Schemas>
+    | string,
+  onSqlCommand?: (sql: string, params?: any[]) => void,
+  onIgnoredError?: (error: any) => void,
+): DurableObjectSqlStoragePersister<Schemas>;

package/@types/persisters/persister-pglite/index.d.ts

@@ -166,6 +166,7 @@ export interface PglitePersister
  * await pglite.close();
  * ```
  * @category Creation
+ * @essential Persisting stores
  * @since 5.2.0
  */
 export function createPglitePersister(

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

@@ -185,6 +185,7 @@ export interface PglitePersister<Schemas extends OptionalSchemas>
  * await pglite.close();
  * ```
  * @category Creation
+ * @essential Persisting stores
  * @since 5.2.0
  */
 export function createPglitePersister<Schemas extends OptionalSchemas>(

package/@types/persisters/persister-sqlite-wasm/index.d.ts

@@ -163,6 +163,7 @@ export interface SqliteWasmPersister
  * await persister.destroy();
  * ```
  * @category Creation
+ * @essential Persisting stores
  * @since v4.0.0
  */
 export function createSqliteWasmPersister(

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

@@ -183,6 +183,7 @@ export interface SqliteWasmPersister<Schemas extends OptionalSchemas>
  * await persister.destroy();
  * ```
  * @category Creation
+ * @essential Persisting stores
  * @since v4.0.0
  */
 export function createSqliteWasmPersister<Schemas extends OptionalSchemas>(

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

@@ -6,8 +6,8 @@
  * Many entry points are provided (in separately installed modules), each of
  * which returns different types of Persister that can load and save a Store.
  * Between them, these allow you to store your TinyBase data locally, remotely,
- * to SQLite and PostgreSQL databases, and across synchronization boundaries
- * with CRDT frameworks.
+ * to a Durable Object, to SQLite and PostgreSQL databases, and across
+ * synchronization boundaries with CRDT frameworks.
  *
  * |Persister|Storage|Store|MergeableStore
  * |-|-|-|-|
@@ -16,6 +16,8 @@
  * |FilePersister|Local file (where possible)|Yes|Yes
  * |IndexedDbPersister|Browser IndexedDB|Yes|No
  * |RemotePersister|Remote server|Yes|No
+ * |DurableObjectStoragePersister|Cloudflare Durable Object (KV)|No|Yes
+ * |DurableObjectSqlStoragePersister|Cloudflare Durable Object (SQLite)|No|Yes
  * |Sqlite3Persister|SQLite in Node, via [sqlite3](https://github.com/TryGhost/node-sqlite3)|Yes|Yes*
  * |SqliteBunPersister| SQLite in Bun, via [bun:sqlite](https://bun.sh/docs/api/sqlite)|Yes|Yes*
  * |SqliteWasmPersister|SQLite in a browser, via [sqlite-wasm](https://github.com/tomayac/sqlite-wasm)|Yes|Yes*
@@ -1029,6 +1031,7 @@ export type DpcTabularValues = {
  * sessionStorage.clear();
  * ```
  * @category Persister
+ * @essential Persisting stores
  * @since v1.0.0
  */
 export interface Persister<

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

@@ -1331,7 +1331,7 @@ export type Where = {
  * If you provide a Group for every Select, the result will be a single Row with
  * every Cell having been aggregated. If you provide a Group for only one, or
  * some, of the Select clauses, the _others_ will be automatically used as
- * dimensional values (analogous to the 'group by` semantics in SQL), within
+ * dimensional values (analogous to the `group by` semantics in SQL), within
  * which the aggregations of Group Cells will be performed.
  *
  * You can join the same underlying Cell multiple times, but in that case you

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

@@ -1518,7 +1518,7 @@ export type Where<
  * If you provide a Group for every Select, the result will be a single Row with
  * every Cell having been aggregated. If you provide a Group for only one, or
  * some, of the Select clauses, the _others_ will be automatically used as
- * dimensional values (analogous to the 'group by` semantics in SQL), within
+ * dimensional values (analogous to the `group by` semantics in SQL), within
  * which the aggregations of Group Cells will be performed.
  *
  * You can join the same underlying Cell multiple times, but in that case you

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

@@ -1872,6 +1872,7 @@ export type StoreListenerStats = {
  * @see Hello World demos
  * @see Todo App demos
  * @category Store
+ * @essential Creating stores
  * @since v1.0.0
  */
 export interface Store {
@@ -2321,6 +2322,7 @@ export interface Store {
    * // -> {}
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v1.0.0
    */
   getRow(tableId: Id, rowId: Id): Row;
@@ -2394,6 +2396,7 @@ export interface Store {
    * // -> undefined
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v1.0.0
    */
   getCell(tableId: Id, rowId: Id, cellId: Id): CellOrUndefined;
@@ -2489,6 +2492,7 @@ export interface Store {
    * // -> undefined
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v3.0.0
    */
   getValue(valueId: Id): ValueOrUndefined;
@@ -3157,6 +3161,7 @@ export interface Store {
    * // -> {pets: {fido: {color: 'brown'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   setRow(tableId: Id, rowId: Id, row: Row): this;
@@ -3223,6 +3228,7 @@ export interface Store {
    * // -> {pets: {'0': {species: 'dog'}, '1': {species: 'cat'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   addRow(tableId: Id, row: Row, reuseRowIds?: boolean): Id | undefined;
@@ -3343,6 +3349,7 @@ export interface Store {
    * // -> {pets: {fido: {species: 'dog'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): this;
@@ -3506,6 +3513,7 @@ export interface Store {
    * // -> {employees: 3}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v3.0.0
    */
   setValue(valueId: Id, value: Value | MapValue): this;
@@ -4263,6 +4271,7 @@ export interface Store {
    * // -> {open: true}
    * ```
    * @category Transaction
+   * @essential Setting data
    * @since v1.0.0
    */
   transaction<Return>(actions: () => Return, doRollback?: DoRollback): Return;
@@ -6025,6 +6034,7 @@ export interface Store {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v1.0.0
    */
   addRowListener(
@@ -6392,6 +6402,7 @@ export interface Store {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v1.0.0
    */
   addCellListener(
@@ -6794,6 +6805,7 @@ export interface Store {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v3.0.0
    */
   addValueListener(
@@ -7715,6 +7727,7 @@ export interface Store {
  * ```
  * @see The Basics guides
  * @category Creation
+ * @essential Creating stores
  * @since v1.0.0
  */
 export function createStore(): Store;

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

@@ -2843,6 +2843,7 @@ export type StoreListenerStats = {
  * @see Hello World demos
  * @see Todo App demos
  * @category Store
+ * @essential Creating stores
  * @since v1.0.0
  */
 export interface Store<in out Schemas extends OptionalSchemas> {
@@ -3363,6 +3364,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {}
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v1.0.0
    */
   getRow<TableId extends TableIdFromSchema<Schemas[0]>>(
@@ -3454,6 +3456,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> undefined
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v1.0.0
    */
   getCell<
@@ -3574,6 +3577,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> undefined
    * ```
    * @category Getter
+   * @essential Getting data
    * @since v3.0.0
    */
   getValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
@@ -4310,6 +4314,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {pets: {fido: {color: 'brown'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   setRow<TableId extends TableIdFromSchema<Schemas[0]>>(
@@ -4386,6 +4391,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {pets: {'0': {species: 'dog'}, '1': {species: 'cat'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   addRow<TableId extends TableIdFromSchema<Schemas[0]>>(
@@ -4526,6 +4532,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {pets: {fido: {species: 'dog'}}}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v1.0.0
    */
   setCell<
@@ -4717,6 +4724,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {employees: 3}
    * ```
    * @category Setter
+   * @essential Setting data
    * @since v3.0.0
    */
   setValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
@@ -5572,6 +5580,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // -> {open: true}
    * ```
    * @category Transaction
+   * @essential Setting data
    * @since v1.0.0
    */
   transaction<Return>(
@@ -7551,6 +7560,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v1.0.0
    */
   addRowListener<
@@ -7973,6 +7983,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v1.0.0
    */
   addCellListener<
@@ -8438,6 +8449,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @essential Listening for changes
    * @since v3.0.0
    */
   addValueListener<ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null>(
@@ -9408,6 +9420,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
  * ```
  * @see The Basics guides
  * @category Creation
+ * @essential Creating stores
  * @since v1.0.0
  */
 export function createStore(): Store<NoSchemas>;

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

@@ -198,6 +198,7 @@ export type SynchronizerStats = {
  * await synchronizer2.destroy();
  * ```
  * @category Synchronizer
+ * @essential Synchronizing stores
  * @since v5.0.0
  */
 export interface Synchronizer extends Persister<Persists.MergeableStoreOnly> {

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

@@ -148,6 +148,7 @@ export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
  * await server.destroy();
  * ```
  * @category Creation
+ * @essential Synchronizing stores
  * @since v5.0.0
  */
 export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(

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

@@ -164,6 +164,7 @@ export interface WsSynchronizer<
  * await server.destroy();
  * ```
  * @category Creation
+ * @essential Synchronizing stores
  * @since v5.0.0
  */
 export function createWsSynchronizer<