@classytic/arc 2.21.0 → 2.23.0

package/dist/factory/index.d.mts

@@ -1,6 +1,7 @@
-import { a as getModuleExports, c as LoadResourcesOptions, d as loadResources, i as defineModule, l as ResourceLike, n as ArcModuleInput, o as orderModules, r as ArcModuleRegistry, s as resolveModule, t as ArcModule, u as ResourceModule } from "../module-WeuU5jfd.mjs";
-import "../fastify-augmentation-DafigGQp.mjs";
-import { a as CustomPluginAuthOption, c as RawBodyOptions, d as preloadResourcesAsync, i as CustomAuthenticatorOption, l as UnderPressureOptions, n as BetterAuthOption, o as JwtAuthOption, r as CreateAppOptions, s as MultipartOptions, t as AuthOption, u as preloadResources } from "../types-DpxoNX5v.mjs";
+import { a as getModuleExports, c as LoadResourcesOptions, d as loadResources, i as defineModule, l as ResourceLike, n as ArcModuleInput, o as orderModules, r as ArcModuleRegistry, s as resolveModule, t as ArcModule, u as ResourceModule } from "../module-B4u10iOJ.mjs";
+import "../fastify-augmentation-g_f9omSc.mjs";
+import { a as AuthOption, c as CustomPluginAuthOption, d as preloadResourcesAsync, i as UnderPressureOptions, l as JwtAuthOption, n as MultipartOptions, o as BetterAuthOption, r as RawBodyOptions, s as CustomAuthenticatorOption, t as CreateAppOptions, u as preloadResources } from "../index-Ba10fdKp.mjs";
+import { b as HealthCheck } from "../versioning-D6PvCwpq.mjs";
 import { FastifyInstance, FastifyServerOptions } from "fastify";
 //#region src/factory/createApp.d.ts
 /**
@@ -32,6 +33,29 @@ declare const ArcFactory: {
   testing(options: Omit<CreateAppOptions, "preset">): Promise<FastifyInstance>;
 };
 //#endregion
+//#region src/factory/createWorker.d.ts
+interface WorkerHealthOptions {
+  /** Port for the worker's ONLY listener (liveness/readiness probes). */
+  port: number;
+  /** Bind host. Default `0.0.0.0`. */
+  host?: string;
+  /** Readiness checks — same contract as the API role's healthPlugin. */
+  checks?: HealthCheck[];
+}
+interface CreateWorkerOptions {
+  /** Opt-in probe listener. Omit = the worker binds NOTHING. */
+  health?: WorkerHealthOptions;
+}
+interface ArcWorker {
+  /** The underlying Fastify instance (decorations, inject, logs). */
+  app: FastifyInstance;
+  /** Typed module-export accessor — same contract as `getModuleExports`. */
+  exports<TExports = unknown>(name: string): TExports;
+  /** Close app → module onClose (reverse) → app onClose. Idempotent. */
+  close(): Promise<void>;
+}
+declare function createWorker(options: CreateAppOptions, workerOptions?: CreateWorkerOptions): Promise<ArcWorker>;
+//#endregion
 //#region src/factory/edge.d.ts
 interface FetchHandlerOptions {
   /**
@@ -40,15 +64,31 @@ interface FetchHandlerOptions {
    * @default true
    */
   autoReady?: boolean;
+  /**
+   * Reject request bodies larger than this many bytes with 413
+   * `arc.payload_too_large`. Enforcement precision matters: bodies with a
+   * declared `Content-Length` are rejected BEFORE buffering; chunked or
+   * undeclared bodies are necessarily buffered first and checked AFTER
+   * (`arrayBuffer()` allocates the full body — a consequence of the
+   * buffered-adapter design, not a bug). Platform/gateway body limits
+   * remain the real pre-allocation protection for hostile senders.
+   * Fastify's own `bodyLimit` still applies after this gate. Set to `0`
+   * to disable the gate.
+   * @default 1_048_576 (1 MiB — matches Fastify's default bodyLimit)
+   */
+  maxRequestBytes?: number;
 }
 /**
  * Convert a Fastify app into a Web Standards fetch handler.
  *
  * The returned function accepts a Web Standard `Request` and returns
- * a Web Standard `Response` — the universal serverless/edge contract.
+ * a Web Standard `Response` — the universal serverless contract.
  *
  * Internally uses `app.inject()` which processes the request through
  * the full Fastify pipeline (hooks, plugins, routes) without TCP.
+ * Bodies are read as raw bytes (`arrayBuffer()`), so binary payloads
+ * (protobuf, images, non-UTF-8 charsets) survive intact — the
+ * content-type parser decides how to decode, same as a real socket.
  */
 declare function toFetchHandler(app: FastifyInstance, options?: FetchHandlerOptions): (request: Request) => Promise<Response>;
 //#endregion
@@ -91,9 +131,6 @@ declare const testingPreset: Partial<CreateAppOptions>;
  * when using `toFetchHandler()` (routes through Fastify's `.inject()`).
  */
 declare const edgePreset: Partial<CreateAppOptions>;
-/**
- * Get preset by name
- */
-declare function getPreset(name: "production" | "development" | "testing" | "edge"): Partial<CreateAppOptions>;
+declare function getPreset(name: "production" | "development" | "testing" | "edge" | "worker"): Partial<CreateAppOptions>;
 //#endregion
-export { ArcFactory, type ArcModule, type ArcModuleInput, type ArcModuleRegistry, type AuthOption, type BetterAuthOption, type CreateAppOptions, type CustomAuthenticatorOption, type CustomPluginAuthOption, type FetchHandlerOptions, type JwtAuthOption, type LoadResourcesOptions, type MultipartOptions, type RawBodyOptions, type ResourceLike, type ResourceModule, type UnderPressureOptions, createApp, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveModule, testingPreset, toFetchHandler };
+export { ArcFactory, type ArcModule, type ArcModuleInput, type ArcModuleRegistry, type ArcWorker, type AuthOption, type BetterAuthOption, type CreateAppOptions, type CreateWorkerOptions, type CustomAuthenticatorOption, type CustomPluginAuthOption, type FetchHandlerOptions, type JwtAuthOption, type LoadResourcesOptions, type MultipartOptions, type RawBodyOptions, type ResourceLike, type ResourceModule, type UnderPressureOptions, type WorkerHealthOptions, createApp, createWorker, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveModule, testingPreset, toFetchHandler };

package/dist/factory/index.mjs

@@ -1,33 +1,73 @@
-import { n as preloadResourcesAsync, t as preloadResources } from "../preloadResources-CHw3_oA_.mjs";
-import { a as edgePreset, c as testingPreset, d as orderModules, f as resolveModule, i as developmentPreset, l as defineModule, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory, u as getModuleExports } from "../createApp-Bi61XxqU.mjs";
+import { a as edgePreset, c as testingPreset, d as getModuleExports, f as orderModules, h as preloadResourcesAsync, i as developmentPreset, l as workerPreset, m as preloadResources, n as createApp, o as getPreset, p as resolveModule, s as productionPreset, t as ArcFactory, u as defineModule } from "../createApp-CjOeWJ9_.mjs";
+import { t as healthPlugin } from "../health-ScyjIVo5.mjs";
 import { t as loadResources } from "../loadResources-DpU8pfjV.mjs";
+//#region src/factory/createWorker.ts
+async function createWorker(options, workerOptions = {}) {
+	const { auth: _auth, helmet: _helmet, cors: _cors, rateLimit: _rateLimit, multipart: _multipart, rawBody: _rawBody, sensible: _sensible, underPressure: _underPressure, replyHelpers: _replyHelpers, ...runtimeOptions } = options;
+	const app = await createApp({
+		...runtimeOptions,
+		preset: "worker",
+		...runtimeOptions.arcPlugins ? { arcPlugins: {
+			...workerPreset.arcPlugins,
+			...runtimeOptions.arcPlugins
+		} } : {}
+	});
+	if (workerOptions.health) {
+		const { port, host = "0.0.0.0", checks = [] } = workerOptions.health;
+		await app.register(healthPlugin, { checks });
+		await app.listen({
+			port,
+			host
+		});
+	} else await app.ready();
+	let closed = false;
+	return {
+		app,
+		exports: (name) => getModuleExports(app, name),
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			await app.close();
+		}
+	};
+}
+//#endregion
 //#region src/factory/edge.ts
 /**
 * Convert a Fastify app into a Web Standards fetch handler.
 *
 * The returned function accepts a Web Standard `Request` and returns
-* a Web Standard `Response` — the universal serverless/edge contract.
+* a Web Standard `Response` — the universal serverless contract.
 *
 * Internally uses `app.inject()` which processes the request through
 * the full Fastify pipeline (hooks, plugins, routes) without TCP.
+* Bodies are read as raw bytes (`arrayBuffer()`), so binary payloads
+* (protobuf, images, non-UTF-8 charsets) survive intact — the
+* content-type parser decides how to decode, same as a real socket.
 */
 function toFetchHandler(app, options = {}) {
-	const { autoReady = true } = options;
-	let ready = false;
+	const { autoReady = true, maxRequestBytes = 1048576 } = options;
+	let readyPromise = null;
 	return async (request) => {
-		if (autoReady && !ready) {
-			await app.ready();
-			ready = true;
+		if (autoReady) {
+			readyPromise ??= Promise.resolve(app.ready());
+			await readyPromise;
 		}
 		const url = new URL(request.url);
 		const headers = {};
 		request.headers.forEach((value, key) => {
 			headers[key] = value;
 		});
+		if (maxRequestBytes > 0) {
+			const declared = Number(request.headers.get("content-length"));
+			if (Number.isFinite(declared) && declared > maxRequestBytes) return payloadTooLarge(maxRequestBytes);
+		}
 		let payload;
-		if (request.method !== "GET" && request.method !== "HEAD") try {
-			payload = await request.text();
-		} catch {}
+		if (request.method !== "GET" && request.method !== "HEAD" && request.body !== null) {
+			const bytes = await request.arrayBuffer();
+			if (maxRequestBytes > 0 && bytes.byteLength > maxRequestBytes) return payloadTooLarge(maxRequestBytes);
+			if (bytes.byteLength > 0) payload = Buffer.from(bytes);
+		}
 		const response = await app.inject({
 			method: request.method,
 			url: url.pathname + url.search,
@@ -40,11 +80,22 @@ function toFetchHandler(app, options = {}) {
 			if (Array.isArray(value)) for (const v of value) responseHeaders.append(key, v);
 			else responseHeaders.set(key, String(value));
 		}
-		return new Response(response.payload, {
+		return new Response(response.rawPayload, {
 			status: response.statusCode,
 			headers: responseHeaders
 		});
 	};
 }
+/** Canonical ErrorContract shape for the pre-dispatch 413. */
+function payloadTooLarge(limit) {
+	return new Response(JSON.stringify({
+		code: "arc.payload_too_large",
+		message: `Request body exceeds ${limit} bytes`,
+		status: 413
+	}), {
+		status: 413,
+		headers: { "content-type": "application/json" }
+	});
+}
 //#endregion
-export { ArcFactory, createApp, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveModule, testingPreset, toFetchHandler };
+export { ArcFactory, createApp, createWorker, defineModule, developmentPreset, edgePreset, getModuleExports, getPreset, loadResources, orderModules, preloadResources, preloadResourcesAsync, productionPreset, resolveModule, testingPreset, toFetchHandler };

package/dist/{fastify-augmentation-DafigGQp.d.mts → fastify-augmentation-g_f9omSc.d.mts}

@@ -1,6 +1,6 @@
-import { bn as HookSystem, z as ResourceRegistry } from "./index-Dtrj6XZk.mjs";
+import { xn as HookSystem, z as ResourceRegistry } from "./index-BBsvQt7U.mjs";
 import { t as ExternalOpenApiPaths } from "./externalPaths-BE6wFpYv.mjs";
-import { r as ArcModuleRegistry } from "./module-WeuU5jfd.mjs";
+import { r as ArcModuleRegistry } from "./module-B4u10iOJ.mjs";
 import { FastifyPluginAsync } from "fastify";
 //#region src/core/arcCorePlugin.d.ts
 interface ArcCorePluginOptions {

package/dist/fields-D3lhgzhD.d.mts

@@ -0,0 +1,121 @@
+//#region src/permissions/fields.d.ts
+/**
+ * Field-Level Permissions
+ *
+ * Control field visibility and writability per role.
+ * Integrated into the response path (read) and sanitization path (write).
+ *
+ * @example
+ * ```typescript
+ * import { fields, defineResource } from '@classytic/arc';
+ *
+ * const userResource = defineResource({
+ *   name: 'user',
+ *   adapter: userAdapter,
+ *   fields: {
+ *     salary: fields.visibleTo(['admin', 'hr']),
+ *     internalNotes: fields.writableBy(['admin']),
+ *     email: fields.redactFor(['viewer']),
+ *     password: fields.hidden(),
+ *   },
+ * });
+ * ```
+ */
+type FieldPermissionType = "hidden" | "visibleTo" | "writableBy" | "redactFor";
+interface FieldPermission {
+  readonly _type: FieldPermissionType;
+  readonly roles?: readonly string[];
+  readonly redactValue?: unknown;
+}
+type FieldPermissionMap = Record<string, FieldPermission>;
+declare const fields: {
+  /**
+   * Field is never included in responses. Not writable via API.
+   *
+   * @example
+   * ```typescript
+   * fields: { password: fields.hidden() }
+   * ```
+   */
+  hidden(): FieldPermission;
+  /**
+   * Field is only visible to users with specified roles.
+   * Other users don't see the field at all.
+   *
+   * @example
+   * ```typescript
+   * fields: { salary: fields.visibleTo(['admin', 'hr']) }
+   * ```
+   */
+  visibleTo(roles: readonly string[]): FieldPermission;
+  /**
+   * Field is only writable by users with specified roles.
+   * All users can still read the field. Users without the role
+   * have the field silently stripped from write operations.
+   *
+   * @example
+   * ```typescript
+   * fields: { role: fields.writableBy(['admin']) }
+   * ```
+   */
+  writableBy(roles: readonly string[]): FieldPermission;
+  /**
+   * Field is redacted (replaced with a placeholder) for specified roles.
+   * Other users see the real value.
+   *
+   * @param roles - Roles that see the redacted value
+   * @param redactValue - Replacement value (default: '***')
+   *
+   * @example
+   * ```typescript
+   * fields: {
+   *   email: fields.redactFor(['viewer']),
+   *   ssn: fields.redactFor(['basic'], '***-**-****'),
+   * }
+   * ```
+   */
+  redactFor(roles: readonly string[], redactValue?: unknown): FieldPermission;
+};
+/**
+ * Apply field-level READ permissions to a response object.
+ * Strips hidden fields, enforces visibility, and applies redaction.
+ *
+ * @param data - The response object (mutated in place for performance)
+ * @param fieldPermissions - Field permission map from resource config
+ * @param userRoles - Current user's roles (empty array for unauthenticated)
+ * @returns The filtered object
+ */
+declare function applyFieldReadPermissions<T extends Record<string, unknown>>(data: T, fieldPermissions: FieldPermissionMap, userRoles: readonly string[]): T;
+/**
+ * Result of applying write permissions — includes both the filtered body
+ * and the list of fields that were stripped so callers can decide whether
+ * to reject the request (secure default) or silently strip (legacy).
+ */
+interface FieldWritePermissionResult<T extends Record<string, unknown>> {
+  readonly body: T;
+  readonly deniedFields: readonly string[];
+}
+/**
+ * Apply field-level WRITE permissions to request body.
+ *
+ * Returns both the filtered body and the list of denied fields. Callers are
+ * expected to reject the request when `deniedFields.length > 0` — silently
+ * stripping fields hides misconfigurations and real attacks. See
+ * `BodySanitizer` for the default policy.
+ *
+ * @param body - The request body (returns a new filtered copy)
+ * @param fieldPermissions - Field permission map from resource config
+ * @param userRoles - Current user's roles
+ */
+declare function applyFieldWritePermissions<T extends Record<string, unknown>>(body: T, fieldPermissions: FieldPermissionMap, userRoles: readonly string[]): FieldWritePermissionResult<T>;
+/**
+ * Resolve effective roles by merging global user roles with org-level roles.
+ *
+ * Global roles come from `req.user.role` (normalized via getUserRoles()).
+ * Org roles come from `req.context.orgRoles` (set by BA adapter's org bridge).
+ *
+ * When no org context exists, returns global roles only — backward compatible.
+ */
+declare function resolveEffectiveRoles(userRoles: readonly string[], orgRoles: readonly string[]): string[];
+//#endregion
+export { applyFieldWritePermissions as a, applyFieldReadPermissions as i, FieldPermissionMap as n, fields as o, FieldPermissionType as r, resolveEffectiveRoles as s, FieldPermission as t };

package/dist/health-ScyjIVo5.mjs

@@ -0,0 +1,202 @@
+import fp from "fastify-plugin";
+//#region src/plugins/health.ts
+function createHttpMetrics() {
+	return {
+		requestsTotal: {},
+		requestDurations: [],
+		_ringIndex: 0,
+		startTime: Date.now()
+	};
+}
+const healthPlugin = async (fastify, opts = {}) => {
+	const { prefix = "/_health", checks = [], metrics = false, metricsCollector, version, collectHttpMetrics = metrics } = opts;
+	const httpMetrics = createHttpMetrics();
+	fastify.get(prefix, { schema: {
+		tags: ["Health"],
+		summary: "Liveness probe (alias for /live)",
+		description: "Returns 200 if the process is alive",
+		response: { 200: {
+			type: "object",
+			properties: {
+				status: {
+					type: "string",
+					enum: ["ok"]
+				},
+				timestamp: { type: "string" },
+				version: { type: "string" }
+			}
+		} }
+	} }, async () => ({
+		status: "ok",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...version ? { version } : {}
+	}));
+	fastify.get(`${prefix}/live`, { schema: {
+		tags: ["Health"],
+		summary: "Liveness probe",
+		description: "Returns 200 if the process is alive",
+		response: { 200: {
+			type: "object",
+			properties: {
+				status: {
+					type: "string",
+					enum: ["ok"]
+				},
+				timestamp: { type: "string" },
+				version: { type: "string" }
+			}
+		} }
+	} }, async () => {
+		return {
+			status: "ok",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...version ? { version } : {}
+		};
+	});
+	fastify.get(`${prefix}/ready`, { schema: {
+		tags: ["Health"],
+		summary: "Readiness probe",
+		description: "Returns 200 if all dependencies are healthy",
+		response: {
+			200: {
+				type: "object",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["ready", "not_ready"]
+					},
+					timestamp: { type: "string" },
+					checks: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								name: { type: "string" },
+								healthy: { type: "boolean" },
+								duration: { type: "number" },
+								error: { type: "string" }
+							}
+						}
+					}
+				}
+			},
+			503: {
+				type: "object",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["not_ready"]
+					},
+					timestamp: { type: "string" },
+					checks: { type: "array" }
+				}
+			}
+		}
+	} }, async (_, reply) => {
+		const results = await runChecks(checks);
+		const criticalFailed = results.some((r) => !r.healthy && (checks.find((c) => c.name === r.name)?.critical ?? true));
+		const response = {
+			status: criticalFailed ? "not_ready" : "ready",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			checks: results
+		};
+		if (criticalFailed) reply.code(503);
+		return response;
+	});
+	if (metrics) fastify.get(`${prefix}/metrics`, async (_, reply) => {
+		reply.type("text/plain; charset=utf-8");
+		if (metricsCollector) return await metricsCollector();
+		const uptime = process.uptime();
+		const memory = process.memoryUsage();
+		const cpu = process.cpuUsage();
+		const lines = [
+			"# HELP process_uptime_seconds Process uptime in seconds",
+			"# TYPE process_uptime_seconds gauge",
+			`process_uptime_seconds ${uptime.toFixed(2)}`,
+			"",
+			"# HELP process_memory_heap_bytes Heap memory usage in bytes",
+			"# TYPE process_memory_heap_bytes gauge",
+			`process_memory_heap_bytes{type="used"} ${memory.heapUsed}`,
+			`process_memory_heap_bytes{type="total"} ${memory.heapTotal}`,
+			"",
+			"# HELP process_memory_rss_bytes RSS memory in bytes",
+			"# TYPE process_memory_rss_bytes gauge",
+			`process_memory_rss_bytes ${memory.rss}`,
+			"",
+			"# HELP process_memory_external_bytes External memory in bytes",
+			"# TYPE process_memory_external_bytes gauge",
+			`process_memory_external_bytes ${memory.external}`,
+			"",
+			"# HELP process_cpu_user_microseconds User CPU time in microseconds",
+			"# TYPE process_cpu_user_microseconds counter",
+			`process_cpu_user_microseconds ${cpu.user}`,
+			"",
+			"# HELP process_cpu_system_microseconds System CPU time in microseconds",
+			"# TYPE process_cpu_system_microseconds counter",
+			`process_cpu_system_microseconds ${cpu.system}`,
+			""
+		];
+		if (collectHttpMetrics && Object.keys(httpMetrics.requestsTotal).length > 0) {
+			lines.push("# HELP http_requests_total Total HTTP requests by status code", "# TYPE http_requests_total counter");
+			for (const [status, count] of Object.entries(httpMetrics.requestsTotal)) lines.push(`http_requests_total{status="${status}"} ${count}`);
+			lines.push("");
+			if (httpMetrics.requestDurations.length > 0) {
+				const sorted = [...httpMetrics.requestDurations].sort((a, b) => a - b);
+				const p50 = sorted[Math.floor(sorted.length * .5)] || 0;
+				const p95 = sorted[Math.floor(sorted.length * .95)] || 0;
+				const p99 = sorted[Math.floor(sorted.length * .99)] || 0;
+				const sum = sorted.reduce((a, b) => a + b, 0);
+				lines.push("# HELP http_request_duration_milliseconds HTTP request duration", "# TYPE http_request_duration_milliseconds summary", `http_request_duration_milliseconds{quantile="0.5"} ${p50.toFixed(2)}`, `http_request_duration_milliseconds{quantile="0.95"} ${p95.toFixed(2)}`, `http_request_duration_milliseconds{quantile="0.99"} ${p99.toFixed(2)}`, `http_request_duration_milliseconds_sum ${sum.toFixed(2)}`, `http_request_duration_milliseconds_count ${sorted.length}`, "");
+			}
+		}
+		return lines.join("\n");
+	});
+	if (collectHttpMetrics) fastify.addHook("onResponse", async (_request, reply) => {
+		const duration = reply.elapsedTime;
+		const statusBucket = `${Math.floor(reply.statusCode / 100)}xx`;
+		httpMetrics.requestsTotal[statusBucket] = (httpMetrics.requestsTotal[statusBucket] || 0) + 1;
+		if (httpMetrics.requestDurations.length < 1e4) httpMetrics.requestDurations.push(duration);
+		else httpMetrics.requestDurations[httpMetrics._ringIndex % 1e4] = duration;
+		httpMetrics._ringIndex = httpMetrics._ringIndex + 1;
+	});
+	fastify.log?.debug?.(`Health plugin registered at ${prefix} (alias), ${prefix}/live, ${prefix}/ready${metrics ? `, ${prefix}/metrics` : ""}`);
+};
+/**
+* Run all health checks with timeout
+*/
+async function runChecks(checks) {
+	const results = [];
+	for (const check of checks) {
+		const start = Date.now();
+		const timeout = check.timeout ?? 5e3;
+		let timer;
+		try {
+			const checkPromise = Promise.resolve(check.check());
+			const timeoutPromise = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Health check timeout")), timeout);
+			});
+			const healthy = await Promise.race([checkPromise, timeoutPromise]);
+			results.push({
+				name: check.name,
+				healthy: Boolean(healthy),
+				duration: Date.now() - start
+			});
+		} catch (err) {
+			results.push({
+				name: check.name,
+				healthy: false,
+				duration: Date.now() - start,
+				error: err.message
+			});
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	return results;
+}
+var health_default = fp(healthPlugin, {
+	name: "arc-health",
+	fastify: "5.x"
+});
+//#endregion
+export { health_default as n, healthPlugin as t };

package/dist/hooks/index.d.mts

@@ -1,2 +1,2 @@
-import { Cn as afterDelete, Dn as beforeUpdate, En as beforeDelete, On as createHookSystem, Sn as afterCreate, Tn as beforeCreate, _n as HookOperation, bn as HookSystem, gn as HookHandler, hn as HookContext, kn as defineHook, mn as DefineHookOptions, vn as HookPhase, wn as afterUpdate, xn as HookSystemOptions, yn as HookRegistration } from "../index-Dtrj6XZk.mjs";
+import { An as defineHook, Cn as afterCreate, Dn as beforeDelete, En as beforeCreate, On as beforeUpdate, Sn as HookSystemOptions, Tn as afterUpdate, _n as HookHandler, bn as HookRegistration, gn as HookContext, hn as DefineHookOptions, kn as createHookSystem, vn as HookOperation, wn as afterDelete, xn as HookSystem, yn as HookPhase } from "../index-BBsvQt7U.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/idempotency/index.d.mts

@@ -77,6 +77,13 @@ declare module "fastify" {
        * ```
        */
       middleware: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+      /**
+       * The resolved backing store. Exposed so non-HTTP executors (MCP
+       * tools via `mcpPlugin`'s execution wiring, jobs, workflows) can run
+       * the same check → lock → execute → record protocol against the same
+       * backend. `undefined` when the plugin is disabled.
+       */
+      store?: IdempotencyStore;
     };
   }
 }

package/dist/idempotency/index.mjs

@@ -1,4 +1,5 @@
 import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-DY6xq4sM.mjs";
+import { t as createIdempotencyResult } from "../interface-n5hpKg1d.mjs";
 import { createHash } from "node:crypto";
 import fp from "fastify-plugin";
 import { and, eq, exists, gt, lt, or, startsWith } from "@classytic/repo-core/filter";
@@ -100,21 +101,6 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 	};
 }
 //#endregion
-//#region src/idempotency/stores/interface.ts
-/**
-* Helper to create a result object
-*/
-function createIdempotencyResult(statusCode, body, headers, ttlMs) {
-	const now = /* @__PURE__ */ new Date();
-	return {
-		statusCode,
-		headers,
-		body,
-		createdAt: now,
-		expiresAt: new Date(now.getTime() + ttlMs)
-	};
-}
-//#endregion
 //#region src/idempotency/stores/memory.ts
 var MemoryIdempotencyStore = class {
 	name = "memory";
@@ -283,16 +269,19 @@ const idempotencyPlugin = async (fastify, opts = {}) => {
 		fastify.decorate("idempotency", {
 			invalidate: async () => {},
 			has: async () => false,
-			middleware: async () => {}
+			middleware: async () => {},
+			store: void 0
 		});
 		fastify.decorateRequest("idempotencyKey", void 0);
 		fastify.decorateRequest("idempotencyReplayed", false);
+		fastify.decorateRequest("_idempotencyFullKey", void 0);
 		fastify.log?.debug?.("Idempotency plugin disabled");
 		return;
 	}
 	const methodSet = new Set(methods.map((m) => m.toUpperCase()));
 	fastify.decorateRequest("idempotencyKey", void 0);
 	fastify.decorateRequest("idempotencyReplayed", false);
+	fastify.decorateRequest("_idempotencyFullKey", void 0);
 	/**
 	* Check if this request should use idempotency
 	*/
@@ -378,7 +367,8 @@ const idempotencyPlugin = async (fastify, opts = {}) => {
 		has: async (key) => {
 			return !!await store.findByPrefix(`${key}:`);
 		},
-		middleware: idempotencyMiddleware
+		middleware: idempotencyMiddleware,
+		store
 	});
 	fastify.addHook("preSerialization", async (request, reply, payload) => {
 		if (request.idempotencyReplayed) return payload;