@dabble/patches 0.2.32 → 0.3.0

package/dist/client/PatchesDoc.js

@@ -1,8 +1,7 @@
-import { createId } from 'crypto-id';
+import { createStateFromSnapshot } from '../algorithms/client/createStateFromSnapshot.js';
+import { makeChange } from '../algorithms/client/makeChange.js';
+import { applyChanges } from '../algorithms/shared/applyChanges.js';
 import { signal } from '../event-signal.js';
-import { createJSONPatch } from '../json-patch/createJSONPatch.js';
-import { applyChanges, rebaseChanges } from '../utils.js';
-import { breakChange } from '../utils/breakChange.js';
 /**
  * Represents a document synchronized using JSON patches.
  * Manages committed state, pending (local-only) changes, and
@@ -17,18 +16,18 @@ export class PatchesDoc {
      */
     constructor(initialState = {}, initialMetadata = {}, options = {}) {
         this._id = null;
-        this._pendingChanges = [];
-        this._sendingChanges = [];
         this._changeMetadata = {};
+        this._syncing = null;
         /** Subscribe to be notified before local state changes. */
         this.onBeforeChange = signal();
         /** Subscribe to be notified after local state changes are applied. */
         this.onChange = signal();
         /** Subscribe to be notified whenever state changes from any source. */
         this.onUpdate = signal();
-        this._committedState = structuredClone(initialState);
+        /** Subscribe to be notified when syncing state changes. */
+        this.onSyncing = signal();
         this._state = structuredClone(initialState);
-        this._committedRev = 0;
+        this._snapshot = { state: this._state, rev: 0, changes: [] };
         this._changeMetadata = initialMetadata;
         this._maxPayloadBytes = options.maxPayloadBytes;
     }
@@ -36,23 +35,23 @@ export class PatchesDoc {
     get id() {
         return this._id;
     }
-    /** Current local state (committed + sending + pending). */
+    /** Current local state (committed + pending). */
     get state() {
         return this._state;
     }
+    /** Are we currently syncing this document? */
+    get syncing() {
+        return this._syncing;
+    }
     /** Last committed revision number from the server. */
     get committedRev() {
-        return this._committedRev;
-    }
-    /** Are there changes currently awaiting server confirmation? */
-    get isSending() {
-        return this._sendingChanges.length > 0;
+        return this._snapshot.rev;
     }
     /** Are there local changes that haven't been sent yet? */
     get hasPending() {
-        return this._pendingChanges.length > 0;
+        return this._snapshot.changes.length > 0;
     }
-    /** Subscribe to be notified whenever value changes. */
+    /** Subscribe to be notified whenever the state changes. */
     subscribe(onUpdate) {
         const unsub = this.onUpdate(onUpdate);
         onUpdate(this._state);
@@ -65,23 +64,15 @@ export class PatchesDoc {
      * are treated as pending.
      */
     export() {
-        return {
-            state: this._committedState,
-            rev: this._committedRev,
-            // Includes sending and pending changes. On import, all become pending.
-            changes: [...this._sendingChanges, ...this._pendingChanges],
-        };
+        return structuredClone(this._snapshot);
     }
     /**
      * Imports previously exported document state.
      * Resets sending state and treats all imported changes as pending.
      */
     import(snapshot) {
-        this._committedState = structuredClone(snapshot.state); // Use structuredClone
-        this._committedRev = snapshot.rev;
-        this._pendingChanges = snapshot.changes ?? []; // All imported changes become pending
-        this._sendingChanges = []; // Reset sending state on import
-        this._recalculateLocalState();
+        this._snapshot = structuredClone(snapshot);
+        this._state = createStateFromSnapshot(snapshot);
         this.onUpdate.emit(this._state);
     }
     /**
@@ -96,203 +87,44 @@ export class PatchesDoc {
      * @returns The generated Change object or null if no changes occurred.
      */
     change(mutator) {
-        const patch = createJSONPatch(this._state, mutator);
-        if (patch.ops.length === 0) {
-            return null;
-        }
-        // Determine the client-side rev for local ordering before server assigns final rev.
-        const lastPendingRev = this._pendingChanges[this._pendingChanges.length - 1]?.rev;
-        const lastSendingRev = this._sendingChanges[this._sendingChanges.length - 1]?.rev;
-        const latestLocalRev = Math.max(this._committedRev, lastPendingRev ?? 0, lastSendingRev ?? 0);
-        // It's the baseRev that matters for sending.
-        const change = {
-            rev: latestLocalRev + 1, // Tentative rev for local sorting
-            id: createId(),
-            ops: patch.ops,
-            baseRev: this._committedRev,
-            created: Date.now(),
-            ...(Object.keys(this._changeMetadata).length > 0 && { metadata: { ...this._changeMetadata } }),
-        };
-        this.onBeforeChange.emit(change);
-        // Apply to local state immediately
-        this._state = patch.apply(this._state);
-        if (this._maxPayloadBytes) {
-            // Check if the change needs to be split due to size
-            const changes = breakChange(change, this._maxPayloadBytes);
-            // Emit events for each change piece
-            for (const piece of changes) {
-                this._pendingChanges.push(piece);
-                this.onChange.emit(piece);
-            }
-        }
-        else {
-            this._pendingChanges.push(change);
-            this.onChange.emit(change);
+        const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxPayloadBytes);
+        if (changes.length === 0) {
+            return changes;
         }
+        this._state = applyChanges(this._state, changes);
+        this._snapshot.changes.push(...changes);
+        this.onChange.emit(changes);
         this.onUpdate.emit(this._state);
-        return change;
+        return changes;
     }
     /**
-     * Retrieves pending changes and marks them as sending.
-     * @returns Array of changes ready to be sent to the server.
-     * @throws Error if changes are already being sent.
+     * Returns the pending changes for this document.
+     * @returns The pending changes.
      */
-    getUpdatesForServer() {
-        if (this.isSending) {
-            // It's generally simpler if the client waits for confirmation before sending more.
-            // If overlapping requests are needed, state management becomes much more complex.
-            throw new Error('Cannot get updates while previous batch is awaiting confirmation.');
-        }
-        if (!this.hasPending) {
-            return [];
-        }
-        this._sendingChanges = this._pendingChanges;
-        this._pendingChanges = [];
-        return this._sendingChanges;
+    getPendingChanges() {
+        return this._snapshot.changes;
     }
     /**
-     * Processes the server's response to a batch of changes sent via `getUpdatesForServer`.
-     * @param serverCommit The array of committed changes from the server.
-     *                     Expected to be empty (`[]`) if the sent batch was a no‑op,
-     *                     or contain **one or more** `Change` objects consisting of:
-     *                       • any missing history since the client's `baseRev`, followed by
-     *                       • the server‑side result of the client's batch (typically the
-     *                         transformed versions of the changes the client sent).
-     * @throws Error if the input format is unexpected or application fails.
+     * Applies committed changes to the document. Should only be called from a sync provider.
+     * @param serverChanges The changes to apply.
+     * @param rebasedPendingChanges The rebased pending changes to apply.
      */
-    applyServerConfirmation(serverCommit) {
-        if (!Array.isArray(serverCommit)) {
-            throw new Error('Invalid server confirmation format: Expected an array.');
-        }
-        if (!this.isSending) {
-            console.warn('Received server confirmation but no changes were marked as sending.');
-            // Decide how to handle this - ignore? Apply if possible?
-            // For now, let's ignore if the server sent something unexpected.
-            if (serverCommit.length === 0)
-                return; // Ignore empty confirmations if not sending
-            // If server sent a commit unexpectedly, it implies a state mismatch. Hard to recover.
-            // Maybe apply cautiously if rev matches?
-            const commit = serverCommit[0];
-            if (commit && commit.rev === this._committedRev + 1) {
-                console.warn('Applying unexpected server commit cautiously.');
-                // Proceed as if confirmation was expected
-            }
-            else {
-                throw new Error('Received unexpected server commit with mismatching revision.');
-            }
-        }
-        if (serverCommit.length === 0) {
-            // Server confirmed no change; discard the sending changes.
-            this._sendingChanges = [];
-        }
-        else {
-            // Server responded with one *or more* changes:
-            //   1. possibly earlier missing revisions produced by other clients
-            //   2. followed by the server‑side commit(s) that correspond to the batch we sent.
-            // Basic sanity check – final revision in the array should advance committedRev.
-            const lastChange = serverCommit[serverCommit.length - 1];
-            if (!lastChange.rev || lastChange.rev <= this._committedRev) {
-                throw new Error(`Server commit invalid final revision: ${lastChange.rev}, expected > ${this._committedRev}`);
-            }
-            // 1. Discard the confirmed _sendingChanges first so that the delegated
-            //    external‑update path does not attempt to rebase them.
-            this._sendingChanges = [];
-            // 2. Apply everything through the common external‑update handler which
-            //    will update committed state, revision, rebase pending changes, etc.
-            this.applyExternalServerUpdate(serverCommit);
-            return; // done – external handler emitted updates
-        }
-        // For the zero‑length confirmation path we still need to recalc state and
-        // notify listeners (the 1‑change path is handled by applyExternalServerUpdate).
-        this._recalculateLocalState();
+    applyCommittedChanges(serverChanges, rebasedPendingChanges) {
+        // Ensure server changes are sequential to the current committed revision
+        if (this._snapshot.rev !== serverChanges[0].rev - 1) {
+            throw new Error('Cannot apply committed changes to a doc that is not at the correct revision');
+        }
+        // Track IDs of pending changes for debugging
+        // const pendingIds = new Set(rebasedPendingChanges.map(c => c.id));
+        // Apply server changes to the base state of the snapshot
+        this._snapshot.state = applyChanges(this._snapshot.state, serverChanges);
+        this._snapshot.rev = serverChanges[serverChanges.length - 1].rev;
+        // The rebasedPendingChanges are the new complete set of pending changes
+        this._snapshot.changes = rebasedPendingChanges;
+        // Recalculate the live state from the updated snapshot
+        this._state = createStateFromSnapshot(this._snapshot);
         this.onUpdate.emit(this._state);
     }
-    /**
-     * Applies incoming changes from the server that were *not* initiated by this client.
-     * @param externalServerChanges An array of sequential changes from the server.
-     */
-    applyExternalServerUpdate(externalServerChanges) {
-        if (externalServerChanges.length === 0) {
-            return;
-        }
-        const firstChange = externalServerChanges[0];
-        // Allow for gaps if server sends updates out of order, but warn.
-        if (firstChange.rev && firstChange.rev <= this._committedRev) {
-            console.warn(`Ignoring external server update starting at revision ${firstChange.rev} which is <= current committed ${this._committedRev}`);
-            return; // Ignore already processed or irrelevant changes
-        }
-        // if (firstChange.rev && firstChange.rev !== this._committedRev + 1) {
-        //   console.warn(`External server update starting at ${firstChange.rev} does not directly follow committed ${this._committedRev}`);
-        //   // Handle potential gaps - request resync? Apply cautiously?
-        // }
-        const lastChange = externalServerChanges[externalServerChanges.length - 1];
-        // 1. Apply to committed state
-        try {
-            this._committedState = applyChanges(this._committedState, externalServerChanges);
-        }
-        catch (error) {
-            console.error('Failed to apply external server update to committed state:', error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Critical sync error applying external server update: ${errorMessage}`);
-        }
-        // 2. Update committed revision
-        if (lastChange.rev) {
-            this._committedRev = lastChange.rev;
-        }
-        else {
-            console.error('External server update missing revision on last change.');
-            // Cannot reliably update revision - potential state divergence
-        }
-        // 3. Rebase *both* sending and pending changes against the external changes
-        if (this.isSending) {
-            this._sendingChanges = rebaseChanges(externalServerChanges, this._sendingChanges);
-        }
-        if (this.hasPending) {
-            this._pendingChanges = rebaseChanges(externalServerChanges, this._pendingChanges);
-        }
-        // 4. Recalculate local state
-        this._recalculateLocalState();
-        // 5. Notify listeners
-        this.onUpdate.emit(this._state);
-    }
-    /**
-     * Handles the scenario where sending changes to the server failed.
-     * Moves the changes that were in the process of being sent back to the
-     * beginning of the pending queue to be retried later.
-     */
-    handleSendFailure() {
-        if (this.isSending) {
-            console.warn(`Handling send failure: Moving ${this._sendingChanges.length} changes back to pending queue.`);
-            // Prepend sending changes back to pending queue to maintain order and prioritize retry
-            this._pendingChanges.unshift(...this._sendingChanges);
-            this._sendingChanges = [];
-            // Do NOT recalculate state here, as the state didn't actually advance
-            // due to the failed send. The state should still reflect the last known
-            // good state + pending changes (which now includes the failed ones).
-        }
-        else {
-            console.warn('handleSendFailure called but no changes were marked as sending.');
-        }
-    }
-    /** Recalculates _state from _committedState + _sendingChanges + _pendingChanges */
-    _recalculateLocalState() {
-        try {
-            this._state = applyChanges(this._committedState, [...this._sendingChanges, ...this._pendingChanges]);
-        }
-        catch (error) {
-            console.error('CRITICAL: Error recalculating local state after update:', error);
-            // This indicates a potentially serious issue with patch application or rebasing logic.
-            // Re-throw the error to allow higher-level handling (e.g., trigger resync)
-            throw error;
-        }
-    }
-    /**
-     * @deprecated Use export() - kept for backward compatibility if needed.
-     */
-    toJSON() {
-        console.warn('PatchesDoc.toJSON() is deprecated. Use export() instead.');
-        return this.export();
-    }
     /**
      * Assigns an identifier to this document. Can only be set once.
      * @param id The unique identifier for the document.
@@ -306,4 +138,15 @@ export class PatchesDoc {
             this._id = id;
         }
     }
+    /**
+     * Updates the syncing state of the document.
+     * @param newSyncing The new syncing state.
+     */
+    updateSyncing(newSyncing) {
+        this._syncing = newSyncing;
+        this.onSyncing.emit(newSyncing);
+    }
+    toJSON() {
+        return this.export();
+    }
 }

package/dist/client/PatchesHistoryClient.js

@@ -1,5 +1,5 @@
+import { applyChanges } from '../algorithms/shared/applyChanges.js';
 import { signal } from '../event-signal.js';
-import { applyChanges } from '../utils.js';
 class LRUCache {
     constructor(maxSize) {
         this.maxSize = maxSize;

package/dist/client/PatchesStore.d.ts

@@ -13,27 +13,204 @@ export interface TrackedDoc {
  */
 export interface PatchesStore {
     /**
-     * Ensure these docs exist in the local index (or undelete them).
-     * Called by `trackDocs` before syncing begins.
+     * Registers documents for local tracking and synchronization.
+     *
+     * Creates local records for new documents or reactivates previously deleted ones.
+     * Must handle duplicate calls gracefully - tracking an already-tracked document is a no-op.
+     * Sets initial committedRev to 0 for new documents.
+     *
+     * @param docIds Array of document IDs to start tracking
+     * @example
+     * // Start tracking two documents
+     * await store.trackDocs(['doc1', 'doc2']);
+     *
+     * // Reactivate a previously deleted document
+     * await store.trackDocs(['previously-deleted-doc']);
      */
     trackDocs(docIds: string[]): Promise<void>;
     /**
-     * Drop all local data for these docs without creating a delete tombstone.
-     * Called by `untrackDocs` when the user no longer cares about a doc locally.
+     * Permanently removes documents from local tracking and storage.
+     *
+     * Deletes all local data (state, pending changes, metadata) without notifying the server.
+     * Use this when the user no longer wants a document synchronized locally, not for collaborative deletion.
+     * Cannot be undone - use deleteDoc() for collaborative deletion that syncs to other clients.
+     *
+     * @param docIds Array of document IDs to stop tracking
+     * @example
+     * // Stop tracking documents the user no longer needs
+     * await store.untrackDocs(['old-draft', 'cancelled-project']);
      */
     untrackDocs(docIds: string[]): Promise<void>;
-    /** List currently tracked docs (optionally including deleted). */
+    /**
+     * Returns metadata for all locally tracked documents.
+     *
+     * By default excludes documents marked as deleted. Set includeDeleted=true to include tombstoned
+     * documents that are pending server deletion confirmation.
+     *
+     * @param includeDeleted Whether to include documents marked for deletion
+     * @returns Array of document metadata including docId, committedRev, and deletion status
+     * @example
+     * // Get active documents
+     * const activeDocs = await store.listDocs();
+     *
+     * // Get all documents including deleted ones
+     * const allDocs = await store.listDocs(true);
+     */
     listDocs(includeDeleted?: boolean): Promise<TrackedDoc[]>;
+    /**
+     * Retrieves the current document snapshot from storage.
+     *
+     * Returns the complete document state as last saved, including revision metadata.
+     * Returns undefined if the document doesn't exist or isn't tracked.
+     * This is the primary method for loading document state on startup.
+     *
+     * @param docId Document identifier
+     * @returns Document snapshot with state and metadata, or undefined if not found
+     * @example
+     * const snapshot = await store.getDoc('my-document');
+     * if (snapshot) {
+     *   console.log('Current state:', snapshot.state);
+     *   console.log('At revision:', snapshot.rev);
+     * }
+     */
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
+    /**
+     * Retrieves all pending (unconfirmed) changes for a document.
+     *
+     * Pending changes are local edits that haven't been confirmed by the server yet.
+     * Returns changes in chronological order as they were created locally.
+     * Used during sync to resend unconfirmed operations.
+     *
+     * @param docId Document identifier
+     * @returns Array of pending changes in chronological order
+     * @example
+     * const pendingChanges = await store.getPendingChanges('my-document');
+     * console.log(`${pendingChanges.length} changes waiting for server confirmation`);
+     */
     getPendingChanges(docId: string): Promise<Change[]>;
+    /**
+     * Returns revision counters for tracking document sync state.
+     *
+     * committedRev: Last revision confirmed by the server
+     * pendingRev: Next revision number for new local changes
+     * The gap between these indicates how many changes are pending server confirmation.
+     *
+     * @param docId Document identifier
+     * @returns Tuple of [committedRev, pendingRev]
+     * @example
+     * const [committed, pending] = await store.getLastRevs('my-document');
+     * console.log(`Server confirmed through rev ${committed}, local changes at rev ${pending}`);
+     * if (pending > committed) {
+     *   console.log(`${pending - committed} changes pending server confirmation`);
+     * }
+     */
     getLastRevs(docId: string): Promise<[committedRev: number, pendingRev: number]>;
+    /**
+     * Saves the current document state to persistent storage.
+     *
+     * Overwrites the existing document snapshot with new state and revision metadata.
+     * Called after applying committed changes from the server or creating document snapshots.
+     * The state should include the revision number it represents.
+     *
+     * @param docId Document identifier
+     * @param docState Complete document state with metadata
+     * @example
+     * // Save state after applying server changes
+     * await store.saveDoc('my-document', {
+     *   state: { title: 'Updated Title', content: '...' },
+     *   rev: 42,
+     *   createdAt: Date.now()
+     * });
+     */
     saveDoc(docId: string, docState: PatchesState): Promise<void>;
-    savePendingChange(docId: string, change: Change): Promise<void>;
+    /**
+     * Appends new pending changes to the document's local change queue.
+     *
+     * Adds changes to the end of the pending changes list without replacing existing ones.
+     * Called when the user makes local edits that haven't been sent to the server yet.
+     * Changes should have sequential revision numbers starting after the last pending change.
+     *
+     * @param docId Document identifier
+     * @param changes Array of new changes to append
+     * @example
+     * // User made a local edit
+     * const newChange = { rev: 15, patches: [...], clientId: 'client-123' };
+     * await store.savePendingChanges('my-document', [newChange]);
+     */
+    savePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    /**
+     * Records changes confirmed by the server and optionally removes sent pending changes.
+     *
+     * Adds server-confirmed changes to the document's history and updates the committed revision.
+     * If sentPendingRange is provided, removes the specified range of pending changes that
+     * were confirmed by the server (they're no longer pending).
+     *
+     * @param docId Document identifier
+     * @param changes Server-confirmed changes to record
+     * @param sentPendingRange Optional range [startRev, endRev] of pending changes to remove
+     * @example
+     * // Server confirmed our changes
+     * await store.saveCommittedChanges('my-document', serverChanges, [10, 12]);
+     *
+     * // Server sent changes from other clients
+     * await store.saveCommittedChanges('my-document', serverChanges);
+     */
     saveCommittedChanges(docId: string, changes: Change[], sentPendingRange?: [number, number]): Promise<void>;
-    /** Permanently delete document (writes tombstone so server delete happens later). */
+    /**
+     * Completely replaces the document's pending changes with a new set.
+     *
+     * Discards all existing pending changes and replaces them with the provided array.
+     * Used when operational transformation rebases pending changes after receiving server updates.
+     * The new changes should have sequential revision numbers.
+     *
+     * @param docId Document identifier
+     * @param changes New complete set of pending changes
+     * @example
+     * // After rebasing pending changes due to server conflicts
+     * const rebasedChanges = transformPendingChanges(serverChanges, currentPending);
+     * await store.replacePendingChanges('my-document', rebasedChanges);
+     */
+    replacePendingChanges(docId: string, changes: Change[]): Promise<void>;
+    /**
+     * Marks a document for collaborative deletion.
+     *
+     * Sets the document's deleted flag to create a tombstone that will be synchronized
+     * to the server and other clients. The document remains locally accessible until
+     * confirmDeleteDoc() is called after server confirmation.
+     * Different from untrackDocs() which only affects local storage.
+     *
+     * @param docId Document identifier to mark for deletion
+     * @example
+     * // User deletes a document
+     * await store.deleteDoc('my-document');
+     * // Document is marked deleted but still accessible until server confirms
+     */
     deleteDoc(docId: string): Promise<void>;
-    /** Confirm that a doc has been deleted (e.g., after a tombstone has been written). */
+    /**
+     * Confirms server-side deletion and removes the document locally.
+     *
+     * Called after the server confirms a document deletion. Removes all local data
+     * for the document including the tombstone. The document will no longer appear
+     * in listDocs() results even with includeDeleted=true.
+     *
+     * @param docId Document identifier to confirm deletion
+     * @example
+     * // Server confirmed the deletion
+     * await store.confirmDeleteDoc('my-document');
+     * // Document is now completely removed from local storage
+     */
     confirmDeleteDoc(docId: string): Promise<void>;
-    /** Close the store */
+    /**
+     * Shuts down the store and releases resources.
+     *
+     * Closes database connections, clears caches, and performs cleanup.
+     * Should be called when the application is shutting down or switching stores.
+     * The store cannot be used after calling close().
+     *
+     * @example
+     * // Application shutdown
+     * await store.close();
+     * // Store is no longer usable
+     */
     close(): Promise<void>;
 }

package/dist/data/change.d.ts

@@ -0,0 +1,3 @@
+import type { JSONPatchOp } from '../json-patch/types';
+import type { Change } from '../types';
+export declare function createChange(baseRev: number, rev: number, ops: JSONPatchOp[], metadata?: Record<string, any>): Change;

package/dist/data/change.js

@@ -0,0 +1,20 @@
+import { inc } from 'alphacounter';
+import { createId } from 'crypto-id';
+/**
+ * Create a change id for a given revision. Uses a random 4 character id, prefixed with a revision number string.
+ * @param rev - The revision number.
+ * @returns The change id.
+ */
+function createChangeId(rev) {
+    return inc.from(rev) + createId(4);
+}
+export function createChange(baseRev, rev, ops, metadata) {
+    return {
+        id: createChangeId(rev),
+        baseRev,
+        rev,
+        ops,
+        created: Date.now(),
+        ...metadata,
+    };
+}

package/dist/data/version.d.ts

@@ -0,0 +1,12 @@
+import type { VersionMetadata } from '../types';
+/**
+ * Create a version id for a given document. Uses a sortable 16 character id.
+ * @returns The version id.
+ */
+export declare function createVersionId(): string;
+/**
+ * Create a version.
+ * @param data - The version data.
+ * @returns The version.
+ */
+export declare function createVersionMetadata(data: Omit<VersionMetadata, 'id'>): VersionMetadata;

package/dist/data/version.js

@@ -0,0 +1,17 @@
+import { createSortableId } from 'crypto-id';
+/**
+ * Create a version id for a given document. Uses a sortable 16 character id.
+ * @returns The version id.
+ */
+export function createVersionId() {
+    return createSortableId();
+}
+/**
+ * Create a version.
+ * @param data - The version data.
+ * @returns The version.
+ */
+export function createVersionMetadata(data) {
+    data.id = createVersionId();
+    return data;
+}

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

@@ -15,7 +15,7 @@ export const add = {
         }
         if (Array.isArray(target)) {
             const index = toArrayIndex(target, lastKey);
-            if (target.length < index) {
+            if (index < 0 || target.length < index) {
                 return `[op:add] invalid array index: ${path}`;
             }
             pluckWithShallowCopy(state, keys, true).splice(index, 0, value);

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

@@ -19,7 +19,7 @@ export const move = {
         }
         if (Array.isArray(target)) {
             const index = toArrayIndex(target, lastKey);
-            if (target.length <= index) {
+            if (index < 0 || target.length <= index) {
                 return `[op:move] invalid array index: ${path}`;
             }
             value = target[index];

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

@@ -12,7 +12,7 @@ export const remove = {
         }
         if (Array.isArray(target)) {
             const index = toArrayIndex(target, lastKey);
-            if (target.length <= index) {
+            if (index < 0 || target.length <= index) {
                 return '[op:remove] invalid array index: ' + path;
             }
             pluckWithShallowCopy(state, keys).splice(index, 1);

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

@@ -16,7 +16,7 @@ export const replace = {
         }
         if (Array.isArray(target)) {
             const index = toArrayIndex(target, lastKey);
-            if (target.length <= index) {
+            if (index < 0 || target.length <= index) {
                 return `[op:replace] invalid array index: ${path}`;
             }
             if (!deepEqual(target[index], value)) {