@dabble/patches 0.8.0 → 0.8.2

package/dist/algorithms/ot/shared/rebaseChanges.js

@@ -20,12 +20,13 @@ function rebaseChanges(serverChanges, localChanges) {
   );
   const baseRev = lastChange.rev;
   let rev = lastChange.rev;
-  const result = filteredLocalChanges.map((change) => {
-    rev++;
+  const result = [];
+  for (const change of filteredLocalChanges) {
     const ops = transformPatch.transform(change.ops).ops;
-    if (!ops.length) return null;
-    return { ...change, baseRev, rev, ops };
-  }).filter(Boolean);
+    if (!ops.length) continue;
+    rev++;
+    result.push({ ...change, baseRev, rev, ops });
+  }
   return result;
 }
 export {

package/dist/client/LWWDoc.js

@@ -17,13 +17,8 @@ class LWWDoc extends BaseDoc {
     this._committedRev = snapshot?.rev ?? 0;
     this._hasPending = (snapshot?.changes?.length ?? 0) > 0;
     if (snapshot?.changes && snapshot.changes.length > 0) {
-      let currentState = this.state;
-      for (const change of snapshot.changes) {
-        for (const op of change.ops) {
-          currentState = applyPatch(currentState, [op], { partial: true });
-        }
-      }
-      this.state = currentState;
+      const allOps = snapshot.changes.flatMap((c) => c.ops);
+      this.state = applyPatch(this.state, allOps, { partial: true });
     }
     this._baseState = this.state;
     this._checkLoaded();
@@ -46,11 +41,11 @@ class LWWDoc extends BaseDoc {
     this._optimisticOps = [];
     let currentState = snapshot.state;
     if (snapshot.changes && snapshot.changes.length > 0) {
-      for (const change of snapshot.changes) {
-        for (const op of change.ops) {
-          currentState = applyPatch(currentState, [op], { partial: true });
-        }
-      }
+      currentState = applyPatch(
+        currentState,
+        snapshot.changes.flatMap((c) => c.ops),
+        { partial: true }
+      );
     }
     this._baseState = currentState;
     this._checkLoaded();
@@ -97,20 +92,12 @@ class LWWDoc extends BaseDoc {
     this._hasPending = hasPending ?? hasPendingChanges;
     this._checkLoaded();
     if (hasServerChanges) {
-      let newBaseState = this._baseState;
-      for (const change of changes) {
-        for (const op of change.ops) {
-          newBaseState = applyPatch(newBaseState, [op], { partial: true });
-        }
-      }
-      this._baseState = newBaseState;
+      const allOps = changes.flatMap((c) => c.ops);
+      this._baseState = applyPatch(this._baseState, allOps, { partial: true });
       this._recomputeState();
     } else {
-      for (const change of changes) {
-        for (const op of change.ops) {
-          this._baseState = applyPatch(this._baseState, [op], { partial: true });
-        }
-      }
+      const allOps = changes.flatMap((c) => c.ops);
+      this._baseState = applyPatch(this._baseState, allOps, { partial: true });
       if (this._optimisticOps.length > 0) {
         this._optimisticOps.shift();
       } else {

package/dist/client/Patches.js

@@ -102,8 +102,6 @@ class Patches {
     if (!docIds.length) return;
     docIds.forEach(this.trackedDocs.delete, this.trackedDocs);
     this.onUntrackDocs.emit(docIds);
-    const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
-    await Promise.all(closedPromises);
     const byAlgorithm = /* @__PURE__ */ new Map();
     for (const docId of docIds) {
       const managed = this.docs.get(docId);
@@ -112,6 +110,8 @@ class Patches {
       list.push(docId);
       byAlgorithm.set(algorithm, list);
     }
+    const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
+    await Promise.all(closedPromises);
     await Promise.all([...byAlgorithm.entries()].map(([algorithm, ids]) => algorithm.untrackDocs(ids)));
   }
   // ensure a second call to openDoc with the same docId returns the same promise while opening

package/dist/client/PatchesDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/PatchesDoc.js

@@ -1,6 +1,5 @@
 import "../chunk-IZ2YBCUP.js";
-import { OTDoc, OTDoc as OTDoc2 } from "./OTDoc.js";
+import { OTDoc } from "./OTDoc.js";
 export {
-  OTDoc,
-  OTDoc2 as PatchesDocClass
+  OTDoc
 };

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BaseDoc, O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';

package/dist/{index-C7ZhU2kS.d.ts → index-BO6EQFpw.d.ts}

@@ -1,4 +1,4 @@
-import { JSONPatchOpHandlerMap, JSONPatchOpHandler } from './json-patch/types.js';
+import { JSONPatchOpHandlerMap } from './json-patch/types.js';
 import { add } from './json-patch/ops/add.js';
 import { bit } from './json-patch/ops/bitmask.js';
 import { copy } from './json-patch/ops/copy.js';
@@ -9,19 +9,7 @@ import { remove } from './json-patch/ops/remove.js';
 import { replace } from './json-patch/ops/replace.js';
 import { test } from './json-patch/ops/test.js';
 
-declare function getTypes(custom?: JSONPatchOpHandlerMap): {
-    test: JSONPatchOpHandler;
-    add: JSONPatchOpHandler;
-    remove: JSONPatchOpHandler;
-    replace: JSONPatchOpHandler;
-    copy: JSONPatchOpHandler;
-    move: JSONPatchOpHandler;
-    '@inc': JSONPatchOpHandler;
-    '@bit': JSONPatchOpHandler;
-    '@txt': JSONPatchOpHandler;
-    '@max': JSONPatchOpHandler;
-    '@min': JSONPatchOpHandler;
-};
+declare function getTypes(custom?: JSONPatchOpHandlerMap): JSONPatchOpHandlerMap;
 
 declare const index_add: typeof add;
 declare const index_bit: typeof bit;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Delta } from '@dabble/delta';
-export { B as BaseDoc, O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from './BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from './BaseDoc-BT18xPxU.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';
@@ -18,25 +18,25 @@ export { LWWClientStore } from './client/LWWClientStore.js';
 export { ClientAlgorithm } from './client/ClientAlgorithm.js';
 export { createChange } from './data/change.js';
 export { createVersionId, createVersionMetadata } from './data/version.js';
-export { ReadonlyStore, Signal, SignalSubscriber, Store, Subscriber, Unsubscriber, afterChange, batch, clearAllContext, computed, readonly, signal, store, watch, whenMatches, whenReady } from 'easy-signal';
+export { ReadonlyStore, Signal, SignalSubscriber, Store, Subscriber, Unsubscriber, batch, computed, readonly, signal, store, watch } from 'easy-signal';
 export { fractionalIndex, healDuplicateOrders, sortByOrder } from './fractionalIndex.js';
 export { applyPatch } from './json-patch/applyPatch.js';
 export { composePatch } from './json-patch/composePatch.js';
 export { invertPatch } from './json-patch/invertPatch.js';
-export { applyBitmask, bit, bitmask, combineBitmasks } from './json-patch/ops/bitmask.js';
-export { i as defaultOps, g as getTypes } from './index-C7ZhU2kS.js';
+export { applyBitmask, bitmask, combineBitmasks } from './json-patch/ops/bitmask.js';
+export { i as defaultOps } from './index-BO6EQFpw.js';
 export { createPathProxy, pathProxy } from './json-patch/pathProxy.js';
 export { transformPatch } from './json-patch/transformPatch.js';
 export { JSONPatch, PathLike, WriteOptions } from './json-patch/JSONPatch.js';
-export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './json-patch/types.js';
+export { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './json-patch/types.js';
 export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocSyncState, DocSyncStatus, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, VersionMetadata } from './types.js';
-export { add } from './json-patch/ops/add.js';
-export { copy } from './json-patch/ops/copy.js';
-export { increment } from './json-patch/ops/increment.js';
-export { max, min } from './json-patch/ops/minmax.js';
-export { move } from './json-patch/ops/move.js';
-export { remove } from './json-patch/ops/remove.js';
-export { replace } from './json-patch/ops/replace.js';
-export { test } from './json-patch/ops/test.js';
 import './utils/deferred.js';
 import './net/protocol/types.js';
+import './json-patch/ops/add.js';
+import './json-patch/ops/copy.js';
+import './json-patch/ops/increment.js';
+import './json-patch/ops/minmax.js';
+import './json-patch/ops/move.js';
+import './json-patch/ops/remove.js';
+import './json-patch/ops/replace.js';
+import './json-patch/ops/test.js';

package/dist/index.js

@@ -9,24 +9,16 @@ import {
   readonly,
   computed,
   batch,
-  watch,
-  whenReady,
-  whenMatches,
-  afterChange,
-  clearAllContext
+  watch
 } from "easy-signal";
 export * from "./fractionalIndex.js";
 export * from "./json-patch/index.js";
 export {
   Delta,
-  afterChange,
   batch,
-  clearAllContext,
   computed,
   readonly,
   signal,
   store,
-  watch,
-  whenMatches,
-  whenReady
+  watch
 };

package/dist/json-patch/index.d.ts

@@ -1,19 +1,19 @@
 export { applyPatch } from './applyPatch.js';
 export { composePatch } from './composePatch.js';
 export { invertPatch } from './invertPatch.js';
-export { applyBitmask, bit, bitmask, combineBitmasks } from './ops/bitmask.js';
-export { i as defaultOps, g as getTypes } from '../index-C7ZhU2kS.js';
+export { applyBitmask, bitmask, combineBitmasks } from './ops/bitmask.js';
+export { i as defaultOps } from '../index-BO6EQFpw.js';
 export { createPathProxy, pathProxy } from './pathProxy.js';
 export { transformPatch } from './transformPatch.js';
 export { JSONPatch, PathLike, WriteOptions } from './JSONPatch.js';
-export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './types.js';
-export { add } from './ops/add.js';
-export { copy } from './ops/copy.js';
-export { increment } from './ops/increment.js';
-export { max, min } from './ops/minmax.js';
-export { move } from './ops/move.js';
-export { remove } from './ops/remove.js';
-export { replace } from './ops/replace.js';
-export { test } from './ops/test.js';
+export { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+import './ops/add.js';
+import './ops/copy.js';
+import './ops/increment.js';
+import './ops/minmax.js';
+import './ops/move.js';
+import './ops/remove.js';
+import './ops/replace.js';
+import './ops/test.js';
 import '../types.js';
 import '@dabble/delta';

package/dist/json-patch/index.js

@@ -7,7 +7,6 @@ import * as defaultOps from "./ops/index.js";
 export * from "./pathProxy.js";
 import { transformPatch } from "./transformPatch.js";
 export * from "./JSONPatch.js";
-export * from "./ops/index.js";
 export {
   applyBitmask,
   applyPatch,

package/dist/json-patch/ops/index.d.ts

@@ -8,4 +8,4 @@ export { move } from './move.js';
 export { remove } from './remove.js';
 export { replace } from './replace.js';
 export { test } from './test.js';
-export { g as getTypes } from '../../index-C7ZhU2kS.js';
+export { g as getTypes } from '../../index-BO6EQFpw.js';

package/dist/json-patch/ops/index.js

@@ -9,21 +9,22 @@ import { remove } from "./remove.js";
 import { replace } from "./replace.js";
 import { test } from "./test.js";
 import { text } from "./text.js";
+const defaultTypes = {
+  test,
+  add,
+  remove,
+  replace,
+  copy,
+  move,
+  "@inc": increment,
+  "@bit": bit,
+  "@txt": text,
+  "@max": max,
+  "@min": min
+};
 function getTypes(custom) {
-  return {
-    test,
-    add,
-    remove,
-    replace,
-    copy,
-    move,
-    "@inc": increment,
-    "@bit": bit,
-    "@txt": text,
-    "@max": max,
-    "@min": min,
-    ...custom
-  };
+  if (!custom || Object.keys(custom).length === 0) return defaultTypes;
+  return { ...defaultTypes, ...custom };
 }
 export {
   add,

package/dist/json-patch/utils/getType.d.ts

@@ -1,6 +1,6 @@
 import { State, JSONPatchOp, JSONPatchOpHandler } from '../types.js';
 
 declare function getType(state: State, patch: JSONPatchOp): JSONPatchOpHandler;
-declare function getTypeLike(state: State, patch: JSONPatchOp): "test" | "add" | "remove" | "replace" | "copy" | "move";
+declare function getTypeLike(state: State, patch: JSONPatchOp): "add" | "remove" | "replace" | "move" | "copy" | "test";
 
 export { getType, getTypeLike };

package/dist/micro/client.d.ts

@@ -0,0 +1,44 @@
+import { Signal } from 'easy-signal';
+import { MicroDoc } from './doc.js';
+import '@dabble/delta';
+import './types.js';
+
+interface ClientOptions {
+    /** Base URL for REST API, e.g. "https://api.example.com" */
+    url: string;
+    /** If provided, persists state to IndexedDB with this database name. */
+    dbName?: string;
+    /** Debounce delay in ms before flushing pending ops. Default: 300 */
+    debounce?: number;
+}
+declare class MicroClient {
+    private _url;
+    private _dbName?;
+    private _debounce;
+    private _docs;
+    private _ws;
+    private _wsBackoff;
+    private _wsTimer;
+    private _db;
+    readonly onConnection: Signal<(connected: boolean) => void>;
+    constructor(opts: ClientOptions);
+    /** Open a document. Fetches from server (or IDB cache), subscribes via WS. */
+    open<T = Record<string, any>>(docId: string): Promise<MicroDoc<T>>;
+    /** Close a document subscription. */
+    close(docId: string): void;
+    /** Force flush pending ops for a document immediately. */
+    flush(docId: string): Promise<void>;
+    /** Disconnect WebSocket and clean up. */
+    destroy(): void;
+    private _scheduleFlush;
+    private _doFlush;
+    private _ensureWS;
+    private _reconnectWS;
+    private _wsSend;
+    private _fetch;
+    private _idbOpen;
+    private _idbLoad;
+    private _idbSave;
+}
+
+export { type ClientOptions, MicroClient };

package/dist/micro/client.js

@@ -0,0 +1,224 @@
+import "../chunk-IZ2YBCUP.js";
+import { signal } from "easy-signal";
+import { MicroDoc } from "./doc.js";
+import { transformPendingTxt } from "./ops.js";
+class MicroClient {
+  _url;
+  _dbName;
+  _debounce;
+  _docs = /* @__PURE__ */ new Map();
+  _ws = null;
+  _wsBackoff = 0;
+  _wsTimer = null;
+  _db = null;
+  onConnection = signal();
+  constructor(opts) {
+    this._url = opts.url.replace(/\/$/, "");
+    this._dbName = opts.dbName;
+    this._debounce = opts.debounce ?? 300;
+  }
+  /** Open a document. Fetches from server (or IDB cache), subscribes via WS. */
+  async open(docId) {
+    if (this._docs.has(docId)) return this._docs.get(docId).doc;
+    let state = { rev: 0, fields: {} };
+    let pending = {};
+    if (this._dbName) {
+      const cached = await this._idbLoad(docId);
+      if (cached) {
+        state = { rev: cached.rev, fields: cached.fields };
+        pending = cached.pending;
+      }
+    }
+    try {
+      if (state.rev > 0 && Object.keys(pending).length) {
+        try {
+          const sync = await this._fetch(`/docs/${docId}/sync?since=${state.rev}`);
+          if (sync.rev > state.rev) {
+            Object.assign(state.fields, sync.fields);
+            pending = transformPendingTxt(pending, sync.textLog);
+            state.rev = sync.rev;
+          }
+        } catch {
+          const remote = await this._fetch(`/docs/${docId}`);
+          if (remote.rev > state.rev) {
+            state = remote;
+            pending = {};
+          }
+        }
+      } else {
+        const remote = await this._fetch(`/docs/${docId}`);
+        if (remote.rev > state.rev) {
+          state = remote;
+          pending = {};
+        }
+      }
+    } catch {
+    }
+    const doc = new MicroDoc(state.fields, pending, state.rev);
+    const entry = { doc, timer: null };
+    this._docs.set(docId, entry);
+    doc._onUpdate = () => this._scheduleFlush(docId);
+    this._ensureWS();
+    this._wsSend({ type: "sub", docId });
+    return doc;
+  }
+  /** Close a document subscription. */
+  close(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry) return;
+    if (entry.timer) clearTimeout(entry.timer);
+    this._docs.delete(docId);
+    this._wsSend({ type: "unsub", docId });
+  }
+  /** Force flush pending ops for a document immediately. */
+  async flush(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry) return;
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+      entry.timer = null;
+    }
+    await this._doFlush(docId, entry);
+  }
+  /** Disconnect WebSocket and clean up. */
+  destroy() {
+    for (const entry of this._docs.values()) {
+      if (entry.timer) clearTimeout(entry.timer);
+    }
+    this._docs.clear();
+    if (this._wsTimer) clearTimeout(this._wsTimer);
+    this._ws?.close();
+    this._ws = null;
+    this._db?.close();
+    this._db = null;
+  }
+  // --- Sync ---
+  _scheduleFlush(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry || entry.timer) return;
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      this._doFlush(docId, entry);
+    }, this._debounce);
+  }
+  async _doFlush(docId, entry) {
+    const change = entry.doc._flush();
+    if (!change) return;
+    if (this._dbName) this._idbSave(docId, entry.doc);
+    try {
+      const result = await this._fetch(`/docs/${docId}/changes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(change)
+      });
+      entry.doc._confirmSend(result.rev);
+      if (this._dbName) this._idbSave(docId, entry.doc);
+      if (Object.keys(entry.doc.pending).length) this._scheduleFlush(docId);
+    } catch {
+      entry.doc._failSend();
+      entry.timer = setTimeout(() => {
+        entry.timer = null;
+        this._doFlush(docId, entry);
+      }, 2e3);
+    }
+  }
+  // --- WebSocket ---
+  _ensureWS() {
+    if (this._ws && this._ws.readyState <= WebSocket.OPEN) return;
+    const wsUrl = this._url.replace(/^http/, "ws") + "/ws";
+    const ws = new WebSocket(wsUrl);
+    this._ws = ws;
+    ws.onopen = () => {
+      this._wsBackoff = 0;
+      this.onConnection.emit(true);
+      for (const docId of this._docs.keys()) {
+        this._wsSend({ type: "sub", docId });
+      }
+    };
+    ws.onmessage = (e) => {
+      try {
+        const msg = JSON.parse(e.data);
+        if (msg.type === "change" && msg.docId) {
+          const entry = this._docs.get(msg.docId);
+          if (entry) entry.doc.applyRemote(msg.fields, msg.rev);
+        }
+      } catch {
+      }
+    };
+    ws.onclose = () => {
+      this.onConnection.emit(false);
+      this._reconnectWS();
+    };
+    ws.onerror = () => ws.close();
+  }
+  _reconnectWS() {
+    if (this._wsTimer) return;
+    const delay = Math.min(1e3 * 2 ** this._wsBackoff, 3e4);
+    this._wsBackoff++;
+    this._wsTimer = setTimeout(() => {
+      this._wsTimer = null;
+      if (this._docs.size > 0) this._ensureWS();
+    }, delay);
+  }
+  _wsSend(msg) {
+    if (this._ws?.readyState === WebSocket.OPEN) {
+      this._ws.send(JSON.stringify(msg));
+    }
+  }
+  // --- REST ---
+  async _fetch(path, init) {
+    const res = await fetch(this._url + path, init);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.json();
+  }
+  // --- IndexedDB ---
+  async _idbOpen() {
+    if (this._db) return this._db;
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains("docs")) db.createObjectStore("docs");
+        if (!db.objectStoreNames.contains("pending")) db.createObjectStore("pending");
+      };
+      req.onsuccess = () => {
+        this._db = req.result;
+        resolve(req.result);
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async _idbLoad(docId) {
+    try {
+      const db = await this._idbOpen();
+      const tx = db.transaction(["docs", "pending"], "readonly");
+      const [docData, pendingData] = await Promise.all([
+        idbGet(tx.objectStore("docs"), docId),
+        idbGet(tx.objectStore("pending"), docId)
+      ]);
+      if (!docData) return null;
+      return { fields: docData.fields, rev: docData.rev, pending: pendingData?.ops ?? {} };
+    } catch {
+      return null;
+    }
+  }
+  async _idbSave(docId, doc) {
+    try {
+      const db = await this._idbOpen();
+      const tx = db.transaction(["docs", "pending"], "readwrite");
+      tx.objectStore("docs").put({ fields: doc.confirmed, rev: doc.rev }, docId);
+      tx.objectStore("pending").put({ ops: doc.pending }, docId);
+    } catch {
+    }
+  }
+}
+function idbGet(store, key) {
+  return new Promise((resolve, reject) => {
+    const req = store.get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+export {
+  MicroClient
+};

package/dist/micro/doc.d.ts

@@ -0,0 +1,51 @@
+import { Delta } from '@dabble/delta';
+import { Subscriber, Unsubscriber } from 'easy-signal';
+import { FieldMap, Change } from './types.js';
+
+interface BaseUpdates<T> {
+    set(val: T): void;
+    del(): void;
+}
+interface NumberUpdates extends BaseUpdates<number> {
+    inc(val?: number): void;
+    bit(val: number): void;
+    max(val: number): void;
+}
+interface StringUpdates extends BaseUpdates<string> {
+    max(val: string): void;
+}
+interface DeltaUpdates extends BaseUpdates<Delta> {
+    txt(delta: Delta): void;
+}
+type Updatable<T> = T extends Delta ? DeltaUpdates : T extends number ? NumberUpdates : T extends string ? StringUpdates : T extends object ? {
+    [K in keyof T]-?: Updatable<NonNullable<T[K]>>;
+} & BaseUpdates<T> : BaseUpdates<T>;
+declare class MicroDoc<T = Record<string, any>> {
+    rev: number;
+    private _store;
+    private _confirmed;
+    private _sending;
+    private _sendingId;
+    private _pending;
+    /** Called by client when ops are queued. */
+    _onUpdate?: () => void;
+    constructor(confirmed?: FieldMap, pending?: FieldMap, rev?: number);
+    get state(): T;
+    get pending(): FieldMap;
+    get confirmed(): FieldMap;
+    get isSending(): boolean;
+    subscribe(cb: Subscriber<T>, noInit?: false): Unsubscriber;
+    /** Apply changes via proxy-based updater. */
+    update(fn: (doc: Updatable<T>) => void): void;
+    /** Move pending to sending, return the Change to POST. Returns null if nothing to send. */
+    _flush(): Change | null;
+    /** Confirm a successful send. Merge sending into confirmed. */
+    _confirmSend(rev: number): void;
+    /** Roll sending back into pending on failure. */
+    _failSend(): void;
+    /** Apply remote fields from another client (via WS push). */
+    applyRemote(fields: FieldMap, rev: number): void;
+    private _rebuild;
+}
+
+export { MicroDoc, type Updatable };