@korajs/store 0.3.2 → 0.4.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import { Q as QueryDescriptor, a as SubscriptionCallback, C as CollectionRecord, S as StorageAdapter, W as WhereClause, O as OrderByDirection, b as StoreConfig, A as ApplyResult } from './types-DF-KDSK1.cjs';
-export { M as MigrationPlan, c as OrderByClause, T as Transaction, d as WhereOperators } from './types-DF-KDSK1.cjs';
-import { KoraError, Operation, CollectionDefinition, SchemaDefinition, OperationLog, VersionVector, HybridLogicalClock } from '@korajs/core';
+import { Q as QueryDescriptor, a as SubscriptionCallback, C as CollectionRecord, S as StorageAdapter, W as WhereClause, O as OrderByDirection, b as StoreConfig, A as ApplyResult, T as Transaction } from './types-DF-KDSK1.cjs';
+export { M as MigrationPlan, c as OrderByClause, d as WhereOperators } from './types-DF-KDSK1.cjs';
+import { KoraError, Operation, CollectionDefinition, SchemaDefinition, SequenceConfig, HybridLogicalClock, OperationLog, VersionVector, OnDeleteAction, RelationDefinition, StateMachineDefinition } from '@korajs/core';
 
 /**
  * Thrown when a query is invalid (bad field names, invalid operators, etc.).
@@ -46,14 +46,77 @@ declare class PersistenceError extends KoraError {
 }
 
 /**
- * Manages reactive subscriptions. When a mutation occurs on a collection,
- * affected subscriptions are re-evaluated in a microtask batch and callbacks
- * are invoked only if results actually changed.
+ * Configuration options for the SubscriptionManager.
+ */
+interface SubscriptionManagerOptions {
+    /**
+     * Minimum number of subscriptions before activating bloom filter.
+     * Below this threshold, linear scanning is used (bloom filter overhead not worth it).
+     * @default 100
+     */
+    bloomThreshold?: number;
+    /**
+     * Expected number of unique collection+field dependencies for bloom filter sizing.
+     * @default 500
+     */
+    bloomExpectedItems?: number;
+    /**
+     * Target false positive rate for the bloom filter.
+     * Lower values require more memory but reduce unnecessary precise checks.
+     * @default 0.01
+     */
+    bloomFalsePositiveRate?: number;
+}
+/**
+ * Performance statistics for monitoring subscription checking efficiency.
+ */
+interface SubscriptionStats {
+    /** Total number of mutation notifications processed */
+    totalChecks: number;
+    /** Number of times bloom filter said "maybe" (proceeded to precise check) */
+    bloomFilterHits: number;
+    /** Number of times bloom filter said "definitely not" (skipped all subscriptions) */
+    bloomFilterMisses: number;
+    /** Number of times bloom filter said "maybe" but precise check found no match */
+    falsePositives: number;
+    /** Average time per check in milliseconds */
+    averageCheckTimeMs: number;
+    /** Whether bloom filter is currently active */
+    bloomFilterActive: boolean;
+    /** Current subscription count */
+    subscriptionCount: number;
+}
+/**
+ * Manages reactive subscriptions with two-level dependency checking.
+ *
+ * When a mutation occurs on a collection, affected subscriptions are re-evaluated
+ * in a microtask batch and callbacks are invoked only if results actually changed.
+ *
+ * For large subscription counts (>= bloomThreshold), a bloom filter provides O(k)
+ * pre-filtering to avoid scanning all subscriptions on every mutation:
+ *
+ * Level 1 (Bloom filter): Fast O(k) check -- does this mutation potentially affect
+ * any subscription? If NO: skip all subscriptions (guaranteed correct).
+ * If MAYBE: proceed to Level 2.
+ *
+ * Level 2 (Precise check): Only evaluate subscriptions that match the mutated
+ * collection, including included (related) collection tracking.
  */
 declare class SubscriptionManager {
     private subscriptions;
     private pendingCollections;
     private flushScheduled;
+    private bloomFilter;
+    private bloomDirty;
+    private readonly bloomThreshold;
+    private readonly bloomExpectedItems;
+    private readonly bloomFalsePositiveRate;
+    private totalChecks;
+    private bloomFilterHits;
+    private bloomFilterMisses;
+    private falsePositives;
+    private totalCheckTimeMs;
+    constructor(options?: SubscriptionManagerOptions);
     /**
      * Register a new subscription.
      *
@@ -87,6 +150,33 @@ declare class SubscriptionManager {
     clear(): void;
     /** Number of active subscriptions (for testing/debugging) */
     get size(): number;
+    /**
+     * Get performance statistics for monitoring subscription checking efficiency.
+     * Useful for DevTools integration and performance tuning.
+     */
+    getStats(): SubscriptionStats;
+    /**
+     * Check if bloom filter is currently active.
+     * Active when subscription count meets or exceeds the threshold.
+     */
+    isBloomActive(): boolean;
+    /**
+     * Find subscriptions affected by mutations to the given collections.
+     * Uses two-level checking when bloom filter is active:
+     *
+     * Level 1: Bloom filter pre-check -- if no subscription depends on any
+     * of the mutated collections, skip everything (O(k) per collection).
+     *
+     * Level 2: Precise check -- linear scan of subscriptions, matching
+     * against the mutated collections.
+     */
+    private findAffectedSubscriptions;
+    /**
+     * Rebuild the bloom filter from all current subscriptions.
+     * Adds collection-level dependencies for every subscription, plus
+     * any included collection dependencies.
+     */
+    private rebuildBloomFilter;
     private scheduleFlush;
     /**
      * Compare two result sets. Uses length check + JSON comparison as pragmatic approach.
@@ -192,6 +282,145 @@ declare class QueryBuilder<T = CollectionRecord> {
     private findRelation;
 }
 
+/**
+ * Manages offline-safe sequences backed by a `_kora_sequences` table.
+ *
+ * Each sequence counter is scoped by (name, scope, nodeId), ensuring
+ * that different devices never collide. The counter is atomically
+ * incremented within a database transaction.
+ *
+ * @example
+ * ```typescript
+ * const mgr = new SequenceManager(adapter, 'node-abc')
+ *
+ * const receipt = await mgr.next('receipt', {
+ *   scope: 'store-1',
+ *   format: 'S-{date}-{node4}-{seq}',
+ * })
+ * // → "S-20260508-node-0001"
+ * ```
+ */
+declare class SequenceManager {
+    private readonly adapter;
+    private readonly nodeId;
+    constructor(adapter: StorageAdapter, nodeId: string);
+    /**
+     * Get the next value in a sequence, atomically incrementing the counter.
+     *
+     * @param name - The sequence name (e.g., 'receipt', 'invoice')
+     * @param config - Optional configuration for scope, format, and starting value
+     * @returns The formatted sequence value
+     */
+    next(name: string, config?: SequenceConfig): Promise<string>;
+    /**
+     * Get the current counter value without incrementing.
+     *
+     * @param name - The sequence name
+     * @param config - Optional scope
+     * @returns The current counter value, or 0 if the sequence has never been used
+     */
+    current(name: string, config?: {
+        scope?: string;
+    }): Promise<number>;
+    /**
+     * Reset a sequence counter.
+     *
+     * @param name - The sequence name
+     * @param config - Optional scope and target value
+     */
+    reset(name: string, config?: {
+        scope?: string;
+        to?: number;
+    }): Promise<void>;
+}
+
+/**
+ * Internal configuration for creating a TransactionContext.
+ * Passed from Store to avoid exposing Store internals publicly.
+ */
+interface TransactionContextConfig {
+    schema: SchemaDefinition;
+    adapter: StorageAdapter;
+    clock: HybridLogicalClock;
+    nodeId: string;
+    getSequenceNumber: () => number;
+}
+/**
+ * A collection accessor within a transaction.
+ * Operations are buffered and committed atomically when the transaction completes.
+ */
+interface TransactionCollectionAccessor {
+    insert(data: Record<string, unknown>): Promise<CollectionRecord>;
+    update(id: string, data: Record<string, unknown>): Promise<CollectionRecord>;
+    delete(id: string): Promise<void>;
+    findById(id: string): Promise<CollectionRecord | null>;
+}
+/**
+ * TransactionContext provides atomic multi-collection operations.
+ *
+ * All mutations are buffered and committed in a single StorageAdapter.transaction()
+ * call. All operations share the same transactionId (UUID v7).
+ *
+ * Subscription notifications are deferred until after commit.
+ *
+ * @example
+ * ```typescript
+ * const { operations, affectedCollections } = await txContext.commit()
+ * // Notify subscriptions after commit
+ * for (const op of operations) {
+ *   subscriptionManager.notify(op.collection, op)
+ * }
+ * ```
+ */
+declare class TransactionContext {
+    private readonly transactionId;
+    private mutationName;
+    private readonly buffer;
+    private committed;
+    private rolledBack;
+    private readonly config;
+    constructor(config: TransactionContextConfig);
+    /**
+     * Set a human-readable mutation name for this transaction.
+     * Propagated to all operations for DevTools display.
+     */
+    setMutationName(name: string): void;
+    /**
+     * Get the mutation name, if set.
+     */
+    getMutationName(): string | undefined;
+    /**
+     * Get a collection accessor for buffered operations within this transaction.
+     */
+    collection(name: string): TransactionCollectionAccessor;
+    /**
+     * Commit all buffered operations atomically.
+     * Returns the list of operations and affected collections for subscription notification.
+     */
+    commit(): Promise<{
+        operations: Operation[];
+        affectedCollections: Set<string>;
+    }>;
+    /**
+     * Mark the transaction as rolled back. No operations will be committed.
+     */
+    rollback(): void;
+    /**
+     * Get the transaction ID shared by all operations in this transaction.
+     */
+    getTransactionId(): string;
+    private ensureActive;
+    private insert;
+    private update;
+    private deleteRecord;
+    private findById;
+    /**
+     * Get the effective state of a record, considering both the database and buffered operations.
+     * Buffered inserts/updates take precedence over the database state.
+     */
+    private getEffectiveRecord;
+}
+
 /**
  * Store is the main orchestrator. It owns a schema, a storage adapter,
  * a clock, and a subscription manager. It creates Collection instances
@@ -214,6 +443,7 @@ declare class Store implements OperationLog {
     private clock;
     private collections;
     private subscriptionManager;
+    private sequenceManager;
     private readonly schema;
     private readonly adapter;
     private readonly configNodeId;
@@ -263,7 +493,45 @@ declare class Store implements OperationLog {
     getSchema(): SchemaDefinition;
     /** Expose the subscription manager for direct access (e.g., by QueryBuilder) */
     getSubscriptionManager(): SubscriptionManager;
+    /**
+     * Get the sequence manager for offline-safe sequence generation.
+     * @throws {StoreNotOpenError} If the store is not open
+     */
+    getSequenceManager(): SequenceManager;
+    /**
+     * Create a TransactionContext for atomic multi-collection operations.
+     * The returned context buffers all mutations and commits them atomically.
+     *
+     * After commit, the caller is responsible for notifying subscriptions
+     * and emitting events for each operation.
+     */
+    createTransaction(): TransactionContext;
+    /**
+     * Execute a function within a transaction. All mutations performed on the
+     * TransactionContext are committed atomically. Subscription notifications
+     * are batched and fired after the commit.
+     *
+     * If the function throws, the transaction is rolled back and the error is re-thrown.
+     *
+     * @param fn - Function receiving a TransactionContext for buffered operations
+     * @returns The operations that were committed
+     */
+    transaction(fn: (tx: TransactionContext) => Promise<void>): Promise<Operation[]>;
     private nextSequenceNumber;
+    /**
+     * Check the stored schema version and run any pending migrations.
+     * Migrations are applied in version order within a transaction.
+     */
+    private runMigrationsIfNeeded;
+    /**
+     * Get the stored schema version from _kora_meta. Returns 0 if not set.
+     */
+    private getStoredSchemaVersion;
+    /**
+     * Run a backfill transform on all records in a collection.
+     * Reads all rows, applies the transform, and updates changed fields.
+     */
+    private runBackfill;
     private loadOrGenerateNodeId;
     private loadSequenceNumber;
     private loadVersionVector;
@@ -280,6 +548,205 @@ interface CollectionAccessor {
     where(conditions: Record<string, unknown>): QueryBuilder;
 }
 
+/**
+ * Bloom filter for subscription dependency tracking.
+ *
+ * Each subscription adds its watched collection (and optionally fields) to the
+ * filter. When a mutation arrives, we check "collection" and "collection:field"
+ * keys against the filter. A negative result means no subscription cares about
+ * this mutation, so we can skip the expensive per-subscription scan.
+ *
+ * @example
+ * ```typescript
+ * const filter = new SubscriptionBloomFilter(100, 0.01)
+ * filter.add('todos')
+ * filter.add('todos', 'completed')
+ *
+ * filter.mightContain('todos')              // true (definitely added)
+ * filter.mightContain('projects')           // false (definitely not added)
+ * filter.mightContain('todos', 'completed') // true (definitely added)
+ * ```
+ */
+declare class SubscriptionBloomFilter {
+    private bits;
+    private readonly bitCount;
+    private readonly hashCount;
+    private itemCount;
+    constructor(expectedItems: number, falsePositiveRate?: number);
+    /**
+     * Add a collection (and optional field) to the bloom filter.
+     *
+     * @param collection - Collection name (e.g., "todos")
+     * @param field - Optional field name (e.g., "completed")
+     */
+    add(collection: string, field?: string): void;
+    /**
+     * Check if a collection (and optional field) might be in the filter.
+     *
+     * A return value of `false` means the item is DEFINITELY NOT in the filter.
+     * A return value of `true` means the item MIGHT be in the filter (possible false positive).
+     *
+     * @param collection - Collection name to check
+     * @param field - Optional field name to check
+     * @returns false = definitely absent, true = possibly present
+     */
+    mightContain(collection: string, field?: string): boolean;
+    /**
+     * Reset the bloom filter, clearing all bits and the item count.
+     */
+    clear(): void;
+    /**
+     * Estimate the current false positive rate based on the number of items inserted.
+     *
+     * Formula: (1 - e^(-kn/m))^k
+     * where k = hash count, n = item count, m = bit count.
+     *
+     * @returns Estimated false positive rate as a number between 0 and 1
+     */
+    estimatedFalsePositiveRate(): number;
+    /**
+     * @returns The number of items that have been added to the filter
+     */
+    getItemCount(): number;
+    /**
+     * @returns The total number of bits in the filter
+     */
+    getBitCount(): number;
+    /**
+     * @returns The number of hash functions used
+     */
+    getHashCount(): number;
+    /**
+     * Count the number of bits currently set to 1.
+     * Uses Brian Kernighan's algorithm: each iteration clears the lowest set bit,
+     * so the loop runs exactly as many times as there are set bits.
+     *
+     * @returns Number of bits set to 1
+     */
+    getSetBitCount(): number;
+    /**
+     * Compute k bit positions for a given key using Kirsch-Mitzenmacker double hashing.
+     *
+     * Instead of computing k independent hash functions, we compute two base hashes
+     * (h1 and h2) and derive the rest as: h_i = (h1 + i * h2) mod m.
+     * This technique is proven to have the same asymptotic false positive rate as
+     * k independent hash functions.
+     *
+     * We derive h1 and h2 from a single FNV-1a hash by splitting and mixing:
+     * h1 = fnv1a(key), h2 = fnv1a(key + "\0salt") to ensure independence.
+     */
+    private getPositions;
+}
+
+/**
+ * A resolved relation reference: describes a relation that points TO a given collection.
+ * When a record in `targetCollection` is deleted, we must handle records in
+ * `sourceCollection` that reference it via `foreignKeyField`.
+ */
+interface IncomingRelation {
+    /** Name of the relation in the schema */
+    relationName: string;
+    /** Collection that holds the foreign key (the "from" side) */
+    sourceCollection: string;
+    /** Field in the source collection that references the target */
+    foreignKeyField: string;
+    /** What to do when the referenced record is deleted */
+    onDelete: OnDeleteAction;
+    /** The full relation definition */
+    relation: RelationDefinition;
+}
+
+/**
+ * Configuration for the RelationEnforcer.
+ */
+interface RelationEnforcerConfig {
+    schema: SchemaDefinition;
+    adapter: StorageAdapter;
+    clock: HybridLogicalClock;
+    nodeId: string;
+    getSequenceNumber: () => number;
+}
+/**
+ * Result of enforcing referential integrity on a delete operation.
+ * Contains all additional operations that were created as side effects
+ * (cascaded deletes and set-null updates).
+ */
+interface EnforcementResult {
+    /** Additional operations created by cascading deletes and set-null updates */
+    operations: Operation[];
+}
+/**
+ * Enforces referential integrity constraints during local delete operations.
+ *
+ * When a record is deleted, this enforcer checks all relations that reference
+ * the deleted record's collection and applies the appropriate onDelete policy:
+ *
+ * - **cascade**: Recursively deletes all referencing records
+ * - **set-null**: Sets the foreign key to null on all referencing records
+ * - **restrict**: Throws a ReferentialIntegrityError if any references exist
+ * - **no-action**: Does nothing (the foreign key is left dangling)
+ *
+ * The enforcer operates within a provided transaction to ensure atomicity.
+ * All generated operations (cascaded deletes, set-null updates) share a
+ * causal dependency chain through the original delete operation.
+ *
+ * @example
+ * ```typescript
+ * const enforcer = new RelationEnforcer({
+ *   schema, adapter, clock, nodeId,
+ *   getSequenceNumber: () => ++seq,
+ * })
+ * const result = await enforcer.enforceDelete(
+ *   'projects', 'proj-1', tx, ['delete-op-id']
+ * )
+ * // result.operations contains any cascaded delete/update ops
+ * ```
+ */
+declare class RelationEnforcer {
+    private readonly lookup;
+    private readonly schema;
+    private readonly adapter;
+    private readonly clock;
+    private readonly nodeId;
+    private readonly getSequenceNumber;
+    constructor(config: RelationEnforcerConfig);
+    /**
+     * Enforce referential integrity after deleting a record.
+     *
+     * Must be called within a transaction. The transaction handle is used
+     * for all cascaded writes to ensure atomicity.
+     *
+     * @param collection - The collection the deleted record belongs to
+     * @param recordId - The ID of the deleted record
+     * @param tx - The active transaction handle
+     * @param causalDeps - Causal dependencies for generated operations
+     * @returns All additional operations created as side effects
+     * @throws {ReferentialIntegrityError} If a 'restrict' policy is violated
+     */
+    enforceDelete(collection: string, recordId: string, tx: Transaction, causalDeps: string[]): Promise<EnforcementResult>;
+    /**
+     * Enforce a single relation's onDelete policy.
+     */
+    private enforceRelation;
+    /**
+     * Cascade: delete all records in the source collection that reference
+     * the deleted record, then recursively cascade those deletes.
+     */
+    private enforceCascade;
+    /**
+     * Set-null: update all referencing records to set the foreign key to null.
+     */
+    private enforceSetNull;
+    /**
+     * Restrict: refuse the delete if any referencing records exist.
+     */
+    private enforceRestrict;
+    /**
+     * Get the relation lookup map for external use (e.g., by the merge engine).
+     */
+    getRelationLookup(): Map<string, IncomingRelation[]>;
+}
+
 /**
  * Callback invoked after a mutation so the Store can notify subscriptions.
  */
@@ -287,6 +754,9 @@ type MutationCallback = (collection: string, operation: Operation) => void;
 /**
  * Collection provides CRUD operations on a single schema collection.
  * Each mutation creates an Operation and persists both the data and the operation atomically.
+ *
+ * When a RelationEnforcer is provided, delete operations enforce referential integrity
+ * policies (cascade, set-null, restrict) defined in the schema's relations.
  */
 declare class Collection {
     private readonly name;
@@ -297,7 +767,8 @@ declare class Collection {
     private readonly nodeId;
     private readonly getSequenceNumber;
     private readonly onMutation;
-    constructor(name: string, definition: CollectionDefinition, schema: SchemaDefinition, adapter: StorageAdapter, clock: HybridLogicalClock, nodeId: string, getSequenceNumber: () => number, onMutation: MutationCallback);
+    private readonly relationEnforcer;
+    constructor(name: string, definition: CollectionDefinition, schema: SchemaDefinition, adapter: StorageAdapter, clock: HybridLogicalClock, nodeId: string, getSequenceNumber: () => number, onMutation: MutationCallback, relationEnforcer?: RelationEnforcer);
     /**
      * Insert a new record into the collection.
      * Generates a UUID v7 for the id, validates data, and persists atomically.
@@ -322,8 +793,19 @@ declare class Collection {
     /**
      * Soft-delete a record by its ID.
      *
+     * When a RelationEnforcer is configured, referential integrity policies
+     * are enforced within the same transaction:
+     * - **cascade**: Recursively deletes all referencing records
+     * - **set-null**: Sets foreign keys to null on referencing records
+     * - **restrict**: Throws ReferentialIntegrityError if references exist
+     * - **no-action**: Does nothing (dangling references are left)
+     *
+     * All cascaded operations are created atomically within the same transaction
+     * and share causal dependencies with the original delete.
+     *
      * @param id - The record ID to delete
      * @throws {RecordNotFoundError} If the record doesn't exist or is already deleted
+     * @throws {ReferentialIntegrityError} If a 'restrict' policy is violated
      */
     delete(id: string): Promise<void>;
     /** Get the collection name */
@@ -332,6 +814,60 @@ declare class Collection {
     getDefinition(): CollectionDefinition;
 }
 
+/**
+ * Error thrown when a local mutation attempts an invalid state transition.
+ *
+ * Contains enough context to debug without reproduction:
+ * the collection, record, field, current state, attempted state, and allowed transitions.
+ */
+declare class InvalidStateTransitionError extends KoraError {
+    readonly collection: string;
+    readonly recordId: string;
+    readonly field: string;
+    readonly fromState: string;
+    readonly toState: string;
+    readonly allowedStates: string[];
+    constructor(collection: string, recordId: string, field: string, fromState: string, toState: string, allowedStates: string[]);
+}
+/**
+ * Validates a state machine transition for a local mutation (insert or update).
+ *
+ * For inserts: validates that the initial state (from the data or the default value)
+ * is a known state in the state machine.
+ *
+ * For updates: looks up the current state field value and checks whether
+ * the transition to the new value is allowed.
+ *
+ * @param collectionName - Name of the collection
+ * @param recordId - The record being mutated
+ * @param stateMachine - The state machine definition
+ * @param currentState - The current value of the state field (null for inserts)
+ * @param newState - The new value being set for the state field
+ * @returns An object indicating whether the transition is valid, and if not, the allowed states.
+ *          When `onInvalidTransition` is 'last-valid-state', callers should suppress the field update
+ *          rather than throwing.
+ */
+declare function validateStateTransition(collectionName: string, recordId: string, stateMachine: StateMachineDefinition, currentState: string | null, newState: string): {
+    valid: boolean;
+    allowedStates: string[];
+};
+/**
+ * Checks whether a collection update data object contains a change to the state machine field,
+ * and if so, validates the transition.
+ *
+ * If the state field is not in the update data, returns the data unchanged.
+ * If the transition is invalid and mode is 'last-valid-state', removes the field from the data.
+ * If the transition is invalid and mode is 'reject', throws InvalidStateTransitionError.
+ *
+ * @param collectionName - Name of the collection
+ * @param recordId - The record being updated
+ * @param collectionDef - The collection definition from the schema
+ * @param currentRecord - The current record data (must include the state field)
+ * @param updateData - The partial update data
+ * @returns The update data, potentially with the state field removed if invalid and mode is 'last-valid-state'
+ */
+declare function validateUpdateStateMachine(collectionName: string, recordId: string, collectionDef: CollectionDefinition, currentRecord: Record<string, unknown>, updateData: Record<string, unknown>): Record<string, unknown>;
+
 type RichtextInput = string | Uint8Array | ArrayBuffer | null | undefined;
 /**
  * Encodes richtext values into Yjs document updates.
@@ -373,4 +909,4 @@ declare function pluralize(word: string): string;
  */
 declare function singularize(word: string): string;
 
-export { AdapterError, ApplyResult, Collection, type CollectionAccessor, CollectionRecord, OrderByDirection, PersistenceError, QueryBuilder, QueryDescriptor, QueryError, RecordNotFoundError, StorageAdapter, Store, StoreConfig, StoreNotOpenError, SubscriptionCallback, SubscriptionManager, WhereClause, WorkerInitError, WorkerTimeoutError, decodeRichtext, encodeRichtext, pluralize, richtextToPlainText, singularize };
+export { AdapterError, ApplyResult, Collection, type CollectionAccessor, CollectionRecord, InvalidStateTransitionError, OrderByDirection, PersistenceError, QueryBuilder, QueryDescriptor, QueryError, RecordNotFoundError, SequenceManager, StorageAdapter, Store, StoreConfig, StoreNotOpenError, SubscriptionBloomFilter, SubscriptionCallback, SubscriptionManager, type SubscriptionManagerOptions, type SubscriptionStats, Transaction, type TransactionCollectionAccessor, TransactionContext, type TransactionContextConfig, WhereClause, WorkerInitError, WorkerTimeoutError, decodeRichtext, encodeRichtext, pluralize, richtextToPlainText, singularize, validateStateTransition, validateUpdateStateMachine };