@dabble/patches 0.5.12 → 0.5.13

package/dist/index.d.ts

@@ -17,7 +17,7 @@ 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 { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata } from './types.js';
+export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata } from './types.js';
 export { clampTimestamp, extractTimezoneOffset, getISO, getLocalISO, getLocalTimezoneOffset, timestampDiff } from './utils/dates.js';
 export { add } from './json-patch/ops/add.js';
 export { copy } from './json-patch/ops/copy.js';

package/dist/net/PatchesClient.d.ts

@@ -17,6 +17,8 @@ declare class PatchesClient implements PatchesAPI {
     transport: ClientTransport;
     /** Signal emitted when the server pushes document changes. */
     readonly onChangesCommitted: Signal<(docId: string, changes: Change[]) => void>;
+    /** Signal emitted when a document is deleted (either by another client or discovered on subscribe). */
+    readonly onDocDeleted: Signal<(docId: string) => void>;
     /**
      * Creates a new Patches WebSocket client instance.
      * @param url - The WebSocket server URL to connect to

package/dist/net/PatchesClient.js

@@ -7,6 +7,8 @@ class PatchesClient {
   // --- Public Signals ---
   /** Signal emitted when the server pushes document changes. */
   onChangesCommitted = signal();
+  /** Signal emitted when a document is deleted (either by another client or discovered on subscribe). */
+  onDocDeleted = signal();
   /**
    * Creates a new Patches WebSocket client instance.
    * @param url - The WebSocket server URL to connect to
@@ -19,6 +21,9 @@ class PatchesClient {
       const { docId, changes } = params;
       this.onChangesCommitted.emit(docId, changes);
     });
+    this.rpc.on("docDeleted", (params) => {
+      this.onDocDeleted.emit(params.docId);
+    });
   }
   // --- Patches API Methods ---
   // === Subscription Operations ===

package/dist/net/PatchesSync.d.ts

@@ -53,6 +53,11 @@ declare class PatchesSync {
     readonly onError: Signal<(error: Error, context?: {
         docId?: string;
     }) => void>;
+    /**
+     * Signal emitted when a document is deleted remotely (by another client or discovered via tombstone).
+     * Provides the pending changes that were discarded so the application can handle them.
+     */
+    readonly onRemoteDocDeleted: Signal<(docId: string, pendingChanges: Change[]) => void>;
     constructor(patches: Patches, url: string, options?: PatchesSyncOptions | undefined);
     /**
      * Gets the URL of the WebSocket connection.
@@ -119,6 +124,15 @@ declare class PatchesSync {
     protected _handleDocsTracked(docIds: string[]): Promise<void>;
     protected _handleDocsUntracked(docIds: string[]): Promise<void>;
     protected _handleDocChange(docId: string, _changes: Change[]): Promise<void>;
+    /**
+     * Unified handler for remote document deletion (both real-time notifications and offline discovery).
+     * Cleans up local state and notifies the application with any pending changes that were lost.
+     */
+    protected _handleRemoteDocDeleted(docId: string): Promise<void>;
+    /**
+     * Helper to detect DOC_DELETED (410) errors from the server.
+     */
+    protected _isDocDeletedError(err: unknown): boolean;
 }
 
 export { PatchesSync, type PatchesSyncOptions, type PatchesSyncState };

package/dist/net/PatchesSync.js

@@ -35,6 +35,11 @@ class PatchesSync {
      * Signal emitted when an error occurs.
      */
     __publicField(this, "onError", signal());
+    /**
+     * Signal emitted when a document is deleted remotely (by another client or discovered via tombstone).
+     * Provides the pending changes that were discarded so the application can handle them.
+     */
+    __publicField(this, "onRemoteDocDeleted", signal());
     this.patches = patches;
     this.store = patches.store;
     this.maxPayloadBytes = options?.maxPayloadBytes;
@@ -46,6 +51,7 @@ class PatchesSync {
     onlineState.onOnlineChange((online) => this.updateState({ online }));
     this.ws.onStateChange(this._handleConnectionChange.bind(this));
     this.ws.onChangesCommitted(this._receiveCommittedChanges.bind(this));
+    this.ws.onDocDeleted((docId) => this._handleRemoteDocDeleted(docId));
     patches.onTrackDocs(this._handleDocsTracked.bind(this));
     patches.onUntrackDocs(this._handleDocsUntracked.bind(this));
     patches.onDeleteDoc(this._handleDocDeleted.bind(this));
@@ -183,6 +189,10 @@ class PatchesSync {
         doc.updateSyncing(null);
       }
     } catch (err) {
+      if (this._isDocDeletedError(err)) {
+        await this._handleRemoteDocDeleted(docId);
+        return;
+      }
       console.error(`Error syncing doc ${docId}:`, err);
       this.onError.emit(err, { docId });
       if (doc) {
@@ -221,6 +231,10 @@ class PatchesSync {
         pending = await this.store.getPendingChanges(docId);
       }
     } catch (err) {
+      if (this._isDocDeletedError(err)) {
+        await this._handleRemoteDocDeleted(docId);
+        return;
+      }
       console.error(`Flush failed for doc ${docId}:`, err);
       this.onError.emit(err, { docId });
       throw err;
@@ -328,6 +342,26 @@ class PatchesSync {
     if (!this.trackedDocs.has(docId)) return;
     await this.flushDoc(docId);
   }
+  /**
+   * Unified handler for remote document deletion (both real-time notifications and offline discovery).
+   * Cleans up local state and notifies the application with any pending changes that were lost.
+   */
+  async _handleRemoteDocDeleted(docId) {
+    const pendingChanges = await this.store.getPendingChanges(docId);
+    const doc = this.patches.getOpenDoc(docId);
+    if (doc) {
+      await this.patches.closeDoc(docId);
+    }
+    this.trackedDocs.delete(docId);
+    await this.store.confirmDeleteDoc(docId);
+    await this.onRemoteDocDeleted.emit(docId, pendingChanges);
+  }
+  /**
+   * Helper to detect DOC_DELETED (410) errors from the server.
+   */
+  _isDocDeletedError(err) {
+    return typeof err === "object" && err !== null && "code" in err && err.code === 410;
+  }
 }
 _init = __decoratorStart(null);
 __decorateElement(_init, 1, "syncDoc", _syncDoc_dec, PatchesSync);

package/dist/net/error.d.ts

@@ -1,7 +1,17 @@
 declare class StatusError extends Error {
     code: number;
-    constructor(code: number, message: string);
+    data?: Record<string, any> | undefined;
+    constructor(code: number, message: string, data?: Record<string, any> | undefined);
 }
+/**
+ * Standard error codes for Patches operations.
+ */
+declare const ErrorCodes: {
+    /** Document was deleted (tombstone exists). */
+    readonly DOC_DELETED: 410;
+    /** Document not found (never existed). */
+    readonly DOC_NOT_FOUND: 404;
+};
 /**
  * Error thrown when the JSON-RPC client receives a message that cannot be parsed as JSON.
  * This typically indicates a server-side error (HTTP 500, load balancer timeout, etc.)
@@ -13,4 +23,4 @@ declare class JSONRPCParseError extends Error {
     constructor(rawMessage: string, parseError: Error);
 }
 
-export { JSONRPCParseError, StatusError };
+export { ErrorCodes, JSONRPCParseError, StatusError };

package/dist/net/error.js

@@ -1,10 +1,17 @@
 import "../chunk-IZ2YBCUP.js";
 class StatusError extends Error {
-  constructor(code, message) {
+  constructor(code, message, data) {
     super(message);
     this.code = code;
+    this.data = data;
   }
 }
+const ErrorCodes = {
+  /** Document was deleted (tombstone exists). */
+  DOC_DELETED: 410,
+  /** Document not found (never existed). */
+  DOC_NOT_FOUND: 404
+};
 class JSONRPCParseError extends Error {
   rawMessage;
   parseError;
@@ -17,6 +24,7 @@ class JSONRPCParseError extends Error {
   }
 }
 export {
+  ErrorCodes,
   JSONRPCParseError,
   StatusError
 };

package/dist/net/index.d.ts

@@ -6,7 +6,7 @@ export { ConnectionSignalSubscriber, JSONRPCServer, MessageHandler } from './pro
 export { AwarenessUpdateNotificationParams, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListOptions, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams } from './protocol/types.js';
 export { rpcError, rpcNotification, rpcResponse } from './protocol/utils.js';
 export { PatchesState, SyncingState } from './types.js';
-export { Access, AuthContext, AuthorizationProvider, allowAll, denyAll } from './websocket/AuthorizationProvider.js';
+export { Access, AuthContext, AuthorizationProvider, allowAll, assertNotDeleted, denyAll } from './websocket/AuthorizationProvider.js';
 export { onlineState } from './websocket/onlineState.js';
 export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 export { RPCServer, RPCServerOptions } from './websocket/RPCServer.js';
@@ -19,9 +19,9 @@ import '../algorithms/shared/changeBatching.js';
 import '../client/Patches.js';
 import '../client/PatchesDoc.js';
 import '../client/PatchesStore.js';
+import '../server/types.js';
 import '../server/PatchesBranchManager.js';
 import '../server/PatchesServer.js';
-import '../server/types.js';
 import '../compression/index.js';
 import '../algorithms/shared/lz.js';
 import '../json-patch/types.js';

package/dist/net/protocol/JSONRPCServer.d.ts

@@ -1,6 +1,7 @@
 import { Signal, Unsubscriber } from '../../event-signal.js';
 import { AuthContext } from '../websocket/AuthorizationProvider.js';
 import { JsonRpcNotification, Message, JsonRpcResponse } from './types.js';
+import '../../server/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/net/websocket/AuthorizationProvider.d.ts

@@ -1,3 +1,9 @@
+import { PatchesStoreBackend } from '../../server/types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Access level requested for an operation.
  *
@@ -19,6 +25,10 @@ interface AuthContext {
  * a certain action on a document.  Implementations are entirely application-
  * specific – they may look at a JWT decoded during the WebSocket handshake,
  * consult an ACL service, inspect the actual RPC method, etc.
+ *
+ * **Tombstone checking:** If your store implements tombstones, call
+ * `assertNotDeleted(store, docId)` at the start of canAccess() to automatically
+ * reject access to deleted documents with a 410 error.
  */
 interface AuthorizationProvider<T extends AuthContext = AuthContext> {
     /**
@@ -51,5 +61,20 @@ declare const allowAll: AuthorizationProvider;
  * Use this as the default to ensure security by default.
  */
 declare const denyAll: AuthorizationProvider;
+/**
+ * Helper for AuthorizationProvider implementations.
+ * Call this in your canAccess() to check for document tombstones.
+ * Throws StatusError(410) if the document has been deleted.
+ *
+ * @example
+ * const myAuthProvider: AuthorizationProvider = {
+ *   async canAccess(ctx, docId, kind, method, params) {
+ *     await assertNotDeleted(store, docId);
+ *     // ... rest of your auth logic
+ *     return true;
+ *   }
+ * };
+ */
+declare function assertNotDeleted(store: PatchesStoreBackend, docId: string): Promise<void>;
 
-export { type Access, type AuthContext, type AuthorizationProvider, allowAll, denyAll };
+export { type Access, type AuthContext, type AuthorizationProvider, allowAll, assertNotDeleted, denyAll };

package/dist/net/websocket/AuthorizationProvider.js

@@ -1,4 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
+import { ErrorCodes, StatusError } from "../error.js";
 const allowAll = {
   canAccess: () => true
 };
@@ -8,7 +9,17 @@ const denyAll = {
     return false;
   }
 };
+async function assertNotDeleted(store, docId) {
+  const tombstone = await store.getTombstone?.(docId);
+  if (tombstone) {
+    throw new StatusError(ErrorCodes.DOC_DELETED, `Document ${docId} was deleted`, {
+      deletedAt: tombstone.deletedAt,
+      lastRev: tombstone.lastRev
+    });
+  }
+}
 export {
   allowAll,
+  assertNotDeleted,
   denyAll
 };

package/dist/net/websocket/RPCServer.d.ts

@@ -82,6 +82,14 @@ declare class RPCServer {
     deleteDoc(params: {
         docId: string;
     }, ctx?: AuthContext): Promise<void>;
+    /**
+     * Removes the tombstone for a deleted document, allowing it to be recreated.
+     * @param params - The undelete parameters
+     * @param params.docId - The ID of the document to undelete
+     */
+    undeleteDoc(params: {
+        docId: string;
+    }, ctx?: AuthContext): Promise<boolean>;
     listVersions(params: {
         docId: string;
         options?: ListVersionsOptions;

package/dist/net/websocket/RPCServer.js

@@ -25,6 +25,7 @@ class RPCServer {
     this.rpc.registerMethod("getChangesSince", this.getChangesSince.bind(this));
     this.rpc.registerMethod("commitChanges", this.commitChanges.bind(this));
     this.rpc.registerMethod("deleteDoc", this.deleteDoc.bind(this));
+    this.rpc.registerMethod("undeleteDoc", this.undeleteDoc.bind(this));
     if (this.history) {
       this.rpc.registerMethod("listVersions", this.listVersions.bind(this));
       this.rpc.registerMethod("createVersion", this.createVersion.bind(this));
@@ -95,6 +96,16 @@ class RPCServer {
     await this.assertWrite(ctx, docId, "deleteDoc", params);
     await this.patches.deleteDoc(docId, ctx?.clientId);
   }
+  /**
+   * Removes the tombstone for a deleted document, allowing it to be recreated.
+   * @param params - The undelete parameters
+   * @param params.docId - The ID of the document to undelete
+   */
+  async undeleteDoc(params, ctx) {
+    const { docId } = params;
+    await this.assertWrite(ctx, docId, "undeleteDoc", params);
+    return this.patches.undeleteDoc(docId);
+  }
   // ---------------------------------------------------------------------------
   // History Manager wrappers
   // ---------------------------------------------------------------------------

package/dist/net/websocket/WebSocketServer.d.ts

@@ -6,9 +6,9 @@ import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
+import '../../server/types.js';
 import '../../server/PatchesBranchManager.js';
 import '../../server/PatchesServer.js';
-import '../../server/types.js';
 import '../../compression/index.js';
 import '../../algorithms/shared/lz.js';
 import '../../server/PatchesHistoryManager.js';
@@ -30,6 +30,7 @@ declare class WebSocketServer {
     constructor(transport: ServerTransport, rpcServer: RPCServer);
     /**
      * Subscribes the client to one or more documents to receive real-time updates.
+     * If a document has been deleted (tombstone exists), sends immediate docDeleted notification.
      * @param connectionId - The ID of the connection making the request
      * @param params - The subscription parameters
      * @param params.ids - Document ID or IDs to subscribe to

package/dist/net/websocket/WebSocketServer.js

@@ -1,4 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
+import { ErrorCodes, StatusError } from "../error.js";
 import { denyAll } from "./AuthorizationProvider.js";
 class WebSocketServer {
   transport;
@@ -26,6 +27,7 @@ class WebSocketServer {
   }
   /**
    * Subscribes the client to one or more documents to receive real-time updates.
+   * If a document has been deleted (tombstone exists), sends immediate docDeleted notification.
    * @param connectionId - The ID of the connection making the request
    * @param params - The subscription parameters
    * @param params.ids - Document ID or IDs to subscribe to
@@ -41,7 +43,17 @@ class WebSocketServer {
           if (await this.auth.canAccess(ctx, id, "read", "subscribe", params)) {
             allowed.push(id);
           }
-        } catch {
+        } catch (err) {
+          if (err instanceof StatusError && err.code === ErrorCodes.DOC_DELETED) {
+            this.transport.send(
+              ctx.clientId,
+              JSON.stringify({
+                jsonrpc: "2.0",
+                method: "docDeleted",
+                params: { docId: id }
+              })
+            );
+          }
         }
       })
     );

package/dist/server/CompressedStoreBackend.d.ts

@@ -1,5 +1,5 @@
 import { OpsCompressor } from '../compression/index.js';
-import { Change, ListChangesOptions, VersionMetadata, EditableVersionMetadata, ListVersionsOptions } from '../types.js';
+import { Change, ListChangesOptions, VersionMetadata, EditableVersionMetadata, ListVersionsOptions, DocumentTombstone } from '../types.js';
 import { PatchesStoreBackend } from './types.js';
 import '../algorithms/shared/lz.js';
 import '../json-patch/types.js';
@@ -39,6 +39,9 @@ declare class CompressedStoreBackend implements PatchesStoreBackend {
     listVersions(docId: string, options: ListVersionsOptions): Promise<VersionMetadata[]>;
     loadVersionState(docId: string, versionId: string): Promise<any | undefined>;
     deleteDoc(docId: string): Promise<void>;
+    createTombstone(tombstone: DocumentTombstone): Promise<void>;
+    getTombstone(docId: string): Promise<DocumentTombstone | undefined>;
+    removeTombstone(docId: string): Promise<void>;
 }
 
 export { CompressedStoreBackend };

package/dist/server/CompressedStoreBackend.js

@@ -73,6 +73,15 @@ class CompressedStoreBackend {
   async deleteDoc(docId) {
     return this.store.deleteDoc(docId);
   }
+  async createTombstone(tombstone) {
+    return this.store.createTombstone(tombstone);
+  }
+  async getTombstone(docId) {
+    return this.store.getTombstone(docId);
+  }
+  async removeTombstone(docId) {
+    return this.store.removeTombstone(docId);
+  }
 }
 export {
   CompressedStoreBackend

package/dist/server/PatchesServer.d.ts

@@ -1,6 +1,6 @@
 import { Signal } from '../event-signal.js';
 import { PatchesStoreBackend } from './types.js';
-import { Change, PatchesState, ChangeInput, CommitChangesOptions, ChangeMutator, EditableVersionMetadata } from '../types.js';
+import { Change, PatchesState, ChangeInput, CommitChangesOptions, ChangeMutator, DeleteDocOptions, EditableVersionMetadata } from '../types.js';
 import { OpsCompressor } from '../compression/index.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
@@ -89,8 +89,15 @@ declare class PatchesServer {
      * Deletes a document.
      * @param docId The document ID.
      * @param originClientId - The ID of the client that initiated the delete operation.
+     * @param options - Optional deletion settings (e.g., skipTombstone for testing).
      */
-    deleteDoc(docId: string, originClientId?: string): Promise<void>;
+    deleteDoc(docId: string, originClientId?: string, options?: DeleteDocOptions): Promise<void>;
+    /**
+     * Removes the tombstone for a deleted document, allowing it to be recreated.
+     * @param docId The document ID.
+     * @returns True if tombstone was found and removed, false if no tombstone existed.
+     */
+    undeleteDoc(docId: string): Promise<boolean>;
     /**
      * Captures the current state of a document as a new version.
      * @param docId The document ID.

package/dist/server/PatchesServer.js

@@ -7,6 +7,7 @@ import { applyChanges } from "../algorithms/shared/applyChanges.js";
 import { createChange } from "../data/change.js";
 import { signal } from "../event-signal.js";
 import { createJSONPatch } from "../json-patch/createJSONPatch.js";
+import { getISO } from "../utils/dates.js";
 import { CompressedStoreBackend } from "./CompressedStoreBackend.js";
 class PatchesServer {
   sessionTimeoutMillis;
@@ -100,11 +101,37 @@ class PatchesServer {
    * Deletes a document.
    * @param docId The document ID.
    * @param originClientId - The ID of the client that initiated the delete operation.
+   * @param options - Optional deletion settings (e.g., skipTombstone for testing).
    */
-  async deleteDoc(docId, originClientId) {
+  async deleteDoc(docId, originClientId, options) {
+    if (this.store.createTombstone && !options?.skipTombstone) {
+      const { rev: lastRev } = await this.getDoc(docId);
+      await this.store.createTombstone({
+        docId,
+        deletedAt: getISO(),
+        lastRev,
+        deletedByClientId: originClientId
+      });
+    }
     await this.store.deleteDoc(docId);
     await this.onDocDeleted.emit(docId, originClientId);
   }
+  /**
+   * Removes the tombstone for a deleted document, allowing it to be recreated.
+   * @param docId The document ID.
+   * @returns True if tombstone was found and removed, false if no tombstone existed.
+   */
+  async undeleteDoc(docId) {
+    if (!this.store.removeTombstone) {
+      return false;
+    }
+    const tombstone = await this.store.getTombstone?.(docId);
+    if (!tombstone) {
+      return false;
+    }
+    await this.store.removeTombstone(docId);
+    return true;
+  }
   // === Version Operations ===
   /**
    * Captures the current state of a document as a new version.

package/dist/server/types.d.ts

@@ -1,4 +1,4 @@
-import { Change, ListChangesOptions, PatchesState, VersionMetadata, EditableVersionMetadata, ListVersionsOptions, Branch } from '../types.js';
+import { Change, ListChangesOptions, PatchesState, VersionMetadata, EditableVersionMetadata, ListVersionsOptions, DocumentTombstone, Branch } from '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
@@ -36,6 +36,12 @@ interface PatchesStoreBackend {
     loadVersionChanges(docId: string, versionId: string): Promise<Change[]>;
     /** Deletes a document. */
     deleteDoc(docId: string): Promise<void>;
+    /** Creates a tombstone for a deleted document. Called before deleteDoc() to preserve deletion metadata. */
+    createTombstone(tombstone: DocumentTombstone): Promise<void>;
+    /** Retrieves a tombstone for a document if it exists. Returns undefined if the document was never deleted or tombstone has expired. */
+    getTombstone(docId: string): Promise<DocumentTombstone | undefined>;
+    /** Removes a tombstone (for undelete or TTL cleanup). */
+    removeTombstone(docId: string): Promise<void>;
 }
 /**
  * Extends PatchesStoreBackend with methods specifically for managing branches.

package/dist/types.d.ts

@@ -81,6 +81,30 @@ interface Branch {
     [metadata: string]: any;
 }
 type EditableBranchMetadata = Disallowed<Branch, 'id' | 'docId' | 'branchedAtRev' | 'createdAt' | 'status'>;
+/**
+ * Represents a tombstone for a deleted document.
+ * Tombstones persist after deletion to inform late-connecting clients
+ * that a document has been deleted rather than never existing.
+ */
+interface DocumentTombstone {
+    /** The ID of the deleted document. */
+    docId: string;
+    /** ISO timestamp when the document was deleted (UTC with Z). */
+    deletedAt: string;
+    /** The last revision number before deletion. */
+    lastRev: number;
+    /** Optional client ID that initiated the deletion. */
+    deletedByClientId?: string;
+    /** Optional ISO timestamp for automatic tombstone expiration (UTC with Z). */
+    expiresAt?: string;
+}
+/**
+ * Options for deleting a document.
+ */
+interface DeleteDocOptions {
+    /** Skip creating tombstone (useful for testing/migration scripts). */
+    skipTombstone?: boolean;
+}
 /**
  * Metadata, state snapshot, and included changes for a specific version.
  */
@@ -194,4 +218,4 @@ type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
  */
 type ChangeMutator<T> = (patch: JSONPatch, root: PathProxy<T>) => void;
 
-export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };
+export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.5.12",
+  "version": "0.5.13",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {