@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/workflows/documents/syncContentKeys.d.ts

@@ -0,0 +1,39 @@
+import type { DocumentSyncResponse, DocumentWriterProjectionResponse } from "../../internal/validators/response/index.js";
+import type { DocumentSyncPreparedUpdate, ProjectionVerificationOptions } from "../../data/documents/shared/types.js";
+import type { PendingUpdateRecord } from "../../data/sqlite/documentPersistence.js";
+import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
+type SyncResponseUpdate = DocumentSyncResponse["updates"][number];
+type RawHistoryUnavailableValidator = (input: {
+    contentKeysByEpoch: ReadonlyMap<number, Uint8Array>;
+    updates: readonly SyncResponseUpdate[];
+}) => void | Promise<void>;
+/** A raw recovery cannot reconstruct history without this retained epoch. */
+export declare class DocumentRawHistoryUnavailableError extends Error {
+    readonly contentKeyEpoch: number;
+    readonly code = "document_raw_history_epoch_unavailable";
+    constructor(contentKeyEpoch: number, cause: unknown);
+}
+export declare function prepareDocumentOutgoingUpdates(input: {
+    contentKey: Uint8Array;
+    contentKeyEpoch: number;
+    documentId: string;
+    organizationId: string;
+    pendingUpdates: readonly PendingUpdateRecord[];
+}): Promise<DocumentSyncPreparedUpdate[]>;
+/** @internal Keeps epoch-wide failures anonymous and integrity failures typed. */
+export declare function throwDocumentSyncContentKeyFailure(input: {
+    cause: unknown;
+    updates: readonly SyncResponseUpdate[];
+}): never;
+export declare function unwrapDocumentSyncResponseContentKeys(input: {
+    currentContentKey: Uint8Array;
+    currentContentKeyEpoch: number;
+    execSql?: ExecSql | undefined;
+    historyMode?: "raw" | undefined;
+    /** @internal Validate every decryptable sibling before raw availability wins. */
+    onRawHistoryUnavailable?: RawHistoryUnavailableValidator | undefined;
+    response: DocumentSyncResponse;
+    targetSecretKey: Uint8Array;
+    writerProjection: DocumentWriterProjectionResponse;
+} & ProjectionVerificationOptions): Promise<ReadonlyMap<number, Uint8Array>>;
+export {};

package/workflows/documents/syncContentKeys.js

@@ -0,0 +1,259 @@
+import { importContentKeyMaterial } from "../../data/documents/shared/contentRecordKeys.js";
+import { encryptDocumentPendingUpdate } from "../../data/documents/shared/crypto.js";
+import { assertDocumentSyncUpdateEncryptedRecord } from "../../data/documents/shared/documentSyncUpdateDecryption.js";
+import { isDocumentSyncUpdateIsolationError, isolateDocumentSyncBatchError, isolateDocumentSyncUpdateError, } from "../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { ContainerKekHistoryUnavailableError, collectContainerKeksForDocumentSync, DocumentContentKeyUnavailableError, DocumentHistoryUnavailableError, unwrapDocumentContentKeyFromBundle, } from "../../data/documents/shared/projection.js";
+import { readWriteHeader, serializeCanonical, } from "../../data/documents/shared/readers.js";
+import { projectionVerificationOptions } from "../../data/documents/shared/types.js";
+import { isKeyingVerificationError } from "../../data/keyingProjectionVerification/error.js";
+function isRawHistoryUnavailableCause(error) {
+    return (error instanceof DocumentContentKeyUnavailableError ||
+        (error instanceof DocumentHistoryUnavailableError &&
+            error.historyCause instanceof ContainerKekHistoryUnavailableError));
+}
+/** A raw recovery cannot reconstruct history without this retained epoch. */
+export class DocumentRawHistoryUnavailableError extends Error {
+    contentKeyEpoch;
+    code = "document_raw_history_epoch_unavailable";
+    constructor(contentKeyEpoch, cause) {
+        super(`Document raw-history recovery cannot decrypt content-key epoch ${contentKeyEpoch}`, { cause });
+        this.contentKeyEpoch = contentKeyEpoch;
+        this.name = "DocumentRawHistoryUnavailableError";
+    }
+}
+async function assertResponseEncryptedRecords(updates) {
+    const inspections = await Promise.allSettled(updates.map(assertDocumentSyncUpdateEncryptedRecord));
+    const failures = inspections.flatMap((inspection, index) => inspection.status === "rejected"
+        ? [{ index, reason: inspection.reason }]
+        : []);
+    const firstFailure = failures[0];
+    if (failures.length === 1 && firstFailure) {
+        throw firstFailure.reason;
+    }
+    if (failures.length > 1 && firstFailure) {
+        const stage = isDocumentSyncUpdateIsolationError(firstFailure.reason) &&
+            failures.every(({ reason }) => isDocumentSyncUpdateIsolationError(reason) &&
+                reason.stage === firstFailure.reason.stage)
+            ? firstFailure.reason.stage
+            : "encrypted_record";
+        throw isolateDocumentSyncBatchError({
+            cause: new Error("Multiple document encrypted records are invalid"),
+            stage,
+            updateIds: failures.map(({ index }) => updates[index]?.id ?? "unknown"),
+        });
+    }
+}
+async function throwRawHistoryUnavailable(input) {
+    await assertResponseEncryptedRecords(input.response.updates);
+    await input.validate?.({
+        contentKeysByEpoch: input.contentKeysByEpoch,
+        updates: input.response.updates.filter((update) => input.contentKeysByEpoch.has(readWriteHeader(update.writeHeader, "Document sync response write header").contentKeyEpoch)),
+    });
+    throw new DocumentRawHistoryUnavailableError(input.unavailable.contentKeyEpoch, input.unavailable.cause);
+}
+export async function prepareDocumentOutgoingUpdates(input) {
+    if (input.pendingUpdates.length === 0) {
+        return [];
+    }
+    const contentKeyMaterial = await importContentKeyMaterial(input.contentKey);
+    return Promise.all(input.pendingUpdates.map(async (update) => {
+        const encrypted = await encryptDocumentPendingUpdate({
+            contentKeyMaterial,
+            contentKeyEpoch: input.contentKeyEpoch,
+            documentId: input.documentId,
+            organizationId: input.organizationId,
+            update,
+        });
+        return {
+            contentRecordId: encrypted.contentRecordId,
+            encryptedData: encrypted.encryptedData,
+            id: update.id,
+            partialStartVersionVector: update.partialStartVersionVector,
+            partialEndVersionVector: update.partialEndVersionVector,
+            metadataHash: encrypted.metadataHash,
+            ciphertextHash: encrypted.ciphertextHash,
+            plaintextHash: encrypted.plaintextHash,
+            ...(update.sourceVersionVector
+                ? {
+                    checkpointKind: "rotate_baseline",
+                    checkpointPayloadKind: "full_history_snapshot",
+                    sourceVersionVector: update.sourceVersionVector,
+                }
+                : {}),
+        };
+    }));
+}
+function syncResponseContentKeyBundlesByEpoch(response) {
+    const byEpoch = new Map();
+    for (const bundle of [
+        response.contentKeyBundle,
+        ...response.contentKeyBundles,
+    ]) {
+        const existing = byEpoch.get(bundle.contentKeyEpoch);
+        if (!existing) {
+            byEpoch.set(bundle.contentKeyEpoch, bundle);
+            continue;
+        }
+        if (serializeCanonical(existing, "content-key bundle") !==
+            serializeCanonical(bundle, "content-key bundle")) {
+            throw new Error("Document sync response content-key bundle conflict");
+        }
+    }
+    return byEpoch;
+}
+function syncResponseUpdatesByContentKeyEpoch(response) {
+    const updatesByEpoch = new Map();
+    for (const update of response.updates) {
+        let contentKeyEpoch;
+        try {
+            contentKeyEpoch = readWriteHeader(update.writeHeader, "Document sync response write header").contentKeyEpoch;
+        }
+        catch (error) {
+            throw isolateDocumentSyncUpdateError({
+                cause: error,
+                responseUpdate: update,
+                stage: "write_header",
+                updateId: update.id,
+            });
+        }
+        const epochUpdates = updatesByEpoch.get(contentKeyEpoch);
+        if (epochUpdates)
+            epochUpdates.push(update);
+        else
+            updatesByEpoch.set(contentKeyEpoch, [update]);
+    }
+    return updatesByEpoch;
+}
+function assertBundleMatchesUpdateHeaders(input) {
+    for (const update of input.updates) {
+        const header = readWriteHeader(update.writeHeader, "Document sync response write header");
+        if (header.objectId !== input.bundle.documentId ||
+            header.contentKeyEpoch !== input.bundle.contentKeyEpoch ||
+            (input.requireOriginalTargets &&
+                (header.accessManifestHash !== input.bundle.linkSetManifestHash ||
+                    header.targetHash !== input.bundle.targetHash))) {
+            throw new Error(input.requireOriginalTargets
+                ? "Document sync response content key is unavailable and its bundle differs from the original update headers"
+                : "Document sync response content-key bundle does not match its update headers");
+        }
+    }
+}
+/**
+ * Linking can rewrap a retained key at the same content epoch. Its latest bundle
+ * then has newer targets than older signed updates. A usable key is validated
+ * by the caller's authenticated record decryption; the update's own historical
+ * manifest, targets and signature are verified independently before this step.
+ *
+ * If the key cannot be recovered, require the original target commitments before
+ * calling that an availability failure. Substituted unavailable targets must
+ * still be quarantined, never disguised as legitimate missing history.
+ */
+async function unwrapHistoricalContentKey(input) {
+    assertBundleMatchesUpdateHeaders({ ...input, requireOriginalTargets: false });
+    try {
+        return await unwrapDocumentContentKeyFromBundle(input.bundle, input.documentId, input.collectedKeks.keksByEpochId, input.collectedKeks.predecessorFailuresByEpochId, input.collectedKeks.unattributedPredecessorFailuresByContainerId);
+    }
+    catch (error) {
+        if (isRawHistoryUnavailableCause(error)) {
+            assertBundleMatchesUpdateHeaders({
+                ...input,
+                requireOriginalTargets: true,
+            });
+        }
+        throw error;
+    }
+}
+/** @internal Keeps epoch-wide failures anonymous and integrity failures typed. */
+export function throwDocumentSyncContentKeyFailure(input) {
+    if (isKeyingVerificationError(input.cause)) {
+        throw input.cause;
+    }
+    if (input.cause instanceof DocumentHistoryUnavailableError &&
+        isKeyingVerificationError(input.cause.historyCause)) {
+        throw input.cause.historyCause;
+    }
+    throw isolateDocumentSyncBatchError({
+        cause: input.cause,
+        stage: "content_key",
+        updateIds: input.updates.map((update) => update.id),
+    });
+}
+export async function unwrapDocumentSyncResponseContentKeys(input) {
+    // A stale read-only pass can carry an empty placeholder when none of its
+    // authorizing paths reaches the bundle target. Do not mark that epoch as
+    // resolved: every served update must instead unwrap its bundle through the
+    // verified predecessor KEK chain or fail with an honest error.
+    const contentKeysByEpoch = new Map(input.currentContentKey.byteLength > 0
+        ? [[input.currentContentKeyEpoch, input.currentContentKey]]
+        : []);
+    const updatesByContentKeyEpoch = syncResponseUpdatesByContentKeyEpoch(input.response);
+    const missingContentKeyEpochs = [...updatesByContentKeyEpoch.keys()].filter((contentKeyEpoch) => !contentKeysByEpoch.has(contentKeyEpoch));
+    missingContentKeyEpochs.sort((left, right) => left - right);
+    if (missingContentKeyEpochs.length === 0) {
+        return contentKeysByEpoch;
+    }
+    const missingUpdates = missingContentKeyEpochs.flatMap((contentKeyEpoch) => updatesByContentKeyEpoch.get(contentKeyEpoch) ?? []);
+    let bundlesByEpoch;
+    try {
+        bundlesByEpoch = syncResponseContentKeyBundlesByEpoch(input.response);
+    }
+    catch (error) {
+        throwDocumentSyncContentKeyFailure({
+            cause: error,
+            updates: missingUpdates,
+        });
+    }
+    const absentBundleEpoch = missingContentKeyEpochs.find((contentKeyEpoch) => !bundlesByEpoch.has(contentKeyEpoch));
+    if (absentBundleEpoch !== undefined) {
+        throwDocumentSyncContentKeyFailure({
+            cause: new Error("Document sync response content-key bundle missing"),
+            updates: updatesByContentKeyEpoch.get(absentBundleEpoch) ?? missingUpdates,
+        });
+    }
+    const collectedKeks = await collectContainerKeksForDocumentSync({
+        execSql: input.execSql,
+        secretKey: input.targetSecretKey,
+        writerProjection: input.writerProjection,
+        ...projectionVerificationOptions(input),
+    });
+    let unavailableRawHistory;
+    for (const contentKeyEpoch of missingContentKeyEpochs) {
+        const bundle = bundlesByEpoch.get(contentKeyEpoch);
+        const responseUpdates = updatesByContentKeyEpoch.get(contentKeyEpoch) ?? missingUpdates;
+        if (!bundle) {
+            const error = new Error("Document sync response content-key bundle missing");
+            throwDocumentSyncContentKeyFailure({
+                cause: error,
+                updates: responseUpdates,
+            });
+        }
+        try {
+            contentKeysByEpoch.set(bundle.contentKeyEpoch, await unwrapHistoricalContentKey({
+                bundle,
+                collectedKeks,
+                documentId: input.writerProjection.documentId,
+                updates: responseUpdates,
+            }));
+        }
+        catch (error) {
+            if (input.historyMode === "raw" && isRawHistoryUnavailableCause(error)) {
+                unavailableRawHistory ??= { cause: error, contentKeyEpoch };
+                continue;
+            }
+            throwDocumentSyncContentKeyFailure({
+                cause: error,
+                updates: responseUpdates,
+            });
+        }
+    }
+    if (unavailableRawHistory) {
+        await throwRawHistoryUnavailable({
+            contentKeysByEpoch,
+            response: input.response,
+            unavailable: unavailableRawHistory,
+            validate: input.onRawHistoryUnavailable,
+        });
+    }
+    return contentKeysByEpoch;
+}
+//# sourceMappingURL=syncContentKeys.js.map

package/workflows/documents/syncContentKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncContentKeys.js","sourceRoot":"","sources":["syncContentKeys.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,uCAAuC,EAAE,MAAM,0DAA0D,CAAC;AACnH,OAAO,EACL,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,yDAAyD,CAAC;AACjE,OAAO,EACL,mCAAmC,EACnC,mCAAmC,EACnC,kCAAkC,EAClC,+BAA+B,EAC/B,kCAAkC,GACnC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,eAAe,EACf,kBAAkB,GACnB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAS1F,SAAS,4BAA4B,CACnC,KAAc;IAEd,OAAO,CACL,KAAK,YAAY,kCAAkC;QACnD,CAAC,KAAK,YAAY,+BAA+B;YAC/C,KAAK,CAAC,YAAY,YAAY,mCAAmC,CAAC,CACrE,CAAC;AACJ,CAAC;AAOD,6EAA6E;AAC7E,MAAM,OAAO,kCAAmC,SAAQ,KAAK;IAIhD;IAHF,IAAI,GAAG,wCAAwC,CAAC;IAEzD,YACW,eAAuB,EAChC,KAAc;QAEd,KAAK,CACH,kEAAkE,eAAe,EAAE,EACnF,EAAE,KAAK,EAAE,CACV,CAAC;QANO,oBAAe,GAAf,eAAe,CAAQ;QAOhC,IAAI,CAAC,IAAI,GAAG,oCAAoC,CAAC;IACnD,CAAC;CACF;AAED,KAAK,UAAU,8BAA8B,CAC3C,OAAsC;IAEtC,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,UAAU,CAC1C,OAAO,CAAC,GAAG,CAAC,uCAAuC,CAAC,CACrD,CAAC;IACF,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,CACzD,UAAU,CAAC,MAAM,KAAK,UAAU;QAC9B,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;QACxC,CAAC,CAAC,EAAE,CACP,CAAC;IACF,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACjC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,EAAE,CAAC;QAC1C,MAAM,YAAY,CAAC,MAAM,CAAC;IAC5B,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,EAAE,CAAC;QACxC,MAAM,KAAK,GACT,kCAAkC,CAAC,YAAY,CAAC,MAAM,CAAC;YACvD,QAAQ,CAAC,KAAK,CACZ,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CACb,kCAAkC,CAAC,MAAM,CAAC;gBAC1C,MAAM,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM,CAAC,KAAK,CAC7C;YACC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK;YAC3B,CAAC,CAAC,kBAAkB,CAAC;QACzB,MAAM,6BAA6B,CAAC;YAClC,KAAK,EAAE,IAAI,KAAK,CAAC,iDAAiD,CAAC;YACnE,KAAK;YACL,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,SAAS,CAAC;SACxE,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,KAAK,UAAU,0BAA0B,CAAC,KAKzC;IACC,MAAM,8BAA8B,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7D,MAAM,KAAK,CAAC,QAAQ,EAAE,CAAC;QACrB,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAChD,KAAK,CAAC,kBAAkB,CAAC,GAAG,CAC1B,eAAe,CACb,MAAM,CAAC,WAAW,EAClB,qCAAqC,CACtC,CAAC,eAAe,CAClB,CACF;KACF,CAAC,CAAC;IACH,MAAM,IAAI,kCAAkC,CAC1C,KAAK,CAAC,WAAW,CAAC,eAAe,EACjC,KAAK,CAAC,WAAW,CAAC,KAAK,CACxB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAAC,KAMpD;IACC,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,kBAAkB,GAAG,MAAM,wBAAwB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAE5E,OAAO,OAAO,CAAC,GAAG,CAChB,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,SAAS,GAAG,MAAM,4BAA4B,CAAC;YACnD,kBAAkB;YAClB,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,MAAM;SACP,CAAC,CAAC;QAEH,OAAO;YACL,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,aAAa,EAAE,SAAS,CAAC,aAAa;YACtC,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,yBAAyB,EAAE,MAAM,CAAC,yBAAyB;YAC3D,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;YACvD,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,cAAc,EAAE,SAAS,CAAC,cAAc;YACxC,aAAa,EAAE,SAAS,CAAC,aAAa;YACtC,GAAG,CAAC,MAAM,CAAC,mBAAmB;gBAC5B,CAAC,CAAC;oBACE,cAAc,EAAE,iBAA0B;oBAC1C,qBAAqB,EAAE,uBAAgC;oBACvD,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;iBAChD;gBACH,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AAED,SAAS,oCAAoC,CAC3C,QAA8B;IAE9B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAoD,CAAC;IAE5E,KAAK,MAAM,MAAM,IAAI;QACnB,QAAQ,CAAC,gBAAgB;QACzB,GAAG,QAAQ,CAAC,iBAAiB;KAC9B,EAAE,CAAC;QACF,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;YAC5C,SAAS;QACX,CAAC;QACD,IACE,kBAAkB,CAAC,QAAQ,EAAE,oBAAoB,CAAC;YAClD,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAChD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,oCAAoC,CAC3C,QAA8B;IAE9B,MAAM,cAAc,GAAG,IAAI,GAAG,EAAgC,CAAC;IAC/D,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACtC,IAAI,eAAuB,CAAC;QAC5B,IAAI,CAAC;YACH,eAAe,GAAG,eAAe,CAC/B,MAAM,CAAC,WAAW,EAClB,qCAAqC,CACtC,CAAC,eAAe,CAAC;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,8BAA8B,CAAC;gBACnC,KAAK,EAAE,KAAK;gBACZ,cAAc,EAAE,MAAM;gBACtB,KAAK,EAAE,cAAc;gBACrB,QAAQ,EAAE,MAAM,CAAC,EAAE;aACpB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,YAAY,GAAG,cAAc,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,YAAY;YAAE,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;YACvC,cAAc,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,SAAS,gCAAgC,CAAC,KAIzC;IACC,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,eAAe,CAC5B,MAAM,CAAC,WAAW,EAClB,qCAAqC,CACtC,CAAC;QACF,IACE,MAAM,CAAC,QAAQ,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU;YAC3C,MAAM,CAAC,eAAe,KAAK,KAAK,CAAC,MAAM,CAAC,eAAe;YACvD,CAAC,KAAK,CAAC,sBAAsB;gBAC3B,CAAC,MAAM,CAAC,kBAAkB,KAAK,KAAK,CAAC,MAAM,CAAC,mBAAmB;oBAC7D,MAAM,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EACnD,CAAC;YACD,MAAM,IAAI,KAAK,CACb,KAAK,CAAC,sBAAsB;gBAC1B,CAAC,CAAC,2GAA2G;gBAC7G,CAAC,CAAC,6EAA6E,CAClF,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,KAAK,UAAU,0BAA0B,CAAC,KAOzC;IACC,gCAAgC,CAAC,EAAE,GAAG,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9E,IAAI,CAAC;QACH,OAAO,MAAM,kCAAkC,CAC7C,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,aAAa,CAAC,aAAa,EACjC,KAAK,CAAC,aAAa,CAAC,4BAA4B,EAChD,KAAK,CAAC,aAAa,CAAC,4CAA4C,CACjE,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,4BAA4B,CAAC,KAAK,CAAC,EAAE,CAAC;YACxC,gCAAgC,CAAC;gBAC/B,GAAG,KAAK;gBACR,sBAAsB,EAAE,IAAI;aAC7B,CAAC,CAAC;QACL,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,kCAAkC,CAAC,KAGlD;IACC,IAAI,yBAAyB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,MAAM,KAAK,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IACE,KAAK,CAAC,KAAK,YAAY,+BAA+B;QACtD,yBAAyB,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,EACnD,CAAC;QACD,MAAM,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC;IACjC,CAAC;IACD,MAAM,6BAA6B,CAAC;QAClC,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,aAAa;QACpB,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;KACpD,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qCAAqC,CACzD,KAUiC;IAEjC,yEAAyE;IACzE,yEAAyE;IACzE,2EAA2E;IAC3E,+DAA+D;IAC/D,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAChC,KAAK,CAAC,iBAAiB,CAAC,UAAU,GAAG,CAAC;QACpC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,sBAAsB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAC3D,CAAC,CAAC,EAAE,CACP,CAAC;IACF,MAAM,wBAAwB,GAAG,oCAAoC,CACnE,KAAK,CAAC,QAAQ,CACf,CAAC;IACF,MAAM,uBAAuB,GAAG,CAAC,GAAG,wBAAwB,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CACzE,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,eAAe,CAAC,CAC9D,CAAC;IACF,uBAAuB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;IAC5D,IAAI,uBAAuB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzC,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IACD,MAAM,cAAc,GAAG,uBAAuB,CAAC,OAAO,CACpD,CAAC,eAAe,EAAE,EAAE,CAAC,wBAAwB,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,EAAE,CACzE,CAAC;IACF,IAAI,cAAuE,CAAC;IAC5E,IAAI,CAAC;QACH,cAAc,GAAG,oCAAoC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kCAAkC,CAAC;YACjC,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE,cAAc;SACxB,CAAC,CAAC;IACL,CAAC;IACD,MAAM,iBAAiB,GAAG,uBAAuB,CAAC,IAAI,CACpD,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,eAAe,CAAC,CAC1D,CAAC;IACF,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;QACpC,kCAAkC,CAAC;YACjC,KAAK,EAAE,IAAI,KAAK,CAAC,mDAAmD,CAAC;YACrE,OAAO,EACL,wBAAwB,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,cAAc;SACpE,CAAC,CAAC;IACL,CAAC;IACD,MAAM,aAAa,GAAG,MAAM,mCAAmC,CAAC;QAC9D,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,SAAS,EAAE,KAAK,CAAC,eAAe;QAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,GAAG,6BAA6B,CAAC,KAAK,CAAC;KACxC,CAAC,CAAC;IACH,IAAI,qBAES,CAAC;IAEd,KAAK,MAAM,eAAe,IAAI,uBAAuB,EAAE,CAAC;QACtD,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QACnD,MAAM,eAAe,GACnB,wBAAwB,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,cAAc,CAAC;QAClE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,KAAK,GAAG,IAAI,KAAK,CACrB,mDAAmD,CACpD,CAAC;YACF,kCAAkC,CAAC;gBACjC,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,eAAe;aACzB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC;YACH,kBAAkB,CAAC,GAAG,CACpB,MAAM,CAAC,eAAe,EACtB,MAAM,0BAA0B,CAAC;gBAC/B,MAAM;gBACN,aAAa;gBACb,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU;gBAC7C,OAAO,EAAE,eAAe;aACzB,CAAC,CACH,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,IAAI,4BAA4B,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvE,qBAAqB,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC;gBAC5D,SAAS;YACX,CAAC;YACD,kCAAkC,CAAC;gBACjC,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,eAAe;aACzB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,IAAI,qBAAqB,EAAE,CAAC;QAC1B,MAAM,0BAA0B,CAAC;YAC/B,kBAAkB;YAClB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,WAAW,EAAE,qBAAqB;YAClC,QAAQ,EAAE,KAAK,CAAC,uBAAuB;SACxC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,kBAAkB,CAAC;AAC5B,CAAC","sourcesContent":["import type {\n  DocumentSyncResponse,\n  DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport { importContentKeyMaterial } from \"../../data/documents/shared/contentRecordKeys\";\nimport { encryptDocumentPendingUpdate } from \"../../data/documents/shared/crypto\";\nimport { assertDocumentSyncUpdateEncryptedRecord } from \"../../data/documents/shared/documentSyncUpdateDecryption\";\nimport {\n  isDocumentSyncUpdateIsolationError,\n  isolateDocumentSyncBatchError,\n  isolateDocumentSyncUpdateError,\n} from \"../../data/documents/shared/documentSyncUpdateIsolation\";\nimport {\n  ContainerKekHistoryUnavailableError,\n  collectContainerKeksForDocumentSync,\n  DocumentContentKeyUnavailableError,\n  DocumentHistoryUnavailableError,\n  unwrapDocumentContentKeyFromBundle,\n} from \"../../data/documents/shared/projection\";\nimport {\n  readWriteHeader,\n  serializeCanonical,\n} from \"../../data/documents/shared/readers\";\nimport type {\n  DocumentSyncPreparedUpdate,\n  ProjectionVerificationOptions,\n} from \"../../data/documents/shared/types\";\nimport { projectionVerificationOptions } from \"../../data/documents/shared/types\";\nimport { isKeyingVerificationError } from \"../../data/keyingProjectionVerification/error\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\nimport type { ExecSql } from \"../../data/sqlite/sqlSchema\";\n\ntype SyncResponseUpdate = DocumentSyncResponse[\"updates\"][number];\ntype RawHistoryUnavailableCause =\n  | DocumentContentKeyUnavailableError\n  | DocumentHistoryUnavailableError;\n\nfunction isRawHistoryUnavailableCause(\n  error: unknown,\n): error is RawHistoryUnavailableCause {\n  return (\n    error instanceof DocumentContentKeyUnavailableError ||\n    (error instanceof DocumentHistoryUnavailableError &&\n      error.historyCause instanceof ContainerKekHistoryUnavailableError)\n  );\n}\n\ntype RawHistoryUnavailableValidator = (input: {\n  contentKeysByEpoch: ReadonlyMap<number, Uint8Array>;\n  updates: readonly SyncResponseUpdate[];\n}) => void | Promise<void>;\n\n/** A raw recovery cannot reconstruct history without this retained epoch. */\nexport class DocumentRawHistoryUnavailableError extends Error {\n  readonly code = \"document_raw_history_epoch_unavailable\";\n\n  constructor(\n    readonly contentKeyEpoch: number,\n    cause: unknown,\n  ) {\n    super(\n      `Document raw-history recovery cannot decrypt content-key epoch ${contentKeyEpoch}`,\n      { cause },\n    );\n    this.name = \"DocumentRawHistoryUnavailableError\";\n  }\n}\n\nasync function assertResponseEncryptedRecords(\n  updates: readonly SyncResponseUpdate[],\n): Promise<void> {\n  const inspections = await Promise.allSettled(\n    updates.map(assertDocumentSyncUpdateEncryptedRecord),\n  );\n  const failures = inspections.flatMap((inspection, index) =>\n    inspection.status === \"rejected\"\n      ? [{ index, reason: inspection.reason }]\n      : [],\n  );\n  const firstFailure = failures[0];\n  if (failures.length === 1 && firstFailure) {\n    throw firstFailure.reason;\n  }\n  if (failures.length > 1 && firstFailure) {\n    const stage =\n      isDocumentSyncUpdateIsolationError(firstFailure.reason) &&\n      failures.every(\n        ({ reason }) =>\n          isDocumentSyncUpdateIsolationError(reason) &&\n          reason.stage === firstFailure.reason.stage,\n      )\n        ? firstFailure.reason.stage\n        : \"encrypted_record\";\n    throw isolateDocumentSyncBatchError({\n      cause: new Error(\"Multiple document encrypted records are invalid\"),\n      stage,\n      updateIds: failures.map(({ index }) => updates[index]?.id ?? \"unknown\"),\n    });\n  }\n}\n\nasync function throwRawHistoryUnavailable(input: {\n  contentKeysByEpoch: ReadonlyMap<number, Uint8Array>;\n  response: DocumentSyncResponse;\n  unavailable: { cause: RawHistoryUnavailableCause; contentKeyEpoch: number };\n  validate?: RawHistoryUnavailableValidator | undefined;\n}): Promise<never> {\n  await assertResponseEncryptedRecords(input.response.updates);\n  await input.validate?.({\n    contentKeysByEpoch: input.contentKeysByEpoch,\n    updates: input.response.updates.filter((update) =>\n      input.contentKeysByEpoch.has(\n        readWriteHeader(\n          update.writeHeader,\n          \"Document sync response write header\",\n        ).contentKeyEpoch,\n      ),\n    ),\n  });\n  throw new DocumentRawHistoryUnavailableError(\n    input.unavailable.contentKeyEpoch,\n    input.unavailable.cause,\n  );\n}\n\nexport async function prepareDocumentOutgoingUpdates(input: {\n  contentKey: Uint8Array;\n  contentKeyEpoch: number;\n  documentId: string;\n  organizationId: string;\n  pendingUpdates: readonly PendingUpdateRecord[];\n}): Promise<DocumentSyncPreparedUpdate[]> {\n  if (input.pendingUpdates.length === 0) {\n    return [];\n  }\n  const contentKeyMaterial = await importContentKeyMaterial(input.contentKey);\n\n  return Promise.all(\n    input.pendingUpdates.map(async (update) => {\n      const encrypted = await encryptDocumentPendingUpdate({\n        contentKeyMaterial,\n        contentKeyEpoch: input.contentKeyEpoch,\n        documentId: input.documentId,\n        organizationId: input.organizationId,\n        update,\n      });\n\n      return {\n        contentRecordId: encrypted.contentRecordId,\n        encryptedData: encrypted.encryptedData,\n        id: update.id,\n        partialStartVersionVector: update.partialStartVersionVector,\n        partialEndVersionVector: update.partialEndVersionVector,\n        metadataHash: encrypted.metadataHash,\n        ciphertextHash: encrypted.ciphertextHash,\n        plaintextHash: encrypted.plaintextHash,\n        ...(update.sourceVersionVector\n          ? {\n              checkpointKind: \"rotate_baseline\" as const,\n              checkpointPayloadKind: \"full_history_snapshot\" as const,\n              sourceVersionVector: update.sourceVersionVector,\n            }\n          : {}),\n      };\n    }),\n  );\n}\n\nfunction syncResponseContentKeyBundlesByEpoch(\n  response: DocumentSyncResponse,\n): ReadonlyMap<number, DocumentSyncResponse[\"contentKeyBundle\"]> {\n  const byEpoch = new Map<number, DocumentSyncResponse[\"contentKeyBundle\"]>();\n\n  for (const bundle of [\n    response.contentKeyBundle,\n    ...response.contentKeyBundles,\n  ]) {\n    const existing = byEpoch.get(bundle.contentKeyEpoch);\n    if (!existing) {\n      byEpoch.set(bundle.contentKeyEpoch, bundle);\n      continue;\n    }\n    if (\n      serializeCanonical(existing, \"content-key bundle\") !==\n      serializeCanonical(bundle, \"content-key bundle\")\n    ) {\n      throw new Error(\"Document sync response content-key bundle conflict\");\n    }\n  }\n\n  return byEpoch;\n}\n\nfunction syncResponseUpdatesByContentKeyEpoch(\n  response: DocumentSyncResponse,\n): ReadonlyMap<number, readonly SyncResponseUpdate[]> {\n  const updatesByEpoch = new Map<number, SyncResponseUpdate[]>();\n  for (const update of response.updates) {\n    let contentKeyEpoch: number;\n    try {\n      contentKeyEpoch = readWriteHeader(\n        update.writeHeader,\n        \"Document sync response write header\",\n      ).contentKeyEpoch;\n    } catch (error) {\n      throw isolateDocumentSyncUpdateError({\n        cause: error,\n        responseUpdate: update,\n        stage: \"write_header\",\n        updateId: update.id,\n      });\n    }\n    const epochUpdates = updatesByEpoch.get(contentKeyEpoch);\n    if (epochUpdates) epochUpdates.push(update);\n    else updatesByEpoch.set(contentKeyEpoch, [update]);\n  }\n  return updatesByEpoch;\n}\n\nfunction assertBundleMatchesUpdateHeaders(input: {\n  bundle: DocumentSyncResponse[\"contentKeyBundle\"];\n  requireOriginalTargets: boolean;\n  updates: readonly SyncResponseUpdate[];\n}): void {\n  for (const update of input.updates) {\n    const header = readWriteHeader(\n      update.writeHeader,\n      \"Document sync response write header\",\n    );\n    if (\n      header.objectId !== input.bundle.documentId ||\n      header.contentKeyEpoch !== input.bundle.contentKeyEpoch ||\n      (input.requireOriginalTargets &&\n        (header.accessManifestHash !== input.bundle.linkSetManifestHash ||\n          header.targetHash !== input.bundle.targetHash))\n    ) {\n      throw new Error(\n        input.requireOriginalTargets\n          ? \"Document sync response content key is unavailable and its bundle differs from the original update headers\"\n          : \"Document sync response content-key bundle does not match its update headers\",\n      );\n    }\n  }\n}\n\n/**\n * Linking can rewrap a retained key at the same content epoch. Its latest bundle\n * then has newer targets than older signed updates. A usable key is validated\n * by the caller's authenticated record decryption; the update's own historical\n * manifest, targets and signature are verified independently before this step.\n *\n * If the key cannot be recovered, require the original target commitments before\n * calling that an availability failure. Substituted unavailable targets must\n * still be quarantined, never disguised as legitimate missing history.\n */\nasync function unwrapHistoricalContentKey(input: {\n  bundle: DocumentSyncResponse[\"contentKeyBundle\"];\n  documentId: string;\n  collectedKeks: Awaited<\n    ReturnType<typeof collectContainerKeksForDocumentSync>\n  >;\n  updates: readonly SyncResponseUpdate[];\n}): Promise<Uint8Array> {\n  assertBundleMatchesUpdateHeaders({ ...input, requireOriginalTargets: false });\n  try {\n    return await unwrapDocumentContentKeyFromBundle(\n      input.bundle,\n      input.documentId,\n      input.collectedKeks.keksByEpochId,\n      input.collectedKeks.predecessorFailuresByEpochId,\n      input.collectedKeks.unattributedPredecessorFailuresByContainerId,\n    );\n  } catch (error) {\n    if (isRawHistoryUnavailableCause(error)) {\n      assertBundleMatchesUpdateHeaders({\n        ...input,\n        requireOriginalTargets: true,\n      });\n    }\n    throw error;\n  }\n}\n\n/** @internal Keeps epoch-wide failures anonymous and integrity failures typed. */\nexport function throwDocumentSyncContentKeyFailure(input: {\n  cause: unknown;\n  updates: readonly SyncResponseUpdate[];\n}): never {\n  if (isKeyingVerificationError(input.cause)) {\n    throw input.cause;\n  }\n  if (\n    input.cause instanceof DocumentHistoryUnavailableError &&\n    isKeyingVerificationError(input.cause.historyCause)\n  ) {\n    throw input.cause.historyCause;\n  }\n  throw isolateDocumentSyncBatchError({\n    cause: input.cause,\n    stage: \"content_key\",\n    updateIds: input.updates.map((update) => update.id),\n  });\n}\n\nexport async function unwrapDocumentSyncResponseContentKeys(\n  input: {\n    currentContentKey: Uint8Array;\n    currentContentKeyEpoch: number;\n    execSql?: ExecSql | undefined;\n    historyMode?: \"raw\" | undefined;\n    /** @internal Validate every decryptable sibling before raw availability wins. */\n    onRawHistoryUnavailable?: RawHistoryUnavailableValidator | undefined;\n    response: DocumentSyncResponse;\n    targetSecretKey: Uint8Array;\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<ReadonlyMap<number, Uint8Array>> {\n  // A stale read-only pass can carry an empty placeholder when none of its\n  // authorizing paths reaches the bundle target. Do not mark that epoch as\n  // resolved: every served update must instead unwrap its bundle through the\n  // verified predecessor KEK chain or fail with an honest error.\n  const contentKeysByEpoch = new Map<number, Uint8Array>(\n    input.currentContentKey.byteLength > 0\n      ? [[input.currentContentKeyEpoch, input.currentContentKey]]\n      : [],\n  );\n  const updatesByContentKeyEpoch = syncResponseUpdatesByContentKeyEpoch(\n    input.response,\n  );\n  const missingContentKeyEpochs = [...updatesByContentKeyEpoch.keys()].filter(\n    (contentKeyEpoch) => !contentKeysByEpoch.has(contentKeyEpoch),\n  );\n  missingContentKeyEpochs.sort((left, right) => left - right);\n  if (missingContentKeyEpochs.length === 0) {\n    return contentKeysByEpoch;\n  }\n  const missingUpdates = missingContentKeyEpochs.flatMap(\n    (contentKeyEpoch) => updatesByContentKeyEpoch.get(contentKeyEpoch) ?? [],\n  );\n  let bundlesByEpoch: ReturnType<typeof syncResponseContentKeyBundlesByEpoch>;\n  try {\n    bundlesByEpoch = syncResponseContentKeyBundlesByEpoch(input.response);\n  } catch (error) {\n    throwDocumentSyncContentKeyFailure({\n      cause: error,\n      updates: missingUpdates,\n    });\n  }\n  const absentBundleEpoch = missingContentKeyEpochs.find(\n    (contentKeyEpoch) => !bundlesByEpoch.has(contentKeyEpoch),\n  );\n  if (absentBundleEpoch !== undefined) {\n    throwDocumentSyncContentKeyFailure({\n      cause: new Error(\"Document sync response content-key bundle missing\"),\n      updates:\n        updatesByContentKeyEpoch.get(absentBundleEpoch) ?? missingUpdates,\n    });\n  }\n  const collectedKeks = await collectContainerKeksForDocumentSync({\n    execSql: input.execSql,\n    secretKey: input.targetSecretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n  let unavailableRawHistory:\n    | { cause: RawHistoryUnavailableCause; contentKeyEpoch: number }\n    | undefined;\n\n  for (const contentKeyEpoch of missingContentKeyEpochs) {\n    const bundle = bundlesByEpoch.get(contentKeyEpoch);\n    const responseUpdates =\n      updatesByContentKeyEpoch.get(contentKeyEpoch) ?? missingUpdates;\n    if (!bundle) {\n      const error = new Error(\n        \"Document sync response content-key bundle missing\",\n      );\n      throwDocumentSyncContentKeyFailure({\n        cause: error,\n        updates: responseUpdates,\n      });\n    }\n    try {\n      contentKeysByEpoch.set(\n        bundle.contentKeyEpoch,\n        await unwrapHistoricalContentKey({\n          bundle,\n          collectedKeks,\n          documentId: input.writerProjection.documentId,\n          updates: responseUpdates,\n        }),\n      );\n    } catch (error) {\n      if (input.historyMode === \"raw\" && isRawHistoryUnavailableCause(error)) {\n        unavailableRawHistory ??= { cause: error, contentKeyEpoch };\n        continue;\n      }\n      throwDocumentSyncContentKeyFailure({\n        cause: error,\n        updates: responseUpdates,\n      });\n    }\n  }\n\n  if (unavailableRawHistory) {\n    await throwRawHistoryUnavailable({\n      contentKeysByEpoch,\n      response: input.response,\n      unavailable: unavailableRawHistory,\n      validate: input.onRawHistoryUnavailable,\n    });\n  }\n\n  return contentKeysByEpoch;\n}\n"]}

package/workflows/documents/syncFailureClassification.d.ts

@@ -0,0 +1,74 @@
+import type { DocumentSyncSubmitFailure } from "../../data/documents/shared/types.js";
+import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
+export type RemoteDocumentDeletionHandler = (input: {
+    /** Present only after the SDK has verified the signed terminal purge proof. */
+    readonly commitPurgeProof?: ((transactionExecSql: ExecSql) => Promise<void>) | undefined;
+    readonly documentId: string;
+}) => Promise<void> | void;
+/**
+ * Invoked when a submission fails terminally — the failure is neither a
+ * retryable conflict nor a recoverable update-id conflict, so the sync pass
+ * stops and the pending writes stay queued (e.g. a 403 after write access was
+ * revoked). Callers persist the failure so the write queue can surface it.
+ */
+export type TerminalSubmitFailureHandler = (failure: DocumentSyncSubmitFailure) => Promise<void> | void;
+/**
+ * Read-only counterpart to describeDocumentSyncSubmitFailure: names a refused
+ * revalidation without implying a blocked write. 403s never reach this — a
+ * read-only 403 is deliberately suppressed (edge-case row 9) so unattempted
+ * local edits are never flagged.
+ */
+export declare function describeDocumentRevalidationFailure(failure: Pick<DocumentSyncSubmitFailure, "message" | "status">): string;
+/** Human-readable description of a terminal submit failure for queue display. */
+export declare function describeDocumentSyncSubmitFailure(failure: Pick<DocumentSyncSubmitFailure, "message" | "status">): string;
+type ProjectionIntegrityErrorCode = "equivocation" | "rollback" | "stale_predecessor";
+export declare function projectionIntegrityErrorCode(error: unknown): ProjectionIntegrityErrorCode | null;
+/**
+ * Shared shell for the stale-projection retry classifiers. A cached
+ * projection older than a checkpoint we already recorded ("rollback") —
+ * typical right after a peer shared/rotated a linked container — is resolved
+ * by refetching the current projection. The refetch is safe: it cannot
+ * bypass the anti-rollback check, because a genuinely rolled-back server
+ * response re-throws on the rebuilt plan. Any other keying-verification
+ * failure is terminal; anything else defers to the caller's message
+ * predicate for its unwrap-failure shape.
+ */
+export declare function shouldRetryWithFreshProjection(error: unknown, messageMatches: (message: string) => boolean): boolean;
+export declare function shouldRetrySyncWithFreshWriterProjection(error: unknown): boolean;
+export declare function isRecoverableDocumentUpdateIdConflict(failure: DocumentSyncSubmitFailure): boolean;
+/**
+ * The server's covering-baseline gate refused a queued rotation checkpoint
+ * (e.g. a leftover from an interrupted recovery or a lost heal ack) because
+ * it no longer covers the committed frontier. The pass can repair itself by
+ * regenerating a fresh covering baseline from the live document instead of
+ * resubmitting the stale payload — which would fail terminally forever.
+ */
+export declare function isCheckpointCoverageConflict(failure: DocumentSyncSubmitFailure): boolean;
+/**
+ * A create submitted with a stable documentId whose first attempt already
+ * committed server-side comes back as this 409 (see the server's
+ * `assertCreateCanAdvanceDocumentHead`). It is not a failure — the caller adopts
+ * the existing remote document instead of creating a duplicate.
+ */
+export declare function isDocumentManifestAlreadyExistsConflict(failure: {
+    readonly code?: string | undefined;
+    readonly message: string;
+    readonly status: number | null;
+}): boolean;
+export declare function canRetryDocumentSyncConflict(input: {
+    attempt: number;
+    failure: DocumentSyncSubmitFailure;
+    maxAttempts: number;
+}): boolean;
+export declare function canRecoverDocumentUpdateIdConflict(input: {
+    attempt: number;
+    failure: DocumentSyncSubmitFailure;
+    maxAttempts: number;
+    pendingUpdateCount: number;
+}): boolean;
+export declare function handleUpstreamDeletedDocumentSyncFailure(input: {
+    documentId: string;
+    failure: DocumentSyncSubmitFailure;
+    onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;
+}): Promise<boolean>;
+export {};

package/workflows/documents/syncFailureClassification.js

@@ -0,0 +1,120 @@
+import { KeyingVerificationError } from "../../internal/crypto/index.js";
+import { DOCUMENT_MUTATION_ERROR_CODES, DOCUMENT_SYNC_ERROR_CODES, } from "../../internal/validators/response/index.js";
+import { ContainerKekRepairRequiredError } from "../../data/documents/shared/containerKekCurrency.js";
+import { isRetryableDocumentSyncConflict, isUpstreamDeletedDocumentSyncFailure, } from "../../data/documents/shared/responses.js";
+import { isKeyingVerificationError } from "../../data/keyingProjectionVerification/error.js";
+/**
+ * Read-only counterpart to describeDocumentSyncSubmitFailure: names a refused
+ * revalidation without implying a blocked write. 403s never reach this — a
+ * read-only 403 is deliberately suppressed (edge-case row 9) so unattempted
+ * local edits are never flagged.
+ */
+export function describeDocumentRevalidationFailure(failure) {
+    const detail = failure.message.trim().length > 0
+        ? failure.message.trim()
+        : "the server refused the read";
+    const suffix = failure.status === null ? "" : ` (${failure.status})`;
+    return `Remote revalidation failed: ${detail}${suffix}`;
+}
+/** Human-readable description of a terminal submit failure for queue display. */
+export function describeDocumentSyncSubmitFailure(failure) {
+    if (failure.status === 403) {
+        return "Write access denied by the server (403)";
+    }
+    const message = failure.message.trim().length > 0 ? failure.message.trim() : "Sync failed";
+    return failure.status === null ? message : `${message} (${failure.status})`;
+}
+function keyingVerificationErrorCode(error) {
+    if (!isKeyingVerificationError(error) || !(error instanceof Error)) {
+        return null;
+    }
+    const code = Reflect.get(error, "code");
+    return typeof code === "string" ? code : null;
+}
+export function projectionIntegrityErrorCode(error) {
+    if (!(error instanceof KeyingVerificationError) &&
+        !(error instanceof Error && error.name === "KeyingVerificationError")) {
+        return null;
+    }
+    const code = keyingVerificationErrorCode(error);
+    return code === "rollback" ||
+        code === "equivocation" ||
+        code === "stale_predecessor"
+        ? code
+        : null;
+}
+/**
+ * Shared shell for the stale-projection retry classifiers. A cached
+ * projection older than a checkpoint we already recorded ("rollback") —
+ * typical right after a peer shared/rotated a linked container — is resolved
+ * by refetching the current projection. The refetch is safe: it cannot
+ * bypass the anti-rollback check, because a genuinely rolled-back server
+ * response re-throws on the rebuilt plan. Any other keying-verification
+ * failure is terminal; anything else defers to the caller's message
+ * predicate for its unwrap-failure shape.
+ */
+export function shouldRetryWithFreshProjection(error, messageMatches) {
+    // A peer may already have repaired the chain. Refetch once; the same guard
+    // rejects a still-stale response before any new ciphertext is produced.
+    if (error instanceof ContainerKekRepairRequiredError)
+        return true;
+    const integrityErrorCode = projectionIntegrityErrorCode(error);
+    if (integrityErrorCode) {
+        return integrityErrorCode === "rollback";
+    }
+    if (keyingVerificationErrorCode(error) === "invalid_shape") {
+        // Verification boundaries normalize malformed/stale projection data to a
+        // terminal error. One cache eviction is still safe: a dishonest or broken
+        // fresh response fails again outside this retry boundary.
+        return true;
+    }
+    if (isKeyingVerificationError(error)) {
+        return false;
+    }
+    return error instanceof Error && messageMatches(error.message);
+}
+export function shouldRetrySyncWithFreshWriterProjection(error) {
+    return shouldRetryWithFreshProjection(error, (message) => message.startsWith("Document authorizing container KEK path could not be unwrapped") && message.includes("Container writer projection KEK"));
+}
+export function isRecoverableDocumentUpdateIdConflict(failure) {
+    return (failure.status === 409 &&
+        failure.code === DOCUMENT_SYNC_ERROR_CODES.updateIdConflict);
+}
+/**
+ * The server's covering-baseline gate refused a queued rotation checkpoint
+ * (e.g. a leftover from an interrupted recovery or a lost heal ack) because
+ * it no longer covers the committed frontier. The pass can repair itself by
+ * regenerating a fresh covering baseline from the live document instead of
+ * resubmitting the stale payload — which would fail terminally forever.
+ */
+export function isCheckpointCoverageConflict(failure) {
+    return (failure.status === 409 &&
+        failure.code === DOCUMENT_SYNC_ERROR_CODES.checkpointCoverageConflict);
+}
+/**
+ * A create submitted with a stable documentId whose first attempt already
+ * committed server-side comes back as this 409 (see the server's
+ * `assertCreateCanAdvanceDocumentHead`). It is not a failure — the caller adopts
+ * the existing remote document instead of creating a duplicate.
+ */
+export function isDocumentManifestAlreadyExistsConflict(failure) {
+    return (failure.status === 409 &&
+        failure.code === DOCUMENT_MUTATION_ERROR_CODES.manifestAlreadyExists);
+}
+export function canRetryDocumentSyncConflict(input) {
+    return (input.attempt < input.maxAttempts &&
+        isRetryableDocumentSyncConflict(input.failure));
+}
+export function canRecoverDocumentUpdateIdConflict(input) {
+    return (input.attempt < input.maxAttempts &&
+        input.pendingUpdateCount > 0 &&
+        isRecoverableDocumentUpdateIdConflict(input.failure));
+}
+export async function handleUpstreamDeletedDocumentSyncFailure(input) {
+    if (!isUpstreamDeletedDocumentSyncFailure(input.failure)) {
+        return false;
+    }
+    await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });
+    return true;
+}
+//# sourceMappingURL=syncFailureClassification.js.map

package/workflows/documents/syncFailureClassification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncFailureClassification.js","sourceRoot":"","sources":["syncFailureClassification.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyingVerificationError } from \"@tearleads/crypto\";\nimport {\n  DOCUMENT_MUTATION_ERROR_CODES,\n  DOCUMENT_SYNC_ERROR_CODES,\n} from \"@tearleads/validators/response\";\nimport { ContainerKekRepairRequiredError } from \"../../data/documents/shared/containerKekCurrency\";\nimport {\n  isRetryableDocumentSyncConflict,\n  isUpstreamDeletedDocumentSyncFailure,\n} from \"../../data/documents/shared/responses\";\nimport type { DocumentSyncSubmitFailure } from \"../../data/documents/shared/types\";\nimport { isKeyingVerificationError } from \"../../data/keyingProjectionVerification/error\";\nimport type { ExecSql } from \"../../data/sqlite/sqlSchema\";\n\nexport type RemoteDocumentDeletionHandler = (input: {\n  /** Present only after the SDK has verified the signed terminal purge proof. */\n  readonly commitPurgeProof?:\n    | ((transactionExecSql: ExecSql) => Promise<void>)\n    | undefined;\n  readonly documentId: string;\n}) => Promise<void> | void;\n\n/**\n * Invoked when a submission fails terminally — the failure is neither a\n * retryable conflict nor a recoverable update-id conflict, so the sync pass\n * stops and the pending writes stay queued (e.g. a 403 after write access was\n * revoked). Callers persist the failure so the write queue can surface it.\n */\nexport type TerminalSubmitFailureHandler = (\n  failure: DocumentSyncSubmitFailure,\n) => Promise<void> | void;\n\n/**\n * Read-only counterpart to describeDocumentSyncSubmitFailure: names a refused\n * revalidation without implying a blocked write. 403s never reach this — a\n * read-only 403 is deliberately suppressed (edge-case row 9) so unattempted\n * local edits are never flagged.\n */\nexport function describeDocumentRevalidationFailure(\n  failure: Pick<DocumentSyncSubmitFailure, \"message\" | \"status\">,\n): string {\n  const detail =\n    failure.message.trim().length > 0\n      ? failure.message.trim()\n      : \"the server refused the read\";\n  const suffix = failure.status === null ? \"\" : ` (${failure.status})`;\n  return `Remote revalidation failed: ${detail}${suffix}`;\n}\n\n/** Human-readable description of a terminal submit failure for queue display. */\nexport function describeDocumentSyncSubmitFailure(\n  failure: Pick<DocumentSyncSubmitFailure, \"message\" | \"status\">,\n): string {\n  if (failure.status === 403) {\n    return \"Write access denied by the server (403)\";\n  }\n  const message =\n    failure.message.trim().length > 0 ? failure.message.trim() : \"Sync failed\";\n  return failure.status === null ? message : `${message} (${failure.status})`;\n}\n\ntype ProjectionIntegrityErrorCode =\n  | \"equivocation\"\n  | \"rollback\"\n  | \"stale_predecessor\";\n\nfunction keyingVerificationErrorCode(error: unknown): string | null {\n  if (!isKeyingVerificationError(error) || !(error instanceof Error)) {\n    return null;\n  }\n  const code = Reflect.get(error, \"code\");\n  return typeof code === \"string\" ? code : null;\n}\n\nexport function projectionIntegrityErrorCode(\n  error: unknown,\n): ProjectionIntegrityErrorCode | null {\n  if (\n    !(error instanceof KeyingVerificationError) &&\n    !(error instanceof Error && error.name === \"KeyingVerificationError\")\n  ) {\n    return null;\n  }\n\n  const code = keyingVerificationErrorCode(error);\n  return code === \"rollback\" ||\n    code === \"equivocation\" ||\n    code === \"stale_predecessor\"\n    ? code\n    : null;\n}\n\n/**\n * Shared shell for the stale-projection retry classifiers. A cached\n * projection older than a checkpoint we already recorded (\"rollback\") —\n * typical right after a peer shared/rotated a linked container — is resolved\n * by refetching the current projection. The refetch is safe: it cannot\n * bypass the anti-rollback check, because a genuinely rolled-back server\n * response re-throws on the rebuilt plan. Any other keying-verification\n * failure is terminal; anything else defers to the caller's message\n * predicate for its unwrap-failure shape.\n */\nexport function shouldRetryWithFreshProjection(\n  error: unknown,\n  messageMatches: (message: string) => boolean,\n): boolean {\n  // A peer may already have repaired the chain. Refetch once; the same guard\n  // rejects a still-stale response before any new ciphertext is produced.\n  if (error instanceof ContainerKekRepairRequiredError) return true;\n  const integrityErrorCode = projectionIntegrityErrorCode(error);\n  if (integrityErrorCode) {\n    return integrityErrorCode === \"rollback\";\n  }\n  if (keyingVerificationErrorCode(error) === \"invalid_shape\") {\n    // Verification boundaries normalize malformed/stale projection data to a\n    // terminal error. One cache eviction is still safe: a dishonest or broken\n    // fresh response fails again outside this retry boundary.\n    return true;\n  }\n  if (isKeyingVerificationError(error)) {\n    return false;\n  }\n\n  return error instanceof Error && messageMatches(error.message);\n}\n\nexport function shouldRetrySyncWithFreshWriterProjection(\n  error: unknown,\n): boolean {\n  return shouldRetryWithFreshProjection(\n    error,\n    (message) =>\n      message.startsWith(\n        \"Document authorizing container KEK path could not be unwrapped\",\n      ) && message.includes(\"Container writer projection KEK\"),\n  );\n}\n\nexport function isRecoverableDocumentUpdateIdConflict(\n  failure: DocumentSyncSubmitFailure,\n): boolean {\n  return (\n    failure.status === 409 &&\n    failure.code === DOCUMENT_SYNC_ERROR_CODES.updateIdConflict\n  );\n}\n\n/**\n * The server's covering-baseline gate refused a queued rotation checkpoint\n * (e.g. a leftover from an interrupted recovery or a lost heal ack) because\n * it no longer covers the committed frontier. The pass can repair itself by\n * regenerating a fresh covering baseline from the live document instead of\n * resubmitting the stale payload — which would fail terminally forever.\n */\nexport function isCheckpointCoverageConflict(\n  failure: DocumentSyncSubmitFailure,\n): boolean {\n  return (\n    failure.status === 409 &&\n    failure.code === DOCUMENT_SYNC_ERROR_CODES.checkpointCoverageConflict\n  );\n}\n\n/**\n * A create submitted with a stable documentId whose first attempt already\n * committed server-side comes back as this 409 (see the server's\n * `assertCreateCanAdvanceDocumentHead`). It is not a failure — the caller adopts\n * the existing remote document instead of creating a duplicate.\n */\nexport function isDocumentManifestAlreadyExistsConflict(failure: {\n  readonly code?: string | undefined;\n  readonly message: string;\n  readonly status: number | null;\n}): boolean {\n  return (\n    failure.status === 409 &&\n    failure.code === DOCUMENT_MUTATION_ERROR_CODES.manifestAlreadyExists\n  );\n}\n\nexport function canRetryDocumentSyncConflict(input: {\n  attempt: number;\n  failure: DocumentSyncSubmitFailure;\n  maxAttempts: number;\n}): boolean {\n  return (\n    input.attempt < input.maxAttempts &&\n    isRetryableDocumentSyncConflict(input.failure)\n  );\n}\n\nexport function canRecoverDocumentUpdateIdConflict(input: {\n  attempt: number;\n  failure: DocumentSyncSubmitFailure;\n  maxAttempts: number;\n  pendingUpdateCount: number;\n}): boolean {\n  return (\n    input.attempt < input.maxAttempts &&\n    input.pendingUpdateCount > 0 &&\n    isRecoverableDocumentUpdateIdConflict(input.failure)\n  );\n}\n\nexport async function handleUpstreamDeletedDocumentSyncFailure(input: {\n  documentId: string;\n  failure: DocumentSyncSubmitFailure;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n}): Promise<boolean> {\n  if (!isUpstreamDeletedDocumentSyncFailure(input.failure)) {\n    return false;\n  }\n\n  await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });\n  return true;\n}\n"]}

package/workflows/documents/syncFailureClearance.d.ts

@@ -0,0 +1,17 @@
+interface SyncFailureClearancePass {
+    readonly exhaustedPendingUpdateCount: number;
+    readonly plan: {
+        readonly request: {
+            readonly pullCursor?: string | undefined;
+        };
+    };
+}
+/**
+ * A cursor continuation intentionally defers every queued write. Its success
+ * therefore cannot clear a terminal failure recorded by an earlier
+ * write-bearing pass. A continuation with no queued writes can still clear a
+ * read-only revalidation failure, and a later write-bearing pass can clear
+ * the failure once it has no exhausted updates.
+ */
+export declare function shouldClearDocumentSyncFailureAfterPass(pass: SyncFailureClearancePass, outgoingUpdateCount: number): boolean;
+export {};

package/workflows/documents/syncFailureClearance.js

@@ -0,0 +1,12 @@
+/**
+ * A cursor continuation intentionally defers every queued write. Its success
+ * therefore cannot clear a terminal failure recorded by an earlier
+ * write-bearing pass. A continuation with no queued writes can still clear a
+ * read-only revalidation failure, and a later write-bearing pass can clear
+ * the failure once it has no exhausted updates.
+ */
+export function shouldClearDocumentSyncFailureAfterPass(pass, outgoingUpdateCount) {
+    return (pass.exhaustedPendingUpdateCount === 0 &&
+        (pass.plan.request.pullCursor === undefined || outgoingUpdateCount === 0));
+}
+//# sourceMappingURL=syncFailureClearance.js.map

package/workflows/documents/syncFailureClearance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncFailureClearance.js","sourceRoot":"","sources":["syncFailureClearance.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,UAAU,uCAAuC,CACrD,IAA8B,EAC9B,mBAA2B;IAE3B,OAAO,CACL,IAAI,CAAC,2BAA2B,KAAK,CAAC;QACtC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,mBAAmB,KAAK,CAAC,CAAC,CAC1E,CAAC;AACJ,CAAC","sourcesContent":["interface SyncFailureClearancePass {\n  readonly exhaustedPendingUpdateCount: number;\n  readonly plan: {\n    readonly request: { readonly pullCursor?: string | undefined };\n  };\n}\n\n/**\n * A cursor continuation intentionally defers every queued write. Its success\n * therefore cannot clear a terminal failure recorded by an earlier\n * write-bearing pass. A continuation with no queued writes can still clear a\n * read-only revalidation failure, and a later write-bearing pass can clear\n * the failure once it has no exhausted updates.\n */\nexport function shouldClearDocumentSyncFailureAfterPass(\n  pass: SyncFailureClearancePass,\n  outgoingUpdateCount: number,\n): boolean {\n  return (\n    pass.exhaustedPendingUpdateCount === 0 &&\n    (pass.plan.request.pullCursor === undefined || outgoingUpdateCount === 0)\n  );\n}\n"]}