@mdbase-dev/connect 0.1.0-beta.32 → 0.1.0-beta.34

package/dist/connect-authorization-helpers.js

@@ -0,0 +1,13 @@
+import { MdbaseConnectError, connectError } from "./errors.js";
+export function declarationIdFromFamilyIdentity(familyIdentity) {
+    const prefix = "bundle:";
+    if (!familyIdentity.startsWith(prefix) || familyIdentity.length === prefix.length) {
+        throw new Error("The registered application has no valid declaration identity.");
+    }
+    return familyIdentity.slice(prefix.length);
+}
+export function authorizationAbort(signal, message, cause) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("authorization_cancelled", message, { cause });
+}

package/dist/connect.js

@@ -3,8 +3,9 @@ import { abortableDelay } from "./async.js";
 import { randomBase64Url } from "./base64.js";
 import { ApplicationIdentityStoreError, IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, applicationIdentity, applicationInstallationId, signApplicationAuthorization } from "./application-identity.js";
 import { MdbaseConnection } from "./connection.js";
+import { authorizationAbort, declarationIdFromFamilyIdentity } from "./connect-authorization-helpers.js";
 import { IndexedDbGrantKeyStore, MemoryGrantKeyStore } from "./crypto.js";
-import { MdbaseConnectError, connectError, serverConnectError } from "./errors.js";
+import { connectError, serverConnectError } from "./errors.js";
 import { DEFAULT_OPERATIONS } from "./internal-types.js";
 import { uniqueOperations } from "./operation-helpers.js";
 import { resolveConnectTimeouts, withRequestBudget } from "./request-budget.js";
@@ -197,6 +198,7 @@ export class MdbaseConnectInternals {
             protocol_version: APPLICATION_AUTHORIZATION_PROTOCOL_VERSION,
             authorization_id: authorizationId,
             application_id: application.id,
+            application_declaration_id: declarationIdFromFamilyIdentity(application.family_identity),
             application_manifest_digest: application.manifest_digest,
             application_installation_id: await applicationInstallationId(installation),
             installation_signing_public_key: installation.signingPublicKey,
@@ -299,6 +301,7 @@ export class MdbaseConnectInternals {
             protocol_version: APPLICATION_AUTHORIZATION_PROTOCOL_VERSION,
             authorization_id: authorizationId,
             application_id: application.id,
+            application_declaration_id: declarationIdFromFamilyIdentity(application.family_identity),
             application_manifest_digest: application.manifest_digest,
             application_installation_id: await applicationInstallationId(installation),
             installation_signing_public_key: installation.signingPublicKey,
@@ -714,8 +717,3 @@ export class MdbaseConnectInternals {
             listener(connections);
     }
 }
-function authorizationAbort(signal, message, cause) {
-    if (signal.reason instanceof MdbaseConnectError)
-        return signal.reason;
-    return connectError("authorization_cancelled", message, { cause });
-}

package/dist/connection.d.ts

@@ -1,11 +1,11 @@
-import type { CollectionChangesPage, CollectionDescription, CollectionOperation, CollectionTypeDocument, CreateViewSourceInput, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, FileCapability, GrantScope, JsonObject, ReadViewSourceInput, RecordDocument, SavedViewExecution, SavedViewList, SavedViewSourceDocument, ApplyTypePackInput, AssessTypePackInput, TypePackApplyResult, TypePackAssessment, UpdateViewSourceInput } from "@mdbase-dev/connect-protocol";
+import type { CollectionOperation, CollectionTypeDocument, FileCapability, GrantScope, JsonObject } from "@mdbase-dev/connect-protocol";
 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 { type Application } from "./internal-types.js";
 import type { MdbaseNativeNotificationRegistration, MdbaseNativeNotificationRegistrationOptions, MdbaseNotificationRegistration, MdbaseNotificationRegistrationOptions } from "./notifications.js";
-import type { ChangesInput, CreateInput, CreateTypeInput, DeleteInput, DeletePreflightResult, DeleteProgressOptions, DeleteResult, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, PendingMutation, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, RenameInput, RenamePreflightResult, RenameProgressOptions, RenameResult, UpdateInput, UpdateTypeInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.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, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, MdbaseWatchSubscription, WatchInput } from "./operation-types.js";
 import { type AuthorizationProblemCode, type CollectionChangesProblemCode, type CollectionDescriptionProblemCode, type CollectionMutationProblemCode, type CollectionQueryProblemCode, type CollectionReadProblemCode, type CollectionTypeProblemCode, type ConnectOutcome, type DirectAccessProblemCode, type NotificationProblemCode, type RegistrationProblemCode } from "./outcomes.js";
 import type { MdbaseDeviceAuthorization } from "./authorization-types.js";
 import { type ResolvedConnectTimeouts } from "./request-budget.js";
@@ -109,7 +109,7 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     read(input: ReadInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
     query(input?: QueryInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
     queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<QueryPage<Frontmatter>, CollectionQueryProblemCode>>;
-    queryAll(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    queryAll(input?: QueryInput, options?: QueryAllOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
     listViews(options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
     executeView(input: ExecuteViewInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;
     readViewSource(input: ReadViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionReadProblemCode>>;
@@ -133,10 +133,12 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     updateType(input: UpdateTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
     assessTypePack(input: AssessTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackAssessment, CollectionTypeProblemCode>>;
     applyTypePack(input: ApplyTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackApplyResult, CollectionTypeProblemCode>>;
+    assessCollectionSetup(input: AssessCollectionSetupInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionSetupAssessment, CollectionTypeProblemCode>>;
+    applyCollectionSetup(input: ApplyCollectionSetupInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionSetupApplyResult, CollectionTypeProblemCode>>;
     listTimers(namespace: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerList, CollectionReadProblemCode>>;
     putTimer(input: {
         namespace: string;
-        criterion_id: string;
+        criterionId: string;
         timer: MdbaseDesiredTimer;
     }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimer, CollectionMutationProblemCode>>;
     cancelTimer(input: {
@@ -150,10 +152,9 @@ export declare class MdbaseConnection<Frontmatter extends JsonObject = JsonObjec
     }, CollectionMutationProblemCode>>;
     reconcileTimers(input: {
         namespace: string;
-        criterion_id: string;
+        criterionId: string;
         timers: MdbaseDesiredTimer[];
     }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerReconciliation, CollectionMutationProblemCode>>;
     watch(input?: WatchInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseWatchSubscription, CollectionChangesProblemCode>>;
-    operation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<ConnectOutcome<Result>>;
     private emitConnection;
 }

package/dist/connection.js

@@ -6,7 +6,7 @@ import { MdbaseFileClient } from "./files.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";
-import { withRequestBudget } from "./request-budget.js";
+import { withCooperativeRequestBudget, withRequestBudget } from "./request-budget.js";
 export class MdbaseConnection {
     internals;
     collectionId;
@@ -37,7 +37,7 @@ export class MdbaseConnection {
         }, internals.timeouts);
         this.collectionClient = new MdbaseCollectionClient({
             operation: (operation, input, requestOptions) => this.transport.performOperation(operation, input, requestOptions)
-        });
+        }, internals.timeouts.requestMs);
         this.notifications = new ConnectionNotifications({
             serverUrl: internals.serverUrl,
             storage: internals.storage,
@@ -267,108 +267,116 @@ export class MdbaseConnection {
         return this.collectionClient.preflightRename(input, options);
     }
     async renameWithProgress(input, options = {}) {
-        const started = Date.now();
-        const resumed = false;
-        let estimate;
-        const emit = (state, cancellable, completedUnits = 0) => {
-            options.onProgress?.({
-                operation: "rename",
-                state,
-                elapsedMs: Date.now() - started,
-                cancellable,
-                resumed,
-                completedUnits,
-                ...(estimate ? { estimate } : {})
-            });
-        };
-        try {
-            throwIfCancelled(options.signal);
-            emit("preflighting", true);
-            const previewOutcome = options.preflight
-                ? connectSuccess(options.preflight)
-                : await this.preflightRename(input, { signal: options.signal });
-            if (!previewOutcome.ok)
-                return previewOutcome;
-            const preview = previewOutcome.value;
+        return withCooperativeRequestBudget(options, this.internals.timeouts.requestMs, async (budget) => {
+            const started = Date.now();
+            const resumed = false;
+            let estimate;
+            const emit = (state, cancellable, completedUnits = 0) => {
+                options.onProgress?.({
+                    operation: "rename",
+                    state,
+                    elapsedMs: Date.now() - started,
+                    cancellable,
+                    resumed,
+                    completedUnits,
+                    ...(estimate ? { estimate } : {})
+                });
+            };
             try {
-                assertRenamePreview(input, preview);
+                throwIfCancelled(budget.signal);
+                emit("preflighting", true);
+                const previewOutcome = options.preflight
+                    ? connectSuccess(options.preflight)
+                    : await this.preflightRename(input, { signal: budget.signal, timeoutMs: null });
+                if (!previewOutcome.ok)
+                    return previewOutcome;
+                const preview = previewOutcome.value;
+                try {
+                    assertRenamePreview(input, preview);
+                }
+                catch (error) {
+                    if (error instanceof MdbaseConnectError) {
+                        return connectFailure(error.problem);
+                    }
+                    throw error;
+                }
+                estimate = renameEstimate(input, preview);
+                emit("ready", true);
+                throwIfCancelled(budget.signal);
+                const cancellable = this.transport.hasResumableMutationTransport();
+                emit("applying", cancellable);
+                const result = await this.rename(input, cancellable
+                    ? { signal: budget.signal, timeoutMs: null }
+                    : { timeoutMs: remainingTimeout(budget.remainingMs()) });
+                if (result.ok)
+                    emit("completed", false, estimate.totalUnits);
+                return result;
             }
             catch (error) {
+                if (isCancellation(error, budget.signal))
+                    emit("cancelled", false);
                 if (error instanceof MdbaseConnectError) {
                     return connectFailure(error.problem);
                 }
                 throw error;
             }
-            estimate = renameEstimate(input, preview);
-            emit("ready", true);
-            throwIfCancelled(options.signal);
-            const cancellable = this.transport.hasResumableMutationTransport();
-            emit("applying", cancellable);
-            const result = await this.rename(input, cancellable ? { signal: options.signal } : undefined);
-            if (result.ok)
-                emit("completed", false, estimate.totalUnits);
-            return result;
-        }
-        catch (error) {
-            if (isCancellation(error, options.signal))
-                emit("cancelled", false);
-            if (error instanceof MdbaseConnectError) {
-                return connectFailure(error.problem);
-            }
-            throw error;
-        }
+        });
     }
     async deleteWithProgress(input, options = {}) {
-        const started = Date.now();
-        const resumed = false;
-        let estimate;
-        const emit = (state, cancellable, completedUnits = 0) => {
-            options.onProgress?.({
-                operation: "delete",
-                state,
-                elapsedMs: Date.now() - started,
-                cancellable,
-                resumed,
-                completedUnits,
-                ...(estimate ? { estimate } : {})
-            });
-        };
-        try {
-            throwIfCancelled(options.signal);
-            emit("preflighting", true);
-            const previewOutcome = options.preflight
-                ? connectSuccess(options.preflight)
-                : await this.preflightDelete(input, { signal: options.signal });
-            if (!previewOutcome.ok)
-                return previewOutcome;
-            const preview = previewOutcome.value;
+        return withCooperativeRequestBudget(options, this.internals.timeouts.requestMs, async (budget) => {
+            const started = Date.now();
+            const resumed = false;
+            let estimate;
+            const emit = (state, cancellable, completedUnits = 0) => {
+                options.onProgress?.({
+                    operation: "delete",
+                    state,
+                    elapsedMs: Date.now() - started,
+                    cancellable,
+                    resumed,
+                    completedUnits,
+                    ...(estimate ? { estimate } : {})
+                });
+            };
             try {
-                assertDeletePreview(input, preview);
+                throwIfCancelled(budget.signal);
+                emit("preflighting", true);
+                const previewOutcome = options.preflight
+                    ? connectSuccess(options.preflight)
+                    : await this.preflightDelete(input, { signal: budget.signal, timeoutMs: null });
+                if (!previewOutcome.ok)
+                    return previewOutcome;
+                const preview = previewOutcome.value;
+                try {
+                    assertDeletePreview(input, preview);
+                }
+                catch (error) {
+                    if (error instanceof MdbaseConnectError) {
+                        return connectFailure(error.problem);
+                    }
+                    throw error;
+                }
+                estimate = deleteEstimate(preview);
+                emit("ready", true);
+                throwIfCancelled(budget.signal);
+                const cancellable = this.transport.hasResumableMutationTransport();
+                emit("applying", cancellable);
+                const result = await this.delete(input, cancellable
+                    ? { signal: budget.signal, timeoutMs: null }
+                    : { timeoutMs: remainingTimeout(budget.remainingMs()) });
+                if (result.ok)
+                    emit("completed", false, estimate.totalUnits);
+                return result;
             }
             catch (error) {
+                if (isCancellation(error, budget.signal))
+                    emit("cancelled", false);
                 if (error instanceof MdbaseConnectError) {
                     return connectFailure(error.problem);
                 }
                 throw error;
             }
-            estimate = deleteEstimate(preview);
-            emit("ready", true);
-            throwIfCancelled(options.signal);
-            const cancellable = this.transport.hasResumableMutationTransport();
-            emit("applying", cancellable);
-            const result = await this.delete(input, cancellable ? { signal: options.signal } : undefined);
-            if (result.ok)
-                emit("completed", false, estimate.totalUnits);
-            return result;
-        }
-        catch (error) {
-            if (isCancellation(error, options.signal))
-                emit("cancelled", false);
-            if (error instanceof MdbaseConnectError) {
-                return connectFailure(error.problem);
-            }
-            throw error;
-        }
+        });
     }
     pendingMutations() {
         return this.transport.pendingMutations().map((summary) => ({
@@ -413,6 +421,12 @@ export class MdbaseConnection {
     applyTypePack(input, options) {
         return this.collectionClient.applyTypePack(input, options);
     }
+    assessCollectionSetup(input, options) {
+        return this.collectionClient.assessCollectionSetup(input, options);
+    }
+    applyCollectionSetup(input, options) {
+        return this.collectionClient.applyCollectionSetup(input, options);
+    }
     listTimers(namespace, options) {
         return this.collectionClient.listTimers(namespace, options);
     }
@@ -436,9 +450,6 @@ export class MdbaseConnection {
             return new CollectionWatchSubscription(this.collectionClient, initial.value.cursor, input, input.cursor === undefined ? [] : initial.value.events, this.internals.timeouts.watchStartMs);
         }), COLLECTION_CHANGES_PROBLEM_CODES);
     }
-    operation(operation, input, options) {
-        return this.collectionClient.operation(operation, input, options);
-    }
     emitConnection() {
         const connection = this.info();
         for (const listener of this.connectionListeners)
@@ -559,3 +570,6 @@ function syncRequestOptions(options, defaultTimeoutMs) {
         timeoutMs: options?.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs
     };
 }
+function remainingTimeout(remainingMs) {
+    return remainingMs === null ? null : Math.max(1, Math.ceil(remainingMs));
+}

package/dist/crypto-entry.d.ts

@@ -1,4 +1,7 @@
 /** Opt-in cryptographic storage and transport primitives. */
-export * from "./crypto.js";
-export * from "./file-crypto.js";
-export * from "./application-identity.js";
+export { IndexedDbGrantKeyStore, MemoryGrantKeyStore, RelayCryptoError, signAuthorityRequest, authorityProofMessage, encryptRelayRequest, decryptRelayResponse, deriveP256SharedSecret, validateGrantEncryption } from "./crypto.js";
+export type { GrantKeyRecord, GrantKeyStore, RelayBinding, AuthorityProofInput } from "./crypto.js";
+export { FileTransferCryptoError, GrantFileTransferCipher, deriveFileTransferKey } from "./file-crypto.js";
+export type { FileTransferBinding } from "./file-crypto.js";
+export { IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, ApplicationIdentityStoreError, applicationInstallationId, signApplicationAuthorization, applicationIdentity } from "./application-identity.js";
+export type { ApplicationIdentity, ApplicationIdentityStore } from "./application-identity.js";

package/dist/crypto-entry.js

@@ -1,4 +1,4 @@
 /** Opt-in cryptographic storage and transport primitives. */
-export * from "./crypto.js";
-export * from "./file-crypto.js";
-export * from "./application-identity.js";
+export { IndexedDbGrantKeyStore, MemoryGrantKeyStore, RelayCryptoError, signAuthorityRequest, authorityProofMessage, encryptRelayRequest, decryptRelayResponse, deriveP256SharedSecret, validateGrantEncryption } from "./crypto.js";
+export { FileTransferCryptoError, GrantFileTransferCipher, deriveFileTransferKey } from "./file-crypto.js";
+export { IndexedDbApplicationIdentityStore, MemoryApplicationIdentityStore, ApplicationIdentityStoreError, applicationInstallationId, signApplicationAuthorization, applicationIdentity } from "./application-identity.js";

package/dist/file-transfer-internals.d.ts

@@ -1,4 +1,4 @@
-import type { FileTransferSession, PreparedFilePart } from "@mdbase-dev/connect-protocol";
+import type { FileTransferSession, FileTransferStatus, PreparedFilePart } from "@mdbase-dev/connect-protocol";
 import { MdbaseConnectError } from "./errors.js";
 export declare const MAX_OBJECT_ATTEMPTS = 3;
 export declare const MAX_BUFFERED_DOWNLOAD_BYTES: number;
@@ -13,6 +13,7 @@ export declare function uploadBodyBytes(body: UploadPartBody): Promise<Uint8Arra
 export declare function validConcurrency(value?: number): number;
 export declare function validPageSize(value: number): number;
 export declare function requireTransferSession(session: FileTransferSession, transferId: string, direction: "upload" | "download"): void;
+export declare function requireTransferStatus(status: FileTransferStatus, session: FileTransferSession): void;
 export declare function chunkLength(totalSize: number, partSize: number, index: number): number;
 export declare function retryChunk<Result>(work: () => Promise<Result>, signal?: AbortSignal): Promise<Result>;
 export declare function requirePreparedPart(part: PreparedFilePart, transferId: string, partIndex: number, offset: number, contentLength: number, method: "PUT"): void;

package/dist/file-transfer-internals.js

@@ -90,6 +90,44 @@ export function requireTransferSession(session, transferId, direction) {
         throw connectError("invalid_operation_response", "The authority returned invalid uploaded part receipts.");
     }
 }
+export function requireTransferStatus(status, session) {
+    const partSize = session.strategy.kind === "framed_chunks"
+        ? session.strategy.chunk_size
+        : session.strategy.kind === "object_put"
+            ? Math.max(1, session.total_size)
+            : session.strategy.part_size;
+    const partCount = session.strategy.kind === "object_put"
+        ? 1
+        : Math.ceil(session.total_size / partSize);
+    if (status?.protocol_version !== 1
+        || status.type !== "file_transfer_status"
+        || status.transfer_id !== session.transfer_id
+        || !["open", "committed", "aborted", "expired"].includes(status.state)
+        || !Array.isArray(status.received)
+        || new Set(status.received).size !== status.received.length
+        || status.received.some((index) => !Number.isSafeInteger(index) || index < 0 || index >= partCount)
+        || !Number.isSafeInteger(status.received_bytes)
+        || status.received_bytes < 0
+        || status.received_bytes > session.total_size
+        || status.received.reduce((total, index) => total + chunkLength(session.total_size, partSize, index), 0) !== status.received_bytes) {
+        throw connectError("invalid_operation_response", "The authority returned invalid transfer status.");
+    }
+    const uploadedParts = status.uploaded_parts;
+    if (!Array.isArray(uploadedParts)
+        || uploadedParts.some((part, index) => !Number.isSafeInteger(part?.part_number)
+            || part.part_number < 1
+            || part.part_number > partCount
+            || typeof part.etag !== "string"
+            || part.etag.length === 0
+            || part.etag.length > 255
+            || (index > 0 && uploadedParts[index - 1].part_number >= part.part_number))
+        || (session.strategy.kind === "object_multipart"
+            ? uploadedParts.length !== status.received.length
+                || uploadedParts.some((part, index) => part.part_number - 1 !== status.received[index])
+            : uploadedParts.length !== 0)) {
+        throw connectError("invalid_operation_response", "The authority returned invalid uploaded part status.");
+    }
+}
 function validTransferStrategy(session) {
     if (session.strategy.kind === "framed_chunks") {
         return session.protection === "grant_aead_v1"

package/dist/files.d.ts

@@ -1,8 +1,26 @@
-import type { CollectionFileDescriptor, DeleteFileReceipt, FileCapability, FileTransferSession } from "@mdbase-dev/connect-protocol";
+import type { FileCapability, FileTransferSession } from "@mdbase-dev/connect-protocol";
 import { type FileSource } from "./file-transfer-internals.js";
 import type { ConnectRequestOptions } from "./operation-types.js";
 import { type ResolvedConnectTimeouts } from "./request-budget.js";
 export type MdbaseFileSource = FileSource;
+export interface CollectionFileDescriptor {
+    fileId: string;
+    path: string;
+    revision: string;
+    contentDigest: `sha256:${string}`;
+    size: number;
+    mediaType?: string;
+    mediaClass: import("@mdbase-dev/connect-protocol").FileMediaClass;
+    modifiedAt: string;
+}
+export interface MdbaseFileDeleteReceipt {
+    protocolVersion: 1;
+    type: "file_deleted";
+    mutationId: string;
+    fileId: string;
+    previousPath: string;
+    revision: string;
+}
 export interface MdbaseFileStreamSource {
     /** Exact plaintext byte length. */
     size: number;
@@ -84,7 +102,7 @@ export declare class MdbaseFileClient {
     downloadBytes(file: CollectionFileDescriptor, options?: MdbaseFileDownloadOptions): Promise<Uint8Array>;
     move(file: CollectionFileDescriptor, path: string, options?: MdbaseFileMoveOptions): Promise<CollectionFileDescriptor>;
     private moveWithinBudget;
-    delete(file: CollectionFileDescriptor, options?: MdbaseFileDeleteOptions): Promise<DeleteFileReceipt>;
+    delete(file: CollectionFileDescriptor, options?: MdbaseFileDeleteOptions): Promise<MdbaseFileDeleteReceipt>;
     private deleteWithinBudget;
     private uploadPart;
     private tryReplayUploadCommit;

package/dist/files.js

@@ -2,7 +2,7 @@ import { FILE_PROTOCOL_VERSION } from "@mdbase-dev/connect-protocol";
 import { MdbaseConnectError, connectError } from "./errors.js";
 import { IncrementalSha256 } from "./file-sha256.js";
 import { BinaryPartReader } from "./file-stream-source.js";
-import { MAX_BUFFERED_DOWNLOAD_BYTES, MAX_OBJECT_ATTEMPTS, SHA256_DIGEST, UUID, browserObjectHeaders, chunkLength, hashBlob, mapConcurrent, normalizeFileError, requirePreparedPart, requireTransferSession, retryChunk, sourceBlob, throwIfAborted, uploadBodyBytes, uploadBodyLength, validConcurrency, validPageSize } from "./file-transfer-internals.js";
+import { MAX_BUFFERED_DOWNLOAD_BYTES, MAX_OBJECT_ATTEMPTS, SHA256_DIGEST, UUID, browserObjectHeaders, chunkLength, hashBlob, mapConcurrent, normalizeFileError, requirePreparedPart, requireTransferSession, requireTransferStatus, retryChunk, sourceBlob, throwIfAborted, uploadBodyBytes, uploadBodyLength, validConcurrency, validPageSize } from "./file-transfer-internals.js";
 import { createRequestBudget, resolveConnectTimeouts, withCooperativeRequestBudget } from "./request-budget.js";
 /** Ergonomic facade over resumable, authority-specific file delivery. */
 export class MdbaseFileClient {
@@ -38,7 +38,7 @@ export class MdbaseFileClient {
                 }
                 for (const file of page.files) {
                     throwIfAborted(signal);
-                    yield file;
+                    yield clientFileDescriptor(file);
                 }
                 after = page.next;
             } while (after);
@@ -130,16 +130,21 @@ export class MdbaseFileClient {
             const partCount = session.strategy.kind === "object_put"
                 ? 1
                 : Math.ceil(size / partSize);
+            const status = await this.request("GET", `transfers/${encodeURIComponent(transferId)}`, undefined, options.signal);
+            requireTransferStatus(status, session);
+            if (status.state !== "open" && status.state !== "committed") {
+                throw connectError("invalid_operation_response", `The authority cannot resume a ${status.state} file transfer.`);
+            }
             prepareSource?.(partSize);
-            if (!framed && session.received.length === partCount) {
-                const replay = await this.tryReplayUploadCommit(transferId, session.strategy.kind === "object_multipart" ? session.uploaded_parts : undefined, options.signal);
+            if (!framed && status.received.length === partCount) {
+                const replay = await this.tryReplayUploadCommit(transferId, session.strategy.kind === "object_multipart" ? status.uploaded_parts : undefined, options.signal);
                 if (replay) {
                     committed = true;
-                    return replay.file;
+                    return clientFileDescriptor(replay.file);
                 }
             }
-            const received = new Set(session.received);
-            const uploadedParts = new Map((session.uploaded_parts ?? []).map((part) => [part.part_number - 1, part]));
+            const received = new Set(status.received);
+            const uploadedParts = new Map(status.uploaded_parts.map((part) => [part.part_number - 1, part]));
             let transferredBytes = [...received].reduce((total, index) => total + chunkLength(size, partSize, index), 0);
             const parts = await mapConcurrent(partCount, concurrency, async (partIndex) => {
                 const offset = partIndex * partSize;
@@ -174,7 +179,7 @@ export class MdbaseFileClient {
                 throw connectError("invalid_operation_response", "The authority returned an invalid file receipt.");
             }
             committed = true;
-            return receipt.file;
+            return clientFileDescriptor(receipt.file);
         }
         catch (error) {
             throw normalizeFileError(error);
@@ -202,7 +207,7 @@ export class MdbaseFileClient {
             const copy = new Uint8Array(chunk.byteLength);
             copy.set(chunk);
             return copy.buffer;
-        }), { type: file.media_type ?? "" });
+        }), { type: file.mediaType ?? "" });
     }
     /** Download and verify a file with network backpressure and bounded buffering. */
     async downloadStream(file, options = {}) {
@@ -218,7 +223,7 @@ export class MdbaseFileClient {
                 protocol_version: FILE_PROTOCOL_VERSION,
                 type: "open_file_download",
                 transfer_id: transferId,
-                file_id: file.file_id,
+                file_id: file.fileId,
                 revision: file.revision
             }, startupSignal);
             requireTransferSession(session, transferId, "download");
@@ -257,7 +262,7 @@ export class MdbaseFileClient {
             await this.abort(transferId);
         };
         const verify = () => {
-            if (receivedBytes !== file.size || `sha256:${hash.digestHex()}` !== file.content_digest) {
+            if (receivedBytes !== file.size || `sha256:${hash.digestHex()}` !== file.contentDigest) {
                 throw connectError("invalid_operation_response", "Downloaded file bytes failed integrity verification.");
             }
         };
@@ -357,11 +362,11 @@ export class MdbaseFileClient {
         const mutationId = options.mutationId ?? crypto.randomUUID();
         let receipt;
         try {
-            receipt = await this.request("POST", `${encodeURIComponent(file.file_id)}/move`, {
+            receipt = await this.request("POST", `${encodeURIComponent(file.fileId)}/move`, {
                 protocol_version: FILE_PROTOCOL_VERSION,
                 type: "move_file",
                 mutation_id: mutationId,
-                file_id: file.file_id,
+                file_id: file.fileId,
                 if_revision: options.ifRevision ?? file.revision,
                 from_path: file.path,
                 path,
@@ -376,11 +381,11 @@ export class MdbaseFileClient {
         if (receipt.protocol_version !== 1
             || receipt.type !== "file_moved"
             || receipt.mutation_id !== mutationId
-            || receipt.file.file_id !== file.file_id
+            || receipt.file.file_id !== file.fileId
             || receipt.file.path !== path) {
             throw connectError("invalid_operation_response", "The authority returned an invalid file move receipt.");
         }
-        return receipt.file;
+        return clientFileDescriptor(receipt.file);
     }
     async delete(file, options = {}) {
         return withCooperativeRequestBudget(options, this.timeouts.requestMs, (budget) => this.deleteWithinBudget(file, { ...options, signal: budget.signal, timeoutMs: null }));
@@ -390,11 +395,11 @@ export class MdbaseFileClient {
         const mutationId = options.mutationId ?? crypto.randomUUID();
         let receipt;
         try {
-            receipt = await this.request("POST", `${encodeURIComponent(file.file_id)}/delete`, {
+            receipt = await this.request("POST", `${encodeURIComponent(file.fileId)}/delete`, {
                 protocol_version: FILE_PROTOCOL_VERSION,
                 type: "delete_file",
                 mutation_id: mutationId,
-                file_id: file.file_id,
+                file_id: file.fileId,
                 if_revision: options.ifRevision ?? file.revision,
                 path: file.path
             }, options.signal);
@@ -405,11 +410,18 @@ export class MdbaseFileClient {
         if (receipt.protocol_version !== 1
             || receipt.type !== "file_deleted"
             || receipt.mutation_id !== mutationId
-            || receipt.file_id !== file.file_id
+            || receipt.file_id !== file.fileId
             || receipt.previous_path !== file.path) {
             throw connectError("invalid_operation_response", "The authority returned an invalid file delete receipt.");
         }
-        return receipt;
+        return {
+            protocolVersion: receipt.protocol_version,
+            type: receipt.type,
+            mutationId: receipt.mutation_id,
+            fileId: receipt.file_id,
+            previousPath: receipt.previous_path,
+            revision: receipt.revision
+        };
     }
     async uploadPart(transferId, partIndex, offset, body, contentLength, requireEtag, signal) {
         for (let attempt = 1; attempt <= MAX_OBJECT_ATTEMPTS; attempt += 1) {
@@ -488,3 +500,15 @@ export class MdbaseFileClient {
         await this.request("DELETE", `transfers/${encodeURIComponent(transferId)}`).catch(() => undefined);
     }
 }
+function clientFileDescriptor(file) {
+    return {
+        fileId: file.file_id,
+        path: file.path,
+        revision: file.revision,
+        contentDigest: file.content_digest,
+        size: file.size,
+        ...(file.media_type ? { mediaType: file.media_type } : {}),
+        mediaClass: file.media_class,
+        modifiedAt: file.modified_at
+    };
+}