@classytic/arc 2.3.0 → 2.4.2

package/dist/discovery/index.mjs

@@ -1,16 +1,49 @@
 import { extname, join, resolve } from "node:path";
-import { readdir } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
-
+import { readdir } from "node:fs/promises";
 //#region src/discovery/index.ts
 /**
+* Arc Auto-Discovery Plugin
+*
+* Automatically discovers and registers resource files matching a glob pattern.
+* Eliminates manual resource registration boilerplate.
+*
+* This is a SEPARATE subpath import — only loaded when explicitly used:
+*   import { discoveryPlugin, discoverResources } from '@classytic/arc/discovery';
+*
+* Serverless-safe: only runs at startup, no persistent process needed.
+*
+* @example
+* ```typescript
+* import { discoveryPlugin } from '@classytic/arc/discovery';
+*
+* // Auto-discovers all *.resource.ts files
+* await fastify.register(discoveryPlugin, {
+*   paths: ['./src/modules'],
+*   pattern: '**\/*.resource.{ts,js}',
+* });
+*
+* // Or use the helper directly
+* import { discoverResources } from '@classytic/arc/discovery';
+*
+* const resources = await discoverResources({
+*   paths: ['./src/modules'],
+*   pattern: '**\/*.resource.{ts,js}',
+* });
+*
+* for (const resource of resources) {
+*   await fastify.register(resource.toPlugin());
+* }
+* ```
+*/
+/**
 * Match a filename against a simple pattern.
 * Supports: *.resource.ts, *.resource.js, *.resource.{ts,js}
 */
 function matchPattern(filename, pattern) {
 	if (pattern.includes("{") && pattern.includes("}")) {
 		const match = pattern.match(/\{([^}]+)\}/);
-		if (match) return match[1].split(",").map((s) => s.trim()).some((alt) => {
+		if (match) return (match[1]?.split(",").map((s) => s.trim()) ?? []).some((alt) => {
 			return matchPattern(filename, pattern.replace(match[0], alt));
 		});
 	}
@@ -104,6 +137,5 @@ const discoveryPluginImpl = async (fastify, options) => {
 };
 /** Auto-discovery plugin for Arc resources */
 const discoveryPlugin = discoveryPluginImpl;
-
 //#endregion
-export { discoveryPlugin as default, discoveryPlugin, discoverResources };
+export { discoveryPlugin as default, discoveryPlugin, discoverResources };

package/dist/docs/index.d.mts

@@ -1,8 +1,5 @@
-import "../elevation-DGo5shaX.mjs";
-import "../interface-BtdYtQUA.mjs";
-import "../types-RLkFVgaw.mjs";
-import { RegistryEntry } from "../types/index.mjs";
-import { t as ExternalOpenApiPaths } from "../externalPaths-SyPF2tgK.mjs";
+import { Q as RegistryEntry } from "../interface-DGmPxakH.mjs";
+import { t as ExternalOpenApiPaths } from "../externalPaths-DpO-s7r8.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/docs/openapi.d.ts
@@ -74,19 +71,19 @@ interface Operation {
   responses: Record<string, Response>;
   security?: Array<Record<string, string[]>>;
   /** Arc permission metadata (OpenAPI extension) */
-  'x-arc-permission'?: {
+  "x-arc-permission"?: {
     type: string;
     roles?: readonly string[];
   };
   /** Arc pipeline steps (OpenAPI extension) */
-  'x-arc-pipeline'?: Array<{
+  "x-arc-pipeline"?: Array<{
     type: string;
     name: string;
   }>;
 }
 interface Parameter {
   name: string;
-  in: 'path' | 'query' | 'header';
+  in: "path" | "query" | "header";
   required?: boolean;
   schema: SchemaObject;
   description?: string;
@@ -144,7 +141,7 @@ interface ScalarOptions {
   /** Page title */
   title?: string;
   /** Theme (default: 'default') */
-  theme?: 'default' | 'alternate' | 'moon' | 'purple' | 'solarized' | 'bluePlanet' | 'saturn' | 'kepler' | 'mars' | 'deepSpace';
+  theme?: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "saturn" | "kepler" | "mars" | "deepSpace";
   /** Show sidebar (default: true) */
   showSidebar?: boolean;
   /** Dark mode (default: false) */

package/dist/docs/index.mjs

@@ -1,24 +1,7 @@
-import { t as getUserRoles } from "../types-DelU6kln.mjs";
-import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-9nB_kiuR.mjs";
+import { t as getUserRoles } from "../types-ZUu_h0jp.mjs";
+import { n as openApiPlugin, r as openapi_default, t as buildOpenApiSpec } from "../openapi-CBmZ6EQN.mjs";
 import fp from "fastify-plugin";
-
 //#region src/docs/scalar.ts
-/**
-* Scalar API Reference Plugin
-*
-* Beautiful, modern API documentation UI.
-* Lighter and more modern than Swagger UI.
-*
-* @example
-* import { scalarPlugin } from '@classytic/arc/docs';
-*
-* await fastify.register(scalarPlugin, {
-*   routePrefix: '/docs',
-*   specUrl: '/_docs/openapi.json',
-* });
-*
-* // UI available at /docs
-*/
 const scalarPlugin = async (fastify, opts = {}) => {
 	const { routePrefix = "/docs", specUrl = "/_docs/openapi.json", title = "API Documentation", theme = "default", showSidebar = true, darkMode = false, authRoles = [], customCss = "", favicon } = opts;
 	const scalarConfig = JSON.stringify({
@@ -69,6 +52,5 @@ var scalar_default = fp(scalarPlugin, {
 	name: "arc-scalar",
 	fastify: "5.x"
 });
-
 //#endregion
-export { buildOpenApiSpec, openapi_default as openApiPlugin, openApiPlugin as openApiPluginFn, scalar_default as scalarPlugin, scalarPlugin as scalarPluginFn };
+export { buildOpenApiSpec, openapi_default as openApiPlugin, openApiPlugin as openApiPluginFn, scalar_default as scalarPlugin, scalarPlugin as scalarPluginFn };

package/dist/dynamic/index.d.mts

@@ -0,0 +1,93 @@
+import { Lt as ResourceDefinition, n as DataAdapter } from "../interface-DGmPxakH.mjs";
+import { t as PermissionCheck } from "../types-BNUccdcf.mjs";
+
+//#region src/dynamic/ArcDynamicLoader.d.ts
+interface ArcArchitectureSchema {
+  /** Application name */
+  app: string;
+  /** Resources to provision */
+  resources: ArcResourceSchema[];
+}
+/** Field type — maps to JSON Schema / Zod types */
+type ArcFieldType = "string" | "number" | "boolean" | "date" | "object" | "array";
+/** Per-field definition — matches Arc's FieldRuleEntry for MCP compatibility */
+interface ArcFieldSchema {
+  type: ArcFieldType;
+  required?: boolean;
+  description?: string;
+  enum?: string[];
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  /** System-managed fields (createdAt, updatedAt) — excluded from create/update schemas */
+  systemManaged?: boolean;
+  /** Immutable after creation (e.g. slug, organizationId) */
+  immutable?: boolean;
+}
+/** Permission preset name — matches Arc's built-in presets */
+type ArcPermissionPreset = "publicRead" | "publicReadAdminWrite" | "authenticated" | "adminOnly" | "ownerWithAdminBypass" | "fullPublic" | "readOnly";
+/** Fine-grained per-operation permission */
+interface ArcPermissionMap {
+  list?: "public" | "auth" | "admin";
+  get?: "public" | "auth" | "admin";
+  create?: "auth" | "admin";
+  update?: "auth" | "admin" | "owner";
+  delete?: "auth" | "admin" | "owner";
+}
+interface ArcResourceSchema {
+  /** Resource name (e.g., 'product', 'user') — used for URL prefix and tool names */
+  name: string;
+  /** Display name for docs and MCP descriptions (defaults to capitalized name) */
+  displayName?: string;
+  /** Custom URL prefix (defaults to `/${name}s`) */
+  prefix?: string;
+  /** Adapter resolution key — passed to adapterResolver */
+  adapterPattern?: string;
+  /** Permission preset name or fine-grained per-operation map */
+  permissions: ArcPermissionPreset | ArcPermissionMap;
+  /** Presets to apply (e.g., 'softDelete', 'slugLookup', 'bulk') */
+  presets?: string[];
+  /** Field definitions — drives schemaOptions.fieldRules for validation and MCP tool schemas */
+  fields?: Record<string, ArcFieldSchema | ArcFieldType>;
+  /** Fields allowed for filtering in list operations (drives queryParser + MCP) */
+  filterable?: string[];
+  /** Fields allowed for sorting (drives queryParser + MCP) */
+  sortable?: string[];
+  /** CRUD operations to disable (e.g., ['delete'] for append-only resources) */
+  disabledRoutes?: string[];
+  /** Tenant field name for multi-tenant resources */
+  tenantField?: string;
+}
+interface DynamicLoaderContext {
+  /** Resolve a data adapter for a resource — receives name and optional pattern key */
+  adapterResolver: (resourceName: string, pattern?: string) => DataAdapter;
+  /** Resolve custom permission checks beyond built-in presets */
+  permissionResolver?: (policy: string) => PermissionCheck;
+}
+/**
+ * Load an Arc Architecture Schema (JSON) and produce fully configured ResourceDefinitions.
+ *
+ * Each resource gets:
+ * - Adapter from the resolver
+ * - Permissions from presets or fine-grained map
+ * - schemaOptions.fieldRules for validation and MCP tool schemas
+ * - ArcQueryParser with allowedFilterFields/allowedSortFields for MCP auto-derive
+ * - Presets applied
+ */
+declare class ArcDynamicLoader {
+  private context;
+  constructor(context: DynamicLoaderContext);
+  /**
+   * Load an AAS definition and return fully constructed ResourceDefinitions.
+   * Validates the schema before processing — throws on malformed input.
+   */
+  load(schema: ArcArchitectureSchema): ResourceDefinition<unknown>[];
+  private buildFieldRules;
+  private buildQueryParser;
+  private resolvePermissions;
+  private resolvePreset;
+  private resolveFinGrained;
+}
+//#endregion
+export { ArcArchitectureSchema, ArcDynamicLoader, ArcFieldSchema, ArcFieldType, ArcPermissionMap, ArcPermissionPreset, ArcResourceSchema, DynamicLoaderContext };

package/dist/dynamic/index.mjs

@@ -0,0 +1,122 @@
+import { t as ArcQueryParser } from "../queryParser-CgCtsjti.mjs";
+import { n as defineResource } from "../defineResource-D9aY5Cy6.mjs";
+import { _ as ownerWithAdminBypass, b as publicReadAdminWrite, g as fullPublic, h as authenticated, m as adminOnly, x as readOnly, y as publicRead } from "../permissions-CA5zg0yK.mjs";
+//#region src/dynamic/ArcDynamicLoader.ts
+const VALID_FIELD_TYPES = new Set([
+	"string",
+	"number",
+	"boolean",
+	"date",
+	"object",
+	"array"
+]);
+function validateSchema(schema) {
+	if (!schema.app || typeof schema.app !== "string") throw new Error("AAS: 'app' name is required");
+	if (!Array.isArray(schema.resources) || schema.resources.length === 0) throw new Error("AAS: 'resources' must be a non-empty array");
+	for (const r of schema.resources) {
+		if (!r.name || typeof r.name !== "string") throw new Error("AAS: each resource must have a 'name' string");
+		if (!r.permissions) throw new Error(`AAS: resource "${r.name}" must have 'permissions'`);
+		if (r.fields) for (const [fieldName, fieldDef] of Object.entries(r.fields)) {
+			const type = typeof fieldDef === "string" ? fieldDef : fieldDef.type;
+			if (!VALID_FIELD_TYPES.has(type)) throw new Error(`AAS: resource "${r.name}" field "${fieldName}" has invalid type "${type}". Valid types: ${[...VALID_FIELD_TYPES].join(", ")}`);
+		}
+	}
+}
+/**
+* Load an Arc Architecture Schema (JSON) and produce fully configured ResourceDefinitions.
+*
+* Each resource gets:
+* - Adapter from the resolver
+* - Permissions from presets or fine-grained map
+* - schemaOptions.fieldRules for validation and MCP tool schemas
+* - ArcQueryParser with allowedFilterFields/allowedSortFields for MCP auto-derive
+* - Presets applied
+*/
+var ArcDynamicLoader = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	/**
+	* Load an AAS definition and return fully constructed ResourceDefinitions.
+	* Validates the schema before processing — throws on malformed input.
+	*/
+	load(schema) {
+		validateSchema(schema);
+		return schema.resources.map((r) => {
+			const adapter = this.context.adapterResolver(r.name, r.adapterPattern);
+			const fieldRules = this.buildFieldRules(r.fields);
+			const queryParser = this.buildQueryParser(r);
+			return defineResource({
+				name: r.name,
+				displayName: r.displayName,
+				prefix: r.prefix,
+				adapter,
+				queryParser,
+				presets: r.presets,
+				permissions: this.resolvePermissions(r.permissions),
+				disabledRoutes: r.disabledRoutes,
+				tenantField: r.tenantField,
+				schemaOptions: fieldRules ? {
+					fieldRules,
+					filterableFields: r.filterable
+				} : void 0
+			});
+		});
+	}
+	buildFieldRules(fields) {
+		if (!fields) return void 0;
+		const rules = {};
+		for (const [name, def] of Object.entries(fields)) rules[name] = typeof def === "string" ? { type: def } : def;
+		return rules;
+	}
+	buildQueryParser(r) {
+		if (!r.filterable && !r.sortable) return void 0;
+		return new ArcQueryParser({
+			allowedFilterFields: r.filterable,
+			allowedSortFields: r.sortable
+		});
+	}
+	resolvePermissions(policy) {
+		if (typeof policy === "string") return this.resolvePreset(policy);
+		return this.resolveFinGrained(policy);
+	}
+	resolvePreset(preset) {
+		switch (preset) {
+			case "publicRead": return publicRead();
+			case "publicReadAdminWrite": return publicReadAdminWrite();
+			case "authenticated": return authenticated();
+			case "adminOnly": return adminOnly();
+			case "ownerWithAdminBypass": return ownerWithAdminBypass();
+			case "fullPublic": return fullPublic();
+			case "readOnly": return readOnly();
+			default:
+				if (this.context.permissionResolver) {
+					const resolved = this.context.permissionResolver(preset);
+					if (resolved) return resolved;
+				}
+				throw new Error(`Unknown permission preset: "${preset}"`);
+		}
+	}
+	resolveFinGrained(policy) {
+		const pick = (preset, op) => preset[op] ?? authenticated()[op];
+		const map = {
+			public: (op) => pick(publicRead(), op),
+			auth: (op) => pick(authenticated(), op),
+			admin: (op) => pick(adminOnly(), op),
+			owner: (op) => pick(ownerWithAdminBypass(), op)
+		};
+		const permissions = {};
+		const ops = {
+			list: policy.list,
+			get: policy.get,
+			create: policy.create,
+			update: policy.update,
+			delete: policy.delete
+		};
+		for (const [op, level] of Object.entries(ops)) if (level && map[level]) permissions[op] = map[level](op);
+		return permissions;
+	}
+};
+//#endregion
+export { ArcDynamicLoader };

package/dist/{elevation-DSTbVvYj.mjs → elevation-BEdACOLB.mjs}

@@ -1,39 +1,8 @@
-import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
-import { t as getUserRoles } from "./types-DelU6kln.mjs";
-import { t as arcLog } from "./logger-ByrvQWZO.mjs";
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
+import { t as getUserRoles } from "./types-ZUu_h0jp.mjs";
+import { t as arcLog } from "./logger-Dz3j1ItV.mjs";
 import fp from "fastify-plugin";
-
 //#region src/scope/elevation.ts
-/**
-* Elevation Plugin — Explicit Platform Admin Access
-*
-* Opt-in Fastify plugin that allows platform admins to explicitly
-* elevate their scope via the `x-arc-scope: platform` header.
-*
-* Without this header, a superadmin is treated as a normal user.
-* This prevents implicit bypass and enables audit logging.
-*
-* ## Lifecycle
-*
-* Elevation wraps `fastify.authenticate` so it always runs AFTER
-* authentication has set `request.user`. This avoids the `onRequest`
-* timing issue where `request.user` doesn't exist yet.
-*
-* Flow: `authenticate()` → user is set → `elevation check` → scope is set
-*
-* Inspired by Stripe Connect's `Stripe-Account` header.
-*
-* @example
-* ```typescript
-* const app = await createApp({
-*   auth: { type: 'betterAuth', betterAuth: adapter },
-*   elevation: {
-*     platformRoles: ['superadmin'],
-*     onElevation: (event) => auditLog.write(event),
-*   },
-* });
-* ```
-*/
 var elevation_exports = /* @__PURE__ */ __exportAll({
 	default: () => elevation_default,
 	elevationPlugin: () => elevationPlugin
@@ -80,6 +49,7 @@ const elevationPlugin = async (fastify, opts = {}) => {
 		const userId = String(user.id ?? user._id ?? "unknown");
 		request.scope = {
 			kind: "elevated",
+			userId,
 			organizationId: orgId || void 0,
 			elevatedBy: userId
 		};
@@ -108,6 +78,5 @@ var elevation_default = fp(elevationPlugin, {
 	name: "arc-elevation",
 	fastify: "5.x"
 });
-
 //#endregion
-export { elevation_default as n, elevation_exports as r, elevationPlugin as t };
+export { elevation_default as n, elevation_exports as r, elevationPlugin as t };

package/dist/{elevation-DGo5shaX.d.mts → elevation-Ca_yveIO.d.mts}

@@ -15,6 +15,10 @@ import { FastifyPluginAsync, FastifyRequest } from "fastify";
  * const scope = request.scope;
  * if (isElevated(scope)) return true;
  * if (isMember(scope) && scope.orgRoles.includes('admin')) return true;
+ *
+ * // Get user identity from scope
+ * const userId = getUserId(scope);
+ * const globalRoles = getUserRoles(scope);
  * ```
  */
 /**
@@ -26,28 +30,36 @@ import { FastifyPluginAsync, FastifyRequest } from "fastify";
  * | authenticated | Logged in, no org context          |
  * | member        | In an org with specific roles      |
  * | elevated      | Platform admin, explicit elevation |
+ *
+ * `userId` and `userRoles` are available on all authenticated variants.
+ * `orgRoles` are org-level roles (from membership); `userRoles` are global roles (from user document).
  */
 type RequestScope = {
-  kind: 'public';
+  kind: "public";
 } | {
-  kind: 'authenticated';
+  kind: "authenticated";
+  userId?: string;
+  userRoles?: string[];
 } | {
-  kind: 'member';
+  kind: "member";
+  userId?: string;
+  userRoles: string[];
   organizationId: string;
   orgRoles: string[];
   teamId?: string;
 } | {
-  kind: 'elevated';
+  kind: "elevated";
+  userId?: string;
   organizationId?: string;
   elevatedBy: string;
 };
 /** Check if scope is `member` kind */
 declare function isMember(scope: RequestScope): scope is Extract<RequestScope, {
-  kind: 'member';
+  kind: "member";
 }>;
 /** Check if scope is `elevated` kind */
 declare function isElevated(scope: RequestScope): scope is Extract<RequestScope, {
-  kind: 'elevated';
+  kind: "elevated";
 }>;
 /** Check if scope has org access (member OR elevated) */
 declare function hasOrgAccess(scope: RequestScope): boolean;
@@ -59,6 +71,28 @@ declare function getOrgId(scope: RequestScope): string | undefined;
 declare function getOrgRoles(scope: RequestScope): string[];
 /** Get team ID from scope (only available on member kind) */
 declare function getTeamId(scope: RequestScope): string | undefined;
+/**
+ * Get userId from scope (available on authenticated, member, elevated).
+ *
+ * @example
+ * ```typescript
+ * import { getUserId } from '@classytic/arc/scope';
+ * const userId = getUserId(request.scope);
+ * ```
+ */
+declare function getUserId(scope: RequestScope): string | undefined;
+/**
+ * Get global user roles from scope (available on authenticated and member).
+ * These are user-level roles (e.g. superadmin, finance-admin) distinct from
+ * org-level roles (scope.orgRoles).
+ *
+ * @example
+ * ```typescript
+ * import { getUserRoles } from '@classytic/arc/scope';
+ * const globalRoles = getUserRoles(request.scope);
+ * ```
+ */
+declare function getUserRoles(scope: RequestScope): string[];
 /** Default public scope — used as initial decoration value */
 declare const PUBLIC_SCOPE: Readonly<RequestScope>;
 /** Default authenticated scope — used when user is logged in but no org */
@@ -84,4 +118,4 @@ interface ElevationEvent {
 declare const elevationPlugin: FastifyPluginAsync<ElevationOptions>;
 declare const _default: FastifyPluginAsync<ElevationOptions>;
 //#endregion
-export { AUTHENTICATED_SCOPE as a, getOrgId as c, hasOrgAccess as d, isAuthenticated as f, elevationPlugin as i, getOrgRoles as l, isMember as m, ElevationOptions as n, PUBLIC_SCOPE as o, isElevated as p, _default as r, RequestScope as s, ElevationEvent as t, getTeamId as u };
+export { AUTHENTICATED_SCOPE as a, getOrgId as c, getUserId as d, getUserRoles as f, isMember as g, isElevated as h, elevationPlugin as i, getOrgRoles as l, isAuthenticated as m, ElevationOptions as n, PUBLIC_SCOPE as o, hasOrgAccess as p, _default as r, RequestScope as s, ElevationEvent as t, getTeamId as u };

package/dist/{errorHandler-C3GY3_ow.mjs → errorHandler--zp54tGc.mjs}

@@ -1,7 +1,6 @@
-import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
-import { f as isArcError } from "./errors-DBANPbGr.mjs";
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
+import { f as isArcError } from "./errors-rxhfP7Hf.mjs";
 import fp from "fastify-plugin";
-
 //#region src/plugins/errorHandler.ts
 var errorHandler_exports = /* @__PURE__ */ __exportAll({
 	default: () => errorHandlerPlugin,
@@ -103,6 +102,5 @@ const errorHandlerPlugin = fp(errorHandlerPluginFn, {
 	name: "arc-error-handler",
 	fastify: "5.x"
 });
-
 //#endregion
-export { errorHandler_exports as n, errorHandlerPlugin as t };
+export { errorHandler_exports as n, errorHandlerPlugin as t };

package/dist/errorHandler-Do4vVQ1f.d.mts

@@ -0,0 +1,139 @@
+import { t as DomainEvent } from "./EventTransport-wc5hSLik.mjs";
+import { FastifyInstance, FastifyPluginAsync, FastifyRequest } from "fastify";
+
+//#region src/plugins/caching.d.ts
+interface CachingRule {
+  /** Path prefix to match (e.g., '/api/products') */
+  match: string;
+  /** Cache-Control max-age in seconds */
+  maxAge: number;
+  /** Cache-Control: private vs public (default: public) */
+  private?: boolean;
+  /** stale-while-revalidate directive in seconds */
+  staleWhileRevalidate?: number;
+}
+interface CachingOptions {
+  /** Default max-age in seconds for Cache-Control (default: 0 = no-cache) */
+  maxAge?: number;
+  /** Enable ETag generation (default: true) */
+  etag?: boolean;
+  /** Enable conditional requests — 304 Not Modified (default: true) */
+  conditional?: boolean;
+  /** HTTP methods to cache (default: ['GET', 'HEAD']) */
+  methods?: string[];
+  /** Paths to exclude from caching (prefix match) */
+  exclude?: string[];
+  /** Custom cache rules per path prefix */
+  rules?: CachingRule[];
+}
+declare const cachingPlugin: FastifyPluginAsync<CachingOptions>;
+declare const _default$3: FastifyPluginAsync<CachingOptions>;
+//#endregion
+//#region src/plugins/sse.d.ts
+interface SSEOptions {
+  /** SSE endpoint path (default: '/events/stream') */
+  path?: string;
+  /** Require authentication (default: true) */
+  requireAuth?: boolean;
+  /** Event patterns to stream (default: ['*'] = all) */
+  patterns?: string[];
+  /** Heartbeat interval in ms (default: 30000) */
+  heartbeat?: number;
+  /** Filter events by organizationId from request.scope (default: false) */
+  orgScoped?: boolean;
+  /** Custom event filter function */
+  filter?: (event: DomainEvent<unknown>, request: FastifyRequest) => boolean;
+}
+declare const ssePlugin: FastifyPluginAsync<SSEOptions>;
+declare const _default$2: FastifyPluginAsync<SSEOptions>;
+//#endregion
+//#region src/plugins/metrics.d.ts
+interface MetricsOptions {
+  /** Endpoint path (default: '/_metrics') */
+  path?: string;
+  /** Prefix for all metric names (default: 'arc') */
+  prefix?: string;
+  /** Called after metrics are collected (for OTLP push, etc.) */
+  onCollect?: (metrics: MetricEntry[]) => void;
+}
+interface MetricEntry {
+  name: string;
+  type: "counter" | "histogram" | "gauge";
+  help: string;
+  values: Array<{
+    labels: Record<string, string>;
+    value: number;
+  }>;
+}
+interface MetricsCollector {
+  /** Get all metrics as structured data */
+  collect(): MetricEntry[];
+  /** Reset all metrics */
+  reset(): void;
+  /** Record a CRUD operation */
+  recordOperation(resource: string, operation: string, status: number, durationMs: number): void;
+  /** Record a cache hit */
+  recordCacheHit(resource: string): void;
+  /** Record a cache miss */
+  recordCacheMiss(resource: string): void;
+  /** Record an event publish */
+  recordEventPublish(eventType: string): void;
+  /** Record an event consume */
+  recordEventConsume(eventType: string): void;
+  /** Record a circuit breaker state change */
+  recordCircuitBreakerState(service: string, state: string): void;
+}
+declare module "fastify" {
+  interface FastifyInstance {
+    metrics: MetricsCollector;
+  }
+}
+declare const metricsPlugin: FastifyPluginAsync<MetricsOptions>;
+declare const _default$1: FastifyPluginAsync<MetricsOptions>;
+//#endregion
+//#region src/plugins/versioning.d.ts
+interface VersioningOptions {
+  /** Versioning strategy */
+  type: "header" | "prefix";
+  /** Default version when none specified (default: '1') */
+  defaultVersion?: string;
+  /** Header name to read (default: 'accept-version') */
+  headerName?: string;
+  /** Response header name (default: 'x-api-version') */
+  responseHeader?: string;
+  /** Deprecated versions — adds Deprecation + Sunset headers */
+  deprecated?: string[];
+  /** Sunset date for deprecated versions (ISO 8601) */
+  sunset?: string;
+}
+declare module "fastify" {
+  interface FastifyRequest {
+    apiVersion: string;
+  }
+}
+declare const versioningPlugin: FastifyPluginAsync<VersioningOptions>;
+declare const _default: FastifyPluginAsync<VersioningOptions>;
+//#endregion
+//#region src/plugins/errorHandler.d.ts
+interface ErrorHandlerOptions {
+  /**
+   * Include stack trace in error responses (default: false in production)
+   */
+  includeStack?: boolean;
+  /**
+   * Custom error callback for logging to external services
+   */
+  onError?: (error: Error, request: FastifyRequest) => void | Promise<void>;
+  /**
+   * Map specific error types to custom responses
+   */
+  errorMap?: Record<string, {
+    statusCode: number;
+    code: string;
+    message?: string;
+  }>;
+}
+declare function errorHandlerPluginFn(fastify: FastifyInstance, options?: ErrorHandlerOptions): Promise<void>;
+declare const errorHandlerPlugin: typeof errorHandlerPluginFn;
+//#endregion
+export { cachingPlugin as _, versioningPlugin as a, MetricsOptions as c, SSEOptions as d, _default$2 as f, _default$3 as g, CachingRule as h, _default as i, _default$1 as l, CachingOptions as m, errorHandlerPlugin as n, MetricEntry as o, ssePlugin as p, VersioningOptions as r, MetricsCollector as s, ErrorHandlerOptions as t, metricsPlugin as u };

package/dist/{errors-DBANPbGr.mjs → errors-rxhfP7Hf.mjs}

@@ -206,6 +206,5 @@ function createError(statusCode, message, details) {
 function isArcError(error) {
 	return error instanceof ArcError;
 }
-
 //#endregion
-export { OrgAccessDeniedError as a, ServiceUnavailableError as c, createError as d, isArcError as f, NotFoundError as i, UnauthorizedError as l, ConflictError as n, OrgRequiredError as o, ForbiddenError as r, RateLimitError as s, ArcError as t, ValidationError as u };
+export { OrgAccessDeniedError as a, ServiceUnavailableError as c, createError as d, isArcError as f, NotFoundError as i, UnauthorizedError as l, ConflictError as n, OrgRequiredError as o, ForbiddenError as r, RateLimitError as s, ArcError as t, ValidationError as u };