@classytic/arc 2.7.7 → 2.8.1

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-B6U_nCFU.mjs";
+import { a as MemoryEventTransport, i as withRetry, o as createEvent, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-XijlQmlL.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-Dag5LFa9.mjs";
+import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-BgrYzpeq.mjs";
 export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

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-C4VheKeC.mjs";
+import { i as EventTransport, n as EventHandler, r as EventLogger, t as DomainEvent } from "../../EventTransport-CLXJUzyT.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-CKB47kiu.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-BlOuKTPw.mjs";
 import { FastifyInstance } from "fastify";
 
 //#region src/factory/createApp.d.ts

package/dist/factory/index.mjs

@@ -1,4 +1,4 @@
-import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-D7e77m8C.mjs";
+import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-p2OThysU.mjs";
 import { readdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";

package/dist/hooks/index.d.mts

@@ -1,2 +1,2 @@
-import { _n as defineHook, an as HookOperation, cn as HookSystem, dn as afterDelete, fn as afterUpdate, gn as createHookSystem, hn as beforeUpdate, in as HookHandler, ln as HookSystemOptions, mn as beforeDelete, nn as DefineHookOptions, on as HookPhase, pn as beforeCreate, rn as HookContext, sn as HookRegistration, un as afterCreate } from "../interface-B91alUzq.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-CS6d7HiB.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/hooks/index.mjs

@@ -1,2 +1,2 @@
-import { a as beforeCreate, c as createHookSystem, i as afterUpdate, l as defineHook, n as afterCreate, o as beforeDelete, r as afterDelete, s as beforeUpdate, t as HookSystem } from "../HookSystem-BNYKnrXF.mjs";
+import { a as beforeCreate, c as createHookSystem, i as afterUpdate, l as defineHook, n as afterCreate, o as beforeDelete, r as afterDelete, s as beforeUpdate, t as HookSystem } from "../HookSystem-BjFu7zf1.mjs";
 export { HookSystem, 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-CSbZdv_3.mjs";
-import { n as MongoIdempotencyStoreOptions } from "../mongodb-B7zupyck.mjs";
-import { r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-3TQxm2VZ.mjs";
+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 { 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-B7zupyck.mjs";
+import { n as MongoIdempotencyStoreOptions, t as MongoIdempotencyStore } from "../mongodb-NShVZDMr.mjs";
 export { MongoIdempotencyStore, type MongoIdempotencyStoreOptions };

package/dist/idempotency/redis.d.mts

@@ -1,2 +1,2 @@
-import { n as RedisIdempotencyStore, r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-3TQxm2VZ.mjs";
+import { n as RedisIdempotencyStore, r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-Bunu3qWg.mjs";
 export { type RedisClient, RedisIdempotencyStore, type RedisIdempotencyStoreOptions };

package/dist/{index-C9eYNjGR.d.mts → index-0zj73o2U.d.mts}

@@ -1,4 +1,4 @@
-import { G as OpenApiSchemas, Q as QueryParserInterface, Ut as CrudRepository, c as ValidationResult, ft as RouteSchemaOptions, n as AdapterSchemaContext, o as RepositoryLike, q as ParsedQuery, r as DataAdapter, s as SchemaMetadata } from "./interface-B91alUzq.mjs";
+import { Y as OpenApiSchemas, Z as ParsedQuery, Zt as CrudRepository, c as ValidationResult, n as AdapterSchemaContext, nt as QueryParserInterface, o as RepositoryLike, r as DataAdapter, s as SchemaMetadata, vt as RouteSchemaOptions } from "./interface-CS6d7HiB.mjs";
 import { Model } from "mongoose";
 
 //#region src/adapters/mongoose.d.ts

package/dist/{index-B0extFr4.d.mts → index-CBru2y5Y.d.mts}

@@ -1,6 +1,6 @@
-import { r as RequestScope } from "./types--D3vvfdt.mjs";
-import { n as PermissionContext, r as PermissionResult, t as PermissionCheck } from "./types-B4BNthET.mjs";
-import { i as CacheStore, t as CacheLogger } from "./interface-CG7oRZjX.mjs";
+import { r as RequestScope } from "./types-CN6JvmYz.mjs";
+import { n as PermissionContext, r as PermissionResult, t as PermissionCheck } from "./types-BoaZHr-2.mjs";
+import { i as CacheStore, t as CacheLogger } from "./interface-bpoLKKqx.mjs";
 import { FastifyRequest } from "fastify";
 
 //#region src/permissions/applyPermissionResult.d.ts

package/dist/{index-BjShrzoj.d.mts → index-DadoLP51.d.mts}

@@ -1,6 +1,6 @@
-import { r as RequestScope } from "./types--D3vvfdt.mjs";
-import { C as CrudRouterOptions, Ft as IController, It as IControllerResponse, Lt as IRequestContext, Vt as ResourceDefinition, it as RequestWithExtras, k as FastifyWithDecorators, nt as RequestContext, ot as ResourceConfig, u as AnyRecord, x as CrudController } from "./interface-B91alUzq.mjs";
-import { t as PermissionCheck } from "./types-B4BNthET.mjs";
+import { r as RequestScope } from "./types-CN6JvmYz.mjs";
+import { D as CrudRouterOptions, Ht as IControllerResponse, N as FastifyWithDecorators, T as CrudController, Ut as IRequestContext, Vt as IController, ct as RequestWithExtras, m as AnyRecord, ot as RequestContext, qt as ResourceDefinition, ut as ResourceConfig } from "./interface-CS6d7HiB.mjs";
+import { t as PermissionCheck } from "./types-BoaZHr-2.mjs";
 import { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from "fastify";
 
 //#region src/constants.d.ts
@@ -60,7 +60,7 @@ declare const RESERVED_QUERY_PARAMS: Readonly<Set<string>>;
  * @param req - Full Fastify request object
  * @returns Action result (will be wrapped in success response)
  */
-type ActionHandler<TData = any, TResult = any> = (id: string, data: TData, req: RequestWithExtras) => Promise<TResult>;
+type ActionHandler<TData = Record<string, unknown>, TResult = unknown> = (id: string, data: TData, req: RequestWithExtras) => Promise<TResult>;
 /**
  * Action router configuration
  */
@@ -68,31 +68,63 @@ interface ActionRouterConfig {
   /**
    * OpenAPI tag for grouping routes
    */
-  tag?: string;
+  readonly tag?: string;
   /**
    * Action handlers map
    * @example { approve: (id, data, req) => service.approve(id), ... }
    */
-  actions: Record<string, ActionHandler>;
+  readonly actions: Record<string, ActionHandler>;
   /**
    * Per-action permission checks (PermissionCheck functions)
    * @example { approve: requireRoles(['admin', 'manager']), cancel: requireRoles(['admin']) }
    */
-  actionPermissions?: Record<string, PermissionCheck>;
+  readonly actionPermissions?: Record<string, PermissionCheck>;
   /**
-   * Per-action JSON schema for body validation
-   * @example { dispatch: { transport: { type: 'object' } } }
+   * Per-action schema for body validation.
+   *
+   * Accepted shapes per action:
+   *
+   * 1. **Full JSON Schema object** with `type: 'object'`, `properties`, `required` —
+   *    used verbatim. Required fields ARE enforced by Fastify's AJV.
+   *
+   * 2. **Zod v4 schema** — auto-converted via `z.toJSONSchema()`. Required fields
+   *    ARE enforced.
+   *
+   * 3. **Legacy field map** `{ fieldName: { type: 'string' } }` — each key becomes
+   *    a property and is treated as REQUIRED unless the property schema has
+   *    `nullable: true` or Arc's sentinel `required: false`. Kept for back-compat.
+   *
+   * All shapes are compiled into a single `oneOf` discriminator body schema
+   * so AJV can validate action-specific required fields at the HTTP layer.
+   *
+   * @example JSON Schema
+   * ```ts
+   * actionSchemas: {
+   *   dispatch: {
+   *     type: 'object',
+   *     properties: { carrier: { type: 'string' } },
+   *     required: ['carrier'],
+   *   },
+   * }
+   * ```
+   *
+   * @example Zod v4
+   * ```ts
+   * actionSchemas: {
+   *   dispatch: z.object({ carrier: z.string() }),
+   * }
+   * ```
    */
-  actionSchemas?: Record<string, Record<string, any>>;
+  readonly actionSchemas?: Record<string, Record<string, unknown>>;
   /**
    * Global permission check applied to all actions (if action-specific not defined)
    */
-  globalAuth?: PermissionCheck;
+  readonly globalAuth?: PermissionCheck;
   /**
    * Optional idempotency service
    * If provided, will handle idempotency-key header
    */
-  idempotencyService?: IdempotencyService;
+  readonly idempotencyService?: IdempotencyService;
   /**
    * Custom error handler for action execution failures
    * @param error - The error thrown by action handler
@@ -100,7 +132,7 @@ interface ActionRouterConfig {
    * @param id - The resource ID
    * @returns Status code and error response
    */
-  onError?: (error: Error, action: string, id: string) => {
+  readonly onError?: (error: Error, action: string, id: string) => {
     statusCode: number;
     error: string;
     code?: string;
@@ -111,11 +143,11 @@ interface ActionRouterConfig {
  * Apps can provide their own implementation
  */
 interface IdempotencyService {
-  check(key: string, payload: any): Promise<{
+  check(key: string, payload: unknown): Promise<{
     isNew: boolean;
-    existingResult?: any;
+    existingResult?: unknown;
   }>;
-  complete(key: string | undefined, result: any): Promise<void>;
+  complete(key: string | undefined, result: unknown): Promise<void>;
   fail(key: string | undefined, error: Error): Promise<void>;
 }
 /**