@trestleinc/replicate 1.1.1 → 1.1.2-preview.0

package/dist/client/errors.d.ts

@@ -1,59 +0,0 @@
-declare const NetworkError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "NetworkError";
-} & Readonly<A>;
-export declare class NetworkError extends NetworkError_base<{
-    readonly cause: unknown;
-    readonly retryable: true;
-    readonly operation: string;
-}> {
-}
-declare const IDBError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "IDBError";
-} & Readonly<A>;
-export declare class IDBError extends IDBError_base<{
-    readonly operation: 'get' | 'set' | 'delete' | 'clear';
-    readonly store?: string;
-    readonly key?: string;
-    readonly cause: unknown;
-}> {
-}
-declare const IDBWriteError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "IDBWriteError";
-} & Readonly<A>;
-export declare class IDBWriteError extends IDBWriteError_base<{
-    readonly key: string;
-    readonly value: unknown;
-    readonly cause: unknown;
-}> {
-}
-declare const ReconciliationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ReconciliationError";
-} & Readonly<A>;
-export declare class ReconciliationError extends ReconciliationError_base<{
-    readonly collection: string;
-    readonly reason: string;
-    readonly cause?: unknown;
-}> {
-}
-declare const ProseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ProseError";
-} & Readonly<A>;
-export declare class ProseError extends ProseError_base<{
-    readonly documentId: string;
-    readonly field: string;
-    readonly collection: string;
-}> {
-}
-declare const CollectionNotReadyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "CollectionNotReadyError";
-} & Readonly<A>;
-export declare class CollectionNotReadyError extends CollectionNotReadyError_base<{
-    readonly collection: string;
-    readonly reason: string;
-}> {
-}
-/** Error that should not be retried (auth failures, validation errors) */
-export declare class NonRetriableError extends Error {
-    constructor(message: string);
-}
-export {};

package/dist/client/logger.d.ts

@@ -1,2 +0,0 @@
-import { type Logger } from '@logtape/logtape';
-export declare function getLogger(category: string[]): Logger;

package/dist/client/merge.d.ts

@@ -1,77 +0,0 @@
-/**
- * Merge Helpers - Plain functions for Yjs CRDT operations
- *
- * Provides document creation, state encoding, and merge operations.
- */
-import * as Y from 'yjs';
-import type { KeyValueStore } from '$/client/persistence/types.js';
-/**
- * Create a Yjs document with a persistent clientId.
- * The clientId ensures consistent identity across sessions for CRDT merging.
- *
- * @param collection - The collection name
- * @param kv - Key-value store for persisting the clientId
- */
-export declare function createYjsDocument(collection: string, kv: KeyValueStore): Promise<Y.Doc>;
-/**
- * Apply a binary update to a Yjs document.
- * Y.applyUpdateV2 is already atomic, no need for transaction wrapper.
- */
-export declare function applyUpdate(doc: Y.Doc, update: Uint8Array, origin?: string): void;
-/**
- * Get a Y.Map from a Yjs document by name.
- */
-export declare function getYMap<T = unknown>(doc: Y.Doc, name: string): Y.Map<T>;
-/**
- * Execute a function within a Yjs transaction.
- */
-export declare function yjsTransact<A>(doc: Y.Doc, fn: () => A, origin?: string): A;
-/**
- * Execute a function within a Yjs transaction and capture the delta.
- * Returns both the function result and a delta containing only the changes made.
- */
-export declare function transactWithDelta<A>(doc: Y.Doc, fn: () => A, origin?: string): {
-    result: A;
-    delta: Uint8Array;
-};
-/**
- * Serialize a Y.Map to a plain object.
- */
-export declare function serializeYMap(ymap: Y.Map<unknown>): Record<string, unknown>;
-/**
- * Extract all items from a Y.Map as plain objects.
- */
-export declare function extractItems<T>(ymap: Y.Map<unknown>): T[];
-/**
- * Extract a single item from a Y.Map by key.
- */
-export declare function extractItem<T>(ymap: Y.Map<unknown>, key: string): T | null;
-import type { XmlFragmentJSON } from '$/shared/types.js';
-/**
- * Check if a value looks like ProseMirror/BlockNote JSON document.
- * Used internally to auto-detect prose fields during insert/update.
- */
-export declare function isDoc(value: unknown): value is XmlFragmentJSON;
-/**
- * Convert a Y.XmlFragment to ProseMirror-compatible JSON.
- */
-export declare function fragmentToJSON(fragment: Y.XmlFragment): XmlFragmentJSON;
-/**
- * Initialize a Y.XmlFragment from ProseMirror-compatible JSON.
- */
-export declare function fragmentFromJSON(fragment: Y.XmlFragment, json: XmlFragmentJSON): void;
-/**
- * Extract plain text from ProseMirror/BlockNote JSON content.
- * Handles various content structures defensively for search and display.
- */
-export declare function extract(content: unknown): string;
-/**
- * Serialize any value, handling Yjs types specially.
- * Uses our custom serialization system that works across module instances.
- */
-export declare function serializeYMapValue(value: unknown): unknown;
-/**
- * Get a Y.XmlFragment from a document's field.
- * Returns null if the document or field doesn't exist, or if the field is not an XmlFragment.
- */
-export declare function getFragmentFromYMap(ymap: Y.Map<unknown>, documentId: string, field: string): Y.XmlFragment | null;

package/dist/client/persistence/adapters/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * SQLite adapter wrappers for different platforms.
- *
- * These are wrapper classes - the consuming app imports and initializes
- * the actual database packages, then passes them to these wrappers.
- */
-export { SqlJsAdapter, type SqlJsDatabase, type SqlJsAdapterOptions } from './sqljs.js';
-export { OPSqliteAdapter, type OPSQLiteDatabase } from './opsqlite.js';

package/dist/client/persistence/adapters/opsqlite.d.ts

@@ -1,46 +0,0 @@
-/**
- * op-sqlite adapter wrapper for React Native SQLite.
- *
- * The consuming app imports @op-engineering/op-sqlite and opens the database,
- * then passes it to this wrapper.
- *
- * @example
- * ```typescript
- * import { open } from '@op-engineering/op-sqlite';
- * import { OPSqliteAdapter } from '@trestleinc/replicate/client';
- *
- * const db = open({ name: 'myapp.db' });
- * const adapter = new OPSqliteAdapter(db);
- * ```
- */
-import type { SqliteAdapter } from '../sqlite-level.js';
-/**
- * Interface for op-sqlite Database.
- * Consumer must install @op-engineering/op-sqlite and pass a Database instance.
- */
-export interface OPSQLiteDatabase {
-    execute(sql: string, params?: unknown[]): Promise<{
-        rows: Record<string, unknown>[];
-    }>;
-    close(): void;
-}
-/**
- * Wraps an op-sqlite Database as a SqliteAdapter.
- *
- * @example
- * ```typescript
- * import { open } from '@op-engineering/op-sqlite';
- * import { OPSqliteAdapter } from '@trestleinc/replicate/client';
- *
- * const db = open({ name: 'myapp.db' });
- * const adapter = new OPSqliteAdapter(db);
- * ```
- */
-export declare class OPSqliteAdapter implements SqliteAdapter {
-    private db;
-    constructor(db: OPSQLiteDatabase);
-    execute(sql: string, params?: unknown[]): Promise<{
-        rows: Record<string, unknown>[];
-    }>;
-    close(): void;
-}

package/dist/client/persistence/adapters/sqljs.d.ts

@@ -1,83 +0,0 @@
-/**
- * sql.js adapter wrapper for browser SQLite.
- *
- * The consuming app imports sql.js and creates the database,
- * then passes it to this wrapper.
- *
- * @example
- * ```typescript
- * import initSqlJs from 'sql.js';
- * import { SqlJsAdapter } from '@trestleinc/replicate/client';
- *
- * const SQL = await initSqlJs({ locateFile: f => `/wasm/${f}` });
- * const db = new SQL.Database();
- * const adapter = new SqlJsAdapter(db, {
- *   onPersist: async (data) => {
- *     // Persist to OPFS, localStorage, etc.
- *   }
- * });
- * ```
- */
-import type { SqliteAdapter } from '../sqlite-level.js';
-/**
- * Interface for sql.js Database.
- * Consumer must install sql.js and pass a Database instance.
- */
-export interface SqlJsDatabase {
-    run(sql: string, params?: unknown[]): void;
-    prepare(sql: string): {
-        bind(params?: unknown[]): void;
-        step(): boolean;
-        getAsObject(): Record<string, unknown>;
-        free(): void;
-    };
-    export(): Uint8Array;
-    close(): void;
-}
-/**
- * Options for the SqlJsAdapter.
- */
-export interface SqlJsAdapterOptions {
-    /**
-     * Callback to persist database after write operations.
-     * Called with the exported database bytes.
-     *
-     * @example OPFS persistence
-     * ```typescript
-     * onPersist: async (data) => {
-     *   const root = await navigator.storage.getDirectory();
-     *   const handle = await root.getFileHandle('myapp.sqlite', { create: true });
-     *   const writable = await handle.createWritable();
-     *   await writable.write(data.buffer);
-     *   await writable.close();
-     * }
-     * ```
-     */
-    onPersist?: (data: Uint8Array) => Promise<void>;
-}
-/**
- * Wraps a sql.js Database as a SqliteAdapter.
- *
- * @example
- * ```typescript
- * import initSqlJs from 'sql.js';
- * import { SqlJsAdapter } from '@trestleinc/replicate/client';
- *
- * const SQL = await initSqlJs();
- * const db = new SQL.Database();
- * const adapter = new SqlJsAdapter(db);
- * ```
- */
-export declare class SqlJsAdapter implements SqliteAdapter {
-    private db;
-    private onPersist?;
-    constructor(db: SqlJsDatabase, options?: SqlJsAdapterOptions);
-    execute(sql: string, params?: unknown[]): Promise<{
-        rows: Record<string, unknown>[];
-    }>;
-    close(): void;
-    /**
-     * Persist database using the onPersist callback if provided.
-     */
-    private persist;
-}

package/dist/client/persistence/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * Persistence layer exports.
- *
- * Provides swappable storage backends for Y.Doc and key-value data.
- */
-export type { Persistence, PersistenceProvider, KeyValueStore } from './types.js';
-export type { SqlitePersistenceOptions } from './sqlite.js';
-export type { SqlJsStatic } from './sqlite-browser.js';
-export type { SqliteAdapter } from './sqlite-level.js';
-import { indexeddbPersistence } from './indexeddb.js';
-import { memoryPersistence } from './memory.js';
-import { sqlitePersistence } from './sqlite.js';
-import { createBrowserSqlitePersistence } from './sqlite-browser.js';
-import { createReactNativeSqlitePersistence } from './sqlite-rn.js';
-/**
- * Persistence API - nested object pattern for ergonomic access.
- *
- * @example
- * ```typescript
- * import { persistence } from '@trestleinc/replicate/client';
- *
- * // Browser SQLite (recommended for web)
- * const p = await persistence.sqlite.browser(SQL, 'myapp');
- *
- * // React Native SQLite
- * const p = await persistence.sqlite.native(db, 'myapp');
- *
- * // IndexedDB fallback
- * const p = persistence.indexeddb('myapp');
- *
- * // In-memory (testing)
- * const p = persistence.memory();
- * ```
- */
-export declare const persistence: {
-    /** IndexedDB-backed persistence (browser) */
-    readonly indexeddb: typeof indexeddbPersistence;
-    /** In-memory persistence (testing/ephemeral) */
-    readonly memory: typeof memoryPersistence;
-    /** SQLite persistence variants */
-    readonly sqlite: {
-        /** Browser SQLite with OPFS (sql.js) */
-        readonly browser: typeof createBrowserSqlitePersistence;
-        /** React Native SQLite (op-sqlite) */
-        readonly native: typeof createReactNativeSqlitePersistence;
-        /** Custom SQLite adapter */
-        readonly create: typeof sqlitePersistence;
-    };
-};

package/dist/client/persistence/indexeddb.d.ts

@@ -1,17 +0,0 @@
-import type { Persistence } from './types.js';
-/**
- * Create an IndexedDB persistence factory.
- *
- * Uses y-indexeddb for Y.Doc persistence and browser-level for metadata storage.
- *
- * @param dbName - Name for the LevelDB database (default: 'replicate-kv')
- *
- * @example
- * ```typescript
- * convexCollectionOptions<Task>({
- *   // ... other options
- *   persistence: indexeddbPersistence(),
- * });
- * ```
- */
-export declare function indexeddbPersistence(dbName?: string): Persistence;

package/dist/client/persistence/memory.d.ts

@@ -1,16 +0,0 @@
-import type { Persistence } from './types.js';
-/**
- * Create an in-memory persistence factory.
- *
- * Useful for testing where you don't want IndexedDB side effects.
- *
- * @example
- * ```typescript
- * // In tests
- * convexCollectionOptions<Task>({
- *   // ... other options
- *   persistence: memoryPersistence(),
- * });
- * ```
- */
-export declare function memoryPersistence(): Persistence;

package/dist/client/persistence/sqlite-browser.d.ts

@@ -1,51 +0,0 @@
-/**
- * Browser SQLite persistence helper using sql.js and OPFS.
- *
- * Handles all the boilerplate for browser SQLite:
- * - Loading existing database from OPFS
- * - Persisting to OPFS on every write
- * - Creating the SqlJsAdapter
- *
- * @example
- * ```typescript
- * import { createBrowserSqlitePersistence } from '@trestleinc/replicate/client';
- * import initSqlJs from 'sql.js';
- *
- * const SQL = await initSqlJs({ locateFile: f => `https://sql.js.org/dist/${f}` });
- * const persistence = await createBrowserSqlitePersistence(SQL, 'myapp');
- * ```
- */
-import { type SqlJsDatabase } from './adapters/sqljs.js';
-import type { Persistence } from './types.js';
-/**
- * Interface for the sql.js module (the result of initSqlJs).
- */
-export interface SqlJsStatic {
-    Database: new (data?: ArrayLike<number>) => SqlJsDatabase;
-}
-/**
- * Create browser SQLite persistence with OPFS storage.
- *
- * This helper handles all the OPFS boilerplate:
- * - Loads existing database from OPFS on init
- * - Persists to OPFS after every write operation
- *
- * @param SQL - The initialized sql.js module (from `await initSqlJs()`)
- * @param dbName - Name for the database (used for OPFS filename: `{dbName}.sqlite`)
- *
- * @example
- * ```typescript
- * import { createBrowserSqlitePersistence } from '@trestleinc/replicate/client';
- * import initSqlJs from 'sql.js';
- *
- * const SQL = await initSqlJs({ locateFile: f => `https://sql.js.org/dist/${f}` });
- * const persistence = await createBrowserSqlitePersistence(SQL, 'intervals');
- *
- * // Use in collection options
- * convexCollectionOptions<Task>({
- *   // ...
- *   persistence,
- * });
- * ```
- */
-export declare function createBrowserSqlitePersistence(SQL: SqlJsStatic, dbName: string): Promise<Persistence>;

package/dist/client/persistence/sqlite-level.d.ts

@@ -1,63 +0,0 @@
-/**
- * SQLite-backed abstract-level implementation.
- *
- * Provides a LevelDB-compatible key-value store backed by SQLite,
- * enabling y-leveldb to work with SQLite databases.
- *
- * Supports both browser (sql.js WASM) and React Native (op-sqlite).
- */
-import { AbstractLevel, AbstractIterator, AbstractKeyIterator, AbstractValueIterator } from 'abstract-level';
-/**
- * Interface for SQLite database operations.
- * Abstracts over sql.js (browser) and op-sqlite (React Native).
- */
-export interface SqliteAdapter {
-    execute(sql: string, params?: unknown[]): Promise<{
-        rows: Record<string, unknown>[];
-    }>;
-    close(): void;
-}
-interface SqliteLevelOptions {
-    /** Custom SQLite adapter (for testing or alternative backends) */
-    adapter?: SqliteAdapter;
-    /** Value encoding (default: 'utf8') */
-    valueEncoding?: string;
-    keyEncoding?: string;
-}
-/**
- * SQLite-backed implementation of abstract-level.
- *
- * Uses a simple key-value table with lexicographic ordering:
- * CREATE TABLE entries (key BLOB PRIMARY KEY, value BLOB)
- */
-export declare class SqliteLevel<K = string, V = string> extends AbstractLevel<K, V> {
-    private adapter;
-    private adapterFactory;
-    constructor(_location: string, options?: SqliteLevelOptions);
-    /**
-     * Set the adapter factory for deferred initialization.
-     * Call this before open() to configure the SQLite backend.
-     */
-    setAdapterFactory(factory: () => Promise<SqliteAdapter>): void;
-    _open(): Promise<void>;
-    _close(): Promise<void>;
-    _get(key: K): Promise<V | undefined>;
-    _put(key: K, value: V): Promise<void>;
-    _del(key: K): Promise<void>;
-    _batch(operations: Array<{
-        type: 'put';
-        key: K;
-        value: V;
-    } | {
-        type: 'del';
-        key: K;
-    }>): Promise<void>;
-    _clear(): Promise<void>;
-    _iterator(options: Record<string, unknown>): AbstractIterator<typeof this, K, V>;
-    _keys(options: Record<string, unknown>): AbstractKeyIterator<typeof this, K>;
-    _values(options: Record<string, unknown>): AbstractValueIterator<typeof this, K, V>;
-    private encodeKey;
-    private encodeValue;
-    private decodeValue;
-}
-export {};

package/dist/client/persistence/sqlite-rn.d.ts

@@ -1,36 +0,0 @@
-/**
- * React Native SQLite persistence helper using op-sqlite.
- *
- * @example
- * ```typescript
- * import { createReactNativeSqlitePersistence } from '@trestleinc/replicate/client';
- * import { open } from '@op-engineering/op-sqlite';
- *
- * const db = open({ name: 'myapp.db' });
- * const persistence = await createReactNativeSqlitePersistence(db, 'myapp');
- * ```
- */
-import { type OPSQLiteDatabase } from './adapters/opsqlite.js';
-import type { Persistence } from './types.js';
-/**
- * Create React Native SQLite persistence using op-sqlite.
- *
- * @param db - The opened op-sqlite database instance
- * @param dbName - Name for internal database identification
- *
- * @example
- * ```typescript
- * import { createReactNativeSqlitePersistence } from '@trestleinc/replicate/client';
- * import { open } from '@op-engineering/op-sqlite';
- *
- * const db = open({ name: 'myapp.db' });
- * const persistence = await createReactNativeSqlitePersistence(db, 'myapp');
- *
- * // Use in collection options
- * convexCollectionOptions<Task>({
- *   // ...
- *   persistence,
- * });
- * ```
- */
-export declare function createReactNativeSqlitePersistence(db: OPSQLiteDatabase, dbName: string): Promise<Persistence>;

package/dist/client/persistence/sqlite.d.ts

@@ -1,47 +0,0 @@
-import { type SqliteAdapter } from './sqlite-level.js';
-import type { Persistence } from './types.js';
-/**
- * Options for SQLite persistence.
- */
-export interface SqlitePersistenceOptions {
-    /**
-     * Pre-created SQLite adapter (required).
-     * Use SqlJsAdapter for browser or OPSqliteAdapter for React Native.
-     */
-    adapter: SqliteAdapter;
-    /**
-     * Database name for internal y-leveldb usage.
-     * @default 'replicate'
-     */
-    dbName?: string;
-}
-/**
- * Create a universal SQLite persistence factory.
- *
- * Requires a pre-created SqliteAdapter - the replicate package does not
- * import any SQLite packages directly, making it environment-agnostic.
- *
- * @param options - Configuration with required adapter
- *
- * @example Browser (sql.js)
- * ```typescript
- * import initSqlJs from 'sql.js';
- * import { sqlitePersistence, SqlJsAdapter } from '@trestleinc/replicate/client';
- *
- * const SQL = await initSqlJs();
- * const db = new SQL.Database();
- * const adapter = new SqlJsAdapter(db);
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- *
- * @example React Native (op-sqlite)
- * ```typescript
- * import { open } from '@op-engineering/op-sqlite';
- * import { sqlitePersistence, OPSqliteAdapter } from '@trestleinc/replicate/client';
- *
- * const db = open({ name: 'myapp.db' });
- * const adapter = new OPSqliteAdapter(db);
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- */
-export declare function sqlitePersistence(options: SqlitePersistenceOptions): Promise<Persistence>;

package/dist/client/persistence/types.d.ts

@@ -1,42 +0,0 @@
-/**
- * Persistence layer types for swappable storage backends.
- *
- * Supports IndexedDB (browser), SQLite (React Native), and in-memory (testing).
- */
-import type * as Y from 'yjs';
-/**
- * Provider that persists Y.Doc state to storage.
- *
- * This wraps providers like y-indexeddb or y-op-sqlite, normalizing their APIs.
- */
-export interface PersistenceProvider {
-    /** Promise that resolves when initial sync from storage completes */
-    readonly whenSynced: Promise<void>;
-    /** Clean up resources (stop observing, close connections) */
-    destroy(): void;
-}
-/**
- * Factory that creates persistence providers.
- *
- * Each persistence implementation (IndexedDB, SQLite, memory) exports a
- * factory function that returns this interface.
- */
-export interface Persistence {
-    /** Create a Y.Doc persistence provider for a collection */
-    createDocPersistence(collection: string, ydoc: Y.Doc): PersistenceProvider;
-    /** Key-value store for metadata (checkpoints, clientID) */
-    readonly kv: KeyValueStore;
-}
-/**
- * Simple key-value storage interface.
- *
- * Used for storing metadata like checkpoints and Yjs client IDs.
- */
-export interface KeyValueStore {
-    /** Get a value by key */
-    get<T>(key: string): Promise<T | undefined>;
-    /** Set a value by key */
-    set<T>(key: string, value: T): Promise<void>;
-    /** Delete a value by key */
-    del(key: string): Promise<void>;
-}

package/dist/client/prose.d.ts

@@ -1,56 +0,0 @@
-/**
- * Prose Field Helpers - Document-level state management for rich text sync
- *
- * Manages Y.XmlFragment observation, debounced sync, and pending state.
- * Uses document-level tracking to prevent race conditions.
- */
-import * as Y from 'yjs';
-import type { Collection } from '@tanstack/db';
-/**
- * Check if a document is currently applying server data.
- * Used to prevent echo loops in onUpdate handlers.
- */
-export declare function isApplyingFromServer(collection: string, documentId: string): boolean;
-/**
- * Set whether a document is currently applying server data.
- */
-export declare function setApplyingFromServer(collection: string, documentId: string, value: boolean): void;
-/**
- * Get current pending state for a document.
- */
-export declare function isPending(collection: string, documentId: string): boolean;
-/**
- * Subscribe to pending state changes for a document.
- */
-export declare function subscribePending(collection: string, documentId: string, callback: (pending: boolean) => void): () => void;
-/**
- * Cancel any pending debounced sync for a document.
- * Called when receiving remote updates to avoid conflicts.
- */
-export declare function cancelPending(collection: string, documentId: string): void;
-/**
- * Cancel all pending syncs for a collection.
- * Called when receiving a snapshot that replaces all state.
- */
-export declare function cancelAllPending(collection: string): void;
-/** Configuration for fragment observation */
-export interface ProseObserverConfig {
-    collection: string;
-    documentId: string;
-    field: string;
-    fragment: Y.XmlFragment;
-    ydoc: Y.Doc;
-    ymap: Y.Map<unknown>;
-    collectionRef: Collection<any>;
-    debounceMs?: number;
-}
-/**
- * Set up observation for a prose field's Y.XmlFragment.
- * Returns a cleanup function.
- */
-export declare function observeFragment(config: ProseObserverConfig): () => void;
-/**
- * Clean up all prose state for a collection.
- * Called when collection is destroyed.
- */
-export declare function cleanup(collection: string): void;