@classytic/arc 2.7.7 → 2.8.1

package/dist/{core-B_zEeA2b.mjs → createActionRouter-Df1BuawX.mjs}

@@ -1,6 +1,11 @@
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
 import { n as normalizePermissionResult, t as applyPermissionResult } from "./applyPermissionResult-D6GPMsvh.mjs";
-import { n as defineResource } from "./defineResource-BW2dMCu9.mjs";
+import { a as toJsonSchema } from "./schemaConverter-OxfCshus.mjs";
 //#region src/core/createActionRouter.ts
+var createActionRouter_exports = /* @__PURE__ */ __exportAll({
+	buildActionBodySchema: () => buildActionBodySchema,
+	createActionRouter: () => createActionRouter
+});
 /**
 * Create action-based state transition endpoint
 *
@@ -17,19 +22,7 @@ function createActionRouter(fastify, config) {
 		fastify.log.warn("[createActionRouter] No actions defined, skipping route creation");
 		return;
 	}
-	const bodyProperties = { action: {
-		type: "string",
-		enum: actionEnum,
-		description: `Action to perform: ${actionEnum.join(" | ")}`
-	} };
-	Object.entries(actionSchemas).forEach(([actionName, schema]) => {
-		if (schema && typeof schema === "object") Object.entries(schema).forEach(([propName, propSchema]) => {
-			bodyProperties[propName] = {
-				...propSchema,
-				description: `${propSchema.description || ""} (for ${actionName} action)`.trim()
-			};
-		});
-	});
+	const bodySchema = buildActionBodySchema(actionEnum, actionSchemas);
 	const routeSchema = {
 		tags: tag ? [tag] : void 0,
 		summary: `Perform action (${actionEnum.join("/")})`,
@@ -42,11 +35,7 @@ function createActionRouter(fastify, config) {
 			} },
 			required: ["id"]
 		},
-		body: {
-			type: "object",
-			properties: bodyProperties,
-			required: ["action"]
-		}
+		body: bodySchema
 	};
 	const preHandler = [];
 	const hasPublicActions = Object.entries(actionPermissions).some(([, p]) => p?._isPublic) || globalAuth && globalAuth?._isPublic;
@@ -165,6 +154,85 @@ function createActionRouter(fastify, config) {
 	}, "[createActionRouter] Registered action endpoint: POST /:id/action");
 }
 /**
+* Build a discriminated body schema for the unified action endpoint.
+*
+* Produces a schema of the form:
+* ```json
+* {
+*   "type": "object",
+*   "required": ["action"],
+*   "oneOf": [
+*     { "properties": { "action": { "const": "dispatch" }, "carrier": {...} }, "required": ["action", "carrier"] },
+*     { "properties": { "action": { "const": "approve" } }, "required": ["action"] }
+*   ]
+* }
+* ```
+*
+* AJV validates this natively, so an action call missing required fields is
+* rejected with HTTP 400 before the handler ever runs.
+*
+* Exported so OpenAPI generation and MCP tool generation can reuse the same
+* schema shape (single source of truth).
+*/
+function buildActionBodySchema(actionEnum, actionSchemas = {}) {
+	const branches = [];
+	for (const actionName of actionEnum) {
+		const raw = actionSchemas[actionName];
+		const { properties, required } = normalizeActionSchema(raw);
+		const branchProperties = {
+			action: {
+				type: "string",
+				const: actionName
+			},
+			...properties
+		};
+		const branchRequired = ["action", ...required.filter((r) => r !== "action")];
+		branches.push({
+			type: "object",
+			properties: branchProperties,
+			required: branchRequired
+		});
+	}
+	return {
+		type: "object",
+		required: ["action"],
+		oneOf: branches
+	};
+}
+/**
+* Normalize the accepted schema shapes into `{ properties, required }`.
+*
+* Handles:
+* 1. Full JSON Schema object (has `type: 'object'` + `properties`)
+* 2. Zod v4 schema (has `_zod` marker) — converted via `toJsonSchema`
+* 3. Legacy field map (`{ fieldName: { type: 'string' } }`) — every field required
+*    unless its schema has `nullable: true` or sentinel `required: false`
+*/
+function normalizeActionSchema(raw) {
+	if (!raw || typeof raw !== "object") return {
+		properties: {},
+		required: []
+	};
+	const converted = toJsonSchema(raw);
+	if (converted && typeof converted === "object" && (converted.type === "object" || "properties" in converted)) return {
+		properties: converted.properties ?? {},
+		required: Array.isArray(converted.required) ? converted.required : []
+	};
+	const properties = {};
+	const required = [];
+	for (const [fieldName, fieldSchema] of Object.entries(raw)) {
+		if (fieldName === "type" || fieldName === "properties" || fieldName === "required") continue;
+		if (!fieldSchema || typeof fieldSchema !== "object") continue;
+		const fs = fieldSchema;
+		properties[fieldName] = fs;
+		if (fs.required !== false) required.push(fieldName);
+	}
+	return {
+		properties,
+		required
+	};
+}
+/**
 * Build description with action details
 * Uses _roles metadata from PermissionCheck functions for OpenAPI docs
 */
@@ -178,36 +246,4 @@ function buildActionDescription(actions, actionPermissions) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/core/defineResourceVariants.ts
-/**
-* Define multiple resources from a shared base config and per-variant overrides.
-*
-* Each variant is independently passed through `defineResource()` — the
-* returned `ResourceDefinition`s are real, fully-registered resources.
-* Register each one's plugin in your app:
-*
-* ```typescript
-* await app.register(articlePublic.toPlugin());
-* await app.register(articleAdmin.toPlugin());
-* ```
-*
-* @param base    Shared config — adapter, queryParser, schemaOptions, hooks, etc.
-*                Must NOT include `name` or `prefix` (those are per-variant).
-* @param variants  Map of variant key → override. Each variant must declare
-*                  its own `name` and `prefix`. Other fields override the base.
-* @returns A record where each key from `variants` maps to a real
-*          `ResourceDefinition` ready for `.toPlugin()` registration.
-*/
-function defineResourceVariants(base, variants) {
-	const out = {};
-	for (const key of Object.keys(variants)) {
-		const override = variants[key];
-		out[key] = defineResource({
-			...base,
-			...override
-		});
-	}
-	return out;
-}
-//#endregion
-export { createActionRouter as n, defineResourceVariants as t };
+export { createActionRouter as n, createActionRouter_exports as r, buildActionBodySchema as t };

package/dist/{createApp-D7e77m8C.mjs → createApp-p2OThysU.mjs}

@@ -207,7 +207,7 @@ async function registerArcCore(fastify, config, trackPlugin) {
 	await fastify.register(arcCorePlugin, { emitEvents: config.arcPlugins?.emitEvents !== false });
 	trackPlugin("arc-core");
 	if (config.arcPlugins?.events !== false) {
-		const { default: eventPlugin } = await import("./eventPlugin-B6U_nCFU.mjs").then((n) => n.n);
+		const { default: eventPlugin } = await import("./eventPlugin-XijlQmlL.mjs").then((n) => n.n);
 		const eventOpts = typeof config.arcPlugins?.events === "object" ? config.arcPlugins.events : {};
 		await fastify.register(eventPlugin, {
 			...eventOpts,
@@ -243,13 +243,13 @@ async function registerArcPlugins(fastify, config, trackPlugin, modules) {
 		trackPlugin("arc-graceful-shutdown");
 	}
 	if (config.arcPlugins?.caching) {
-		const { default: cachingPlugin } = await import("./caching-5DtLwIqb.mjs").then((n) => n.r);
+		const { default: cachingPlugin } = await import("./caching-CHH-iHs3.mjs").then((n) => n.r);
 		const opts = config.arcPlugins.caching === true ? {} : config.arcPlugins.caching;
 		await fastify.register(cachingPlugin, opts);
 		trackPlugin("arc-caching", opts);
 	}
 	if (config.arcPlugins?.queryCache) {
-		const { queryCachePlugin } = await import("./queryCachePlugin-CwTpR04-.mjs").then((n) => n.n);
+		const { queryCachePlugin } = await import("./queryCachePlugin-D0iIVhW_.mjs").then((n) => n.n);
 		const opts = config.arcPlugins.queryCache === true ? {} : config.arcPlugins.queryCache;
 		const store = config.stores?.queryCache ?? new (await (import("./memory-Cp7_cAko.mjs").then((n) => n.n))).MemoryCacheStore();
 		await fastify.register(queryCachePlugin, {
@@ -260,19 +260,19 @@ async function registerArcPlugins(fastify, config, trackPlugin, modules) {
 	}
 	if (config.arcPlugins?.sse) if (config.arcPlugins?.events === false) fastify.log.warn("SSE plugin requires events plugin (arcPlugins.events). SSE disabled.");
 	else {
-		const { default: ssePlugin } = await import("./sse-6W0hjVS_.mjs").then((n) => n.r);
+		const { default: ssePlugin } = await import("./sse-CD5Hghpu.mjs").then((n) => n.r);
 		const opts = config.arcPlugins.sse === true ? {} : config.arcPlugins.sse;
 		await fastify.register(ssePlugin, opts);
 		trackPlugin("arc-sse", opts);
 	}
 	if (config.arcPlugins?.metrics) {
-		const { default: metricsPlugin } = await import("./metrics-Qnvwc-LQ.mjs").then((n) => n.r);
+		const { default: metricsPlugin } = await import("./metrics-DuhiSEZI.mjs").then((n) => n.r);
 		const opts = config.arcPlugins.metrics === true ? {} : config.arcPlugins.metrics;
 		await fastify.register(metricsPlugin, opts);
 		trackPlugin("arc-metrics", opts);
 	}
 	if (config.arcPlugins?.versioning) {
-		const { default: versioningPlugin } = await import("./versioning-CdBbFefk.mjs").then((n) => n.r);
+		const { default: versioningPlugin } = await import("./versioning-CPU_5Xfs.mjs").then((n) => n.r);
 		await fastify.register(versioningPlugin, config.arcPlugins.versioning);
 		trackPlugin("arc-versioning", config.arcPlugins.versioning);
 	}
@@ -340,7 +340,7 @@ async function registerAuth(fastify, config, trackPlugin) {
 */
 async function registerElevation(fastify, config, trackPlugin) {
 	if (!config.elevation) return;
-	const { elevationPlugin } = await import("./elevation-By_p2lnn.mjs").then((n) => n.r);
+	const { elevationPlugin } = await import("./elevation-BBGFjzIP.mjs").then((n) => n.r);
 	await fastify.register(elevationPlugin, config.elevation);
 	trackPlugin("arc-elevation", config.elevation);
 	fastify.log.debug("Elevation plugin enabled");
@@ -350,7 +350,7 @@ async function registerElevation(fastify, config, trackPlugin) {
 */
 async function registerErrorHandler(fastify, config, trackPlugin) {
 	if (config.errorHandler === false) return;
-	const { errorHandlerPlugin } = await import("./errorHandler-CH8wk1eD.mjs").then((n) => n.n);
+	const { errorHandlerPlugin } = await import("./errorHandler-Cw34h_om.mjs").then((n) => n.n);
 	const errorOpts = typeof config.errorHandler === "object" ? config.errorHandler : { includeStack: config.preset !== "production" };
 	await fastify.register(errorHandlerPlugin, errorOpts);
 	trackPlugin("arc-error-handler", errorOpts);
@@ -667,7 +667,7 @@ function validateDistributedRuntime(options) {
 */
 async function createApp(options) {
 	if (options.debug !== void 0 && options.debug !== false) {
-		const { configureArcLogger } = await import("./logger-DLg8-Ueg.mjs").then((n) => n.r);
+		const { configureArcLogger } = await import("./logger-CDjpjySd.mjs").then((n) => n.r);
 		configureArcLogger({ debug: options.debug });
 	}
 	validateAuthOptions(options);
@@ -720,7 +720,7 @@ async function createApp(options) {
 	await registerErrorHandler(fastify, config, trackPlugin);
 	await registerResources(fastify, config);
 	if (config.replyHelpers) {
-		const { replyHelpersPlugin } = await import("./replyHelpers-uDUIYh7u.mjs").then((n) => n.n);
+		const { replyHelpersPlugin } = await import("./replyHelpers-CXtJDAZ0.mjs").then((n) => n.n);
 		await fastify.register(replyHelpersPlugin);
 	}
 	if (config.serializeBigInt) fastify.addHook("preSerialization", async (_request, _reply, payload) => {

package/dist/{defineResource-BW2dMCu9.mjs → defineResource-CqeUltrW.mjs}

@@ -1,13 +1,13 @@
 import { s as DEFAULT_UPDATE_METHOD, t as CRUD_OPERATIONS } from "./constants-Cxde4rpC.mjs";
 import { _ as isElevated, n as PUBLIC_SCOPE, v as isMember } from "./types-AOD8fxIw.mjs";
-import { t as BaseController } from "./BaseController-CpMfCXdn.mjs";
+import { t as BaseController } from "./BaseController-DAGGc5Xn.mjs";
 import { i as resolveEffectiveRoles, t as applyFieldReadPermissions } from "./fields-ipsbIRPK.mjs";
 import { t as getUserRoles } from "./types-ZUu_h0jp.mjs";
 import { n as normalizePermissionResult, t as applyPermissionResult } from "./applyPermissionResult-D6GPMsvh.mjs";
-import { t as requestContext } from "./requestContext-xHIKedG6.mjs";
-import { i as getDefaultCrudSchemas } from "./utils-B-l6410F.mjs";
-import { r as ForbiddenError } from "./errors-Cg58SLNi.mjs";
-import { n as convertRouteSchema, t as convertOpenApiSchemas } from "./schemaConverter-Y5EejTnJ.mjs";
+import { n as convertRouteSchema, t as convertOpenApiSchemas } from "./schemaConverter-OxfCshus.mjs";
+import { t as requestContext } from "./requestContext-DYvHl113.mjs";
+import { i as getDefaultCrudSchemas } from "./utils-7sJ8X83I.mjs";
+import { r as ForbiddenError } from "./errors-BF2bIOIS.mjs";
 import { t as hasEvents } from "./typeGuards-CcFZXgU7.mjs";
 import { r as getAvailablePresets, t as applyPresets } from "./presets-BFrGvvjL.mjs";
 //#region src/pipeline/pipe.ts
@@ -888,6 +888,25 @@ function defineResource(config) {
 			if (typeof route.permissions !== "function") throw new Error(`[Arc] Resource '${config.name}' route ${route.method} ${route.path}: permissions is required and must be a PermissionCheck function.\nUse allowPublic() or requireAuth() from @classytic/arc/permissions.`);
 			if (typeof route.wrapHandler !== "boolean") throw new Error(`[Arc] Resource '${config.name}' route ${route.method} ${route.path}: wrapHandler is required.\nSet true for ControllerHandler (context object) or false for FastifyHandler (req, reply).`);
 		}
+		if (config.routes && config.additionalRoutes) throw new Error(`[Arc] Resource '${config.name}': Cannot use both 'routes' and 'additionalRoutes'.\nUse 'routes' (v2.8) — it replaces 'additionalRoutes'.`);
+		for (const route of config.routes ?? []) if (typeof route.permissions !== "function") throw new Error(`[Arc] Resource '${config.name}' route ${route.method} ${route.path}: permissions is required and must be a PermissionCheck function.`);
+		if (config.actions) {
+			const CRUD_OPS = new Set([
+				"create",
+				"update",
+				"delete",
+				"list",
+				"get"
+			]);
+			for (const [name, entry] of Object.entries(config.actions)) {
+				if (CRUD_OPS.has(name)) throw new Error(`[Arc] Resource '${config.name}': action '${name}' conflicts with CRUD operation.\nUse a different name (e.g., '${name}_item', 'do_${name}').`);
+				if (typeof entry !== "function") {
+					const def = entry;
+					if (typeof def.handler !== "function") throw new Error(`[Arc] Resource '${config.name}': actions.${name}.handler must be a function.`);
+					if (def.permissions !== void 0 && typeof def.permissions !== "function") throw new Error(`[Arc] Resource '${config.name}': actions.${name}.permissions must be a PermissionCheck function.`);
+				}
+			}
+		}
 	}
 	const repository = config.adapter?.repository;
 	if (config.idField === void 0 && repository) {
@@ -1068,9 +1087,21 @@ var ResourceDefinition = class {
 	customSchemas;
 	permissions;
 	additionalRoutes;
+	/**
+	* Original v2.8 `routes` declaration — retained for downstream consumers
+	* (OpenAPI, MCP, registry, CLI introspect). Preserves fields dropped during
+	* normalization to `additionalRoutes` (notably `mcp`, `description`,
+	* `annotations`). Undefined when the resource was defined with the legacy
+	* `additionalRoutes` shape.
+	*
+	* Added in 2.8.1 — the source-of-truth fix for "canonical resource manifest".
+	*/
+	routes;
 	middlewares;
 	disableDefaultRoutes;
 	disabledRoutes;
+	actions;
+	actionPermissions;
 	events;
 	rateLimit;
 	audit;
@@ -1096,10 +1127,13 @@ var ResourceDefinition = class {
 		this.schemaOptions = config.schemaOptions ?? {};
 		this.customSchemas = config.customSchemas ?? {};
 		this.permissions = config.permissions ?? {};
-		this.additionalRoutes = config.additionalRoutes ?? [];
+		this.routes = config.routes;
+		this.additionalRoutes = config.routes ? convertRoutesToAdditionalRoutes(config.routes) : config.additionalRoutes ?? [];
 		this.middlewares = config.middlewares ?? {};
 		this.disableDefaultRoutes = config.disableDefaultRoutes ?? false;
 		this.disabledRoutes = config.disabledRoutes ?? [];
+		this.actions = config.actions;
+		this.actionPermissions = config.actionPermissions;
 		this.events = config.events ?? {};
 		this.rateLimit = config.rateLimit;
 		this.audit = config.audit;
@@ -1167,10 +1201,10 @@ var ResourceDefinition = class {
 				pattern,
 				tags
 			});
-			const onRegister = self._onRegister;
-			if (onRegister) await onRegister(fastify);
 			await fastify.register(async (instance) => {
 				const typedInstance = instance;
+				const onRegister = self._onRegister;
+				if (onRegister) await onRegister(instance);
 				let schemas = null;
 				const openApi = self._registryMeta?.openApiSchemas;
 				if (openApi && (!self.customSchemas || Object.keys(self.customSchemas).length === 0)) {
@@ -1259,6 +1293,10 @@ var ResourceDefinition = class {
 					pipe: self.pipe,
 					fields: self.fields
 				});
+				if (self.actions && Object.keys(self.actions).length > 0) {
+					const { createActionRouter } = await import("./createActionRouter-Df1BuawX.mjs").then((n) => n.r);
+					createActionRouter(instance, normalizeActionsToRouterConfig(self.actions, self.actionPermissions, self.tag));
+				}
 				if (self.events && Object.keys(self.events).length > 0) typedInstance.log?.debug?.(`Resource '${self.name}' defined ${Object.keys(self.events).length} events`);
 			}, { prefix: self.prefix });
 			if (hasEvents(fastify)) try {
@@ -1312,5 +1350,50 @@ function capitalize(str) {
 	if (!str) return "";
 	return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+* Convert v2.8 RouteDefinition[] to internal AdditionalRoute[] format.
+* The internal format is what createCrudRouter understands.
+*/
+function convertRoutesToAdditionalRoutes(routes) {
+	return routes.map((route) => ({
+		method: route.method,
+		path: route.path,
+		handler: route.handler,
+		permissions: route.permissions,
+		wrapHandler: !route.raw,
+		operation: route.operation,
+		summary: route.summary,
+		description: route.description,
+		tags: route.tags,
+		preHandler: route.preHandler,
+		preAuth: route.preAuth,
+		streamResponse: route.streamResponse,
+		schema: route.schema,
+		mcpHandler: route.mcpHandler,
+		mcp: route.mcp
+	}));
+}
+/**
+* Normalize ActionsMap into the ActionRouterConfig shape that createActionRouter expects.
+*/
+function normalizeActionsToRouterConfig(actions, globalAuth, tag) {
+	const handlers = {};
+	const permissions = {};
+	const schemas = {};
+	for (const [name, entry] of Object.entries(actions)) if (typeof entry === "function") handlers[name] = entry;
+	else {
+		const def = entry;
+		handlers[name] = def.handler;
+		if (def.permissions) permissions[name] = def.permissions;
+		if (def.schema) schemas[name] = def.schema;
+	}
+	return {
+		tag,
+		actions: handlers,
+		actionPermissions: permissions,
+		actionSchemas: schemas,
+		globalAuth
+	};
+}
 //#endregion
 export { validateResourceConfig as a, createCrudHandlers as c, getControllerContext as d, getControllerScope as f, formatValidationErrors as i, createFastifyHandler as l, pipe as m, defineResource as n, createCrudRouter as o, sendControllerResponse as p, assertValidConfig as r, createPermissionMiddleware as s, ResourceDefinition as t, createRequestContext as u };

package/dist/docs/index.d.mts

@@ -1,5 +1,5 @@
-import { et as RegistryEntry } from "../interface-B91alUzq.mjs";
-import { t as ExternalOpenApiPaths } from "../externalPaths-iba7jD3d.mjs";
+import { it as RegistryEntry } from "../interface-CS6d7HiB.mjs";
+import { t as ExternalOpenApiPaths } from "../externalPaths-BQ8QijNH.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/docs/openapi.d.ts

package/dist/docs/index.mjs

@@ -1,5 +1,5 @@
 import { t as getUserRoles } from "../types-ZUu_h0jp.mjs";
-import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-D7Z7VODz.mjs";
+import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-q6rNKfZy.mjs";
 import fp from "fastify-plugin";
 //#region src/docs/scalar.ts
 const scalarPlugin = async (fastify, opts = {}) => {

package/dist/dynamic/index.d.mts

@@ -1,5 +1,5 @@
-import { Vt as ResourceDefinition, r as DataAdapter } from "../interface-B91alUzq.mjs";
-import { t as PermissionCheck } from "../types-B4BNthET.mjs";
+import { qt as ResourceDefinition, r as DataAdapter } from "../interface-CS6d7HiB.mjs";
+import { t as PermissionCheck } from "../types-BoaZHr-2.mjs";
 
 //#region src/dynamic/ArcDynamicLoader.d.ts
 interface ArcArchitectureSchema {

package/dist/dynamic/index.mjs

@@ -1,5 +1,5 @@
 import { t as ArcQueryParser } from "../queryParser-CgCtsjti.mjs";
-import { n as defineResource } from "../defineResource-BW2dMCu9.mjs";
+import { n as defineResource } from "../defineResource-CqeUltrW.mjs";
 import { C as publicRead, T as readOnly, b as fullPublic, v as adminOnly, w as publicReadAdminWrite, x as ownerWithAdminBypass, y as authenticated } from "../permissions-CH4cNwJi.mjs";
 //#region src/dynamic/ArcDynamicLoader.ts
 const VALID_FIELD_TYPES = new Set([

package/dist/{elevation-By_p2lnn.mjs → elevation-BBGFjzIP.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
 import { t as getUserRoles } from "./types-ZUu_h0jp.mjs";
-import { t as arcLog } from "./logger-DLg8-Ueg.mjs";
+import { t as arcLog } from "./logger-CDjpjySd.mjs";
 import fp from "fastify-plugin";
 //#region src/scope/elevation.ts
 var elevation_exports = /* @__PURE__ */ __exportAll({

package/dist/{errorHandler-CH8wk1eD.mjs → errorHandler-Cw34h_om.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { p as isArcError } from "./errors-Cg58SLNi.mjs";
+import { p as isArcError } from "./errors-BF2bIOIS.mjs";
 import fp from "fastify-plugin";
 //#region src/plugins/errorHandler.ts
 var errorHandler_exports = /* @__PURE__ */ __exportAll({ errorHandlerPlugin: () => errorHandlerPlugin });

package/dist/{errorHandler-pCpEtNd7.d.mts → errorHandler-DJ7OAB2V.d.mts}

@@ -1,4 +1,4 @@
-import { t as DomainEvent } from "./EventTransport-C4VheKeC.mjs";
+import { t as DomainEvent } from "./EventTransport-CLXJUzyT.mjs";
 import { FastifyInstance, FastifyPluginAsync, FastifyRequest } from "fastify";
 
 //#region src/plugins/caching.d.ts

package/dist/{eventPlugin-CdvUoUna.d.mts → eventPlugin-Cdjwo0Gv.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";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/events/defineEvent.d.ts

package/dist/{eventPlugin-B6U_nCFU.mjs → eventPlugin-XijlQmlL.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { t as requestContext } from "./requestContext-xHIKedG6.mjs";
+import { t as requestContext } from "./requestContext-DYvHl113.mjs";
 import fp from "fastify-plugin";
 //#region src/events/EventTransport.ts
 /**
@@ -33,6 +33,24 @@ var MemoryEventTransport = class {
 			this.logger.error(`[EventTransport] Handler error for ${event.type}:`, err);
 		}
 	}
+	/**
+	* Reference `publishMany` implementation — delegates to `publish()` in order.
+	*
+	* Production transports (Kafka, Redis pipeline, SQS batch) should override
+	* this with a single batched network call. Memory transport has nothing to
+	* batch, so we just loop — the loop still returns a proper result map so
+	* `EventOutbox.relay` can exercise the batched code path in tests.
+	*/
+	async publishMany(events) {
+		const results = /* @__PURE__ */ new Map();
+		for (const event of events) try {
+			await this.publish(event);
+			results.set(event.meta.id, null);
+		} catch (err) {
+			results.set(event.meta.id, err instanceof Error ? err : new Error(String(err)));
+		}
+		return results;
+	}
 	async subscribe(pattern, handler) {
 		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
 		this.handlers.get(pattern)?.add(handler);