@dabble/patches 0.7.21 → 0.7.23

package/dist/server/RevConflictError.js

@@ -0,0 +1,10 @@
+import "../chunk-IZ2YBCUP.js";
+class RevConflictError extends Error {
+  constructor(message) {
+    super(message ?? "Revision conflict: another commit wrote to the same revision");
+    this.name = "RevConflictError";
+  }
+}
+export {
+  RevConflictError
+};

package/dist/server/index.d.ts

@@ -5,13 +5,17 @@ export { LWWBranchManager } from './LWWBranchManager.js';
 export { OTBranchManager, PatchesBranchManager } from './OTBranchManager.js';
 export { LWWMemoryStoreBackend } from './LWWMemoryStoreBackend.js';
 export { PatchesHistoryManager } from './PatchesHistoryManager.js';
+export { buildVersionState, getBaseStateBeforeVersion } from '../algorithms/ot/server/buildVersionState.js';
+export { concatStreams, jsonReadable, parseVersionState, readStreamAsString } from './jsonReadable.js';
+export { blockable, blockableResponse, blocking, singleInvocation } from '../utils/concurrency.js';
+export { RevConflictError } from './RevConflictError.js';
 export { BranchIdGenerator, BranchLoader, assertBranchMetadata, assertBranchOpenForMerge, assertNotABranch, branchManagerApi, createBranchRecord, generateBranchId, wrapMergeCommit } from './branchUtils.js';
 export { CompressedStoreBackend } from './CompressedStoreBackend.js';
 export { createTombstoneIfSupported, isTombstoneStore, removeTombstoneIfExists } from './tombstone.js';
 export { assertVersionMetadata } from './utils.js';
 export { CommitChangesOptions, DeleteDocOptions } from '../types.js';
 export { PatchesServer } from './PatchesServer.js';
-export { BranchingStoreBackend, LWWStoreBackend, ListFieldsOptions, OTStoreBackend, ServerStoreBackend, TombstoneStoreBackend, VersioningStoreBackend } from './types.js';
+export { BranchingStoreBackend, LWWStoreBackend, ListFieldsOptions, OTStoreBackend, ServerStoreBackend, SnapshotResult, TombstoneStoreBackend, VersioningStoreBackend } from './types.js';
 import 'easy-signal';
 import '../net/protocol/JSONRPCServer.js';
 import '../net/websocket/AuthorizationProvider.js';

package/dist/server/index.js

@@ -5,6 +5,10 @@ import { LWWBranchManager } from "./LWWBranchManager.js";
 import { OTBranchManager, PatchesBranchManager } from "./OTBranchManager.js";
 import { LWWMemoryStoreBackend } from "./LWWMemoryStoreBackend.js";
 import { PatchesHistoryManager } from "./PatchesHistoryManager.js";
+import { buildVersionState, getBaseStateBeforeVersion } from "../algorithms/ot/server/buildVersionState.js";
+import { concatStreams, jsonReadable, parseVersionState, readStreamAsString } from "./jsonReadable.js";
+import { blockable, blockableResponse, blocking, singleInvocation } from "../utils/concurrency.js";
+import { RevConflictError } from "./RevConflictError.js";
 import {
   assertBranchMetadata,
   assertBranchOpenForMerge,
@@ -26,15 +30,26 @@ export {
   OTServer,
   PatchesBranchManager,
   PatchesHistoryManager,
+  RevConflictError,
   assertBranchMetadata,
   assertBranchOpenForMerge,
   assertNotABranch,
   assertVersionMetadata,
+  blockable,
+  blockableResponse,
+  blocking,
   branchManagerApi,
+  buildVersionState,
+  concatStreams,
   createBranchRecord,
   createTombstoneIfSupported,
   generateBranchId,
+  getBaseStateBeforeVersion,
   isTombstoneStore,
+  jsonReadable,
+  parseVersionState,
+  readStreamAsString,
   removeTombstoneIfExists,
+  singleInvocation,
   wrapMergeCommit
 };

package/dist/server/jsonReadable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Creates a ReadableStream that emits a single string chunk.
+ */
+declare function jsonReadable(json: string): ReadableStream<string>;
+/**
+ * Concatenates strings and ReadableStreams into a single ReadableStream.
+ * Each source is consumed in order. Backpressure propagates naturally:
+ * each stream source is only read when the previous one has been fully consumed.
+ */
+declare function concatStreams(...sources: (string | ReadableStream<string>)[]): ReadableStream<string>;
+/**
+ * Parses a version state from store format (string or ReadableStream) into a JS object.
+ * Only use in non-hot-path code (explicit operations like captureCurrentVersion, createBranch).
+ */
+declare function parseVersionState(raw: string | ReadableStream<string>): Promise<any>;
+/**
+ * Consumes a ReadableStream<string> into a single string.
+ * Only use in non-hot-path code (explicit operations like captureCurrentVersion).
+ */
+declare function readStreamAsString(stream: ReadableStream<string>): Promise<string>;
+
+export { concatStreams, jsonReadable, parseVersionState, readStreamAsString };

package/dist/server/jsonReadable.js

@@ -0,0 +1,68 @@
+import "../chunk-IZ2YBCUP.js";
+function jsonReadable(json) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(json);
+      controller.close();
+    }
+  });
+}
+function concatStreams(...sources) {
+  let index = 0;
+  let currentReader = null;
+  return new ReadableStream({
+    async pull(controller) {
+      while (index < sources.length) {
+        const source = sources[index];
+        if (typeof source === "string") {
+          controller.enqueue(source);
+          index++;
+          return;
+        }
+        if (!currentReader) {
+          currentReader = source.getReader();
+        }
+        const { done, value } = await currentReader.read();
+        if (!done) {
+          controller.enqueue(value);
+          return;
+        }
+        currentReader = null;
+        index++;
+      }
+      controller.close();
+    },
+    cancel(reason) {
+      if (currentReader) {
+        currentReader.cancel(reason);
+      }
+      const start = currentReader ? index + 1 : index;
+      for (let i = start; i < sources.length; i++) {
+        const s = sources[i];
+        if (typeof s !== "string") {
+          s.cancel(reason);
+        }
+      }
+    }
+  });
+}
+async function parseVersionState(raw) {
+  const json = typeof raw === "string" ? raw : await readStreamAsString(raw);
+  return JSON.parse(json);
+}
+async function readStreamAsString(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return chunks.join("");
+}
+export {
+  concatStreams,
+  jsonReadable,
+  parseVersionState,
+  readStreamAsString
+};

package/dist/server/types.d.ts

@@ -17,24 +17,26 @@ interface ServerStoreBackend {
  */
 interface VersioningStoreBackend {
     /**
-     * Saves version metadata, its state snapshot, and optionally the original changes.
-     * State and changes are stored separately from the core metadata.
+     * Saves version metadata and optionally the original changes.
+     * Implementations are responsible for building and persisting version state —
+     * inline or queued, but must throw if state creation fails.
      * @param changes - Optional for LWW (which doesn't store changes), required for OT.
      */
-    createVersion(docId: string, metadata: VersionMetadata, state: any, changes?: Change[]): Promise<void>;
+    createVersion(docId: string, metadata: VersionMetadata, changes?: Change[]): Promise<void>;
     /** Lists version metadata based on filtering/sorting options. */
     listVersions(docId: string, options: ListVersionsOptions): Promise<VersionMetadata[]>;
-    /** Loads the state snapshot for a specific version ID. */
-    loadVersionState(docId: string, versionId: string): Promise<any | undefined>;
+    /** Loads metadata for a specific version by its ID. */
+    loadVersion(docId: string, versionId: string): Promise<VersionMetadata | undefined>;
+    /**
+     * Loads the state snapshot for a specific version ID.
+     * Returns a JSON string, ReadableStream of JSON chunks, or undefined if not found.
+     * ReadableStream allows large state blobs to be streamed without full materialization.
+     */
+    loadVersionState(docId: string, versionId: string): Promise<string | ReadableStream<string> | undefined>;
     /** Update a version's metadata. */
     updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
     /** Loads the original Change objects associated with a specific version ID. */
     loadVersionChanges?(docId: string, versionId: string): Promise<Change[]>;
-    /**
-     * Appends changes to an existing version, updating its state snapshot, endedAt, and endRev.
-     * Used when a session spans multiple batch submissions.
-     */
-    appendVersionChanges?(docId: string, versionId: string, changes: Change[], newEndedAt: number, newEndRev: number, newState: any): Promise<void>;
 }
 /**
  * Interface for OT (Operational Transformation) storage backend.
@@ -42,6 +44,12 @@ interface VersioningStoreBackend {
  * for session tracking and state snapshots.
  */
 interface OTStoreBackend extends ServerStoreBackend, VersioningStoreBackend {
+    /**
+     * Get the current revision number without loading state.
+     * @param docId - The document ID.
+     * @returns The current revision number, or 0 if document doesn't exist.
+     */
+    getCurrentRev(docId: string): Promise<number>;
     /** Saves a batch of committed server changes. */
     saveChanges(docId: string, changes: Change[]): Promise<void>;
     /** Lists committed server changes based on revision numbers. */
@@ -55,6 +63,14 @@ type ListFieldsOptions = {
 } | {
     paths: string[];
 };
+/**
+ * Result from LWW getSnapshot. State is a ReadableStream so large snapshots
+ * can be streamed to clients without full materialization.
+ */
+interface SnapshotResult {
+    rev: number;
+    state: ReadableStream<string>;
+}
 /**
  * Interface for LWW (Last-Write-Wins) storage backend.
  * LWW stores fields (not changes) and reconstructs state from fields.
@@ -69,13 +85,11 @@ interface LWWStoreBackend extends ServerStoreBackend {
     getCurrentRev(docId: string): Promise<number>;
     /**
      * Get the latest snapshot of document state.
+     * State is returned as a ReadableStream so it can be streamed to clients.
      * @param docId - The document ID.
-     * @returns The snapshot state and revision, or null if no snapshot exists.
+     * @returns The snapshot revision and state stream, or null if no snapshot exists.
      */
-    getSnapshot(docId: string): Promise<{
-        state: any;
-        rev: number;
-    } | null>;
+    getSnapshot(docId: string): Promise<SnapshotResult | null>;
     /**
      * Save a snapshot of document state (overwrites previous snapshot).
      * @param docId - The document ID.
@@ -150,4 +164,4 @@ interface BranchingStoreBackend {
     closeBranch(branchId: string): Promise<void>;
 }
 
-export type { BranchingStoreBackend, LWWStoreBackend, ListFieldsOptions, OTStoreBackend, ServerStoreBackend, TombstoneStoreBackend, VersioningStoreBackend };
+export type { BranchingStoreBackend, LWWStoreBackend, ListFieldsOptions, OTStoreBackend, ServerStoreBackend, SnapshotResult, TombstoneStoreBackend, VersioningStoreBackend };

package/package.json

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