@getstrata/core 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @getstrata/core changelog
 
+## 2.0.4
+
+- Place cache rollout guidance beside outbox docs without overlapping API additions
+
+## 2.0.3
+
+- Persist transactional events with leased tenant-aware SQL outbox workers
+
 ## 2.0.2
 
 - Adopt TypeScript 7.0.2 in framework and generated apps; preserve tested TypeScript 5.9 and 6.x consumer compatibility.

package/dist/core/database/baseRepository.d.ts

@@ -21,6 +21,8 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     protected readonly table: TableDefinition<TEntity, PrimaryKey>;
     protected readonly connection: DatabaseConnection;
     constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
+    private assertTransactionalEvent;
+    private runModelMutation;
     count(options?: ExtendedQueryOptions<TEntity>): Promise<number>;
     findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
     paginate(options: {

package/dist/core/database/dialect.d.ts

@@ -4,6 +4,10 @@ interface SqlDialect {
     placeholder(index: number): string;
     quoteIdentifier(identifier: string): string;
     nowExpression(): string;
+    /** Authoritative database wall clock for persisted lease/retry deadlines. */
+    epochMillisecondsExpression(): string;
+    /** Current reads/row locks; SQLite serializes writes at transaction admission. */
+    rowLockClause(skipLocked?: boolean): string;
     /** Render a Date as a literal this engine accepts for a timestamp column. */
     timestampValue(value: Date): string;
     returningClause(columns: string): string;

package/dist/core/database/mysqlConnection.d.ts

@@ -1,18 +1,28 @@
-import type { ActiveDatabaseHandle } from "./connectionContext.ts";
+import { type ActiveDatabaseHandle } from "./connectionContext.ts";
 type MysqlExecutable = {
     execute: (sql: string, params?: unknown[]) => Promise<[unknown, unknown]>;
+    query?: (sql: string) => Promise<[unknown, unknown]>;
     end?: () => Promise<void>;
+    getConnection?: () => Promise<MysqlPoolConnection>;
 };
 type MysqlPool = MysqlExecutable & {
     end(): Promise<void>;
     on(event: "connection", listener: (connection: unknown) => void): void;
 };
+type MysqlPoolConnection = MysqlExecutable & {
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    release(): void;
+    destroy(): void;
+};
 type MysqlConnection = ActiveDatabaseHandle & {
+    begin<T>(callback: (transaction: ActiveDatabaseHandle) => Promise<T>): Promise<T>;
     close(): Promise<void>;
 };
 declare function resetMysqlLoaderForTests(importer?: () => Promise<unknown>): void;
 declare function createMysqlConnectionFromPool(pool: MysqlExecutable): MysqlConnection;
 declare function createMysqlPool(url: string): Promise<MysqlPool>;
 declare function createMysqlConnection(url: string): MysqlConnection;
-export type { MysqlConnection, MysqlExecutable, MysqlPool };
+export type { MysqlConnection, MysqlExecutable, MysqlPool, MysqlPoolConnection };
 export { createMysqlConnection, createMysqlConnectionFromPool, createMysqlPool, resetMysqlLoaderForTests, };

package/dist/core/database/sqliteConnection.d.ts

@@ -1,5 +1,6 @@
-import type { ActiveDatabaseHandle } from "./connectionContext.ts";
+import { type ActiveDatabaseHandle } from "./connectionContext.ts";
 type SqliteConnection = ActiveDatabaseHandle & {
+    begin<T>(callback: (transaction: ActiveDatabaseHandle) => Promise<T>): Promise<T>;
     close(): void;
 };
 declare function createSqliteConnection(filename: string): SqliteConnection;

package/dist/core/database/transaction.d.ts

@@ -1,4 +1,4 @@
 import type { DatabaseConnection } from "./baseRepository.ts";
-import { requestTransactionRollback } from "./transactionControl.ts";
+import { hasActiveTransaction, requestTransactionRollback } from "./transactionControl.ts";
 declare function runInTransaction<TValue>(operation: (connection: DatabaseConnection) => Promise<TValue>): Promise<TValue>;
-export { requestTransactionRollback, runInTransaction };
+export { hasActiveTransaction, requestTransactionRollback, runInTransaction };

package/dist/core/database/transactionControl.d.ts

@@ -1,5 +1,6 @@
+declare function hasActiveTransaction(): boolean;
 declare function requestTransactionRollback(): void;
 declare function commitOrRollbackScope<T>(result: T): Promise<T>;
 declare function settleTransaction<T>(work: () => Promise<T>): Promise<T>;
 declare function runWithTransactionScope<T>(callback: () => T | Promise<T>): Promise<T>;
-export { commitOrRollbackScope, requestTransactionRollback, runWithTransactionScope, settleTransaction, };
+export { commitOrRollbackScope, hasActiveTransaction, requestTransactionRollback, runWithTransactionScope, settleTransaction, };

package/dist/core/events/eventBus.d.ts

@@ -1,6 +1,10 @@
 type EventListener = (payload: unknown) => void | Promise<void>;
 declare class EventBus {
     constructor();
+    private readonly transactionalListeners;
+    listenTransactional(event: string, listener: EventListener): () => void;
+    hasTransactionalListeners(event: string): boolean;
+    dispatchTransactional(event: string, payload: unknown): Promise<void>;
     private readonly listeners;
     on(event: string, listener: EventListener): () => void;
     listen(event: string, listener: EventListener): () => void;

package/dist/core/events/outbox/index.d.ts

@@ -0,0 +1,55 @@
+import { type TenantContext } from "../../tenant/tenantContext";
+interface DurableEvent {
+    readonly id: string;
+    readonly name: string;
+    readonly version: number;
+    readonly tenantId: number | null;
+    readonly payload: unknown;
+}
+interface DurableListener {
+    readonly name: string;
+    readonly event: string;
+    handle(event: DurableEvent, context: {
+        signal: AbortSignal;
+    }): Promise<void>;
+}
+interface SqlOutboxOptions {
+    listeners: readonly DurableListener[];
+    leaseMs?: number;
+    maxAttempts?: number;
+    retryDelayMs?: number;
+    maxPayloadBytes?: number;
+    resolveTenant?: (id: number) => Promise<TenantContext | null>;
+}
+/** Opt-in SQL effects. Publishing writes only; workers execute listeners at least once. */
+declare class SqlOutbox {
+    private readonly listeners;
+    private readonly leaseMs;
+    private readonly maxAttempts;
+    private readonly retryDelayMs;
+    private readonly maxPayloadBytes;
+    private readonly tenantResolver;
+    constructor(options: SqlOutboxOptions);
+    hasListener(name: string, event?: string): boolean;
+    publish(name: string, payload: unknown, options?: {
+        id?: string;
+        version?: number;
+    }): Promise<string>;
+    private persist;
+    private claim;
+    private renew;
+    private finish;
+    processNext(options?: {
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    /** Stop admission on cancellation; handlers must observe the supplied signal to drain. */
+    work(options: {
+        signal: AbortSignal;
+        pollMs?: number;
+    }): Promise<void>;
+    /** Operator operation: retains the event and atomically makes one failed delivery eligible. */
+    replay(eventId: string, listenerName: string): Promise<void>;
+}
+export { createOutboxMigration } from "./migration";
+export type { DurableEvent, DurableListener, SqlOutboxOptions };
+export { SqlOutbox };

package/dist/core/events/outbox/migration.d.ts

@@ -0,0 +1,7 @@
+import type { Migration } from "../../database/migrations/types";
+import type { DatabaseDriver } from "../../database/schema/driver";
+/** Infrastructure tables belong to core; apps choose the file migration name and RLS mode. */
+declare function createOutboxMigration(name: string, driver: DatabaseDriver, options?: {
+    rls?: boolean;
+}): Migration;
+export { createOutboxMigration };

package/dist/core/http/requestMetaContext.d.ts

@@ -4,6 +4,8 @@ type RequestMeta = {
     request?: Request;
     /** Registered route template; never a URL supplied by the client. */
     routeTemplate?: string;
+    /** API error contracts take precedence over client content negotiation. */
+    errorFormat?: "json";
     flash?: {
         level: string;
         message: string;

package/dist/core/http/response.d.ts

@@ -6,4 +6,5 @@ declare function errorResponse(error: unknown): Response;
 declare function withErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
 declare function withJsonErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
 declare function createJsonErrorMiddleware(): Middleware;
-export { createdResponse, createJsonErrorMiddleware, errorResponse, jsonResponse, noContentResponse, withErrorHandling, withJsonErrorHandling, };
+declare function createWebErrorMiddleware(): Middleware;
+export { createdResponse, createJsonErrorMiddleware, createWebErrorMiddleware, errorResponse, jsonResponse, noContentResponse, withErrorHandling, withJsonErrorHandling, };

package/dist/core/openapi/registeredRoute.d.ts

@@ -1,6 +1,45 @@
+/** JSON Schema keywords remain extensible; metadata cannot contain executable values. */
+type OpenApiJson = null | boolean | number | string | OpenApiJson[] | {
+    [key: string]: OpenApiJson | undefined;
+};
+type OpenApiSchema = boolean | {
+    [keyword: string]: OpenApiJson | undefined;
+};
+interface OpenApiParameter {
+    name: string;
+    in: "header" | "query" | "path" | "cookie";
+    required?: boolean;
+    description?: string;
+    schema: OpenApiSchema;
+}
+interface OpenApiMediaType {
+    schema?: OpenApiSchema;
+    example?: OpenApiJson;
+}
+interface OpenApiResponse {
+    description: string;
+    content?: Record<string, OpenApiMediaType>;
+}
+interface OpenApiOperation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: string[];
+    deprecated?: boolean;
+    parameters?: OpenApiParameter[];
+    requestBody?: {
+        required?: boolean;
+        description?: string;
+        content: Record<string, OpenApiMediaType>;
+    };
+    responses?: Record<string, OpenApiResponse>;
+    security?: Array<Record<string, string[]>>;
+}
+type OpenApiRouteMap = Record<string, Partial<Record<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS", OpenApiOperation>>>;
 interface RegisteredRoute {
     method: string;
     path: string;
     middleware: string[];
+    openApi?: OpenApiOperation;
 }
-export type { RegisteredRoute };
+export type { OpenApiJson, OpenApiMediaType, OpenApiOperation, OpenApiParameter, OpenApiResponse, OpenApiRouteMap, OpenApiSchema, RegisteredRoute, };

package/dist/core/security/safeFetch.d.ts

@@ -1,5 +1,6 @@
 declare const DEFAULT_FETCH_TIMEOUT_MS = 10000;
 interface SafeFetchOptions {
+    /** One deadline covering DNS, redirects, headers, and response body consumption. */
     timeoutMs?: number;
     maxRedirects?: number;
     allowHttp?: boolean;

package/dist/entries/audit/exportAuditLogs.js

@@ -58,6 +58,24 @@ var init_tenantContext = __esm(() => {
 // ../../src/core/events/eventBus.ts
 class EventBus {
   constructor() {}
+  transactionalListeners = new Map;
+  listenTransactional(event, listener) {
+    const handlers = this.transactionalListeners.get(event) ?? new Set;
+    handlers.add(listener);
+    this.transactionalListeners.set(event, handlers);
+    return () => {
+      handlers.delete(listener);
+      if (!handlers.size)
+        this.transactionalListeners.delete(event);
+    };
+  }
+  hasTransactionalListeners(event) {
+    return (this.transactionalListeners.get(event)?.size ?? 0) > 0;
+  }
+  async dispatchTransactional(event, payload) {
+    for (const listener of this.transactionalListeners.get(event) ?? [])
+      await listener(payload);
+  }
   listeners = new Map;
   on(event, listener) {
     return this.listen(event, listener);
@@ -164,6 +182,7 @@ async function runWithTransactionScope(callback) {
 var TransactionRollback, transactionScopes;
 var init_transactionControl = __esm(() => {
   init_asyncContextStore();
+  init_connectionContext();
   TransactionRollback = class TransactionRollback extends Error {
     result;
     constructor(result) {
@@ -452,6 +471,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "NOW()";
     },
+    epochMillisecondsExpression() {
+      return "CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
     timestampValue(value) {
       return value.toISOString();
     },
@@ -490,6 +515,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "CURRENT_TIMESTAMP";
     },
+    epochMillisecondsExpression() {
+      return "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS UNSIGNED)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
     timestampValue(value) {
       return value.toISOString().slice(0, 19).replace("T", " ");
     },
@@ -528,6 +559,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
     },
+    epochMillisecondsExpression() {
+      return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+    },
+    rowLockClause() {
+      return "";
+    },
     timestampValue(value) {
       return value.toISOString();
     },
@@ -1077,50 +1114,133 @@ async function resolveSafeOutboundTarget(rawUrl, options = {}) {
 
 // ../../src/core/security/safeFetch.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+function untilAborted(work, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function preserveResponseMetadata(response, original) {
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type }
+  });
+  const clone = response.clone.bind(response);
+  response.clone = () => preserveResponseMetadata(clone(), original);
+  return response;
+}
+function withBodyDeadline(response, signal, release) {
+  if (!response.body) {
+    release();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let stopped = false;
+  let bodyController;
+  const stop = (reason, errorBody) => {
+    if (stopped)
+      return;
+    stopped = true;
+    release();
+    signal.removeEventListener("abort", onAbort);
+    if (errorBody)
+      bodyController.error(reason);
+    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
+  };
+  const onAbort = () => stop(signal.reason, true);
+  const body = new ReadableStream({
+    start(controller) {
+      bodyController = controller;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    },
+    async pull(controller) {
+      try {
+        const result = await untilAborted(reader.read(), signal);
+        if (stopped)
+          return;
+        if (result.done) {
+          stopped = true;
+          release();
+          signal.removeEventListener("abort", onAbort);
+          reader.releaseLock();
+          controller.close();
+        } else {
+          controller.enqueue(result.value);
+        }
+      } catch (error) {
+        stop(error, true);
+      }
+    },
+    cancel(reason) {
+      stop(reason, false);
+    }
+  }, { highWaterMark: 0 });
+  return preserveResponseMetadata(new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  }), response);
+}
 async function safeFetch(input, init = {}, options = {}) {
+  init.signal?.throwIfAborted();
   const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
+  }
   const maxRedirects = options.maxRedirects ?? 0;
-  const resolveDns = options.resolveDns ?? true;
   const urlOptions = {
     allowHttp: options.allowHttp,
-    resolveDns,
+    resolveDns: options.resolveDns ?? true,
     allowPrivate: options.allowPrivate
   };
   const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const forwardAbort = () => controller.abort(init.signal?.reason);
+  init.signal?.addEventListener("abort", forwardAbort, { once: true });
+  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  const release = () => {
+    clearTimeout(timeout);
+    init.signal?.removeEventListener("abort", forwardAbort);
+  };
   try {
-    let current = await resolveSafeOutboundTarget(input, urlOptions);
+    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
     let redirectCount = 0;
     while (true) {
+      controller.signal.throwIfAborted();
       const address = current.addresses[0];
       const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
       const headers = new Headers(init.headers);
-      if (address && !headers.has("host")) {
+      if (address && !headers.has("host"))
         headers.set("Host", current.url.host);
-      }
       const fetchInit = {
         ...init,
         headers,
         signal: controller.signal,
         redirect: "manual"
       };
-      if (address) {
+      if (address)
         fetchInit.tls = { serverName: current.url.hostname };
-      }
-      const response = await fetch(fetchUrl, fetchInit);
+      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
       if (response.status >= 300 && response.status < 400) {
         const location = response.headers.get("location");
-        if (!location || redirectCount >= maxRedirects) {
-          return response;
+        if (location && redirectCount < maxRedirects) {
+          if (response.body)
+            await untilAborted(response.body.cancel(), controller.signal);
+          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
+          redirectCount++;
+          continue;
         }
-        current = await resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions);
-        redirectCount += 1;
-        continue;
       }
-      return response;
+      return withBodyDeadline(response, controller.signal, release);
     }
-  } finally {
-    clearTimeout(timeout);
+  } catch (error) {
+    controller.abort(error);
+    release();
+    throw error;
   }
 }
 

package/dist/entries/auth/basicAuthGuard.js

@@ -171,6 +171,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "NOW()";
     },
+    epochMillisecondsExpression() {
+      return "CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
     timestampValue(value) {
       return value.toISOString();
     },
@@ -209,6 +215,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "CURRENT_TIMESTAMP";
     },
+    epochMillisecondsExpression() {
+      return "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS UNSIGNED)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
     timestampValue(value) {
       return value.toISOString().slice(0, 19).replace("T", " ");
     },
@@ -247,6 +259,12 @@ var init_dialect = __esm(() => {
     nowExpression() {
       return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
     },
+    epochMillisecondsExpression() {
+      return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+    },
+    rowLockClause() {
+      return "";
+    },
     timestampValue(value) {
       return value.toISOString();
     },

package/dist/entries/auth/oauth/oidcProvider.js

@@ -264,50 +264,133 @@ async function resolveSafeOutboundTarget(rawUrl, options = {}) {
 
 // ../../src/core/security/safeFetch.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+function untilAborted(work, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function preserveResponseMetadata(response, original) {
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type }
+  });
+  const clone = response.clone.bind(response);
+  response.clone = () => preserveResponseMetadata(clone(), original);
+  return response;
+}
+function withBodyDeadline(response, signal, release) {
+  if (!response.body) {
+    release();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let stopped = false;
+  let bodyController;
+  const stop = (reason, errorBody) => {
+    if (stopped)
+      return;
+    stopped = true;
+    release();
+    signal.removeEventListener("abort", onAbort);
+    if (errorBody)
+      bodyController.error(reason);
+    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
+  };
+  const onAbort = () => stop(signal.reason, true);
+  const body = new ReadableStream({
+    start(controller) {
+      bodyController = controller;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    },
+    async pull(controller) {
+      try {
+        const result = await untilAborted(reader.read(), signal);
+        if (stopped)
+          return;
+        if (result.done) {
+          stopped = true;
+          release();
+          signal.removeEventListener("abort", onAbort);
+          reader.releaseLock();
+          controller.close();
+        } else {
+          controller.enqueue(result.value);
+        }
+      } catch (error) {
+        stop(error, true);
+      }
+    },
+    cancel(reason) {
+      stop(reason, false);
+    }
+  }, { highWaterMark: 0 });
+  return preserveResponseMetadata(new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  }), response);
+}
 async function safeFetch(input, init = {}, options = {}) {
+  init.signal?.throwIfAborted();
   const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
+  }
   const maxRedirects = options.maxRedirects ?? 0;
-  const resolveDns = options.resolveDns ?? true;
   const urlOptions = {
     allowHttp: options.allowHttp,
-    resolveDns,
+    resolveDns: options.resolveDns ?? true,
     allowPrivate: options.allowPrivate
   };
   const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const forwardAbort = () => controller.abort(init.signal?.reason);
+  init.signal?.addEventListener("abort", forwardAbort, { once: true });
+  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  const release = () => {
+    clearTimeout(timeout);
+    init.signal?.removeEventListener("abort", forwardAbort);
+  };
   try {
-    let current = await resolveSafeOutboundTarget(input, urlOptions);
+    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
     let redirectCount = 0;
     while (true) {
+      controller.signal.throwIfAborted();
       const address = current.addresses[0];
       const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
       const headers = new Headers(init.headers);
-      if (address && !headers.has("host")) {
+      if (address && !headers.has("host"))
         headers.set("Host", current.url.host);
-      }
       const fetchInit = {
         ...init,
         headers,
         signal: controller.signal,
         redirect: "manual"
       };
-      if (address) {
+      if (address)
         fetchInit.tls = { serverName: current.url.hostname };
-      }
-      const response = await fetch(fetchUrl, fetchInit);
+      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
       if (response.status >= 300 && response.status < 400) {
         const location = response.headers.get("location");
-        if (!location || redirectCount >= maxRedirects) {
-          return response;
+        if (location && redirectCount < maxRedirects) {
+          if (response.body)
+            await untilAborted(response.body.cancel(), controller.signal);
+          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
+          redirectCount++;
+          continue;
         }
-        current = await resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions);
-        redirectCount += 1;
-        continue;
       }
-      return response;
+      return withBodyDeadline(response, controller.signal, release);
     }
-  } finally {
-    clearTimeout(timeout);
+  } catch (error) {
+    controller.abort(error);
+    release();
+    throw error;
   }
 }