@classytic/arc 2.41.1 → 2.44.0

package/dist/{EventTransport-CbUKDzZZ.d.mts → EventTransport-CiicKz2Z.d.mts}

@@ -88,7 +88,7 @@ interface MemoryEventTransportOptions {
  */
 declare class MemoryEventTransport implements EventTransport {
   readonly name = "memory";
-  private handlers;
+  private router;
   private logger;
   private onHandlerError;
   private handlerDispatch;

package/dist/{EventTransport-DSqD_Xsg.mjs → EventTransport-DZWDsaPa.mjs}

@@ -1,6 +1,6 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { r as workSeedFromEvent, t as runWorkScope } from "./workScope-CxKqoIFn.mjs";
-import { createEvent, matchEventPattern } from "@classytic/primitives/events";
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+import { r as workSeedFromEvent, t as runWorkScope } from "./workScope-n9a7d_lZ.mjs";
+import { createEvent, createEventRouter } from "@classytic/primitives/events";
 //#region src/events/EventTransport.ts
 /**
 * Internal arc events module — concrete in-memory transport.
@@ -77,7 +77,7 @@ function resolveEventTransport(fastify) {
 */
 var MemoryEventTransport = class {
 	name = "memory";
-	handlers = /* @__PURE__ */ new Map();
+	router = createEventRouter();
 	logger;
 	onHandlerError;
 	handlerDispatch;
@@ -103,9 +103,8 @@ var MemoryEventTransport = class {
 		return runWorkScope(workSeedFromEvent(event), () => this.dispatch(event));
 	}
 	async dispatch(event) {
-		const allHandlers = /* @__PURE__ */ new Set();
-		for (const [pattern, handlers] of this.handlers) if (matchEventPattern(pattern, event.type)) for (const h of handlers) allHandlers.add(h);
-		if (allHandlers.size === 0 && this.onUnroutedEvent) try {
+		const allHandlers = this.router.route(event.type);
+		if (allHandlers.length === 0 && this.onUnroutedEvent) try {
 			this.onUnroutedEvent(event);
 		} catch (err) {
 			try {
@@ -132,7 +131,7 @@ var MemoryEventTransport = class {
 			* written not to reject, and `allSettled` means the next person to add a
 			* timeout or a metric to it cannot silently break that.
 			*/
-			const pending = [...allHandlers];
+			const pending = allHandlers;
 			if (this.handlerConcurrency >= pending.length) await Promise.allSettled(pending.map(run));
 			else {
 				let next = 0;
@@ -154,7 +153,7 @@ var MemoryEventTransport = class {
 		* finds nothing. A broker-backed transport has no such ambiguity — publish
 		* means "durably handed off" and redelivery is the consumer group's job.
 		*/
-		if (failures.length > 0 && this.onHandlerError === "throw") throw new AggregateError(failures, `[EventTransport] ${failures.length} handler(s) failed for ${event.type}`);
+		if (failures.length > 0 && this.onHandlerError === "throw") throw new AggregateError(failures, `[EventTransport] ${failures.length} handler(s) failed for ${event.type}: ${describeFailures(failures)}`);
 	}
 	/**
 	* Reference `publishMany` implementation — delegates to `publish()` in order.
@@ -175,19 +174,25 @@ var MemoryEventTransport = class {
 		return results;
 	}
 	async subscribe(pattern, handler) {
-		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
-		this.handlers.get(pattern)?.add(handler);
+		this.router.add(pattern, handler);
 		return () => {
-			const set = this.handlers.get(pattern);
-			if (set) {
-				set.delete(handler);
-				if (set.size === 0) this.handlers.delete(pattern);
-			}
+			this.router.remove(pattern, handler);
 		};
 	}
 	async close() {
-		this.handlers.clear();
+		this.router.clear();
 	}
 };
+/** Per-cause and total caps, so a dead-lettered row's `lastError` stays readable and bounded. */
+const CAUSE_MESSAGE_MAX = 300;
+const FAILURES_MESSAGE_MAX = 1500;
+/** Every cause's message, `; `-joined and truncated — the aggregate names what failed. */
+function describeFailures(failures) {
+	const joined = failures.map((err) => {
+		const message = err instanceof Error ? err.message : String(err);
+		return message.length > CAUSE_MESSAGE_MAX ? `${message.slice(0, CAUSE_MESSAGE_MAX)}…` : message;
+	}).join("; ");
+	return joined.length > FAILURES_MESSAGE_MAX ? `${joined.slice(0, FAILURES_MESSAGE_MAX)}… (${failures.length} causes)` : joined;
+}
 //#endregion
 export { resolveEventTransport as i, MemoryEventTransport as n, createEvent as r, ARC_EVENT_TRANSPORT as t };

package/dist/{HookSystem-CMF94SEA.mjs → HookSystem-yjEgn7Cm.mjs}

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { t as buildRequestScopeProjection } from "./projection-BzIgzoKZ.mjs";
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+import { t as buildRequestScopeProjection } from "./projection-wFoLqdss.mjs";
 //#region src/hooks/HookSystem.ts
 /**
 * Hook System

package/dist/{QueryCache-DFA-QrU9.d.mts → QueryCache--5uAuYPW.d.mts}

@@ -27,10 +27,14 @@ interface QueryCacheConfig {
   jitter?: number;
 }
 type CacheStatus = "fresh" | "stale" | "miss";
-interface CacheResult<T> {
+/** A miss carries no data — narrow on `status` before reading `data`. */
+type CacheResult<T> = {
+  status: "miss";
+  data: undefined;
+} | {
+  status: "fresh" | "stale";
   data: T;
-  status: CacheStatus;
-}
+};
 declare class QueryCache {
   private readonly store;
   constructor(store: CacheStore);

package/dist/{ResourceRegistry-MGpXoxHZ.mjs → ResourceRegistry-DJxHUpE4.mjs}

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import "./constants-D5Ubn1fe.mjs";
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+import "./constants-B2QHb6u6.mjs";
 //#region src/registry/ResourceRegistry.ts
 /**
 * Resource Registry
@@ -17,13 +17,29 @@ var ResourceRegistry = class {
 	* runtime-only handle is still reachable.
 	*/
 	_adapters;
+	/** The mounted definitions, in registration order — see `getDefinitions`. */
+	_definitions;
 	_frozen;
 	constructor() {
 		this._resources = /* @__PURE__ */ new Map();
 		this._adapters = /* @__PURE__ */ new Map();
+		this._definitions = /* @__PURE__ */ new Map();
 		this._frozen = false;
 	}
 	/**
+	* The live `ResourceDefinition`s that mounted, in registration order — what a host hands to
+	* `mcpPlugin({ resources })` or a docs generator instead of re-collecting them. A resource
+	* declaring `skipRegistry` (incl. `customRoutesOnly`) opted out and is absent. Fresh array per call.
+	* One composed module's share: `getModuleResources(fastify, name)` from `@classytic/arc/factory`.
+	*/
+	getDefinitions() {
+		return [...this._definitions.values()];
+	}
+	/** The live definition registered under `name`, or `undefined`. */
+	getDefinition(name) {
+		return this._definitions.get(name);
+	}
+	/**
 	* Get the live `DataAdapter` for a registered resource — the handle whose
 	* `.repository` cascade / cleanup helpers actually call. Returns `undefined`
 	* when the resource is unknown OR was registered without an adapter
@@ -33,12 +49,22 @@ var ResourceRegistry = class {
 	getAdapter(name) {
 		return this._adapters.get(name);
 	}
+	/** Set only by an explicit `strictResources: false`: a duplicate name keeps the FIRST entry. */
+	_tolerateDuplicates = false;
+	/** Accept a duplicate resource name (the host opted out of `strictResources`; it was warned). */
+	tolerateDuplicateNames() {
+		this._tolerateDuplicates = true;
+	}
 	/**
-	* Register a resource
+	* Register a resource. A duplicate name throws — a resource missing from the registry still
+	* serves traffic but vanishes from introspection, the permission matrix and MCP.
 	*/
 	register(resource, options = {}) {
 		if (this._frozen) throw new Error(`Registry frozen. Cannot register '${resource.name}' after startup.`);
-		if (this._resources.has(resource.name)) throw new Error(`Resource '${resource.name}' already registered.`);
+		if (this._resources.has(resource.name)) {
+			if (this._tolerateDuplicates) return this;
+			throw new Error(`Resource '${resource.name}' already registered.`);
+		}
 		const entry = {
 			name: resource.name,
 			displayName: resource.displayName,
@@ -62,12 +88,21 @@ var ResourceRegistry = class {
 				permissions: r.permissions,
 				capability: r.capability,
 				raw: r.rawHandler !== void 0,
-				schema: r.schema
+				schema: r.schema,
+				...(r.config?.idempotency)?.required === true ? { idempotency: {
+					required: true,
+					...(r.config?.idempotency)?.dedup === "handler" ? {
+						dedup: "handler",
+						owner: String((r.config?.idempotency)?.owner)
+					} : {}
+				} } : {}
 			})),
 			events: Object.keys(resource.events ?? {}),
 			registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
 			disableDefaultRoutes: resource.disableDefaultRoutes,
 			tenantField: resource.tenantField,
+			idField: resource.idField,
+			versionField: resource.versionField,
 			resolvedTenantPurge: resource.resolvedTenantPurge,
 			updateMethod: resource.updateMethod,
 			disabledRoutes: resource.disabledRoutes ? [...resource.disabledRoutes] : void 0,
@@ -76,6 +111,7 @@ var ResourceRegistry = class {
 			fields: resource.fields && Object.keys(resource.fields).length > 0 ? resource.fields : void 0,
 			pipelineSteps: extractPipelineSteps(resource.pipe),
 			rateLimit: resource.rateLimit,
+			idempotency: resource.idempotency,
 			audit: resource.audit,
 			actionPermissions: resource.actionPermissions,
 			actions: resource.actions ? Object.entries(resource.actions).map(([name, entry]) => {
@@ -86,6 +122,7 @@ var ResourceRegistry = class {
 					schema: entry.schema,
 					permissions: entry.permissions,
 					mcp: entry.mcp,
+					idempotency: entry.idempotency,
 					id: entry.id
 				};
 			}) : void 0,
@@ -108,6 +145,7 @@ var ResourceRegistry = class {
 		};
 		this._resources.set(resource.name, entry);
 		if (resource.adapter) this._adapters.set(resource.name, resource.adapter);
+		this._definitions.set(resource.name, resource);
 		return this;
 	}
 	/**
@@ -303,16 +341,9 @@ var ResourceRegistry = class {
 	reset() {
 		this._resources.clear();
 		this._adapters.clear();
+		this._definitions.clear();
 		this._frozen = false;
 	}
-	/** @internal Alias for unfreeze() */
-	_unfreeze() {
-		this.unfreeze();
-	}
-	/** @internal Alias for reset() */
-	_clear() {
-		this.reset();
-	}
 	/**
 	* Group by key
 	*/

package/dist/acquire-BozJ-9yt.mjs

@@ -0,0 +1,35 @@
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+//#region src/idempotency/acquire.ts
+async function acquireIdempotencyKey(store, key, requestId, lockTtlMs) {
+	if (typeof store.acquire === "function") return store.acquire(key, requestId, lockTtlMs);
+	return acquireBySteps(store, key, requestId, lockTtlMs);
+}
+/** `get` → `tryLock` → `get`, for stores without an atomic `acquire`. */
+async function acquireBySteps(store, key, requestId, lockTtlMs) {
+	const cached = await store.get(key);
+	if (cached) return {
+		status: "completed",
+		result: cached
+	};
+	if (!await store.tryLock(key, requestId, lockTtlMs)) return { status: "locked" };
+	let completed;
+	try {
+		completed = await store.get(key);
+	} catch (err) {
+		await store.unlock(key, requestId);
+		throw err;
+	}
+	if (!completed) return { status: "acquired" };
+	await store.unlock(key, requestId);
+	return {
+		status: "completed",
+		result: completed
+	};
+}
+/** Release a held lock — skipped after a completion that already released it. */
+async function releaseIdempotencyLock(store, key, requestId, completed) {
+	if (completed && store.completionReleasesLock === true) return;
+	await store.unlock(key, requestId);
+}
+//#endregion
+export { acquireIdempotencyKey as n, releaseIdempotencyLock as r, acquireBySteps as t };