@classytic/arc 1.1.0 → 2.1.3

package/dist/queryCachePlugin-B6R0d4av.mjs

@@ -0,0 +1,138 @@
+import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
+import { i as versionKey, r as tagVersionKey } from "./keys-DhqDRxv3.mjs";
+import { t as hasEvents } from "./typeGuards-DwxA1t_L.mjs";
+import { t as MemoryCacheStore } from "./memory-B2v7KrCB.mjs";
+import fp from "fastify-plugin";
+
+//#region src/cache/QueryCache.ts
+var QueryCache = class {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	async get(key) {
+		const envelope = await this.store.get(key);
+		if (!envelope || !envelope.createdAt) return {
+			data: void 0,
+			status: "miss"
+		};
+		const now = Date.now();
+		if (now >= envelope.expiresAt) {
+			await this.store.delete(key);
+			return {
+				data: void 0,
+				status: "miss"
+			};
+		}
+		if (now < envelope.staleAfter) return {
+			data: envelope.data,
+			status: "fresh"
+		};
+		return {
+			data: envelope.data,
+			status: "stale"
+		};
+	}
+	async set(key, data, config) {
+		const staleTimeMs = (config.staleTime ?? 0) * 1e3;
+		const totalTtl = staleTimeMs + (config.gcTime ?? 60) * 1e3;
+		const now = Date.now();
+		const envelope = {
+			data,
+			createdAt: now,
+			staleAfter: now + staleTimeMs,
+			expiresAt: now + totalTtl,
+			tags: config.tags ?? []
+		};
+		await this.store.set(key, envelope, { ttlMs: totalTtl });
+	}
+	async invalidate(key) {
+		await this.store.delete(key);
+	}
+	/** Get current version for a resource (defaults to 0 if not set) */
+	async getResourceVersion(resource) {
+		return await this.store.get(versionKey(resource)) ?? 0;
+	}
+	/** Bump resource version — orphans all cached queries for this resource */
+	async bumpResourceVersion(resource) {
+		const key = versionKey(resource);
+		const newVersion = Date.now();
+		await this.store.set(key, newVersion, { ttlMs: 1440 * 60 * 1e3 });
+	}
+	/** Get current version for a tag */
+	async getTagVersion(tag) {
+		return await this.store.get(tagVersionKey(tag)) ?? 0;
+	}
+	/** Bump tag version — orphans all cached queries tagged with this tag */
+	async bumpTagVersion(tag) {
+		const key = tagVersionKey(tag);
+		const newVersion = Date.now();
+		await this.store.set(key, newVersion, { ttlMs: 1440 * 60 * 1e3 });
+	}
+};
+
+//#endregion
+//#region src/cache/queryCachePlugin.ts
+/**
+* QueryCache Fastify Plugin
+*
+* Registers QueryCache on `fastify.queryCache` and wires automatic
+* cache invalidation via CRUD events. Zero config for memory mode.
+*
+* @example
+* ```typescript
+* // Memory mode (default)
+* await fastify.register(queryCachePlugin);
+*
+* // With Redis store
+* await fastify.register(queryCachePlugin, {
+*   store: new RedisCacheStore({ client: redis, prefix: 'arc:qc:' }),
+*   defaults: { staleTime: 30, gcTime: 300 },
+* });
+* ```
+*/
+var queryCachePlugin_exports = /* @__PURE__ */ __exportAll({ queryCachePlugin: () => queryCachePlugin });
+const CRUD_SUFFIXES = new Set([
+	"created",
+	"updated",
+	"deleted"
+]);
+const queryCachePluginImpl = async (fastify, opts = {}) => {
+	const store = opts.store ?? new MemoryCacheStore();
+	const queryCache = new QueryCache(store);
+	const defaults = {
+		staleTime: opts.defaults?.staleTime ?? 0,
+		gcTime: opts.defaults?.gcTime ?? 60
+	};
+	fastify.decorate("queryCache", queryCache);
+	fastify.decorate("queryCacheConfig", defaults);
+	const crossResourceRules = [];
+	fastify.decorate("registerCacheInvalidationRule", (rule) => {
+		crossResourceRules.push(rule);
+	});
+	fastify.addHook("onReady", async () => {
+		if (!hasEvents(fastify)) return;
+		await fastify.events.subscribe("*", async (event) => {
+			const type = event.type;
+			const dotIdx = type.lastIndexOf(".");
+			if (dotIdx === -1) return;
+			const suffix = type.slice(dotIdx + 1);
+			if (!CRUD_SUFFIXES.has(suffix)) return;
+			const resource = type.slice(0, dotIdx);
+			await queryCache.bumpResourceVersion(resource);
+		});
+		for (const rule of crossResourceRules) await fastify.events.subscribe(rule.pattern, async () => {
+			for (const tag of rule.tags) await queryCache.bumpTagVersion(tag);
+		});
+	});
+	fastify.addHook("onClose", async () => {
+		if ("close" in store && typeof store.close === "function") await store.close();
+	});
+};
+const queryCachePlugin = fp(queryCachePluginImpl, {
+	name: "arc-query-cache",
+	fastify: "5.x"
+});
+
+//#endregion
+export { queryCachePlugin_exports as n, QueryCache as r, queryCachePlugin as t };

package/dist/queryCachePlugin-Q6SYuHZ6.d.mts

@@ -0,0 +1,71 @@
+import { i as CacheStore } from "./interface-DTbsvIWe.mjs";
+import { FastifyPluginAsync } from "fastify";
+
+//#region src/cache/QueryCache.d.ts
+/** Metadata wrapper stored in CacheStore */
+interface CacheEnvelope<T = unknown> {
+  data: T;
+  createdAt: number;
+  staleAfter: number;
+  expiresAt: number;
+  tags: string[];
+}
+interface QueryCacheConfig {
+  /** Seconds data is "fresh" (no revalidation). Default: 0 */
+  staleTime?: number;
+  /** Seconds stale data stays cached (SWR window). Default: 60 */
+  gcTime?: number;
+  /** Tags for group invalidation */
+  tags?: string[];
+}
+type CacheStatus = 'fresh' | 'stale' | 'miss';
+interface CacheResult<T> {
+  data: T;
+  status: CacheStatus;
+}
+declare class QueryCache {
+  private readonly store;
+  constructor(store: CacheStore);
+  get<T>(key: string): Promise<CacheResult<T>>;
+  set<T>(key: string, data: T, config: QueryCacheConfig): Promise<void>;
+  invalidate(key: string): Promise<void>;
+  /** Get current version for a resource (defaults to 0 if not set) */
+  getResourceVersion(resource: string): Promise<number>;
+  /** Bump resource version — orphans all cached queries for this resource */
+  bumpResourceVersion(resource: string): Promise<void>;
+  /** Get current version for a tag */
+  getTagVersion(tag: string): Promise<number>;
+  /** Bump tag version — orphans all cached queries tagged with this tag */
+  bumpTagVersion(tag: string): Promise<void>;
+}
+//#endregion
+//#region src/cache/queryCachePlugin.d.ts
+interface QueryCachePluginOptions {
+  /** CacheStore instance. Default: MemoryCacheStore with default options. */
+  store?: CacheStore;
+  /** Global defaults for staleTime/gcTime (seconds) */
+  defaults?: {
+    staleTime?: number;
+    gcTime?: number;
+  };
+}
+interface QueryCacheDefaults {
+  staleTime: number;
+  gcTime: number;
+}
+/** Cross-resource invalidation rules collected from resource configs */
+interface CrossResourceRule {
+  pattern: string;
+  tags: string[];
+}
+declare module 'fastify' {
+  interface FastifyInstance {
+    queryCache: QueryCache;
+    queryCacheConfig: QueryCacheDefaults;
+    /** Register cross-resource invalidation rules (called by defineResource) */
+    registerCacheInvalidationRule?(rule: CrossResourceRule): void;
+  }
+}
+declare const queryCachePlugin: FastifyPluginAsync<QueryCachePluginOptions>;
+//#endregion
+export { CacheEnvelope as a, QueryCache as c, queryCachePlugin as i, QueryCacheConfig as l, QueryCacheDefaults as n, CacheResult as o, QueryCachePluginOptions as r, CacheStatus as s, CrossResourceRule as t };

package/dist/redis-UwjEp8Ea.d.mts

@@ -0,0 +1,49 @@
+import { n as IdempotencyResult, r as IdempotencyStore } from "./interface-CSNjltAc.mjs";
+
+//#region src/idempotency/stores/redis.d.ts
+interface RedisClient {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string, options?: {
+    EX?: number;
+    NX?: boolean;
+  }): Promise<string | null>;
+  del(key: string | string[]): Promise<number>;
+  exists(key: string | string[]): Promise<number>;
+  /** SCAN command — compatible with node-redis and ioredis varargs signatures. */
+  scan?(cursor: string | number, ...args: (string | number)[]): Promise<[string | number, string[]]>;
+  quit?(): Promise<string>;
+  disconnect?(): Promise<void>;
+}
+interface RedisIdempotencyStoreOptions {
+  /** Redis client instance */
+  client: RedisClient;
+  /** Key prefix (default: 'idem:') */
+  prefix?: string;
+  /** Lock key prefix (default: 'idem:lock:') */
+  lockPrefix?: string;
+  /** Default TTL in ms (default: 86400000 = 24 hours) */
+  ttlMs?: number;
+}
+declare class RedisIdempotencyStore implements IdempotencyStore {
+  readonly name = "redis";
+  private client;
+  private prefix;
+  private lockPrefix;
+  private ttlMs;
+  constructor(options: RedisIdempotencyStoreOptions);
+  private resultKey;
+  private lockKey;
+  get(key: string): Promise<IdempotencyResult | undefined>;
+  set(key: string, result: Omit<IdempotencyResult, 'key'>): Promise<void>;
+  tryLock(key: string, requestId: string, ttlMs: number): Promise<boolean>;
+  unlock(key: string, requestId: string): Promise<void>;
+  isLocked(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  deleteByPrefix(prefix: string): Promise<number>;
+  findByPrefix(prefix: string): Promise<IdempotencyResult | undefined>;
+  /** Scan Redis keys matching a prefix pattern. Falls back to empty if SCAN unavailable. */
+  private scanByPrefix;
+  close(): Promise<void>;
+}
+//#endregion
+export { RedisIdempotencyStore as n, RedisIdempotencyStoreOptions as r, RedisClient as t };

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

@@ -0,0 +1,103 @@
+import { i as EventTransport, n as EventHandler, r as EventLogger, t as DomainEvent } from "./EventTransport-BkUDYZEb.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: (string | number)[]): Promise<Array<[string, Array<[string, string[]]>]> | null>;
+  xack(key: string, group: string, ...ids: string[]): Promise<number>;
+  xgroup(command: string, key: string, group: string, ...args: string[]): Promise<unknown>;
+  xpending(key: string, group: string, ...args: (string | number)[]): Promise<Array<[string, string, number, number]>>;
+  xclaim(key: string, group: string, consumer: string, minIdleTime: number, ...ids: string[]): Promise<Array<[string, string[]]>>;
+  xlen(key: string): Promise<number>;
+  quit(): Promise<unknown>;
+}
+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;
+  /**
+   * 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;
+  /**
+   * 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 maxRetries;
+  private claimTimeoutMs;
+  private deadLetterStream;
+  private maxLen;
+  private logger;
+  private handlers;
+  private running;
+  private pollPromise;
+  private groupCreated;
+  constructor(redis: RedisStreamLike, options?: RedisStreamTransportOptions);
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  close(): Promise<void>;
+  private ensureGroup;
+  private pollLoop;
+  private readNewMessages;
+  private claimPending;
+  private processEntry;
+  private getMatchingHandlers;
+  private matchesPattern;
+  private moveToDlq;
+  private sleep;
+}
+//#endregion
+export { RedisStreamTransport as n, RedisStreamTransportOptions as r, RedisStreamLike as t };

package/dist/registry/index.d.mts

@@ -0,0 +1,11 @@
+import "../elevation-DGo5shaX.mjs";
+import { C as RegisterOptions, w as ResourceRegistry } from "../interface-e9XfSsUV.mjs";
+import "../types-RLkFVgaw.mjs";
+import { IntrospectionPluginOptions } from "../types/index.mjs";
+import { FastifyPluginAsync } from "fastify";
+
+//#region src/registry/introspectionPlugin.d.ts
+declare const introspectionPlugin: FastifyPluginAsync<IntrospectionPluginOptions>;
+declare const _default: FastifyPluginAsync<IntrospectionPluginOptions>;
+//#endregion
+export { type IntrospectionPluginOptions, type RegisterOptions, ResourceRegistry, _default as introspectionPlugin, introspectionPlugin as introspectionPluginFn };

package/dist/registry/index.mjs

@@ -0,0 +1,4 @@
+import { t as ResourceRegistry } from "../ResourceRegistry-7Ic20ZMw.mjs";
+import { n as introspectionPlugin_default, t as introspectionPlugin } from "../introspectionPlugin-B3JkrjwU.mjs";
+
+export { ResourceRegistry, introspectionPlugin_default as introspectionPlugin, introspectionPlugin as introspectionPluginFn };

package/dist/requestContext-xi6OKBL-.mjs

@@ -0,0 +1,55 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/context/requestContext.ts
+/**
+* Request Context via AsyncLocalStorage
+*
+* Provides request-scoped context accessible anywhere in the call stack
+* without threading parameters through every function call.
+*
+* Uses Node.js native AsyncLocalStorage — zero-cost per request, no allocation
+* beyond the store object, and fully supported since Node 16.
+*
+* @example
+* ```typescript
+* import { requestContext } from '@classytic/arc';
+*
+* // Anywhere in the call stack — no parameter passing needed
+* async function auditAction(action: string) {
+*   const ctx = requestContext.get();
+*   await auditLog.write({
+*     action,
+*     userId: ctx?.user?.id,
+*     orgId: ctx?.organizationId,
+*     requestId: ctx?.requestId,
+*   });
+* }
+*
+* // Type-safe access to specific fields
+* const userId = requestContext.get()?.user?.id;
+* const orgId = requestContext.get()?.organizationId;
+* ```
+*/
+const storage = new AsyncLocalStorage();
+/**
+* Request context API.
+*
+* - `get()` — returns current store or undefined if outside request scope
+* - `run(store, fn)` — run a function with a specific store (used by Arc internals)
+* - `getStore()` — alias for get() (matches Node.js API naming)
+*/
+const requestContext = {
+	get() {
+		return storage.getStore();
+	},
+	getStore() {
+		return storage.getStore();
+	},
+	run(store, fn) {
+		return storage.run(store, fn);
+	},
+	storage
+};
+
+//#endregion
+export { requestContext as t };

package/dist/schemaConverter-Dtg0Kt9T.mjs

@@ -0,0 +1,98 @@
+//#region src/utils/schemaConverter.ts
+let _toJSONSchema = null;
+import("zod").then(({ z }) => {
+	if (typeof z?.toJSONSchema === "function") _toJSONSchema = (schema, opts) => z.toJSONSchema(schema, opts);
+}).catch(() => {});
+/**
+* Check if an object is already a plain JSON Schema.
+* Returns true if it has JSON Schema markers (`type`, `properties`, `$ref`,
+* `allOf`, `anyOf`, `oneOf`, `items`, `enum`) and does NOT have Zod markers.
+*/
+function isJsonSchema(input) {
+	if (input === null || typeof input !== "object") return false;
+	const obj = input;
+	if ("_def" in obj || "_zod" in obj) return false;
+	return "type" in obj || "properties" in obj || "$ref" in obj || "allOf" in obj || "anyOf" in obj || "oneOf" in obj || "items" in obj || "enum" in obj;
+}
+/**
+* Check if an object is a Zod schema (has `_zod` marker from Zod v4).
+*/
+function isZodSchema(input) {
+	return input !== null && typeof input === "object" && "_zod" in input;
+}
+/**
+* Convert any schema input to JSON Schema.
+*
+* Detection order:
+* 1. `null`/`undefined` → `undefined`
+* 2. Already JSON Schema → pass through as-is (zero overhead)
+* 3. Zod v4 schema → `z.toJSONSchema(schema, { target: 'openapi-3.0' })`
+* 4. Unrecognized object → return as-is (treat as opaque schema)
+*/
+function toJsonSchema(input) {
+	if (input == null) return void 0;
+	if (typeof input !== "object") return void 0;
+	if (isJsonSchema(input)) return input;
+	if (isZodSchema(input)) {
+		if (!_toJSONSchema) {
+			console.warn("[Arc] Zod schema detected but zod is not installed. Install zod v4: npm install zod");
+			return input;
+		}
+		try {
+			return _toJSONSchema(input, { target: "openapi-3.0" });
+		} catch {
+			return { type: "object" };
+		}
+	}
+	return input;
+}
+/**
+* Convert all schema fields in an OpenApiSchemas object.
+* JSON Schema values pass through unchanged. Only Zod schemas are converted.
+*/
+function convertOpenApiSchemas(schemas) {
+	const result = {};
+	const schemaFields = [
+		"entity",
+		"createBody",
+		"updateBody",
+		"params",
+		"listQuery",
+		"response"
+	];
+	for (const field of schemaFields) {
+		const value = schemas[field];
+		if (value !== void 0) result[field] = toJsonSchema(value) ?? value;
+	}
+	for (const [key, value] of Object.entries(schemas)) if (!schemaFields.includes(key)) result[key] = value;
+	return result;
+}
+/**
+* Convert schema values in a Fastify route schema record.
+*
+* Handles `body`, `querystring`, `params`, `headers` (top-level conversion)
+* and `response` (iterates by status code — each value converted individually).
+*
+* JSON Schema values pass through unchanged. Only Zod schemas are converted.
+*
+* Used for both additionalRoutes and customSchemas (CRUD overrides).
+*/
+function convertRouteSchema(schema) {
+	const result = { ...schema };
+	for (const field of [
+		"body",
+		"querystring",
+		"params",
+		"headers"
+	]) if (result[field] !== void 0) result[field] = toJsonSchema(result[field]) ?? result[field];
+	if (result.response !== void 0 && typeof result.response === "object" && result.response !== null) {
+		const responseObj = result.response;
+		const convertedResponse = {};
+		for (const [statusCode, responseSchema] of Object.entries(responseObj)) convertedResponse[statusCode] = toJsonSchema(responseSchema) ?? responseSchema;
+		result.response = convertedResponse;
+	}
+	return result;
+}
+
+//#endregion
+export { toJsonSchema as a, isZodSchema as i, convertRouteSchema as n, isJsonSchema as r, convertOpenApiSchemas as t };

package/dist/schemas/index.d.mts

@@ -0,0 +1,63 @@
+import * as _sinclair_typebox0 from "@sinclair/typebox";
+import { Static, TObject, TSchema, TSchema as TSchema$1, Type } from "@sinclair/typebox";
+import { FastifyPluginAsyncTypebox, FastifyPluginCallbackTypebox, TypeBoxTypeProvider, TypeBoxValidatorCompiler } from "@fastify/type-provider-typebox";
+
+//#region src/schemas/index.d.ts
+/**
+ * Paginated list response — matches Arc's runtime format:
+ * `{ success, docs: [...], page, limit, total, pages, hasNext, hasPrev }`
+ */
+declare function ArcListResponse<T extends TSchema$1>(itemSchema: T): _sinclair_typebox0.TObject<{
+  success: _sinclair_typebox0.TBoolean;
+  docs: _sinclair_typebox0.TArray<T>;
+  page: _sinclair_typebox0.TInteger;
+  limit: _sinclair_typebox0.TInteger;
+  total: _sinclair_typebox0.TInteger;
+  pages: _sinclair_typebox0.TInteger;
+  hasNext: _sinclair_typebox0.TBoolean;
+  hasPrev: _sinclair_typebox0.TBoolean;
+}>;
+/**
+ * Single item response — `{ success, data: {...} }`
+ */
+declare function ArcItemResponse<T extends TSchema$1>(itemSchema: T): _sinclair_typebox0.TObject<{
+  success: _sinclair_typebox0.TBoolean;
+  data: T;
+}>;
+/**
+ * Mutation (create/update) response — `{ success, data: {...}, message? }`
+ */
+declare function ArcMutationResponse<T extends TSchema$1>(itemSchema: T): _sinclair_typebox0.TObject<{
+  success: _sinclair_typebox0.TBoolean;
+  data: T;
+  message: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+}>;
+/**
+ * Delete response — `{ success, message }`
+ */
+declare function ArcDeleteResponse(): _sinclair_typebox0.TObject<{
+  success: _sinclair_typebox0.TBoolean;
+  message: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+}>;
+/**
+ * Error response schema
+ */
+declare function ArcErrorResponse(): _sinclair_typebox0.TObject<{
+  success: _sinclair_typebox0.TLiteral<false>;
+  error: _sinclair_typebox0.TString;
+  code: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  message: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+}>;
+/**
+ * Standard pagination + sorting + filtering query parameters.
+ * Matches Arc's list endpoint conventions.
+ */
+declare function ArcPaginationQuery(): _sinclair_typebox0.TObject<{
+  page: _sinclair_typebox0.TOptional<_sinclair_typebox0.TInteger>;
+  limit: _sinclair_typebox0.TOptional<_sinclair_typebox0.TInteger>;
+  sort: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  select: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  populate: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+}>;
+//#endregion
+export { ArcDeleteResponse, ArcErrorResponse, ArcItemResponse, ArcListResponse, ArcMutationResponse, ArcPaginationQuery, type FastifyPluginAsyncTypebox, type FastifyPluginCallbackTypebox, type Static, type TObject, type TSchema, Type, type TypeBoxTypeProvider, TypeBoxValidatorCompiler };

package/dist/schemas/index.mjs

@@ -0,0 +1,82 @@
+import { Type, Type as Type$1 } from "@sinclair/typebox";
+import { TypeBoxValidatorCompiler } from "@fastify/type-provider-typebox";
+
+//#region src/schemas/index.ts
+/**
+* Paginated list response — matches Arc's runtime format:
+* `{ success, docs: [...], page, limit, total, pages, hasNext, hasPrev }`
+*/
+function ArcListResponse(itemSchema) {
+	return Type$1.Object({
+		success: Type$1.Boolean(),
+		docs: Type$1.Array(itemSchema),
+		page: Type$1.Integer(),
+		limit: Type$1.Integer(),
+		total: Type$1.Integer(),
+		pages: Type$1.Integer(),
+		hasNext: Type$1.Boolean(),
+		hasPrev: Type$1.Boolean()
+	});
+}
+/**
+* Single item response — `{ success, data: {...} }`
+*/
+function ArcItemResponse(itemSchema) {
+	return Type$1.Object({
+		success: Type$1.Boolean(),
+		data: itemSchema
+	});
+}
+/**
+* Mutation (create/update) response — `{ success, data: {...}, message? }`
+*/
+function ArcMutationResponse(itemSchema) {
+	return Type$1.Object({
+		success: Type$1.Boolean(),
+		data: itemSchema,
+		message: Type$1.Optional(Type$1.String())
+	});
+}
+/**
+* Delete response — `{ success, message }`
+*/
+function ArcDeleteResponse() {
+	return Type$1.Object({
+		success: Type$1.Boolean(),
+		message: Type$1.Optional(Type$1.String())
+	});
+}
+/**
+* Error response schema
+*/
+function ArcErrorResponse() {
+	return Type$1.Object({
+		success: Type$1.Literal(false),
+		error: Type$1.String(),
+		code: Type$1.Optional(Type$1.String()),
+		message: Type$1.Optional(Type$1.String())
+	});
+}
+/**
+* Standard pagination + sorting + filtering query parameters.
+* Matches Arc's list endpoint conventions.
+*/
+function ArcPaginationQuery() {
+	return Type$1.Object({
+		page: Type$1.Optional(Type$1.Integer({
+			minimum: 1,
+			default: 1
+		})),
+		limit: Type$1.Optional(Type$1.Integer({
+			minimum: 1,
+			maximum: 100,
+			default: 20
+		})),
+		sort: Type$1.Optional(Type$1.String()),
+		select: Type$1.Optional(Type$1.String()),
+		populate: Type$1.Optional(Type$1.String())
+	});
+}
+
+//#endregion
+export { ArcDeleteResponse, ArcErrorResponse, ArcItemResponse, ArcListResponse, ArcMutationResponse, ArcPaginationQuery, Type, TypeBoxValidatorCompiler };