@mdbase-dev/connect 0.1.0-beta.111 → 0.1.0-beta.113

package/dist/browser/mdbase-connect.min.js.sha384

@@ -1 +1 @@
-sha384-/62JQssTDGRQGVQwcO5KLWO7BOqrDVxB0ne307QlEFVO3/MzYMBJfjmbz/OdCRWP
+sha384-uKL9FxAY8Ji2mQSA44JTIIarA2CnPGN3EFC4jxk1Kx+OfDsPbFr2J+iwlH/p77Qz

package/dist/connection-transport.d.ts

@@ -34,6 +34,8 @@ export declare class ConnectionTransport {
     disableDirectAccess(): void;
     /** Return pending writes without exposing authority transport credentials. */
     pendingMutations(): readonly PendingMutationSummary[];
+    /** The request ID of an interrupted update to one record, if any. */
+    pendingUpdate(path: string): Promise<string | null>;
     pendingMutation(requestId: string): PendingMutationSummary | null;
     recoverPendingMutation<Result>(requestId: string, options?: ConnectRequestOptions): Promise<Result>;
     performOperation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<Result>;

package/dist/connection-transport.js

@@ -1,3 +1,4 @@
+import { interruptedUpdate, updatedRecordDigest } from "./record-digest.js";
 import { OPERATION_TRANSPORT_PROTOCOL_VERSION, isConnectProblem, mutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
 import { decryptRelayResponse, encryptRelayRequest, RelayCryptoError } from "./crypto.js";
 import { MdbaseConnectError, connectError, serverConnectError } from "./errors.js";
@@ -108,23 +109,16 @@ export class ConnectionTransport {
     }
     /** Return pending writes without exposing authority transport credentials. */
     pendingMutations() {
-        return this.storedPendingMutations().map((pending) => ({
-            requestId: pending.requestId,
-            operation: this.pendingMutationStore.identifier(pending),
-            fingerprint: pending.inputFingerprint,
-            status: "outcome_unknown",
-            createdAt: new Date(pending.createdAt).toISOString()
-        }));
+        return this.storedPendingMutations().map((pending) => this.pendingMutationStore.summary(pending));
+    }
+    /** The request ID of an interrupted update to one record, if any. */
+    async pendingUpdate(path) {
+        const collectionId = this.currentToken()?.collectionId;
+        return collectionId ? interruptedUpdate(this.storedPendingMutations(), collectionId, path) : null;
     }
     pendingMutation(requestId) {
         const pending = this.storedPendingMutation(requestId);
-        return pending ? {
-            requestId: pending.requestId,
-            operation: this.pendingMutationStore.identifier(pending),
-            fingerprint: pending.inputFingerprint,
-            status: "outcome_unknown",
-            createdAt: new Date(pending.createdAt).toISOString()
-        } : null;
+        return pending ? this.pendingMutationStore.summary(pending) : null;
     }
     async recoverPendingMutation(requestId, options) {
         const pending = this.storedPendingMutation(requestId);
@@ -372,10 +366,13 @@ export class ConnectionTransport {
         let requestId = pendingRequestId ?? crypto.randomUUID();
         let pending = null;
         let inputFingerprint;
+        let updatedRecord;
         if (pendingRequestId !== undefined) {
             pending = this.storedPendingMutation(pendingRequestId);
             inputFingerprint = pending?.inputFingerprint
                 ?? await operationFingerprint(operation, input);
+            if (!pending)
+                updatedRecord = await updatedRecordDigest(token.collectionId, operation, input);
             if (pending) {
                 if (pending.collectionId !== token.collectionId
                     || pending.operation !== operation
@@ -420,6 +417,7 @@ export class ConnectionTransport {
                             operation,
                             mutation: mutation,
                             inputFingerprint: inputFingerprint,
+                            ...(updatedRecord ? { recordDigest: updatedRecord } : {}),
                             requestId,
                             envelope: encryptedRequest,
                             createdAt: Date.now()
@@ -452,6 +450,7 @@ export class ConnectionTransport {
                     operation,
                     mutation: mutation,
                     inputFingerprint: inputFingerprint,
+                    ...(updatedRecord ? { recordDigest: updatedRecord } : {}),
                     requestId,
                     request,
                     createdAt: Date.now()

package/dist/connection.d.ts

@@ -4,6 +4,7 @@ import { type ConnectionTransportInternals } from "./connection-transport.js";
 import type { DirectAccessStatus, MdbaseAuthorizationCapabilities, MdbaseConnectionInfo, MdbaseConnectionRoute, MdbaseSyncConnection } from "./connection-types.js";
 import type { GrantKeyStore } from "./crypto.js";
 import { MdbaseFileClient } from "./files.js";
+import { MdbaseRecords } from "./records.js";
 import { type Application } from "./internal-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
 import type { ChangesInput, CollectionChangesPage, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, ApplyCollectionSetupInput, ApplyTypePackInput, AssessCollectionSetupInput, AssessTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, PendingMutation, QueryAllOptions, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.js";
@@ -74,6 +75,8 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     private readonly notifications;
     private readonly transport;
     readonly files: MdbaseFileClient;
+    /** Editable record sessions shared by every view of this connection. */
+    readonly records: MdbaseRecords<Frontmatter>;
     private readonly connectionListeners;
     constructor(internals: MdbaseConnectionInternals<Frontmatter>, collectionId: string);
     get displayName(): string;

package/dist/connection.js

@@ -5,6 +5,7 @@ import { ConnectionNotifications } from "./connection-notifications.js";
 import { ConnectionTransport } from "./connection-transport.js";
 import { MdbaseConnectError, connectProblem, operationProblem } from "./errors.js";
 import { MdbaseFileClient } from "./files.js";
+import { MdbaseRecords } from "./records.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { assertDeletePreview, assertRenamePreview, deleteEstimate, isCancellation, renameEstimate, throwIfCancelled, uniqueOperations } from "./operation-helpers.js";
 import { AUTHORIZATION_PROBLEM_CODES, COLLECTION_CHANGES_PROBLEM_CODES, COLLECTION_MUTATION_PROBLEM_CODES, DIRECT_ACCESS_PROBLEM_CODES, NOTIFICATION_PROBLEM_CODES, REGISTRATION_PROBLEM_CODES, captureConnectOutcome, connectFailure, connectSuccess } from "./outcomes.js";
@@ -17,6 +18,8 @@ export class MdbaseConnection {
     notifications;
     transport;
     files;
+    /** Editable record sessions shared by every view of this connection. */
+    records;
     connectionListeners = new Set();
     constructor(internals, collectionId) {
         this.internals = internals;
@@ -38,6 +41,7 @@ export class MdbaseConnection {
         }, {
             downloadPart: (session, partIndex, expectedLength, signal) => this.transport.files.downloadHostedPart(session, partIndex, expectedLength, signal)
         }, internals.timeouts);
+        this.records = new MdbaseRecords(this, (path) => this.transport.pendingUpdate(path));
         this.collectionClient = new MdbaseCollectionClient(new CollectionRequestCoordinator({
             operation: (operation, input, requestOptions) => this.transport.performOperation(operation, input, requestOptions)
         }, internals.timeouts.requestMs), internals.timeouts.requestMs);

package/dist/crypto.js

@@ -1,4 +1,5 @@
 import { OPERATION_TRANSPORT_PROTOCOL_VERSION, GRANT_ENCRYPTION_PROTOCOL_VERSION, AUTHORITY_PROOF_DOMAIN, AUTHORITY_PROOF_HEADERS, AUTHORITY_PROOF_VERSION, RELAY_ENCRYPTION_SUITE, isConnectProblem } from "@mdbase-dev/connect-protocol";
+import { base64UrlBytes, bytesToBase64Url } from "./base64.js";
 const DATABASE_NAME = "mdbase-connect-keys";
 const STORE_NAME = "grant-keys";
 const MAX_U64 = 18446744073709551615n;
@@ -206,7 +207,7 @@ export async function decryptRelayResponse(store, handle, binding, request, resp
             iv: nonce(request.counter),
             additionalData: new TextEncoder().encode(aad(metadata, "response")),
             tagLength: 128
-        }, key, toArrayBuffer(base64UrlToBytes(response.ciphertext)));
+        }, key, base64UrlToBytes(response.ciphertext));
         const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
         if (value?.ok === true && "result" in value)
             return value;
@@ -364,12 +365,6 @@ function nonce(counter) {
     view.setBigUint64(4, value, false);
     return result;
 }
-function bytesToBase64Url(bytes) {
-    let binary = "";
-    for (const byte of bytes)
-        binary += String.fromCharCode(byte);
-    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
 async function sha256Base64Url(value) {
     const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
     return bytesToBase64Url(new Uint8Array(digest));
@@ -377,9 +372,7 @@ async function sha256Base64Url(value) {
 function base64UrlToBytes(value) {
     if (!/^[A-Za-z0-9_-]+$/.test(value))
         throw new RelayCryptoError("invalid_base64", "Encrypted relay data is malformed.");
-    const padding = "=".repeat((4 - value.length % 4) % 4);
-    const binary = atob(value.replaceAll("-", "+").replaceAll("_", "/") + padding);
-    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return base64UrlBytes(value);
 }
 function p256PublicKey(value) {
     const bytes = base64UrlToBytes(value);

package/dist/errors.d.ts

@@ -39,7 +39,7 @@ export declare function serverConnectError(serverCode: string, message: string,
     status?: number;
     cause?: unknown;
 }): MdbaseConnectError;
-export declare function operationProblem<Result>(envelope: MdbaseOperationEnvelope<Result>): KnownConnectProblem<"collection_configuration_invalid" | "collection_invalid" | "collection_type_registry_invalid" | "collection_version_unsupported" | "operation_invalid">;
+export declare function operationProblem<Result>(envelope: MdbaseOperationEnvelope<Result>): KnownConnectProblem<"collection_configuration_invalid" | "collection_invalid" | "collection_type_registry_invalid" | "collection_version_unsupported" | "concurrent_modification" | "file_not_found" | "invalid_path" | "operation_invalid">;
 /** True only when repeating an operation is safe without asking the user. */
 export declare function isRetryableConnectError(error: unknown): boolean;
 export {};

package/dist/errors.js

@@ -68,6 +68,11 @@ export function serverConnectError(serverCode, message, options = {}) {
 export function operationProblem(envelope) {
     const code = diagnosticProblemCode(envelope.diagnostics);
     const message = diagnosticMessage(envelope.diagnostics);
+    // mdbase reports these record conditions as diagnostics; hosted authorities
+    // report them as problems. Surface one code for both.
+    if (code === "concurrent_modification" || code === "file_not_found" || code === "invalid_path") {
+        return connectProblem(code, message, { operationOutcome: "rejected" });
+    }
     if (code === "collection_version_unsupported") {
         const versions = diagnosticVersions(envelope.diagnostics);
         return connectProblem(code, message, {
@@ -110,6 +115,10 @@ function diagnosticProblemCode(diagnostics) {
     if (["collection_invalid", "collection_open_failed"]
         .some((code) => codes.has(code)))
         return "collection_invalid";
+    for (const code of ["concurrent_modification", "file_not_found", "invalid_path"]) {
+        if (codes.has(code))
+            return code;
+    }
     return "operation_invalid";
 }
 function diagnosticVersions(diagnostics) {

package/dist/index.d.ts

@@ -11,6 +11,10 @@ export type { MdbaseCapabilityState, MdbaseCapabilityEvidence, MdbaseEffectiveCa
 export { MdbaseConnectError, isRetryableConnectError } from "./errors.js";
 export type { ConnectErrorContext } from "./errors.js";
 export { MdbaseFileClient } from "./files.js";
+export { MdbaseRecords } from "./records.js";
+export type { MdbaseRecordLease, MdbaseRecordOpenOptions } from "./records.js";
+export { MdbaseRecordSession } from "./record-session.js";
+export type { MdbaseRecordResolution, MdbaseRecordSessionOptions, MdbaseRecordSessionSnapshot, MdbaseRecordSessionState } from "./record-session.js";
 export type { MdbaseFileSource, CollectionFileDescriptor, MdbaseFileDeleteReceipt, MdbaseFileStreamSource, MdbaseFileProgress, MdbaseFileListOptions, MdbaseFileUploadOptions, MdbaseFileStreamUploadOptions, MdbaseFileDownloadOptions, MdbaseFileMoveOptions, MdbaseFileDeleteOptions } from "./files.js";
 export { parseMdbasePushPayload, parseMdbaseNativeNotificationData, showMdbasePushNotification } from "./notifications.js";
 export type { MdbaseNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNativeNotificationRegistration, MdbaseNativeNotificationData, MdbasePushPayload } from "./notifications.js";

package/dist/index.js

@@ -4,6 +4,8 @@ export { MdbaseConnection } from "./connection.js";
 export { effectiveCapabilities } from "./capabilities.js";
 export { MdbaseConnectError, isRetryableConnectError } from "./errors.js";
 export { MdbaseFileClient } from "./files.js";
+export { MdbaseRecords } from "./records.js";
+export { MdbaseRecordSession } from "./record-session.js";
 export { parseMdbasePushPayload, parseMdbaseNativeNotificationData, showMdbasePushNotification } from "./notifications.js";
 export { externalStore } from "./external-store.js";
 export { MdbaseBrowserSelection, MdbaseMemorySelection } from "./selection.js";

package/dist/internal-types.d.ts

@@ -82,6 +82,8 @@ export interface PendingMutation {
     operation: CollectionOperation;
     mutation?: MutationOperationIdentifier;
     inputFingerprint: string;
+    /** `recordDigest(collectionId, path)` of an update's record, never the path itself. */
+    recordDigest?: string;
     requestId: string;
     envelope?: EncryptedRelayOperationRequest;
     /** Exact plaintext protocol request for transports that do not use a grant envelope. */

package/dist/outcomes.d.ts

@@ -28,18 +28,18 @@ export type SessionProblemCode = AuthorizationProblemCode | "collection_not_read
 export declare const SESSION_PROBLEM_CODES: readonly ["discovery_failed", "invalid_operation_response", "invalid_application_manifest", "invalid_request", "manifest_load_failed", "rate_limited", "temporarily_unavailable", "timeout", "access_denied", "application_declaration_mismatch", "application_identity_unavailable", "approval_window_blocked", "authorization_binding_incompatible", "authorization_cancelled", "authorization_replayed", "browser_required", "capability_contract_incompatible", "collection_access_denied", "collection_configuration_invalid", "collection_contracts_missing", "collection_incompatible", "collection_invalid", "collection_kind_unsupported", "collection_mismatch", "collection_not_found", "collection_type_registry_invalid", "collection_version_unsupported", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "device_authorization_failed", "durable_mutation_unsupported", "encryption_required", "expired_token", "invalid_application_authorization", "invalid_callback", "invalid_device_authorization_response", "invalid_token_response", "legacy_scope_reauthorization_required", "scope_denied", "reconnect_required", "token_exchange_failed", "transport_protocol_incompatible", "collection_not_ready", "collection_not_selected", "operation_cancelled", "session_destroyed", "session_not_started", "session_starting", "unknown_collection"];
 export type CollectionSetupProblemCode = "collection_configuration_invalid" | "collection_invalid" | "collection_type_registry_invalid" | "collection_version_unsupported";
 export type CollectionDescriptionProblemCode = CommonOperationProblemCode | CollectionSetupProblemCode;
-export type CollectionReadProblemCode = CollectionDescriptionProblemCode | "invalid_path" | "operation_invalid";
+export type CollectionReadProblemCode = CollectionDescriptionProblemCode | "file_not_found" | "invalid_path" | "operation_invalid";
 export type CollectionQueryProblemCode = CollectionReadProblemCode | "cursor_capacity_exhausted" | "generation_expired" | "invalid_read_cursor" | "query_snapshot_changed" | "sandbox_unsupported";
 export type CollectionMutationProblemCode = CollectionReadProblemCode | "concurrent_modification" | "invalid_preflight" | "pending_mutation_unresolved";
 export type CollectionChangesProblemCode = CollectionDescriptionProblemCode | "change_cursor_reset";
 export type CollectionTypeProblemCode = CollectionMutationProblemCode | "type_pack_provision_failed";
 export declare const COLLECTION_SETUP_PROBLEM_CODES: readonly ["collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported"];
 export declare const COLLECTION_DESCRIPTION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported"];
-export declare const COLLECTION_READ_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid"];
-export declare const COLLECTION_QUERY_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "cursor_capacity_exhausted", "generation_expired", "invalid_read_cursor", "query_snapshot_changed", "sandbox_unsupported"];
-export declare const COLLECTION_MUTATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved"];
+export declare const COLLECTION_READ_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "file_not_found", "invalid_path", "operation_invalid"];
+export declare const COLLECTION_QUERY_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "file_not_found", "invalid_path", "operation_invalid", "cursor_capacity_exhausted", "generation_expired", "invalid_read_cursor", "query_snapshot_changed", "sandbox_unsupported"];
+export declare const COLLECTION_MUTATION_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "file_not_found", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved"];
 export declare const COLLECTION_CHANGES_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "change_cursor_reset"];
-export declare const COLLECTION_TYPE_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved", "type_pack_provision_failed"];
+export declare const COLLECTION_TYPE_PROBLEM_CODES: readonly ["access_denied", "access_paused", "application_declaration_mismatch", "authorization_binding_incompatible", "authorization_expired", "capability_contract_incompatible", "collection_access_denied", "connector_identity_changed", "connector_offline", "connector_upgrade_required", "direct_operation_rejected", "durable_mutation_unsupported", "operation_outcome_unknown", "encryption_required", "encrypted_relay_rejected", "hosted_provider_unavailable", "insufficient_access", "invalid_encrypted_response", "invalid_operation_response", "invalid_request", "missing_grant_key", "mutation_recovery_expired", "mutation_request_conflict", "not_authorized", "operation_cancelled", "operation_failed", "rate_limited", "relay_authorization_expired", "relay_unavailable", "temporarily_unavailable", "timeout", "transport_protocol_incompatible", "unsupported_operation", "collection_configuration_invalid", "collection_invalid", "collection_type_registry_invalid", "collection_version_unsupported", "file_not_found", "invalid_path", "operation_invalid", "concurrent_modification", "invalid_preflight", "pending_mutation_unresolved", "type_pack_provision_failed"];
 export declare function connectSuccess<Value>(value: Value, diagnostics?: MdbaseDiagnostic[]): ConnectSuccess<Value>;
 export declare function connectFailure<Code extends ConnectProblemCode>(problem: ConnectProblem<Code>): ConnectFailure<Code>;
 export declare function captureConnectOutcome<Value, Code extends ConnectProblemCode>(operation: () => Promise<Value>, allowedCodes: readonly Code[]): Promise<ConnectOutcome<Value, Code>>;

package/dist/outcomes.js

@@ -129,6 +129,7 @@ export const COLLECTION_DESCRIPTION_PROBLEM_CODES = [
 ];
 export const COLLECTION_READ_PROBLEM_CODES = [
     ...COLLECTION_DESCRIPTION_PROBLEM_CODES,
+    "file_not_found",
     "invalid_path",
     "operation_invalid"
 ];

package/dist/pending-mutation-store.d.ts

@@ -1,5 +1,6 @@
 import { type MutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
 import type { PendingMutation } from "./internal-types.js";
+import type { PendingMutationSummary } from "./operation-types.js";
 export declare class PendingMutationStore {
     private readonly storage;
     private readonly baseKey;
@@ -7,6 +8,8 @@ export declare class PendingMutationStore {
     list(collectionId: string | null): PendingMutation[];
     find(collectionId: string | null, requestId: string): PendingMutation | null;
     identifier(pending: PendingMutation): MutationOperationIdentifier;
+    /** A pending write without its authority transport credentials. */
+    summary(pending: PendingMutation): PendingMutationSummary;
     store(pending: PendingMutation): void;
     take(requestId: string): PendingMutation | null;
     private key;

package/dist/pending-mutation-store.js

@@ -37,6 +37,16 @@ export class PendingMutationStore {
     identifier(pending) {
         return pending.mutation ?? mutationOperationIdentifier(pending.operation, pending.request?.input ?? (pending.operation === "sync" ? { action: "mutate" } : {})) ?? (pending.operation === "sync" ? "sync:mutate" : pending.operation);
     }
+    /** A pending write without its authority transport credentials. */
+    summary(pending) {
+        return {
+            requestId: pending.requestId,
+            operation: this.identifier(pending),
+            fingerprint: pending.inputFingerprint,
+            status: "outcome_unknown",
+            createdAt: new Date(pending.createdAt).toISOString()
+        };
+    }
     store(pending) {
         this.storage.setItem(this.key(pending.requestId), JSON.stringify(pending));
     }

package/dist/record-digest.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An equality token for one record in one collection. Stored with a pending
+ * update so an editing session can find its own interrupted write after a
+ * reload without the record path ever being persisted.
+ */
+export declare function recordDigest(collectionId: string, path: string): Promise<string>;
+/** The digest a new pending mutation stores: only updates name a record. */
+export declare function updatedRecordDigest(collectionId: string, operation: string, input: unknown): Promise<string | undefined>;
+/** The request ID of a stored interrupted update to one record, if any. */
+export declare function interruptedUpdate(pending: readonly {
+    operation: string;
+    requestId: string;
+    recordDigest?: string;
+}[], collectionId: string, path: string): Promise<string | null>;

package/dist/record-digest.js

@@ -0,0 +1,20 @@
+/**
+ * An equality token for one record in one collection. Stored with a pending
+ * update so an editing session can find its own interrupted write after a
+ * reload without the record path ever being persisted.
+ */
+export async function recordDigest(collectionId, path) {
+    const bytes = new TextEncoder().encode(`${collectionId}\n${path}`);
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes));
+    return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** The digest a new pending mutation stores: only updates name a record. */
+export async function updatedRecordDigest(collectionId, operation, input) {
+    const path = input?.path;
+    return operation === "update" && typeof path === "string" ? recordDigest(collectionId, path) : undefined;
+}
+/** The request ID of a stored interrupted update to one record, if any. */
+export async function interruptedUpdate(pending, collectionId, path) {
+    const digest = await recordDigest(collectionId, path);
+    return pending.find((entry) => entry.operation === "update" && entry.recordDigest === digest)?.requestId ?? null;
+}

package/dist/record-session.d.ts

@@ -0,0 +1,164 @@
+import type { ConnectProblem, JsonObject } from "@mdbase-dev/connect-protocol";
+import type { ConnectRequestOptions } from "./operation-types.js";
+import { type ConnectOutcome } from "./outcomes.js";
+/**
+ * - `saved`: the draft is the acknowledged record.
+ * - `unsaved`: local changes wait for autosave, `save()` or `flush()`.
+ * - `saving`: a write or exact recovery is in flight.
+ * - `conflict`: a newer record changed what was edited locally; see `remote`.
+ * - `recovery`: a write's outcome is unknown; no new write is sent until it is recovered.
+ * - `error`: the last write failed; local changes are kept.
+ * - `deleted`: the record no longer exists; local changes are kept.
+ */
+export type MdbaseRecordSessionState = "saved" | "unsaved" | "saving" | "conflict" | "recovery" | "error" | "deleted";
+/** The parts of a record a session writes. Only locally changed parts are present. */
+export interface MdbaseRecordChange {
+    body?: string;
+    patch?: JsonObject;
+}
+/**
+ * How a session reads and writes one record. `R` is the application's record
+ * value; the session reads it only through these accessors. Every expected
+ * failure is a `ConnectOutcome` failure; an adapter that throws has a bug.
+ */
+export interface MdbaseRecordSessionAdapter<R> {
+    revision(record: R): string;
+    body(record: R): string;
+    frontmatter?(record: R): JsonObject;
+    /** Apply `change` to the record at `base`'s revision, or fail without writing. */
+    write(base: R, change: MdbaseRecordChange, options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /** The current record. A `file_not_found` failure means it was deleted. */
+    read?(base: R, options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /** Exact continuation of a write whose outcome is unknown. Never a new write. */
+    recover?(requestId: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /** Whether that write's durable pending mutation is still unsettled. */
+    isPending?(requestId: string): boolean;
+}
+export interface MdbaseRecordSessionOptions {
+    /** Write after this much idle time following an edit. Default `{ idleMs: 1000 }`. */
+    autosave?: {
+        idleMs: number;
+    } | false;
+}
+export interface MdbaseRecordSessionSnapshot<R> {
+    readonly state: MdbaseRecordSessionState;
+    readonly body: string;
+    /** The record's frontmatter with local patches applied. */
+    readonly frontmatter: JsonObject;
+    /** The latest record this session has accepted as its base. */
+    readonly record: R;
+    /** The newer record that conflicts with local changes, while `state` is `conflict`. */
+    readonly remote: R | null;
+    /** Local changes not yet acknowledged, including a write in flight or awaiting recovery. */
+    readonly dirty: boolean;
+    /** Why the last write or recovery failed. */
+    readonly problem: ConnectProblem | null;
+    /** The interrupted write's request ID, while `state` is `recovery`. */
+    readonly pendingRequestId?: string;
+}
+export type MdbaseRecordResolution = {
+    keep: "mine" | "theirs";
+} | {
+    body: string;
+};
+/**
+ * One open, editable record: debounced autosave, one write queue, own
+ * acknowledgements recognized by revision after each write settles,
+ * field-level conflict detection, and exact recovery of writes whose outcome
+ * is unknown. Share one session between every view of the same record.
+ */
+export declare class MdbaseRecordSession<R> {
+    private readonly adapter;
+    private record;
+    /** The local text `record` acknowledges; it differs from the record's body after server normalization. */
+    private baseBody;
+    private body;
+    private patch;
+    private remote;
+    private problem;
+    private deleted;
+    private busy;
+    private pending;
+    private incoming;
+    private readonly seen;
+    private readonly listeners;
+    private tail;
+    private queued;
+    private inFlight;
+    private timer;
+    private lastEdit;
+    private readonly idleMs;
+    private current;
+    constructor(record: R, adapter: MdbaseRecordSessionAdapter<R>, options?: MdbaseRecordSessionOptions);
+    get snapshot(): MdbaseRecordSessionSnapshot<R>;
+    getSnapshot: () => MdbaseRecordSessionSnapshot<R>;
+    /** Listeners run synchronously after every change, including each edit. */
+    subscribe: (listener: () => void) => (() => void);
+    setBody(body: string): void;
+    patchFrontmatter(patch: JsonObject): void;
+    /**
+     * Offer a draft kept outside the session, such as a crash-recovery copy. It
+     * is never written by itself: call `autosave()` or `save()`. A draft whose
+     * base is unknown or has since changed is a conflict with the current record.
+     */
+    restore(draft: {
+        body: string;
+        baseBody?: string;
+    }): void;
+    /**
+     * Continue a write interrupted before this session existed, such as one
+     * found in durable storage after a reload. No new write is sent until it
+     * settles; with autosave, recovery is attempted after one idle interval.
+     */
+    resumeRecovery(requestId: string): void;
+    /** Schedule an autosave one idle interval from now. */
+    autosave(): void;
+    /**
+     * A record published by another view or cache. It may be stale, so a
+     * revision this session has already seen is ignored, and records arriving
+     * while a write is unsettled wait until that write's acknowledgement is known.
+     */
+    receive(record: R): void;
+    /**
+     * Read the current record after any queued write and apply it. Unlike a
+     * publication this is never stale, so a revision seen before is still
+     * applied (revisions repeat when content is reverted).
+     */
+    refresh(options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /**
+     * Accept a record this application produced outside the session's writes,
+     * such as a rename's result. It is never a conflict: local changes made
+     * meanwhile are kept on top of it.
+     */
+    accept(record: R): void;
+    markDeleted(): void;
+    /**
+     * Write local changes now, or continue an interrupted write's exact
+     * recovery. Joins a save already in flight. Resolves with the accepted record.
+     */
+    save(options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /** Save until every local change is acknowledged, or report why it cannot be. */
+    flush(options?: ConnectRequestOptions): Promise<ConnectOutcome<R>>;
+    /** Run another operation on this record (rename, delete, …) in the session's write queue. */
+    run<Result>(operation: () => Promise<Result>): Promise<Result>;
+    /** Settle a conflict: keep local changes on top of the remote record, take the remote record, or use merged text. */
+    resolve(choice: MdbaseRecordResolution): void;
+    /** Drop local changes and return to the latest record. */
+    discard(): void;
+    private edited;
+    private schedule;
+    private dirtyLocally;
+    private write;
+    private recoverPending;
+    /** An adapter that throws breaks its contract: rethrow, but leave the queue usable. */
+    private guard;
+    private failure;
+    private acknowledge;
+    /** Read once to learn whether a failed write met a conflict, a convergent edit or deletion. */
+    private classifyFailure;
+    private settle;
+    /** Field-level three-way comparison of a newer record with the base and local changes. */
+    private classify;
+    private compute;
+    private emit;
+}