@classytic/arc 2.6.3 → 2.7.3

package/dist/{permissions-C8ImI8gC.mjs → permissions-CH4cNwJi.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { d as isElevated, f as isMember, n as PUBLIC_SCOPE, o as getTeamId, s as getUserId } from "./types-BhtYdxZU.mjs";
+import { _ as isElevated, b as isService, c as getRequestScope, d as getServiceScopes, f as getTeamId, h as hasOrgAccess, l as getScopeContext, p as getUserId, u as getScopeContextMap, v as isMember, y as isOrgInScope } from "./types-AOD8fxIw.mjs";
 import { t as getUserRoles } from "./types-ZUu_h0jp.mjs";
-import { t as MemoryCacheStore } from "./memory-BFAYkf8H.mjs";
+import { t as MemoryCacheStore } from "./memory-Cp7_cAko.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/permissions/roleHierarchy.ts
 /**
@@ -180,6 +180,29 @@ function readOnly(overrides) {
 //#endregion
 //#region src/permissions/index.ts
 /**
+* Normalize a `string | [readonly string[]]` rest-args tuple into a single
+* `readonly string[]`. Lets a permission helper accept BOTH variadic and
+* array call shapes from the same overload signature without each helper
+* re-implementing the same ternary.
+*
+* Used by `requireOrgRole`, `requireServiceScope`, etc. **Not** used by
+* `requireRoles` — that helper has a richer overload signature with an
+* options object and stays on its own normalization path.
+*
+* @example
+* ```typescript
+* function requireFoo(...args: string[] | [readonly string[]]) {
+*   const items = normalizeVariadicOrArray(args);
+*   // items is always readonly string[]
+* }
+* requireFoo('a', 'b', 'c');
+* requireFoo(['a', 'b', 'c']);
+* ```
+*/
+function normalizeVariadicOrArray(args) {
+	return Array.isArray(args[0]) ? args[0] : args;
+}
+/**
 * Allow public access (no authentication required)
 *
 * @example
@@ -216,26 +239,21 @@ function requireAuth() {
 	};
 	return check;
 }
-/**
-* Require specific roles
-*
-* @param roles - Required roles (user needs at least one)
-* @param options - Optional bypass roles
-*
-* @example
-* ```typescript
-* permissions: {
-*   create: requireRoles(['admin', 'editor']),
-*   delete: requireRoles(['admin']),
-* }
-*
-* // With bypass roles
-* permissions: {
-*   update: requireRoles(['owner'], { bypassRoles: ['admin', 'superadmin'] }),
-* }
-* ```
-*/
-function requireRoles(roles, options) {
+function requireRoles(rolesOrFirst, optionsOrSecond, ...rest) {
+	let roles;
+	let options;
+	if (typeof rolesOrFirst === "string") {
+		roles = [
+			rolesOrFirst,
+			...typeof optionsOrSecond === "string" ? [optionsOrSecond] : [],
+			...rest
+		];
+		options = void 0;
+	} else {
+		roles = rolesOrFirst;
+		options = optionsOrSecond && typeof optionsOrSecond === "object" ? optionsOrSecond : void 0;
+	}
+	const includeOrgRoles = options?.includeOrgRoles ?? true;
 	const check = (ctx) => {
 		if (!ctx.user) return {
 			granted: false,
@@ -244,8 +262,9 @@ function requireRoles(roles, options) {
 		const userRoles = getUserRoles(ctx.user);
 		if (options?.bypassRoles?.some((r) => userRoles.includes(r))) return true;
 		if (roles.some((r) => userRoles.includes(r))) return true;
-		if (options?.includeOrgRoles) {
-			const scope = getScope(ctx.request);
+		if (includeOrgRoles) {
+			const scope = getRequestScope(ctx.request);
+			if (isElevated(scope)) return true;
 			if (isMember(scope) && roles.some((r) => scope.orgRoles.includes(r))) return true;
 		}
 		return {
@@ -257,25 +276,30 @@ function requireRoles(roles, options) {
 	return check;
 }
 /**
-* Unified role check — checks both platform roles AND org roles.
+* **Alias of `requireRoles()`** — checks both platform roles AND org roles.
 *
-* This is the recommended helper for Better Auth organization plugin users.
-* It checks `user.role` (platform) first, then `scope.orgRoles` (org membership).
-* Elevated scope always passes.
+* Since 2.7.1, `requireRoles()` defaults to `includeOrgRoles: true`, which
+* means `roles('admin')` and `requireRoles('admin')` are now functionally
+* identical. This helper is preserved for backwards compatibility and for
+* call sites that prefer the shorter `roles()` name.
 *
-* For platform-only checks: use `requireRoles(['admin'])`
-* For org-only checks: use `requireOrgRole('admin')`
+* **For new code, prefer `requireRoles()`** — it's the canonical name and
+* matches the rest of the `requireXxx()` family (`requireAuth`, `requireOwnership`,
+* `requireOrgRole`, etc.).
+*
+* For platform-only checks: `requireRoles(['admin'], { includeOrgRoles: false })`
+* For org-only checks: `requireOrgRole('admin')`
 *
 * @example
 * ```typescript
-* permissions: {
-*   create: roles('admin', 'editor'),  // passes if user has role at either level
-*   delete: roles('admin'),
-* }
+* // These are identical:
+* roles('admin', 'editor')
+* requireRoles('admin', 'editor')
+* requireRoles(['admin', 'editor'])
 * ```
 */
 function roles(...args) {
-	const roleList = Array.isArray(args[0]) ? args[0] : args;
+	const roleList = normalizeVariadicOrArray(args);
 	const check = (ctx) => {
 		if (!ctx.user) return {
 			granted: false,
@@ -283,7 +307,7 @@ function roles(...args) {
 		};
 		const userRoles = getUserRoles(ctx.user);
 		if (roleList.some((r) => userRoles.includes(r))) return true;
-		const scope = getScope(ctx.request);
+		const scope = getRequestScope(ctx.request);
 		if (isElevated(scope)) return true;
 		if (isMember(scope) && roleList.some((r) => scope.orgRoles.includes(r))) return true;
 		return {
@@ -318,7 +342,7 @@ function requireOwnership(ownerField = "userId", options) {
 		};
 		const userRoles = getUserRoles(ctx.user);
 		if (options?.bypassRoles?.some((r) => userRoles.includes(r))) return true;
-		const userId = getUserId(getScope(ctx.request)) ?? ctx.user.id ?? ctx.user._id;
+		const userId = getUserId(getRequestScope(ctx.request)) ?? ctx.user.id ?? ctx.user._id;
 		if (!userId) return {
 			granted: false,
 			reason: "User identity missing (no id or _id)"
@@ -330,10 +354,22 @@ function requireOwnership(ownerField = "userId", options) {
 	};
 }
 /**
-* Combine multiple checks - ALL must pass (AND logic)
+* Combine multiple checks - ALL must pass (AND logic).
+*
+* Each child runs against the **accumulated** state of previous children:
+*   - `filters` from earlier children are merged into the next child's
+*     `_policyFilters` (so e.g. `requireOwnership` sees row-level scoping)
+*   - `scope` from earlier children is installed on the request before the
+*     next child runs (so e.g. `requireOrgMembership` after `requireApiKey`
+*     sees the service scope from the API key check)
+*
+* The final returned `PermissionResult` carries both the merged `filters` AND
+* the merged `scope`, so the outer middleware's `applyPermissionResult` call
+* sees the same end-state.
 *
 * @example
 * ```typescript
+* // CRUD permissions composed across roles + ownership
 * permissions: {
 *   update: allOf(
 *     requireAuth(),
@@ -341,23 +377,57 @@ function requireOwnership(ownerField = "userId", options) {
 *     requireOwnership('createdBy')
 *   ),
 * }
+*
+* // Custom auth + org membership — first check installs the scope,
+* // second check reads it.
+* permissions: {
+*   list: allOf(requireApiKey(), requireOrgMembership()),
+* }
 * ```
 */
 function allOf(...checks) {
 	return async (ctx) => {
 		let mergedFilters = {};
-		for (const check of checks) {
-			const result = await check(ctx);
-			const normalized = typeof result === "boolean" ? { granted: result } : result;
-			if (!normalized.granted) return normalized;
-			if (normalized.filters) mergedFilters = {
-				...mergedFilters,
-				...normalized.filters
-			};
+		let installedScope;
+		const sink = ctx.request;
+		const originalFilters = sink._policyFilters;
+		const originalScope = sink.scope;
+		try {
+			for (const check of checks) {
+				const result = await check(ctx);
+				const normalized = typeof result === "boolean" ? { granted: result } : result;
+				if (!normalized.granted) {
+					sink._policyFilters = originalFilters;
+					sink.scope = originalScope;
+					return normalized;
+				}
+				if (normalized.filters) {
+					mergedFilters = {
+						...mergedFilters,
+						...normalized.filters
+					};
+					sink._policyFilters = {
+						...sink._policyFilters ?? {},
+						...normalized.filters
+					};
+				}
+				if (normalized.scope) {
+					const current = sink.scope;
+					if (!current || current.kind === "public") {
+						sink.scope = normalized.scope;
+						installedScope = normalized.scope;
+					} else if (!installedScope) installedScope = normalized.scope;
+				}
+			}
+		} catch (err) {
+			sink._policyFilters = originalFilters;
+			sink.scope = originalScope;
+			throw err;
 		}
 		return {
 			granted: true,
-			filters: Object.keys(mergedFilters).length > 0 ? mergedFilters : void 0
+			filters: Object.keys(mergedFilters).length > 0 ? mergedFilters : void 0,
+			scope: installedScope
 		};
 	};
 }
@@ -424,33 +494,37 @@ function when(condition) {
 		};
 	};
 }
-/** Read request.scope safely */
-function getScope(request) {
-	return request.scope ?? PUBLIC_SCOPE;
-}
 /**
-* Require membership in the active organization.
-* User must be authenticated AND have an active org (member or elevated scope).
+* Require an org-bound caller. Grants access for any scope kind that
+* carries org context: `member` (human user with org membership), `service`
+* (API key bound to an org), or `elevated` (platform admin). Denies for
+* `public` and `authenticated` scopes (no org context).
 *
-* Reads `request.scope` set by auth adapters.
+* This is the canonical "is the caller acting inside an org" check, and the
+* usual partner for `multiTenantPreset` — if a route is multi-tenant
+* filtered, you almost always want this gate too.
+*
+* Reads `request.scope` set by auth adapters or by upstream permission
+* checks via `PermissionResult.scope` (e.g. a custom `requireApiKey()`).
 *
 * @example
 * ```typescript
 * permissions: {
 *   list: requireOrgMembership(),
 *   get: requireOrgMembership(),
+*
+*   // Composed with an OAuth-style scope check for API-key callers
+*   create: allOf(requireOrgMembership(), requireServiceScope('jobs:write')),
 * }
 * ```
 */
 function requireOrgMembership() {
 	const check = (ctx) => {
+		if (hasOrgAccess(getRequestScope(ctx.request))) return true;
 		if (!ctx.user) return {
 			granted: false,
 			reason: "Authentication required"
 		};
-		const scope = getScope(ctx.request);
-		if (isElevated(scope)) return true;
-		if (isMember(scope)) return true;
 		return {
 			granted: false,
 			reason: "Organization membership required"
@@ -464,6 +538,23 @@ function requireOrgMembership() {
 * Reads `request.scope.orgRoles` (set by auth adapters).
 * Elevated scope always passes (platform admin bypass).
 *
+* **Service scopes (API keys) always fail this check** — services don't
+* carry user-style org roles, only OAuth-style `scopes` strings. For routes
+* that should accept BOTH human admins AND API keys, compose explicitly:
+*
+* ```typescript
+* permissions: {
+*   create: anyOf(
+*     requireOrgRole('admin'),                       // human path
+*     requireServiceScope('jobs:write'),             // machine path
+*   ),
+* }
+* ```
+*
+* This separation is intentional — implicit "API key bypasses role checks"
+* is the kind of footgun that ships data breaches. Services must opt into
+* specific scopes the same way OAuth clients do.
+*
 * @param roles - Required org roles (user needs at least one)
 *
 * @example
@@ -475,14 +566,18 @@ function requireOrgMembership() {
 * ```
 */
 function requireOrgRole(...args) {
-	const roles = Array.isArray(args[0]) ? args[0] : args;
+	const roles = normalizeVariadicOrArray(args);
 	const check = (ctx) => {
+		const scope = getRequestScope(ctx.request);
+		if (isElevated(scope)) return true;
+		if (isService(scope)) return {
+			granted: false,
+			reason: "Service scopes (API keys) cannot satisfy requireOrgRole. Use requireServiceScope(...) for machine identities, or compose with anyOf(requireOrgRole(...), requireServiceScope(...)) to accept both."
+		};
 		if (!ctx.user) return {
 			granted: false,
 			reason: "Authentication required"
 		};
-		const scope = getScope(ctx.request);
-		if (isElevated(scope)) return true;
 		if (!isMember(scope)) return {
 			granted: false,
 			reason: "Organization membership required"
@@ -497,6 +592,205 @@ function requireOrgRole(...args) {
 	return check;
 }
 /**
+* Require specific OAuth-style scope strings on a service (API key) identity.
+*
+* Reads `request.scope.scopes` — only populated when the scope kind is
+* `service`. Mirrors how OAuth 2.0 / Better Auth's apiKey plugin / API
+* gateways express machine permissions: a comma- or array-encoded list of
+* scope strings like `'jobs:read'`, `'jobs:write'`, `'memories:*'`.
+*
+* **Pass behavior:**
+* - `service` scope where `scopes` contains ANY of the required strings → grant
+* - `elevated` scope (platform admin) → grant
+* - Anything else → deny with a clear reason
+*
+* Notably this does **not** grant for `member` scopes — humans go through
+* `requireOrgRole`. For routes that should accept both, compose with `anyOf`:
+*
+* ```typescript
+* permissions: {
+*   create: anyOf(
+*     requireOrgRole('admin'),
+*     requireServiceScope('jobs:write'),
+*   ),
+* }
+* ```
+*
+* @param scopes - Required scope strings (caller needs at least one)
+*
+* @example
+* ```typescript
+* // Variadic
+* requireServiceScope('jobs:write')
+* requireServiceScope('jobs:read', 'jobs:write')
+*
+* // Array
+* requireServiceScope(['jobs:read', 'jobs:write'])
+*
+* // Composed with org membership for org-scoped API keys
+* permissions: {
+*   list: allOf(requireOrgMembership(), requireServiceScope('jobs:read')),
+*   create: allOf(requireOrgMembership(), requireServiceScope('jobs:write')),
+* }
+* ```
+*/
+function requireServiceScope(...args) {
+	const required = normalizeVariadicOrArray(args);
+	if (required.length === 0) throw new Error("requireServiceScope() requires at least one scope string (e.g. requireServiceScope('jobs:write'))");
+	const check = (ctx) => {
+		const scope = getRequestScope(ctx.request);
+		if (isElevated(scope)) return true;
+		if (!isService(scope)) return {
+			granted: false,
+			reason: "Service identity required (API key). For human users, use requireOrgRole(...) or compose with anyOf(requireOrgRole(...), requireServiceScope(...))."
+		};
+		const granted = getServiceScopes(scope);
+		if (required.some((r) => granted.includes(r))) return true;
+		return {
+			granted: false,
+			reason: `Required service scopes: ${required.join(", ")} (granted: ${granted.length > 0 ? granted.join(", ") : "none"})`
+		};
+	};
+	check._serviceScopes = required;
+	return check;
+}
+/**
+* Require app-defined scope context dimensions (branch, project, department,
+* region, workspace, etc.) on the current request.
+*
+* Reads `request.scope.context` (a `Readonly<Record<string, string>>` slot
+* available on `member`, `service`, and `elevated` scope kinds). Arc takes
+* no position on what dimensions you use — you set them, you check them.
+*
+* **Three call shapes:**
+*
+* ```typescript
+* // 1. Presence check — key must exist on scope.context
+* requireScopeContext('branchId')
+*
+* // 2. Value match — key must equal a specific string
+* requireScopeContext('branchId', 'eng-paris')
+*
+* // 3. Multi-key (object form, AND semantics) — every key must match
+* requireScopeContext({ branchId: 'eng-paris', projectId: 'p-123' })
+* requireScopeContext({ region: 'eu', branchId: undefined })  // 'undefined' = presence-only for that key
+* ```
+*
+* **Pass behavior:**
+* - All required keys present (and matching values when specified) → grant
+* - `elevated` scope (platform admin) → grant unconditionally (cross-context bypass)
+* - Any required key missing or mismatched → deny with a clear reason
+* - Scope kind without context support (`public`, `authenticated`) → deny
+*
+* Pairs with `multiTenantPreset({ tenantFields: [...] })` for row-level
+* filtering on the same dimensions.
+*
+* @example
+* ```typescript
+* permissions: {
+*   // Branch-scoped CRUD — caller must have branchId in their scope context
+*   list: allOf(requireOrgMembership(), requireScopeContext('branchId')),
+*
+*   // Project admin — caller must have BOTH project context AND admin role
+*   delete: allOf(requireOrgRole('admin'), requireScopeContext('projectId')),
+*
+*   // Region-locked endpoint
+*   euOnly: requireScopeContext('region', 'eu'),
+* }
+* ```
+*/
+function requireScopeContext(keyOrMap, value) {
+	let required;
+	if (typeof keyOrMap === "string") required = { [keyOrMap]: value };
+	else if (keyOrMap && typeof keyOrMap === "object") required = keyOrMap;
+	else throw new Error("requireScopeContext() requires a key (string), key+value, or { key: value } map");
+	const requiredKeys = Object.keys(required);
+	if (requiredKeys.length === 0) throw new Error("requireScopeContext() requires at least one key (e.g. requireScopeContext('branchId'))");
+	const check = (ctx) => {
+		const scope = getRequestScope(ctx.request);
+		if (isElevated(scope)) return true;
+		if (!getScopeContextMap(scope)) return {
+			granted: false,
+			reason: "Scope context required (member, service, or elevated scope). Populate request.scope.context in your auth function."
+		};
+		for (const key of requiredKeys) {
+			const expected = required[key];
+			const actual = getScopeContext(scope, key);
+			if (actual === void 0) return {
+				granted: false,
+				reason: `Required scope context key "${key}" is missing`
+			};
+			if (expected !== void 0 && actual !== expected) return {
+				granted: false,
+				reason: `Required scope context "${key}" must equal "${expected}" (got "${actual}")`
+			};
+		}
+		return true;
+	};
+	check._scopeContext = required;
+	return check;
+}
+/**
+* Require that the caller's scope grants access to a target organization
+* — either the current org or one of its ancestors (`scope.ancestorOrgIds`).
+*
+* Designed for parent-child organization hierarchies (holding company →
+* subsidiary → branch, MSP → managed tenants, white-label parent → child
+* accounts) where some routes need to accept "this org OR any org I have
+* access to via the chain". Arc takes no position on the source of the
+* chain — your auth function loads `ancestorOrgIds` from your own data
+* model. There's no automatic inheritance: every route opts in explicitly.
+*
+* **Two call shapes:**
+*
+* ```typescript
+* // Static target — rare, used when one route only ever acts on one org
+* requireOrgInScope('acme-holding')
+*
+* // Dynamic target — extracted from request params/body/headers per call
+* requireOrgInScope((ctx) => ctx.request.params.orgId)
+* requireOrgInScope((ctx) => ctx.request.body?.organizationId)
+* ```
+*
+* **Pass behavior:**
+* - Target equals `scope.organizationId` → grant
+* - Target appears in `scope.ancestorOrgIds` → grant
+* - `elevated` scope → grant unconditionally (cross-org admin bypass)
+* - Target is undefined (extractor returned nothing) → deny with reason
+* - Anything else → deny with target name in reason
+*
+* @example
+* ```typescript
+* // /orgs/:orgId/jobs — caller can act on any org in their hierarchy chain
+* permissions: {
+*   list: requireOrgInScope((ctx) => ctx.request.params.orgId),
+*   create: allOf(
+*     requireOrgInScope((ctx) => ctx.request.body?.organizationId),
+*     requireOrgRole('admin'),
+*   ),
+* }
+* ```
+*/
+function requireOrgInScope(target) {
+	if (target === void 0 || target === null) throw new Error("requireOrgInScope() requires a target org id (string) or an extractor function");
+	const check = (ctx) => {
+		const scope = getRequestScope(ctx.request);
+		if (isElevated(scope)) return true;
+		const targetOrgId = typeof target === "function" ? target(ctx) : target;
+		if (!targetOrgId) return {
+			granted: false,
+			reason: "requireOrgInScope: target org id could not be resolved from the request"
+		};
+		if (isOrgInScope(scope, targetOrgId)) return true;
+		return {
+			granted: false,
+			reason: `Target organization "${targetOrgId}" is not in the caller's org hierarchy`
+		};
+	};
+	check._orgInScopeTarget = target;
+	return check;
+}
+/**
 * Create a scoped permission system for resource-action patterns.
 * Maps org roles to fine-grained permissions without external API calls.
 *
@@ -537,7 +831,7 @@ function createOrgPermissions(config) {
 					granted: false,
 					reason: "Authentication required"
 				};
-				const scope = getScope(ctx.request);
+				const scope = getRequestScope(ctx.request);
 				if (isElevated(scope)) return true;
 				if (!isMember(scope)) return {
 					granted: false,
@@ -650,7 +944,7 @@ function createDynamicPermissionMatrix(config) {
 				granted: false,
 				reason: "Authentication required"
 			};
-			const scope = getScope(ctx.request);
+			const scope = getRequestScope(ctx.request);
 			if (isElevated(scope)) return true;
 			if (!isMember(scope)) return {
 				granted: false,
@@ -774,7 +1068,7 @@ function requireTeamMembership() {
 			granted: false,
 			reason: "Authentication required"
 		};
-		const scope = getScope(ctx.request);
+		const scope = getRequestScope(ctx.request);
 		if (isElevated(scope)) return true;
 		if (!isMember(scope)) return {
 			granted: false,
@@ -790,4 +1084,4 @@ function requireTeamMembership() {
 	return check;
 }
 //#endregion
-export { createRoleHierarchy as C, readOnly as S, fullPublic as _, createOrgPermissions as a, publicRead as b, requireOrgMembership as c, requireRoles as d, requireTeamMembership as f, authenticated as g, adminOnly as h, createDynamicPermissionMatrix as i, requireOrgRole as l, when as m, allowPublic as n, denyAll as o, roles as p, anyOf as r, requireAuth as s, allOf as t, requireOwnership as u, ownerWithAdminBypass as v, publicReadAdminWrite as x, presets_exports as y };
+export { publicRead as C, createRoleHierarchy as E, presets_exports as S, readOnly as T, when as _, createOrgPermissions as a, fullPublic as b, requireOrgInScope as c, requireOwnership as d, requireRoles as f, roles as g, requireTeamMembership as h, createDynamicPermissionMatrix as i, requireOrgMembership as l, requireServiceScope as m, allowPublic as n, denyAll as o, requireScopeContext as p, anyOf as r, requireAuth as s, allOf as t, requireOrgRole as u, adminOnly as v, publicReadAdminWrite as w, ownerWithAdminBypass as x, authenticated as y };

package/dist/plugins/index.d.mts

@@ -1,8 +1,9 @@
-import { Bt as ResourceRegistry, H as MiddlewareConfig, X as PresetHook, cn as HookSystem, ft as RouteSchemaOptions, l as AdditionalRoute, u as AnyRecord } from "../interface-DYH8AXGe.mjs";
-import { t as ExternalOpenApiPaths } from "../externalPaths-DpO-s7r8.mjs";
-import { _ as cachingPlugin, a as versioningPlugin, c as MetricsOptions, d as SSEOptions, f as _default$6, g as _default$1, h as CachingRule, i as _default$7, l as _default$4, m as CachingOptions, n as errorHandlerPlugin, o as MetricEntry, p as ssePlugin, r as VersioningOptions, s as MetricsCollector, t as ErrorHandlerOptions, u as metricsPlugin } from "../errorHandler-Do4vVQ1f.mjs";
-import { t as TracingOptions } from "../tracing-bz_U4EM1.mjs";
+import { Bt as ResourceRegistry, H as MiddlewareConfig, X as PresetHook, cn as HookSystem, ft as RouteSchemaOptions, l as AdditionalRoute, u as AnyRecord } from "../interface-B91alUzq.mjs";
+import { t as ExternalOpenApiPaths } from "../externalPaths-iba7jD3d.mjs";
+import { _ as cachingPlugin, a as versioningPlugin, c as MetricsOptions, d as SSEOptions, f as _default$6, g as _default$1, h as CachingRule, i as _default$7, l as _default$4, m as CachingOptions, n as errorHandlerPlugin, o as MetricEntry, p as ssePlugin, r as VersioningOptions, s as MetricsCollector, t as ErrorHandlerOptions, u as metricsPlugin } from "../errorHandler-pCpEtNd7.mjs";
+import { t as TracingOptions } from "../tracing-DEqdGkr-.mjs";
 import { FastifyInstance, FastifyPluginAsync } from "fastify";
+import * as _$node_stream0 from "node:stream";
 
 //#region src/core/arcCorePlugin.d.ts
 interface ArcCorePluginOptions {
@@ -148,6 +149,52 @@ interface HealthOptions {
 declare const healthPlugin: FastifyPluginAsync<HealthOptions>;
 declare const _default$3: FastifyPluginAsync<HealthOptions>;
 //#endregion
+//#region src/plugins/replyHelpers.d.ts
+declare module "fastify" {
+  interface FastifyReply {
+    /** Send a success response with data */
+    ok<T>(data: T, statusCode?: number): FastifyReply;
+    /** Send an error response */
+    fail(error: string | string[], statusCode?: number): FastifyReply;
+    /** Send a paginated list response */
+    paginated<T>(result: {
+      docs: T[];
+      total: number;
+      page: number;
+      limit: number;
+      [key: string]: unknown;
+    }): FastifyReply;
+    /**
+     * Stream a readable source as a file download or raw stream.
+     *
+     * @example
+     * ```typescript
+     * // CSV export
+     * return reply.stream(csvReadableStream, {
+     *   contentType: 'text/csv',
+     *   filename: 'export.csv',
+     * });
+     *
+     * // PDF download
+     * return reply.stream(pdfBuffer, {
+     *   contentType: 'application/pdf',
+     *   filename: 'report.pdf',
+     * });
+     *
+     * // Raw stream (no Content-Disposition)
+     * return reply.stream(dataStream, { contentType: 'application/octet-stream' });
+     * ```
+     */
+    stream(source: _$node_stream0.Readable | Buffer | AsyncIterable<unknown>, options: {
+      contentType: string;
+      filename?: string;
+      statusCode?: number;
+    }): FastifyReply;
+  }
+}
+declare function replyHelpersPluginFn(fastify: FastifyInstance): Promise<void>;
+declare const replyHelpersPlugin: typeof replyHelpersPluginFn;
+//#endregion
 //#region src/plugins/requestId.d.ts
 interface RequestIdOptions {
   /** Header name to read/write request ID (default: 'x-request-id') */
@@ -166,4 +213,4 @@ declare module "fastify" {
 declare const requestIdPlugin: FastifyPluginAsync<RequestIdOptions>;
 declare const _default$5: FastifyPluginAsync<RequestIdOptions>;
 //#endregion
-export { type ArcCore, type ArcCorePluginOptions, type ArcPlugin, type CachingOptions, type CachingRule, type CreatePluginDefinition, type ErrorHandlerOptions, type GracefulShutdownOptions, type HealthCheck, type HealthOptions, type MetricEntry, type MetricsCollector, type MetricsOptions, type PluginMeta, type PluginResourceResult, type RequestIdOptions, type SSEOptions, type TracingOptions, type VersioningOptions, _default as arcCorePlugin, arcCorePlugin as arcCorePluginFn, _default$1 as cachingPlugin, cachingPlugin as cachingPluginFn, createPlugin, errorHandlerPlugin, errorHandlerPlugin as errorHandlerPluginFn, _default$2 as gracefulShutdownPlugin, gracefulShutdownPlugin as gracefulShutdownPluginFn, _default$3 as healthPlugin, healthPlugin as healthPluginFn, _default$4 as metricsPlugin, metricsPlugin as metricsPluginFn, _default$5 as requestIdPlugin, requestIdPlugin as requestIdPluginFn, _default$6 as ssePlugin, ssePlugin as ssePluginFn, _default$7 as versioningPlugin, versioningPlugin as versioningPluginFn };
+export { type ArcCore, type ArcCorePluginOptions, type ArcPlugin, type CachingOptions, type CachingRule, type CreatePluginDefinition, type ErrorHandlerOptions, type GracefulShutdownOptions, type HealthCheck, type HealthOptions, type MetricEntry, type MetricsCollector, type MetricsOptions, type PluginMeta, type PluginResourceResult, type RequestIdOptions, type SSEOptions, type TracingOptions, type VersioningOptions, _default as arcCorePlugin, arcCorePlugin as arcCorePluginFn, _default$1 as cachingPlugin, cachingPlugin as cachingPluginFn, createPlugin, errorHandlerPlugin, errorHandlerPlugin as errorHandlerPluginFn, _default$2 as gracefulShutdownPlugin, gracefulShutdownPlugin as gracefulShutdownPluginFn, _default$3 as healthPlugin, healthPlugin as healthPluginFn, _default$4 as metricsPlugin, metricsPlugin as metricsPluginFn, replyHelpersPlugin, _default$5 as requestIdPlugin, requestIdPlugin as requestIdPluginFn, _default$6 as ssePlugin, ssePlugin as ssePluginFn, _default$7 as versioningPlugin, versioningPlugin as versioningPluginFn };