@classytic/arc 2.22.0 → 2.25.0

package/dist/integrations/webhooks.mjs

@@ -31,20 +31,127 @@ import fp from "fastify-plugin";
 * ```
 */
 /**
-* Sign a payload with HMAC-SHA256 for outbound webhook delivery.
+* Signed-string layout for the v1 webhook contract:
 *
-* @returns `sha256=<hex>` — the format written to `x-webhook-signature`
+*     v1.<timestampMs>.<deliveryId>.<body>
+*
+* Binding the timestamp bounds replay to the verifier's tolerance window,
+* and binding the delivery id lets receivers deduplicate redeliveries on an
+* AUTHENTICATED value (the legacy `x-webhook-id` header was unsigned — an
+* attacker replaying a captured request could change it and defeat dedup).
+*
+* Wire headers:
+*   - `x-arc-webhook-signature: v1=<hex hmac-sha256>`
+*   - `x-arc-webhook-timestamp: <unix epoch ms>`
+*   - `x-arc-webhook-delivery:  <delivery id>` (arc sends the event's
+*     `meta.id` — STABLE across retries of the same event, so dedup on it
+*     collapses redeliveries)
 */
-function signPayload(payload, secret) {
+function signWebhook(body, secret, meta) {
 	const hmac = createHmac("sha256", secret);
-	hmac.update(payload);
-	return `sha256=${hmac.digest("hex")}`;
+	hmac.update(`v1.${meta.timestamp}.${meta.deliveryId}.${body}`);
+	return `v1=${hmac.digest("hex")}`;
 }
 /**
-* Verify an inbound webhook signature using timing-safe comparison.
+* Verify an inbound v1 arc webhook: signature + timestamp tolerance, and
+* return the authenticated delivery id for receiver-side deduplication.
 *
-* Works with Arc's own `signPayload` format by default (`sha256=<hex>`),
-* but configurable for any HMAC scheme via options.
+* ⚠ Pass `req.rawBody` (route opted in via `config: { rawBody: true }`),
+* never the parsed `req.body` — re-serialised JSON won't match the HMAC.
+*
+* @example
+* ```typescript
+* fastify.post('/hooks/arc', { config: { rawBody: true } }, async (req, reply) => {
+*   const result = verifyWebhook({
+*     body: req.rawBody,
+*     secret: process.env.WEBHOOK_SECRET,
+*     signature: req.headers['x-arc-webhook-signature'] as string,
+*     timestamp: req.headers['x-arc-webhook-timestamp'] as string,
+*     deliveryId: req.headers['x-arc-webhook-delivery'] as string,
+*   });
+*   if (!result.valid) return reply.status(401).send({ error: result.reason });
+*   if (await seen(result.deliveryId)) return reply.send({ ok: true }); // dedup
+*   // ... handle, then mark result.deliveryId seen
+* });
+* ```
+*/
+function verifyWebhook(input) {
+	const { body, secret, signature, deliveryId, toleranceMs = 3e5, now = Date.now } = input;
+	if (typeof body !== "string" && !Buffer.isBuffer(body)) throw new TypeError("verifyWebhook: body must be a string or Buffer (the exact bytes the sender signed). Add `config: { rawBody: true }` to the route and pass req.rawBody — not req.body.");
+	if (!signature || !deliveryId || input.timestamp === void 0 || input.timestamp === "") return {
+		valid: false,
+		reason: "missing_headers"
+	};
+	const timestamp = Number(input.timestamp);
+	if (!Number.isFinite(timestamp)) return {
+		valid: false,
+		reason: "bad_timestamp"
+	};
+	if (Math.abs(now() - timestamp) > toleranceMs) return {
+		valid: false,
+		reason: "expired"
+	};
+	const expected = signWebhook(typeof body === "string" ? body : body.toString("utf8"), secret, {
+		timestamp,
+		deliveryId
+	});
+	const a = Buffer.from(signature);
+	const b = Buffer.from(expected);
+	if (a.length !== b.length || !timingSafeEqual(a, b)) return {
+		valid: false,
+		reason: "bad_signature"
+	};
+	return {
+		valid: true,
+		deliveryId,
+		timestamp
+	};
+}
+/**
+* Opt-in URL policy for tenant-registered webhooks: requires HTTPS and
+* rejects loopback, link-local, private-network, and cloud-metadata
+* destinations. Pass as `validateUrl: defaultWebhookUrlPolicy`.
+*
+* Scope note: this validates the URL LITERAL at registration time. It does
+* not resolve DNS — rebinding/level-2 SSRF protection belongs at the actual
+* outbound network boundary (egress proxy, network policy), where the real
+* connection target is known. Internal deployments that legitimately POST
+* to private services should write their own narrower policy instead.
+*/
+const BLOCKED_V4 = /^(?:127\.|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.|169\.254\.|0\.)/;
+function defaultWebhookUrlPolicy(url) {
+	if (url.protocol !== "https:") throw new Error(`Webhook URL must use https (got ${url.protocol}//)`);
+	let host = url.hostname.toLowerCase();
+	if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+	const blockedName = host === "localhost" || host.endsWith(".localhost") || host === "metadata.google.internal";
+	const isV6 = host.includes(":");
+	const mappedV4 = isV6 ? decodeMappedV4(host) : void 0;
+	const blockedV6 = isV6 && (host === "::1" || host === "::" || /^f[cd]/.test(host) || /^fe[89ab]/.test(host) || mappedV4 !== void 0 && BLOCKED_V4.test(mappedV4));
+	const blockedV4 = !isV6 && BLOCKED_V4.test(host);
+	if (blockedName || blockedV4 || blockedV6) throw new Error(`Webhook URL host '${host}' is not allowed (loopback/private/metadata)`);
+}
+/**
+* Decode an IPv4-mapped IPv6 literal to its dotted-quad form. Accepts both
+* the textual spelling (`::ffff:1.2.3.4`) and the hex-group canonical form
+* WHATWG URL produces (`::ffff:102:304`). Returns undefined for anything else.
+*/
+function decodeMappedV4(host) {
+	const dotted = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(host)?.[1];
+	if (dotted) return dotted;
+	const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(host);
+	if (!hex?.[1] || !hex[2]) return void 0;
+	const hi = Number.parseInt(hex[1], 16);
+	const lo = Number.parseInt(hex[2], 16);
+	return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+}
+/**
+* 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}.
+*
+* 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
@@ -62,21 +169,17 @@ function signPayload(payload, secret) {
 * ```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)
@@ -133,9 +236,27 @@ const webhookPlugin = async (fastify, opts = {}) => {
 	const timeout = opts.timeout ?? 1e4;
 	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();
+	if (opts.validateUrl) {
+		const admitted = [];
+		for (const sub of subscriptions) try {
+			await opts.validateUrl(new URL(sub.url), sub);
+			admitted.push(sub);
+		} catch (err) {
+			fastify.log.warn({
+				subscriptionId: sub.id,
+				url: sub.url,
+				err
+			}, "webhookPlugin: persisted subscription failed the URL policy — excluded from dispatch. Fix the URL or unregister the subscription.");
+		}
+		subscriptions = admitted;
+	}
 	async function dispatchEvent(event) {
 		const matching = subscriptions.filter((s) => matchesPattern(s.events, event.type));
 		if (matching.length === 0) return;
@@ -151,29 +272,42 @@ const webhookPlugin = async (fastify, opts = {}) => {
 				success: false,
 				timestamp: /* @__PURE__ */ new Date()
 			};
-			try {
-				const signature = 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-webhook-signature": signature,
-							"x-webhook-id": event.meta.id,
-							"x-webhook-event": event.type
-						},
-						body,
-						signal: ac.signal
+					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);
@@ -188,6 +322,13 @@ const webhookPlugin = async (fastify, opts = {}) => {
 	if (fastify.events) unsubscribe = await fastify.events.subscribe("*", dispatchEvent);
 	fastify.decorate("webhooks", {
 		async register(sub) {
+			let parsed;
+			try {
+				parsed = new URL(sub.url);
+			} catch {
+				throw new Error(`webhookPlugin: invalid webhook URL '${sub.url}'`);
+			}
+			if (opts.validateUrl) await opts.validateUrl(parsed, sub);
 			await store.save(sub);
 			subscriptions = subscriptions.filter((s) => s.id !== sub.id);
 			subscriptions.push(sub);
@@ -197,7 +338,10 @@ const webhookPlugin = async (fastify, opts = {}) => {
 			subscriptions = subscriptions.filter((s) => s.id !== id);
 		},
 		list() {
-			return [...subscriptions];
+			return subscriptions.map(({ secret: _secret, ...pub }) => pub);
+		},
+		getSecret(id) {
+			return subscriptions.find((s) => s.id === id)?.secret;
 		},
 		deliveryLog(limit) {
 			if (limit) return log.slice(-limit);
@@ -217,4 +361,4 @@ var webhooks_default = fp(webhookPlugin, {
 	dependencies: ["arc-events"]
 });
 //#endregion
-export { webhooks_default as default, signPayload, verifySignature, 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 };

package/dist/integrations/websocket.mjs

@@ -648,7 +648,15 @@ function safeAsync(p, logger, op, ctx) {
 */
 var SendQueue = class {
 	entries = [];
-	/** `coalesceKey → entries[] index` for O(1) replacement. */
+	/**
+	* Logical queue head — `entries[head..]` is the live queue. Draining
+	* advances the pointer instead of `shift()`ing (which moves every
+	* trailing element AND invalidated every tracked coalesce index,
+	* making a full drain O(n²)). The prefix is garbage-collected by
+	* {@link compactIfNeeded} — amortized O(1) per drained frame.
+	*/
+	head = 0;
+	/** `coalesceKey → ABSOLUTE entries[] index` for O(1) replacement. */
 	coalesceIndex = /* @__PURE__ */ new Map();
 	socket;
 	capacity;
@@ -666,7 +674,7 @@ var SendQueue = class {
 	/** Ordered, guaranteed-best-effort delivery. Overflow ⇒ terminate. */
 	send(payload) {
 		if (this.disposed) return;
-		if (this.entries.length >= this.capacity) {
+		if (this.size() >= this.capacity) {
 			this.terminate("Queue overflow");
 			return;
 		}
@@ -685,7 +693,7 @@ var SendQueue = class {
 		if (this.disposed) return;
 		if (coalesceKey !== void 0) {
 			const idx = this.coalesceIndex.get(coalesceKey);
-			if (idx !== void 0 && this.entries[idx]) {
+			if (idx !== void 0 && idx >= this.head && this.entries[idx]) {
 				this.entries[idx] = {
 					payload,
 					cls: "droppable",
@@ -695,12 +703,16 @@ var SendQueue = class {
 				return;
 			}
 		}
-		if (this.entries.length >= this.capacity) {
-			const shedIdx = this.entries.findIndex((e) => e.cls === "droppable");
+		if (this.size() >= this.capacity) {
+			let shedIdx = -1;
+			for (let i = this.head; i < this.entries.length; i++) if (this.entries[i]?.cls === "droppable") {
+				shedIdx = i;
+				break;
+			}
 			if (shedIdx === -1) return;
 			const evicted = this.entries.splice(shedIdx, 1)[0];
 			if (evicted?.coalesceKey !== void 0) this.coalesceIndex.delete(evicted.coalesceKey);
-			this.reindexCoalesceFrom(shedIdx);
+			for (const [key, idx] of this.coalesceIndex) if (idx > shedIdx) this.coalesceIndex.set(key, idx - 1);
 		}
 		this.entries.push({
 			payload,
@@ -718,28 +730,44 @@ var SendQueue = class {
 	*/
 	flush() {
 		if (this.disposed) return;
-		while (this.entries.length > 0 && this.socket.readyState === 1) {
+		while (this.size() > 0 && this.socket.readyState === 1) {
 			if ((this.socket.bufferedAmount ?? 0) >= this.drainThreshold) {
 				this.scheduleRetry();
-				return;
+				break;
 			}
-			const entry = this.entries.shift();
+			const entry = this.entries[this.head];
 			if (!entry) return;
+			this.head++;
 			if (entry.coalesceKey !== void 0) this.coalesceIndex.delete(entry.coalesceKey);
-			if (this.coalesceIndex.size > 0) this.reindexCoalesceFrom(0);
 			try {
 				this.socket.send(entry.payload);
 			} catch {
 				return;
 			}
 		}
+		this.compactIfNeeded();
 	}
 	size() {
-		return this.entries.length;
+		return this.entries.length - this.head;
+	}
+	/**
+	* Drop the drained prefix once it dominates the array. Rebuilding the
+	* (small) coalesce index here is the amortized cost that replaces the
+	* per-frame O(n) reindex the old `shift()` drain paid.
+	*/
+	compactIfNeeded() {
+		if (this.head < 64 || this.head * 2 < this.entries.length) return;
+		this.entries = this.entries.slice(this.head);
+		this.head = 0;
+		if (this.coalesceIndex.size > 0) {
+			this.coalesceIndex.clear();
+			this.reindexCoalesceFrom(0);
+		}
 	}
 	dispose() {
 		this.disposed = true;
 		this.entries.length = 0;
+		this.head = 0;
 		this.coalesceIndex.clear();
 		if (this.retryTimer) {
 			clearTimeout(this.retryTimer);
@@ -829,7 +857,6 @@ async function handleConnection(ctx, socket, request) {
 		clientId: serviceClientId,
 		authMode: options.auth
 	});
-	options.messageEnvelope;
 	const urlPushRef = readPushRefFromRequest(request);
 	let pushRef;
 	let envelope;
@@ -1279,7 +1306,7 @@ var RoomManager = class {
 		for (const clientId of members) {
 			if (clientId === excludeClientId) continue;
 			const client = this.clients.get(clientId);
-			if (!client || client.socket.readyState !== 1) continue;
+			if (client?.socket.readyState !== 1) continue;
 			if ((client.socket.bufferedAmount ?? 0) > WS_BACKPRESSURE_LIMIT) continue;
 			try {
 				client.socket.send(message);
@@ -1303,7 +1330,7 @@ var RoomManager = class {
 		if (!members) return;
 		for (const clientId of members) {
 			const client = this.clients.get(clientId);
-			if (!client || client.socket.readyState !== 1) continue;
+			if (client?.socket.readyState !== 1) continue;
 			if (client.queue) client.queue.sendRealtime(message, coalesceKey);
 			else if ((client.socket.bufferedAmount ?? 0) <= WS_BACKPRESSURE_LIMIT) try {
 				client.socket.send(message);

package/dist/{interface-C1_WLTMK.d.mts → interface-BGZCzOGL.d.mts}

@@ -1,34 +1,5 @@
+import { CacheAdapter } from "@classytic/repo-core/cache";
 //#region src/cache/interface.d.ts
-/**
- * Cache Store Interface — aligned with `@classytic/repo-core/cache.CacheAdapter`.
- *
- * Arc's cache layer speaks the same `get / set(ttlSeconds?) / del / clear(pattern?)`
- * transport-level contract published by `@classytic/repo-core`. One Redis
- * implementation drops into Arc's `QueryCache`, mongokit's cache plugin,
- * sqlitekit's cache plugin, and every future kit without wrapper shims.
- *
- * Arc extends the bare adapter with two optional observability fields —
- * `name` (for diagnostics) and `stats()` (for the response-cache plugin) —
- * that are opt-in: consumers implementing only `CacheAdapter` still
- * structurally satisfy `CacheStore`, so a raw repo-core adapter plugs
- * directly into Arc.
- *
- * ## TTL unit
- *
- * `ttlSeconds`, not milliseconds. Matches Redis (`SET … EX seconds`) which
- * is the dominant backend. `0` or `undefined` means no expiry; implementations
- * may apply their own default.
- *
- * ## Not-found semantics
- *
- * `get()` returns `undefined` on miss / expired. Matches repo-core.
- *
- * ## Sync-or-async
- *
- * Method returns are `Promise<T> | T` — in-memory `Map` adapters can be
- * synchronous; Redis adapters are async. Consumers always `await`, so
- * sync values just short-circuit the microtask.
- */
 interface CacheLogger {
   warn(message: string, ...args: unknown[]): void;
   error(message: string, ...args: unknown[]): void;
@@ -45,7 +16,14 @@ interface CacheStats {
   /** Number of entries evicted since creation */
   evictions: number;
 }
-interface CacheStore<TValue = unknown> {
+/**
+ * `extends CacheAdapter` is load-bearing: repo-core owns the transport
+ * contract, and extending (instead of maintaining a structural copy) makes
+ * any drift between the two a COMPILE error in arc rather than a runtime
+ * incompatibility — e.g. an argument-order divergence on `increment` would
+ * make a conforming adapter misread a TTL as the increment amount.
+ */
+interface CacheStore<TValue = unknown> extends CacheAdapter {
   /** Store name for logs/diagnostics. Optional to match repo-core's bare `CacheAdapter`. */
   readonly name?: string;
   /**
@@ -70,6 +48,21 @@ interface CacheStore<TValue = unknown> {
    * need strict invalidation must check for its presence: `store.clear?.(pattern)`.
    */
   clear?(pattern?: string): Promise<void> | void;
+  /**
+   * Atomic increment — adds `by` (default 1) to the integer at `key`,
+   * creating it with value `by` when absent; returns the NEW value.
+   * Signature is the canonical `@classytic/repo-core/cache.CacheAdapter`
+   * contract — Redis adapters map to `INCRBY` (+ `EXPIRE` when
+   * `ttlSeconds` is given).
+   *
+   * Optional — consumers feature-detect it. Arc's `QueryCache` uses it for
+   * version-based invalidation: with `increment`, concurrent bumps from
+   * multiple replicas are strictly monotonic and never collide; without it,
+   * QueryCache falls back to a read-modify-write that is monotonic within a
+   * process but can lose a concurrent replica's bump. Distributed hosts
+   * should use a store that implements this.
+   */
+  increment?(key: string, by?: number, ttlSeconds?: number): Promise<number> | number;
   /** Cache statistics for observability. Optional. */
   stats?(): CacheStats;
 }

package/dist/interface-n5hpKg1d.mjs

@@ -0,0 +1,16 @@
+//#region src/idempotency/stores/interface.ts
+/**
+* Helper to create a result object
+*/
+function createIdempotencyResult(statusCode, body, headers, ttlMs) {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		statusCode,
+		headers,
+		body,
+		createdAt: now,
+		expiresAt: new Date(now.getTime() + ttlMs)
+	};
+}
+//#endregion
+export { createIdempotencyResult as t };

package/dist/{loadResourcesFromEntry-OMCvIEE7.mjs → loadResourcesFromEntry-kvGT6EcO.mjs}

@@ -1,4 +1,4 @@
-import { t as ResourceRegistry } from "./ResourceRegistry-7RnrEWNP.mjs";
+import { t as ResourceRegistry } from "./ResourceRegistry-y9Hnypus.mjs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region src/cli/utils/loadResourcesFromEntry.ts