silgi 0.0.14 → 0.1.0-beta.10

package/dist/compile.d.mts

@@ -0,0 +1,46 @@
+import { ProcedureDef } from "./types.mjs";
+
+//#region src/compile.d.ts
+/**
+ * Compiled pipeline — called per request.
+ * May return sync value OR Promise — caller uses instanceof check.
+ */
+type CompiledHandler = (ctx: Record<string, unknown>, rawInput: unknown, signal: AbortSignal) => unknown | Promise<unknown>;
+/**
+ * Compile a procedure into the fastest possible handler.
+ *
+ * Optimizations applied:
+ * - Guard count specialization (unrolled for 0-4)
+ * - Separate fast path for no-wrap case (zero closures per request)
+ * - Pre-computed fail function (singleton per procedure)
+ * - Sync fast path when all guards are sync
+ */
+declare function compileProcedure(procedure: ProcedureDef): CompiledHandler;
+interface CompiledRoute {
+  handler: CompiledHandler;
+  /** Pre-computed Cache-Control header value, or undefined if no caching */
+  cacheControl?: string;
+  /** Procedure is accessible over WebSocket */
+  ws?: boolean;
+  /** Skip body parsing — procedure receives raw request (e.g. catch-all proxy) */
+  passthrough?: boolean;
+  /** HTTP method this route is registered for (uppercase) */
+  method: string;
+}
+/** Match result from the router */
+interface MatchedRoute<T = unknown> {
+  data: T;
+  params?: Record<string, string>;
+}
+/** Compiled router function — returns matched route + params */
+type CompiledRouterFn = (method: string, path: string) => MatchedRoute<CompiledRoute> | undefined;
+/**
+ * Compile a router tree into a rou3 radix router.
+ *
+ * Powered by rou3 (unjs) — battle-tested, fast, minimal.
+ */
+declare function compileRouter(def: Record<string, unknown>): CompiledRouterFn;
+/** Acquire a context object from the pool (or create one). */
+declare function createContext(): Record<string, unknown>;
+//#endregion
+export { compileProcedure, compileRouter, createContext };

package/dist/compile.mjs

@@ -0,0 +1,332 @@
+import { validateSchema } from "./core/schema.mjs";
+import { SilgiError } from "./core/error.mjs";
+import { isProcedureDef } from "./core/router-utils.mjs";
+import { addRoute, createRouter, findRoute } from "rou3";
+//#region src/compile.ts
+/**
+* Pipeline Compiler — guard unrolling, context pooling, rou3 routing.
+*
+* 1. UNROLLED GUARDS — 0-4 guard specialization (no loop, V8 inlines)
+* 2. ZERO-ALLOC CONTEXT — Object.create(null) + pool reuse
+* 3. ROU3 ROUTER — unjs radix tree (same as h3/nitro)
+*/
+/** Internal symbol for pipeline raw input — prevents collision with user context keys */
+const RAW_INPUT = Symbol.for("silgi.rawInput");
+function isThenable(value) {
+	return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function createFail(errors) {
+	return (code, data) => {
+		const def = errors[code];
+		throw new SilgiError(code, {
+			status: typeof def === "number" ? def : def?.status ?? 500,
+			message: typeof def === "object" && def !== null && "message" in def ? def.message : void 0,
+			data,
+			defined: true
+		});
+	};
+}
+function noopFail(code, data) {
+	throw new SilgiError(code, {
+		data,
+		defined: false
+	});
+}
+const UNSAFE_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Pre-frozen empty params — avoids per-request {} allocation */
+const EMPTY_PARAMS = /* @__PURE__ */ Object.freeze(Object.create(null));
+/** Sanitize a value to prevent prototype pollution from nested __proto__ keys */
+function sanitizeValue(value) {
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) value[i] = sanitizeValue(value[i]);
+		return value;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return value;
+	const obj = value;
+	if (Object.prototype.hasOwnProperty.call(obj, "__proto__")) {
+		const clean = Object.create(null);
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const k = keys[i];
+			if (!UNSAFE_KEYS.has(k)) clean[k] = sanitizeValue(obj[k]);
+		}
+		return clean;
+	}
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const k = keys[i];
+		obj[k] = sanitizeValue(obj[k]);
+	}
+	return value;
+}
+/** Apply a single guard result to context — direct property set */
+function applyGuardResult(ctx, result) {
+	if (result === null || result === void 0 || typeof result !== "object") return;
+	const keys = Object.keys(result);
+	for (let i = 0; i < keys.length; i++) {
+		const k = keys[i];
+		if (UNSAFE_KEYS.has(k)) continue;
+		ctx[k] = sanitizeValue(result[k]);
+	}
+}
+/** Apply a single guard (sync fast-path, async fallback) */
+async function applyGuard(ctx, guard) {
+	const result = guard.fn(ctx);
+	applyGuardResult(ctx, isThenable(result) ? await result : result);
+}
+function runGuards0() {}
+function runGuards1(ctx, g0) {
+	const r0 = g0.fn(ctx);
+	if (isThenable(r0)) return r0.then((v) => applyGuardResult(ctx, v));
+	applyGuardResult(ctx, r0);
+}
+function runGuards2(ctx, g0, g1) {
+	const r0 = g0.fn(ctx);
+	if (isThenable(r0)) return r0.then((v) => {
+		applyGuardResult(ctx, v);
+		return applyGuard(ctx, g1);
+	});
+	applyGuardResult(ctx, r0);
+	const r1 = g1.fn(ctx);
+	if (isThenable(r1)) return r1.then((v) => applyGuardResult(ctx, v));
+	applyGuardResult(ctx, r1);
+}
+function runGuards3(ctx, g0, g1, g2) {
+	const r0 = g0.fn(ctx);
+	if (isThenable(r0)) return r0.then(async (v) => {
+		applyGuardResult(ctx, v);
+		await applyGuard(ctx, g1);
+		await applyGuard(ctx, g2);
+	});
+	applyGuardResult(ctx, r0);
+	const r1 = g1.fn(ctx);
+	if (isThenable(r1)) return r1.then(async (v) => {
+		applyGuardResult(ctx, v);
+		await applyGuard(ctx, g2);
+	});
+	applyGuardResult(ctx, r1);
+	const r2 = g2.fn(ctx);
+	if (isThenable(r2)) return r2.then((v) => applyGuardResult(ctx, v));
+	applyGuardResult(ctx, r2);
+}
+function runGuards4(ctx, g0, g1, g2, g3) {
+	const r0 = g0.fn(ctx);
+	if (isThenable(r0)) return r0.then(async (v) => {
+		applyGuardResult(ctx, v);
+		await applyGuard(ctx, g1);
+		await applyGuard(ctx, g2);
+		await applyGuard(ctx, g3);
+	});
+	applyGuardResult(ctx, r0);
+	const r1 = g1.fn(ctx);
+	if (isThenable(r1)) return r1.then(async (v) => {
+		applyGuardResult(ctx, v);
+		await applyGuard(ctx, g2);
+		await applyGuard(ctx, g3);
+	});
+	applyGuardResult(ctx, r1);
+	const r2 = g2.fn(ctx);
+	if (isThenable(r2)) return r2.then(async (v) => {
+		applyGuardResult(ctx, v);
+		await applyGuard(ctx, g3);
+	});
+	applyGuardResult(ctx, r2);
+	const r3 = g3.fn(ctx);
+	if (isThenable(r3)) return r3.then((v) => applyGuardResult(ctx, v));
+	applyGuardResult(ctx, r3);
+}
+/** Fallback for 5+ guards — loop */
+async function runGuardsN(ctx, guards) {
+	for (const guard of guards) {
+		const result = guard.fn(ctx);
+		applyGuardResult(ctx, isThenable(result) ? await result : result);
+	}
+}
+/**
+* Select the optimal guard runner based on count.
+* Returns a function that applies all guards to a context.
+*/
+function selectGuardRunner(guards) {
+	switch (guards.length) {
+		case 0: return runGuards0;
+		case 1: {
+			const g0 = guards[0];
+			return (ctx) => runGuards1(ctx, g0);
+		}
+		case 2: {
+			const [g0, g1] = guards;
+			return (ctx) => runGuards2(ctx, g0, g1);
+		}
+		case 3: {
+			const [g0, g1, g2] = guards;
+			return (ctx) => runGuards3(ctx, g0, g1, g2);
+		}
+		case 4: {
+			const [g0, g1, g2, g3] = guards;
+			return (ctx) => runGuards4(ctx, g0, g1, g2, g3);
+		}
+		default: return (ctx) => runGuardsN(ctx, guards);
+	}
+}
+/** Call resolve, then validate output (sync-first, async fallback) */
+function _resolveWithOutput(resolveFn, input, ctx, failFn, signal, outputSchema) {
+	const output = resolveFn({
+		input,
+		ctx,
+		fail: failFn,
+		signal,
+		params: ctx.params ?? EMPTY_PARAMS
+	});
+	if (!outputSchema) return output;
+	if (isThenable(output)) return output.then((o) => validateSchema(outputSchema, o));
+	return validateSchema(outputSchema, output);
+}
+/** Validate input, resolve, validate output — sync-first with rejected Promise fallback.
+*  All sync throws (validation errors, fail() calls, resolver errors) are converted
+*  to rejected Promises for consistent error handling in .then().catch() chains. */
+function _validateAndResolve(inputSchema, outputSchema, resolveFn, rawInput, ctx, failFn, signal) {
+	try {
+		const input = inputSchema ? validateSchema(inputSchema, rawInput ?? {}) : rawInput;
+		if (isThenable(input)) return input.then((resolvedInput) => _resolveWithOutput(resolveFn, resolvedInput, ctx, failFn, signal, outputSchema));
+		return _resolveWithOutput(resolveFn, input, ctx, failFn, signal, outputSchema);
+	} catch (e) {
+		return Promise.reject(e);
+	}
+}
+/**
+* Compile a procedure into the fastest possible handler.
+*
+* Optimizations applied:
+* - Guard count specialization (unrolled for 0-4)
+* - Separate fast path for no-wrap case (zero closures per request)
+* - Pre-computed fail function (singleton per procedure)
+* - Sync fast path when all guards are sync
+*/
+function compileProcedure(procedure) {
+	const middlewares = procedure.use ?? [];
+	const guards = [];
+	const wraps = [];
+	for (const mw of middlewares) if (mw.kind === "guard") guards.push(mw);
+	else wraps.push(mw);
+	const inputSchema = procedure.input;
+	const outputSchema = procedure.output;
+	const resolveFn = procedure.resolve;
+	let mergedErrors = procedure.errors;
+	for (const guard of guards) if (guard.errors) mergedErrors = mergedErrors ? {
+		...mergedErrors,
+		...guard.errors
+	} : guard.errors;
+	const failFn = mergedErrors ? createFail(mergedErrors) : noopFail;
+	const runGuards = selectGuardRunner(guards);
+	if (wraps.length === 0 && !inputSchema && !outputSchema) return (ctx, rawInput, signal) => {
+		try {
+			const guardResult = runGuards(ctx);
+			if (guardResult && isThenable(guardResult)) return guardResult.then(() => resolveFn({
+				input: rawInput,
+				ctx,
+				fail: failFn,
+				signal,
+				params: ctx.params ?? EMPTY_PARAMS
+			}));
+			return resolveFn({
+				input: rawInput,
+				ctx,
+				fail: failFn,
+				signal,
+				params: ctx.params ?? EMPTY_PARAMS
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	};
+	if (wraps.length === 0) return (ctx, rawInput, signal) => {
+		try {
+			const guardResult = runGuards(ctx);
+			if (guardResult && isThenable(guardResult)) return guardResult.then(() => _validateAndResolve(inputSchema, outputSchema, resolveFn, rawInput, ctx, failFn, signal));
+			return _validateAndResolve(inputSchema, outputSchema, resolveFn, rawInput, ctx, failFn, signal);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	};
+	return async (ctx, rawInput, signal) => {
+		const guardResult = runGuards(ctx);
+		if (guardResult && isThenable(guardResult)) await guardResult;
+		let input;
+		if (inputSchema) {
+			const validated = validateSchema(inputSchema, rawInput ?? {});
+			input = isThenable(validated) ? await validated : validated;
+		} else input = rawInput;
+		ctx[RAW_INPUT] = input;
+		let execute = () => {
+			const resolvedInput = ctx[RAW_INPUT] ?? input;
+			return Promise.resolve(resolveFn({
+				input: resolvedInput,
+				ctx,
+				fail: failFn,
+				signal,
+				params: ctx.params ?? EMPTY_PARAMS
+			}));
+		};
+		for (let i = wraps.length - 1; i >= 0; i--) {
+			const wrapFn = wraps[i].fn;
+			const next = execute;
+			execute = () => wrapFn(ctx, next);
+		}
+		const output = await execute();
+		if (!outputSchema) return output;
+		const validated = validateSchema(outputSchema, output);
+		return isThenable(validated) ? await validated : validated;
+	};
+}
+/**
+* Compile a router tree into a rou3 radix router.
+*
+* Powered by rou3 (unjs) — battle-tested, fast, minimal.
+*/
+function compileRouter(def) {
+	const router = createRouter();
+	function walk(node, path) {
+		if (isProcedureDef(node)) {
+			const proc = node;
+			const route = proc.route;
+			const routePath = route?.path || "/" + path.join("/");
+			const method = route?.method?.toUpperCase() || "POST";
+			let cacheControl;
+			if (route?.cache != null) cacheControl = typeof route.cache === "number" ? `public, max-age=${route.cache}` : route.cache;
+			const compiled = {
+				handler: compileProcedure(proc),
+				cacheControl,
+				ws: route?.ws ?? void 0,
+				passthrough: routePath.includes("**") || void 0,
+				method
+			};
+			addRoute(router, method, routePath, compiled);
+			addRoute(router, "", routePath, compiled);
+			return;
+		}
+		if (typeof node === "object" && node !== null) for (const [k, v] of Object.entries(node)) walk(v, [...path, k]);
+	}
+	walk(def, []);
+	return (method, path) => findRoute(router, method, path);
+}
+/** Pool of pre-allocated null-prototype context objects — eliminates per-request GC pressure. */
+const CTX_POOL = [];
+const CTX_POOL_MAX = 128;
+/** Acquire a context object from the pool (or create one). */
+function createContext() {
+	return CTX_POOL.length > 0 ? CTX_POOL.pop() : Object.create(null);
+}
+/** Return a context object to the pool after request completes. */
+function releaseContext(ctx) {
+	for (const key of Object.keys(ctx)) delete ctx[key];
+	for (const sym of Object.getOwnPropertySymbols(ctx)) delete ctx[sym];
+	if (CTX_POOL.length < CTX_POOL_MAX) CTX_POOL.push(ctx);
+}
+//#endregion
+export { RAW_INPUT, compileProcedure, compileRouter, createContext, releaseContext };

package/dist/contract.d.mts

@@ -0,0 +1,36 @@
+import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
+import { ErrorDef, ProcedureType, Route, RouterDef } from "./types.mjs";
+
+//#region src/contract.d.ts
+interface ProcedureContract<TType extends ProcedureType = ProcedureType, TInput extends AnySchema | undefined = AnySchema | undefined, TOutput extends AnySchema | undefined = AnySchema | undefined, TErrors extends ErrorDef = ErrorDef> {
+  type?: TType;
+  input?: TInput;
+  output?: TOutput;
+  errors?: TErrors;
+  route?: Route;
+  description?: string;
+}
+type ContractRouter = {
+  [key: string]: ProcedureContract<any, any, any, any> | ContractRouter;
+};
+/**
+ * Define an API contract — shared between client and server.
+ * Pure type information, no runtime behavior.
+ */
+declare function contract<T extends ContractRouter>(definition: T): T;
+type ImplementProcedure<T extends ProcedureContract> = T extends ProcedureContract<infer _TType, infer TInput, infer TOutput, infer TErrors> ? (opts: {
+  input: TInput extends AnySchema ? InferSchemaOutput<TInput> : undefined;
+  ctx: Record<string, unknown>;
+  fail: TErrors extends ErrorDef ? <K extends keyof TErrors & string>(code: K, ...args: any[]) => never : never;
+  signal: AbortSignal;
+}) => TOutput extends AnySchema ? InferSchemaOutput<TOutput> | Promise<InferSchemaOutput<TOutput>> : unknown : never;
+type ImplementRouter<T extends ContractRouter> = { [K in keyof T]: T[K] extends ProcedureContract ? ImplementProcedure<T[K]> : T[K] extends ContractRouter ? ImplementRouter<T[K]> : never };
+/**
+ * Implement a contract — returns a silgi RouterDef.
+ * Type-safe: implementation must match the contract.
+ */
+declare function implement<T extends ContractRouter>(contractDef: T, implementations: ImplementRouter<T>): RouterDef;
+/** Infer client type from a contract (no server code needed) */
+type InferContractClient<T extends ContractRouter> = { [K in keyof T]: T[K] extends ProcedureContract<any, infer TInput, infer TOutput> ? TInput extends AnySchema ? (input: InferSchemaInput<TInput>) => Promise<TOutput extends AnySchema ? InferSchemaOutput<TOutput> : unknown> : () => Promise<TOutput extends AnySchema ? InferSchemaOutput<TOutput> : unknown> : T[K] extends ContractRouter ? InferContractClient<T[K]> : never };
+//#endregion
+export { ContractRouter, InferContractClient, ProcedureContract, contract, implement };

package/dist/contract.mjs

@@ -0,0 +1,40 @@
+//#region src/contract.ts
+/**
+* Define an API contract — shared between client and server.
+* Pure type information, no runtime behavior.
+*/
+function contract(definition) {
+	return definition;
+}
+/**
+* Implement a contract — returns a silgi RouterDef.
+* Type-safe: implementation must match the contract.
+*/
+function implement(contractDef, implementations) {
+	return buildRouter(contractDef, implementations);
+}
+function buildRouter(contractDef, impls) {
+	const router = {};
+	for (const [key, contractEntry] of Object.entries(contractDef)) {
+		const impl = impls[key];
+		if (!impl) continue;
+		if (isProcedureContract(contractEntry)) router[key] = {
+			type: contractEntry.type ?? "query",
+			input: contractEntry.input ?? null,
+			output: contractEntry.output ?? null,
+			errors: contractEntry.errors ?? null,
+			use: null,
+			resolve: impl,
+			route: contractEntry.route ?? null,
+			meta: null
+		};
+		else router[key] = buildRouter(contractEntry, impl);
+	}
+	return router;
+}
+function isProcedureContract(v) {
+	if (typeof v !== "object" || v === null) return false;
+	return "input" in v || "output" in v || "type" in v || "errors" in v;
+}
+//#endregion
+export { contract, implement };

package/dist/core/codec.mjs

@@ -0,0 +1,67 @@
+import { ValidationError } from "./schema.mjs";
+import { SilgiError, toSilgiError } from "./error.mjs";
+import { stringifyJSON } from "./utils.mjs";
+//#region src/core/codec.ts
+/**
+* Response encoding — JSON, MessagePack, devalue.
+*
+* Lazy-loads binary codecs on first non-JSON request.
+*/
+let _msgpack;
+let _devalue;
+/** Detect response format from Accept header */
+function detectResponseFormat(request) {
+	const accept = request.headers.get("accept");
+	if (!accept) return "json";
+	if (accept.includes("msgpack")) return "msgpack";
+	if (accept.includes("x-devalue")) return "devalue";
+	return "json";
+}
+/** Encode data into a Response with the given format */
+async function encodeResponse(data, status, format, extraHeaders) {
+	switch (format) {
+		case "msgpack":
+			_msgpack ??= await import("../codec/msgpack.mjs");
+			return new Response(_msgpack.encode(data), {
+				status,
+				headers: {
+					"content-type": _msgpack.MSGPACK_CONTENT_TYPE,
+					...extraHeaders
+				}
+			});
+		case "devalue":
+			_devalue ??= await import("../codec/devalue.mjs");
+			return new Response(_devalue.encode(data), {
+				status,
+				headers: {
+					"content-type": _devalue.DEVALUE_CONTENT_TYPE,
+					...extraHeaders
+				}
+			});
+		default: return new Response(stringifyJSON(data), {
+			status,
+			headers: {
+				"content-type": "application/json",
+				...extraHeaders
+			}
+		});
+	}
+}
+/** Build error Response from any thrown error */
+function makeErrorResponse(error, format) {
+	if (error instanceof ValidationError) return encodeResponse({
+		code: "BAD_REQUEST",
+		status: 400,
+		message: error.message,
+		data: { issues: error.issues }
+	}, 400, format);
+	if (error instanceof SyntaxError) return encodeResponse({
+		code: "BAD_REQUEST",
+		status: 400,
+		message: "Invalid JSON body"
+	}, 400, format);
+	const e = error instanceof SilgiError ? error : toSilgiError(error);
+	return encodeResponse(e.toJSON(), e.status, format);
+}
+//#endregion
+export { detectResponseFormat, encodeResponse, makeErrorResponse };

package/dist/core/dispatch.mjs

@@ -0,0 +1,62 @@
+import { ValidationError } from "./schema.mjs";
+import { SilgiError, toSilgiError } from "./error.mjs";
+//#region src/core/dispatch.ts
+/**
+* Shared dispatch utilities for adapters.
+*
+* Centralizes: context building, method enforcement, input parsing, error serialization.
+* Every non-Fetch adapter (express, nestjs, bun, lambda, message-port) uses these
+* instead of reimplementing the same logic.
+*/
+/**
+* Copy properties from source into target context via direct property set.
+* V8 monomorphic access — no Object.assign, no spread.
+*/
+function applyContext(target, source) {
+	const keys = Object.keys(source);
+	for (let i = 0; i < keys.length; i++) target[keys[i]] = source[keys[i]];
+}
+/**
+* Build a null-prototype context object from a base context and route params.
+* Uses direct property assignment (no Object.assign) for V8 monomorphic access.
+*/
+function buildContext(baseCtx, params) {
+	const ctx = Object.create(null);
+	if (baseCtx) applyContext(ctx, baseCtx);
+	if (params) ctx.params = params;
+	return ctx;
+}
+/** Check if an HTTP method is allowed for a compiled route. */
+function isMethodAllowed(reqMethod, routeMethod) {
+	if (routeMethod === "*") return true;
+	if (reqMethod === routeMethod) return true;
+	if (reqMethod === "OPTIONS") return true;
+	if (reqMethod === "GET" && routeMethod === "POST") return true;
+	return false;
+}
+/** Convert any thrown error to a serializable error body + status. */
+function serializeError(error) {
+	if (error instanceof ValidationError) return {
+		code: "BAD_REQUEST",
+		status: 400,
+		message: error.message,
+		data: { issues: error.issues }
+	};
+	return (error instanceof SilgiError ? error : toSilgiError(error)).toJSON();
+}
+/** Max allowed size for GET ?data= parameter (bytes). Prevents JSON bomb via URL. */
+const MAX_QUERY_DATA_LENGTH = 8192;
+/**
+* Parse a JSON string from a query parameter.
+* Throws SilgiError(BAD_REQUEST) on invalid JSON or oversized input.
+*/
+function parseQueryData(dataValue) {
+	if (dataValue.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
+	try {
+		return JSON.parse(dataValue);
+	} catch {
+		throw new SilgiError("BAD_REQUEST", { message: "Invalid JSON in data parameter" });
+	}
+}
+//#endregion
+export { applyContext, buildContext, isMethodAllowed, parseQueryData, serializeError };

package/dist/core/error.d.mts

@@ -0,0 +1,104 @@
+//#region src/core/error.d.ts
+/**
+ * SilgiError — unified RPC error with cross-realm instanceof.
+ */
+declare const COMMON_ERRORS: Readonly<{
+  readonly BAD_REQUEST: {
+    readonly status: 400;
+    readonly message: "Bad Request";
+  };
+  readonly UNAUTHORIZED: {
+    readonly status: 401;
+    readonly message: "Unauthorized";
+  };
+  readonly FORBIDDEN: {
+    readonly status: 403;
+    readonly message: "Forbidden";
+  };
+  readonly NOT_FOUND: {
+    readonly status: 404;
+    readonly message: "Not Found";
+  };
+  readonly METHOD_NOT_ALLOWED: {
+    readonly status: 405;
+    readonly message: "Method Not Allowed";
+  };
+  readonly NOT_ACCEPTABLE: {
+    readonly status: 406;
+    readonly message: "Not Acceptable";
+  };
+  readonly CONFLICT: {
+    readonly status: 409;
+    readonly message: "Conflict";
+  };
+  readonly GONE: {
+    readonly status: 410;
+    readonly message: "Gone";
+  };
+  readonly UNPROCESSABLE_CONTENT: {
+    readonly status: 422;
+    readonly message: "Unprocessable Content";
+  };
+  readonly PRECONDITION_REQUIRED: {
+    readonly status: 428;
+    readonly message: "Precondition Required";
+  };
+  readonly TOO_MANY_REQUESTS: {
+    readonly status: 429;
+    readonly message: "Too Many Requests";
+  };
+  readonly CLIENT_CLOSED_REQUEST: {
+    readonly status: 499;
+    readonly message: "Client Closed Request";
+  };
+  readonly INTERNAL_SERVER_ERROR: {
+    readonly status: 500;
+    readonly message: "Internal Server Error";
+  };
+  readonly NOT_IMPLEMENTED: {
+    readonly status: 501;
+    readonly message: "Not Implemented";
+  };
+  readonly BAD_GATEWAY: {
+    readonly status: 502;
+    readonly message: "Bad Gateway";
+  };
+  readonly SERVICE_UNAVAILABLE: {
+    readonly status: 503;
+    readonly message: "Service Unavailable";
+  };
+  readonly GATEWAY_TIMEOUT: {
+    readonly status: 504;
+    readonly message: "Gateway Timeout";
+  };
+}>;
+type SilgiErrorCode = keyof typeof COMMON_ERRORS | (string & {});
+interface SilgiErrorOptions<TData = unknown> {
+  status?: number;
+  message?: string;
+  data?: TData;
+  cause?: unknown;
+  defined?: boolean;
+}
+interface SilgiErrorJSON<TCode extends string = string, TData = unknown> {
+  defined: boolean;
+  code: TCode;
+  status: number;
+  message: string;
+  data: TData;
+}
+declare class SilgiError<TCode extends string = string, TData = unknown> extends Error {
+  readonly code: TCode;
+  readonly status: number;
+  readonly data: TData;
+  readonly defined: boolean;
+  constructor(code: TCode, options?: SilgiErrorOptions<TData>);
+  toJSON(): SilgiErrorJSON<TCode, TData>;
+  static [Symbol.hasInstance](instance: unknown): boolean;
+}
+declare function isDefinedError<TError>(error: TError): error is TError & SilgiError & {
+  defined: true;
+};
+declare function toSilgiError(error: unknown): SilgiError;
+//#endregion
+export { SilgiError, SilgiErrorCode, SilgiErrorJSON, SilgiErrorOptions, isDefinedError, toSilgiError };