silgi 0.1.0-beta.4 → 0.1.0-beta.5

package/dist/adapters/aws-lambda.d.mts

@@ -16,6 +16,9 @@ interface LambdaEvent {
   requestContext?: Record<string, unknown>;
   isBase64Encoded?: boolean;
 }
+interface LambdaContext {
+  getRemainingTimeInMillis?: () => number;
+}
 interface LambdaResponse {
   statusCode: number;
   headers: Record<string, string>;
@@ -26,6 +29,6 @@ interface LambdaResponse {
  *
  * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
  */
-declare function silgiLambda<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent) => Promise<LambdaResponse>;
+declare function silgiLambda<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResponse>;
 //#endregion
 export { LambdaAdapterOptions, silgiLambda };

package/dist/adapters/aws-lambda.mjs

@@ -22,7 +22,7 @@ import { compileRouter } from "../compile.mjs";
 function silgiLambda(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	const prefix = options.prefix ?? "";
-	return async (event) => {
+	return async (event, context) => {
 		let pathname = event.path;
 		if (prefix && pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
 		if (pathname.startsWith("/")) pathname = pathname.slice(1);
@@ -50,11 +50,32 @@ function silgiLambda(router, options = {}) {
 				const body = event.isBase64Encoded ? Buffer.from(event.body, "base64").toString("utf-8") : event.body;
 				try {
 					input = JSON.parse(body);
-				} catch {}
+				} catch {
+					return {
+						statusCode: 400,
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							code: "BAD_REQUEST",
+							status: 400,
+							message: "Invalid JSON body"
+						})
+					};
+				}
 			} else if (event.queryStringParameters?.data) try {
 				input = JSON.parse(event.queryStringParameters.data);
-			} catch {}
-			const signal = AbortSignal.timeout(3e4);
+			} catch {
+				return {
+					statusCode: 400,
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						code: "BAD_REQUEST",
+						status: 400,
+						message: "Invalid JSON in data parameter"
+					})
+				};
+			}
+			const timeoutMs = context?.getRemainingTimeInMillis ? context.getRemainingTimeInMillis() - 500 : 3e4;
+			const signal = AbortSignal.timeout(Math.max(timeoutMs, 1e3));
 			const output = await route.handler(ctx, input, signal);
 			return {
 				statusCode: 200,

package/dist/adapters/express.mjs

@@ -1,6 +1,7 @@
 import { SilgiError, toSilgiError } from "../core/error.mjs";
 import { ValidationError } from "../core/schema.mjs";
 import { compileRouter } from "../compile.mjs";
+import { iteratorToEventStream } from "../core/sse.mjs";
 //#region src/adapters/express.ts
 /**
 * Express adapter — use Silgi as Express middleware.
@@ -31,6 +32,15 @@ function silgiExpress(router, options = {}) {
 		const match = flatRouter(req.method, "/" + pathname);
 		if (!match) return next();
 		const route = match.data;
+		const method = req.method;
+		if (route.method !== "*" && method !== route.method && method !== "OPTIONS" && !(method === "GET" && route.method === "POST")) {
+			res.status(405).set("allow", route.method).json({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${method} not allowed`
+			});
+			return;
+		}
 		const handle = async () => {
 			try {
 				const ctx = Object.create(null);
@@ -54,9 +64,49 @@ function silgiExpress(router, options = {}) {
 				}
 				else input = req.query.data;
 				const ac = new AbortController();
-				req.on("close", () => ac.abort());
-				const output = await route.handler(ctx, input, ac.signal);
-				res.json(output);
+				const onClose = () => ac.abort();
+				req.on("close", onClose);
+				try {
+					const output = await route.handler(ctx, input, ac.signal);
+					if (output instanceof Response) {
+						res.status(output.status);
+						output.headers.forEach((v, k) => res.setHeader(k, v));
+						const body = output.body ? Buffer.from(await output.arrayBuffer()) : "";
+						res.end(body);
+					} else if (output instanceof ReadableStream) {
+						res.setHeader("content-type", "application/octet-stream");
+						const reader = output.getReader();
+						const pump = async () => {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						};
+						await pump();
+					} else if (output && typeof output === "object" && Symbol.asyncIterator in output) {
+						const stream = iteratorToEventStream(output);
+						res.setHeader("content-type", "text/event-stream");
+						res.setHeader("cache-control", "no-cache");
+						const reader = stream.getReader();
+						const pump = async () => {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						};
+						await pump();
+					} else res.json(output);
+				} finally {
+					req.removeListener("close", onClose);
+				}
 			} catch (error) {
 				if (error instanceof ValidationError) {
 					res.status(400).json({
@@ -71,7 +121,12 @@ function silgiExpress(router, options = {}) {
 				res.status(e.status).json(e.toJSON());
 			}
 		};
-		handle();
+		handle().catch((error) => {
+			if (!res.headersSent) {
+				const e = error instanceof SilgiError ? error : toSilgiError(error);
+				res.status(e.status).json(e.toJSON());
+			}
+		});
 	};
 }
 //#endregion

package/dist/callable.d.mts

@@ -4,6 +4,8 @@ import { ErrorDef, ProcedureDef } from "./types.mjs";
 interface CallableOptions<TCtx extends Record<string, unknown>> {
   /** Context factory — called on every invocation */
   context: () => TCtx | Promise<TCtx>;
+  /** Default timeout in ms. Default: 30000. Set null to disable. */
+  timeout?: number | null;
 }
 type CallableFn<TInput, TOutput> = undefined extends TInput ? (input?: TInput) => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
 /**

package/dist/callable.mjs

@@ -29,13 +29,13 @@ import { compileProcedure } from "./compile.mjs";
 function callable(procedure, options) {
 	const handler = compileProcedure(procedure);
 	const contextFactory = options.context;
-	const signal = new AbortController().signal;
+	const defaultTimeout = options.timeout !== void 0 ? options.timeout : 3e4;
 	return (async (input) => {
 		const ctx = await contextFactory();
 		const ctxObj = Object.create(null);
 		const keys = Object.keys(ctx);
 		for (let i = 0; i < keys.length; i++) ctxObj[keys[i]] = ctx[keys[i]];
-		return handler(ctxObj, input, signal);
+		return handler(ctxObj, input, defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : new AbortController().signal);
 	});
 }
 //#endregion

package/dist/caller.mjs

@@ -0,0 +1,97 @@
+import { routerCache } from "./core/router-utils.mjs";
+import { compileRouter, createContext, releaseContext } from "./compile.mjs";
+//#region src/caller.ts
+/**
+* createCaller — call procedures directly without HTTP.
+*
+* Compiles the router, creates context, and runs the pipeline
+* for each procedure call. Perfect for testing and server-side usage.
+*
+* @example
+* ```ts
+* const caller = s.createCaller(appRouter)
+*
+* // Call procedures directly
+* const users = await caller.users.list({ limit: 10 })
+* const user = await caller.users.get({ id: 1 })
+*
+* // With custom context override
+* const adminCaller = s.createCaller(appRouter, {
+*   contextOverride: { user: { id: 1, role: 'admin' } },
+* })
+* ```
+*/
+/**
+* Create a direct caller for a router — no HTTP, no serialization.
+*
+* Returns a proxy that mirrors the router's nested structure.
+* Calling a leaf procedure invokes the compiled pipeline directly.
+*/
+function createCaller(routerDef, contextFactory, options) {
+	let compiledRouter = routerCache.get(routerDef);
+	if (!compiledRouter) {
+		compiledRouter = compileRouter(routerDef);
+		routerCache.set(routerDef, compiledRouter);
+	}
+	const router = compiledRouter;
+	const defaultTimeout = options?.timeout !== void 0 ? options.timeout : 3e4;
+	function createMockRequest(extraHeaders) {
+		const headers = new Headers(options?.headers);
+		if (extraHeaders) for (const [k, v] of Object.entries(extraHeaders)) headers.set(k, v);
+		return new Request("http://localhost/__caller", { headers });
+	}
+	async function resolveContext(perCallContext) {
+		const ctx = createContext();
+		if (contextFactory) {
+			const result = contextFactory(createMockRequest());
+			const baseCtx = result instanceof Promise ? await result : result;
+			const keys = Object.keys(baseCtx);
+			for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+		}
+		if (options?.contextOverride) {
+			const keys = Object.keys(options.contextOverride);
+			for (let i = 0; i < keys.length; i++) ctx[keys[i]] = options.contextOverride[keys[i]];
+		}
+		if (perCallContext) {
+			const keys = Object.keys(perCallContext);
+			for (let i = 0; i < keys.length; i++) ctx[keys[i]] = perCallContext[keys[i]];
+		}
+		return ctx;
+	}
+	function createProxy(segments) {
+		const cache = /* @__PURE__ */ new Map();
+		return new Proxy(() => {}, {
+			get(_target, prop) {
+				if (typeof prop === "symbol") return void 0;
+				if (prop === "then" || prop === "toJSON" || prop === "toString" || prop === "$$typeof") return;
+				let sub = cache.get(prop);
+				if (!sub) {
+					sub = createProxy([...segments, prop]);
+					cache.set(prop, sub);
+				}
+				return sub;
+			},
+			apply(_target, _thisArg, args) {
+				const path = "/" + segments.join("/");
+				const input = args[0];
+				const callOptions = args[1];
+				return (async () => {
+					const match = router("", path);
+					if (!match) throw new Error(`Procedure not found: ${path}`);
+					const ctx = await resolveContext(callOptions?.context);
+					if (match.params) ctx.params = match.params;
+					const signal = callOptions?.signal ?? (defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : void 0);
+					try {
+						const result = match.data.handler(ctx, input, signal);
+						return result instanceof Promise ? await result : result;
+					} finally {
+						releaseContext(ctx);
+					}
+				})();
+			}
+		});
+	}
+	return createProxy([]);
+}
+//#endregion
+export { createCaller };

package/dist/client/client.mjs

@@ -23,7 +23,7 @@ function createClientProxy(link, path) {
 			if (typeof prop !== "string") return void 0;
 			let cached = cache.get(prop);
 			if (!cached) {
-				cached = createClientProxy(link, Object.freeze([...path, prop]));
+				cached = createClientProxy(link, [...path, prop]);
 				cache.set(prop, cached);
 			}
 			return cached;

package/dist/client/plugins/batch.mjs

@@ -31,7 +31,7 @@ var BatchLink = class {
 		if (batch.length === 0) return;
 		const chunks = [];
 		for (let i = 0; i < batch.length; i += this.#maxSize) chunks.push(batch.slice(i, i + this.#maxSize));
-		for (const chunk of chunks) await this.#sendChunk(chunk);
+		await Promise.all(chunks.map((chunk) => this.#sendChunk(chunk)));
 	}
 	async #sendChunk(chunk) {
 		const batchBody = chunk.map((call) => ({
@@ -40,7 +40,7 @@ var BatchLink = class {
 			body: call.input
 		}));
 		try {
-			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk[0]?.options.signal });
+			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk.length === 1 ? chunk[0].options.signal : AbortSignal.any(chunk.map((c) => c.options.signal).filter(Boolean)) });
 			if (!Array.isArray(responses)) {
 				for (const call of chunk) call.reject(/* @__PURE__ */ new Error("Invalid batch response"));
 				return;

package/dist/client/plugins/circuit-breaker.d.mts

@@ -0,0 +1,24 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/circuit-breaker.d.ts
+type CircuitState = 'closed' | 'open' | 'half-open';
+declare class CircuitBreakerOpenError extends Error {
+  readonly state: CircuitState;
+  constructor();
+}
+interface CircuitBreakerOptions {
+  /** Number of consecutive failures before opening (default: 5) */
+  failureThreshold?: number;
+  /** Time in ms to wait before moving to half-open (default: 30000) */
+  resetTimeout?: number;
+  /** Called when circuit state changes */
+  onStateChange?: (state: CircuitState, info: {
+    failures: number;
+  }) => void;
+}
+declare function withCircuitBreaker<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: CircuitBreakerOptions): ClientLink<TClientContext> & {
+  getState: () => CircuitState;
+  reset: () => void;
+};
+//#endregion
+export { CircuitBreakerOpenError, CircuitBreakerOptions, CircuitState, withCircuitBreaker };

package/dist/client/plugins/circuit-breaker.mjs

@@ -0,0 +1,60 @@
+//#region src/client/plugins/circuit-breaker.ts
+var CircuitBreakerOpenError = class extends Error {
+	state = "open";
+	constructor() {
+		super("Circuit breaker is open — requests are blocked. Try again later.");
+		this.name = "CircuitBreakerOpenError";
+	}
+};
+function withCircuitBreaker(link, options = {}) {
+	const threshold = options.failureThreshold ?? 5;
+	const resetTimeout = options.resetTimeout ?? 3e4;
+	let state = "closed";
+	let failures = 0;
+	let openedAt = 0;
+	let probeSent = false;
+	function setState(newState) {
+		if (state !== newState) {
+			state = newState;
+			if (newState !== "half-open") probeSent = false;
+			options.onStateChange?.(state, { failures });
+		}
+	}
+	function recordSuccess() {
+		failures = 0;
+		setState("closed");
+	}
+	function recordFailure() {
+		failures++;
+		if (failures >= threshold) {
+			openedAt = Date.now();
+			setState("open");
+		}
+	}
+	return {
+		async call(path, input, callOptions) {
+			if (state === "open") if (Date.now() - openedAt >= resetTimeout) setState("half-open");
+			else throw new CircuitBreakerOpenError();
+			if (state === "half-open") {
+				if (probeSent) throw new CircuitBreakerOpenError();
+				probeSent = true;
+			}
+			try {
+				const result = await link.call(path, input, callOptions);
+				recordSuccess();
+				return result;
+			} catch (error) {
+				recordFailure();
+				throw error;
+			}
+		},
+		getState: () => state,
+		reset: () => {
+			failures = 0;
+			probeSent = false;
+			setState("closed");
+		}
+	};
+}
+//#endregion
+export { CircuitBreakerOpenError, withCircuitBreaker };

package/dist/client/plugins/index.d.mts

@@ -1,5 +1,7 @@
 import { RetryOptions, withRetry } from "./retry.mjs";
+import { CircuitBreakerOpenError, CircuitBreakerOptions, CircuitState, withCircuitBreaker } from "./circuit-breaker.mjs";
+import { TimeoutOptions, withTimeout } from "./timeout.mjs";
 import { BatchLink, BatchLinkOptions } from "./batch.mjs";
 import { DedupeOptions, withDedupe } from "./dedupe.mjs";
 import { CSRFLinkOptions, withCSRF } from "./csrf.mjs";
-export { BatchLink, type BatchLinkOptions, type CSRFLinkOptions, type DedupeOptions, type RetryOptions, withCSRF, withDedupe, withRetry };
+export { BatchLink, type BatchLinkOptions, type CSRFLinkOptions, CircuitBreakerOpenError, type CircuitBreakerOptions, type CircuitState, type DedupeOptions, type RetryOptions, type TimeoutOptions, withCSRF, withCircuitBreaker, withDedupe, withRetry, withTimeout };

package/dist/client/plugins/index.mjs

@@ -1,5 +1,7 @@
 import { withRetry } from "./retry.mjs";
+import { CircuitBreakerOpenError, withCircuitBreaker } from "./circuit-breaker.mjs";
+import { withTimeout } from "./timeout.mjs";
 import { BatchLink } from "./batch.mjs";
 import { withDedupe } from "./dedupe.mjs";
 import { withCSRF } from "./csrf.mjs";
-export { BatchLink, withCSRF, withDedupe, withRetry };
+export { BatchLink, CircuitBreakerOpenError, withCSRF, withCircuitBreaker, withDedupe, withRetry, withTimeout };

package/dist/client/plugins/retry.d.mts

@@ -2,9 +2,30 @@ import { ClientContext, ClientLink } from "../types.mjs";
 
 //#region src/client/plugins/retry.d.ts
 interface RetryOptions {
+  /** Maximum number of retry attempts (default: 3) */
   maxRetries?: number;
-  retryDelay?: number | ((attempt: number) => number);
-  shouldRetry?: (error: unknown) => boolean;
+  /**
+   * Base delay in ms for exponential backoff (default: 1000).
+   * Actual delay: `baseDelay * 2^attempt + jitter`
+   * Or pass a function: `(attempt: number) => delayMs`
+   */
+  baseDelay?: number | ((attempt: number) => number);
+  /** Add random jitter 0-25% to prevent thundering herd (default: true) */
+  jitter?: boolean;
+  /**
+   * HTTP status codes to retry on (default: [408, 429, 500, 502, 503, 504]).
+   * Network errors (no status) are always retried unless shouldRetry returns false.
+   */
+  retryOn?: number[];
+  /** Custom retry predicate — return false to stop retrying */
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+  /** Called before each retry attempt */
+  onRetry?: (info: {
+    attempt: number;
+    delay: number;
+    error: unknown;
+    path: readonly string[];
+  }) => void;
 }
 declare function withRetry<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: RetryOptions): ClientLink<TClientContext>;
 //#endregion

package/dist/client/plugins/retry.mjs

@@ -1,20 +1,64 @@
 //#region src/client/plugins/retry.ts
+const DEFAULT_RETRY_CODES = [
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+];
+function getStatusFromError(error) {
+	if (error && typeof error === "object") {
+		const e = error;
+		if (typeof e.status === "number") return e.status;
+		if (typeof e.statusCode === "number") return e.statusCode;
+		if (e.response && typeof e.response === "object") {
+			const r = e.response;
+			if (typeof r.status === "number") return r.status;
+		}
+	}
+}
 function withRetry(link, options = {}) {
 	const maxRetries = options.maxRetries ?? 3;
-	const getDelay = typeof options.retryDelay === "function" ? options.retryDelay : () => options.retryDelay ?? 1e3;
-	const shouldRetry = options.shouldRetry ?? (() => true);
+	const baseDelay = options.baseDelay ?? 1e3;
+	const useJitter = options.jitter ?? true;
+	const retryCodes = new Set(options.retryOn ?? DEFAULT_RETRY_CODES);
+	const shouldRetry = options.shouldRetry;
+	const onRetry = options.onRetry;
+	function getDelay(attempt) {
+		const base = typeof baseDelay === "function" ? baseDelay(attempt) : baseDelay * 2 ** attempt;
+		const jitter = useJitter ? base * Math.random() * .25 : 0;
+		return Math.round(base + jitter);
+	}
+	function isRetryable(error, attempt) {
+		if (shouldRetry && !shouldRetry(error, attempt)) return false;
+		const status = getStatusFromError(error);
+		if (status === void 0) return true;
+		return retryCodes.has(status);
+	}
 	return { async call(path, input, callOptions) {
-		let lastError;
 		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
 			return await link.call(path, input, callOptions);
 		} catch (error) {
-			lastError = error;
-			if (attempt === maxRetries || !shouldRetry(error)) throw error;
+			if (attempt === maxRetries) throw error;
 			if (callOptions.signal?.aborted) throw error;
+			if (!isRetryable(error, attempt)) throw error;
 			const delay = getDelay(attempt);
-			await new Promise((resolve) => setTimeout(resolve, delay));
+			onRetry?.({
+				attempt: attempt + 1,
+				delay,
+				error,
+				path
+			});
+			await new Promise((resolve, reject) => {
+				const timer = setTimeout(resolve, delay);
+				callOptions.signal?.addEventListener("abort", () => {
+					clearTimeout(timer);
+					reject(callOptions.signal.reason);
+				}, { once: true });
+			});
 		}
-		throw lastError;
+		throw new Error("Retry exhausted");
 	} };
 }
 //#endregion

package/dist/client/plugins/timeout.d.mts

@@ -0,0 +1,10 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/timeout.d.ts
+interface TimeoutOptions {
+  /** Timeout in ms (default: 30000) */
+  timeout?: number;
+}
+declare function withTimeout<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: TimeoutOptions): ClientLink<TClientContext>;
+//#endregion
+export { TimeoutOptions, withTimeout };

package/dist/client/plugins/timeout.mjs

@@ -0,0 +1,14 @@
+//#region src/client/plugins/timeout.ts
+function withTimeout(link, options = {}) {
+	const timeout = options.timeout ?? 3e4;
+	return { async call(path, input, callOptions) {
+		const timeoutSignal = AbortSignal.timeout(timeout);
+		const signal = callOptions.signal ? AbortSignal.any([callOptions.signal, timeoutSignal]) : timeoutSignal;
+		return link.call(path, input, {
+			...callOptions,
+			signal
+		});
+	} };
+}
+//#endregion
+export { withTimeout };

package/dist/codec/devalue.d.mts

@@ -2,7 +2,7 @@
 /**
  * devalue codec — rich type serialization.
  *
- * Supports Date, Map, Set, BigInt, RegExp, undefined, circular refs.
+ * Supports Date, Map, Set, BigInt, undefined, circular refs.
  * 2.7x faster than superjson, 37% smaller output.
  *
  * Use when your RPC procedures return rich JS types
@@ -11,7 +11,7 @@
 declare const DEVALUE_CONTENT_TYPE = "application/x-devalue+json";
 /** Serialize a value with devalue (handles Date, Map, Set, BigInt, etc.) */
 declare function encode(value: unknown): string;
-/** Deserialize a devalue string back to the original value */
+/** Deserialize a devalue string back to the original value, sanitized for safety */
 declare function decode(text: string): unknown;
 /** Check if request body uses devalue encoding */
 declare function isDevalue(contentType: string | null | undefined): boolean;

package/dist/codec/devalue.mjs

@@ -3,7 +3,7 @@ import { parse, stringify } from "devalue";
 /**
 * devalue codec — rich type serialization.
 *
-* Supports Date, Map, Set, BigInt, RegExp, undefined, circular refs.
+* Supports Date, Map, Set, BigInt, undefined, circular refs.
 * 2.7x faster than superjson, 37% smaller output.
 *
 * Use when your RPC procedures return rich JS types
@@ -14,9 +14,9 @@ const DEVALUE_CONTENT_TYPE = "application/x-devalue+json";
 function encode(value) {
 	return stringify(value);
 }
-/** Deserialize a devalue string back to the original value */
+/** Deserialize a devalue string back to the original value, sanitized for safety */
 function decode(text) {
-	return parse(text);
+	return sanitizeDecoded(parse(text));
 }
 /** Check if request body uses devalue encoding */
 function isDevalue(contentType) {
@@ -28,5 +28,32 @@ function acceptsDevalue(acceptHeader) {
 	if (!acceptHeader) return false;
 	return acceptHeader.includes(DEVALUE_CONTENT_TYPE);
 }
+/** Strip potentially dangerous types (RegExp, Error) from decoded values */
+function sanitizeDecoded(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (value instanceof RegExp) return String(value);
+	if (value instanceof Error) return { message: value.message };
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) value[i] = sanitizeDecoded(value[i]);
+		return value;
+	}
+	if (value instanceof Map) {
+		const clean = /* @__PURE__ */ new Map();
+		for (const [k, v] of value) clean.set(sanitizeDecoded(k), sanitizeDecoded(v));
+		return clean;
+	}
+	if (value instanceof Set) {
+		const clean = /* @__PURE__ */ new Set();
+		for (const v of value) clean.add(sanitizeDecoded(v));
+		return clean;
+	}
+	if (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) {
+		const obj = value;
+		for (const key of Object.keys(obj)) if (key === "__proto__") delete obj[key];
+		else obj[key] = sanitizeDecoded(obj[key]);
+	}
+	return value;
+}
 //#endregion
 export { DEVALUE_CONTENT_TYPE, acceptsDevalue, decode, encode, isDevalue };

package/dist/codec/msgpack.d.mts

@@ -1,12 +1,9 @@
 //#region src/codec/msgpack.d.ts
 /**
- * MessagePack codec for Silgi binary protocol.
+ * MessagePack codec — binary transport for Silgi.
  *
- * 2-4x faster encoding, ~50% smaller payloads vs JSON.
- * No competitor (oRPC, tRPC) offers binary transport.
- *
- * Uses msgpackr with record extension — repeated object shapes
- * (common in RPC: same fields every request) get 2-3x decode speedup.
+ * ~50% smaller payloads vs JSON. Uses msgpackr with record extension
+ * for fast encoding of repeated object shapes.
  */
 declare const MSGPACK_CONTENT_TYPE = "application/x-msgpack";
 /** Encode a value to MessagePack binary (usable as Response body) */

package/dist/codec/msgpack.mjs

@@ -1,13 +1,10 @@
 import { Packr } from "msgpackr";
 //#region src/codec/msgpack.ts
 /**
-* MessagePack codec for Silgi binary protocol.
+* MessagePack codec — binary transport for Silgi.
 *
-* 2-4x faster encoding, ~50% smaller payloads vs JSON.
-* No competitor (oRPC, tRPC) offers binary transport.
-*
-* Uses msgpackr with record extension — repeated object shapes
-* (common in RPC: same fields every request) get 2-3x decode speedup.
+* ~50% smaller payloads vs JSON. Uses msgpackr with record extension
+* for fast encoding of repeated object shapes.
 */
 const MSGPACK_CONTENT_TYPE = "application/x-msgpack";
 /**
@@ -40,7 +37,17 @@ function sanitizeDecoded(value) {
 	if (value instanceof Error) return { message: value.message };
 	if (value instanceof RegExp) return String(value);
 	if (Array.isArray(value)) return value.map(sanitizeDecoded);
-	if (value instanceof Date || value instanceof Map || value instanceof Set) return value;
+	if (value instanceof Date) return value;
+	if (value instanceof Map) {
+		const sanitized = /* @__PURE__ */ new Map();
+		for (const [k, v] of value) sanitized.set(k, sanitizeDecoded(v));
+		return sanitized;
+	}
+	if (value instanceof Set) {
+		const sanitized = /* @__PURE__ */ new Set();
+		for (const v of value) sanitized.add(sanitizeDecoded(v));
+		return sanitized;
+	}
 	const result = {};
 	for (const [k, v] of Object.entries(value)) result[k] = sanitizeDecoded(v);
 	return result;