@classytic/arc 2.18.1 → 2.18.3

package/dist/pipeline-D4sqiokR.mjs

@@ -0,0 +1,336 @@
+import { b as isElevated, c as getOrgId, g as getUserId, n as PUBLIC_SCOPE, x as isMember } from "./types-Bi0r0vjG.mjs";
+import { L as resolveEffectiveRoles, P as applyFieldReadPermissions } from "./permissions-3uzwkbQt.mjs";
+import { t as getUserRoles } from "./types-D57iXYb8.mjs";
+import { t as executePipeline } from "./pipe-9Tl-OAus.mjs";
+import { isPaginatedResult, toCanonicalList } from "@classytic/repo-core/pagination";
+//#region src/scope/projection.ts
+/**
+* Compute the request-scope projection. Returns `undefined` when no
+* scope is attached (public / unscoped routes) so hosts can idiomatically
+* write `ctx.scope?.organizationId` without a double-null check.
+*/
+function buildRequestScopeProjection(scope) {
+	if (!scope) return void 0;
+	return {
+		organizationId: getOrgId(scope),
+		userId: getUserId(scope),
+		orgRoles: isMember(scope) ? scope.orgRoles : void 0
+	};
+}
+//#endregion
+//#region src/core/fastifyAdapter.ts
+/** Type guard for Mongoose-like documents with toObject() */
+function isMongooseDoc(obj) {
+	return !!obj && typeof obj === "object" && "toObject" in obj && typeof obj.toObject === "function";
+}
+/**
+* Apply field mask to a single object
+* Filters fields based on include/exclude rules
+*/
+function applyFieldMaskToObject(obj, fieldMask) {
+	if (!obj || typeof obj !== "object") return obj;
+	const plain = isMongooseDoc(obj) ? obj.toObject() : obj;
+	const { include, exclude } = fieldMask;
+	if (include && include.length > 0) {
+		const filtered = {};
+		for (const field of include) if (field in plain) filtered[field] = plain[field];
+		return filtered;
+	}
+	if (exclude && exclude.length > 0) {
+		const filtered = { ...plain };
+		for (const field of exclude) delete filtered[field];
+		return filtered;
+	}
+	return plain;
+}
+/**
+* Apply field mask to response data (handles both objects and arrays)
+*/
+function applyFieldMask(data, fieldMask) {
+	if (!fieldMask) return data;
+	if (Array.isArray(data)) return data.map((item) => applyFieldMaskToObject(item, fieldMask));
+	if (data && typeof data === "object") return applyFieldMaskToObject(data, fieldMask);
+	return data;
+}
+/**
+* Project `FastifyRequest` into the curated `IRequestContext` shape that
+* arc's controllers receive. This is a developer-facing facade, not a
+* portability boundary — arc is Fastify-only. The projection lifts the
+* fields tenant-scoped controllers reach for (`organizationId`,
+* `teamId`, `scope`, `context`, server accessor) onto a flat, typed
+* surface so handler code doesn't have to dig through Fastify's
+* decorator surface or `req.metadata._scope` internals.
+*/
+function createRequestContext(req) {
+	const reqWithExtras = req;
+	const requestContext = reqWithExtras.context ?? {};
+	const srv = req.server;
+	const serverAccessor = {
+		events: srv && "events" in srv ? srv.events : void 0,
+		audit: srv && "audit" in srv ? srv.audit : void 0,
+		queryCache: srv && "queryCache" in srv ? srv.queryCache : void 0,
+		log: req.log
+	};
+	const rawScope = reqWithExtras.scope;
+	const scopeProjection = buildRequestScopeProjection(rawScope);
+	return {
+		query: reqWithExtras.query ?? {},
+		body: reqWithExtras.body ?? {},
+		params: reqWithExtras.params ?? {},
+		headers: reqWithExtras.headers,
+		user: reqWithExtras.user ? (() => {
+			const user = reqWithExtras.user;
+			const rawId = user._id ?? user.id;
+			const normalizedId = rawId ? String(rawId) : void 0;
+			return {
+				...user,
+				id: normalizedId,
+				_id: normalizedId
+			};
+		})() : null,
+		context: requestContext,
+		scope: scopeProjection,
+		metadata: {
+			...reqWithExtras.context,
+			arc: reqWithExtras.arc,
+			_scope: rawScope,
+			_ownershipCheck: reqWithExtras._ownershipCheck,
+			_policyFilters: reqWithExtras._policyFilters ?? {},
+			log: reqWithExtras.log
+		},
+		server: serverAccessor
+	};
+}
+/**
+* Get typed auth context from an IRequestContext.
+* Use this in controller overrides to access request context.
+*
+* For org scope, use `getControllerScope(req)` instead.
+*/
+function getControllerContext(req) {
+	return req.context ?? req.metadata ?? {};
+}
+/**
+* Get request scope from an IRequestContext.
+* Returns the RequestScope set by auth adapters.
+*/
+function getControllerScope(req) {
+	return req.metadata?._scope ?? PUBLIC_SCOPE;
+}
+/**
+* Compute per-field capability metadata for the current user.
+* Only includes fields that have restrictions — unrestricted fields
+* are omitted (frontend defaults to { readable: true, writable: true }).
+*/
+function computeFieldCapabilities(fieldPerms, effectiveRoles) {
+	const caps = {};
+	for (const [field, perm] of Object.entries(fieldPerms)) {
+		let readable = true;
+		let writable = true;
+		switch (perm._type) {
+			case "hidden":
+				readable = false;
+				writable = false;
+				break;
+			case "visibleTo":
+				readable = perm.roles?.some((r) => effectiveRoles.includes(r)) ?? false;
+				break;
+			case "writableBy":
+				writable = perm.roles?.some((r) => effectiveRoles.includes(r)) ?? false;
+				break;
+		}
+		caps[field] = {
+			readable,
+			writable
+		};
+	}
+	return caps;
+}
+/**
+* Send a controller's `IControllerResponse` through Fastify's reply.
+*
+* The `IControllerResponse<T>` envelope is arc's internal pipeline
+* contract — it's how custom `status`, `meta`, `headers`, and field
+* permissions thread from a handler through interceptors to the wire
+* without each step having to touch `reply` directly. Not a portability
+* abstraction (arc is Fastify-only); a pipeline-internal one.
+*
+* **Auto-envelope of bare returns.** Custom route handlers are
+* expected to return the envelope shape so this function can apply
+* field permissions, attach `fieldCaps`, and flatten paginated lists.
+* A handler that returns raw `T` (array, plain object, primitive) used
+* to silently produce a broken response — `response.data` was
+* `undefined`, the body sent was `undefined`, and any declared
+* `fields:` permission map was bypassed (the leak shape mentora
+* flagged). 2.17 detects bare returns and wraps them into
+* `{ data: response, status: 200 }` before the field-permission
+* pipeline runs, so `fields:` applies to ALL custom routes whether the
+* handler envelopes its return value or not. The envelope shape is
+* still the canonical contract — auto-wrapping is a safety net, not
+* an invitation to drop the envelope.
+*/
+function sendControllerResponse(reply, response, request) {
+	if (response === null || typeof response !== "object" || !Object.hasOwn(response, "data")) response = {
+		data: response,
+		status: 200
+	};
+	const reqWithExtras = request;
+	const fieldMaskConfig = reqWithExtras?.fieldMask;
+	const arcMeta = reqWithExtras?.arc;
+	const scope = reqWithExtras?.scope ?? PUBLIC_SCOPE;
+	const fieldPerms = isElevated(scope) ? void 0 : arcMeta?.fields;
+	const effectiveRoles = fieldPerms ? resolveEffectiveRoles(getUserRoles(reqWithExtras?.user), isMember(scope) ? scope.orgRoles : []) : [];
+	const fieldCaps = fieldPerms ? computeFieldCapabilities(fieldPerms, effectiveRoles) : void 0;
+	const hasFieldRestrictions = !!(fieldMaskConfig || fieldPerms);
+	/** Apply both field mask and field-level permissions to a data item */
+	const applyPermissions = (data) => {
+		let result = fieldMaskConfig ? applyFieldMask(data, fieldMaskConfig) : data;
+		if (fieldPerms && result && typeof result === "object") if (Array.isArray(result)) result = result.map((item) => applyFieldReadPermissions(item, fieldPerms, effectiveRoles));
+		else result = applyFieldReadPermissions(result, fieldPerms, effectiveRoles);
+		return result;
+	};
+	if (response.headers) for (const [key, value] of Object.entries(response.headers)) reply.header(key, value);
+	if (response.data && typeof response.data === "object" && Array.isArray(response.data.data)) {
+		const payload = response.data;
+		const filteredRows = hasFieldRestrictions ? applyPermissions(payload.data) : payload.data;
+		let canonical;
+		if (isPaginatedResult(payload)) canonical = toCanonicalList({
+			...payload,
+			data: filteredRows
+		});
+		else if (typeof payload.page === "number" && typeof payload.limit === "number" && typeof payload.total === "number") canonical = toCanonicalList({
+			method: "offset",
+			data: filteredRows,
+			page: payload.page,
+			limit: payload.limit,
+			total: payload.total,
+			pages: payload.pages ?? Math.ceil(payload.total / Math.max(1, payload.limit)),
+			hasNext: payload.hasNext ?? false,
+			hasPrev: payload.hasPrev ?? false
+		});
+		else canonical = toCanonicalList(filteredRows);
+		reply.code(response.status ?? 200).send({
+			...canonical,
+			...response.meta ?? {},
+			...fieldCaps ? { fieldPermissions: fieldCaps } : {}
+		});
+		return;
+	}
+	const rawData = hasFieldRestrictions ? applyPermissions(response.data) : response.data;
+	const filteredData = rawData !== null && typeof rawData === "object" && typeof rawData.toJSON === "function" ? rawData.toJSON() : rawData;
+	const status = response.status ?? 200;
+	if (filteredData !== null && typeof filteredData === "object" && !Array.isArray(filteredData) && (response.meta || fieldCaps)) {
+		reply.code(status).send({
+			...filteredData,
+			...response.meta ?? {},
+			...fieldCaps ? { fieldPermissions: fieldCaps } : {}
+		});
+		return;
+	}
+	reply.code(status).send(filteredData);
+}
+/**
+* Bridge an `IController` method (`(ctx: IRequestContext) => Promise<IControllerResponse<T>>`)
+* into a Fastify route handler. Translates between arc's curated request
+* context surface and Fastify's request/reply, and routes the envelope
+* through `sendControllerResponse` so the pipeline applies field
+* permissions, status, and meta uniformly. Internal plumbing, not a
+* portability layer — arc is Fastify-only.
+*
+* @example
+* ```typescript
+* const controller = new BaseController(repository);
+* const listHandler = createFastifyHandler(controller.list.bind(controller));
+* fastify.get('/products', listHandler);
+* ```
+*/
+function createFastifyHandler(controllerMethod) {
+	return async (req, reply) => {
+		sendControllerResponse(reply, await controllerMethod(createRequestContext(req)), req);
+	};
+}
+/**
+* Create Fastify adapters for all CRUD methods of an IController
+*
+* Returns Fastify-compatible handlers for each CRUD operation
+*
+* @example
+* ```typescript
+* const controller = new BaseController(repository);
+* const handlers = createCrudHandlers(controller);
+*
+* fastify.get('/', handlers.list);
+* fastify.get('/:id', handlers.get);
+* fastify.post('/', handlers.create);
+* fastify.patch('/:id', handlers.update);
+* fastify.delete('/:id', handlers.delete);
+* ```
+*/
+function createCrudHandlers(controller) {
+	return {
+		list: createFastifyHandler(controller.list.bind(controller)),
+		get: createFastifyHandler(controller.get.bind(controller)),
+		create: createFastifyHandler(controller.create.bind(controller)),
+		update: createFastifyHandler(controller.update.bind(controller)),
+		delete: createFastifyHandler(controller.delete.bind(controller))
+	};
+}
+//#endregion
+//#region src/core/middlewares/pipeline.ts
+/**
+* Resolve pipeline steps for a specific operation.
+* Flat-array config applies to every op; map config applies per-op.
+*/
+function resolvePipelineSteps(pipeline, operation) {
+	if (!pipeline) return [];
+	if (Array.isArray(pipeline)) return pipeline;
+	return pipeline[operation] ?? [];
+}
+/**
+* Wrap a controller method (one that takes `IRequestContext` and returns
+* `IControllerResponse<T>`) with pipeline execution. Used by CRUD ops and
+* string-handler custom routes.
+*/
+function buildPipelineHandler(controllerMethod, steps, operation, resourceName) {
+	return async (req, reply) => {
+		sendControllerResponse(reply, await executePipeline(steps, {
+			...createRequestContext(req),
+			resource: resourceName,
+			operation
+		}, (ctx) => controllerMethod(ctx), operation), req);
+	};
+}
+/**
+* Wrap an action handler (one that takes `(id, data, req)` and returns a raw
+* result) with pipeline execution. Returns a function that produces a full
+* `IControllerResponse<unknown>` — the action router feeds this directly into
+* `sendControllerResponse`, so field masking, custom status codes, `meta`,
+* `details`, and structured error codes from pipeline interceptors flow
+* through to the client unchanged.
+*
+* CRUD and actions now share the same parity invariant: a pipeline that
+* returns `{ success: false, status: 422, error, details, meta }` reaches the
+* client with all four fields intact. Previously the action path stringified
+* failures into a generic `Error` and dropped everything except `statusCode`.
+*
+* Handler throws still bubble out — the caller's try/catch handles `onError`
+* shaping and the generic `ACTION_FAILED` fallback.
+*/
+function buildActionPipelineHandler(handler, steps, operation, resourceName) {
+	if (steps.length === 0) return async (id, data, req) => ({
+		status: 200,
+		data: await handler(id, data, req)
+	});
+	return async (id, data, req) => {
+		return executePipeline(steps, {
+			...createRequestContext(req),
+			resource: resourceName,
+			operation
+		}, async (_ctx) => ({
+			status: 200,
+			data: await handler(id, data, req)
+		}), operation);
+	};
+}
+//#endregion
+export { createFastifyHandler as a, getControllerScope as c, createCrudHandlers as i, sendControllerResponse as l, buildPipelineHandler as n, createRequestContext as o, resolvePipelineSteps as r, getControllerContext as s, buildActionPipelineHandler as t, buildRequestScopeProjection as u };

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
-import { Kt as AnyRecord, Q as MiddlewareConfig, dt as RouteDefinition, mt as RouteSchemaOptions, nt as PresetHook } from "../index-C000faom.mjs";
-import { a as arcCorePlugin, i as _default, n as ArcCorePluginOptions, r as PluginMeta, t as ArcCore } from "../fastify-augmentation-CL48B6gW.mjs";
-import { _ as HealthOptions, a as MetricsCollector, c as metricsPlugin, d as ssePlugin, f as CachingOptions, g as HealthCheck, h as cachingPlugin, i as MetricEntry, l as SSEOptions, m as _default$1, n as _default$7, o as MetricsOptions, p as CachingRule, r as versioningPlugin, s as _default$4, t as VersioningOptions, u as _default$6, v as _default$3, y as healthPlugin } from "../versioning-5H4930tj.mjs";
-import { i as errorHandlerPlugin, n as ErrorMapper, r as defaultIsDuplicateKeyError, t as ErrorHandlerOptions } from "../errorHandler-DuqTqeqn.mjs";
-import { t as TracingOptions } from "../tracing-BYQ3hsbM.mjs";
+import { Kt as AnyRecord, Q as MiddlewareConfig, dt as RouteDefinition, mt as RouteSchemaOptions, nt as PresetHook } from "../index-QYma8mdC.mjs";
+import { a as arcCorePlugin, i as _default, n as ArcCorePluginOptions, r as PluginMeta, t as ArcCore } from "../fastify-augmentation-BdCl_eNo.mjs";
+import { _ as HealthOptions, a as MetricsCollector, c as metricsPlugin, d as ssePlugin, f as CachingOptions, g as HealthCheck, h as cachingPlugin, i as MetricEntry, l as SSEOptions, m as _default$1, n as _default$7, o as MetricsOptions, p as CachingRule, r as versioningPlugin, s as _default$4, t as VersioningOptions, u as _default$6, v as _default$3, y as healthPlugin } from "../versioning-BSEDGXKC.mjs";
+import { i as errorHandlerPlugin, n as ErrorMapper, r as defaultIsDuplicateKeyError, t as ErrorHandlerOptions } from "../errorHandler-_Lp2k9M3.mjs";
+import { t as TracingOptions } from "../tracing-Bnb1-YVd.mjs";
 import * as _$node_stream0 from "node:stream";
 import { PaginatedResult } from "@classytic/repo-core/pagination";
 import { FastifyInstance, FastifyPluginAsync } from "fastify";

package/dist/plugins/index.mjs

@@ -1,15 +1,15 @@
 import { p as MUTATION_OPERATIONS } from "../constants-TrJVIJl0.mjs";
 import { c as getOrgId } from "../types-Bi0r0vjG.mjs";
 import { n as requestContext } from "../requestContext-DDLS3NVU.mjs";
-import { t as hasEvents } from "../typeGuards-BzkXkvVv.mjs";
-import { t as HookSystem } from "../HookSystem-Cmf7-Etp.mjs";
-import { t as ResourceRegistry } from "../ResourceRegistry-CzSzVK1m.mjs";
-import { n as caching_default, t as cachingPlugin } from "../caching-8MfrrUYU.mjs";
-import { n as errorHandlerPlugin, t as defaultIsDuplicateKeyError } from "../errorHandler-wQejMBT3.mjs";
-import { n as metrics_default, t as metricsPlugin } from "../metrics-B-PU4-Yu.mjs";
-import { t as replyHelpersPlugin } from "../replyHelpers-boS5Rx26.mjs";
-import { n as sse_default, t as ssePlugin } from "../sse-jh5OqFjR.mjs";
-import { n as versioning_default, t as versioningPlugin } from "../versioning-CuIwUQZ2.mjs";
+import { t as hasEvents } from "../typeGuards-CcFZXgU7.mjs";
+import { t as HookSystem } from "../HookSystem-BfCpWbwM.mjs";
+import { t as ResourceRegistry } from "../ResourceRegistry-CWmOggxS.mjs";
+import { n as caching_default, t as cachingPlugin } from "../caching-C0DdKiYB.mjs";
+import { n as errorHandlerPlugin, t as defaultIsDuplicateKeyError } from "../errorHandler-Bua97SEt.mjs";
+import { n as metrics_default, t as metricsPlugin } from "../metrics-Da2EUPi9.mjs";
+import { t as replyHelpersPlugin } from "../replyHelpers-DXHVxrrj.mjs";
+import { n as sse_default, t as ssePlugin } from "../sse-Xq8UtuQx.mjs";
+import { n as versioning_default, t as versioningPlugin } from "../versioning-C0K8KQLx.mjs";
 import { randomUUID } from "node:crypto";
 import fp from "fastify-plugin";
 //#region src/core/arcCorePlugin.ts

package/dist/plugins/response-cache.mjs

@@ -1,4 +1,4 @@
-import { t as hasEvents } from "../typeGuards-BzkXkvVv.mjs";
+import { t as hasEvents } from "../typeGuards-CcFZXgU7.mjs";
 import fp from "fastify-plugin";
 //#region src/plugins/response-cache.ts
 /**

package/dist/plugins/tracing-entry.d.mts

@@ -1,2 +1,2 @@
-import { a as traced, i as isTracingAvailable, n as _default, r as createSpan, t as TracingOptions } from "../tracing-BYQ3hsbM.mjs";
+import { a as traced, i as isTracingAvailable, n as _default, r as createSpan, t as TracingOptions } from "../tracing-Bnb1-YVd.mjs";
 export { type TracingOptions, createSpan, isTracingAvailable, traced, _default as tracingPlugin };

package/dist/plugins/tracing-entry.mjs

@@ -58,7 +58,7 @@ try {
 function createTracerProvider(options) {
 	if (!isAvailable || !NodeTracerProvider || !BatchSpanProcessor || !OTLPTraceExporter) return null;
 	const { serviceName = "@classytic/arc", serviceVersion, exporterUrl = "http://localhost:4318/v1/traces" } = options;
-	const resolvedVersion = serviceVersion ?? "2.18.1";
+	const resolvedVersion = serviceVersion ?? "2.18.3";
 	const exporter = new OTLPTraceExporter({ url: exporterUrl });
 	const provider = new NodeTracerProvider({ resource: { attributes: {
 		"service.name": serviceName,

package/dist/presets/filesUpload.d.mts

@@ -1,7 +1,7 @@
-import { rt as PresetResult } from "../index-C000faom.mjs";
-import { i as RequestScope } from "../types-CfapW2t8.mjs";
-import { c as PermissionCheck } from "../fields-DqZLp5d6.mjs";
-import { a as StorageReadResult, i as StorageReadRange, n as StorageContext, o as StorageUploadInput, r as StorageFile, t as Storage } from "../storage-BFmamN5m.mjs";
+import { rt as PresetResult } from "../index-QYma8mdC.mjs";
+import { i as RequestScope } from "../types-BJwJN2Pg.mjs";
+import { c as PermissionCheck } from "../fields-CKLrhyOb.mjs";
+import { a as StorageReadResult, i as StorageReadRange, n as StorageContext, o as StorageUploadInput, r as StorageFile, t as Storage } from "../storage-C5q8fuEt.mjs";
 
 //#region src/presets/filesUpload.d.ts
 interface FilesUploadPresetRoutes {

package/dist/presets/filesUpload.mjs

@@ -1,7 +1,7 @@
 import { i as NotFoundError, u as ValidationError } from "../errors-j4aJm1Wg.mjs";
 import { c as getOrgId, g as getUserId } from "../types-Bi0r0vjG.mjs";
-import { C as requireAuth, y as allowPublic } from "../permissions-B1Qy55fg.mjs";
-import { t as multipartBody } from "../multipartBody-VjVWmZl8.mjs";
+import { C as requireAuth, y as allowPublic } from "../permissions-3uzwkbQt.mjs";
+import { t as multipartBody } from "../multipartBody-709YcXi1.mjs";
 //#region src/presets/filesUpload.ts
 const DEFAULT_FIELD_NAME = "file";
 const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;

package/dist/presets/index.d.mts

@@ -1,4 +1,4 @@
-import { Kt as AnyRecord, bt as IRequestContext, d as PaginationResult, rt as PresetResult, st as ResourceConfig, yt as IControllerResponse } from "../index-C000faom.mjs";
+import { Kt as AnyRecord, bt as IRequestContext, d as PaginationResult, rt as PresetResult, st as ResourceConfig, yt as IControllerResponse } from "../index-QYma8mdC.mjs";
 import { FilesUploadPresetOptions, FilesUploadPresetPermissions, FilesUploadPresetRoutes, filesUploadPreset } from "./filesUpload.mjs";
 import { MultiTenantOptions, TenantFieldSpec, multiTenantPreset } from "./multiTenant.mjs";
 import { SearchHandler, SearchPresetOptions, SearchRouteConfig, searchPreset } from "./search.mjs";

package/dist/presets/index.mjs

@@ -1,5 +1,5 @@
 import { multiTenantPreset } from "./multiTenant.mjs";
-import { a as registerPreset, c as auditedPreset, d as ownedByUserPreset, i as getPreset, l as softDeletePreset, n as flexibleMultiTenantPreset, o as treePreset, r as getAvailablePresets, s as bulkPreset, t as applyPresets, u as slugLookupPreset } from "../presets-BYbPobbF.mjs";
+import { a as registerPreset, c as auditedPreset, d as ownedByUserPreset, i as getPreset, l as softDeletePreset, n as flexibleMultiTenantPreset, o as treePreset, r as getAvailablePresets, s as bulkPreset, t as applyPresets, u as slugLookupPreset } from "../presets-CF79RHEo.mjs";
 import { filesUploadPreset } from "./filesUpload.mjs";
 import { searchPreset } from "./search.mjs";
 export { applyPresets, auditedPreset, bulkPreset, filesUploadPreset, flexibleMultiTenantPreset, getAvailablePresets, getPreset, multiTenantPreset, ownedByUserPreset, registerPreset, searchPreset, slugLookupPreset, softDeletePreset, treePreset };

package/dist/presets/multiTenant.d.mts

@@ -1,4 +1,4 @@
-import { J as CrudRouteKey, rt as PresetResult } from "../index-C000faom.mjs";
+import { J as CrudRouteKey, rt as PresetResult } from "../index-QYma8mdC.mjs";
 
 //#region src/presets/multiTenant.d.ts
 /**

package/dist/presets/search.d.mts

@@ -1,5 +1,5 @@
-import { dt as RouteDefinition, ft as RouteMcpConfig, ht as ControllerHandler, rt as PresetResult } from "../index-C000faom.mjs";
-import { c as PermissionCheck } from "../fields-DqZLp5d6.mjs";
+import { dt as RouteDefinition, ft as RouteMcpConfig, ht as ControllerHandler, rt as PresetResult } from "../index-QYma8mdC.mjs";
+import { c as PermissionCheck } from "../fields-CKLrhyOb.mjs";
 
 //#region src/presets/search.d.ts
 /**

package/dist/presets/search.mjs

@@ -1,4 +1,4 @@
-import { C as requireAuth, y as allowPublic } from "../permissions-B1Qy55fg.mjs";
+import { C as requireAuth, y as allowPublic } from "../permissions-3uzwkbQt.mjs";
 //#region src/presets/search.ts
 const BUILTINS = [
 	{

package/dist/{presets-BYbPobbF.mjs → presets-CF79RHEo.mjs}

@@ -1,5 +1,5 @@
 import { b as isElevated, n as PUBLIC_SCOPE } from "./types-Bi0r0vjG.mjs";
-import { C as requireAuth, T as requireRoles, y as allowPublic } from "./permissions-B1Qy55fg.mjs";
+import { C as requireAuth, T as requireRoles, y as allowPublic } from "./permissions-3uzwkbQt.mjs";
 import { multiTenantPreset } from "./presets/multiTenant.mjs";
 //#region src/presets/ownedByUser.ts
 /**

package/dist/{queryCachePlugin-Do4P_WBC.d.mts → queryCachePlugin-Bd2tYgh5.d.mts}

@@ -1,5 +1,5 @@
-import { r as CacheStore } from "./interface-BVkZsvEe.mjs";
-import { i as QueryCache } from "./QueryCache-8YmAQ-zW.mjs";
+import { r as CacheStore } from "./interface-DL7LlWS5.mjs";
+import { i as QueryCache } from "./QueryCache-Dsyv2mLS.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/cache/queryCachePlugin.d.ts

package/dist/{queryCachePlugin-B4XMSSe7.mjs → queryCachePlugin-CnAeFqju.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { t as MemoryCacheStore } from "./memory-QOLe11D5.mjs";
-import { t as hasEvents } from "./typeGuards-BzkXkvVv.mjs";
-import { i as versionKey, r as tagVersionKey } from "./keys-DopsCuyQ.mjs";
+import { t as MemoryCacheStore } from "./memory-TdTHCS9-.mjs";
+import { t as hasEvents } from "./typeGuards-CcFZXgU7.mjs";
+import { i as versionKey, r as tagVersionKey } from "./keys-B3yyBEyH.mjs";
 import fp from "fastify-plugin";
 //#region src/cache/QueryCache.ts
 var QueryCache = class {