@mdbase-dev/connect 0.1.0-beta.61 → 0.1.0-beta.63

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

@@ -1 +1 @@
-sha384-8q/ad0vEZFISbJVmcgiwghE8Zi5/u4kBtZPskPy+cHhXMEwZoHGTiGdujLx57o8/
+sha384-lle3e5SEN8S45RwEaaerEa1VKEBzMw7JZGQcuO1VI734WP7P95QHHR5DbXASXaaL

package/dist/connection-transport.js

@@ -4,10 +4,10 @@ import { MdbaseConnectError, connectError, serverConnectError } from "./errors.j
 import { ConnectionFileTransport } from "./connection-file-transport.js";
 import { authorityProofHeaders } from "./authority-proof.js";
 import { PendingMutationStore } from "./pending-mutation-store.js";
-import { directFallbackStatus, isMutation, localNetworkPermission, loopbackRequest, operationFingerprint, operationTransportError, sameAuthorization, throwIfCancelled, unknownMutationOutcome } from "./operation-helpers.js";
+import { directFallbackStatus, encryptedOperationError, fetchOperationRequest, isMutation, localNetworkPermission, loopbackRequest, operationFingerprint, operationTransportError, sameAuthorization, throwIfCancelled, unknownMutationOutcome, withOperationDeadline } from "./operation-helpers.js";
 import { apiError, decodeJsonResponse, oauthErrorCode, parseStored, } from "./runtime-utils.js";
 import { readStoredToken } from "./stored-token.js";
-import { withCooperativeRequestBudget, withRequestBudget } from "./request-budget.js";
+import { requestOptionsWithinBudget, withCooperativeRequestBudget, withRequestBudget } from "./request-budget.js";
 import { sendAuthoritySyncRequest } from "./authority-sync-request.js";
 import { freshEncryptedRequest } from "./fresh-encrypted-request.js";
 import { isExplicitConnectorBusyResponse, retryExplicitConnectorBusy } from "./transient-retry.js";
@@ -124,13 +124,10 @@ export class ConnectionTransport {
         if (!pending) {
             throw connectError("no_pending_mutation", "There is no interrupted mutation to resume.");
         }
-        return withCooperativeRequestBudget(options, this.timeouts.requestMs, (budget) => this.performOperationWithinBudget(pending.operation, pending.request?.input ?? {}, { ...options, signal: budget.signal }, pending));
+        return withCooperativeRequestBudget(options, this.timeouts.requestMs, (budget) => this.performOperationWithinBudget(pending.operation, pending.request?.input ?? {}, requestOptionsWithinBudget(options ?? {}, budget), pending));
     }
     async performOperation(operation, input, options = {}) {
-        return withCooperativeRequestBudget(options, this.timeouts.requestMs, (budget) => this.performOperationWithinBudget(operation, input, {
-            ...options,
-            signal: budget.signal
-        }));
+        return withCooperativeRequestBudget(options, this.timeouts.requestMs, (budget) => this.performOperationWithinBudget(operation, input, requestOptionsWithinBudget(options, budget)));
     }
     async performOperationWithinBudget(operation, input, options, storedPending, freshReadRetried = false, connectorBusyRetries = 0, knownRejectedMutationRetry = false) {
         throwIfCancelled(options.signal);
@@ -214,6 +211,8 @@ export class ConnectionTransport {
                 && !freshReadRetried) {
                 return this.performOperationWithinBudget(operation, input, options, undefined, true);
             }
+            if (attempt.pendingMutation && error.outcomeUnknown)
+                throw error;
             if (attempt.pendingMutation
                 && (attempt.directDeliveryUncertain
                     || (attempt.encryptedRequest && attempt.resumingMutation))) {
@@ -251,16 +250,14 @@ export class ConnectionTransport {
                     && !freshReadRetried) {
                     return this.performOperationWithinBudget(operation, input, options, undefined, true);
                 }
+                if (!decrypted.ok) {
+                    const error = encryptedOperationError(decrypted.problem);
+                    if (attempt.pendingMutation && !error.outcomeUnknown)
+                        this.clearPendingMutation(attempt.requestId);
+                    throw error;
+                }
                 if (attempt.pendingMutation)
                     this.clearPendingMutation(attempt.requestId);
-                if (!decrypted.ok)
-                    throw serverConnectError(decrypted.problem.code === "unknown"
-                        ? decrypted.problem.server_code
-                        : decrypted.problem.code, decrypted.problem.message, {
-                        details: decrypted.problem.details,
-                        operationOutcome: decrypted.problem.operation_outcome ?? "rejected",
-                        traceId: decrypted.problem.trace_id
-                    });
                 return decrypted.result;
             }
             catch (error) {
@@ -292,7 +289,7 @@ export class ConnectionTransport {
             const recovery = await retryBusy(error);
             if (recovery.retried)
                 return recovery.result;
-            if (attempt.pendingMutation)
+            if (attempt.pendingMutation && !error.outcomeUnknown)
                 this.clearPendingMutation(attempt.requestId);
             throw error;
         }
@@ -380,10 +377,12 @@ export class ConnectionTransport {
                         if (!pending.envelope) {
                             throw connectError("pending_mutation_unresolved", "The pending write belongs to a different transport. Reconnect before retrying it.");
                         }
-                        encryptedRequest = pending.envelope;
+                        // Preserve the durable identity and ciphertext, but refresh the
+                        // unauthenticated scheduling deadline for this recovery attempt.
+                        encryptedRequest = withOperationDeadline(pending.envelope, options.deadlineUnixMs);
                     }
                     else {
-                        encryptedRequest = await encryptRelayRequest(this.keyStore, token.keyHandle, { grantId: token.grantId, applicationId: token.clientId, encryption: token.encryption }, operation, input, requestId);
+                        encryptedRequest = await encryptRelayRequest(this.keyStore, token.keyHandle, { grantId: token.grantId, applicationId: token.clientId, encryption: token.encryption }, operation, input, requestId, options.deadlineUnixMs);
                         this.pendingMutationStore.store({
                             collectionId: token.collectionId,
                             ...(token.grantId ? { grantId: token.grantId } : {}),
@@ -401,7 +400,7 @@ export class ConnectionTransport {
                     }
                 }
                 else {
-                    encryptedRequest = await encryptRelayRequest(this.keyStore, token.keyHandle, { grantId: token.grantId, applicationId: token.clientId, encryption: token.encryption }, operation, input);
+                    encryptedRequest = await encryptRelayRequest(this.keyStore, token.keyHandle, { grantId: token.grantId, applicationId: token.clientId, encryption: token.encryption }, operation, input, undefined, options.deadlineUnixMs);
                 }
             }
             catch (error) {
@@ -460,8 +459,11 @@ export class ConnectionTransport {
                 this.markDirectUnavailable();
             }
             catch (error) {
-                if (options.signal?.aborted)
+                if (options.signal?.aborted) {
+                    if (pendingMutation)
+                        throw unknownMutationOutcome(requestId, error);
                     throw error;
+                }
                 directDeliveryUncertain = true;
                 if ((await localNetworkPermission()) === "denied")
                     this.setDirectStatus("denied");
@@ -481,7 +483,7 @@ export class ConnectionTransport {
             }
             let response;
             if (!pendingMutation) {
-                encryptedRequest = await freshEncryptedRequest(this.keyStore, relayToken, operation, input);
+                encryptedRequest = await freshEncryptedRequest(this.keyStore, relayToken, operation, input, options.deadlineUnixMs);
                 requestId = encryptedRequest.request_id;
             }
             try {
@@ -496,7 +498,7 @@ export class ConnectionTransport {
                 });
             }
             catch (error) {
-                if (pendingMutation && (directDeliveryUncertain || resumingMutation))
+                if (pendingMutation)
                     throw unknownMutationOutcome(requestId, error);
                 throw error;
             }
@@ -519,16 +521,15 @@ export class ConnectionTransport {
         const proof = token.authority
             ? await authorityProofHeaders(this.keyStore, token, "POST", operationUrl, operationBody, token.authority.accessToken)
             : {};
-        const response = await fetch(operationUrl, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${token.authority?.accessToken ?? token.accessToken}`,
-                "content-type": "application/json",
-                ...proof
-            },
-            body: operationBody,
-            signal: options.signal
-        });
+        let response;
+        try {
+            response = await fetchOperationRequest(operationUrl, token.authority?.accessToken ?? token.accessToken, proof, operationBody, options.signal);
+        }
+        catch (error) {
+            if (pendingMutation)
+                throw unknownMutationOutcome(requestId, error);
+            throw error;
+        }
         if (response.ok)
             this.setRoute(token.authority ? "remote" : "relay");
         return {

package/dist/crypto.d.ts

@@ -46,7 +46,7 @@ export interface AuthorityProofInput {
 /** Sign one remote-authority or token-refresh request with the approved grant key. */
 export declare function signAuthorityRequest(store: GrantKeyStore, handle: string, expectedPublicKey: string, input: AuthorityProofInput): Promise<Record<string, string>>;
 export declare function authorityProofMessage(input: Required<Pick<AuthorityProofInput, "method" | "target" | "credential" | "timestamp" | "nonce">> & Pick<AuthorityProofInput, "body">): Promise<string>;
-export declare function encryptRelayRequest(store: GrantKeyStore, handle: string, binding: RelayBinding, operation: EncryptedRelayOperation, input: unknown, requestId?: string): Promise<EncryptedRelayOperationRequest>;
+export declare function encryptRelayRequest(store: GrantKeyStore, handle: string, binding: RelayBinding, operation: EncryptedRelayOperation, input: unknown, requestId?: string, deadlineUnixMs?: number): Promise<EncryptedRelayOperationRequest>;
 export declare function decryptRelayResponse<Result>(store: GrantKeyStore, handle: string, binding: RelayBinding, request: EncryptedRelayOperationRequest, response: EncryptedRelayOperationResponse): Promise<{
     ok: true;
     result: Result;

package/dist/crypto.js

@@ -157,8 +157,12 @@ export async function authorityProofMessage(input) {
         input.nonce
     ].join("\n");
 }
-export async function encryptRelayRequest(store, handle, binding, operation, input, requestId = crypto.randomUUID()) {
+export async function encryptRelayRequest(store, handle, binding, operation, input, requestId = crypto.randomUUID(), deadlineUnixMs) {
     validateGrantEncryption(binding.encryption);
+    if (deadlineUnixMs !== undefined
+        && (!Number.isSafeInteger(deadlineUnixMs) || deadlineUnixMs <= 0)) {
+        throw new RelayCryptoError("invalid_deadline", "The operation deadline is invalid.");
+    }
     const record = await requireAgreementKey(store, handle, binding.encryption.application_agreement_public_key);
     const counter = await store.nextCounter(handle);
     const metadata = {
@@ -179,6 +183,7 @@ export async function encryptRelayRequest(store, handle, binding, operation, inp
     return {
         type: "encrypted_operation_request",
         ...envelopeMetadata(metadata),
+        ...(deadlineUnixMs === undefined ? {} : { deadline_unix_ms: deadlineUnixMs }),
         ciphertext: bytesToBase64Url(new Uint8Array(ciphertext))
     };
 }

package/dist/files.js

@@ -387,8 +387,14 @@ export class MdbaseFileClient {
                     }
                 }
                 catch (error) {
+                    const failure = options.signal?.aborted
+                        ? connectError("operation_cancelled", "The file transfer was cancelled.", {
+                            operationOutcome: "not_sent",
+                            cause: options.signal.reason
+                        })
+                        : error;
                     await finish();
-                    controller.error(normalizeFileError(error));
+                    controller.error(normalizeFileError(failure));
                 }
             },
             cancel: finish

package/dist/fresh-encrypted-request.d.ts

@@ -1,4 +1,4 @@
 import type { CollectionOperation, EncryptedRelayOperationRequest } from "@mdbase-dev/connect-protocol";
 import { type GrantKeyStore } from "./crypto.js";
 import type { StoredToken } from "./internal-types.js";
-export declare function freshEncryptedRequest(keyStore: GrantKeyStore, token: StoredToken, operation: CollectionOperation, input: unknown): Promise<EncryptedRelayOperationRequest>;
+export declare function freshEncryptedRequest(keyStore: GrantKeyStore, token: StoredToken, operation: CollectionOperation, input: unknown, deadlineUnixMs?: number): Promise<EncryptedRelayOperationRequest>;

package/dist/fresh-encrypted-request.js

@@ -1,6 +1,6 @@
 import { encryptRelayRequest, RelayCryptoError } from "./crypto.js";
 import { connectError, serverConnectError } from "./errors.js";
-export async function freshEncryptedRequest(keyStore, token, operation, input) {
+export async function freshEncryptedRequest(keyStore, token, operation, input, deadlineUnixMs) {
     if (!token.encryption || !token.grantId || !token.keyHandle) {
         throw connectError("authorization_binding_incompatible", "The refreshed authorization no longer supports encrypted connector operations.", {
             details: {
@@ -17,7 +17,7 @@ export async function freshEncryptedRequest(keyStore, token, operation, input) {
             grantId: token.grantId,
             applicationId: token.clientId,
             encryption: token.encryption
-        }, operation, input);
+        }, operation, input, undefined, deadlineUnixMs);
     }
     catch (error) {
         if (error instanceof RelayCryptoError) {

package/dist/operation-helpers.d.ts

@@ -1,4 +1,4 @@
-import { type CollectionOperation } from "@mdbase-dev/connect-protocol";
+import { type CollectionOperation, type ConnectProblem, type EncryptedRelayOperationRequest } from "@mdbase-dev/connect-protocol";
 import { MdbaseConnectError } from "./errors.js";
 import type { StoredToken } from "./internal-types.js";
 import type { DeleteInput, DeletePreflightResult, MutationEstimate, RenameInput, RenamePreflightResult } from "./operation-types.js";
@@ -9,10 +9,13 @@ export declare function loopbackRequest(init: RequestInit): LoopbackRequestInit;
 export declare function localNetworkPermission(): Promise<PermissionState | null>;
 export declare function directFallbackStatus(status: number): boolean;
 export declare function isMutation(operation: CollectionOperation, input?: unknown): boolean;
+export declare function withOperationDeadline(request: EncryptedRelayOperationRequest, deadlineUnixMs?: number): EncryptedRelayOperationRequest;
 export declare function uniqueOperations(operations: CollectionOperation[]): CollectionOperation[];
 export declare function sameAuthorization(left: StoredToken, right: StoredToken): boolean;
 export declare function throwIfCancelled(signal?: AbortSignal): void;
 export declare function operationTransportError(error: unknown, signal: AbortSignal | undefined, pendingRequestId: string | undefined, unavailableCode: "hosted_provider_unavailable" | "relay_unavailable"): Error;
+export declare function encryptedOperationError(problem: ConnectProblem): MdbaseConnectError;
+export declare function fetchOperationRequest(url: string, accessToken: string, proof: Record<string, string>, body: string, signal?: AbortSignal): Promise<Response>;
 export declare function isCancellation(error: unknown, signal?: AbortSignal): boolean;
 export declare function assertRenamePreview(input: RenameInput, preview: RenamePreflightResult): void;
 export declare function assertDeletePreview(input: DeleteInput, preview: DeletePreflightResult): void;

package/dist/operation-helpers.js

@@ -1,5 +1,5 @@
 import { isMutatingOperation, mutationFingerprint } from "@mdbase-dev/connect-protocol";
-import { MdbaseConnectError, connectError } from "./errors.js";
+import { MdbaseConnectError, connectError, serverConnectError } from "./errors.js";
 export function loopbackRequest(init) {
     return { ...init, credentials: "omit", targetAddressSpace: "loopback" };
 }
@@ -22,6 +22,15 @@ export function directFallbackStatus(status) {
 export function isMutation(operation, input) {
     return isMutatingOperation(operation, input);
 }
+export function withOperationDeadline(request, deadlineUnixMs) {
+    if (request.deadline_unix_ms === deadlineUnixMs)
+        return request;
+    const { deadline_unix_ms: _previousDeadline, ...identity } = request;
+    return {
+        ...identity,
+        ...(deadlineUnixMs === undefined ? {} : { deadline_unix_ms: deadlineUnixMs })
+    };
+}
 export function uniqueOperations(operations) {
     return [...new Set(operations)];
 }
@@ -61,6 +70,25 @@ export function operationTransportError(error, signal, pendingRequestId, unavail
     }
     return error instanceof Error ? error : new Error(String(error));
 }
+export function encryptedOperationError(problem) {
+    return serverConnectError(problem.code === "unknown" ? problem.server_code : problem.code, problem.message, {
+        details: problem.details,
+        operationOutcome: problem.operation_outcome ?? "rejected",
+        traceId: problem.trace_id
+    });
+}
+export function fetchOperationRequest(url, accessToken, proof, body, signal) {
+    return fetch(url, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+            "content-type": "application/json",
+            ...proof
+        },
+        body,
+        signal
+    });
+}
 export function isCancellation(error, signal) {
     return signal?.aborted === true
         || (error instanceof MdbaseConnectError && error.code === "operation_cancelled");

package/dist/request-budget.d.ts

@@ -19,6 +19,11 @@ export interface RequestBudget {
     remainingMs(): number | null;
     dispose(): void;
 }
+export type OperationRequestOptions = ConnectRequestOptions & {
+    /** Absolute budget shared with the connector; never supplied directly by callers. */
+    deadlineUnixMs?: number;
+};
+export declare function requestOptionsWithinBudget(options: ConnectRequestOptions, budget: RequestBudget): OperationRequestOptions;
 export declare function createRequestBudget(options?: ConnectRequestOptions, defaultTimeoutMs?: number | null, now?: () => number): RequestBudget;
 export declare function withRequestBudget<Result>(options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, operation: (budget: RequestBudget) => Promise<Result>): Promise<Result>;
 /**

package/dist/request-budget.js

@@ -13,6 +13,13 @@ export function resolveConnectTimeouts(timeouts = {}) {
         syncMs: configuredTimeout(timeouts.syncMs, DEFAULT_SYNC_TIMEOUT_MS, "syncMs")
     };
 }
+export function requestOptionsWithinBudget(options, budget) {
+    return {
+        ...options,
+        signal: budget.signal,
+        ...(budget.deadline === null ? {} : { deadlineUnixMs: budget.deadline })
+    };
+}
 export function createRequestBudget(options = {}, defaultTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, now = Date.now) {
     const configured = options.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs;
     const timeoutMs = configured === null ? null : validTimeout(configured);

package/dist/runtime-utils.js

@@ -49,7 +49,12 @@ export async function createPkce() {
     return { verifier, challenge: bytesToBase64Url(new Uint8Array(digest)) };
 }
 export function apiError(body, fallbackCode, fallbackMessage, status) {
-    return serverConnectError(oauthErrorCode(body) ?? body?.error?.code ?? fallbackCode, body?.error_description ?? body?.error?.message ?? fallbackMessage, { status, details: body?.error?.details });
+    return serverConnectError(oauthErrorCode(body) ?? body?.error?.code ?? fallbackCode, body?.error_description ?? body?.error?.message ?? fallbackMessage, {
+        status,
+        details: body?.error?.details,
+        operationOutcome: body?.error?.operation_outcome,
+        traceId: body?.error?.trace_id
+    });
 }
 export function oauthErrorCode(body) {
     return typeof body?.error === "string" ? body.error : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdbase-dev/connect",
-  "version": "0.1.0-beta.61",
+  "version": "0.1.0-beta.63",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mdbase-dev/connect-protocol": "0.1.0-beta.61"
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.63"
   },
   "devDependencies": {
     "esbuild": "^0.28.1",