silgi 0.43.29 → 0.50.0

package/dist/core/error.mjs

@@ -1,106 +1,139 @@
-import { hasProp } from "./utils/internal/object.mjs";
-import { sanitizeStatusCode, sanitizeStatusMessage } from "./utils/sanitize.mjs";
-import consola from "consola";
-import { isDevelopment } from "std-env";
-
 //#region src/core/error.ts
 /**
-* Silgi Runtime Error
-* @class
-* @extends Error
-* @property {number} statusCode - An integer indicating the HTTP response status code.
-* @property {string} statusMessage - A string representing the HTTP status message.
-* @property {boolean} fatal - Indicates if the error is a fatal error.
-* @property {boolean} unhandled - Indicates if the error was unhandled and auto-captured.
-* @property {DataT} data - An extra data that will be included in the response.
-*                         This can be used to pass additional information about the error.
+* SilgiError — unified RPC error with cross-realm instanceof.
 */
+const COMMON_ERRORS = /* @__PURE__ */ Object.freeze({
+	BAD_REQUEST: {
+		status: 400,
+		message: "Bad Request"
+	},
+	UNAUTHORIZED: {
+		status: 401,
+		message: "Unauthorized"
+	},
+	FORBIDDEN: {
+		status: 403,
+		message: "Forbidden"
+	},
+	NOT_FOUND: {
+		status: 404,
+		message: "Not Found"
+	},
+	METHOD_NOT_ALLOWED: {
+		status: 405,
+		message: "Method Not Allowed"
+	},
+	NOT_ACCEPTABLE: {
+		status: 406,
+		message: "Not Acceptable"
+	},
+	CONFLICT: {
+		status: 409,
+		message: "Conflict"
+	},
+	GONE: {
+		status: 410,
+		message: "Gone"
+	},
+	UNPROCESSABLE_CONTENT: {
+		status: 422,
+		message: "Unprocessable Content"
+	},
+	PRECONDITION_REQUIRED: {
+		status: 428,
+		message: "Precondition Required"
+	},
+	TOO_MANY_REQUESTS: {
+		status: 429,
+		message: "Too Many Requests"
+	},
+	CLIENT_CLOSED_REQUEST: {
+		status: 499,
+		message: "Client Closed Request"
+	},
+	INTERNAL_SERVER_ERROR: {
+		status: 500,
+		message: "Internal Server Error"
+	},
+	NOT_IMPLEMENTED: {
+		status: 501,
+		message: "Not Implemented"
+	},
+	BAD_GATEWAY: {
+		status: 502,
+		message: "Bad Gateway"
+	},
+	SERVICE_UNAVAILABLE: {
+		status: 503,
+		message: "Service Unavailable"
+	},
+	GATEWAY_TIMEOUT: {
+		status: 504,
+		message: "Gateway Timeout"
+	}
+});
+const REGISTRY_KEY = Symbol.for("silgi.error.registry");
+const registry = globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new WeakSet();
 var SilgiError = class extends Error {
-	static __silgi_error__ = true;
-	statusCode = 500;
-	fatal = false;
-	unhandled = false;
-	statusMessage;
+	code;
+	status;
 	data;
-	cause;
-	constructor(message, opts = {}) {
-		super(message, opts);
-		if (opts.cause && !this.cause) this.cause = opts.cause;
-		if (isDevelopment && opts.cause && opts.cause instanceof Error && opts.cause.stack && this.stack) {
-			this.stack += `\nCaused by: ${opts.cause.stack}`;
-			consola.warn(opts.cause);
-		}
+	defined;
+	constructor(code, options = {}) {
+		const defaults = COMMON_ERRORS[code];
+		const message = options.message ?? defaults?.message ?? code;
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.code = code;
+		this.status = options.status ?? defaults?.status ?? 500;
+		this.data = options.data;
+		this.defined = options.defined ?? false;
+		this.name = "SilgiError";
 	}
 	toJSON() {
-		const obj = {
+		return {
+			defined: this.defined,
+			code: this.code,
+			status: this.status,
 			message: this.message,
-			statusCode: sanitizeStatusCode(this.statusCode, 500)
+			data: this.data
 		};
-		if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
-		if (this.data !== void 0) obj.data = this.data;
-		return obj;
 	}
-};
-/**
-* Creates a new `Error` that can be used to handle both internal and runtime errors.
-*
-* @param input {string | (Partial<SilgiError> & { status?: number; statusText?: string })} - The error message or an object containing error properties.
-* If a string is provided, it will be used as the error `message`.
-*
-* @example
-* // String error where `statusCode` defaults to `500`
-* throw createError("An error occurred");
-* // Object error
-* throw createError({
-*   statusCode: 400,
-*   statusMessage: "Bad Request",
-*   message: "Invalid input",
-*   data: { field: "email" }
-* });
-*
-*
-* @return {SilgiError} - An instance of SilgiError.
-*
-* @remarks
-* - Typically, `message` contains a brief, human-readable description of the error, while `statusMessage` is specific to HTTP responses and describes
-* the status text related to the response status code.
-* - In a client-server context, using a short `statusMessage` is recommended because it can be accessed on the client side. Otherwise, a `message`
-* passed to `createError` on the server will not propagate to the client.
-* - Consider avoiding putting dynamic user input in the `message` to prevent potential security issues.
-*/
-function createError(input) {
-	if (typeof input === "string") return new SilgiError(input);
-	const cause = input.cause;
-	const err = new SilgiError(input.message ?? input.statusMessage ?? "", { cause: cause || input });
-	if (hasProp(input, "stack")) try {
-		Object.defineProperty(err, "stack", { get() {
-			return input.stack;
-		} });
-	} catch {
-		try {
-			err.stack = input.stack;
-		} catch {}
+	static {
+		registry.add(this);
+	}
+	static [Symbol.hasInstance](instance) {
+		if (typeof instance !== "object" || instance === null) return false;
+		let proto = Object.getPrototypeOf(instance);
+		while (proto) {
+			if (proto.constructor && registry.has(proto.constructor)) return true;
+			proto = Object.getPrototypeOf(proto);
+		}
+		return false;
 	}
-	if (input.data) err.data = input.data;
-	const statusCode = input.statusCode ?? input.status ?? cause?.statusCode ?? cause?.status;
-	if (typeof statusCode === "number") err.statusCode = sanitizeStatusCode(statusCode);
-	const statusMessage = input.statusMessage ?? input.statusText ?? cause?.statusMessage ?? cause?.statusText;
-	if (statusMessage) err.statusMessage = sanitizeStatusMessage(statusMessage);
-	const fatal = input.fatal ?? cause?.fatal;
-	if (fatal !== void 0) err.fatal = fatal;
-	const unhandled = input.unhandled ?? cause?.unhandled;
-	if (unhandled !== void 0) err.unhandled = unhandled;
-	return err;
+};
+function isDefinedError(error) {
+	return error instanceof SilgiError && error.defined === true;
 }
-/**
-* Checks if the given input is an instance of SilgiError.
-*
-* @param input {*} - The input to check.
-* @return {boolean} - Returns true if the input is an instance of SilgiError, false otherwise.
-*/
-function isError(input) {
-	return input?.constructor?.__silgi_error__ === true;
+function toSilgiError(error) {
+	if (error instanceof SilgiError) return error;
+	return new SilgiError("INTERNAL_SERVER_ERROR", {
+		message: "Internal server error",
+		cause: error
+	});
+}
+function isErrorStatus(status) {
+	return status >= 400;
+}
+function isSilgiErrorJSON(json) {
+	return typeof json === "object" && json !== null && "code" in json && "status" in json && typeof json.code === "string";
+}
+function fromSilgiErrorJSON(json) {
+	return new SilgiError(json.code, {
+		status: json.status,
+		message: json.message,
+		data: json.data,
+		defined: json.defined
+	});
 }
-
 //#endregion
-export { SilgiError, createError, isError };
+export { SilgiError, fromSilgiErrorJSON, isDefinedError, isErrorStatus, isSilgiErrorJSON, toSilgiError };

package/dist/core/handler.d.mts

@@ -0,0 +1,6 @@
+import { Hookable } from "hookable";
+
+//#region src/core/handler.d.ts
+type FetchHandler = (request: Request) => Response | Promise<Response>;
+//#endregion
+export { FetchHandler };

package/dist/core/handler.mjs

@@ -0,0 +1,153 @@
+import { routerCache } from "./router-utils.mjs";
+import { compileRouter, createContext, releaseContext } from "../compile.mjs";
+import { applyContext } from "./dispatch.mjs";
+import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
+import { runWithCtx } from "./context-bridge.mjs";
+import { parseInput } from "./input.mjs";
+import { iteratorToEventStream } from "./sse.mjs";
+import { analyticsTraceMap } from "./trace-map.mjs";
+import { parseUrlPath } from "./url.mjs";
+//#region src/core/handler.ts
+/**
+* Fetch API handler — single unified request handler.
+*
+* Orchestrates: routing → context → input parsing → pipeline → response encoding.
+* Each concern lives in its own module (codec.ts, input.ts, sse.ts).
+*
+* Analytics / Scalar are NOT here — they wrap the handler externally
+* (see wrapWithAnalytics / wrapWithScalar in their respective modules).
+*/
+/** Wrap a stream to release pooled context on completion or cancellation. */
+function wrapStreamWithRelease(source, ctx) {
+	let released = false;
+	const release = () => {
+		if (!released) {
+			released = true;
+			releaseContext(ctx);
+		}
+	};
+	const reader = source.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					release();
+					controller.close();
+				} else controller.enqueue(value);
+			} catch (err) {
+				release();
+				controller.error(err);
+			}
+		},
+		cancel() {
+			release();
+			reader.cancel();
+		}
+	});
+}
+function makeResponse(output, route, format, ctx) {
+	if (output instanceof Response) {
+		releaseContext(ctx);
+		return output;
+	}
+	if (output instanceof ReadableStream) return new Response(wrapStreamWithRelease(output, ctx), { headers: { "content-type": "application/octet-stream" } });
+	if (output && typeof output === "object" && Symbol.asyncIterator in output) {
+		const stream = iteratorToEventStream(output);
+		return new Response(wrapStreamWithRelease(stream, ctx), { headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache"
+		} });
+	}
+	releaseContext(ctx);
+	const cacheHeaders = route.cacheControl ? { "cache-control": route.cacheControl } : void 0;
+	if (format !== "json") return encodeResponse(output, 200, format, cacheHeaders);
+	return new Response(JSON.stringify(output), { headers: cacheHeaders ? {
+		"content-type": "application/json",
+		...cacheHeaders
+	} : { "content-type": "application/json" } });
+}
+function createFetchHandler(routerDef, contextFactory, hooks) {
+	let compiledRouter = routerCache.get(routerDef);
+	if (!compiledRouter) {
+		compiledRouter = compileRouter(routerDef);
+		routerCache.set(routerDef, compiledRouter);
+	}
+	const jsonHeaders = { "content-type": "application/json" };
+	const notFoundBody = JSON.stringify({
+		code: "NOT_FOUND",
+		status: 404,
+		message: "Procedure not found"
+	});
+	function callHook(name, event) {
+		if (!hooks) return;
+		try {
+			const result = hooks.callHook(name, event);
+			if (result instanceof Promise) result.catch(() => {});
+		} catch {}
+	}
+	return async function handleRequest(request) {
+		const url = request.url;
+		const fullPath = parseUrlPath(url);
+		const pathname = fullPath.length > 1 ? fullPath.slice(1) : "";
+		const qMark = url.indexOf("?", url.indexOf("/", url.indexOf("//") + 2));
+		const match = compiledRouter(request.method, fullPath);
+		if (!match) return new Response(notFoundBody, {
+			status: 404,
+			headers: jsonHeaders
+		});
+		const route = match.data;
+		const reqMethod = request.method;
+		if (route.method !== "*" && reqMethod !== route.method && reqMethod !== "OPTIONS") {
+			if (!(reqMethod === "GET" && route.method === "POST")) return new Response(JSON.stringify({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${reqMethod} not allowed`
+			}), {
+				status: 405,
+				headers: {
+					...jsonHeaders,
+					allow: route.method
+				}
+			});
+		}
+		const format = detectResponseFormat(request);
+		const ctx = createContext();
+		let rawInput;
+		try {
+			const baseCtxResult = contextFactory(request);
+			applyContext(ctx, baseCtxResult instanceof Promise ? await baseCtxResult : baseCtxResult);
+			if (match.params) ctx.params = match.params;
+			const reqTrace = analyticsTraceMap.get(request);
+			if (reqTrace) ctx.__analyticsTrace = reqTrace;
+			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
+			if (match.params && Object.keys(match.params).length > 0) rawInput = rawInput != null && typeof rawInput === "object" ? {
+				...match.params,
+				...rawInput
+			} : match.params;
+			callHook("request", {
+				path: pathname,
+				input: rawInput
+			});
+			const pipelineResult = runWithCtx(ctx, () => route.handler(ctx, rawInput, request.signal));
+			const output = pipelineResult instanceof Promise ? await pipelineResult : pipelineResult;
+			callHook("response", {
+				path: pathname,
+				output,
+				durationMs: 0
+			});
+			const response = makeResponse(output, route, format, ctx);
+			return response instanceof Promise ? await response : response;
+		} catch (error) {
+			releaseContext(ctx);
+			callHook("error", {
+				path: pathname,
+				error
+			});
+			const errorResponse = makeErrorResponse(error, format);
+			return errorResponse instanceof Promise ? await errorResponse : errorResponse;
+		}
+	};
+}
+//#endregion
+export { createFetchHandler };

package/dist/core/input.mjs

@@ -0,0 +1,49 @@
+import { SilgiError } from "./error.mjs";
+//#region src/core/input.ts
+/**
+* Request input parsing — JSON, MessagePack, devalue, query string.
+*/
+let _msgpack;
+let _devalue;
+const isBun = typeof globalThis.Bun !== "undefined";
+/** Max allowed size for GET ?data= parameter (bytes). Prevents JSON bomb via URL. */
+const MAX_QUERY_DATA_LENGTH = 8192;
+/** Parse request input from body or query string */
+async function parseInput(request, url, qMark) {
+	if (request.method === "GET" || !request.body) {
+		if (qMark !== -1) {
+			const searchStr = url.slice(qMark + 1);
+			const dataIdx = searchStr.indexOf("data=");
+			if (dataIdx !== -1) {
+				const valueStart = dataIdx + 5;
+				const valueEnd = searchStr.indexOf("&", valueStart);
+				const encoded = valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
+				if (encoded.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
+				return JSON.parse(decodeURIComponent(encoded));
+			}
+		}
+		return;
+	}
+	const ct = request.headers.get("content-type");
+	if (ct) {
+		if (ct.includes("msgpack")) {
+			_msgpack ??= await import("../codec/msgpack.mjs");
+			const buf = new Uint8Array(await request.arrayBuffer());
+			return buf.length > 0 ? _msgpack.decode(buf) : void 0;
+		}
+		if (ct.includes("x-devalue")) {
+			_devalue ??= await import("../codec/devalue.mjs");
+			const text = await request.text();
+			return text ? _devalue.decode(text) : void 0;
+		}
+	}
+	if (isBun) try {
+		return await request.json();
+	} catch {
+		return;
+	}
+	const text = await request.text();
+	return text ? JSON.parse(text) : void 0;
+}
+//#endregion
+export { parseInput };

package/dist/core/iterator.d.mts

@@ -0,0 +1,17 @@
+//#region src/core/iterator.d.ts
+/**
+ * Async iterator utilities for streaming support.
+ */
+type CleanupReason = 'return' | 'throw' | 'next' | 'dispose';
+declare class AsyncIteratorClass<TYield, TReturn = void> implements AsyncGenerator<TYield, TReturn> {
+  #private;
+  constructor(nextFn: () => Promise<IteratorResult<TYield, TReturn>>, cleanup?: (reason: CleanupReason) => Promise<void>);
+  next(): Promise<IteratorResult<TYield, TReturn>>;
+  return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<TYield, TReturn>>;
+  throw(error?: unknown): Promise<IteratorResult<TYield, TReturn>>;
+  [Symbol.asyncIterator](): this;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+declare function mapAsyncIterator<TIn, TOut, TReturn = void>(source: AsyncIterableIterator<TIn>, transform: (value: TIn) => Promise<TOut> | TOut, transformError?: (error: unknown) => unknown): AsyncIteratorClass<TOut, TReturn>;
+//#endregion
+export { AsyncIteratorClass, mapAsyncIterator };

package/dist/core/iterator.mjs

@@ -0,0 +1,79 @@
+import { sequential } from "./utils.mjs";
+//#region src/core/iterator.ts
+/**
+* Async iterator utilities for streaming support.
+*/
+var AsyncIteratorClass = class {
+	#nextFn;
+	#cleanup;
+	#isDone = false;
+	#cleanupCalled = false;
+	constructor(nextFn, cleanup) {
+		this.#nextFn = sequential(nextFn);
+		this.#cleanup = cleanup;
+	}
+	async #doCleanup(reason) {
+		if (this.#cleanupCalled) return;
+		this.#cleanupCalled = true;
+		await this.#cleanup?.(reason);
+	}
+	async next() {
+		if (this.#isDone) return {
+			done: true,
+			value: void 0
+		};
+		try {
+			const result = await this.#nextFn();
+			if (result.done) {
+				this.#isDone = true;
+				await this.#doCleanup("next");
+			}
+			return result;
+		} catch (error) {
+			this.#isDone = true;
+			await this.#doCleanup("throw");
+			throw error;
+		}
+	}
+	async return(value) {
+		this.#isDone = true;
+		await this.#doCleanup("return");
+		return {
+			done: true,
+			value
+		};
+	}
+	async throw(error) {
+		this.#isDone = true;
+		await this.#doCleanup("throw");
+		throw error;
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	async [Symbol.asyncDispose]() {
+		this.#isDone = true;
+		await this.#doCleanup("dispose");
+	}
+};
+function mapAsyncIterator(source, transform, transformError) {
+	return new AsyncIteratorClass(async () => {
+		try {
+			const result = await source.next();
+			if (result.done) return {
+				done: true,
+				value: await transform(result.value)
+			};
+			return {
+				done: false,
+				value: await transform(result.value)
+			};
+		} catch (error) {
+			throw transformError ? transformError(error) : error;
+		}
+	}, async () => {
+		await source.return?.();
+	});
+}
+//#endregion
+export { AsyncIteratorClass, mapAsyncIterator };

package/dist/core/router-utils.mjs

@@ -0,0 +1,22 @@
+import "../compile.mjs";
+//#region src/core/router-utils.ts
+const routerCache = /* @__PURE__ */ new WeakMap();
+function isProcedureDef(value) {
+	return typeof value === "object" && value !== null && "type" in value && "resolve" in value && typeof value.resolve === "function";
+}
+function assignPaths(def, prefix = []) {
+	const result = {};
+	for (const [key, value] of Object.entries(def)) {
+		const currentPath = [...prefix, key];
+		if (isProcedureDef(value)) if (!value.route) result[key] = {
+			...value,
+			route: { path: "/" + currentPath.join("/") }
+		};
+		else result[key] = value;
+		else if (typeof value === "object" && value !== null) result[key] = assignPaths(value, currentPath);
+		else result[key] = value;
+	}
+	return result;
+}
+//#endregion
+export { assignPaths, isProcedureDef, routerCache };

package/dist/core/schema.d.mts

@@ -0,0 +1,20 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/core/schema.d.ts
+type Schema<TInput = unknown, TOutput = unknown> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type InferSchemaInput<T extends AnySchema> = T extends Schema<infer I, unknown> ? I : never;
+type InferSchemaOutput<T extends AnySchema> = T extends Schema<unknown, infer O> ? O : never;
+type SchemaIssue = StandardSchemaV1.Issue;
+declare class ValidationError extends Error {
+  readonly issues: readonly SchemaIssue[];
+  constructor(options: {
+    message?: string;
+    issues: readonly SchemaIssue[];
+  });
+}
+/** Sync fast-path: Zod 4 validate() returns sync result — avoid Promise allocation */
+declare function validateSchema(schema: AnySchema, value: unknown): unknown;
+declare function type<TInput, TOutput = TInput>(...args: TInput extends TOutput ? TOutput extends TInput ? [map?: (input: TInput) => TOutput] : [map: (input: TInput) => TOutput] : [map: (input: TInput) => TOutput]): Schema<TInput, TOutput>;
+//#endregion
+export { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema };

package/dist/core/schema.mjs

@@ -0,0 +1,33 @@
+//#region src/core/schema.ts
+var ValidationError = class extends Error {
+	issues;
+	constructor(options) {
+		super(options.message ?? "Validation failed");
+		this.name = "ValidationError";
+		this.issues = options.issues;
+	}
+};
+/** Sync fast-path: Zod 4 validate() returns sync result — avoid Promise allocation */
+function validateSchema(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (typeof result?.then !== "function") {
+		if ("issues" in result && result.issues) throw new ValidationError({ issues: result.issues });
+		return result.value;
+	}
+	return result.then((r) => {
+		if ("issues" in r && r.issues) throw new ValidationError({ issues: r.issues });
+		return r.value;
+	});
+}
+function type(...args) {
+	const mapFn = args[0];
+	return { "~standard": {
+		version: 1,
+		vendor: "silgi",
+		validate(value) {
+			return { value: mapFn ? mapFn(value) : value };
+		}
+	} };
+}
+//#endregion
+export { ValidationError, type, validateSchema };

package/dist/core/serve.d.mts

@@ -0,0 +1,51 @@
+import { AnalyticsOptions } from "../plugins/analytics/types.mjs";
+import { ScalarOptions } from "../scalar.mjs";
+import { WSAdapterOptions } from "../ws.mjs";
+import { Hookable } from "hookable";
+
+//#region src/core/serve.d.ts
+interface SilgiServer {
+  /** Server URL (e.g. "http://127.0.0.1:3000") */
+  readonly url: string;
+  /** Configured port */
+  readonly port: number;
+  /** Configured hostname */
+  readonly hostname: string;
+  /**
+   * Gracefully shut down the server.
+   *
+   * By default waits for in-flight requests to complete.
+   * Pass `true` to forcefully terminate all active connections immediately.
+   */
+  close(forceCloseConnections?: boolean): Promise<void>;
+}
+interface ServeOptions {
+  port?: number;
+  hostname?: string;
+  /** Enable Scalar API Reference UI at /api/reference and /api/openapi.json */
+  scalar?: boolean | ScalarOptions;
+  /** Enable analytics dashboard at /api/analytics */
+  analytics?: boolean | AnalyticsOptions;
+  /** Enable WebSocket RPC (requires crossws) */
+  ws?: boolean | WSAdapterOptions;
+  /** Enable HTTP/2 (requires cert + key for TLS) */
+  http2?: {
+    cert: string;
+    key: string;
+  };
+  /**
+   * Graceful shutdown on SIGINT/SIGTERM signals.
+   *
+   * - `true` (default): enables graceful shutdown with srvx defaults
+   * - `false`: disables automatic signal handling
+   * - `object`: fine-tune timeouts
+   *
+   * @default true
+   */
+  gracefulShutdown?: boolean | {
+    /** Max time (ms) to wait for in-flight requests before force-closing */timeout?: number; /** Max time (ms) after graceful period before process.exit */
+    forceTimeout?: number;
+  };
+}
+//#endregion
+export { ServeOptions, SilgiServer };