@classytic/arc 2.31.0 → 2.33.0

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

@@ -1,9 +1,9 @@
 
-import { Ht as ServerAccessor, Rt as IControllerResponse, V as ResourceDefinition, zt as IRequestContext } from "../../index-CpzxqePp.mjs";
 import { i as RequestScope } from "../../types-ChuShpCP.mjs";
-import { r as PermissionCheck } from "../../types-B7XeLEgK.mjs";
+import { l as PermissionCheck } from "../../base-Csjc2oF-.mjs";
+import { Fn as IControllerResponse, In as IRequestContext, V as ResourceDefinition, zn as ServerAccessor } from "../../index-BcR2bFZQ.mjs";
 import { n as FieldPermissionMap } from "../../fields-I_EeRWND.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-CwcUQ610.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-BfC83KsP.mjs";
 import { ErrorContract } from "@classytic/repo-core/errors";
 import { FastifyPluginAsync } from "fastify";
 import { z } from "zod";
@@ -222,6 +222,15 @@ interface FieldRulesToZodOptions {
   filterableFields?: readonly string[];
   /** Allowed filter operators — generates `field[op]` entries in list mode (e.g., price[gt], price[lte]) */
   allowedOperators?: readonly string[];
+  /**
+   * The resource's page-size cap, for the `limit` field's `max` AND its description.
+   *
+   * Defaults to 100 only when the resource states nothing. Hardcoding 100 here made
+   * MCP a FOURTH independent cap: a resource configured for 1000 exposed a tool that
+   * rejected `limit: 500` outright and told the agent "max 100" — so the model was
+   * misinformed about the ceiling, not merely limited by it.
+   */
+  maxLimit?: number;
 }
 /** Single field rule entry from Arc's schemaOptions.fieldRules */
 interface FieldRuleEntry {

package/dist/integrations/mcp/index.mjs

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-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-B_es0hiF.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+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-aJg5TqHi.mjs";
 //#region src/integrations/mcp/defineTool.ts
 /**
 * Define a type-safe MCP tool.

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

@@ -1,5 +1,5 @@
 
-import { c as McpAuthResult, u as McpPluginOptions } from "../../types-CwcUQ610.mjs";
+import { c as McpAuthResult, u as McpPluginOptions } from "../../types-BfC83KsP.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,5 +1,5 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-import { m as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-B_es0hiF.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { m as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-aJg5TqHi.mjs";
 //#region src/integrations/mcp/testing.ts
 /**
 * @classytic/arc/mcp/testing — MCP Test Utilities

package/dist/integrations/streamline.mjs

@@ -1,6 +1,6 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-import { f as createError, i as NotFoundError, r as ForbiddenError } from "../errors-Cj42AntO.mjs";
-import { a as promoteStreamTokenToHeader, n as forwardedStreamHeaders } from "../streaming-PSZwi8JV.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { f as createError, i as NotFoundError, r as ForbiddenError } from "../errors-Cd_yy7aW.mjs";
+import { a as promoteStreamTokenToHeader, n as forwardedStreamHeaders } from "../streaming-DsT1B5zJ.mjs";
 import fp from "fastify-plugin";
 //#region src/integrations/streamline.ts
 /**

package/dist/integrations/webhooks.d.mts

@@ -1,5 +1,8 @@
 
+import { a as EventTransport, n as DomainEvent } from "../EventTransport-BEVP50ka.mjs";
+import { n as OutboxModuleOptions, r as createOutboxModule } from "../outbox-module-D-VFq37T.mjs";
 import { FastifyPluginAsync } from "fastify";
+import { OutboxFailurePolicy, OutboxStore } from "@classytic/primitives/outbox";
 //#region src/integrations/webhooks.d.ts
 interface WebhookSubscription {
   /** Unique subscription ID */
@@ -86,6 +89,23 @@ interface WebhookPluginOptions {
    * framework.
    */
   validateUrl?: (url: URL, subscription: WebhookSubscription) => void | Promise<void>;
+  /**
+   * DURABLE delivery — the outbox→worker composition. When set, a matching
+   * event no longer POSTs inline: each (event × subscription) pair becomes ONE
+   * durable row in the given outbox store, and `createDurableWebhookModule`'s
+   * relay claims, delivers, retries with backoff, and dead-letters — all
+   * surviving crash and deploy, which the in-process `retry` cannot.
+   *
+   * The row id is deterministic (`<event id>:wh:<subscription id>`) and the
+   * save carries it as `dedupeKey`, so an at-least-once upstream (Redis
+   * Streams, an events outbox) redelivering the same event enqueues each
+   * delivery exactly once. Mutually exclusive with `retry` — the retry axis
+   * moves to the relay's failure policy.
+   */
+  durable?: {
+    /** Outbox store the delivery rows are written to — share it with the module. */
+    store: OutboxStore;
+  };
 }
 /** `WebhookSubscription` as returned by `list()` — secret withheld. */
 type WebhookSubscriptionPublic = Omit<WebhookSubscription, "secret">;
@@ -245,5 +265,108 @@ interface VerifySignatureOptions {
 declare function verifySignature(body: string | Buffer, secret: string, signature: string | undefined, options?: VerifySignatureOptions): boolean;
 declare const webhookPlugin: FastifyPluginAsync<WebhookPluginOptions>;
 declare const _default: FastifyPluginAsync<WebhookPluginOptions>;
+/** Event type carried by durable webhook delivery rows. */
+declare const WEBHOOK_DELIVERY_EVENT = "arc.webhook.delivery";
+/** Payload of a {@link WEBHOOK_DELIVERY_EVENT} row. */
+interface WebhookDeliveryPayload {
+  subscriptionId: string;
+  /** The original event, verbatim — what the receiver is signed and sent. */
+  event: {
+    type: string;
+    payload: unknown;
+    meta: DomainEvent["meta"];
+  };
+}
+/**
+ * A failed webhook POST, classified for the failure policy: `transient`
+ * failures (network error, timeout, 429, 5xx) are worth retrying; the rest
+ * (4xx rejection, 3xx under `redirect: "manual"`, URL-policy rejection,
+ * malformed row) are final for this payload and dead-letter immediately.
+ */
+declare class WebhookDeliveryError extends Error {
+  readonly status?: number;
+  readonly transient: boolean;
+  constructor(message: string, options: {
+    status?: number;
+    transient: boolean;
+    cause?: unknown;
+  });
+}
+interface WebhookDeliveryTransportOptions {
+  /**
+   * Resolve a subscription (WITH secret) at delivery time — fresh URL and
+   * secret apply to every attempt, and an unregistered id is an acknowledged
+   * no-op (the delivery is moot, not an error).
+   */
+  getSubscription: (id: string) => WebhookSubscription | undefined | Promise<WebhookSubscription | undefined>;
+  /** Custom fetch (for testing). */
+  fetch?: typeof globalThis.fetch;
+  /** Per-POST timeout in ms (default: 10000). */
+  timeout?: number;
+  /**
+   * URL policy — same seam as {@link WebhookPluginOptions.validateUrl}, but
+   * enforced at DELIVERY time (covers rows enqueued before a policy existed
+   * and out-of-band store writes). When set, `redirect: "manual"` applies so
+   * an allowed URL can't 302 into a blocked target; a rejection is permanent.
+   */
+  validateUrl?: (url: URL, subscription: WebhookSubscription) => void | Promise<void>;
+}
+/**
+ * Publish-only `EventTransport` whose `publish()` IS the webhook POST —
+ * plugged into an outbox relay, delivery inherits the relay's guarantees.
+ * Throws {@link WebhookDeliveryError} on failure so the relay observes it
+ * (fail → policy → retryAt/deadLetter); returns normally on 2xx and on
+ * unregistered subscriptions (acknowledge).
+ *
+ * The wire contract is IDENTICAL to inline dispatch: v1 signing, and
+ * `x-arc-webhook-delivery` carries the ORIGINAL event's `meta.id` — stable
+ * across retries, so receiver-side dedup is unchanged.
+ */
+declare function createWebhookDeliveryTransport(options: WebhookDeliveryTransportOptions): EventTransport;
+interface WebhookDeliveryPolicyOptions {
+  /** Total attempts before dead-lettering (default: 8). */
+  maxAttempts?: number;
+  /** First retry delay in ms (default: 5000). */
+  baseMs?: number;
+  /** Backoff cap in ms (default: 900000 — 15 minutes). */
+  maxMs?: number;
+}
+/**
+ * Default failure policy for durable webhook delivery: permanent failures
+ * ({@link WebhookDeliveryError} with `transient: false`) dead-letter on the
+ * first attempt — repeating a rejected payload can't succeed; transient ones
+ * retry on exponential backoff until `maxAttempts`, then dead-letter.
+ */
+declare function webhookDeliveryFailurePolicy(options?: WebhookDeliveryPolicyOptions): OutboxFailurePolicy;
+interface DurableWebhookModuleOptions extends Omit<OutboxModuleOptions, "name" | "transport" | "failurePolicy">, Pick<WebhookDeliveryTransportOptions, "fetch" | "timeout" | "validateUrl"> {
+  /** Module name / `dependsOn` key. Default `'webhook-delivery'`. */
+  name?: string;
+  /** Retry/backoff tuning for the default failure policy. */
+  delivery?: WebhookDeliveryPolicyOptions;
+  /** Full policy override — replaces {@link webhookDeliveryFailurePolicy}. */
+  failurePolicy?: OutboxFailurePolicy;
+}
+/**
+ * Durable webhook delivery as a module: the outbox relay machinery pointed at
+ * webhook POSTs. Pair with `webhookPlugin`'s `durable` option sharing the
+ * same store:
+ *
+ * ```ts
+ * const store = repositoryAsOutboxStore(deliveryRepo);
+ * createApp({
+ *   modules: [createDurableWebhookModule({ store })],
+ *   plugins: async (f) => {
+ *     await f.register(webhookPlugin, { durable: { store } });
+ *   },
+ * });
+ * ```
+ *
+ * The relay arm is `kind: 'relay'`, so `role: 'relay'` deployments run
+ * delivery and `role: 'api'` deployments only enqueue. The delivering process
+ * must ALSO register `webhookPlugin` (with the shared subscription store) —
+ * subscriptions resolve through `fastify.webhooks` at delivery time, which is
+ * boot-checked, not discovered on the first row.
+ */
+declare function createDurableWebhookModule(options: DurableWebhookModuleOptions): ReturnType<typeof createOutboxModule>;
 //#endregion
-export { VerifySignatureOptions, VerifyWebhookInput, VerifyWebhookResult, WebhookDeliveryRecord, WebhookManager, WebhookPluginOptions, WebhookStore, WebhookSubscription, WebhookSubscriptionPublic, _default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookPlugin };
+export { DurableWebhookModuleOptions, VerifySignatureOptions, VerifyWebhookInput, VerifyWebhookResult, WEBHOOK_DELIVERY_EVENT, WebhookDeliveryError, WebhookDeliveryPayload, WebhookDeliveryPolicyOptions, WebhookDeliveryRecord, WebhookDeliveryTransportOptions, WebhookManager, WebhookPluginOptions, WebhookStore, WebhookSubscription, WebhookSubscriptionPublic, createDurableWebhookModule, createWebhookDeliveryTransport, _default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookDeliveryFailurePolicy, webhookPlugin };

package/dist/integrations/webhooks.mjs

@@ -1,6 +1,9 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { n as declareRuntimeCapability } from "../runtimeCapabilities-Dm88DaTW.mjs";
+import { i as exponentialBackoff, t as createOutboxModule } from "../outbox-module-CXB79bvt.mjs";
 import { createHmac, timingSafeEqual } from "node:crypto";
 import fp from "fastify-plugin";
+import { createChildEvent } from "@classytic/primitives/events";
 //#region src/integrations/webhooks.ts
 /**
 * @classytic/arc — Webhook Outbound Integration
@@ -233,6 +236,11 @@ var MemoryWebhookStore = class {
 };
 const webhookPlugin = async (fastify, opts = {}) => {
 	const store = opts.store ?? new MemoryWebhookStore();
+	declareRuntimeCapability(fastify, {
+		subsystem: "webhooks.store",
+		durability: opts.store ? "shared" : "memory",
+		detail: "default MemoryWebhookStore: subscriptions + delivery log are replica-local"
+	});
 	const fetchFn = opts.fetch ?? globalThis.fetch;
 	const timeout = opts.timeout ?? 1e4;
 	const maxLogEntries = opts.maxLogEntries ?? 1e3;
@@ -241,6 +249,8 @@ const webhookPlugin = async (fastify, opts = {}) => {
 	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)})`);
+	if (opts.durable && opts.retry) throw new Error("webhookPlugin: `durable` and `retry` are mutually exclusive — durable delivery retries via the relay's failure policy (webhookDeliveryFailurePolicy), not in-process.");
+	const durableStore = opts.durable?.store;
 	let subscriptions = [];
 	const log = [];
 	subscriptions = await store.getAll();
@@ -261,6 +271,21 @@ const webhookPlugin = async (fastify, opts = {}) => {
 	async function dispatchEvent(event) {
 		const matching = subscriptions.filter((s) => matchesPattern(s.events, event.type));
 		if (matching.length === 0) return;
+		if (durableStore) {
+			for (const sub of matching) {
+				const deliveryId = `${event.meta.id}:wh:${sub.id}`;
+				const delivery = createChildEvent(event, WEBHOOK_DELIVERY_EVENT, {
+					subscriptionId: sub.id,
+					event: {
+						type: event.type,
+						payload: event.payload,
+						meta: event.meta
+					}
+				}, { id: deliveryId });
+				await durableStore.save(delivery, { dedupeKey: deliveryId });
+			}
+			return;
+		}
 		const body = JSON.stringify({
 			type: event.type,
 			payload: event.payload,
@@ -361,5 +386,158 @@ var webhooks_default = fp(webhookPlugin, {
 	fastify: "5.x",
 	dependencies: ["arc-events"]
 });
+/** Event type carried by durable webhook delivery rows. */
+const WEBHOOK_DELIVERY_EVENT = "arc.webhook.delivery";
+/**
+* A failed webhook POST, classified for the failure policy: `transient`
+* failures (network error, timeout, 429, 5xx) are worth retrying; the rest
+* (4xx rejection, 3xx under `redirect: "manual"`, URL-policy rejection,
+* malformed row) are final for this payload and dead-letter immediately.
+*/
+var WebhookDeliveryError = class extends Error {
+	status;
+	transient;
+	constructor(message, options) {
+		super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "WebhookDeliveryError";
+		if (options.status !== void 0) this.status = options.status;
+		this.transient = options.transient;
+	}
+};
+/**
+* Publish-only `EventTransport` whose `publish()` IS the webhook POST —
+* plugged into an outbox relay, delivery inherits the relay's guarantees.
+* Throws {@link WebhookDeliveryError} on failure so the relay observes it
+* (fail → policy → retryAt/deadLetter); returns normally on 2xx and on
+* unregistered subscriptions (acknowledge).
+*
+* The wire contract is IDENTICAL to inline dispatch: v1 signing, and
+* `x-arc-webhook-delivery` carries the ORIGINAL event's `meta.id` — stable
+* across retries, so receiver-side dedup is unchanged.
+*/
+function createWebhookDeliveryTransport(options) {
+	const fetchFn = options.fetch ?? globalThis.fetch;
+	const timeout = options.timeout ?? 1e4;
+	return {
+		name: "webhook-delivery",
+		async publish(event) {
+			if (event.type !== "arc.webhook.delivery") throw new WebhookDeliveryError(`webhook-delivery transport received event type '${event.type}' — this store must contain only ${WEBHOOK_DELIVERY_EVENT} rows (wiring bug: wrong store or transport)`, { transient: false });
+			const payload = event.payload;
+			if (!payload?.subscriptionId || !payload.event?.meta?.id) throw new WebhookDeliveryError("webhook-delivery row is malformed: payload.subscriptionId and payload.event required", { transient: false });
+			const sub = await options.getSubscription(payload.subscriptionId);
+			if (!sub) return;
+			let url;
+			try {
+				url = new URL(sub.url);
+				if (options.validateUrl) await options.validateUrl(url, sub);
+			} catch (err) {
+				throw new WebhookDeliveryError(`webhook URL rejected for subscription '${sub.id}': ${err instanceof Error ? err.message : String(err)}`, {
+					transient: false,
+					cause: err
+				});
+			}
+			const body = JSON.stringify(payload.event);
+			const timestamp = Date.now();
+			const v1Signature = signWebhook(body, sub.secret, {
+				timestamp,
+				deliveryId: payload.event.meta.id
+			});
+			const ac = new AbortController();
+			const timer = setTimeout(() => ac.abort(), timeout);
+			let response;
+			try {
+				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": payload.event.meta.id
+					},
+					body,
+					signal: ac.signal,
+					...options.validateUrl ? { redirect: "manual" } : {}
+				});
+			} catch (err) {
+				throw new WebhookDeliveryError(`webhook POST to subscription '${sub.id}' failed: ${err instanceof Error ? err.message : String(err)}`, {
+					transient: true,
+					cause: err
+				});
+			} finally {
+				clearTimeout(timer);
+			}
+			if (!response.ok) throw new WebhookDeliveryError(`webhook POST to subscription '${sub.id}' returned ${response.status}`, {
+				status: response.status,
+				transient: response.status === 429 || response.status >= 500
+			});
+		}
+	};
+}
+/**
+* Default failure policy for durable webhook delivery: permanent failures
+* ({@link WebhookDeliveryError} with `transient: false`) dead-letter on the
+* first attempt — repeating a rejected payload can't succeed; transient ones
+* retry on exponential backoff until `maxAttempts`, then dead-letter.
+*/
+function webhookDeliveryFailurePolicy(options = {}) {
+	const maxAttempts = options.maxAttempts ?? 8;
+	const baseMs = options.baseMs ?? 5e3;
+	const maxMs = options.maxMs ?? 9e5;
+	return ({ error, attempts }) => {
+		if (error instanceof WebhookDeliveryError && !error.transient) return { deadLetter: true };
+		if (attempts >= maxAttempts) return { deadLetter: true };
+		return { retryAt: exponentialBackoff({
+			attempt: attempts,
+			baseMs,
+			maxMs
+		}) };
+	};
+}
+/**
+* Durable webhook delivery as a module: the outbox relay machinery pointed at
+* webhook POSTs. Pair with `webhookPlugin`'s `durable` option sharing the
+* same store:
+*
+* ```ts
+* const store = repositoryAsOutboxStore(deliveryRepo);
+* createApp({
+*   modules: [createDurableWebhookModule({ store })],
+*   plugins: async (f) => {
+*     await f.register(webhookPlugin, { durable: { store } });
+*   },
+* });
+* ```
+*
+* The relay arm is `kind: 'relay'`, so `role: 'relay'` deployments run
+* delivery and `role: 'api'` deployments only enqueue. The delivering process
+* must ALSO register `webhookPlugin` (with the shared subscription store) —
+* subscriptions resolve through `fastify.webhooks` at delivery time, which is
+* boot-checked, not discovered on the first row.
+*/
+function createDurableWebhookModule(options) {
+	const { name, delivery, failurePolicy, fetch, timeout, validateUrl, ...outboxOptions } = options;
+	return createOutboxModule({
+		...outboxOptions,
+		name: name ?? "webhook-delivery",
+		transport: (fastify) => {
+			if (!fastify.hasDecorator("webhooks")) throw new Error(`Durable webhook module "${name ?? "webhook-delivery"}" requires webhookPlugin — subscriptions resolve through fastify.webhooks at delivery time. Register it in plugins() (with the SHARED subscription store in multi-process topologies).`);
+			return createWebhookDeliveryTransport({
+				getSubscription: (id) => {
+					const pub = fastify.webhooks.list().find((s) => s.id === id);
+					if (!pub) return void 0;
+					const secret = fastify.webhooks.getSecret(id);
+					return secret === void 0 ? void 0 : {
+						...pub,
+						secret
+					};
+				},
+				...fetch !== void 0 ? { fetch } : {},
+				...timeout !== void 0 ? { timeout } : {},
+				...validateUrl !== void 0 ? { validateUrl } : {}
+			});
+		},
+		failurePolicy: failurePolicy ?? webhookDeliveryFailurePolicy(delivery)
+	});
+}
 //#endregion
-export { webhooks_default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookPlugin };
+export { WEBHOOK_DELIVERY_EVENT, WebhookDeliveryError, createDurableWebhookModule, createWebhookDeliveryTransport, webhooks_default as default, defaultWebhookUrlPolicy, signWebhook, verifySignature, verifyWebhook, webhookDeliveryFailurePolicy, webhookPlugin };

package/dist/integrations/websocket-pushref-redis.mjs

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 //#region src/integrations/websocket-pushref-redis.ts
 /**
 * Lua script for atomic claim. Runs server-side, single-roundtrip.

package/dist/integrations/websocket-redis.mjs

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 //#region src/integrations/websocket-redis.ts
 /**
 * Redis Pub/Sub adapter for cross-instance WebSocket broadcast.

package/dist/integrations/websocket.mjs

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 import { randomUUID } from "node:crypto";
 import sjson from "secure-json-parse";
 import fp from "fastify-plugin";
@@ -334,19 +334,21 @@ var MemoryPushRefStore = class {
 	}
 	async claim(args) {
 		const existing = this.entries.get(args.pushRef);
-		if (existing) if (!existing.active && existing.expiresAt <= args.now) this.entries.delete(args.pushRef);
-		else {
-			if (existing.principal !== args.principal) return { outcome: "rejected" };
-			const supersededActive = existing.active === true;
-			existing.active = true;
-			existing.expiresAt = args.now + args.ttlMs;
-			existing.generation = (existing.generation ?? 0) + 1;
-			this.entries.set(args.pushRef, existing);
-			return {
-				outcome: "resumed",
-				entry: existing,
-				supersededActive
-			};
+		if (existing) {
+			if (!existing.active && existing.expiresAt <= args.now) this.entries.delete(args.pushRef);
+			else {
+				if (existing.principal !== args.principal) return { outcome: "rejected" };
+				const supersededActive = existing.active === true;
+				existing.active = true;
+				existing.expiresAt = args.now + args.ttlMs;
+				existing.generation = (existing.generation ?? 0) + 1;
+				this.entries.set(args.pushRef, existing);
+				return {
+					outcome: "resumed",
+					entry: existing,
+					supersededActive
+				};
+			}
 		}
 		if (this.entries.size >= args.maxEntries && !this.evictOldestInactive()) return { outcome: "rejected" };
 		const fresh = args.mintFresh();
@@ -1053,9 +1055,7 @@ async function handleConnection(ctx, socket, request) {
 				}));
 				break;
 			}
-			default:
-				await options.onMessage?.(client, msg);
-				break;
+			default: await options.onMessage?.(client, msg);
 		}
 	});
 	socket.on("close", async () => {
@@ -1137,10 +1137,12 @@ function registerStatsRoute(fastify, rooms, path, expose) {
 		fastify.get(`${path}/stats`, async () => rooms.getStats());
 		return;
 	}
-	if (expose === "authenticated") if (fastify.hasDecorator("authenticate")) {
-		const authenticate = fastify.authenticate;
-		fastify.get(`${path}/stats`, { preHandler: authenticate }, async () => rooms.getStats());
-	} else fastify.log.warn("arc-websocket: exposeStats is \"authenticated\" but fastify.authenticate is not registered — stats endpoint skipped");
+	if (expose === "authenticated") {
+		if (fastify.hasDecorator("authenticate")) {
+			const authenticate = fastify.authenticate;
+			fastify.get(`${path}/stats`, { preHandler: authenticate }, async () => rooms.getStats());
+		} else fastify.log.warn("arc-websocket: exposeStats is \"authenticated\" but fastify.authenticate is not registered — stats endpoint skipped");
+	}
 }
 //#endregion
 //#region src/integrations/websocket/outbound-truncate.ts
@@ -1164,7 +1166,7 @@ function registerStatsRoute(fastify, rooms, path, expose) {
 *     instance, eliminating module state.
 */
 /** 5 MiB default — same as n8n's `relayViaPubSub` ceiling. */
-const DEFAULT_MAX_OUTBOUND_BYTES = 5 * 1024 * 1024;
+const DEFAULT_MAX_OUTBOUND_BYTES = 5242880;
 /**
 * Returns either the original payload (when within `max`) or a
 * placeholder JSON string (when oversize). The placeholder carries the
@@ -1207,7 +1209,7 @@ function createTruncator(max = DEFAULT_MAX_OUTBOUND_BYTES) {
 * other instances fan out to their local sockets.
 */
 /** Drop fan-out to a client whose outbound buffer exceeds this threshold. */
-const WS_BACKPRESSURE_LIMIT = 256 * 1024;
+const WS_BACKPRESSURE_LIMIT = 262144;
 var RoomManager = class {
 	rooms = /* @__PURE__ */ new Map();
 	clients = /* @__PURE__ */ new Map();
@@ -1426,18 +1428,19 @@ var RoomManager = class {
 		if (client.socket.readyState !== 1) return false;
 		const queue = client.queue;
 		if (queue) {
-			if (cls === "critical") if (client.envelope) try {
-				const parsed = JSON.parse(message);
-				queue.send(client.envelope.wrap(parsed));
-				if (this.registry) safeAsync(this.registry.persist(client.pushRef, client.generation), this.logger, "registry.persist", {
-					pushRef: client.pushRef,
-					generation: client.generation
-				});
-			} catch {
-				queue.send(message);
-			}
-			else queue.send(message);
-			else queue.sendRealtime(message, coalesceKey);
+			if (cls === "critical") {
+				if (client.envelope) try {
+					const parsed = JSON.parse(message);
+					queue.send(client.envelope.wrap(parsed));
+					if (this.registry) safeAsync(this.registry.persist(client.pushRef, client.generation), this.logger, "registry.persist", {
+						pushRef: client.pushRef,
+						generation: client.generation
+					});
+				} catch {
+					queue.send(message);
+				}
+				else queue.send(message);
+			} else queue.sendRealtime(message, coalesceKey);
 			return true;
 		}
 		if ((client.socket.bufferedAmount ?? 0) > WS_BACKPRESSURE_LIMIT) return false;

package/dist/{interface-DYzM0q-u.mjs → interface-DznJrm9R.mjs}

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 //#region src/idempotency/stores/interface.ts
 /**
 * Helper to create a result object

package/dist/{jsonBody-BYbLDi5D.mjs → jsonBody-CfGH-GxO.mjs}

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-import { t as ArcError } from "./errors-Cj42AntO.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { t as ArcError } from "./errors-Cd_yy7aW.mjs";
 import sjson from "secure-json-parse";
 //#region src/utils/jsonBody.ts
 /**

package/dist/{keys-C0_pa1tY.mjs → keys-WeKvY1dE.mjs}

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 //#region src/cache/keys.ts
 /**
 * Cache Key Utilities

package/dist/{loadResources-yawi9tAE.mjs → loadResources-Bj-aSsXi.mjs}

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-import { t as __exportAll } from "./rolldown-runtime-CUsjNX9R.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { t as __exportAll } from "./rolldown-runtime-DNg-KNCk.mjs";
 import { arcLog } from "./logger/index.mjs";
 import { readdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
@@ -61,7 +61,8 @@ var loadResources_exports = /* @__PURE__ */ __exportAll({ loadResources: () => l
 */
 async function loadResources(dir, options = {}) {
 	const { suffix = ".resource", recursive = true, exclude, include, filter } = options;
-	const absDir = resolve(dir.startsWith("file://") ? dirname(fileURLToPath(dir)) : dir);
+	const resolvedDir = dir.startsWith("file://") ? dirname(fileURLToPath(dir)) : dir;
+	const absDir = resolve(resolvedDir);
 	const discovered = await collectFiles(absDir, new RegExp(`${escapeRegex(suffix)}\\.(ts|js|mts|mjs)$`), recursive);
 	discovered.sort();
 	const files = filter ? discovered.filter((f) => filter(f)) : discovered;

package/dist/{loadResourcesFromEntry-BAjYZonx.mjs → loadResourcesFromEntry-DwaxNcE2.mjs}

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
-import { t as ResourceRegistry } from "./ResourceRegistry-qq0mn2s9.mjs";
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
+import { t as ResourceRegistry } from "./ResourceRegistry-DoALUlOO.mjs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region src/cli/utils/loadResourcesFromEntry.ts

package/dist/logger/index.mjs

@@ -1,4 +1,4 @@
-/*! @classytic/arc v2.31.0 | MIT | https://classytic.com */
+/*! @classytic/arc v2.34.0 | MIT | https://classytic.com */
 //#region src/logger/index.ts
 let globalOptions = {};
 /**