@dabble/patches 0.4.5 → 0.4.7

package/dist/server/PatchesServer.js

@@ -1,144 +1,138 @@
-import { commitChanges } from '../algorithms/server/commitChanges.js';
-import { createVersion } from '../algorithms/server/createVersion.js';
-import { getSnapshotAtRevision } from '../algorithms/server/getSnapshotAtRevision.js';
-import { getStateAtRevision } from '../algorithms/server/getStateAtRevision.js';
-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';
-/**
- * Handles the server-side Operational Transformation (OT) logic,
- * coordinating batches of changes, managing versioning based on sessions (including offline),
- * and persisting data using a backend store.
- */
-export class PatchesServer {
-    store;
-    sessionTimeoutMillis;
-    /** Notifies listeners whenever a batch of changes is *successfully* committed. */
-    onChangesCommitted = signal();
-    /** Notifies listeners when a document is deleted. */
-    onDocDeleted = signal();
-    constructor(store, options = {}) {
-        this.store = store;
-        this.sessionTimeoutMillis = (options.sessionTimeoutMinutes ?? 30) * 60 * 1000;
+import "../chunk-IZ2YBCUP.js";
+import { commitChanges } from "../algorithms/server/commitChanges.js";
+import { createVersion } from "../algorithms/server/createVersion.js";
+import { getSnapshotAtRevision } from "../algorithms/server/getSnapshotAtRevision.js";
+import { getStateAtRevision } from "../algorithms/server/getStateAtRevision.js";
+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";
+class PatchesServer {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.sessionTimeoutMillis = (options.sessionTimeoutMinutes ?? 30) * 60 * 1e3;
+  }
+  sessionTimeoutMillis;
+  /** Notifies listeners whenever a batch of changes is *successfully* committed. */
+  onChangesCommitted = signal();
+  /** Notifies listeners when a document is deleted. */
+  onDocDeleted = signal();
+  /**
+   * Get the state of a document at a specific revision (or the latest state if no revision is provided).
+   * @param docId - The ID of the document.
+   * @param rev - The revision number.
+   * @returns The state of the document at the specified revision.
+   */
+  async getDoc(docId, atRev) {
+    return getStateAtRevision(this.store, docId, atRev);
+  }
+  /**
+   * Get the state of a document at a specific revision.
+   * @param docId - The ID of the document.
+   * @param rev - The revision number.
+   * @returns The state of the document at the specified revision.
+   */
+  async getStateAtRevision(docId, atRev) {
+    return getStateAtRevision(this.store, docId, atRev);
+  }
+  /**
+   * Get changes that occurred after a specific revision.
+   * @param docId - The ID of the document.
+   * @param rev - The revision number.
+   * @returns The changes that occurred after the specified revision.
+   */
+  getChangesSince(docId, rev) {
+    return this.store.listChanges(docId, { startAfter: rev });
+  }
+  /**
+   * Commits a set of changes to a document, applying operational transformation as needed.
+   * @param docId - The ID of the document.
+   * @param changes - The changes to commit.
+   * @param originClientId - The ID of the client that initiated the commit.
+   * @returns A tuple of [committedChanges, transformedChanges] where:
+   *   - committedChanges: Changes that were already committed to the server after the client's base revision
+   *   - transformedChanges: The client's changes after being transformed against concurrent changes
+   */
+  async commitChanges(docId, changes, originClientId) {
+    const [committedChanges, transformedChanges] = await commitChanges(
+      this.store,
+      docId,
+      changes,
+      this.sessionTimeoutMillis
+    );
+    if (transformedChanges.length > 0) {
+      try {
+        await this.onChangesCommitted.emit(docId, transformedChanges, originClientId);
+      } catch (error) {
+        console.error(`Failed to notify clients about committed changes for doc ${docId}:`, error);
+      }
     }
-    /**
-     * Get the state of a document at a specific revision (or the latest state if no revision is provided).
-     * @param docId - The ID of the document.
-     * @param rev - The revision number.
-     * @returns The state of the document at the specified revision.
-     */
-    async getDoc(docId, atRev) {
-        return getStateAtRevision(this.store, docId, atRev);
+    return [committedChanges, transformedChanges];
+  }
+  /**
+   * Make a server-side change to a document.
+   * @param mutator
+   * @returns
+   */
+  async change(docId, mutator, metadata) {
+    const { state, rev } = await this.getDoc(docId);
+    const patch = createJSONPatch(mutator);
+    if (patch.ops.length === 0) {
+      return null;
     }
-    /**
-     * Get the state of a document at a specific revision.
-     * @param docId - The ID of the document.
-     * @param rev - The revision number.
-     * @returns The state of the document at the specified revision.
-     */
-    async getStateAtRevision(docId, atRev) {
-        return getStateAtRevision(this.store, docId, atRev);
-    }
-    /**
-     * Get changes that occurred after a specific revision.
-     * @param docId - The ID of the document.
-     * @param rev - The revision number.
-     * @returns The changes that occurred after the specified revision.
-     */
-    getChangesSince(docId, rev) {
-        return this.store.listChanges(docId, { startAfter: rev });
-    }
-    /**
-     * Commits a set of changes to a document, applying operational transformation as needed.
-     * @param docId - The ID of the document.
-     * @param changes - The changes to commit.
-     * @param originClientId - The ID of the client that initiated the commit.
-     * @returns A tuple of [committedChanges, transformedChanges] where:
-     *   - committedChanges: Changes that were already committed to the server after the client's base revision
-     *   - transformedChanges: The client's changes after being transformed against concurrent changes
-     */
-    async commitChanges(docId, changes, originClientId) {
-        const [committedChanges, transformedChanges] = await commitChanges(this.store, docId, changes, this.sessionTimeoutMillis);
-        // Persist and notify about newly transformed changes atomically
-        if (transformedChanges.length > 0) {
-            try {
-                // Fire event for realtime transports (WebSocket, etc.)
-                await this.onChangesCommitted.emit(docId, transformedChanges, originClientId);
-            }
-            catch (error) {
-                // If notification fails after saving, log error but don't fail the operation
-                // The changes are already committed to storage, so we can't roll back
-                console.error(`Failed to notify clients about committed changes for doc ${docId}:`, error);
-                // Consider implementing a retry mechanism or dead letter queue here
-            }
-        }
-        // Return committed changes and newly transformed changes separately
-        return [committedChanges, transformedChanges];
-    }
-    /**
-     * Make a server-side change to a document.
-     * @param mutator
-     * @returns
-     */
-    async change(docId, mutator, metadata) {
-        const { state, rev } = await this.getDoc(docId);
-        const patch = createJSONPatch(mutator);
-        if (patch.ops.length === 0) {
-            return null;
-        }
-        // It's the baseRev that matters for sending.
-        const change = createChange(rev, rev + 1, patch.ops, metadata);
-        // Apply to local state to ensure no errors are thrown
-        patch.apply(state);
-        await this.commitChanges(docId, [change]);
-        return change;
-    }
-    /**
-     * Deletes a document.
-     * @param docId The document ID.
-     * @param originClientId - The ID of the client that initiated the delete operation.
-     */
-    async deleteDoc(docId, originClientId) {
-        await this.store.deleteDoc(docId);
-        await this.onDocDeleted.emit(docId, originClientId);
-    }
-    // === Version Operations ===
-    /**
-     * Captures the current state of a document as a new version.
-     * @param docId The document ID.
-     * @param metadata Optional metadata for the version.
-     * @returns The ID of the created version.
-     */
-    async captureCurrentVersion(docId, metadata) {
-        assertVersionMetadata(metadata);
-        const { state: initialState, changes } = await getSnapshotAtRevision(this.store, docId);
-        let state = initialState;
-        state = applyChanges(state, changes);
-        const version = await createVersion(this.store, docId, state, changes, metadata);
-        if (!version) {
-            throw new Error(`No changes to create a version for doc ${docId}.`);
-        }
-        return version.id;
+    const change = createChange(rev, rev + 1, patch.ops, metadata);
+    patch.apply(state);
+    await this.commitChanges(docId, [change]);
+    return change;
+  }
+  /**
+   * Deletes a document.
+   * @param docId The document ID.
+   * @param originClientId - The ID of the client that initiated the delete operation.
+   */
+  async deleteDoc(docId, originClientId) {
+    await this.store.deleteDoc(docId);
+    await this.onDocDeleted.emit(docId, originClientId);
+  }
+  // === Version Operations ===
+  /**
+   * Captures the current state of a document as a new version.
+   * @param docId The document ID.
+   * @param metadata Optional metadata for the version.
+   * @returns The ID of the created version.
+   */
+  async captureCurrentVersion(docId, metadata) {
+    assertVersionMetadata(metadata);
+    const { state: initialState, changes } = await getSnapshotAtRevision(this.store, docId);
+    let state = initialState;
+    state = applyChanges(state, changes);
+    const version = await createVersion(this.store, docId, state, changes, metadata);
+    if (!version) {
+      throw new Error(`No changes to create a version for doc ${docId}.`);
     }
+    return version.id;
+  }
 }
-const nonModifiableMetadataFields = new Set([
-    'id',
-    'parentId',
-    'groupId',
-    'origin',
-    'branchName',
-    'startDate',
-    'endDate',
-    'rev',
-    'baseRev',
+const nonModifiableMetadataFields = /* @__PURE__ */ new Set([
+  "id",
+  "parentId",
+  "groupId",
+  "origin",
+  "branchName",
+  "startDate",
+  "endDate",
+  "rev",
+  "baseRev"
 ]);
-export function assertVersionMetadata(metadata) {
-    if (!metadata)
-        return;
-    for (const key in metadata) {
-        if (nonModifiableMetadataFields.has(key)) {
-            throw new Error(`Cannot modify version field ${key}`);
-        }
+function assertVersionMetadata(metadata) {
+  if (!metadata) return;
+  for (const key in metadata) {
+    if (nonModifiableMetadataFields.has(key)) {
+      throw new Error(`Cannot modify version field ${key}`);
     }
+  }
 }
+export {
+  PatchesServer,
+  assertVersionMetadata
+};

package/dist/server/index.d.ts

@@ -1,4 +1,9 @@
 export { PatchesBranchManager } from './PatchesBranchManager.js';
 export { PatchesHistoryManager } from './PatchesHistoryManager.js';
-export { PatchesServer } from './PatchesServer.js';
-export type { BranchingStoreBackend, PatchesStoreBackend } from './types.js';
+export { PatchesServer, PatchesServerOptions } from './PatchesServer.js';
+export { BranchingStoreBackend, PatchesStoreBackend } from './types.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../event-signal.js';

package/dist/server/index.js

@@ -1,3 +1,9 @@
-export { PatchesBranchManager } from './PatchesBranchManager.js';
-export { PatchesHistoryManager } from './PatchesHistoryManager.js';
-export { PatchesServer } from './PatchesServer.js';
+import "../chunk-IZ2YBCUP.js";
+import { PatchesBranchManager } from "./PatchesBranchManager.js";
+import { PatchesHistoryManager } from "./PatchesHistoryManager.js";
+import { PatchesServer } from "./PatchesServer.js";
+export {
+  PatchesBranchManager,
+  PatchesHistoryManager,
+  PatchesServer
+};

package/dist/server/types.d.ts

@@ -1,9 +1,13 @@
-import type { Branch, Change, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesState, VersionMetadata } from '../types.js';
+import { Change, ListChangesOptions, PatchesState, VersionMetadata, EditableVersionMetadata, ListVersionsOptions, Branch } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
 /**
  * Interface for a backend storage system for patch synchronization.
  * Defines methods needed by PatchesServer, PatchesHistoryManager, etc.
  */
-export interface PatchesStoreBackend {
+interface PatchesStoreBackend {
     /** Saves a batch of committed server changes. */
     saveChanges(docId: string, changes: Change[]): Promise<void>;
     /** Lists committed server changes based on revision numbers. */
@@ -31,7 +35,7 @@ export interface PatchesStoreBackend {
 /**
  * Extends PatchesStoreBackend with methods specifically for managing branches.
  */
-export interface BranchingStoreBackend extends PatchesStoreBackend {
+interface BranchingStoreBackend extends PatchesStoreBackend {
     /** Lists metadata records for branches originating from a document. */
     listBranches(docId: string): Promise<Branch[]>;
     /** Loads the metadata record for a specific branch ID. */
@@ -46,3 +50,5 @@ export interface BranchingStoreBackend extends PatchesStoreBackend {
      */
     closeBranch(branchId: string): Promise<void>;
 }
+
+export type { BranchingStoreBackend, PatchesStoreBackend };

package/dist/server/types.js

@@ -1 +0,0 @@
-export {};

package/dist/types.d.ts

@@ -1,14 +1,22 @@
 import { JSONPatch } from './json-patch/JSONPatch.js';
-import type { JSONPatchOp } from './json-patch/types.js';
-export interface Change {
+import { JSONPatchOp } from './json-patch/types.js';
+import '@dabble/delta';
+
+/**
+ * A change being submitted to the server. Unlike committed Change, rev and baseRev are optional.
+ * If omitted, the server fills them in using the current latest revision (apply to latest).
+ * This is useful for server-to-server operations like migrations so that you don't need to
+ * fetch the document just to get its revision number.
+ */
+interface ChangeInput {
     /** Unique identifier for the change, generated client-side. */
     id: string;
     /** The patch operations. */
     ops: JSONPatchOp[];
-    /** The revision number assigned on the client to the optimistic revision and updated by the server after commit. */
-    rev: number;
-    /** The server revision this change was based on. Required for client->server changes. */
-    baseRev: number;
+    /** Optional base revision. If omitted, server uses current revision (apply to latest). */
+    baseRev?: number;
+    /** Optional revision number. If omitted, server assigns based on current state. */
+    rev?: number;
     /** Client-side timestamp when the change was created. */
     created: number;
     /** Optional batch identifier for grouping changes that belong to the same client batch (for multi-batch offline/large edits). */
@@ -16,12 +24,22 @@ export interface Change {
     /** Optional arbitrary metadata associated with the change. */
     [metadata: string]: any;
 }
+/**
+ * A change that has been committed to the server with assigned revision numbers.
+ * This is the canonical form of changes stored and returned by the server.
+ */
+interface Change extends ChangeInput {
+    /** The server revision this change was based on. */
+    baseRev: number;
+    /** The revision number assigned by the server after commit. */
+    rev: number;
+}
 /**
  * Represents the state of a document in the OT protocol.
  * @property state - The state of the document.
  * @property rev - The revision number of the state.
  */
-export interface PatchesState<T = any> {
+interface PatchesState<T = any> {
     state: T;
     rev: number;
 }
@@ -31,7 +49,7 @@ export interface PatchesState<T = any> {
  * @property rev - The revision number of the state.
  * @property changes - Any unapplied changes since `rev` that may be applied to the `state` to get the latest state.
  */
-export interface PatchesSnapshot<T = any> extends PatchesState<T> {
+interface PatchesSnapshot<T = any> extends PatchesState<T> {
     changes: Change[];
 }
 /**
@@ -41,10 +59,10 @@ export interface PatchesSnapshot<T = any> extends PatchesState<T> {
  * @property null - The document is not syncing.
  * @property Error - The document is syncing with an error.
  */
-export type SyncingState = 'initial' | 'updating' | null | Error;
+type SyncingState = 'initial' | 'updating' | null | Error;
 /** Status options for a branch */
-export type BranchStatus = 'open' | 'closed' | 'merged' | 'archived' | 'abandoned';
-export interface Branch {
+type BranchStatus = 'open' | 'closed' | 'merged' | 'archived' | 'abandoned';
+interface Branch {
     /** The ID of the branch document. */
     id: string;
     /** The ID of the document this document was branched from. */
@@ -60,11 +78,11 @@ export interface Branch {
     /** Optional arbitrary metadata associated with the branch record. */
     [metadata: string]: any;
 }
-export type EditableBranchMetadata = Disallowed<Branch, 'id' | 'branchedFromId' | 'branchedRev' | 'created' | 'status'>;
+type EditableBranchMetadata = Disallowed<Branch, 'id' | 'branchedFromId' | 'branchedRev' | 'created' | 'status'>;
 /**
  * Metadata, state snapshot, and included changes for a specific version.
  */
-export interface VersionMetadata {
+interface VersionMetadata {
     /** Unique identifier (UUID) for this version record. */
     id: string;
     name?: string;
@@ -90,11 +108,11 @@ export interface VersionMetadata {
 type Disallowed<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & {
     [P in K]?: never;
 };
-export type EditableVersionMetadata = Disallowed<VersionMetadata, 'id' | 'parentId' | 'groupId' | 'origin' | 'branchName' | 'startDate' | 'endDate' | 'rev' | 'baseRev'>;
+type EditableVersionMetadata = Disallowed<VersionMetadata, 'id' | 'parentId' | 'groupId' | 'origin' | 'branchName' | 'startDate' | 'endDate' | 'rev' | 'baseRev'>;
 /**
  * Options for listing committed server changes. *Always* ordered by revision number.
  */
-export interface ListChangesOptions {
+interface ListChangesOptions {
     /** List changes committed strictly *after* this revision number. */
     startAfter?: number;
     /** List changes committed strictly *before* this revision number. */
@@ -109,7 +127,7 @@ export interface ListChangesOptions {
 /**
  * Options for listing version metadata.
  */
-export interface ListVersionsOptions {
+interface ListVersionsOptions {
     /** List versions whose orderBy field is *after* this value. */
     startAfter?: number;
     /** List versions whose orderBy field is strictly *before* this value. */
@@ -141,7 +159,7 @@ type DeepPathProxy = {
  * Defaults to `any`, which returns a `DeepPathProxy` allowing arbitrary deep property access.
  * When a specific type is provided, returns a strictly typed proxy.
  */
-export type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
+type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
     [P in keyof T]-?: NonNullable<T[P]> extends object ? PathProxy<NonNullable<T[P]>> : {
         toString: () => string;
     };
@@ -153,5 +171,6 @@ export type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
  * The mutator receives a JSONPatch instance and a PathProxy for type-safe path creation.
  * All modifications must be done through explicit patch operations.
  */
-export type ChangeMutator<T> = (patch: JSONPatch, root: PathProxy<T>) => void;
-export {};
+type ChangeMutator<T> = (patch: JSONPatch, root: PathProxy<T>) => void;
+
+export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };

package/dist/types.js

@@ -1 +1 @@
-import { JSONPatch } from './json-patch/JSONPatch.js';
+import { JSONPatch } from "./json-patch/JSONPatch.js";

package/dist/utils/concurrency.d.ts

@@ -2,17 +2,17 @@
  * Wrap a function which is blockable for a document.
  * Also, a Typescript decorator for functions which are blockable.
  */
-export declare function blockable<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
+declare function blockable<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
 /**
  * Wrap a function which blocks on a document.
  * Also, a Typescript decorator for functions which block.
  */
-export declare function blocking<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
+declare function blocking<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
 /**
  * Wrap a function which returns a response which is blockable for a document (e.g. fetch).
  * Also, a Typescript decorator for functions whose response should be blocked when needed.
  */
-export declare function blockableResponse<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
+declare function blockableResponse<T extends (docId: string, ...args: any[]) => Promise<any>>(target: T): T;
 /**
  * Wrap a function to only return the result of the first call.
  *
@@ -22,5 +22,7 @@ export declare function blockableResponse<T extends (docId: string, ...args: any
  *   ...
  * });
  */
-export declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(target: T): T;
-export declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(matchOnFirstArg: boolean): (target: T) => T;
+declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(target: T): T;
+declare function singleInvocation<T extends (...args: any[]) => Promise<any>>(matchOnFirstArg: boolean): (target: T) => T;
+
+export { blockable, blockableResponse, blocking, singleInvocation };

package/dist/utils/concurrency.js

@@ -1,60 +1,50 @@
-import { simplifiedConcurrency } from 'simplified-concurrency';
-const docIds = new Map();
-/**
- * Make the concurrency be per-path to allow multiple records to be loaded and updated at the same time, keeping only
- * the record's operations sequential with respect to other operations on the same record.
- */
+import "../chunk-IZ2YBCUP.js";
+import { simplifiedConcurrency } from "simplified-concurrency";
+const docIds = /* @__PURE__ */ new Map();
 function concurrency(docId) {
-    let concurrency = docIds.get(docId);
-    if (!concurrency) {
-        concurrency = simplifiedConcurrency();
-        docIds.set(docId, concurrency);
-    }
-    return concurrency;
+  let concurrency2 = docIds.get(docId);
+  if (!concurrency2) {
+    concurrency2 = simplifiedConcurrency();
+    docIds.set(docId, concurrency2);
+  }
+  return concurrency2;
 }
-/**
- * Wrap a function which is blockable for a document.
- * Also, a Typescript decorator for functions which are blockable.
- */
-export function blockable(target) {
-    return function (...args) {
-        return concurrency(args[0]).blockFunction(target, args, this);
-    };
+function blockable(target) {
+  return function(...args) {
+    return concurrency(args[0]).blockFunction(target, args, this);
+  };
 }
-/**
- * Wrap a function which blocks on a document.
- * Also, a Typescript decorator for functions which block.
- */
-export function blocking(target) {
-    return function (...args) {
-        return concurrency(args[0]).blockWhile(target.apply(this, args));
-    };
+function blocking(target) {
+  return function(...args) {
+    return concurrency(args[0]).blockWhile(target.apply(this, args));
+  };
 }
-/**
- * Wrap a function which returns a response which is blockable for a document (e.g. fetch).
- * Also, a Typescript decorator for functions whose response should be blocked when needed.
- */
-export function blockableResponse(target) {
-    return function (...args) {
-        return concurrency(args[0]).blockResponse(target.apply(this, args));
-    };
+function blockableResponse(target) {
+  return function(...args) {
+    return concurrency(args[0]).blockResponse(target.apply(this, args));
+  };
 }
-export function singleInvocation(matchOnFirstArgOrTarget) {
-    if (typeof matchOnFirstArgOrTarget === 'function') {
-        return singleInvocation(false)(matchOnFirstArgOrTarget);
-    }
-    return function (target) {
-        const promises = new Map();
-        return function (...args) {
-            const key = matchOnFirstArgOrTarget ? args[0] : 1;
-            if (promises.has(key))
-                return promises.get(key);
-            const promise = target.apply(this, args);
-            promises.set(key, promise);
-            promise.finally(() => {
-                promises.delete(key);
-            });
-            return promise;
-        };
+function singleInvocation(matchOnFirstArgOrTarget) {
+  if (typeof matchOnFirstArgOrTarget === "function") {
+    return singleInvocation(false)(matchOnFirstArgOrTarget);
+  }
+  return function(target) {
+    const promises = /* @__PURE__ */ new Map();
+    return function(...args) {
+      const key = matchOnFirstArgOrTarget ? args[0] : 1;
+      if (promises.has(key)) return promises.get(key);
+      const promise = target.apply(this, args);
+      promises.set(key, promise);
+      promise.finally(() => {
+        promises.delete(key);
+      });
+      return promise;
     };
+  };
 }
+export {
+  blockable,
+  blockableResponse,
+  blocking,
+  singleInvocation
+};

package/dist/utils/deferred.d.ts

@@ -1,7 +1,9 @@
-export interface Deferred<T = void> {
+interface Deferred<T = void> {
     promise: Promise<T>;
     resolve: (value: T) => void;
     reject: (reason?: any) => void;
     status: 'pending' | 'fulfilled' | 'rejected';
 }
-export declare function deferred<T = void>(): Deferred<T>;
+declare function deferred<T = void>(): Deferred<T>;
+
+export { type Deferred, deferred };