@classytic/arc 2.11.3 → 2.13.1

package/dist/{createActionRouter-u3ql2EDo.mjs → createActionRouter-CEvzKcy8.mjs}

@@ -1,6 +1,7 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { a as buildAuthMiddlewareForPermissions, c as buildPreHandlerChain, f as resolveRouterPluginMw, l as buildRateLimitConfig, n as buildActionPipelineHandler, p as selectPluginMw, r as buildArcDecorator, t as buildActionPermissionMw, u as resolvePipelineSteps, y as sendControllerResponse } from "./routerShared-BqLRb5l7.mjs";
-import { n as schemaIRToJsonSchemaBranch, t as normalizeSchemaIR } from "./schemaIR-BlG9bY7v.mjs";
+import { f as createError } from "./errors-j4aJm1Wg.mjs";
+import { a as buildAuthMiddlewareForPermissions, c as buildPreHandlerChain, f as resolveRouterPluginMw, l as buildRateLimitConfig, n as buildActionPipelineHandler, p as selectPluginMw, r as buildArcDecorator, t as buildActionPermissionMw, u as resolvePipelineSteps, y as sendControllerResponse } from "./routerShared-D6_fEGHh.mjs";
+import { n as schemaIRToJsonSchemaBranch, t as normalizeSchemaIR } from "./schemaIR-7Vl611Qs.mjs";
 //#region src/core/createActionRouter.ts
 var createActionRouter_exports = /* @__PURE__ */ __exportAll({
 	buildActionBodySchema: () => buildActionBodySchema,
@@ -69,23 +70,13 @@ function createActionRouter(fastify, config) {
 			const { action, ...data } = req.body;
 			const { id } = req.params;
 			const handler = wrappedHandlers.get(action);
-			if (!handler) return sendControllerResponse(reply, {
-				success: false,
-				status: 400,
-				error: `Invalid action '${action}'. Valid actions: ${actionEnum.join(", ")}`,
-				meta: { validActions: actionEnum }
-			}, req);
+			if (!handler) throw createError(400, `Invalid action '${action}'. Valid actions: ${actionEnum.join(", ")}`, { validActions: actionEnum });
 			try {
 				return sendControllerResponse(reply, await handler(id, data, req), req);
 			} catch (error) {
 				if (onError) {
 					const { statusCode, error: errorMsg, code } = onError(error, action, id);
-					return sendControllerResponse(reply, {
-						success: false,
-						status: statusCode,
-						error: errorMsg,
-						...code ? { meta: { code } } : {}
-					}, req);
+					throw createError(statusCode, errorMsg, code ? { code } : void 0);
 				}
 				const err = error;
 				const statusCode = err.statusCode || err.status || 500;
@@ -95,12 +86,8 @@ function createActionRouter(fastify, config) {
 					action,
 					id
 				}, "Action handler error");
-				return sendControllerResponse(reply, {
-					success: false,
-					status: statusCode,
-					error: err.message || `Failed to execute '${action}' action`,
-					meta: { code: errorCode }
-				}, req);
+				if (error?.name === "ArcError" || error instanceof Error === false) throw error;
+				throw createError(statusCode, err.message || `Failed to execute '${action}' action`, { code: errorCode });
 			}
 		}
 	});

package/dist/createAggregationRouter-CyecOxnO.mjs

@@ -0,0 +1,114 @@
+import { f as createError, l as UnauthorizedError, r as ForbiddenError } from "./errors-j4aJm1Wg.mjs";
+import { c as buildPreHandlerChain, f as resolveRouterPluginMw, i as buildAuthMiddleware, l as buildRateLimitConfig, p as selectPluginMw, r as buildArcDecorator } from "./routerShared-D6_fEGHh.mjs";
+import { r as validateAggregations, t as buildAggregationHandler } from "./buildHandler-olo-gt94.mjs";
+//#region src/core/aggregation/createAggregationRouter.ts
+/**
+* Register one Fastify route per aggregation. No-op when the map is
+* empty — same convention `createActionRouter` follows.
+*/
+function createAggregationRouter(fastify, config) {
+	const { tag, resourceName, aggregations, fields: fieldPermissions, schemaOptions, permissions: resourcePermissions, routeGuards = [], repository, buildOptions } = config;
+	if (!aggregations || Object.keys(aggregations).length === 0) return;
+	const normalized = validateAggregations(resourceName, aggregations, schemaOptions);
+	const arcDecorator = buildArcDecorator({
+		resourceName,
+		schemaOptions,
+		permissions: resourcePermissions,
+		hooks: fastify.arc?.hooks,
+		events: fastify.events,
+		fields: fieldPermissions
+	});
+	for (const aggregation of normalized) registerOne(fastify, aggregation, {
+		tag,
+		arcDecorator,
+		routeGuards,
+		repository,
+		buildOptions
+	});
+	fastify.log?.debug?.({
+		aggregations: normalized.map((a) => a.name),
+		resourceName
+	}, `[createAggregationRouter] registered ${normalized.length} aggregation route(s)`);
+}
+function registerOne(fastify, normalized, ctx) {
+	const { tag, arcDecorator, routeGuards, repository, buildOptions } = ctx;
+	const { name } = normalized;
+	const config = normalized.base;
+	const authMw = buildAuthMiddleware(fastify, config.permissions);
+	const permissionFn = config.permissions;
+	const permissionMw = async (req, _reply) => {
+		const raw = await permissionFn(buildPermissionContextLite(req, normalized.name));
+		if (!normalizePermissionGranted(raw)) {
+			const status = req.user ? 403 : 401;
+			const reason = normalizePermissionReason(raw);
+			if (status === 401) throw new UnauthorizedError(reason ?? "Authentication required to access this aggregation.");
+			throw new ForbiddenError(reason ?? "You do not have permission to access this aggregation.");
+		}
+	};
+	const preHandler = buildPreHandlerChain({
+		arcDecorator,
+		authMw,
+		permissionMw,
+		pluginMw: selectPluginMw("GET", resolveRouterPluginMw(fastify, false)),
+		routeGuards
+	});
+	const rateLimitConfig = buildRateLimitConfig(config.rateLimit ? {
+		max: config.rateLimit.max,
+		timeWindow: `${config.rateLimit.windowMs}ms`
+	} : void 0);
+	const handler = buildAggregationHandler(normalized, {
+		repo: repository,
+		buildOptions
+	});
+	const routeSchema = {
+		tags: tag ? [tag] : void 0,
+		summary: config.summary ?? `Aggregation: ${name}`,
+		description: config.description ?? "Portable aggregation generated by arc. Filters from query string compose with the declaration's base filter + tenant scope."
+	};
+	fastify.route({
+		method: "GET",
+		url: `/aggregations/${name}`,
+		schema: routeSchema,
+		preHandler: preHandler.length > 0 ? preHandler : void 0,
+		...rateLimitConfig ? { config: rateLimitConfig } : {},
+		handler: async (req, reply) => {
+			try {
+				return await handler(req, reply);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				req.log.error({
+					err,
+					aggregation: name
+				}, "Aggregation handler error");
+				throw createError(500, `Aggregation "${name}" failed: ${message}`);
+			}
+		}
+	});
+}
+/**
+* Minimal `PermissionContext` for aggregation routes. Aggregations are
+* read-shape so the action is `'list'` and `data` / `resourceId` stay
+* undefined unless the URL includes them (none do today — `:name` is
+* the only path param).
+*/
+function buildPermissionContextLite(req, aggregationName) {
+	const reqWithExtras = req;
+	return {
+		user: reqWithExtras.user ?? null,
+		request: req,
+		resource: reqWithExtras.arc?.resource ?? "aggregation",
+		action: `aggregation:${aggregationName}`
+	};
+}
+/** PermissionCheck returns `boolean | PermissionResult`. Pull `granted`. */
+function normalizePermissionGranted(raw) {
+	if (typeof raw === "boolean") return raw;
+	return raw.granted;
+}
+/** Pull `reason` when the check returned a structured `PermissionResult`. */
+function normalizePermissionReason(raw) {
+	if (typeof raw === "boolean") return void 0;
+	return raw.reason;
+}
+//#endregion
+export { createAggregationRouter };

package/dist/{createApp-BFxtdKy6.mjs → createApp-XX2-N0Yd.mjs}

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { n as PUBLIC_SCOPE } from "./types-AOD8fxIw.mjs";
+import { arcLog } from "./logger/index.mjs";
+import { n as PUBLIC_SCOPE } from "./types-C_s5moIu.mjs";
 import Fastify from "fastify";
 import qs from "qs";
 //#region src/factory/presets.ts
@@ -117,10 +118,7 @@ const developmentPreset = {
 		]
 	},
 	rateLimit: false,
-	underPressure: {
-		exposeStatusRoute: true,
-		maxEventLoopDelay: 5e3
-	}
+	underPressure: false
 };
 /**
 * Testing preset - minimal setup, fast startup
@@ -204,7 +202,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-KrFIQ097.mjs").then((n) => n.n);
+		const { default: eventPlugin } = await import("./eventPlugin-CaKTYkYM.mjs").then((n) => n.n);
 		const eventOpts = typeof config.arcPlugins?.events === "object" ? config.arcPlugins.events : {};
 		await fastify.register(eventPlugin, {
 			...eventOpts,
@@ -240,15 +238,15 @@ async function registerArcPlugins(fastify, config, trackPlugin, modules) {
 		trackPlugin("arc-graceful-shutdown");
 	}
 	if (config.arcPlugins?.caching) {
-		const { default: cachingPlugin } = await import("./caching-CheW3m-S.mjs").then((n) => n.r);
+		const { default: cachingPlugin } = await import("./caching-SM8gghN6.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-Bq6bO6vc.mjs").then((n) => n.n);
+		const { queryCachePlugin } = await import("./queryCachePlugin-m1XsgAIJ.mjs").then((n) => n.n);
 		const opts = config.arcPlugins.queryCache === true ? {} : config.arcPlugins.queryCache;
-		const store = config.stores?.queryCache ?? new (await (import("./memory-DikHSvWa.mjs").then((n) => n.n))).MemoryCacheStore();
+		const store = config.stores?.queryCache ?? new (await (import("./memory-UBydS5ku.mjs").then((n) => n.n))).MemoryCacheStore();
 		await fastify.register(queryCachePlugin, {
 			store,
 			...opts
@@ -257,19 +255,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-V7aXc3bW.mjs").then((n) => n.r);
+		const { default: ssePlugin } = await import("./sse-Bz-5ZeTt.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-Csh4nsvv.mjs").then((n) => n.r);
+		const { default: metricsPlugin } = await import("./metrics-Qnvwc-LQ.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-CGPjkqAg.mjs").then((n) => n.r);
+		const { default: versioningPlugin } = await import("./versioning-BUrT5aP4.mjs").then((n) => n.r);
 		await fastify.register(versioningPlugin, config.arcPlugins.versioning);
 		trackPlugin("arc-versioning", config.arcPlugins.versioning);
 	}
@@ -338,7 +336,7 @@ async function registerAuth(fastify, config, trackPlugin) {
 */
 async function registerElevation(fastify, config, trackPlugin) {
 	if (!config.elevation) return;
-	const { elevationPlugin } = await import("./elevation-DOFoxoDs.mjs").then((n) => n.r);
+	const { elevationPlugin } = await import("./elevation-DgoeTyfX.mjs").then((n) => n.r);
 	await fastify.register(elevationPlugin, config.elevation);
 	trackPlugin("arc-elevation", config.elevation);
 	fastify.log.debug("Elevation plugin enabled");
@@ -348,7 +346,7 @@ async function registerElevation(fastify, config, trackPlugin) {
 */
 async function registerErrorHandler(fastify, config, trackPlugin) {
 	if (config.errorHandler === false) return;
-	const { errorHandlerPlugin } = await import("./errorHandler-BQm8ZxTK.mjs").then((n) => n.r);
+	const { errorHandlerPlugin } = await import("./errorHandler-Bk-AGhkU.mjs").then((n) => n.r);
 	const errorOpts = typeof config.errorHandler === "object" ? config.errorHandler : { includeStack: config.preset !== "production" };
 	await fastify.register(errorHandlerPlugin, errorOpts);
 	trackPlugin("arc-error-handler", errorOpts);
@@ -402,7 +400,7 @@ async function registerOne(parent, resource) {
 }
 /**
 * Execute the full resource lifecycle:
-* 1. plugins()                   — infra (DB, docs, webhooks)
+* 1. plugins()                   — infra (DB, data, webhooks)
 * 2. bootstrap[]                 — domain init (singletons, event handlers)
 * 3. resources factory (if any)  — resolved AFTER bootstrap, so engine-backed
 *                                  adapters can `await ensureEngine()` and pass
@@ -448,7 +446,7 @@ async function registerResources(fastify, config) {
 	let discoveryPath;
 	let discoveryYieldedZero = false;
 	if (resolvedResources === void 0 && config.resourceDir) {
-		const { loadResources } = await import("./loadResources-CPpkyKfM.mjs").then((n) => n.n);
+		const { loadResources } = await import("./loadResources-DBMQg_Aj.mjs").then((n) => n.n);
 		const { resolve, dirname } = await import("node:path");
 		const { fileURLToPath } = await import("node:url");
 		const rawDir = config.resourceDir;
@@ -605,7 +603,8 @@ async function registerSecurityPlugins(fastify, config) {
 	if (config.cors !== false) {
 		const cors = await loadPlugin("cors");
 		const corsOptions = { ...config.cors ?? {} };
-		if (config.preset === "production" && corsOptions && !("origin" in corsOptions)) fastify.log.warn("CORS origin is not explicitly configured in production. Set cors.origin to allowed domains, cors: { origin: '*' }, or cors: false to disable.");
+		const originDeclared = "origin" in corsOptions && corsOptions.origin !== void 0;
+		if (config.preset === "production" && !originDeclared) fastify.log.warn("CORS origin is not explicitly configured in production. Browser apps: set cors.origin to allowed domains (e.g. ['https://app.example.com']) with credentials: true. Server-to-server / API-key services: cors: { origin: '*', credentials: false } OR cors: false to disable. Tip: when wiring cors.origin from an env var, fail fast on missing (`if (!process.env.ALLOWED_ORIGINS) throw ...`) instead of letting `undefined` slip through.");
 		if (corsOptions.credentials && corsOptions.origin === "*") corsOptions.origin = true;
 		await fastify.register(cors, corsOptions);
 		fastify.log.debug("CORS enabled");
@@ -747,7 +746,7 @@ function validateDistributedRuntime(options) {
 * 4. Arc core (fastify.arc, events)
 * 5. Arc plugins (requestId, health, caching, SSE, metrics, versioning)
 * 6. Auth (scope decoration, auth strategy, elevation, error handler)
-* 7. plugins()        — user infra (DB, docs, webhooks)
+* 7. plugins()        — user infra (DB, data, webhooks)
 * 8. bootstrap[]      — domain init (singletons, event handlers)
 * 9. resources[]      — auto-discovered routes (prefix + skipGlobalPrefix)
 * 10. afterResources() — post-registration wiring
@@ -812,17 +811,22 @@ async function createApp(options) {
 	await registerErrorHandler(fastify, config, trackPlugin);
 	await registerResources(fastify, config);
 	if (config.replyHelpers) {
-		const { replyHelpersPlugin } = await import("./replyHelpers-ByllIXXV.mjs").then((n) => n.n);
+		const { replyHelpersPlugin } = await import("./replyHelpers-CK-FNO8E.mjs").then((n) => n.n);
 		await fastify.register(replyHelpersPlugin);
 	}
-	if (config.serializeBigInt) fastify.addHook("preSerialization", async (_request, _reply, payload) => {
-		if (payload === null || payload === void 0) return payload;
-		try {
-			return JSON.parse(JSON.stringify(payload, (_key, value) => typeof value === "bigint" ? Number(value) : value));
-		} catch {
-			return payload;
-		}
-	});
+	if (config.serializeBigInt) {
+		const mode = config.serializeBigInt === "string" ? "string" : "number";
+		if (config.serializeBigInt === true) arcLog("createApp").warn("serializeBigInt: true is a back-compat alias for 'number' (lossy above Number.MAX_SAFE_INTEGER = 9007199254740991). For IDs / money / counters / ledger values use serializeBigInt: 'string' (lossless). The boolean form will be removed in a future major.");
+		else if (mode === "number") arcLog("createApp").warn("serializeBigInt: 'number' loses precision above Number.MAX_SAFE_INTEGER (9007199254740991). Use 'string' instead unless you've audited that no bigint payload field can exceed the safe range.");
+		fastify.addHook("preSerialization", async (_request, _reply, payload) => {
+			if (payload === null || payload === void 0) return payload;
+			try {
+				return JSON.parse(JSON.stringify(payload, (_key, value) => typeof value === "bigint" ? mode === "string" ? value.toString() : Number(value) : value));
+			} catch {
+				return payload;
+			}
+		});
+	}
 	const authMode = config.auth === false ? "none" : config.auth ? config.auth.type : "none";
 	fastify.log.info({
 		preset: config.preset ?? "custom",

package/dist/defineEvent-D5h7EvAx.mjs

@@ -0,0 +1,188 @@
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
+import { n as createEvent } from "./EventTransport-DLWoUMHy.mjs";
+//#region src/events/defineEvent.ts
+/**
+* defineEvent — Typed Event Definitions with Optional Schema Validation
+*
+* Provides:
+* 1. defineEvent() — declare an event with name, schema, version, description
+* 2. EventRegistry — catalog of all known events + payload validation
+* 3. .create() helper — build DomainEvent with auto-generated metadata
+*
+* The built-in validator checks: object type, required fields, and top-level
+* property types. It does NOT recurse into nested objects, validate arrays,
+* enums, patterns, formats, or $ref. This is intentional — it's a lightweight
+* guard, not a full JSON Schema engine.
+*
+* For full validation, pass a custom `validate` function to `createEventRegistry()`:
+*
+* @example
+* ```typescript
+* import Ajv from 'ajv';
+* const ajv = new Ajv();
+*
+* const registry = createEventRegistry({
+*   validate: (schema, payload) => {
+*     const valid = ajv.validate(schema, payload);
+*     return valid
+*       ? { valid: true }
+*       : { valid: false, errors: ajv.errorsText().split(', ') };
+*   },
+* });
+* ```
+*
+* @example
+* ```typescript
+* import { defineEvent, createEventRegistry } from '@classytic/arc/events';
+*
+* const OrderCreated = defineEvent({
+*   name: 'order.created',
+*   version: 1,
+*   schema: {
+*     type: 'object',
+*     properties: {
+*       orderId: { type: 'string' },
+*       total: { type: 'number' },
+*     },
+*     required: ['orderId', 'total'],
+*   },
+* });
+*
+* // Type-safe event creation
+* const event = OrderCreated.create({ orderId: 'o-1', total: 100 });
+* await fastify.events.publish(event.type, event.payload, event.meta);
+*
+* // Registry for introspection + validation
+* const registry = createEventRegistry();
+* registry.register(OrderCreated);
+* const result = registry.validate('order.created', payload);
+* ```
+*/
+var defineEvent_exports = /* @__PURE__ */ __exportAll({
+	createEventRegistry: () => createEventRegistry,
+	defineEvent: () => defineEvent
+});
+/**
+* Define a typed event with optional schema validation.
+*
+* @example
+* const OrderCreated = defineEvent({
+*   name: 'order.created',
+*   schema: { type: 'object', properties: { orderId: { type: 'string' } }, required: ['orderId'] },
+* });
+*
+* const event = OrderCreated.create({ orderId: '123' });
+*/
+function defineEvent(input) {
+	const { name, schema, version = 1, description } = input;
+	return {
+		name,
+		schema,
+		version,
+		description,
+		create(payload, meta) {
+			return createEvent(name, payload, {
+				schemaVersion: version,
+				...meta
+			});
+		}
+	};
+}
+/**
+* Create an event registry for cataloging and validating events.
+*
+* The registry is opt-in — unregistered events pass validation.
+* This allows gradual adoption without breaking existing code.
+*
+* @param options.validate - Custom validator replacing the built-in minimal validator.
+*   The built-in validator only checks top-level object structure (type, required, property types).
+*   For nested objects, arrays, enums, patterns, or $ref, provide AJV or similar.
+*/
+function createEventRegistry(options) {
+	const customValidator = options?.validate;
+	const definitions = /* @__PURE__ */ new Map();
+	function registryKey(name, version) {
+		return `${name}:v${version}`;
+	}
+	return {
+		register(definition) {
+			const key = registryKey(definition.name, definition.version);
+			if (definitions.has(key)) throw new Error(`Event '${definition.name}' v${definition.version} is already registered. Use a different version number for schema evolution.`);
+			definitions.set(key, definition);
+		},
+		get(name, version) {
+			if (version !== void 0) return definitions.get(registryKey(name, version));
+			let latest;
+			let latestVersion = -1;
+			for (const def of definitions.values()) if (def.name === name && def.version > latestVersion) {
+				latest = def;
+				latestVersion = def.version;
+			}
+			return latest;
+		},
+		catalog() {
+			return Array.from(definitions.values()).map((def) => ({
+				name: def.name,
+				version: def.version,
+				description: def.description,
+				schema: def.schema
+			}));
+		},
+		validate(name, payload, version) {
+			let target = version !== void 0 ? definitions.get(registryKey(name, version)) : void 0;
+			if (!target && version === void 0) {
+				let latestVersion = -1;
+				for (const candidate of definitions.values()) if (candidate.name === name && candidate.version > latestVersion) {
+					target = candidate;
+					latestVersion = candidate.version;
+				}
+			}
+			if (!target) return { valid: true };
+			if (!target.schema) return { valid: true };
+			return customValidator ? customValidator(target.schema, payload) : validatePayload(payload, target.schema);
+		}
+	};
+}
+/**
+* Built-in minimal validator — lightweight guard, NOT a full JSON Schema engine.
+*
+* Checks:
+* - payload is an object (not null, not array)
+* - required fields are present
+* - top-level property types match (string, number, boolean, array, object)
+*
+* Does NOT check:
+* - nested object properties
+* - array item types
+* - enum, pattern, format, minLength, minimum, $ref
+*
+* For full validation, pass a custom `validate` function to `createEventRegistry()`.
+*/
+function validatePayload(payload, schema) {
+	const errors = [];
+	if (schema.type === "object") {
+		if (payload === null || payload === void 0 || typeof payload !== "object" || Array.isArray(payload)) return {
+			valid: false,
+			errors: ["Payload must be an object"]
+		};
+		const record = payload;
+		if (schema.required) {
+			for (const field of schema.required) if (!(field in record) || record[field] === void 0) errors.push(`Missing required field: '${field}'`);
+		}
+		if (schema.properties) {
+			for (const [key, propSchema] of Object.entries(schema.properties)) if (key in record && record[key] !== void 0 && record[key] !== null) {
+				const expectedType = propSchema.type;
+				if (expectedType) {
+					const actualType = Array.isArray(record[key]) ? "array" : typeof record[key];
+					if (expectedType !== actualType) errors.push(`Field '${key}': expected ${expectedType}, got ${actualType}`);
+				}
+			}
+		}
+	}
+	return errors.length === 0 ? { valid: true } : {
+		valid: false,
+		errors
+	};
+}
+//#endregion
+export { defineEvent as n, defineEvent_exports as r, createEventRegistry as t };

package/dist/docs/index.d.mts

@@ -1,5 +1,5 @@
-import { p as RegistryEntry } from "../index-6u4_Gg6G.mjs";
-import { t as ExternalOpenApiPaths } from "../externalPaths-Bapitwvd.mjs";
+import { p as RegistryEntry } from "../index-BtW7qYwa.mjs";
+import { t as ExternalOpenApiPaths } from "../externalPaths-BD5nw6St.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-DV9WDfeg.mjs";
-import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-BGUn7Ki1.mjs";
+import { t as getUserRoles } from "../types-D57iXYb8.mjs";
+import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-CiOMVW1p.mjs";
 import fp from "fastify-plugin";
 //#region src/docs/scalar.ts
 const scalarPlugin = async (fastify, opts = {}) => {

package/dist/{elevation-DOFoxoDs.mjs → elevation-DgoeTyfX.mjs}

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