@classytic/arc 2.41.1 → 2.43.0

package/dist/redis-stream-BPKscsTB.d.mts

@@ -1,260 +0,0 @@
-
-import { a as EventTransport, i as EventLogger, n as DomainEvent, r as EventHandler } from "./EventTransport-CbUKDzZZ.mjs";
-//#region src/events/transports/redis-stream.d.ts
-interface RedisStreamLike {
-  xadd(key: string, id: string, ...fieldValues: string[]): Promise<string | null>;
-  xreadgroup(command: "GROUP", group: string, consumer: string, ...args: unknown[]): Promise<Array<[string, Array<[string, string[] | null]>]> | null>;
-  xack(key: string, group: string, ...ids: unknown[]): Promise<number>;
-  xgroup(command: string, key: string, group: string, ...args: unknown[]): Promise<unknown>;
-  xpending(key: string, group: string, ...args: unknown[]): Promise<unknown[]>;
-  xclaim(key: string, group: string, consumer: string, minIdleTime: number, ...ids: unknown[]): Promise<unknown[]>;
-  xlen(key: string): Promise<number>;
-  /**
-   * Read a range of entries by id. When present, the DLQ writer uses this
-   * to fetch the original message payload so dead-lettered events are
-   * **fully replayable** (a re-publish of `envelope.event` is sufficient).
-   *
-   * Optional to preserve back-compat with custom Redis wrappers that
-   * satisfied the pre-2.11.3 shape. When missing, the DLQ envelope still
-   * carries the **error reason + attempt accounting** (operator-grade
-   * triage info survives), but `envelope.event.payload` is `null` and
-   * `envelope.event.type` is `<unknown>` — replay is NOT possible without
-   * upgrading the client. A one-shot warning fires per process so this
-   * isn't silent.
-   */
-  xrange?(key: string, start: string, end: string): Promise<Array<[string, string[]]>>;
-  /** Graceful close — flushes queued commands then closes. ioredis-style. */
-  quit(): Promise<unknown>;
-  /**
-   * Force-disconnect — closes the socket immediately, abandoning any
-   * pending command (including a live `XREADGROUP BLOCK`). Optional because
-   * non-ioredis clients may not expose a force path; `close()` falls back
-   * to `quit()` when this is missing, accepting a longer shutdown wait.
-   */
-  disconnect?(): void;
-}
-interface RedisStreamTransportOptions {
-  /**
-   * Redis stream key name.
-   * @default 'arc:events'
-   */
-  stream?: string;
-  /**
-   * Consumer group name. Each group receives every event independently.
-   * Multiple instances of the same service should share a group name.
-   * @default 'default'
-   */
-  group?: string;
-  /**
-   * Consumer name within the group. Must be unique per instance.
-   * @default 'consumer-<random>'
-   */
-  consumer?: string;
-  /**
-   * Block time in ms when waiting for new events.
-   * @default 5000
-   */
-  blockTimeMs?: number;
-  /**
-   * Max events to read per batch.
-   * @default 10
-   */
-  batchSize?: number;
-  /**
-   * Bounded concurrency for processing a batch's ENTRIES (default: 1 —
-   * strict stream order, the safe default). With one slow handler,
-   * throughput per consumer is ~`1 / total handler latency`; raising this
-   * processes up to N entries of a batch concurrently.
-   *
-   * Trade-off: entries within a batch may complete OUT OF ORDER — only
-   * raise it when handlers are order-independent (idempotent, keyed
-   * upserts). Handlers on this transport should be short and I/O-bound
-   * regardless; heavy work belongs in jobs. Matching handlers for a single
-   * event always run sequentially.
-   * @default 1
-   */
-  processingConcurrency?: number;
-  /**
-   * Max delivery attempts before moving to dead letter stream.
-   * @default 5
-   */
-  maxRetries?: number;
-  /**
-   * Idle time in ms before pending entries are claimed by this consumer.
-   * Handles crash recovery — if a consumer dies mid-processing, another
-   * consumer will claim its pending entries after this timeout.
-   * @default 30000
-   */
-  claimTimeoutMs?: number;
-  /**
-   * Dead letter stream name. Failed events are moved here after maxRetries.
-   * Set to `false` to disable DLQ (failed events are acked and dropped).
-   * @default 'arc:events:dlq'
-   */
-  deadLetterStream?: string | false;
-  /**
-   * Max stream length (approximate). Uses XADD MAXLEN ~ to trim old entries.
-   * Set to 0 to disable trimming.
-   * @default 10000
-   */
-  maxLen?: number;
-  /**
-   * Max event payload size in bytes. Publish rejects events exceeding this limit
-   * to prevent Redis memory exhaustion from oversized payloads.
-   * @default 1_000_000 (1 MB)
-   */
-  maxPayloadBytes?: number;
-  /**
-   * If `true`, `close()` does NOT call `redis.quit()` — useful when the host
-   * manages the Redis connection lifecycle externally (shared client across
-   * multiple transports / cache stores). Without this, every transport
-   * `close()` would tear down a shared client and break siblings.
-   *
-   * Mirror of `RedisEventTransportOptions.externalLifecycle`.
-   * @default false
-   */
-  externalLifecycle?: boolean;
-  /**
-   * Hard cap on how long `close()` waits for the in-flight `XREADGROUP BLOCK`
-   * iteration to drain. Tests and serverless shutdowns would otherwise hang
-   * up to `blockTimeMs` (default 5s) per close.
-   *
-   * Behaviour after timeout:
-   *   - `externalLifecycle: false` (default) — `redis.disconnect()` (or
-   *     `quit()` if the client lacks `disconnect`) breaks the BLOCK
-   *     immediately. Strict bounded close.
-   *   - `externalLifecycle: true` — arc CANNOT touch the host's connection,
-   *     so the poll loop is left to drain in the background when its
-   *     XREADGROUP returns. `close()` returns within `closeTimeoutMs` but
-   *     the loop's eventual completion is silently absorbed (no log spam,
-   *     no unhandled rejection). The contract here is "bounded return,
-   *     background drain" — set `blockTimeMs` low (e.g. 500ms) under
-   *     externalLifecycle to keep the drain window short.
-   *
-   * @default 1000
-   */
-  closeTimeoutMs?: number;
-  /**
-   * Logger for error messages (default: console).
-   * Pass `fastify.log` to integrate with your application logger.
-   */
-  logger?: EventLogger;
-}
-declare class RedisStreamTransport implements EventTransport {
-  readonly name = "redis-stream";
-  private redis;
-  private stream;
-  private group;
-  private consumer;
-  private blockTimeMs;
-  private batchSize;
-  private processingConcurrency;
-  private maxRetries;
-  private claimTimeoutMs;
-  private deadLetterStream;
-  private maxLen;
-  private maxPayloadBytes;
-  private logger;
-  /** Tracks the lifecycle policy — set in constructor, read in close(). */
-  private externalLifecycle;
-  private closeTimeoutMs;
-  private handlers;
-  private running;
-  private pollPromise;
-  /**
-   * Monotonic counter bumped every time the poll loop should stop —
-   * `unsubscribe` (last handler removed) and `close()` increment it. Each
-   * `pollLoop` instance captures its generation at start and exits when
-   * `this.generation` no longer matches. Prevents the
-   * subscribe → unsubscribe → fast-resubscribe race where the old loop
-   * would still be in `XREADGROUP BLOCK` while a new loop started, leading
-   * to two concurrent poll loops on the same consumer name.
-   */
-  private generation;
-  private groupCreated;
-  /**
-   * Last-seen failure context per message id, populated when an in-process
-   * handler throws in {@link processEntry}. Consumed (and cleared) by
-   * {@link moveToDlq} so the dead-letter envelope carries the actual error
-   * message instead of opaque "reclaimed without context". Entries are
-   * deleted on ack and on DLQ write; messages resolved by ANOTHER consumer
-   * never drain locally, so the map is additionally hard-capped at
-   * {@link MAX_FAILURE_CONTEXT_ENTRIES} with oldest-first eviction.
-   */
-  private failureContext;
-  /** One-shot guard so the "client lacks xrange" warning fires once per process. */
-  private xrangeWarningEmitted;
-  constructor(redis: RedisStreamLike, options?: RedisStreamTransportOptions);
-  publish(event: DomainEvent): Promise<void>;
-  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
-  /**
-   * Stop polling and release transport state.
-   *
-   * **Two close contracts** — pick the one that matches your deployment:
-   *
-   * 1. **Default (`externalLifecycle: false`) — strict bounded close.**
-   *    `close()` waits up to `closeTimeoutMs` for the in-flight
-   *    `XREADGROUP BLOCK` to drain. On timeout it calls `redis.disconnect()`
-   *    (or `quit()` if the client lacks `disconnect`) to break the BLOCK
-   *    immediately, then awaits the loop's exit. After `close()` returns
-   *    the transport is fully closed and the connection is released.
-   *
-   * 2. **`externalLifecycle: true` — bounded RETURN, background drain.**
-   *    Arc must NOT touch a connection it doesn't own. `close()` returns
-   *    within `closeTimeoutMs`, but the poll loop is left to drain on its
-   *    own when its outstanding `XREADGROUP BLOCK` returns (up to
-   *    `blockTimeMs`). Arc silently absorbs the loop's eventual completion
-   *    so the host doesn't see unhandled rejections / log spam against a
-   *    transport it considers closed. The host's own `redis.quit()` /
-   *    process exit is what ultimately tears the connection down.
-   *
-   *    Practical implication: under `externalLifecycle: true`, set
-   *    `blockTimeMs` low (e.g. 500ms) so the background drain window is
-   *    short. The transport is "closed enough" to stop dispatching to
-   *    handlers (handlers map is cleared and generation is bumped) but is
-   *    not "fully closed" in the connection-lifecycle sense until the host
-   *    closes the underlying client.
-   *
-   * In both modes the generation counter is bumped, so a follow-up
-   * `subscribe()` spawns a fresh poll loop with a new generation — the
-   * stale loop exits on its next iteration and never overlaps the new one.
-   */
-  close(): Promise<void>;
-  private ensureGroup;
-  private pollLoop;
-  private readNewMessages;
-  /**
-   * Process a batch's entries with bounded concurrency
-   * (`processingConcurrency`, default 1 = strict order). Worker-pool over a
-   * shared index — at most N entries in flight, each entry's own handlers
-   * still sequential inside `processEntry`.
-   */
-  private processEntries;
-  private claimPending;
-  private processEntry;
-  /**
-   * The canonical matcher from primitives — the SAME glob rules the memory
-   * transport speaks. A private matcher here once accepted `prefix.*` but not
-   * `prefix:*`, so an `order:*` subscription that worked in-process received
-   * nothing after a move to the stream, with no error.
-   */
-  private getMatchingHandlers;
-  private moveToDlq;
-  /**
-   * Reconstruct a `DeadLetteredEvent` for a message id. Reads the original
-   * entry via `xrange` (when the client supports it) and merges in any
-   * in-process failure context. Returns `null` only when BOTH sources are
-   * missing — callers ack-and-drop rather than re-queuing a ghost.
-   *
-   * Graceful degradation paths:
-   *   - Client lacks `xrange` (older custom wrappers) → log once, build the
-   *     envelope from `failureContext` alone. Payload is absent but the
-   *     error reason + attempt accounting still survive.
-   *   - `xrange` throws (network blip, ACL) → same fallback.
-   *   - Source entry trimmed before DLQ write → same fallback.
-   */
-  private buildDlqEnvelope;
-  private sleep;
-}
-//#endregion
-export { RedisStreamTransport as n, RedisStreamTransportOptions as r, RedisStreamLike as t };

package/dist/registerRoute-Bsnk6NiZ.mjs

@@ -1,364 +0,0 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { n as evaluateAndApplyPermission } from "./authorizationDecision-DawKGoXb.mjs";
-import { f as createError } from "./errors-BH7YU_9O.mjs";
-import { u as getRequestScope } from "./types-CgenB1gv.mjs";
-import { r as deriveHiddenFieldPermissions } from "./fields-BHrkoF5y.mjs";
-import { n as requestContext } from "./requestContext-cDkAUr-P.mjs";
-//#region src/core/middlewares/arcDecorator.ts
-/**
-* Build the `arcDecorator` preHandler for a resource.
-*
-* The decorator is a closure over frozen metadata — allocated once per
-* resource and shared across every request. Stamps `req.arc` with the
-* resource's field permissions, hooks, events bus, and schema options
-* so `sendControllerResponse`, `BaseController.run*`, and custom
-* middleware can read a consistent view.
-*
-* Also populates `requestContext.resourceName` for async-context access
-* in code paths that can't reach `req.arc` directly (e.g. detached logger
-* formatters).
-*/
-function buildArcDecorator(meta) {
-	const frozen = Object.freeze({
-		...meta,
-		fields: deriveHiddenFieldPermissions(meta.schemaOptions, meta.fields)
-	});
-	return async (req, _reply) => {
-		req.arc = frozen;
-		const store = requestContext.get();
-		if (store) store.resourceName = frozen.resourceName;
-	};
-}
-//#endregion
-//#region src/core/middlewares/auth.ts
-/**
-* A permission requires authentication unless it carries the `_isPublic`
-* marker set by `allowPublic()`. Absence of a permission is treated as
-* public (no auth) — matches historical CRUD behaviour.
-*/
-function requiresAuthentication(permission) {
-	if (!permission) return false;
-	return !permission._isPublic;
-}
-/**
-* Pick the right Fastify auth decorator for a single-permission route:
-*   - protected route → `fastify.authenticate` (401 on missing token)
-*   - public route    → `fastify.optionalAuthenticate` (parses token if present)
-*
-* Public routes still get optional auth so downstream multi-tenant filters
-* can narrow queries when a Bearer token IS supplied.
-*/
-function buildAuthMiddleware(fastify, permission) {
-	if (requiresAuthentication(permission)) return fastify.authenticate ?? null;
-	return fastify.optionalAuthenticate ?? null;
-}
-/**
-* Pick the right auth decorator for a multi-permission route (Action router).
-*
-* The input is the array of resolved per-action permissions — one slot per
-* action, in registration order, already flattened against `globalAuth`
-* fallback by the caller (`actionPermissions[name] ?? globalAuth`). A slot
-* may be `undefined` when the action has no per-action check AND no
-* `globalAuth` fallback — that is "public by omission" and must be honored
-* here the same way `buildActionPermissionMw` honors it (by skipping the
-* permission evaluation entirely). If we filtered undefineds out at this
-* layer, a mixed endpoint like `{ ping: undefined, promote: requireRoles(...) }`
-* would collapse to "all protected" and 401 the public `ping` action at the
-* auth layer before the permission prehandler could let it through.
-*
-* Rules:
-*   - ALL public (explicit allowPublic OR omission) → `optionalAuthenticate`
-*   - ALL protected                                 → `authenticate` (fail-fast)
-*   - MIXED                                         → `optionalAuthenticate`
-*     (parse token if present; per-action check fails-closed when user=null)
-*
-* The mixed case was previously handled by an in-handler
-* `fastify.authenticate()` call that bypassed the preHandler chain; this
-* helper moves that logic back into the preHandler stack so the request
-* lifecycle is consistent across router types.
-*/
-function buildAuthMiddlewareForPermissions(fastify, permissions) {
-	if (permissions.length === 0) return fastify.optionalAuthenticate ?? null;
-	const hasProtected = permissions.some((p) => requiresAuthentication(p));
-	const hasPublic = permissions.some((p) => p && p._isPublic === true) || permissions.some((p) => !p);
-	if (hasProtected && !hasPublic) return fastify.authenticate ?? null;
-	return fastify.optionalAuthenticate ?? null;
-}
-//#endregion
-//#region src/core/middlewares/chain.ts
-/**
-* Compose the route-level `onRequest` + `preHandler` arrays in the canonical
-* order. Every null/undefined entry is dropped. Keeps the three routers from
-* accidentally ordering the same ingredients differently (regression risk:
-* cache before auth → user-scoped cache keys leak across users; auth after
-* body parse → anonymous schema probing).
-*
-* onRequest constraints (Fastify lifecycle): `request.body` is undefined —
-* everything placed there must be header/cookie/param/query-driven. arc's
-* `authenticate` / `optionalAuthenticate` qualify by contract (Bearer
-* header, session cookie, api-key header); `preAuth` handlers exist
-* precisely to promote query tokens into headers (SSE `?token=`); the arc
-* decorator stamps static route metadata.
-*/
-function buildRouteHooks(parts) {
-	return {
-		onRequest: [
-			...parts.preAuth ?? [],
-			parts.arcDecorator,
-			parts.authMw ?? null
-		].filter(Boolean),
-		preHandler: [
-			parts.permissionMw ?? null,
-			parts.pluginMw ?? null,
-			...parts.routeGuards ?? [],
-			...parts.customMws ?? []
-		].filter(Boolean)
-	};
-}
-/**
-* Spread helper — turns `RouteHookChains` into the two Fastify route-option
-* fields, omitting empty arrays so routes without middleware stay
-* option-free (Fastify skips absent hooks faster than empty arrays).
-*/
-function routeHookOptions(hooks) {
-	return {
-		...hooks.onRequest.length > 0 ? { onRequest: hooks.onRequest } : {},
-		...hooks.preHandler.length > 0 ? { preHandler: hooks.preHandler } : {}
-	};
-}
-/**
-* `RouteDefinition.preHandler` accepts two shapes:
-*
-*   1. **Array form** — `RouteHandlerMethod[]`. Used directly.
-*   2. **Factory form** — `(fastify) => RouteHandlerMethod[]`. Called once at
-*      route-registration time with the Fastify instance, so handlers can
-*      capture decorators (`fastify.authenticate`, `fastify.events`, etc.)
-*      that aren't on the request.
-*
-* The two forms are equally idiomatic, but the discrimination is by
-* `typeof preHandler === "function"`. Single-function shapes such as
-* `multipartBody({...})` (a `RouteHandlerMethod`) **structurally satisfy
-* the factory branch** at the call site, then fail with a cryptic
-* `Cannot read properties of undefined (reading 'content-type')` once the
-* handler runs with `fastify` in the request slot.
-*
-* This resolver:
-*   1. Distinguishes the two valid shapes.
-*   2. Validates the factory's RETURN — must be an array of functions.
-*   3. Throws an actionable error pointing at the route + the fix when
-*      a single `RouteHandlerMethod` was passed instead of an array, OR
-*      when a factory returned the wrong shape.
-*
-* The error message names the route (`{method} {path}`) and the
-* canonical fix (`preHandler: [yourHandler]`) so the failure mode is
-* obvious instead of debug-archaeology.
-*
-* @param preHandler  The `route.preHandler` value (any of the valid shapes
-*                    plus the common bare-handler mistake).
-* @param fastify     Passed to factory-form preHandlers.
-* @param routeId     `"GET /todos/:id/attach"` (or similar) — used in the
-*                    error message so a multi-route file points at the
-*                    actual offender.
-*/
-function resolveRoutePreHandlers(preHandler, fastify, routeId) {
-	if (preHandler === void 0 || preHandler === null) return [];
-	if (Array.isArray(preHandler)) return preHandler.filter((h) => typeof h === "function");
-	if (typeof preHandler === "function") {
-		let result;
-		try {
-			result = preHandler(fastify);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			throw new TypeError(`Route ${routeId}: preHandler factory threw during route registration: ${msg}.\nIf you intended to pass a single handler (e.g. \`multipartBody({...})\`), wrap it in an array: \`preHandler: [yourHandler]\`. The factory form is \`(fastify) => RouteHandlerMethod[]\` — it must return an array.`, { cause: err instanceof Error ? err : void 0 });
-		}
-		if (result && typeof result.then === "function") result.catch(() => void 0);
-		if (!Array.isArray(result)) throw new TypeError(`Route ${routeId}: preHandler factory must return an array of handlers, got ${describeValue(result)}.\nCommon cause: passing a single \`RouteHandlerMethod\` (e.g. \`multipartBody({...})\`) where an array was expected. Wrap it: \`preHandler: [yourHandler]\`. The factory form \`(fastify) => RouteHandlerMethod[]\` is for cases that need the Fastify instance — e.g. \`(fastify) => [fastify.authenticate, myHandler]\`.`);
-		return result.filter((h) => typeof h === "function");
-	}
-	throw new TypeError(`Route ${routeId}: preHandler must be an array of handlers OR a factory \`(fastify) => RouteHandlerMethod[]\`. Got ${describeValue(preHandler)}.`);
-}
-function describeValue(v) {
-	if (v === null) return "null";
-	if (v === void 0) return "undefined";
-	if (typeof v === "function") return "a function (single handler — wrap in array)";
-	if (Array.isArray(v)) return `an array of length ${v.length}`;
-	return `${typeof v} (${JSON.stringify(v).slice(0, 80)})`;
-}
-//#endregion
-//#region src/core/middlewares/permissions.ts
-/**
-* Build a PermissionContext from a Fastify request. Extracted so the CRUD
-* permission middleware and the dynamic action-permission check use the same
-* field layout — divergence here silently broke policy filters for actions.
-*/
-function buildPermissionContext(req, opts) {
-	const reqWithExtras = req;
-	const params = req.params;
-	return {
-		user: reqWithExtras.user ?? null,
-		scope: getRequestScope(req),
-		request: req,
-		resource: opts.resource,
-		action: opts.action,
-		resourceId: opts.resourceId ?? params?.id,
-		params,
-		data: opts.data ?? req.body
-	};
-}
-/**
-* Static per-route CRUD permission gate. The permission and action are known
-* at route-registration time, so the gate is a plain preHandler.
-*
-* Actions use the dynamic counterpart `buildActionPermissionMw` — their
-* permission is resolved from `body.action` at request time.
-*/
-function buildCrudPermissionMw(permissionCheck, resourceName, action) {
-	if (!permissionCheck) return null;
-	return async (req, reply) => {
-		const context = buildPermissionContext(req, {
-			resource: resourceName,
-			action
-		});
-		await evaluateAndApplyPermission(permissionCheck, context, req, reply);
-	};
-}
-/**
-* Dynamic per-action permission gate for the action router.
-*
-* Resolves the permission from `body.action` at request time and runs
-* `evaluateAndApplyPermission` from the canonical `permissionMw` slot — so
-* `_policyFilters` and `request.scope` are installed BEFORE `pluginMw`
-* (idempotency) and `routeGuards` run. Previously this check lived inside
-* the main action handler, which meant idempotency recorded unauthorized
-* requests and route guards saw unfiltered scope — the very divergence
-* routerShared exists to prevent.
-*
-* Also acts as a defensive fallback for invalid action names — the
-* `oneOf` body schema normally rejects these at AJV validation, but
-* hosts that disable schema validation still get a 400 here.
-*/
-function buildActionPermissionMw(actionEnum, actionPermissions, globalAuth, resourceName) {
-	const enumSet = new Set(actionEnum);
-	const validActions = [...actionEnum];
-	return async (req, reply) => {
-		const body = req.body ?? {};
-		const action = body.action;
-		if (!action || !enumSet.has(action)) throw createError(400, `Invalid action '${action ?? ""}'. Valid actions: ${validActions.join(", ")}`, { validActions });
-		const permissionCheck = actionPermissions[action] ?? globalAuth;
-		if (!permissionCheck) return;
-		const { action: _discard, ...data } = body;
-		const params = req.params;
-		const context = buildPermissionContext(req, {
-			resource: resourceName,
-			action,
-			resourceId: params?.id,
-			data
-		});
-		await evaluateAndApplyPermission(permissionCheck, context, req, reply, { defaultDenialMessage: (user) => user ? `Permission denied for '${action}'` : "Authentication required" });
-	};
-}
-//#endregion
-//#region src/core/middlewares/pluginMw.ts
-/**
-* Pick the request-lifecycle plugin middleware for an HTTP method:
-*   - GET / HEAD        → response cache (if present)
-*   - POST / PUT / PATCH → idempotency (if present)
-*   - DELETE            → none
-*
-* Either field may be `null` if the corresponding plugin wasn't registered.
-*/
-function selectPluginMw(method, mws) {
-	const upper = method.toUpperCase();
-	if (upper === "GET" || upper === "HEAD") return mws.cacheMw;
-	if (upper === "POST" || upper === "PUT" || upper === "PATCH") return mws.idempotencyMw;
-	return null;
-}
-/**
-* Resolve the default cache/idempotency middlewares for a resource.
-*
-* Skips response-cache when the resource has QueryCache active — QueryCache
-* handles caching at the controller level with SWR, so the HTTP-level
-* response-cache would double-cache.
-*/
-function resolveRouterPluginMw(fastify, resourceHasQueryCache) {
-	return {
-		cacheMw: !resourceHasQueryCache && fastify.hasDecorator("responseCache") ? fastify.responseCache.middleware : null,
-		idempotencyMw: fastify.hasDecorator("idempotency") ? fastify.idempotency.middleware : null
-	};
-}
-//#endregion
-//#region src/core/middlewares/rateLimit.ts
-/**
-* Build the per-route Fastify `config` object shared by the CRUD, custom, and
-* action routers. Two independent concerns ride on `routeOptions.config`:
-*   - `config.rateLimit`     — read by `@fastify/rate-limit`.
-*   - `config.cors`          — read by `@fastify/cors` as a per-route override.
-*   - `config.arcExtensions` — read by arc plugins (encryption, …) at request
-*     time, sourced from `defineResource({ extensions })`.
-*
-* Returns `{}` (no `config` key) when neither is present, so routes without
-* either stay config-free and the spread is a genuine no-op. Both fields are
-* optional in the return type, so no cast is needed when only one is set.
-*/
-function buildRouteConfig(rateLimitConfig, extensions, cors) {
-	const hasCors = cors !== void 0;
-	if (!rateLimitConfig && !extensions && !hasCors) return {};
-	return { config: {
-		...rateLimitConfig ?? {},
-		...hasCors ? { cors } : {},
-		...extensions ? { arcExtensions: extensions } : {}
-	} };
-}
-/**
-* Build the `config` object for Fastify route options so
-* @fastify/rate-limit picks up per-route overrides.
-*
-*   - `undefined`                 → no override (inherits instance config)
-*   - `false`                     → explicitly disable rate limiting
-*   - `{ max, timeWindow }`       → apply that limit
-*/
-function buildRateLimitConfig(rateLimit) {
-	if (rateLimit === void 0) return void 0;
-	if (rateLimit === false) return { rateLimit: false };
-	return { rateLimit: {
-		max: rateLimit.max,
-		timeWindow: rateLimit.timeWindow
-	} };
-}
-//#endregion
-//#region src/core/middlewares/registerRoute.ts
-/**
-* Register a route with friendly handling of `FST_ERR_DUPLICATED_ROUTE`.
-*
-* Boot-time `validateRouteCrudCollisions()` catches custom-route → auto-CRUD
-* overlaps before Fastify ever runs, but a few cases still slip through to
-* Fastify itself: two presets contributing the same `routes` entry, hosts
-* mounting two resources at the same prefix, custom routes that share a
-* URL with another plugin. Fastify's default message ("Method 'GET'
-* already declared for route '/'") gives no hint at the resource-shaped
-* fix — `disabledRoutes: ['list']` — so wrap it with one.
-*/
-function tryRegisterRoute(fastify, opts, context) {
-	try {
-		fastify.route(opts);
-	} catch (err) {
-		const fastifyErr = err;
-		if (fastifyErr?.code !== "FST_ERR_DUPLICATED_ROUTE") throw err;
-		const method = opts.method;
-		const url = opts.url;
-		const opHint = context.op ? ` (op: ${context.op})` : "";
-		const fixHint = context.op && [
-			"list",
-			"get",
-			"create",
-			"update",
-			"delete"
-		].includes(context.op) ? ` Suppress the auto-CRUD route with \`disabledRoutes: ['${context.op}']\`.` : " If a custom route in `routes:` collides with auto-CRUD, add `disabledRoutes: ['list' | 'get' | 'create' | 'update' | 'delete']` to `defineResource()` to suppress the matching auto-CRUD route.";
-		const enhanced = /* @__PURE__ */ new Error(`[arc] Duplicate route ${method} ${url} on resource "${context.resourceName}"${opHint}.${fixHint} Original: ${fastifyErr.message ?? "FST_ERR_DUPLICATED_ROUTE"}`);
-		enhanced.code = "FST_ERR_DUPLICATED_ROUTE";
-		enhanced.cause = err;
-		throw enhanced;
-	}
-}
-//#endregion
-export { selectPluginMw as a, buildRouteHooks as c, buildAuthMiddleware as d, buildAuthMiddlewareForPermissions as f, resolveRouterPluginMw as i, resolveRoutePreHandlers as l, buildRateLimitConfig as n, buildActionPermissionMw as o, buildArcDecorator as p, buildRouteConfig as r, buildCrudPermissionMw as s, tryRegisterRoute as t, routeHookOptions as u };

package/dist/sync/changelog.d.mts

@@ -1,3 +0,0 @@
-
-import { ChangeEntry, ChangeLogAppendOptions, ChangeLogStore, ChangeOp, ChangesPage, ChangesSinceOptions, CursorExpiredError, MemoryChangeLogStore, PushMutation, PushVerdict, PushVerdictStatus } from "@classytic/repo-core/sync";
-export { type ChangeEntry, type ChangeLogAppendOptions, type ChangeLogStore, type ChangeOp, type ChangesPage, type ChangesSinceOptions, CursorExpiredError, MemoryChangeLogStore, type PushMutation, type PushVerdict, type PushVerdictStatus };

package/dist/sync/changelog.mjs

@@ -1,3 +0,0 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { CursorExpiredError, MemoryChangeLogStore } from "@classytic/repo-core/sync";
-export { CursorExpiredError, MemoryChangeLogStore };