@classytic/arc 2.8.0 → 2.8.3

package/dist/events/index.mjs

@@ -1,4 +1,4 @@
-import { a as MemoryEventTransport, i as withRetry, o as createEvent, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-x4jo3sG0.mjs";
+import { a as MemoryEventTransport, i as withRetry, o as createEvent, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-D91S2YF4.mjs";
 //#region src/events/defineEvent.ts
 /**
 * defineEvent — Typed Event Definitions with Optional Schema Validation
@@ -224,52 +224,235 @@ const CACHE_EVENTS = Object.freeze({
 });
 //#endregion
 //#region src/events/outbox.ts
-/** Default outbox retention — acknowledged events older than this are eligible for purge */
+/** Default outbox retention — delivered events older than this are eligible for purge */
 const DEFAULT_OUTBOX_RETENTION_MS = 10080 * 60 * 1e3;
+const DEFAULT_LEASE_MS = 3e4;
+/**
+* Thrown by a store when `acknowledge` / `fail` is called by a consumer that
+* does not own the event's current lease.
+*
+* Stores that enforce lease ownership MUST throw this (not silently return)
+* so {@link EventOutbox} can detect the mismatch and avoid over-counting
+* successful deliveries. {@link EventOutbox.relay} catches it and reports
+* via {@link EventOutboxOptions.onError} instead of counting as relayed.
+*/
+var OutboxOwnershipError = class extends Error {
+	eventId;
+	attemptedBy;
+	currentOwner;
+	constructor(eventId, attemptedBy, currentOwner) {
+		super(`Outbox ownership mismatch for event "${eventId}": attempted by "${attemptedBy}", current owner is "${currentOwner ?? "none"}". The lease may have expired and been reclaimed by another worker.`);
+		this.name = "OutboxOwnershipError";
+		this.eventId = eventId;
+		this.attemptedBy = attemptedBy;
+		this.currentOwner = currentOwner;
+	}
+};
+/** Thrown by {@link EventOutbox.store} when an event is missing `type` or `meta.id`. */
+var InvalidOutboxEventError = class extends Error {
+	constructor(reason) {
+		super(`Invalid outbox event: ${reason}`);
+		this.name = "InvalidOutboxEventError";
+	}
+};
 var EventOutbox = class {
 	_store;
 	_transport;
 	_batchSize;
+	_consumerId;
+	_leaseMs;
+	_onError;
+	_usePublishMany;
 	constructor(opts) {
 		this._store = opts.store;
 		this._transport = opts.transport;
 		this._batchSize = opts.batchSize ?? 100;
+		this._consumerId = opts.consumerId ?? `relay-${Math.random().toString(36).slice(2, 10)}`;
+		this._leaseMs = opts.leaseMs ?? DEFAULT_LEASE_MS;
+		this._onError = opts.onError;
+		this._usePublishMany = opts.usePublishMany ?? true;
+	}
+	/** Unique consumer ID used for lease ownership when the store supports claims */
+	get consumerId() {
+		return this._consumerId;
 	}
-	/** Store event in outbox (call within your DB transaction) */
-	async store(event) {
-		await this._store.save(event);
+	/**
+	* Store event in outbox.
+	*
+	* Validates that `event.type` and `event.meta.id` are present — throws
+	* {@link InvalidOutboxEventError} otherwise, so corrupt rows can never
+	* be persisted via this API.
+	*
+	* Pass `options.session` to participate in a host-managed DB transaction
+	* (store must support session-aware writes). Other options (`visibleAt`,
+	* `dedupeKey`, `partitionKey`, `headers`) are forwarded to stores that
+	* implement them and ignored otherwise.
+	*/
+	async store(event, options) {
+		if (!event || typeof event !== "object") throw new InvalidOutboxEventError("event is not an object");
+		if (!event.type || typeof event.type !== "string") throw new InvalidOutboxEventError("event.type is required");
+		if (!event.meta?.id || typeof event.meta.id !== "string") throw new InvalidOutboxEventError("event.meta.id is required");
+		await this._store.save(event, options);
+	}
+	_reportError(kind, error, event) {
+		if (!this._onError) return;
+		const err = error instanceof Error ? error : new Error(String(error));
+		try {
+			this._onError({
+				kind,
+				event,
+				error: err
+			});
+		} catch {}
 	}
 	/**
-	* Relay pending events to transport.
+	* Relay pending events to transport and return the number of successful
+	* publish+acknowledge pairs.
 	*
-	* Processes events in FIFO order up to `batchSize`. Stops on the first
-	* transport failure — remaining events stay pending for the next relay call.
+	* For richer observability (per-kind counts, publishMany detection, etc.)
+	* use {@link relayBatch} which returns a {@link RelayResult}. This method
+	* is the backward-compatible shortcut that returns just the count.
 	*
-	* @returns Number of successfully published events in this batch
+	* @returns Number of successfully published AND acknowledged events
 	*/
 	async relay() {
-		if (!this._transport) return 0;
-		const pending = await this._store.getPending(this._batchSize);
-		let relayed = 0;
+		return (await this.relayBatch()).relayed;
+	}
+	/**
+	* Relay a batch of pending events to the transport and return a rich
+	* {@link RelayResult} describing the outcome of each event.
+	*
+	* Behavior summary:
+	*
+	* - **Claim path**: uses {@link OutboxStore.claimPending} when the store
+	*   supports it (safe for multi-worker relay) or falls back to
+	*   {@link OutboxStore.getPending} (single-worker only).
+	*
+	* - **Publish path**: if the transport implements
+	*   {@link EventTransport.publishMany} and `usePublishMany` is not disabled,
+	*   the entire batch is sent in one call. Otherwise each event is published
+	*   individually. Either way, per-event outcomes are tracked.
+	*
+	* - **Failure path**: if the store implements `fail`, per-event failures
+	*   are reported via `store.fail(...)` and the batch continues. Without
+	*   `fail`, the batch stops on the first failure (legacy behavior).
+	*
+	* - **Malformed events**: events missing `type` or `meta.id` abort the
+	*   batch — a well-behaved store must never return them (see
+	*   {@link OutboxStore} semantics #6). The error is reported via `onError`.
+	*
+	* - **Ownership mismatches**: if `acknowledge`/`fail` throws
+	*   {@link OutboxOwnershipError} (our lease expired and another worker
+	*   claimed the event), the event is NOT counted as relayed. The other
+	*   worker will re-publish — at-least-once semantics preserved.
+	*
+	* @returns Per-kind outcome counts for the batch
+	*/
+	async relayBatch() {
+		const empty = {
+			relayed: 0,
+			attempted: 0,
+			publishFailed: 0,
+			ackFailed: 0,
+			ownershipMismatches: 0,
+			malformed: 0,
+			failHookErrors: 0,
+			usedPublishMany: false
+		};
+		if (!this._transport) return empty;
+		const pending = this._store.claimPending ? await this._store.claimPending({
+			limit: this._batchSize,
+			consumerId: this._consumerId,
+			leaseMs: this._leaseMs
+		}) : await this._store.getPending(this._batchSize);
+		const valid = [];
+		let malformed = 0;
 		for (const event of pending) {
-			if (!event.type || !event.meta?.id) {
-				if (event.meta?.id) await this._store.acknowledge(event.meta.id);
+			if (!event || !event.type || !event.meta?.id) {
+				this._reportError("malformed_event", new InvalidOutboxEventError("store returned event missing type or meta.id — batch aborted"), event);
+				malformed++;
+				break;
+			}
+			valid.push(event);
+		}
+		const counts = {
+			relayed: 0,
+			publishFailed: 0,
+			ackFailed: 0,
+			ownershipMismatches: 0,
+			failHookErrors: 0
+		};
+		const canPublishMany = this._usePublishMany && typeof this._transport.publishMany === "function";
+		const canFail = typeof this._store.fail === "function";
+		let publishOutcomes;
+		if (canPublishMany && valid.length > 0) try {
+			const result = await this._transport.publishMany(valid);
+			publishOutcomes = new Map(result);
+		} catch (batchErr) {
+			publishOutcomes = /* @__PURE__ */ new Map();
+			const err = batchErr instanceof Error ? batchErr : new Error(String(batchErr));
+			for (const ev of valid) publishOutcomes.set(ev.meta.id, err);
+		}
+		else {
+			publishOutcomes = /* @__PURE__ */ new Map();
+			for (const event of valid) try {
+				await this._transport.publish(event);
+				publishOutcomes.set(event.meta.id, null);
+			} catch (err) {
+				publishOutcomes.set(event.meta.id, err instanceof Error ? err : new Error(String(err)));
+				if (!canFail) break;
+			}
+		}
+		let stopBatch = false;
+		for (const event of valid) {
+			if (stopBatch) break;
+			const publishErr = publishOutcomes.get(event.meta.id);
+			if (publishErr instanceof Error) {
+				counts.publishFailed++;
+				this._reportError("publish_failed", publishErr, event);
+				if (!canFail) {
+					stopBatch = true;
+					continue;
+				}
+				try {
+					await this._store.fail(event.meta.id, normalizeError(publishErr), { consumerId: this._consumerId });
+				} catch (failErr) {
+					if (failErr instanceof OutboxOwnershipError) {
+						counts.ownershipMismatches++;
+						this._reportError("ownership_mismatch", failErr, event);
+					} else {
+						counts.failHookErrors++;
+						this._reportError("fail_failed", failErr, event);
+					}
+				}
 				continue;
 			}
 			try {
-				await this._transport.publish(event);
-				await this._store.acknowledge(event.meta.id);
-				relayed++;
-			} catch {
-				break;
+				await this._store.acknowledge(event.meta.id, { consumerId: this._consumerId });
+				counts.relayed++;
+			} catch (ackErr) {
+				counts.ackFailed++;
+				if (ackErr instanceof OutboxOwnershipError) {
+					counts.ownershipMismatches++;
+					this._reportError("ownership_mismatch", ackErr, event);
+				} else this._reportError("acknowledge_failed", ackErr, event);
 			}
 		}
-		return relayed;
+		return {
+			relayed: counts.relayed,
+			attempted: valid.length,
+			publishFailed: counts.publishFailed,
+			ackFailed: counts.ackFailed,
+			ownershipMismatches: counts.ownershipMismatches,
+			malformed,
+			failHookErrors: counts.failHookErrors,
+			usedPublishMany: canPublishMany && valid.length > 0
+		};
 	}
 	/**
-	* Purge old acknowledged events from the outbox store.
+	* Purge old **delivered** events from the outbox store.
 	* Delegates to `store.purge()` if implemented; no-op otherwise.
-	* @param olderThanMs - Remove events acknowledged more than this many ms ago (default: 7 days)
+	* @param olderThanMs - Remove events delivered more than this many ms ago (default: 7 days)
 	* @returns Number of purged events, or 0 if store doesn't support purge
 	*/
 	async purge(olderThanMs = DEFAULT_OUTBOX_RETENTION_MS) {
@@ -277,17 +460,150 @@ var EventOutbox = class {
 		return this._store.purge(olderThanMs);
 	}
 };
+function normalizeError(err) {
+	if (err instanceof Error) return {
+		message: err.message,
+		code: err.code
+	};
+	return { message: String(err) };
+}
+/**
+* In-memory outbox store — reference implementation supporting the full
+* capability set (claim/lease, fail/retry, dedupe, visibleAt).
+*
+* For dev/testing only. Production deployments should use a durable store
+* backed by the app's database.
+*/
 var MemoryOutboxStore = class {
-	events = [];
-	async save(event) {
-		this.events.push(event);
+	entries = [];
+	seenDedupeKeys = /* @__PURE__ */ new Set();
+	async save(event, options) {
+		if (!event?.type || typeof event.type !== "string") throw new InvalidOutboxEventError("event.type is required");
+		if (!event.meta?.id || typeof event.meta.id !== "string") throw new InvalidOutboxEventError("event.meta.id is required");
+		if (options?.dedupeKey) {
+			if (this.seenDedupeKeys.has(options.dedupeKey)) return;
+			this.seenDedupeKeys.add(options.dedupeKey);
+		}
+		this.entries.push({
+			event,
+			status: "pending",
+			attempts: 0,
+			visibleAt: options?.visibleAt?.getTime() ?? 0,
+			leaseOwner: null,
+			leaseExpiresAt: 0,
+			deliveredAt: null,
+			lastError: null,
+			dedupeKey: options?.dedupeKey
+		});
 	}
 	async getPending(limit) {
-		return this.events.slice(0, limit);
+		const now = Date.now();
+		return this.entries.filter((e) => e.status === "pending" && e.visibleAt <= now && (e.leaseOwner === null || e.leaseExpiresAt <= now)).slice(0, limit).map((e) => e.event);
 	}
-	async acknowledge(eventId) {
-		this.events = this.events.filter((e) => e.meta.id !== eventId);
+	async claimPending(options) {
+		const now = Date.now();
+		const limit = options?.limit ?? 100;
+		const leaseMs = options?.leaseMs ?? DEFAULT_LEASE_MS;
+		const consumerId = options?.consumerId ?? "anonymous";
+		const typeFilter = options?.types ? new Set(options.types) : null;
+		const claimed = [];
+		for (const entry of this.entries) {
+			if (claimed.length >= limit) break;
+			if (entry.status !== "pending") continue;
+			if (entry.visibleAt > now) continue;
+			if (entry.leaseOwner !== null && entry.leaseExpiresAt > now) continue;
+			if (typeFilter && !typeFilter.has(entry.event.type)) continue;
+			entry.leaseOwner = consumerId;
+			entry.leaseExpiresAt = now + leaseMs;
+			entry.attempts++;
+			claimed.push(entry.event);
+		}
+		return claimed;
+	}
+	async acknowledge(eventId, options) {
+		const entry = this.entries.find((e) => e.event.meta.id === eventId);
+		if (!entry) return;
+		if (entry.status === "delivered") return;
+		if (options?.consumerId && entry.leaseOwner && entry.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, entry.leaseOwner);
+		entry.status = "delivered";
+		entry.deliveredAt = Date.now();
+		entry.leaseOwner = null;
+	}
+	async fail(eventId, error, options) {
+		const entry = this.entries.find((e) => e.event.meta.id === eventId);
+		if (!entry) return;
+		if (options?.consumerId && entry.leaseOwner && entry.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, entry.leaseOwner);
+		entry.lastError = error;
+		entry.leaseOwner = null;
+		entry.leaseExpiresAt = 0;
+		if (options?.deadLetter) {
+			entry.status = "dead_letter";
+			return;
+		}
+		entry.status = "pending";
+		entry.visibleAt = options?.retryAt ? options.retryAt.getTime() : 0;
+	}
+	async purge(olderThanMs) {
+		const cutoff = Date.now() - olderThanMs;
+		let purged = 0;
+		for (let i = this.entries.length - 1; i >= 0; i--) {
+			const entry = this.entries[i];
+			if (!entry) continue;
+			if (entry.status === "delivered" && entry.deliveredAt !== null && entry.deliveredAt < cutoff) {
+				if (entry.dedupeKey) this.seenDedupeKeys.delete(entry.dedupeKey);
+				this.entries.splice(i, 1);
+				purged++;
+			}
+		}
+		return purged;
+	}
+	/** Test helper: inspect entry by id */
+	_getEntry(eventId) {
+		return this.entries.find((e) => e.event.meta.id === eventId);
 	}
 };
+/**
+* Compute a `retryAt` `Date` using exponential backoff with jitter.
+*
+* This is a convenience helper for store authors implementing
+* {@link OutboxStore.fail}: call it to compute the retry visibility window
+* based on the event's current attempt count.
+*
+* Formula: `delay = min(maxMs, baseMs * 2^(attempt - 1)) * (1 + random * jitter)`
+*
+* @example Basic usage inside a store's `fail()` method
+* ```typescript
+* async fail(eventId, error, options) {
+*   const entry = await this.findById(eventId);
+*   entry.attempts++;
+*   if (entry.attempts >= MAX_ATTEMPTS) {
+*     return this.deadLetter(eventId, error);
+*   }
+*   const retryAt = exponentialBackoff({ attempt: entry.attempts });
+*   entry.visibleAt = retryAt;
+*   await this.update(entry);
+* }
+* ```
+*
+* @example Tuning for a faster transport
+* ```typescript
+* exponentialBackoff({ attempt: 3, baseMs: 250, maxMs: 10_000, jitter: 0.3 });
+* // attempt=1 → ~250ms   ±30%
+* // attempt=2 → ~500ms   ±30%
+* // attempt=3 → ~1000ms  ±30%
+* // attempt=10 → capped at 10_000ms
+* ```
+*/
+function exponentialBackoff(options) {
+	const attempt = Math.max(1, Math.floor(options.attempt));
+	const baseMs = options.baseMs ?? 1e3;
+	const maxMs = options.maxMs ?? 6e4;
+	const jitter = Math.max(0, Math.min(1, options.jitter ?? .2));
+	const now = options.now ?? Date.now();
+	const exp = baseMs * 2 ** (attempt - 1);
+	const capped = Math.min(maxMs, exp);
+	const jittered = jitter > 0 ? capped * (1 + Math.random() * jitter) : capped;
+	return new Date(now + jittered);
+}
 //#endregion
-export { ARC_LIFECYCLE_EVENTS, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, EventOutbox, MemoryEventTransport, MemoryOutboxStore, createDeadLetterPublisher, createEvent, createEventRegistry, crudEventType, defineEvent, eventPlugin, withRetry };
+export { ARC_LIFECYCLE_EVENTS, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, EventOutbox, InvalidOutboxEventError, MemoryEventTransport, MemoryOutboxStore, OutboxOwnershipError, createDeadLetterPublisher, createEvent, createEventRegistry, crudEventType, defineEvent, eventPlugin, exponentialBackoff, withRetry };

package/dist/events/transports/redis-stream-entry.d.mts

@@ -1,2 +1,2 @@
-import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-CF1lrKVk.mjs";
+import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-D54N5oXs.mjs";
 export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

package/dist/events/transports/redis-stream-entry.mjs

@@ -118,7 +118,9 @@ var RedisStreamTransport = class {
 				const claimed = await this.redis.xclaim(this.stream, this.group, this.consumer, this.claimTimeoutMs, ...staleIds);
 				for (const [messageId, fields] of claimed) await this.processEntry(messageId, fields);
 			}
-		} catch {}
+		} catch (err) {
+			this.logger.error("[RedisStreamTransport] claimPending error:", err);
+		}
 	}
 	async processEntry(messageId, fields) {
 		const fieldMap = /* @__PURE__ */ new Map();

package/dist/events/transports/redis.d.mts

@@ -1,4 +1,4 @@
-import { i as EventTransport, n as EventHandler, r as EventLogger, t as DomainEvent } from "../../EventTransport-n1KBxC_N.mjs";
+import { i as EventTransport, n as EventHandler, r as EventLogger, t as DomainEvent } from "../../EventTransport-CinyO7zQ.mjs";
 
 //#region src/events/transports/redis.d.ts
 interface RedisLike {

package/dist/factory/index.d.mts

@@ -1,4 +1,4 @@
-import { a as CustomPluginAuthOption, c as RawBodyOptions, d as ResourceLike, f as loadResources, i as CustomAuthenticatorOption, l as UnderPressureOptions, n as BetterAuthOption, o as JwtAuthOption, r as CreateAppOptions, s as MultipartOptions, t as AuthOption, u as LoadResourcesOptions } from "../types-gUxAIZHp.mjs";
+import { a as CustomPluginAuthOption, c as RawBodyOptions, d as ResourceLike, f as loadResources, i as CustomAuthenticatorOption, l as UnderPressureOptions, n as BetterAuthOption, o as JwtAuthOption, r as CreateAppOptions, s as MultipartOptions, t as AuthOption, u as LoadResourcesOptions } from "../types-Bg2X42_m.mjs";
 import { FastifyInstance } from "fastify";
 
 //#region src/factory/createApp.d.ts

package/dist/factory/index.mjs

@@ -1,7 +1,5 @@
-import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-Cy8eUNKQ.mjs";
-import { readdir } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-BOYjBgdI.mjs";
+import { t as loadResources } from "../loadResources-Bksk8ydA.mjs";
 //#region src/factory/edge.ts
 /**
 * Convert a Fastify app into a Web Standards fetch handler.
@@ -48,152 +46,4 @@ function toFetchHandler(app, options = {}) {
 	};
 }
 //#endregion
-//#region src/factory/loadResources.ts
-/**
-* loadResources — Auto-discover resource files from a directory.
-*
-* Scans for `*.resource.{ts,js,mts,mjs}` files, imports each,
-* and collects their default exports. No barrel file needed.
-*
-* @example
-* ```ts
-* import { createApp, loadResources } from '@classytic/arc/factory';
-*
-* // Recommended: import.meta.url — works in both src/ (dev) and dist/ (prod)
-* const app = await createApp({
-*   resources: await loadResources(import.meta.url),
-*   auth: { type: 'jwt', jwt: { secret: process.env.JWT_SECRET } },
-* });
-*
-* // Or explicit path (must match runtime layout)
-* const app2 = await createApp({
-*   resources: await loadResources('./src/resources'),
-* });
-* ```
-*
-* File convention:
-* ```
-* src/resources/
-*   product/product.resource.ts    → export default defineResource({ name: 'product', ... })
-*   order/order.resource.ts        → export default defineResource({ name: 'order', ... })
-* ```
-*/
-/**
-* Scan a directory for resource files and import their default exports.
-*
-* Accepts a directory path OR `import.meta.url` (file:// URL).
-* When given a URL, resolves to the directory containing that file —
-* so `loadResources(import.meta.url)` works in both dev (`src/`) and
-* production (`dist/`) without path gymnastics.
-*
-* @param dir - Directory path, or `import.meta.url` (file:// URL resolved to its dirname)
-* @param options - Pattern and recursion options
-* @returns Array of resource definitions (anything with `.toPlugin()`)
-*
-* @example
-* ```ts
-* // Works from both src/ and dist/ — resolves relative to the calling file
-* await loadResources(import.meta.url);
-*
-* // Subdirectory relative to the calling file
-* await loadResources(import.meta.url, { suffix: '.resource' });
-*
-* // Explicit path (must match runtime layout)
-* await loadResources('./src/resources');
-* ```
-*/
-async function loadResources(dir, options = {}) {
-	const { suffix = ".resource", recursive = true, exclude, include, silent = false } = options;
-	const files = await collectFiles(resolve(dir.startsWith("file://") ? dirname(fileURLToPath(dir)) : dir), new RegExp(`${escapeRegex(suffix)}\\.(ts|js|mts|mjs)$`), recursive);
-	files.sort();
-	const includeSet = include ? new Set(include) : null;
-	const excludeSet = exclude ? new Set(exclude) : null;
-	const skipped = [];
-	const failed = [];
-	const isWindowsPath = (p) => /^[a-z]:[\\/]/i.test(p);
-	const results = await Promise.all(files.map(async (file) => {
-		let mod;
-		let primaryError;
-		try {
-			mod = await import(pathToFileURL(file).href);
-			return {
-				file,
-				mod
-			};
-		} catch (err) {
-			primaryError = err;
-		}
-		if (!isWindowsPath(file)) try {
-			mod = await import(file);
-			return {
-				file,
-				mod
-			};
-		} catch {}
-		const err = primaryError;
-		const code = err.code;
-		const msg = err instanceof Error ? err.message : String(err);
-		if (code === "ERR_MODULE_NOT_FOUND" && msg.includes(".js")) failed.push(`${file}: ${msg}\n    Hint: This file uses .js extension imports (TypeScript ESM convention).
-    • Production: ensure your build compiles .ts→.js before loadResources() runs.
-    • Node.js: use tsx, ts-node/esm, or a build step.
-    • Vitest: nested .js→.ts resolution may fail through dynamic imports.
-      Workaround: use import.meta.glob to preload resources statically.
-      See: https://github.com/classytic/arc/blob/main/docs/production-ops/factory.mdx#vitest-limitation`);
-		else failed.push(`${file}: ${msg}`);
-		return null;
-	}));
-	const resources = [];
-	for (const result of results) {
-		if (!result) continue;
-		let resource = result.mod.default ?? result.mod.resource;
-		if (!resource || typeof resource.toPlugin !== "function") {
-			for (const value of Object.values(result.mod)) if (value && typeof value === "object" && typeof value.toPlugin === "function") {
-				resource = value;
-				break;
-			}
-		}
-		if (!resource || typeof resource.toPlugin !== "function") {
-			skipped.push(result.file);
-			continue;
-		}
-		const name = resource.name;
-		if (name) {
-			if (includeSet && !includeSet.has(name)) continue;
-			if (!includeSet && excludeSet?.has(name)) continue;
-		}
-		resources.push(resource);
-	}
-	const log = silent ? void 0 : options?.logger;
-	if (log) {
-		if (failed.length) {
-			log.warn(`[arc] loadResources: ${failed.length} file(s) failed to import:`);
-			for (const f of failed) log.warn(`  - ${f}`);
-		}
-		if (skipped.length) {
-			log.warn(`[arc] loadResources: ${skipped.length} file(s) skipped (no default export with toPlugin):`);
-			for (const f of skipped) log.warn(`  - ${f}`);
-		}
-	}
-	return resources;
-}
-async function collectFiles(dir, pattern, recursive) {
-	const results = [];
-	let entries;
-	try {
-		entries = await readdir(dir, { withFileTypes: true });
-	} catch {
-		return results;
-	}
-	for (const entry of entries) {
-		const name = String(entry.name);
-		const fullPath = join(dir, name);
-		if (entry.isDirectory() && recursive) results.push(...await collectFiles(fullPath, pattern, recursive));
-		else if (entry.isFile() && pattern.test(name)) results.push(fullPath);
-	}
-	return results;
-}
-function escapeRegex(str) {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-//#endregion
 export { ArcFactory, createApp, developmentPreset, edgePreset, getPreset, loadResources, productionPreset, testingPreset, toFetchHandler };

package/dist/hooks/index.d.mts

@@ -1,2 +1,2 @@
-import { Cn as defineHook, Sn as createHookSystem, _n as afterDelete, bn as beforeDelete, cn as DefineHookOptions, dn as HookOperation, fn as HookPhase, gn as afterCreate, hn as HookSystemOptions, ln as HookContext, mn as HookSystem, pn as HookRegistration, un as HookHandler, vn as afterUpdate, xn as beforeUpdate, yn as beforeCreate } from "../interface-IJqN3pXK.mjs";
+import { An as beforeCreate, Cn as HookPhase, Dn as afterCreate, En as HookSystemOptions, Mn as beforeUpdate, Nn as createHookSystem, On as afterDelete, Pn as defineHook, Sn as HookOperation, Tn as HookSystem, bn as HookContext, jn as beforeDelete, kn as afterUpdate, wn as HookRegistration, xn as HookHandler, yn as DefineHookOptions } from "../interface-BVuMfeVv.mjs";
 export { type DefineHookOptions, type HookContext, type HookHandler, type HookOperation, type HookPhase, type HookRegistration, HookSystem, type HookSystemOptions, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/idempotency/index.d.mts

@@ -1,6 +1,6 @@
-import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-CkkWm5uR.mjs";
-import { n as MongoIdempotencyStoreOptions } from "../mongodb-NShVZDMr.mjs";
-import { r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-Bunu3qWg.mjs";
+import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-B-pe8fhj.mjs";
+import { n as MongoIdempotencyStoreOptions } from "../mongodb-X7LbEjTN.mjs";
+import { r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-z3sFr1UP.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/idempotency/idempotencyPlugin.d.ts

package/dist/idempotency/mongodb.d.mts

@@ -1,2 +1,2 @@
-import { n as MongoIdempotencyStoreOptions, t as MongoIdempotencyStore } from "../mongodb-NShVZDMr.mjs";
+import { n as MongoIdempotencyStoreOptions, t as MongoIdempotencyStore } from "../mongodb-X7LbEjTN.mjs";
 export { MongoIdempotencyStore, type MongoIdempotencyStoreOptions };