@telecrypt-io/storage 0.6.0 → 0.7.0

package/dist/core/http.js

@@ -12,7 +12,6 @@ export class ResponseBodyReadError extends Error {
         this.bytes = bytes;
     }
 }
-const RESPONSE_CLEANUP_TIMEOUT_MS = 5_000;
 function abortError() {
     return new DOMException("The operation was aborted", "AbortError");
 }
@@ -53,79 +52,32 @@ export function raceWithAbort(operation, signal, error) {
             abort();
     });
 }
-function combineCleanupFailures(primaryError, cleanupFailures, message) {
-    const errors = primaryError === undefined ? [...cleanupFailures] : [primaryError, ...cleanupFailures];
-    return new AggregateError(errors, message, {
-        cause: primaryError ?? cleanupFailures[0],
-    });
-}
-async function runBoundedCleanup(cleanup, operation) {
-    const pending = Promise.resolve().then(cleanup);
-    let timer;
-    const deadline = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-            reject(new Error(`${operation} cleanup timed out`));
-        }, RESPONSE_CLEANUP_TIMEOUT_MS);
-    });
+function startCancellation(cancel) {
     try {
-        await Promise.race([pending, deadline]);
+        void Promise.resolve(cancel()).catch(() => { });
     }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
+    catch {
+        // Cleanup must not delay or replace the operation result.
     }
 }
-/** Await cleanup for a response that is being rejected before its body is read. */
-export async function cancelResponseBody(response, operation, primaryError) {
-    if (!response.body)
-        return;
-    try {
-        await runBoundedCleanup(() => response.body.cancel(), `${operation} response`);
-    }
-    catch (error) {
-        throw combineCleanupFailures(primaryError, [error], primaryError === undefined
-            ? `${operation} response cleanup was incomplete`
-            : `${operation} failed and response cleanup was incomplete`);
-    }
+/** Start discarding a rejected response without waiting for provider cleanup. */
+export function cancelResponseBody(response) {
+    if (response.body)
+        startCancellation(() => response.body.cancel());
 }
-async function cancelReaderAndRelease(reader, operation, primaryError) {
-    const cleanupFailures = [];
-    try {
-        await runBoundedCleanup(() => reader.cancel(), `${operation} reader cancellation`);
-    }
-    catch (error) {
-        cleanupFailures.push(error);
-    }
-    // Cancellation is awaited before releasing the reader, so cleanup failures
-    // stay part of the current operation instead of mutating a later error.
+function cancelReaderAndRelease(reader) {
+    startCancellation(() => reader.cancel());
     try {
         reader.releaseLock();
     }
-    catch (error) {
-        cleanupFailures.push(error);
-    }
-    if (cleanupFailures.length > 0) {
-        throw combineCleanupFailures(primaryError, cleanupFailures, primaryError === undefined
-            ? `${operation} reader cleanup was incomplete`
-            : `${operation} failed and reader cleanup was incomplete`);
+    catch {
+        // The reader may still have a pending read; the caller's error remains authoritative.
     }
 }
 async function readResponseBodyInternal(response, signal, options = {}, maxBytes) {
-    const cancelAbortedResponse = async (failure) => {
-        if (!response.body)
-            return;
-        let reader;
-        try {
-            reader = response.body.getReader();
-        }
-        catch (error) {
-            throw combineCleanupFailures(failure, [error], "response reader setup failed after abort");
-        }
-        await cancelReaderAndRelease(reader, "response body", failure);
-    };
     if (signal?.aborted) {
         const failure = options.abortError?.() ?? abortError();
-        await cancelAbortedResponse(failure);
+        cancelResponseBody(response);
         throw failure;
     }
     if (maxBytes !== undefined &&
@@ -136,7 +88,7 @@ async function readResponseBodyInternal(response, signal, options = {}, maxBytes
         const contentLength = response.headers.get("content-length");
         if (contentLength !== null && /^\d+$/u.test(contentLength) && Number(contentLength) > maxBytes) {
             const tooLarge = new FileTooLargeError();
-            await cancelResponseBody(response, "media response", tooLarge);
+            cancelResponseBody(response);
             throw tooLarge;
         }
     }
@@ -147,18 +99,15 @@ async function readResponseBodyInternal(response, signal, options = {}, maxBytes
         reader = response.body.getReader();
     }
     catch (error) {
-        let failure = error;
-        try {
-            await cancelResponseBody(response, "response body reader setup", error);
-        }
-        catch (cleanupError) {
-            failure = cleanupError;
-        }
-        throw new ResponseBodyReadError(new Uint8Array(), failure);
+        cancelResponseBody(response);
+        throw new ResponseBodyReadError(new Uint8Array(), error);
     }
-    let abortCancellation;
+    let cancellationStarted = false;
     const cancelReader = () => {
-        abortCancellation ??= runBoundedCleanup(() => reader.cancel(), "response body reader");
+        if (cancellationStarted)
+            return;
+        cancellationStarted = true;
+        startCancellation(() => reader.cancel());
     };
     const chunks = [];
     let bytesRead = 0;
@@ -213,34 +162,14 @@ async function readResponseBodyInternal(response, signal, options = {}, maxBytes
     catch (error) {
         if (signal?.aborted) {
             const failure = new ResponseBodyReadError(joinBytes(chunks, bytesRead), error);
-            const cleanupFailures = [];
-            if (abortCancellation) {
-                try {
-                    await abortCancellation;
-                }
-                catch (cleanupError) {
-                    cleanupFailures.push(cleanupError);
-                }
-            }
+            cancelReader();
             try {
                 reader.releaseLock();
             }
-            catch (cleanupError) {
-                cleanupFailures.push(cleanupError);
-            }
-            if (cleanupFailures.length > 0) {
-                throw combineCleanupFailures(failure, cleanupFailures, "response body read failed and reader cleanup was incomplete");
-            }
+            catch { /* Pending reads release with cancellation. */ }
             throw failure;
         }
-        try {
-            await cancelReaderAndRelease(reader, "response body", error);
-        }
-        catch (cleanupError) {
-            if (error instanceof FileTooLargeError)
-                throw cleanupError;
-            throw new ResponseBodyReadError(joinBytes(chunks, bytesRead), cleanupError);
-        }
+        cancelReaderAndRelease(reader);
         if (error instanceof FileTooLargeError)
             throw error;
         throw new ResponseBodyReadError(joinBytes(chunks, bytesRead), error);

package/dist/core/oidc.d.ts

@@ -34,9 +34,6 @@ export type OidcTokenEndpointMetadata = Pick<OidcClientConfig, "issuer" | "token
  * identifiers, or control characters from an untrusted response to cross the
  * SDK boundary. */
 export declare function sanitizeDiagnosticText(value: string): string;
-/** Copy a transport error's useful details across the SDK boundary after the
- * same secret/control-character sanitization used for provider responses. */
-export declare function diagnosticCause(error: unknown, seen?: WeakSet<object>): Error;
 /**
  * Discovers the OIDC/MAS issuer and endpoints for a homeserver via the
  * Matrix client's stable `/auth_metadata` endpoint. Matrix 42 performs this
@@ -44,9 +41,8 @@ export declare function diagnosticCause(error: unknown, seen?: WeakSet<object>):
  */
 export declare function discoverOidcIssuer(homeserverBaseUrl: string, signal?: AbortSignal): Promise<OidcClientConfig>;
 /**
- * Dynamic client registration (DCR). `clientUri`/`redirectUris` must share a
- * host unless the issuer's policy allows a mismatch (our local dev/test MAS
- * does; a production issuer may not).
+ * Dynamic client registration (DCR). The issuer validates the supplied
+ * metadata; the PKCE flow separately binds its callback to the current app.
  */
 export declare function registerClient(authMetadata: OidcClientConfig, metadata: OidcRegistrationClientMetadata, signal?: AbortSignal): Promise<string>;
 /**