@chronos.sh/sdk 0.0.2-canary.fa8e22c → 0.1.0

package/dist/index.d.cts

@@ -6,8 +6,10 @@
 type ChronosHandlerResult = Record<string, unknown> | void;
 /**
  * Custom fetch implementation. Compatible with `globalThis.fetch`. Pass via
- * {@link ChronosOptions.fetch} to inject middleware (logging, tracing, custom
- * timeouts) or run in environments without a global `fetch`.
+ * {@link ChronosOptions.fetch} to inject middleware (logging, tracing) or run
+ * in environments without a global `fetch`. Implementations must forward
+ * `init.signal` to the underlying transport — dropping it disables the SDK's
+ * transport timeout and graceful abort.
  */
 type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
 /**
@@ -39,6 +41,15 @@ type ChronosOptions = {
    * 20 inclusive. Defaults to 20 (the API maximum).
    */
   pollWaitTimeSeconds?: number;
+  /**
+   * Per-request transport timeout in milliseconds, applied to every HTTP
+   * request the SDK makes. Requests exceeding it fail with
+   * `ChronosTimeoutError`. Long-poll claim requests get
+   * `pollWaitTimeSeconds * 1000` of extra headroom on top, so the
+   * intentional poll wait never counts against this bound. Must be a
+   * positive integer no greater than 2147483647. Defaults to 30000.
+   */
+  timeoutMs?: number;
   /**
    * Worker retry delay in milliseconds. Used between failed result-report
    * attempts and between poll-loop iterations after a claim error. Defaults
@@ -100,14 +111,21 @@ type WebhookOptions = {
 //#region src/client.d.ts
 /** Default Chronos API base URL. */
 declare const DEFAULT_BASE_URL = "https://api.chronos.sh";
+/** Default per-request transport timeout in milliseconds. */
+declare const DEFAULT_TIMEOUT_MS = 30000;
+type RequestOptions = {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+};
 declare class BaseClient {
   readonly apiKey: string;
   readonly baseUrl: string;
   readonly fetch: FetchLike;
   readonly logger: ChronosLogger;
+  readonly timeoutMs: number;
   private readonly headers;
   constructor(options: ChronosOptions);
-  request<T>(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<T>;
+  request<T>(path: string, body: Record<string, unknown>, options?: RequestOptions): Promise<T>;
 }
 //#endregion
 //#region src/worker.d.ts
@@ -162,8 +180,11 @@ declare class Worker {
    * in-flight handler that has not exceeded its timeout, along with the
    * subsequent result-report, is allowed to complete. Timed-out handlers
    * are abandoned (their {@link ChronosContext.signal} fires, but the SDK
-   * does not wait for them). Returns the same promise as the active
-   * {@link Worker.start}, or a resolved promise if the worker isn't running.
+   * does not wait for them). Every HTTP request is bounded by the `timeoutMs`
+   * transport timeout and retry waits are skipped once stop is requested, so
+   * the returned promise resolves in bounded time. Returns the same promise
+   * as the active {@link Worker.start}, or a resolved promise if the worker
+   * isn't running.
    */
   stop(): Promise<void>;
   private get isStopped();
@@ -238,7 +259,7 @@ type ChronosApiErrorOptions = {
   /** HTTP status code returned by the Chronos API. */status: number; /** Application-level error code from the response envelope, when present. */
   code?: string; /** Full parsed response payload (envelope + data, or whatever the server returned). */
   body?: unknown; /** Value of the `X-Request-Id` response header, when present. Pair with server logs. */
-  requestId?: string; /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 responses. */
+  requestId?: string; /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 and 5xx responses that include the header. */
   retryAfterSeconds?: number; /** Rate-limit budget from `X-RateLimit-*` headers. Present on non-429 responses. */
   rateLimit?: RateLimitInfo;
 };
@@ -247,7 +268,7 @@ type ChronosApiErrorOptions = {
  * `success: false` envelope. Carries HTTP `status`, the application
  * `code`, parsed `body`, the API's `X-Request-Id`, and — when the
  * relevant headers are present — rate-limit metadata
- * (`retryAfterSeconds` on 429, `rateLimit` on other errors).
+ * (`retryAfterSeconds` on 429 and 5xx, `rateLimit` on non-429 errors).
  *
  * `instanceof ChronosApiError` means the server replied;
  * network/transport failures throw {@link ChronosNetworkError} instead.
@@ -274,7 +295,7 @@ declare class ChronosApiError extends ChronosError {
   readonly body?: unknown;
   /** Value of the `X-Request-Id` response header, when present. */
   readonly requestId?: string;
-  /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 responses. */
+  /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 and 5xx responses that include the header. */
   readonly retryAfterSeconds?: number;
   /** Rate-limit budget from `X-RateLimit-*` headers. Present on non-429 responses. */
   readonly rateLimit?: RateLimitInfo;
@@ -301,12 +322,14 @@ declare class ChronosRateLimitError extends ChronosApiError {
   constructor(message: string, options: ChronosApiErrorOptions);
 }
 /**
- * Thrown when the underlying `fetch` rejects before the server replies —
- * DNS failure, TCP reset, connection refused, etc. The original error is
- * available on `.cause`.
+ * Thrown when a request fails at the transport layer — DNS failure, TCP
+ * reset, connection refused, or a connection dropped mid-response. The
+ * original error is available on `.cause`.
  *
- * Abort signals propagate unwrapped — `instanceof ChronosNetworkError`
- * always means a real transport failure, not a graceful shutdown.
+ * Caller-supplied abort signals propagate unwrapped — `instanceof
+ * ChronosNetworkError` always means a transport failure, not a graceful
+ * shutdown. The SDK's own transport timeout throws the
+ * {@link ChronosTimeoutError} subclass.
  *
  * @example
  * ```ts
@@ -326,6 +349,28 @@ declare class ChronosNetworkError extends ChronosError {
     cause: unknown;
   });
 }
+/**
+ * Thrown when an HTTP request exceeds the configured `timeoutMs` before the
+ * response completes. Subclass of {@link ChronosNetworkError}, so generic
+ * transport-failure handling catches it; the underlying rejection is on
+ * `.cause`.
+ *
+ * @example
+ * ```ts
+ * import { ChronosTimeoutError } from '@chronos.sh/sdk';
+ *
+ * function handleSdkError(err: unknown) {
+ *   if (err instanceof ChronosTimeoutError) {
+ *     console.warn('Chronos request timed out', err.message);
+ *   }
+ * }
+ * ```
+ */
+declare class ChronosTimeoutError extends ChronosNetworkError {
+  constructor(message: string, options: {
+    cause: unknown;
+  });
+}
 /**
  * Wraps an exception thrown by a user-supplied {@link ChronosHandler}. The
  * original error is on `.cause`; `.message` is copied from the original so
@@ -443,5 +488,5 @@ declare class Chronos {
   constructor(options: ChronosOptions);
 }
 //#endregion
-export { Chronos, ChronosApiError, type ChronosApiErrorOptions, ChronosConfigError, type ChronosContext, ChronosError, type ChronosHandler, ChronosHandlerError, type ChronosHandlerResult, type ChronosLogger, ChronosNetworkError, type ChronosOptions, ChronosRateLimitError, type ChronosSchedule, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, type FetchLike, type RateLimitInfo, SDK_VERSION, Webhook, type WebhookOptions };
+export { Chronos, ChronosApiError, type ChronosApiErrorOptions, ChronosConfigError, type ChronosContext, ChronosError, type ChronosHandler, ChronosHandlerError, type ChronosHandlerResult, type ChronosLogger, ChronosNetworkError, type ChronosOptions, ChronosRateLimitError, type ChronosSchedule, ChronosTimeoutError, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMEOUT_MS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, type FetchLike, type RateLimitInfo, SDK_VERSION, Webhook, type WebhookOptions };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -6,8 +6,10 @@
 type ChronosHandlerResult = Record<string, unknown> | void;
 /**
  * Custom fetch implementation. Compatible with `globalThis.fetch`. Pass via
- * {@link ChronosOptions.fetch} to inject middleware (logging, tracing, custom
- * timeouts) or run in environments without a global `fetch`.
+ * {@link ChronosOptions.fetch} to inject middleware (logging, tracing) or run
+ * in environments without a global `fetch`. Implementations must forward
+ * `init.signal` to the underlying transport — dropping it disables the SDK's
+ * transport timeout and graceful abort.
  */
 type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
 /**
@@ -39,6 +41,15 @@ type ChronosOptions = {
    * 20 inclusive. Defaults to 20 (the API maximum).
    */
   pollWaitTimeSeconds?: number;
+  /**
+   * Per-request transport timeout in milliseconds, applied to every HTTP
+   * request the SDK makes. Requests exceeding it fail with
+   * `ChronosTimeoutError`. Long-poll claim requests get
+   * `pollWaitTimeSeconds * 1000` of extra headroom on top, so the
+   * intentional poll wait never counts against this bound. Must be a
+   * positive integer no greater than 2147483647. Defaults to 30000.
+   */
+  timeoutMs?: number;
   /**
    * Worker retry delay in milliseconds. Used between failed result-report
    * attempts and between poll-loop iterations after a claim error. Defaults
@@ -100,14 +111,21 @@ type WebhookOptions = {
 //#region src/client.d.ts
 /** Default Chronos API base URL. */
 declare const DEFAULT_BASE_URL = "https://api.chronos.sh";
+/** Default per-request transport timeout in milliseconds. */
+declare const DEFAULT_TIMEOUT_MS = 30000;
+type RequestOptions = {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+};
 declare class BaseClient {
   readonly apiKey: string;
   readonly baseUrl: string;
   readonly fetch: FetchLike;
   readonly logger: ChronosLogger;
+  readonly timeoutMs: number;
   private readonly headers;
   constructor(options: ChronosOptions);
-  request<T>(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<T>;
+  request<T>(path: string, body: Record<string, unknown>, options?: RequestOptions): Promise<T>;
 }
 //#endregion
 //#region src/worker.d.ts
@@ -162,8 +180,11 @@ declare class Worker {
    * in-flight handler that has not exceeded its timeout, along with the
    * subsequent result-report, is allowed to complete. Timed-out handlers
    * are abandoned (their {@link ChronosContext.signal} fires, but the SDK
-   * does not wait for them). Returns the same promise as the active
-   * {@link Worker.start}, or a resolved promise if the worker isn't running.
+   * does not wait for them). Every HTTP request is bounded by the `timeoutMs`
+   * transport timeout and retry waits are skipped once stop is requested, so
+   * the returned promise resolves in bounded time. Returns the same promise
+   * as the active {@link Worker.start}, or a resolved promise if the worker
+   * isn't running.
    */
   stop(): Promise<void>;
   private get isStopped();
@@ -238,7 +259,7 @@ type ChronosApiErrorOptions = {
   /** HTTP status code returned by the Chronos API. */status: number; /** Application-level error code from the response envelope, when present. */
   code?: string; /** Full parsed response payload (envelope + data, or whatever the server returned). */
   body?: unknown; /** Value of the `X-Request-Id` response header, when present. Pair with server logs. */
-  requestId?: string; /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 responses. */
+  requestId?: string; /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 and 5xx responses that include the header. */
   retryAfterSeconds?: number; /** Rate-limit budget from `X-RateLimit-*` headers. Present on non-429 responses. */
   rateLimit?: RateLimitInfo;
 };
@@ -247,7 +268,7 @@ type ChronosApiErrorOptions = {
  * `success: false` envelope. Carries HTTP `status`, the application
  * `code`, parsed `body`, the API's `X-Request-Id`, and — when the
  * relevant headers are present — rate-limit metadata
- * (`retryAfterSeconds` on 429, `rateLimit` on other errors).
+ * (`retryAfterSeconds` on 429 and 5xx, `rateLimit` on non-429 errors).
  *
  * `instanceof ChronosApiError` means the server replied;
  * network/transport failures throw {@link ChronosNetworkError} instead.
@@ -274,7 +295,7 @@ declare class ChronosApiError extends ChronosError {
   readonly body?: unknown;
   /** Value of the `X-Request-Id` response header, when present. */
   readonly requestId?: string;
-  /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 responses. */
+  /** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 and 5xx responses that include the header. */
   readonly retryAfterSeconds?: number;
   /** Rate-limit budget from `X-RateLimit-*` headers. Present on non-429 responses. */
   readonly rateLimit?: RateLimitInfo;
@@ -301,12 +322,14 @@ declare class ChronosRateLimitError extends ChronosApiError {
   constructor(message: string, options: ChronosApiErrorOptions);
 }
 /**
- * Thrown when the underlying `fetch` rejects before the server replies —
- * DNS failure, TCP reset, connection refused, etc. The original error is
- * available on `.cause`.
+ * Thrown when a request fails at the transport layer — DNS failure, TCP
+ * reset, connection refused, or a connection dropped mid-response. The
+ * original error is available on `.cause`.
  *
- * Abort signals propagate unwrapped — `instanceof ChronosNetworkError`
- * always means a real transport failure, not a graceful shutdown.
+ * Caller-supplied abort signals propagate unwrapped — `instanceof
+ * ChronosNetworkError` always means a transport failure, not a graceful
+ * shutdown. The SDK's own transport timeout throws the
+ * {@link ChronosTimeoutError} subclass.
  *
  * @example
  * ```ts
@@ -326,6 +349,28 @@ declare class ChronosNetworkError extends ChronosError {
     cause: unknown;
   });
 }
+/**
+ * Thrown when an HTTP request exceeds the configured `timeoutMs` before the
+ * response completes. Subclass of {@link ChronosNetworkError}, so generic
+ * transport-failure handling catches it; the underlying rejection is on
+ * `.cause`.
+ *
+ * @example
+ * ```ts
+ * import { ChronosTimeoutError } from '@chronos.sh/sdk';
+ *
+ * function handleSdkError(err: unknown) {
+ *   if (err instanceof ChronosTimeoutError) {
+ *     console.warn('Chronos request timed out', err.message);
+ *   }
+ * }
+ * ```
+ */
+declare class ChronosTimeoutError extends ChronosNetworkError {
+  constructor(message: string, options: {
+    cause: unknown;
+  });
+}
 /**
  * Wraps an exception thrown by a user-supplied {@link ChronosHandler}. The
  * original error is on `.cause`; `.message` is copied from the original so
@@ -443,5 +488,5 @@ declare class Chronos {
   constructor(options: ChronosOptions);
 }
 //#endregion
-export { Chronos, ChronosApiError, type ChronosApiErrorOptions, ChronosConfigError, type ChronosContext, ChronosError, type ChronosHandler, ChronosHandlerError, type ChronosHandlerResult, type ChronosLogger, ChronosNetworkError, type ChronosOptions, ChronosRateLimitError, type ChronosSchedule, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, type FetchLike, type RateLimitInfo, SDK_VERSION, Webhook, type WebhookOptions };
+export { Chronos, ChronosApiError, type ChronosApiErrorOptions, ChronosConfigError, type ChronosContext, ChronosError, type ChronosHandler, ChronosHandlerError, type ChronosHandlerResult, type ChronosLogger, ChronosNetworkError, type ChronosOptions, ChronosRateLimitError, type ChronosSchedule, ChronosTimeoutError, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMEOUT_MS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, type FetchLike, type RateLimitInfo, SDK_VERSION, Webhook, type WebhookOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -57,7 +57,7 @@ var ChronosConfigError = class extends ChronosError {
 * `success: false` envelope. Carries HTTP `status`, the application
 * `code`, parsed `body`, the API's `X-Request-Id`, and — when the
 * relevant headers are present — rate-limit metadata
-* (`retryAfterSeconds` on 429, `rateLimit` on other errors).
+* (`retryAfterSeconds` on 429 and 5xx, `rateLimit` on non-429 errors).
 *
 * `instanceof ChronosApiError` means the server replied;
 * network/transport failures throw {@link ChronosNetworkError} instead.
@@ -84,7 +84,7 @@ var ChronosApiError = class extends ChronosError {
 	body;
 	/** Value of the `X-Request-Id` response header, when present. */
 	requestId;
-	/** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 responses. */
+	/** Seconds to wait before retrying, from the `Retry-After` response header. Present on 429 and 5xx responses that include the header. */
 	retryAfterSeconds;
 	/** Rate-limit budget from `X-RateLimit-*` headers. Present on non-429 responses. */
 	rateLimit;
@@ -123,12 +123,14 @@ var ChronosRateLimitError = class extends ChronosApiError {
 	}
 };
 /**
-* Thrown when the underlying `fetch` rejects before the server replies —
-* DNS failure, TCP reset, connection refused, etc. The original error is
-* available on `.cause`.
+* Thrown when a request fails at the transport layer — DNS failure, TCP
+* reset, connection refused, or a connection dropped mid-response. The
+* original error is available on `.cause`.
 *
-* Abort signals propagate unwrapped — `instanceof ChronosNetworkError`
-* always means a real transport failure, not a graceful shutdown.
+* Caller-supplied abort signals propagate unwrapped — `instanceof
+* ChronosNetworkError` always means a transport failure, not a graceful
+* shutdown. The SDK's own transport timeout throws the
+* {@link ChronosTimeoutError} subclass.
 *
 * @example
 * ```ts
@@ -148,6 +150,29 @@ var ChronosNetworkError = class extends ChronosError {
 	}
 };
 /**
+* Thrown when an HTTP request exceeds the configured `timeoutMs` before the
+* response completes. Subclass of {@link ChronosNetworkError}, so generic
+* transport-failure handling catches it; the underlying rejection is on
+* `.cause`.
+*
+* @example
+* ```ts
+* import { ChronosTimeoutError } from '@chronos.sh/sdk';
+*
+* function handleSdkError(err: unknown) {
+*   if (err instanceof ChronosTimeoutError) {
+*     console.warn('Chronos request timed out', err.message);
+*   }
+* }
+* ```
+*/
+var ChronosTimeoutError = class extends ChronosNetworkError {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ChronosTimeoutError";
+	}
+};
+/**
 * Wraps an exception thrown by a user-supplied {@link ChronosHandler}. The
 * original error is on `.cause`; `.message` is copied from the original so
 * the SDK reports it to the API as the failure reason.
@@ -215,6 +240,10 @@ function validatePollWaitTime(seconds) {
 function validateRetryDelayMs(ms) {
 	if (!Number.isFinite(ms) || ms < 0) throw new ChronosConfigError("retryDelayMs must be a non-negative number");
 }
+const MAX_TIMEOUT_MS = 2147483647;
+function validateTimeoutMs(ms) {
+	if (!Number.isInteger(ms) || ms <= 0 || ms > 2147483647) throw new ChronosConfigError(`timeoutMs must be a positive integer no greater than ${MAX_TIMEOUT_MS}`);
+}
 function validateWorkerId(id) {
 	const trimmed = id.trim();
 	if (trimmed.length === 0 || trimmed.length > 255) throw new ChronosConfigError("workerId must be 1-255 characters");
@@ -230,64 +259,92 @@ function normalizeHandlerName(name) {
 //#region src/client.ts
 /** Default Chronos API base URL. */
 const DEFAULT_BASE_URL = "https://api.chronos.sh";
+/** Default per-request transport timeout in milliseconds. */
+const DEFAULT_TIMEOUT_MS = 3e4;
 var BaseClient = class {
 	apiKey;
 	baseUrl;
 	fetch;
 	logger;
+	timeoutMs;
 	headers;
 	constructor(options) {
 		this.apiKey = validateApiKey(options.apiKey);
 		this.baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://api.chronos.sh");
 		this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
 		this.logger = options.logger ?? defaultLogger;
+		this.timeoutMs = options.timeoutMs ?? 3e4;
+		validateTimeoutMs(this.timeoutMs);
 		this.headers = {
 			"content-type": "application/json",
 			authorization: `Bearer ${this.apiKey}`
 		};
 	}
-	async request(path, body, signal) {
-		let response;
+	async request(path, body, options = {}) {
+		const { signal } = options;
+		const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+		const controller = new AbortController();
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			if (controller.signal.aborted) return;
+			timedOut = true;
+			controller.abort(new DOMException(`Chronos API request timed out after ${timeoutMs}ms`, "TimeoutError"));
+		}, timeoutMs);
+		const onCallerAbort = () => controller.abort(signal?.reason);
+		if (signal?.aborted) onCallerAbort();
+		else signal?.addEventListener("abort", onCallerAbort, { once: true });
 		try {
-			response = await this.fetch(`${this.baseUrl}${path}`, {
-				method: "POST",
-				headers: this.headers,
-				body: JSON.stringify(body),
-				signal
-			});
-		} catch (err) {
-			if (signal?.aborted) throw err;
-			throw new ChronosNetworkError(`Chronos API request failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-		}
-		const payload = await parseJsonResponse(response);
-		const envelope = isEnvelope(payload) ? payload : void 0;
-		if (!response.ok || envelope && !envelope.success) {
-			const is429 = response.status === 429;
-			throw new (is429 ? ChronosRateLimitError : ChronosApiError)(apiErrorMessage(response, envelope), {
-				status: response.status,
-				code: typeof envelope?.code === "string" ? envelope.code : void 0,
-				body: payload,
-				requestId: response.headers.get("x-request-id") ?? void 0,
-				retryAfterSeconds: is429 ? parseIntHeader(response.headers, "retry-after") : void 0,
-				rateLimit: is429 ? void 0 : parseRateLimitHeaders(response.headers)
-			});
+			let response;
+			try {
+				response = await this.fetch(`${this.baseUrl}${path}`, {
+					method: "POST",
+					headers: this.headers,
+					body: JSON.stringify(body),
+					signal: controller.signal
+				});
+			} catch (err) {
+				if (signal?.aborted && !timedOut) throw err;
+				if (timedOut) throw timeoutError(timeoutMs, err);
+				throw new ChronosNetworkError(`Chronos API request failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+			}
+			let payload;
+			try {
+				payload = await response.json();
+			} catch (err) {
+				if (signal?.aborted && !timedOut) throw err;
+				if (timedOut) throw timeoutError(timeoutMs, err);
+				if (err instanceof SyntaxError) payload = null;
+				else throw new ChronosNetworkError(`Chronos API response failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+			}
+			const envelope = isEnvelope(payload) ? payload : void 0;
+			if (!response.ok || envelope && !envelope.success) {
+				const is429 = response.status === 429;
+				const retryAfterApplies = is429 || response.status >= 500;
+				throw new (is429 ? ChronosRateLimitError : ChronosApiError)(apiErrorMessage(response, envelope), {
+					status: response.status,
+					code: typeof envelope?.code === "string" ? envelope.code : void 0,
+					body: payload,
+					requestId: response.headers.get("x-request-id") ?? void 0,
+					retryAfterSeconds: retryAfterApplies ? parseIntHeader(response.headers, "retry-after") : void 0,
+					rateLimit: is429 ? void 0 : parseRateLimitHeaders(response.headers)
+				});
+			}
+			if (!envelope) throw new ChronosError("Chronos API returned an invalid response");
+			return envelope.data;
+		} finally {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onCallerAbort);
 		}
-		if (!envelope) throw new ChronosError("Chronos API returned an invalid response");
-		return envelope.data;
 	}
 };
+function timeoutError(timeoutMs, cause) {
+	return new ChronosTimeoutError(`Chronos API request timed out after ${timeoutMs}ms`, { cause });
+}
 function normalizeBaseUrl(baseUrl) {
 	const normalized = baseUrl.trim().replace(/\/+$/, "");
 	if (!normalized) throw new ChronosConfigError("Chronos baseUrl is required");
 	return normalized;
 }
-async function parseJsonResponse(response) {
-	try {
-		return await response.json();
-	} catch {
-		return null;
-	}
-}
 function apiErrorMessage(response, envelope) {
 	if (typeof envelope?.message === "string" && envelope.message.trim()) return envelope.message;
 	return response.ok ? "Chronos API returned an invalid response" : `Chronos API request failed with status ${response.status}`;
@@ -315,7 +372,7 @@ function isEnvelope(value) {
 //#endregion
 //#region src/internal/id.ts
 function generateWorkerId() {
-	const bytes = crypto.getRandomValues(new Uint8Array(8));
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8));
 	let hex = "";
 	for (const b of bytes) hex += b.toString(16).padStart(2, "0");
 	return `w_${hex}`;
@@ -331,12 +388,13 @@ function detectRuntime() {
 }
 //#endregion
 //#region src/internal/version.ts
-const SDK_VERSION = "0.0.2-canary.fa8e22c";
+const SDK_VERSION = "0.1.0";
 //#endregion
 //#region src/worker.ts
 /** Default worker long-poll wait time in seconds. Equal to the API maximum. */
 const DEFAULT_POLL_WAIT_TIME_SECONDS = 20;
 const DEFAULT_RETRY_DELAY_MS = 1e3;
+const MAX_RETRY_AFTER_MS = 6e4;
 const RESULT_REPORT_MAX_ATTEMPTS = 3;
 const MAX_REPORTED_ERROR_LENGTH = 4096;
 const DEFAULT_HANDLER_ERROR = "Chronos handler failed";
@@ -414,8 +472,11 @@ var Worker = class {
 	* in-flight handler that has not exceeded its timeout, along with the
 	* subsequent result-report, is allowed to complete. Timed-out handlers
 	* are abandoned (their {@link ChronosContext.signal} fires, but the SDK
-	* does not wait for them). Returns the same promise as the active
-	* {@link Worker.start}, or a resolved promise if the worker isn't running.
+	* does not wait for them). Every HTTP request is bounded by the `timeoutMs`
+	* transport timeout and retry waits are skipped once stop is requested, so
+	* the returned promise resolves in bounded time. Returns the same promise
+	* as the active {@link Worker.start}, or a resolved promise if the worker
+	* isn't running.
 	*/
 	stop() {
 		this.pollController?.abort();
@@ -436,7 +497,7 @@ var Worker = class {
 	}
 	async claimJob() {
 		if (this.handlerNames.length === 0) throw new ChronosError("Cannot claim jobs without registered handlers");
-		return this.client.request("/v1/worker/jobs/claim", {
+		return this.client.request("/v1/workers/jobs/claim", {
 			wait_time_seconds: this.pollWaitTimeSeconds,
 			handlers: this.handlerNames,
 			worker: {
@@ -445,7 +506,10 @@ var Worker = class {
 				runtime: this.runtime,
 				uptime_ms: Math.round(performance.now() - this.startedAt)
 			}
-		}, this.pollController?.signal);
+		}, {
+			signal: this.pollController?.signal,
+			timeoutMs: Math.min(this.pollWaitTimeSeconds * 1e3 + this.client.timeoutMs, MAX_TIMEOUT_MS)
+		});
 	}
 	async processJob(job) {
 		const handler = this.handlers.get(job.handler);
@@ -540,7 +604,7 @@ var Worker = class {
 	async reportResultWithRetry(executionId, body) {
 		let lastErr;
 		for (let attempt = 1; attempt <= RESULT_REPORT_MAX_ATTEMPTS; attempt++) try {
-			await this.client.request(`/v1/worker/executions/${encodeURIComponent(executionId)}/result`, body);
+			await this.client.request(`/v1/workers/executions/${encodeURIComponent(executionId)}/result`, body);
 			return;
 		} catch (err) {
 			const apiErr = err instanceof ChronosApiError ? err : void 0;
@@ -562,7 +626,7 @@ var Worker = class {
 				attempt,
 				maxAttempts: RESULT_REPORT_MAX_ATTEMPTS
 			});
-			await sleep(retryDelayFor(err, this.retryDelayMs));
+			await sleep(retryDelayFor(err, this.retryDelayMs), this.pollController?.signal);
 		}
 		throw lastErr;
 	}
@@ -638,10 +702,10 @@ function truncate(value, maxLength) {
 	return value.length <= maxLength ? value : value.slice(0, maxLength);
 }
 function retryDelayFor(err, fallbackMs) {
-	if (err instanceof ChronosApiError && err.retryAfterSeconds !== void 0) return err.retryAfterSeconds * 1e3;
+	if (err instanceof ChronosApiError && err.retryAfterSeconds !== void 0) return Math.max(Math.min(err.retryAfterSeconds * 1e3, MAX_RETRY_AFTER_MS), fallbackMs);
 	return fallbackMs;
 }
-const NON_TERMINAL_4XX = new Set([
+const NON_TERMINAL_4XX = /* @__PURE__ */ new Set([
 	408,
 	409,
 	429
@@ -814,6 +878,6 @@ var Chronos = class {
 	}
 };
 //#endregion
-export { Chronos, ChronosApiError, ChronosConfigError, ChronosError, ChronosHandlerError, ChronosNetworkError, ChronosRateLimitError, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, SDK_VERSION, Webhook };
+export { Chronos, ChronosApiError, ChronosConfigError, ChronosError, ChronosHandlerError, ChronosNetworkError, ChronosRateLimitError, ChronosTimeoutError, ChronosWebhookVerificationError, DEFAULT_BASE_URL, DEFAULT_POLL_WAIT_TIME_SECONDS, DEFAULT_TIMEOUT_MS, DEFAULT_TIMESTAMP_TOLERANCE_SECONDS, SDK_VERSION, Webhook };
 
 //# sourceMappingURL=index.js.map