@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/internal/loro/document.d.ts

@@ -0,0 +1,109 @@
+import { LoroDoc, VersionVector } from "loro-crdt";
+export { getImportBlobMetadata, type ImportBlobMode } from "./importMetadata.js";
+export declare class LoroImportUnresolvedDependenciesError extends Error {
+    readonly importKind: "snapshot" | "updates";
+    constructor(importKind: "snapshot" | "updates");
+}
+export interface VersionVectorSpan {
+    peerId: `${number}`;
+    startCounter: number;
+    endCounter: number;
+}
+export declare function derivePeerId(seed: string | Uint8Array): Promise<`${number}`>;
+export declare function createDocument(peerSeed: string | Uint8Array): Promise<LoroDoc<Record<string, import("loro-crdt").Container>>>;
+export declare function exportAllUpdates(doc: LoroDoc): Uint8Array;
+/** Deterministic, peer-uncompressed identity for an operation-log prefix. */
+export declare function exportFullHistoryIdentity(doc: LoroDoc, endVersion?: string): string;
+/**
+ * Export a mergeable, full-history snapshot — the only snapshot form this
+ * codebase produces. Every document is born with full durable history and
+ * restored from it, so a partial (gc'd) export here is an invariant
+ * violation, not a state to accommodate; fail loudly instead of publishing a
+ * blob that could not safely merge concurrent frontiers.
+ */
+export declare function exportFullHistorySnapshot(doc: LoroDoc): Uint8Array;
+export declare function exportUpdatesSince(doc: LoroDoc, encodedVersionVector?: string | null): Uint8Array;
+export declare function encodeEncodedVersionVector(versionVector: VersionVector): string;
+export declare function encodeVersionVector(doc: LoroDoc): string;
+export declare function emptyVersionVector(): string;
+export declare function decodeVersionVector(encodedVersionVector: string | null | undefined): VersionVector;
+export declare function getUpdateVersionVectors(update: Uint8Array): {
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+};
+export declare function satisfiesVersionVector(encodedVersionVector: string | null | undefined, partialVersionVector: string): boolean;
+export declare function mergeVersionVectors(encodedVersionVectors: ReadonlyArray<string>): string;
+export declare function listVersionVectorSpans(input: {
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+}): VersionVectorSpan[];
+export declare function versionVectorsEqual(left: string | null | undefined, right: string | null | undefined): boolean;
+export declare function importUpdates(doc: LoroDoc, updates: Uint8Array[]): void;
+/**
+ * Load a snapshot blob into a document. Snapshots MUST go through a single
+ * `import()`, never `importBatch()`. A non-empty `pending` means the import
+ * target is incompatible or dependencies are missing, so fail loudly instead
+ * of silently loading a short document.
+ */
+export declare function importSnapshot(doc: LoroDoc, snapshot: Uint8Array): void;
+export declare function getTextValue(doc: LoroDoc, key?: string): string;
+export interface TextCharOpId {
+    /** Peer of the op that inserted this character. */
+    peerId: `${number}`;
+    /** Counter of that op — identifies the character within the peer's stream. */
+    counter: number;
+}
+export interface TextCharBlameSource {
+    /** One entry per Unicode code point of the prose, in document order. */
+    codePoints: string[];
+    /** The op id that inserted each code point — same length and order as `codePoints`. */
+    opIds: TextCharOpId[];
+}
+/**
+ * Per-character op-id attribution for a LoroText container's prose. Returns one
+ * `(peerId, counter)` per Unicode code point — the op that inserted that
+ * character — in document order; the array length equals the code-point count
+ * (`[...text].length`). This is the client-side primitive for character-level
+ * "blame": each op id resolves to a writer by intersecting it against the
+ * document's edit-attribution segments.
+ */
+export declare function listTextCharOpIds(doc: LoroDoc, key?: string): TextCharOpId[];
+/**
+ * {@link listTextCharOpIds} for a persisted snapshot blob, without opening an
+ * editor: rebuilds a throwaway read-only `LoroDoc` from the snapshot and reads
+ * each character's op id, so blame is exact. The doc is only read, never
+ * edited, so no peer id is set.
+ *
+ * Extraction is linear: `getCursor()` is an O(log n) b-tree lookup per code
+ * point (measured ~1.8µs/char — ~90ms for a 50k-char snapshot, flat per char and
+ * unaffected by tombstones). `maxCharacters` (UTF-16 length) is therefore a soft
+ * guard against pathologically large prose, not a quadratic cliff: over it we
+ * return `null` ("skipped, too large", distinct from `[]` for an empty document)
+ * rather than do unbounded synchronous work on the render thread.
+ */
+export declare function listSnapshotCharOpIds(snapshot: Uint8Array, maxCharacters: number, key?: string): TextCharOpId[] | null;
+/**
+ * {@link listSnapshotCharBlameSource} is {@link listSnapshotCharOpIds} that also
+ * returns each code point's text, so a caller can render the prose tinted by
+ * writer (the per-range "blame" view) without a second snapshot reconstruction.
+ * Same linear cost and `maxCharacters` guard.
+ */
+export declare function listSnapshotCharBlameSource(snapshot: Uint8Array, maxCharacters: number, key?: string): TextCharBlameSource | null;
+export interface FieldEditor {
+    /** The map key (e.g. `firstName`, `cardNumber`) of a structured document field. */
+    key: string;
+    /** Peer of the op that last set this field, or null if none is recorded. */
+    peerId: `${number}` | null;
+}
+/**
+ * The structured-document counterpart to {@link listSnapshotCharBlameSource}:
+ * for a persisted snapshot, name the peer that last wrote each key of a LoroMap
+ * (the document's `fields` map). Structured documents (contacts, cards, licenses)
+ * store each field as a `LoroMap` entry — a last-writer-wins register that keeps
+ * the setting op's peer, which `getLastEditor` reads. That peer resolves to a
+ * writer via the same attribution segments,
+ * giving per-field "blame". Fields carry only the peer (no op counter), so
+ * resolution is peer-level. A note (or any document without this map) yields an
+ * empty array. Reconstructing the small map is cheap, so there is no size cap.
+ */
+export declare function listSnapshotFieldEditors(snapshot: Uint8Array, mapKey: string): FieldEditor[];

package/internal/loro/document.js

@@ -0,0 +1,301 @@
+import { base64ToBytes, bytesToBase64 } from "../encoding/index.js";
+import { LoroDoc, VersionVector } from "loro-crdt";
+import { serializeCanonicalHistory } from "./historyCanonicalization.js";
+import { getImportBlobMetadata } from "./importMetadata.js";
+export { getImportBlobMetadata } from "./importMetadata.js";
+function isPeerIdString(value) {
+    return /^\d+$/.test(value);
+}
+const MAX_POSTGRES_INTEGER = 2_147_483_647;
+export class LoroImportUnresolvedDependenciesError extends Error {
+    importKind;
+    constructor(importKind) {
+        super(`import${importKind === "snapshot" ? "Snapshot" : "Updates"} received ${importKind === "snapshot" ? "a snapshot" : "updates"} with unresolved pending dependencies`);
+        this.name = "LoroImportUnresolvedDependenciesError";
+        this.importKind = importKind;
+    }
+}
+function assertSupportedVersionVectorCounter(counter) {
+    if (!Number.isInteger(counter) ||
+        counter < 0 ||
+        counter > MAX_POSTGRES_INTEGER) {
+        throw new Error("Version vector counter is outside the supported integer range.");
+    }
+}
+function normalizeVersionVectorEntries(versionVector) {
+    const entries = new Map();
+    for (const [peerId, counter] of versionVector.toJSON()) {
+        const normalizedPeerId = String(peerId);
+        if (!isPeerIdString(normalizedPeerId)) {
+            throw new Error("Version vector contains a non-numeric peer ID.");
+        }
+        assertSupportedVersionVectorCounter(counter);
+        entries.set(normalizedPeerId, counter);
+    }
+    return entries;
+}
+export async function derivePeerId(seed) {
+    const bytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes.slice()));
+    const view = new DataView(digest.buffer, digest.byteOffset, digest.byteLength);
+    const peerId = (view.getBigUint64(0, false) || 1n).toString();
+    if (!isPeerIdString(peerId)) {
+        throw new Error("Failed to derive a numeric peer ID.");
+    }
+    return peerId;
+}
+export async function createDocument(peerSeed) {
+    const doc = new LoroDoc();
+    doc.setPeerId(await derivePeerId(peerSeed));
+    return doc;
+}
+export function exportAllUpdates(doc) {
+    return doc.export({ mode: "update" });
+}
+/** Deterministic, peer-uncompressed identity for an operation-log prefix. */
+export function exportFullHistoryIdentity(doc, endVersion) {
+    return serializeCanonicalHistory(doc.exportJsonUpdates(undefined, endVersion === undefined ? undefined : decodeVersionVector(endVersion), false));
+}
+/**
+ * Export a mergeable, full-history snapshot — the only snapshot form this
+ * codebase produces. Every document is born with full durable history and
+ * restored from it, so a partial (gc'd) export here is an invariant
+ * violation, not a state to accommodate; fail loudly instead of publishing a
+ * blob that could not safely merge concurrent frontiers.
+ */
+export function exportFullHistorySnapshot(doc) {
+    const snapshot = doc.export({ mode: "snapshot" });
+    const metadata = getImportBlobMetadata(snapshot);
+    if (metadata.mode !== "snapshot" ||
+        !versionVectorsEqual(metadata.partialStartVersionVector, emptyVersionVector())) {
+        throw new Error("Document export lost full history; this document was restored from an incomplete source");
+    }
+    return snapshot;
+}
+export function exportUpdatesSince(doc, encodedVersionVector) {
+    if (!encodedVersionVector) {
+        return exportAllUpdates(doc);
+    }
+    return doc.export({
+        mode: "update",
+        from: VersionVector.decode(base64ToBytes(encodedVersionVector)),
+    });
+}
+export function encodeEncodedVersionVector(versionVector) {
+    return bytesToBase64(versionVector.encode());
+}
+export function encodeVersionVector(doc) {
+    return encodeEncodedVersionVector(doc.oplogVersion());
+}
+export function emptyVersionVector() {
+    return encodeEncodedVersionVector(new VersionVector(undefined));
+}
+export function decodeVersionVector(encodedVersionVector) {
+    if (!encodedVersionVector) {
+        return new VersionVector(undefined);
+    }
+    return VersionVector.decode(base64ToBytes(encodedVersionVector));
+}
+export function getUpdateVersionVectors(update) {
+    const metadata = getImportBlobMetadata(update);
+    return {
+        partialStartVersionVector: metadata.partialStartVersionVector,
+        partialEndVersionVector: metadata.partialEndVersionVector,
+    };
+}
+export function satisfiesVersionVector(encodedVersionVector, partialVersionVector) {
+    const versionVector = decodeVersionVector(encodedVersionVector);
+    const requiredVersionVector = decodeVersionVector(partialVersionVector);
+    for (const [peerId, counter] of requiredVersionVector.toJSON()) {
+        if ((versionVector.get(peerId) ?? 0) < counter) {
+            return false;
+        }
+    }
+    return true;
+}
+export function mergeVersionVectors(encodedVersionVectors) {
+    const merged = new Map();
+    for (const encodedVersionVector of encodedVersionVectors) {
+        for (const [normalizedPeerId, counter] of normalizeVersionVectorEntries(decodeVersionVector(encodedVersionVector))) {
+            merged.set(normalizedPeerId, Math.max(merged.get(normalizedPeerId) ?? 0, counter));
+        }
+    }
+    return encodeEncodedVersionVector(VersionVector.parseJSON(merged));
+}
+export function listVersionVectorSpans(input) {
+    const startEntries = normalizeVersionVectorEntries(decodeVersionVector(input.partialStartVersionVector));
+    const endEntries = normalizeVersionVectorEntries(decodeVersionVector(input.partialEndVersionVector));
+    const spans = [];
+    for (const [peerId, startCounter] of startEntries) {
+        const endCounter = endEntries.get(peerId) ?? 0;
+        if (startCounter > endCounter) {
+            throw new Error("Version vector end must cover start.");
+        }
+    }
+    for (const [peerId, endCounter] of endEntries) {
+        const startCounter = startEntries.get(peerId) ?? 0;
+        if (endCounter <= startCounter) {
+            continue;
+        }
+        spans.push({ peerId, startCounter, endCounter });
+    }
+    return spans.sort((left, right) => left.peerId.localeCompare(right.peerId));
+}
+export function versionVectorsEqual(left, right) {
+    const leftEntries = decodeVersionVector(left).toJSON();
+    const rightEntries = decodeVersionVector(right).toJSON();
+    if (leftEntries.size !== rightEntries.size) {
+        return false;
+    }
+    for (const [peerId, leftCounter] of leftEntries) {
+        if (rightEntries.get(peerId) !== leftCounter) {
+            return false;
+        }
+    }
+    return true;
+}
+export function importUpdates(doc, updates) {
+    // Reject an obsolete member before importBatch can mutate the document.
+    for (const update of updates)
+        getImportBlobMetadata(update);
+    const status = doc.importBatch(updates);
+    if (status.pending != null && status.pending.size > 0) {
+        // importBatch applies out-of-order batches correctly but can still report
+        // the intermediate pending set it saw mid-batch. Trust the document, not
+        // the report: the import only genuinely failed when the document's final
+        // version does not cover some batched update's end version.
+        const documentVersion = encodeVersionVector(doc);
+        const covered = updates.every((update) => satisfiesVersionVector(documentVersion, getImportBlobMetadata(update).partialEndVersionVector));
+        if (!covered) {
+            throw new LoroImportUnresolvedDependenciesError("updates");
+        }
+    }
+}
+/**
+ * Load a snapshot blob into a document. Snapshots MUST go through a single
+ * `import()`, never `importBatch()`. A non-empty `pending` means the import
+ * target is incompatible or dependencies are missing, so fail loudly instead
+ * of silently loading a short document.
+ */
+export function importSnapshot(doc, snapshot) {
+    getImportBlobMetadata(snapshot);
+    const status = doc.import(snapshot);
+    // Reject only a genuinely incomplete import: `pending` can be an empty
+    // VersionVector (size 0) rather than null when everything resolved, so test
+    // for at least one unresolved dependency instead of mere presence.
+    if (status.pending != null && status.pending.size > 0) {
+        throw new LoroImportUnresolvedDependenciesError("snapshot");
+    }
+}
+export function getTextValue(doc, key = "text") {
+    return doc.getText(key).toString();
+}
+/**
+ * Walk a LoroText's prose once, collecting each Unicode code point alongside the
+ * op id `(peerId, counter)` of the op that inserted it. The two arrays share an
+ * index, so callers can both blame and re-render the prose (the per-range view)
+ * from a single pass.
+ *
+ * One Loro op (one counter) is one code point, but an astral character (emoji,
+ * etc.) spans two UTF-16 units. We therefore iterate code points and index
+ * `getCursor` by each code point's LAST UTF-16 unit: a leading high-surrogate
+ * position yields no cursor (so iterating raw UTF-16 units would throw on prose
+ * that opens with an emoji), but the low/last unit always resolves to the
+ * inserting op — and using one position per code point avoids double-counting
+ * the two halves of a surrogate pair.
+ */
+function collectTextCharBlame(doc, key) {
+    const text = doc.getText(key);
+    const codePoints = [];
+    const opIds = [];
+    let utf16End = 0;
+    for (const char of text.toString()) {
+        utf16End += char.length;
+        // getCursor mints a WASM-backed Cursor each call; free it immediately after
+        // reading its op id so a long document does not pile up cursors on the heap.
+        const cursor = text.getCursor(utf16End - 1, 1);
+        const opId = cursor?.pos();
+        cursor?.free();
+        if (opId === undefined) {
+            throw new Error(`LoroText "${key}" code point ending at UTF-16 index ${utf16End - 1} has no op id.`);
+        }
+        codePoints.push(char);
+        opIds.push({ peerId: opId.peer, counter: opId.counter });
+    }
+    return { codePoints, opIds };
+}
+/**
+ * Per-character op-id attribution for a LoroText container's prose. Returns one
+ * `(peerId, counter)` per Unicode code point — the op that inserted that
+ * character — in document order; the array length equals the code-point count
+ * (`[...text].length`). This is the client-side primitive for character-level
+ * "blame": each op id resolves to a writer by intersecting it against the
+ * document's edit-attribution segments.
+ */
+export function listTextCharOpIds(doc, key = "text") {
+    return collectTextCharBlame(doc, key).opIds;
+}
+/**
+ * {@link listTextCharOpIds} for a persisted snapshot blob, without opening an
+ * editor: rebuilds a throwaway read-only `LoroDoc` from the snapshot and reads
+ * each character's op id, so blame is exact. The doc is only read, never
+ * edited, so no peer id is set.
+ *
+ * Extraction is linear: `getCursor()` is an O(log n) b-tree lookup per code
+ * point (measured ~1.8µs/char — ~90ms for a 50k-char snapshot, flat per char and
+ * unaffected by tombstones). `maxCharacters` (UTF-16 length) is therefore a soft
+ * guard against pathologically large prose, not a quadratic cliff: over it we
+ * return `null` ("skipped, too large", distinct from `[]` for an empty document)
+ * rather than do unbounded synchronous work on the render thread.
+ */
+export function listSnapshotCharOpIds(snapshot, maxCharacters, key = "text") {
+    const source = listSnapshotCharBlameSource(snapshot, maxCharacters, key);
+    return source === null ? null : source.opIds;
+}
+/**
+ * {@link listSnapshotCharBlameSource} is {@link listSnapshotCharOpIds} that also
+ * returns each code point's text, so a caller can render the prose tinted by
+ * writer (the per-range "blame" view) without a second snapshot reconstruction.
+ * Same linear cost and `maxCharacters` guard.
+ */
+export function listSnapshotCharBlameSource(snapshot, maxCharacters, key = "text") {
+    const doc = new LoroDoc();
+    try {
+        importSnapshot(doc, snapshot);
+        if (doc.getText(key).length > maxCharacters) {
+            return null;
+        }
+        return collectTextCharBlame(doc, key);
+    }
+    finally {
+        // The throwaway doc is WASM-backed and never returned — free it immediately
+        // rather than waiting for GC, since blame rebuilds one per Info-panel load.
+        doc.free();
+    }
+}
+/**
+ * The structured-document counterpart to {@link listSnapshotCharBlameSource}:
+ * for a persisted snapshot, name the peer that last wrote each key of a LoroMap
+ * (the document's `fields` map). Structured documents (contacts, cards, licenses)
+ * store each field as a `LoroMap` entry — a last-writer-wins register that keeps
+ * the setting op's peer, which `getLastEditor` reads. That peer resolves to a
+ * writer via the same attribution segments,
+ * giving per-field "blame". Fields carry only the peer (no op counter), so
+ * resolution is peer-level. A note (or any document without this map) yields an
+ * empty array. Reconstructing the small map is cheap, so there is no size cap.
+ */
+export function listSnapshotFieldEditors(snapshot, mapKey) {
+    const doc = new LoroDoc();
+    try {
+        importSnapshot(doc, snapshot);
+        const map = doc.getMap(mapKey);
+        return map.keys().map((key) => ({
+            key,
+            peerId: map.getLastEditor(key) ?? null,
+        }));
+    }
+    finally {
+        doc.free();
+    }
+}
+//# sourceMappingURL=document.js.map

package/internal/loro/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","sourceRoot":"","sources":["document.ts"],"names":[],"mappings":"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","sourcesContent":["import { base64ToBytes, bytesToBase64 } from \"@tearleads/encoding\";\nimport { LoroDoc, VersionVector } from \"loro-crdt\";\nimport { serializeCanonicalHistory } from \"./historyCanonicalization\";\nimport { getImportBlobMetadata } from \"./importMetadata\";\n\nexport { getImportBlobMetadata, type ImportBlobMode } from \"./importMetadata\";\n\nfunction isPeerIdString(value: string): value is `${number}` {\n  return /^\\d+$/.test(value);\n}\n\nconst MAX_POSTGRES_INTEGER = 2_147_483_647;\n\nexport class LoroImportUnresolvedDependenciesError extends Error {\n  readonly importKind: \"snapshot\" | \"updates\";\n\n  constructor(importKind: \"snapshot\" | \"updates\") {\n    super(\n      `import${importKind === \"snapshot\" ? \"Snapshot\" : \"Updates\"} received ${\n        importKind === \"snapshot\" ? \"a snapshot\" : \"updates\"\n      } with unresolved pending dependencies`,\n    );\n    this.name = \"LoroImportUnresolvedDependenciesError\";\n    this.importKind = importKind;\n  }\n}\n\nexport interface VersionVectorSpan {\n  peerId: `${number}`;\n  startCounter: number;\n  endCounter: number;\n}\n\nfunction assertSupportedVersionVectorCounter(counter: number): void {\n  if (\n    !Number.isInteger(counter) ||\n    counter < 0 ||\n    counter > MAX_POSTGRES_INTEGER\n  ) {\n    throw new Error(\n      \"Version vector counter is outside the supported integer range.\",\n    );\n  }\n}\n\nfunction normalizeVersionVectorEntries(\n  versionVector: VersionVector,\n): Map<`${number}`, number> {\n  const entries = new Map<`${number}`, number>();\n\n  for (const [peerId, counter] of versionVector.toJSON()) {\n    const normalizedPeerId = String(peerId);\n    if (!isPeerIdString(normalizedPeerId)) {\n      throw new Error(\"Version vector contains a non-numeric peer ID.\");\n    }\n    assertSupportedVersionVectorCounter(counter);\n    entries.set(normalizedPeerId, counter);\n  }\n\n  return entries;\n}\n\nexport async function derivePeerId(\n  seed: string | Uint8Array,\n): Promise<`${number}`> {\n  const bytes =\n    typeof seed === \"string\" ? new TextEncoder().encode(seed) : seed;\n  const digest = new Uint8Array(\n    await crypto.subtle.digest(\"SHA-256\", bytes.slice()),\n  );\n  const view = new DataView(\n    digest.buffer,\n    digest.byteOffset,\n    digest.byteLength,\n  );\n  const peerId = (view.getBigUint64(0, false) || 1n).toString();\n\n  if (!isPeerIdString(peerId)) {\n    throw new Error(\"Failed to derive a numeric peer ID.\");\n  }\n\n  return peerId;\n}\n\nexport async function createDocument(peerSeed: string | Uint8Array) {\n  const doc = new LoroDoc();\n  doc.setPeerId(await derivePeerId(peerSeed));\n  return doc;\n}\n\nexport function exportAllUpdates(doc: LoroDoc): Uint8Array {\n  return doc.export({ mode: \"update\" });\n}\n\n/** Deterministic, peer-uncompressed identity for an operation-log prefix. */\nexport function exportFullHistoryIdentity(\n  doc: LoroDoc,\n  endVersion?: string,\n): string {\n  return serializeCanonicalHistory(\n    doc.exportJsonUpdates(\n      undefined,\n      endVersion === undefined ? undefined : decodeVersionVector(endVersion),\n      false,\n    ),\n  );\n}\n\n/**\n * Export a mergeable, full-history snapshot — the only snapshot form this\n * codebase produces. Every document is born with full durable history and\n * restored from it, so a partial (gc'd) export here is an invariant\n * violation, not a state to accommodate; fail loudly instead of publishing a\n * blob that could not safely merge concurrent frontiers.\n */\nexport function exportFullHistorySnapshot(doc: LoroDoc): Uint8Array {\n  const snapshot = doc.export({ mode: \"snapshot\" });\n  const metadata = getImportBlobMetadata(snapshot);\n  if (\n    metadata.mode !== \"snapshot\" ||\n    !versionVectorsEqual(\n      metadata.partialStartVersionVector,\n      emptyVersionVector(),\n    )\n  ) {\n    throw new Error(\n      \"Document export lost full history; this document was restored from an incomplete source\",\n    );\n  }\n  return snapshot;\n}\n\nexport function exportUpdatesSince(\n  doc: LoroDoc,\n  encodedVersionVector?: string | null,\n): Uint8Array {\n  if (!encodedVersionVector) {\n    return exportAllUpdates(doc);\n  }\n\n  return doc.export({\n    mode: \"update\",\n    from: VersionVector.decode(base64ToBytes(encodedVersionVector)),\n  });\n}\n\nexport function encodeEncodedVersionVector(\n  versionVector: VersionVector,\n): string {\n  return bytesToBase64(versionVector.encode());\n}\n\nexport function encodeVersionVector(doc: LoroDoc): string {\n  return encodeEncodedVersionVector(doc.oplogVersion());\n}\n\nexport function emptyVersionVector(): string {\n  return encodeEncodedVersionVector(new VersionVector(undefined));\n}\n\nexport function decodeVersionVector(\n  encodedVersionVector: string | null | undefined,\n): VersionVector {\n  if (!encodedVersionVector) {\n    return new VersionVector(undefined);\n  }\n\n  return VersionVector.decode(base64ToBytes(encodedVersionVector));\n}\n\nexport function getUpdateVersionVectors(update: Uint8Array): {\n  partialStartVersionVector: string;\n  partialEndVersionVector: string;\n} {\n  const metadata = getImportBlobMetadata(update);\n\n  return {\n    partialStartVersionVector: metadata.partialStartVersionVector,\n    partialEndVersionVector: metadata.partialEndVersionVector,\n  };\n}\n\nexport function satisfiesVersionVector(\n  encodedVersionVector: string | null | undefined,\n  partialVersionVector: string,\n): boolean {\n  const versionVector = decodeVersionVector(encodedVersionVector);\n  const requiredVersionVector = decodeVersionVector(partialVersionVector);\n\n  for (const [peerId, counter] of requiredVersionVector.toJSON()) {\n    if ((versionVector.get(peerId) ?? 0) < counter) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function mergeVersionVectors(\n  encodedVersionVectors: ReadonlyArray<string>,\n): string {\n  const merged = new Map<`${number}`, number>();\n\n  for (const encodedVersionVector of encodedVersionVectors) {\n    for (const [normalizedPeerId, counter] of normalizeVersionVectorEntries(\n      decodeVersionVector(encodedVersionVector),\n    )) {\n      merged.set(\n        normalizedPeerId,\n        Math.max(merged.get(normalizedPeerId) ?? 0, counter),\n      );\n    }\n  }\n\n  return encodeEncodedVersionVector(VersionVector.parseJSON(merged));\n}\n\nexport function listVersionVectorSpans(input: {\n  partialStartVersionVector: string;\n  partialEndVersionVector: string;\n}): VersionVectorSpan[] {\n  const startEntries = normalizeVersionVectorEntries(\n    decodeVersionVector(input.partialStartVersionVector),\n  );\n  const endEntries = normalizeVersionVectorEntries(\n    decodeVersionVector(input.partialEndVersionVector),\n  );\n  const spans: VersionVectorSpan[] = [];\n\n  for (const [peerId, startCounter] of startEntries) {\n    const endCounter = endEntries.get(peerId) ?? 0;\n    if (startCounter > endCounter) {\n      throw new Error(\"Version vector end must cover start.\");\n    }\n  }\n\n  for (const [peerId, endCounter] of endEntries) {\n    const startCounter = startEntries.get(peerId) ?? 0;\n    if (endCounter <= startCounter) {\n      continue;\n    }\n\n    spans.push({ peerId, startCounter, endCounter });\n  }\n\n  return spans.sort((left, right) => left.peerId.localeCompare(right.peerId));\n}\n\nexport function versionVectorsEqual(\n  left: string | null | undefined,\n  right: string | null | undefined,\n): boolean {\n  const leftEntries = decodeVersionVector(left).toJSON();\n  const rightEntries = decodeVersionVector(right).toJSON();\n\n  if (leftEntries.size !== rightEntries.size) {\n    return false;\n  }\n\n  for (const [peerId, leftCounter] of leftEntries) {\n    if (rightEntries.get(peerId) !== leftCounter) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function importUpdates(doc: LoroDoc, updates: Uint8Array[]): void {\n  // Reject an obsolete member before importBatch can mutate the document.\n  for (const update of updates) getImportBlobMetadata(update);\n  const status = doc.importBatch(updates);\n  if (status.pending != null && status.pending.size > 0) {\n    // importBatch applies out-of-order batches correctly but can still report\n    // the intermediate pending set it saw mid-batch. Trust the document, not\n    // the report: the import only genuinely failed when the document's final\n    // version does not cover some batched update's end version.\n    const documentVersion = encodeVersionVector(doc);\n    const covered = updates.every((update) =>\n      satisfiesVersionVector(\n        documentVersion,\n        getImportBlobMetadata(update).partialEndVersionVector,\n      ),\n    );\n    if (!covered) {\n      throw new LoroImportUnresolvedDependenciesError(\"updates\");\n    }\n  }\n}\n\n/**\n * Load a snapshot blob into a document. Snapshots MUST go through a single\n * `import()`, never `importBatch()`. A non-empty `pending` means the import\n * target is incompatible or dependencies are missing, so fail loudly instead\n * of silently loading a short document.\n */\nexport function importSnapshot(doc: LoroDoc, snapshot: Uint8Array): void {\n  getImportBlobMetadata(snapshot);\n  const status = doc.import(snapshot);\n  // Reject only a genuinely incomplete import: `pending` can be an empty\n  // VersionVector (size 0) rather than null when everything resolved, so test\n  // for at least one unresolved dependency instead of mere presence.\n  if (status.pending != null && status.pending.size > 0) {\n    throw new LoroImportUnresolvedDependenciesError(\"snapshot\");\n  }\n}\n\nexport function getTextValue(doc: LoroDoc, key = \"text\"): string {\n  return doc.getText(key).toString();\n}\n\nexport interface TextCharOpId {\n  /** Peer of the op that inserted this character. */\n  peerId: `${number}`;\n  /** Counter of that op — identifies the character within the peer's stream. */\n  counter: number;\n}\n\nexport interface TextCharBlameSource {\n  /** One entry per Unicode code point of the prose, in document order. */\n  codePoints: string[];\n  /** The op id that inserted each code point — same length and order as `codePoints`. */\n  opIds: TextCharOpId[];\n}\n\n/**\n * Walk a LoroText's prose once, collecting each Unicode code point alongside the\n * op id `(peerId, counter)` of the op that inserted it. The two arrays share an\n * index, so callers can both blame and re-render the prose (the per-range view)\n * from a single pass.\n *\n * One Loro op (one counter) is one code point, but an astral character (emoji,\n * etc.) spans two UTF-16 units. We therefore iterate code points and index\n * `getCursor` by each code point's LAST UTF-16 unit: a leading high-surrogate\n * position yields no cursor (so iterating raw UTF-16 units would throw on prose\n * that opens with an emoji), but the low/last unit always resolves to the\n * inserting op — and using one position per code point avoids double-counting\n * the two halves of a surrogate pair.\n */\nfunction collectTextCharBlame(doc: LoroDoc, key: string): TextCharBlameSource {\n  const text = doc.getText(key);\n  const codePoints: string[] = [];\n  const opIds: TextCharOpId[] = [];\n  let utf16End = 0;\n  for (const char of text.toString()) {\n    utf16End += char.length;\n    // getCursor mints a WASM-backed Cursor each call; free it immediately after\n    // reading its op id so a long document does not pile up cursors on the heap.\n    const cursor = text.getCursor(utf16End - 1, 1);\n    const opId = cursor?.pos();\n    cursor?.free();\n    if (opId === undefined) {\n      throw new Error(\n        `LoroText \"${key}\" code point ending at UTF-16 index ${utf16End - 1} has no op id.`,\n      );\n    }\n    codePoints.push(char);\n    opIds.push({ peerId: opId.peer, counter: opId.counter });\n  }\n  return { codePoints, opIds };\n}\n\n/**\n * Per-character op-id attribution for a LoroText container's prose. Returns one\n * `(peerId, counter)` per Unicode code point — the op that inserted that\n * character — in document order; the array length equals the code-point count\n * (`[...text].length`). This is the client-side primitive for character-level\n * \"blame\": each op id resolves to a writer by intersecting it against the\n * document's edit-attribution segments.\n */\nexport function listTextCharOpIds(doc: LoroDoc, key = \"text\"): TextCharOpId[] {\n  return collectTextCharBlame(doc, key).opIds;\n}\n\n/**\n * {@link listTextCharOpIds} for a persisted snapshot blob, without opening an\n * editor: rebuilds a throwaway read-only `LoroDoc` from the snapshot and reads\n * each character's op id, so blame is exact. The doc is only read, never\n * edited, so no peer id is set.\n *\n * Extraction is linear: `getCursor()` is an O(log n) b-tree lookup per code\n * point (measured ~1.8µs/char — ~90ms for a 50k-char snapshot, flat per char and\n * unaffected by tombstones). `maxCharacters` (UTF-16 length) is therefore a soft\n * guard against pathologically large prose, not a quadratic cliff: over it we\n * return `null` (\"skipped, too large\", distinct from `[]` for an empty document)\n * rather than do unbounded synchronous work on the render thread.\n */\nexport function listSnapshotCharOpIds(\n  snapshot: Uint8Array,\n  maxCharacters: number,\n  key = \"text\",\n): TextCharOpId[] | null {\n  const source = listSnapshotCharBlameSource(snapshot, maxCharacters, key);\n  return source === null ? null : source.opIds;\n}\n\n/**\n * {@link listSnapshotCharBlameSource} is {@link listSnapshotCharOpIds} that also\n * returns each code point's text, so a caller can render the prose tinted by\n * writer (the per-range \"blame\" view) without a second snapshot reconstruction.\n * Same linear cost and `maxCharacters` guard.\n */\nexport function listSnapshotCharBlameSource(\n  snapshot: Uint8Array,\n  maxCharacters: number,\n  key = \"text\",\n): TextCharBlameSource | null {\n  const doc = new LoroDoc();\n  try {\n    importSnapshot(doc, snapshot);\n    if (doc.getText(key).length > maxCharacters) {\n      return null;\n    }\n    return collectTextCharBlame(doc, key);\n  } finally {\n    // The throwaway doc is WASM-backed and never returned — free it immediately\n    // rather than waiting for GC, since blame rebuilds one per Info-panel load.\n    doc.free();\n  }\n}\n\nexport interface FieldEditor {\n  /** The map key (e.g. `firstName`, `cardNumber`) of a structured document field. */\n  key: string;\n  /** Peer of the op that last set this field, or null if none is recorded. */\n  peerId: `${number}` | null;\n}\n\n/**\n * The structured-document counterpart to {@link listSnapshotCharBlameSource}:\n * for a persisted snapshot, name the peer that last wrote each key of a LoroMap\n * (the document's `fields` map). Structured documents (contacts, cards, licenses)\n * store each field as a `LoroMap` entry — a last-writer-wins register that keeps\n * the setting op's peer, which `getLastEditor` reads. That peer resolves to a\n * writer via the same attribution segments,\n * giving per-field \"blame\". Fields carry only the peer (no op counter), so\n * resolution is peer-level. A note (or any document without this map) yields an\n * empty array. Reconstructing the small map is cheap, so there is no size cap.\n */\nexport function listSnapshotFieldEditors(\n  snapshot: Uint8Array,\n  mapKey: string,\n): FieldEditor[] {\n  const doc = new LoroDoc();\n  try {\n    importSnapshot(doc, snapshot);\n    const map = doc.getMap(mapKey);\n    return map.keys().map((key) => ({\n      key,\n      peerId: map.getLastEditor(key) ?? null,\n    }));\n  } finally {\n    doc.free();\n  }\n}\n"]}

package/internal/loro/historyCanonicalization.js

@@ -0,0 +1,74 @@
+import { bytesToBase64 } from "../encoding/index.js";
+function compareCanonicalIdentity(left, right) {
+    return left < right ? -1 : Number(left > right);
+}
+function canonicalHistoryValue(value) {
+    if (value === null)
+        return ["null"];
+    if (value === undefined)
+        return ["undefined"];
+    if (typeof value === "boolean")
+        return ["boolean", value];
+    if (typeof value === "bigint")
+        return ["bigint", value.toString()];
+    if (typeof value === "number") {
+        return ["number", Object.is(value, -0) ? "-0" : String(value)];
+    }
+    if (typeof value === "string")
+        return ["string", value];
+    if (value instanceof Uint8Array) {
+        return ["bytes", bytesToBase64(value)];
+    }
+    if (Array.isArray(value)) {
+        return ["array", value.map(canonicalHistoryValue)];
+    }
+    if (value instanceof Map) {
+        const entries = [...value.entries()].map(([key, item]) => [canonicalHistoryValue(key), canonicalHistoryValue(item)]);
+        entries.sort((left, right) => {
+            const leftIdentity = JSON.stringify(left);
+            const rightIdentity = JSON.stringify(right);
+            return compareCanonicalIdentity(leftIdentity, rightIdentity);
+        });
+        return ["map", entries];
+    }
+    if (typeof value === "object") {
+        return [
+            "object",
+            Object.keys(value)
+                .sort()
+                .map((key) => [key, canonicalHistoryValue(Reflect.get(value, key))]),
+        ];
+    }
+    throw new Error(`Unsupported Loro history value type: ${typeof value}`);
+}
+function serializeCanonicalHistoryValue(value) {
+    return JSON.stringify(canonicalHistoryValue(value));
+}
+function canonicalHistoryOperation(operation) {
+    const { content } = operation;
+    // Coalesced backspaces use negative lengths. Slicing that run to one
+    // deletion can produce -1 where the original update used +1: both delete
+    // the same element at the same position. Direction still matters for
+    // longer runs, and application values must retain their literal contents.
+    if (content.type === "delete" && "len" in content && content.len === -1) {
+        return { ...operation, content: { ...content, len: 1 } };
+    }
+    return operation;
+}
+export function serializeCanonicalHistory(history) {
+    const canonicalChanges = history.changes
+        .map((sourceChange) => {
+        const change = {
+            ...sourceChange,
+            ops: sourceChange.ops.map(canonicalHistoryOperation),
+        };
+        return { change, identity: serializeCanonicalHistoryValue(change) };
+    })
+        .sort((left, right) => compareCanonicalIdentity(left.identity, right.identity))
+        .map(({ change }) => change);
+    return serializeCanonicalHistoryValue({
+        ...history,
+        changes: canonicalChanges,
+    });
+}
+//# sourceMappingURL=historyCanonicalization.js.map

package/internal/loro/historyCanonicalization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"historyCanonicalization.js","sourceRoot":"","sources":["historyCanonicalization.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport type { JsonOp, JsonSchema } from \"loro-crdt\";\n\ntype CanonicalHistoryValue =\n  | readonly [\"array\", CanonicalHistoryValue[]]\n  | readonly [\"bigint\", string]\n  | readonly [\"boolean\", boolean]\n  | readonly [\"bytes\", string]\n  | readonly [\n      \"map\",\n      Array<readonly [CanonicalHistoryValue, CanonicalHistoryValue]>,\n    ]\n  | readonly [\"null\"]\n  | readonly [\"number\", string]\n  | readonly [\"object\", Array<readonly [string, CanonicalHistoryValue]>]\n  | readonly [\"string\", string]\n  | readonly [\"undefined\"];\n\nfunction compareCanonicalIdentity(left: string, right: string): number {\n  return left < right ? -1 : Number(left > right);\n}\n\nfunction canonicalHistoryValue(value: unknown): CanonicalHistoryValue {\n  if (value === null) return [\"null\"];\n  if (value === undefined) return [\"undefined\"];\n  if (typeof value === \"boolean\") return [\"boolean\", value];\n  if (typeof value === \"bigint\") return [\"bigint\", value.toString()];\n  if (typeof value === \"number\") {\n    return [\"number\", Object.is(value, -0) ? \"-0\" : String(value)];\n  }\n  if (typeof value === \"string\") return [\"string\", value];\n  if (value instanceof Uint8Array) {\n    return [\"bytes\", bytesToBase64(value)];\n  }\n  if (Array.isArray(value)) {\n    return [\"array\", value.map(canonicalHistoryValue)];\n  }\n  if (value instanceof Map) {\n    const entries = [...value.entries()].map(\n      ([key, item]) =>\n        [canonicalHistoryValue(key), canonicalHistoryValue(item)] as const,\n    );\n    entries.sort((left, right) => {\n      const leftIdentity = JSON.stringify(left);\n      const rightIdentity = JSON.stringify(right);\n      return compareCanonicalIdentity(leftIdentity, rightIdentity);\n    });\n    return [\"map\", entries];\n  }\n  if (typeof value === \"object\") {\n    return [\n      \"object\",\n      Object.keys(value)\n        .sort()\n        .map(\n          (key) =>\n            [key, canonicalHistoryValue(Reflect.get(value, key))] as const,\n        ),\n    ];\n  }\n  throw new Error(`Unsupported Loro history value type: ${typeof value}`);\n}\n\nfunction serializeCanonicalHistoryValue(value: unknown): string {\n  return JSON.stringify(canonicalHistoryValue(value));\n}\n\nfunction canonicalHistoryOperation(operation: JsonOp): JsonOp {\n  const { content } = operation;\n  // Coalesced backspaces use negative lengths. Slicing that run to one\n  // deletion can produce -1 where the original update used +1: both delete\n  // the same element at the same position. Direction still matters for\n  // longer runs, and application values must retain their literal contents.\n  if (content.type === \"delete\" && \"len\" in content && content.len === -1) {\n    return { ...operation, content: { ...content, len: 1 } };\n  }\n  return operation;\n}\n\nexport function serializeCanonicalHistory(history: JsonSchema): string {\n  const canonicalChanges = history.changes\n    .map((sourceChange) => {\n      const change = {\n        ...sourceChange,\n        ops: sourceChange.ops.map(canonicalHistoryOperation),\n      };\n      return { change, identity: serializeCanonicalHistoryValue(change) };\n    })\n    .sort((left, right) =>\n      compareCanonicalIdentity(left.identity, right.identity),\n    )\n    .map(({ change }) => change);\n  return serializeCanonicalHistoryValue({\n    ...history,\n    changes: canonicalChanges,\n  });\n}\n"]}

package/internal/loro/importMetadata.d.ts

@@ -0,0 +1,8 @@
+import { decodeImportBlobMeta } from "loro-crdt";
+export type ImportBlobMode = "snapshot" | "shallow-snapshot" | "update";
+export declare function requireCurrentImportBlobMode(mode: ReturnType<typeof decodeImportBlobMeta>["mode"]): ImportBlobMode;
+export declare function getImportBlobMetadata(update: Uint8Array): {
+    mode: ImportBlobMode;
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+};

package/internal/loro/importMetadata.js

@@ -0,0 +1,17 @@
+import { bytesToBase64 } from "../encoding/index.js";
+import { decodeImportBlobMeta } from "loro-crdt";
+export function requireCurrentImportBlobMode(mode) {
+    if (mode === "outdated-snapshot" || mode === "outdated-update") {
+        throw new Error("Obsolete Loro encoding; reset the document before continuing");
+    }
+    return mode;
+}
+export function getImportBlobMetadata(update) {
+    const metadata = decodeImportBlobMeta(update, true);
+    return {
+        mode: requireCurrentImportBlobMode(metadata.mode),
+        partialStartVersionVector: bytesToBase64(metadata.partialStartVersionVector.encode()),
+        partialEndVersionVector: bytesToBase64(metadata.partialEndVersionVector.encode()),
+    };
+}
+//# sourceMappingURL=importMetadata.js.map

package/internal/loro/importMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"importMetadata.js","sourceRoot":"","sources":["importMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAIjD,MAAM,UAAU,4BAA4B,CAC1C,IAAqD;IAErD,IAAI,IAAI,KAAK,mBAAmB,IAAI,IAAI,KAAK,iBAAiB,EAAE,CAAC;QAC/D,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAAkB;IAKtD,MAAM,QAAQ,GAAG,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACpD,OAAO;QACL,IAAI,EAAE,4BAA4B,CAAC,QAAQ,CAAC,IAAI,CAAC;QACjD,yBAAyB,EAAE,aAAa,CACtC,QAAQ,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAC5C;QACD,uBAAuB,EAAE,aAAa,CACpC,QAAQ,CAAC,uBAAuB,CAAC,MAAM,EAAE,CAC1C;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport { decodeImportBlobMeta } from \"loro-crdt\";\n\nexport type ImportBlobMode = \"snapshot\" | \"shallow-snapshot\" | \"update\";\n\nexport function requireCurrentImportBlobMode(\n  mode: ReturnType<typeof decodeImportBlobMeta>[\"mode\"],\n): ImportBlobMode {\n  if (mode === \"outdated-snapshot\" || mode === \"outdated-update\") {\n    throw new Error(\n      \"Obsolete Loro encoding; reset the document before continuing\",\n    );\n  }\n  return mode;\n}\n\nexport function getImportBlobMetadata(update: Uint8Array): {\n  mode: ImportBlobMode;\n  partialStartVersionVector: string;\n  partialEndVersionVector: string;\n} {\n  const metadata = decodeImportBlobMeta(update, true);\n  return {\n    mode: requireCurrentImportBlobMode(metadata.mode),\n    partialStartVersionVector: bytesToBase64(\n      metadata.partialStartVersionVector.encode(),\n    ),\n    partialEndVersionVector: bytesToBase64(\n      metadata.partialEndVersionVector.encode(),\n    ),\n  };\n}\n"]}

package/internal/loro/index.d.ts

@@ -0,0 +1,4 @@
+export { LoroList, LoroMap } from "loro-crdt";
+export { createDocument, decodeVersionVector, derivePeerId, emptyVersionVector, encodeEncodedVersionVector, encodeVersionVector, exportAllUpdates, exportFullHistoryIdentity, exportFullHistorySnapshot, exportUpdatesSince, type FieldEditor, getImportBlobMetadata, getTextValue, getUpdateVersionVectors, type ImportBlobMode, importSnapshot, importUpdates, LoroImportUnresolvedDependenciesError, listSnapshotCharBlameSource, listSnapshotCharOpIds, listSnapshotFieldEditors, listTextCharOpIds, listVersionVectorSpans, mergeVersionVectors, satisfiesVersionVector, type TextCharBlameSource, type TextCharOpId, type VersionVectorSpan, versionVectorsEqual, } from "./document.js";
+export * from "./shared/index.js";
+export { updateMatchesDocumentHistory } from "./updateIdentity.js";

package/internal/loro/index.js

@@ -0,0 +1,5 @@
+export { LoroList, LoroMap } from "loro-crdt";
+export { createDocument, decodeVersionVector, derivePeerId, emptyVersionVector, encodeEncodedVersionVector, encodeVersionVector, exportAllUpdates, exportFullHistoryIdentity, exportFullHistorySnapshot, exportUpdatesSince, getImportBlobMetadata, getTextValue, getUpdateVersionVectors, importSnapshot, importUpdates, LoroImportUnresolvedDependenciesError, listSnapshotCharBlameSource, listSnapshotCharOpIds, listSnapshotFieldEditors, listTextCharOpIds, listVersionVectorSpans, mergeVersionVectors, satisfiesVersionVector, versionVectorsEqual, } from "./document.js";
+export * from "./shared/index.js";
+export { updateMatchesDocumentHistory } from "./updateIdentity.js";
+//# sourceMappingURL=index.js.map

package/internal/loro/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,EAC1B,mBAAmB,EACnB,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAElB,qBAAqB,EACrB,YAAY,EACZ,uBAAuB,EAEvB,cAAc,EACd,aAAa,EACb,qCAAqC,EACrC,2BAA2B,EAC3B,qBAAqB,EACrB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EAItB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC","sourcesContent":["export { LoroList, LoroMap } from \"loro-crdt\";\nexport {\n  createDocument,\n  decodeVersionVector,\n  derivePeerId,\n  emptyVersionVector,\n  encodeEncodedVersionVector,\n  encodeVersionVector,\n  exportAllUpdates,\n  exportFullHistoryIdentity,\n  exportFullHistorySnapshot,\n  exportUpdatesSince,\n  type FieldEditor,\n  getImportBlobMetadata,\n  getTextValue,\n  getUpdateVersionVectors,\n  type ImportBlobMode,\n  importSnapshot,\n  importUpdates,\n  LoroImportUnresolvedDependenciesError,\n  listSnapshotCharBlameSource,\n  listSnapshotCharOpIds,\n  listSnapshotFieldEditors,\n  listTextCharOpIds,\n  listVersionVectorSpans,\n  mergeVersionVectors,\n  satisfiesVersionVector,\n  type TextCharBlameSource,\n  type TextCharOpId,\n  type VersionVectorSpan,\n  versionVectorsEqual,\n} from \"./document\";\nexport * from \"./shared\";\nexport { updateMatchesDocumentHistory } from \"./updateIdentity\";\n"]}

package/internal/loro/shared/index.d.ts

@@ -0,0 +1 @@
+export type { DocumentCheckpointKind, SyncDocumentOutgoingUpdate, } from "./validators.js";

package/internal/loro/shared/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/internal/loro/shared/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"","sourcesContent":["export type {\n  DocumentCheckpointKind,\n  SyncDocumentOutgoingUpdate,\n} from \"./validators\";\n"]}

package/internal/loro/shared/validators.d.ts

@@ -0,0 +1,12 @@
+export type DocumentCheckpointKind = "rotate_baseline";
+type DocumentCheckpointPayloadKind = "full_history_snapshot";
+export interface SyncDocumentOutgoingUpdate {
+    checkpointKind?: DocumentCheckpointKind;
+    checkpointPayloadKind?: DocumentCheckpointPayloadKind;
+    id: string;
+    encryptedData: string;
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+    sourceVersionVector?: string;
+}
+export {};

package/internal/loro/shared/validators.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validators.js.map

package/internal/loro/shared/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sourceRoot":"","sources":["validators.ts"],"names":[],"mappings":"","sourcesContent":["export type DocumentCheckpointKind = \"rotate_baseline\";\ntype DocumentCheckpointPayloadKind = \"full_history_snapshot\";\n\nexport interface SyncDocumentOutgoingUpdate {\n  checkpointKind?: DocumentCheckpointKind;\n  checkpointPayloadKind?: DocumentCheckpointPayloadKind;\n  id: string;\n  encryptedData: string;\n  partialStartVersionVector: string;\n  partialEndVersionVector: string;\n  sourceVersionVector?: string;\n}\n"]}