@classytic/arc 2.23.0 → 2.25.0

package/dist/integrations/{jobs.mjs → jobs/index.mjs}

@@ -1,45 +1,53 @@
 import fp from "fastify-plugin";
-//#region src/integrations/jobs.ts
-/**
-* Define a background job with typed data and configuration.
-*
-* @example
-* const processImage = defineJob({
-*   name: 'process-image',
-*   handler: async (data: { url: string; width: number }) => {
-*     return await sharp(data.url).resize(data.width).toBuffer();
-*   },
-*   retries: 3,
-*   timeout: 60000,
-* });
-*/
-function defineJob(definition) {
-	return definition;
-}
-var Semaphore = class {
-	available;
-	waiters = [];
-	constructor(permits) {
-		this.available = permits;
-	}
-	get isFull() {
-		return this.available === 0;
-	}
-	acquire() {
-		if (this.available > 0) {
-			this.available--;
-			return Promise.resolve();
-		}
-		return new Promise((resolve) => {
-			this.waiters.push(resolve);
-		});
-	}
-	release() {
-		const next = this.waiters.shift();
-		if (next) next();
-		else this.available++;
+//#region src/integrations/jobs/execution.ts
+async function executeTimedHandler(options) {
+	const { run, label, jobId, timeoutMs, cancelGraceMs = 3e4, logger } = options;
+	let released = false;
+	const releaseSlot = () => {
+		if (released) return;
+		released = true;
+		options.releaseSlot?.();
+	};
+	const abort = new AbortController();
+	const handlerPromise = (async () => run(abort.signal))();
+	handlerPromise.then(releaseSlot, releaseSlot);
+	if (!timeoutMs) return handlerPromise;
+	let timer;
+	const timeoutPromise = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			const err = /* @__PURE__ */ new Error(`Job '${label}' timed out after ${timeoutMs}ms`);
+			abort.abort(err);
+			const timedOutAt = Date.now();
+			const graceTimer = setTimeout(() => {
+				logger?.warn({
+					job: label,
+					jobId,
+					graceMs: cancelGraceMs
+				}, "timed-out job handler still running after grace period — force-releasing its maxConcurrent slot (bulkhead may now be exceeded); make the handler honor its AbortSignal");
+				releaseSlot();
+			}, cancelGraceMs);
+			graceTimer.unref?.();
+			handlerPromise.then(() => logger?.warn({
+				job: label,
+				jobId,
+				afterMs: Date.now() - timedOutAt
+			}, "timed-out job handler eventually completed (result discarded)"), (handlerErr) => logger?.warn({
+				job: label,
+				jobId,
+				afterMs: Date.now() - timedOutAt,
+				err: handlerErr
+			}, "timed-out job handler eventually failed")).finally(() => clearTimeout(graceTimer));
+			reject(err);
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([handlerPromise, timeoutPromise]);
+	} finally {
+		clearTimeout(timer);
 	}
-};
+}
+//#endregion
+//#region src/integrations/jobs/repeat.ts
 /**
 * Whether an existing schedule matches the currently configured repeat spec.
 *
@@ -60,11 +68,6 @@ function repeatSpecMatches(record, spec) {
 * Remove repeatable schedules left behind by a previous deploy whose repeat
 * spec no longer matches the current `JobDefinition.repeat`.
 *
-* BullMQ keys repeatable schedules by a hash of their repeat options, so
-* re-adding a job with a CHANGED pattern/every/tz/endDate creates a NEW
-* schedule while the old one keeps firing — the job double-fires after every
-* repeat-config change. This reconciles at plugin registration:
-*
 *   - Only schedulers whose `name` equals the registered job's name are
 *     candidates — foreign/unknown schedulers are never touched.
 *   - A scheduler matching the current spec is kept (the subsequent
@@ -102,6 +105,32 @@ async function removeStaleRepeatSchedulers(queue, jobName, spec, log) {
 		}, `[arc/jobs] Failed to reconcile repeatable schedules for '${jobName}' — continuing (boot-time hygiene only)`);
 	}
 }
+//#endregion
+//#region src/integrations/jobs/plugin.ts
+var Semaphore = class {
+	available;
+	waiters = [];
+	constructor(permits) {
+		this.available = permits;
+	}
+	get isFull() {
+		return this.available === 0;
+	}
+	acquire() {
+		if (this.available > 0) {
+			this.available--;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			this.waiters.push(resolve);
+		});
+	}
+	release() {
+		const next = this.waiters.shift();
+		if (next) next();
+		else this.available++;
+	}
+};
 const jobsPluginImpl = async (fastify, options) => {
 	const { connection, jobs, prefix = "/jobs", bridgeEvents = true, defaults = {} } = options;
 	let Queue;
@@ -158,11 +187,6 @@ const jobsPluginImpl = async (fastify, options) => {
 		const throttledSet = /* @__PURE__ */ new Set();
 		throttledJobs.set(queueName, throttledSet);
 		const worker = new Worker(queueName, async (bullJob) => {
-			const meta = {
-				jobId: bullJob.id ?? "",
-				attemptsMade: bullJob.attemptsMade ?? 0,
-				timestamp: Date.now()
-			};
 			if (semaphore) {
 				if (semaphore.isFull) throttledSet.add(bullJob.id ?? "");
 				try {
@@ -171,22 +195,23 @@ const jobsPluginImpl = async (fastify, options) => {
 					throttledSet.delete(bullJob.id ?? "");
 				}
 			}
-			let result;
-			try {
-				if (jobTimeout) {
-					let timer;
-					const timeoutPromise = new Promise((_, reject) => {
-						timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Job '${queueName}' timed out after ${jobTimeout}ms`)), jobTimeout);
-					});
-					try {
-						result = await Promise.race([job.handler(bullJob.data, meta), timeoutPromise]);
-					} finally {
-						clearTimeout(timer);
-					}
-				} else result = await job.handler(bullJob.data, meta);
-			} finally {
-				semaphore?.release();
-			}
+			const result = await executeTimedHandler({
+				label: queueName,
+				...bullJob.id !== void 0 ? { jobId: bullJob.id } : {},
+				...jobTimeout !== void 0 ? { timeoutMs: jobTimeout } : {},
+				...job.cancelGraceMs !== void 0 ? { cancelGraceMs: job.cancelGraceMs } : {},
+				...semaphore ? { releaseSlot: () => semaphore.release() } : {},
+				logger: fastify.log,
+				run: (signal) => {
+					const meta = {
+						jobId: bullJob.id ?? "",
+						attemptsMade: bullJob.attemptsMade ?? 0,
+						timestamp: Date.now(),
+						signal
+					};
+					return job.handler(bullJob.data, meta);
+				}
+			});
 			if (bridgeEvents && fastify.events?.publish) try {
 				await fastify.events.publish(`job.${queueName}.completed`, {
 					jobId: bullJob.id,
@@ -366,4 +391,22 @@ const jobsPlugin = fp(jobsPluginImpl, {
 	fastify: "5.x"
 });
 //#endregion
-export { defineJob, jobsPlugin };
+//#region src/integrations/jobs/types.ts
+/**
+* Define a background job with typed data and configuration.
+*
+* @example
+* const processImage = defineJob({
+*   name: 'process-image',
+*   handler: async (data: { url: string; width: number }) => {
+*     return await sharp(data.url).resize(data.width).toBuffer();
+*   },
+*   retries: 3,
+*   timeout: 60000,
+* });
+*/
+function defineJob(definition) {
+	return definition;
+}
+//#endregion
+export { defineJob, executeTimedHandler, jobsPlugin };

package/dist/integrations/mcp/index.d.mts

@@ -1,8 +1,8 @@
-import { Rt as IControllerResponse, V as ResourceDefinition, Vt as ServerAccessor, zt as IRequestContext } from "../../index-BBsvQt7U.mjs";
-import { i as RequestScope } from "../../types-DH0GupI7.mjs";
-import { t as PermissionCheck } from "../../types-Csxga7d3.mjs";
+import { Rt as IControllerResponse, V as ResourceDefinition, Vt as ServerAccessor, zt as IRequestContext } from "../../index-DPRH0Cme.mjs";
+import { i as RequestScope } from "../../types-DjC-KUCz.mjs";
+import { t as PermissionCheck } from "../../types-Dmw-6Qeo.mjs";
 import { n as FieldPermissionMap } from "../../fields-D3lhgzhD.mjs";
-import { _ as ToolDefinition, a as CrudDescriptionOverride, c as McpAuthResult, d as McpResourceConfig, f as PromptDefinition, g as ToolContext, h as ToolAnnotations, i as CrudDescriptionMeta, l as McpExecutionWiring, m as SessionEntry, n as CallToolResult, o as CrudOperation, p as PromptResult, r as CreateMcpServerConfig, s as McpAuthResolver, t as BetterAuthHandler, u as McpPluginOptions } from "../../types-5OuqeTDX.mjs";
+import { _ as ToolDefinition, a as CrudDescriptionOverride, c as McpAuthResult, d as McpResourceConfig, f as PromptDefinition, g as ToolContext, h as ToolAnnotations, i as CrudDescriptionMeta, l as McpExecutionWiring, m as SessionEntry, n as CallToolResult, o as CrudOperation, p as PromptResult, r as CreateMcpServerConfig, s as McpAuthResolver, t as BetterAuthHandler, u as McpPluginOptions } from "../../types-QFGc3Cjv.mjs";
 import { ErrorContract } from "@classytic/repo-core/errors";
 import { FastifyPluginAsync } from "fastify";
 import { z } from "zod";

package/dist/integrations/mcp/index.mjs

@@ -1,4 +1,4 @@
-import { a as defaultCrudDescription, c as mcpHandlerAdapter, d as toCallToolResult, f as toCallToolSuccess, h as resolveToolCollisions, i as fieldRulesToZod, l as permissionDeniedResult, m as createMcpServer, n as mcpPlugin, o as resolveCrudDescription, p as buildRequestContext, r as resourceToTools, s as invokeController, t as filterResourcesForMcp, u as toCallToolError } from "../../mcpPlugin-BtzIL_kM.mjs";
+import { a as defaultCrudDescription, c as mcpHandlerAdapter, d as toCallToolResult, f as toCallToolSuccess, h as resolveToolCollisions, i as fieldRulesToZod, l as permissionDeniedResult, m as createMcpServer, n as mcpPlugin, o as resolveCrudDescription, p as buildRequestContext, r as resourceToTools, s as invokeController, t as filterResourcesForMcp, u as toCallToolError } from "../../mcpPlugin-Cb7olw0j.mjs";
 //#region src/integrations/mcp/defineTool.ts
 /**
 * Define a type-safe MCP tool.
@@ -206,7 +206,7 @@ function createMcpAuthFromBetterAuthApiKey(auth, options = {}) {
 			...userId ? { userId } : {},
 			...organizationId ? { organizationId } : {},
 			...clientId ? { clientId } : {},
-			...scopes && scopes.length ? { scopes } : {}
+			...scopes?.length ? { scopes } : {}
 		};
 	};
 }

package/dist/integrations/mcp/testing.d.mts

@@ -1,4 +1,4 @@
-import { c as McpAuthResult, u as McpPluginOptions } from "../../types-5OuqeTDX.mjs";
+import { c as McpAuthResult, u as McpPluginOptions } from "../../types-QFGc3Cjv.mjs";
 //#region src/integrations/mcp/testing.d.ts
 interface TestMcpClientOptions {
   /** MCP plugin options (resources, overrides, etc.) — same as mcpPlugin config */

package/dist/integrations/mcp/testing.mjs

@@ -1,4 +1,4 @@
-import { m as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-BtzIL_kM.mjs";
+import { m as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-Cb7olw0j.mjs";
 //#region src/integrations/mcp/testing.ts
 /**
 * @classytic/arc/mcp/testing — MCP Test Utilities

package/dist/integrations/webhooks.d.mts

@@ -19,6 +19,8 @@ interface WebhookDeliveryRecord {
   status?: number;
   error?: string;
   timestamp: Date;
+  /** Delivery attempts made (present when `retry` is configured). */
+  attempts?: number;
 }
 /** Pluggable persistence — memory for dev, bring your own DB for prod */
 interface WebhookStore {
@@ -42,6 +44,25 @@ interface WebhookPluginOptions {
    * (a zero would make the delivery loop spin forever without progress).
    */
   concurrency?: number;
+  /**
+   * In-process retry for failed deliveries. Default: single attempt.
+   * Retries fire on network errors, timeouts, 429 and 5xx — NOT on other
+   * 4xx (the receiver rejected the payload; repeating it can't succeed).
+   * Each attempt is re-signed with a fresh timestamp so the receiver's
+   * replay-tolerance window applies per attempt; `x-arc-webhook-delivery`
+   * stays constant, which is exactly what receiver-side dedup keys on.
+   *
+   * This is BEST-EFFORT: attempts live in this process, so a crash or
+   * deploy drops the remaining ones. Guaranteed delivery is a durable-job
+   * concern (queue keyed by subscription + delivery id) — pair the events
+   * outbox with a worker if you need it.
+   */
+  retry?: {
+    /** Total attempts including the first. Must be an integer >= 1. */
+    attempts: number;
+    /** Backoff before retry N, as `backoffMs * 2^(N-1)` ms (default: 1000). */
+    backoffMs?: number;
+  };
   /**
    * URL policy hook — the SSRF seam for tenant-registered URLs. Throw to
    * reject. Pass {@link defaultWebhookUrlPolicy} to require HTTPS and block
@@ -88,19 +109,6 @@ declare module "fastify" {
     webhooks: WebhookManager;
   }
 }
-/**
- * Sign a payload with HMAC-SHA256 for outbound webhook delivery.
- *
- * @deprecated LEGACY (pre-2.23) format — signs the BODY ONLY, so a captured
- * request can be replayed indefinitely and the event-id header is not
- * cryptographically bound to the body. Still emitted on the legacy
- * `x-webhook-signature` header for existing receivers; new receivers should
- * verify the v1 contract (`x-arc-webhook-signature`) via {@link verifyWebhook}.
- * Legacy emission is scheduled for removal in v3.
- *
- * @returns `sha256=<hex>` — the format written to `x-webhook-signature`
- */
-declare function signPayload(payload: string, secret: string): string;
 /**
  * Signed-string layout for the v1 webhook contract:
  *
@@ -185,15 +193,18 @@ interface VerifySignatureOptions {
   prefix?: string;
   /**
    * HMAC algorithm (default: `'sha256'`).
-   * Must match what the sender uses — Arc's `signPayload` always uses sha256.
+   * Must match what the sender uses.
    */
   algorithm?: string;
 }
 /**
- * Verify an inbound webhook signature using timing-safe comparison.
+ * Verify an INBOUND third-party webhook signature using timing-safe
+ * comparison — for webhooks arc RECEIVES (GitHub, Stripe, ...), not for
+ * arc-to-arc delivery. Arc's own outbound contract is v1
+ * (`x-arc-webhook-*`) — receivers of arc webhooks use {@link verifyWebhook}.
  *
- * Works with Arc's own `signPayload` format by default (`sha256=<hex>`),
- * but configurable for any HMAC scheme via options.
+ * Defaults to the common `sha256=<hex>` format; configurable for any HMAC
+ * scheme via options.
  *
  * ⚠ The `body` argument must be the exact bytes the sender signed. Fastify
  * parses JSON bodies by default and the re-serialised object will NOT match
@@ -211,21 +222,17 @@ interface VerifySignatureOptions {
  * ```typescript
  * import { verifySignature } from '@classytic/arc/integrations/webhooks';
  *
- * // Arc-to-Arc (default headers + format). `config: { rawBody: true }` is
- * // REQUIRED — arc registers fastify-raw-body with `global: false`, so
- * // routes opt in per-route; without it `req.rawBody` is undefined and
- * // verifySignature throws a TypeError.
- * fastify.post('/webhooks/incoming', { config: { rawBody: true } }, async (req, reply) => {
- *   const sig = req.headers['x-webhook-signature'] as string;
+ * // `config: { rawBody: true }` is REQUIRED — arc registers
+ * // fastify-raw-body with `global: false`, so routes opt in per-route;
+ * // without it `req.rawBody` is undefined and verifySignature throws a
+ * // TypeError.
+ *
+ * // GitHub-style sender (sha256=<hex>)
+ * fastify.post('/webhooks/github', { config: { rawBody: true } }, async (req, reply) => {
+ *   const sig = req.headers['x-hub-signature-256'] as string;
  *   if (!verifySignature(req.rawBody, secret, sig)) {
  *     return reply.status(401).send({ error: 'Invalid signature' });
  *   }
- *   // handle event via req.headers['x-webhook-event']
- * });
- *
- * // Third-party sender with custom header + bare hex
- * const valid = verifySignature(body, secret, req.headers['x-hub-signature'], {
- *   prefix: 'sha256=',  // GitHub format
  * });
  *
  * // Stripe-style (bare hex, different header)
@@ -238,4 +245,4 @@ declare function verifySignature(body: string | Buffer, secret: string, signatur
 declare const webhookPlugin: FastifyPluginAsync<WebhookPluginOptions>;
 declare const _default: FastifyPluginAsync<WebhookPluginOptions>;
 //#endregion
-export { VerifySignatureOptions, VerifyWebhookInput, VerifyWebhookResult, WebhookDeliveryRecord, WebhookManager, WebhookPluginOptions, WebhookStore, WebhookSubscription, WebhookSubscriptionPublic, _default as default, defaultWebhookUrlPolicy, signPayload, signWebhook, verifySignature, verifyWebhook, webhookPlugin };
+export { VerifySignatureOptions, VerifyWebhookInput, VerifyWebhookResult, WebhookDeliveryRecord, WebhookManager, WebhookPluginOptions, WebhookStore, WebhookSubscription, WebhookSubscriptionPublic, _default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookPlugin };

package/dist/integrations/webhooks.mjs

@@ -31,23 +31,6 @@ import fp from "fastify-plugin";
 * ```
 */
 /**
-* Sign a payload with HMAC-SHA256 for outbound webhook delivery.
-*
-* @deprecated LEGACY (pre-2.23) format — signs the BODY ONLY, so a captured
-* request can be replayed indefinitely and the event-id header is not
-* cryptographically bound to the body. Still emitted on the legacy
-* `x-webhook-signature` header for existing receivers; new receivers should
-* verify the v1 contract (`x-arc-webhook-signature`) via {@link verifyWebhook}.
-* Legacy emission is scheduled for removal in v3.
-*
-* @returns `sha256=<hex>` — the format written to `x-webhook-signature`
-*/
-function signPayload(payload, secret) {
-	const hmac = createHmac("sha256", secret);
-	hmac.update(payload);
-	return `sha256=${hmac.digest("hex")}`;
-}
-/**
 * Signed-string layout for the v1 webhook contract:
 *
 *     v1.<timestampMs>.<deliveryId>.<body>
@@ -162,10 +145,13 @@ function decodeMappedV4(host) {
 	return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
 }
 /**
-* Verify an inbound webhook signature using timing-safe comparison.
+* Verify an INBOUND third-party webhook signature using timing-safe
+* comparison — for webhooks arc RECEIVES (GitHub, Stripe, ...), not for
+* arc-to-arc delivery. Arc's own outbound contract is v1
+* (`x-arc-webhook-*`) — receivers of arc webhooks use {@link verifyWebhook}.
 *
-* Works with Arc's own `signPayload` format by default (`sha256=<hex>`),
-* but configurable for any HMAC scheme via options.
+* Defaults to the common `sha256=<hex>` format; configurable for any HMAC
+* scheme via options.
 *
 * ⚠ The `body` argument must be the exact bytes the sender signed. Fastify
 * parses JSON bodies by default and the re-serialised object will NOT match
@@ -183,21 +169,17 @@ function decodeMappedV4(host) {
 * ```typescript
 * import { verifySignature } from '@classytic/arc/integrations/webhooks';
 *
-* // Arc-to-Arc (default headers + format). `config: { rawBody: true }` is
-* // REQUIRED — arc registers fastify-raw-body with `global: false`, so
-* // routes opt in per-route; without it `req.rawBody` is undefined and
-* // verifySignature throws a TypeError.
-* fastify.post('/webhooks/incoming', { config: { rawBody: true } }, async (req, reply) => {
-*   const sig = req.headers['x-webhook-signature'] as string;
+* // `config: { rawBody: true }` is REQUIRED — arc registers
+* // fastify-raw-body with `global: false`, so routes opt in per-route;
+* // without it `req.rawBody` is undefined and verifySignature throws a
+* // TypeError.
+*
+* // GitHub-style sender (sha256=<hex>)
+* fastify.post('/webhooks/github', { config: { rawBody: true } }, async (req, reply) => {
+*   const sig = req.headers['x-hub-signature-256'] as string;
 *   if (!verifySignature(req.rawBody, secret, sig)) {
 *     return reply.status(401).send({ error: 'Invalid signature' });
 *   }
-*   // handle event via req.headers['x-webhook-event']
-* });
-*
-* // Third-party sender with custom header + bare hex
-* const valid = verifySignature(body, secret, req.headers['x-hub-signature'], {
-*   prefix: 'sha256=',  // GitHub format
 * });
 *
 * // Stripe-style (bare hex, different header)
@@ -255,6 +237,9 @@ const webhookPlugin = async (fastify, opts = {}) => {
 	const maxLogEntries = opts.maxLogEntries ?? 1e3;
 	const concurrency = opts.concurrency ?? 5;
 	if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error(`webhookPlugin: concurrency must be an integer >= 1 (got ${String(opts.concurrency)})`);
+	const retryAttempts = opts.retry?.attempts ?? 1;
+	const retryBackoffMs = opts.retry?.backoffMs ?? 1e3;
+	if (!Number.isInteger(retryAttempts) || retryAttempts < 1) throw new Error(`webhookPlugin: retry.attempts must be an integer >= 1 (got ${String(opts.retry?.attempts)})`);
 	let subscriptions = [];
 	const log = [];
 	subscriptions = await store.getAll();
@@ -287,38 +272,42 @@ const webhookPlugin = async (fastify, opts = {}) => {
 				success: false,
 				timestamp: /* @__PURE__ */ new Date()
 			};
-			try {
-				const timestamp = Date.now();
-				const v1Signature = signWebhook(body, sub.secret, {
-					timestamp,
-					deliveryId: event.meta.id
-				});
-				const legacySignature = signPayload(body, sub.secret);
-				const ac = new AbortController();
-				const timer = setTimeout(() => ac.abort(), timeout);
+			for (let attempt = 1; attempt <= retryAttempts; attempt++) {
+				record.attempts = attempt;
+				delete record.status;
+				delete record.error;
 				try {
-					const response = await fetchFn(sub.url, {
-						method: "POST",
-						headers: {
-							"content-type": "application/json",
-							"x-arc-webhook-signature": v1Signature,
-							"x-arc-webhook-timestamp": String(timestamp),
-							"x-arc-webhook-delivery": event.meta.id,
-							"x-webhook-signature": legacySignature,
-							"x-webhook-id": event.meta.id,
-							"x-webhook-event": event.type
-						},
-						body,
-						signal: ac.signal,
-						...opts.validateUrl ? { redirect: "manual" } : {}
+					const timestamp = Date.now();
+					const v1Signature = signWebhook(body, sub.secret, {
+						timestamp,
+						deliveryId: event.meta.id
 					});
-					record.success = response.ok;
-					record.status = response.status;
-				} finally {
-					clearTimeout(timer);
+					const ac = new AbortController();
+					const timer = setTimeout(() => ac.abort(), timeout);
+					try {
+						const response = await fetchFn(sub.url, {
+							method: "POST",
+							headers: {
+								"content-type": "application/json",
+								"x-arc-webhook-signature": v1Signature,
+								"x-arc-webhook-timestamp": String(timestamp),
+								"x-arc-webhook-delivery": event.meta.id
+							},
+							body,
+							signal: ac.signal,
+							...opts.validateUrl ? { redirect: "manual" } : {}
+						});
+						record.success = response.ok;
+						record.status = response.status;
+					} finally {
+						clearTimeout(timer);
+					}
+				} catch (err) {
+					record.error = err instanceof Error ? err.message : String(err);
 				}
-			} catch (err) {
-				record.error = err instanceof Error ? err.message : String(err);
+				if (record.success) break;
+				if (!(record.status === void 0 || record.status === 429 || record.status >= 500) || attempt === retryAttempts) break;
+				await new Promise((r) => setTimeout(r, retryBackoffMs * 2 ** (attempt - 1)));
 			}
 			log.push(record);
 			if (log.length > maxLogEntries) log.splice(0, log.length - maxLogEntries);
@@ -372,4 +361,4 @@ var webhooks_default = fp(webhookPlugin, {
 	dependencies: ["arc-events"]
 });
 //#endregion
-export { webhooks_default as default, defaultWebhookUrlPolicy, signPayload, signWebhook, verifySignature, verifyWebhook, webhookPlugin };
+export { webhooks_default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookPlugin };

package/dist/integrations/websocket-redis.d.mts

@@ -1,4 +1,4 @@
-import { f as WebSocketAdapter } from "../websocket-uuWqM6UY.mjs";
+import { f as WebSocketAdapter } from "../websocket-_Pd0CgR0.mjs";
 //#region src/integrations/websocket-redis.d.ts
 interface RedisLike {
   publish(channel: string, message: string): Promise<number>;

package/dist/integrations/websocket.d.mts

@@ -1,3 +1,3 @@
-import { a as GeoRoomOptions, c as WebSocketClient, d as LocalWebSocketAdapter, f as WebSocketAdapter, i as GeoRoom, l as WebSocketMessage, n as GeoPoint, o as RoomManager, r as GeoPublishOpts, s as AuthResult, t as websocketPlugin, u as WebSocketPluginOptions } from "../websocket-uuWqM6UY.mjs";
+import { a as GeoRoomOptions, c as WebSocketClient, d as LocalWebSocketAdapter, f as WebSocketAdapter, i as GeoRoom, l as WebSocketMessage, n as GeoPoint, o as RoomManager, r as GeoPublishOpts, s as AuthResult, t as websocketPlugin, u as WebSocketPluginOptions } from "../websocket-_Pd0CgR0.mjs";
 import { a as PushRefRegistry, c as SerializedEntry, i as Principal, o as PushRefRegistryOptions, r as MemoryPushRefStore, s as PushRefStore } from "../pushref-registry-BbcnpNTm.mjs";
 export { type AuthResult, type GeoPoint, type GeoPublishOpts, GeoRoom, type GeoRoomOptions, LocalWebSocketAdapter, MemoryPushRefStore, type Principal, PushRefRegistry, type PushRefRegistryOptions, type PushRefStore, RoomManager, type SerializedEntry, type WebSocketAdapter, type WebSocketClient, type WebSocketMessage, type WebSocketPluginOptions, websocketPlugin };