silgi 0.53.1 → 0.53.3

package/dist/client/adapters/fetch/index.mjs

@@ -1,5 +1,6 @@
 import { SilgiError, fromSilgiErrorJSON, isErrorStatus, isSilgiErrorJSON } from "../../../core/error.mjs";
 import { parseEmptyableJSON, stringifyJSON } from "../../../core/utils.mjs";
+import { eventStreamToIterator } from "../../../core/sse.mjs";
 //#region src/client/adapters/fetch/index.ts
 /**
 * Fetch transport — HTTP client for browser and Node.js.
@@ -29,6 +30,7 @@ var RPCLink = class {
 			signal: options.signal
 		});
 		const contentType = response.headers.get("content-type") ?? "";
+		if (contentType.includes("text/event-stream") && response.body) return eventStreamToIterator(response.body);
 		let responseBody;
 		if (contentType.includes("msgpack")) {
 			const { decode } = await import("../../../codec/msgpack.mjs");

package/dist/client/adapters/ofetch/index.mjs

@@ -1,4 +1,5 @@
 import { SilgiError, fromSilgiErrorJSON, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { eventStreamToIterator } from "../../../core/sse.mjs";
 import { MSGPACK_CONTENT_TYPE, decode, encode } from "../../../codec/msgpack.mjs";
 import { FetchError, ofetch } from "ofetch";
 //#region src/client/adapters/ofetch/index.ts
@@ -42,7 +43,7 @@ function createLink(options) {
 			body = input !== void 0 && input !== null ? devalueEncode(input) : void 0;
 		} else body = input !== void 0 && input !== null ? input : void 0;
 		try {
-			const data = await ofetch(url, {
+			const response = await ofetch.raw(url, {
 				method: "POST",
 				headers,
 				body,
@@ -55,21 +56,28 @@ function createLink(options) {
 				onResponse: options.onResponse,
 				onRequestError: options.onRequestError,
 				onResponseError: options.onResponseError,
-				...resolvedProtocol === "messagepack" ? { responseType: "arrayBuffer" } : resolvedProtocol === "devalue" ? { responseType: "text" } : { parseResponse(text) {
-					if (!text) return void 0;
-					try {
-						return JSON.parse(text);
-					} catch {
-						return text;
-					}
-				} }
+				responseType: "stream"
 			});
+			if ((response.headers.get("content-type") ?? "").includes("text/event-stream") && response.body) return eventStreamToIterator(response.body);
 			let decoded;
-			if (resolvedProtocol === "messagepack") decoded = decode(new Uint8Array(data));
-			else if (resolvedProtocol === "devalue") {
-				const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
-				decoded = data ? devalueDecode(data) : void 0;
-			} else decoded = data;
+			if (resolvedProtocol === "messagepack") {
+				const buf = new Uint8Array(await new Response(response.body).arrayBuffer());
+				decoded = buf.length > 0 ? decode(buf) : void 0;
+			} else if (resolvedProtocol === "devalue") {
+				const text = await new Response(response.body).text();
+				if (text) {
+					const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
+					decoded = devalueDecode(text);
+				} else decoded = void 0;
+			} else {
+				const text = await new Response(response.body).text();
+				if (!text) decoded = void 0;
+				else try {
+					decoded = JSON.parse(text);
+				} catch {
+					decoded = text;
+				}
+			}
 			if (isSilgiErrorJSON(decoded)) throw fromSilgiErrorJSON(decoded);
 			return decoded;
 		} catch (error) {

package/dist/client/types.d.mts

@@ -9,8 +9,13 @@ interface ClientOptions<TContext extends ClientContext = ClientContext> {
 }
 /** A single procedure client — callable function */
 type Client<TClientContext extends ClientContext, TInput, TOutput, _TError = SilgiError> = (...args: ClientRest<TClientContext, TInput>) => Promise<TOutput>;
-/** A subscription client — returns async iterator */
-type SubscriptionClient<TClientContext extends ClientContext, TInput, TOutput> = (...args: ClientRest<TClientContext, TInput>) => AsyncIterableIterator<TOutput>;
+/**
+ * A subscription client — resolves to an async iterator. The Promise
+ * boundary is the network round-trip (open the SSE/WS connection, see
+ * the response headers); the resolved iterator yields each event until
+ * the stream ends.
+ */
+type SubscriptionClient<TClientContext extends ClientContext, TInput, TOutput> = (...args: ClientRest<TClientContext, TInput>) => Promise<AsyncIterableIterator<TOutput>>;
 /** Determine argument shape based on input and context optionality */
 type ClientRest<TClientContext extends ClientContext, TInput> = undefined extends TInput ? Record<never, never> extends TClientContext ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput | undefined, options: ClientOptions<TClientContext>] : Record<never, never> extends TClientContext ? [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
 /** Recursive nested client — mirrors the router structure */

package/dist/compile.d.mts

@@ -8,13 +8,30 @@ import { ProcedureDef, WrapDef } from "./types.mjs";
  */
 type CompiledHandler = (ctx: Record<string, unknown>, rawInput: unknown, signal: AbortSignal) => unknown | Promise<unknown>;
 /**
- * Compile a procedure into the fastest possible handler.
+ * Compile a procedure into its request 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
+ * The generated handler is built as two nested onions:
+ *
+ *   root-wrap onion (outer)
+ *     └─ guards → input validation → procedure-wrap onion → resolver
+ *        → output validation                                  (inner)
+ *
+ * The *inner* handler still selects one of three shapes up front:
+ *
+ *   - fully sync fast-path when there are no procedure wraps and no
+ *     input/output schemas;
+ *   - semi-sync when validation is present but no procedure wraps;
+ *   - full async onion when any procedure wrap is attached.
+ *
+ * The *outer* handler is only built when `rootWraps` is non-empty.
+ * When no root wraps are configured we return the inner handler as
+ * is — zero extra closures per request, every fast-path preserved.
+ *
+ * @param procedure  The procedure definition to compile.
+ * @param rootWraps  Instance-level wraps (from `silgi({ wraps })`).
+ *                   These wrap the *whole* inner pipeline, including
+ *                   guards — that is the contract documented on
+ *                   `SilgiConfig.wraps` (issue #14).
  */
 declare function compileProcedure(procedure: ProcedureDef, rootWraps?: readonly WrapDef[] | null): CompiledHandler;
 interface CompiledRoute {
@@ -40,20 +57,35 @@ type CompiledRouterFn = (method: string, path: string) => MatchedRoute<CompiledR
  */
 declare function compileRouter(def: Record<string, unknown>): CompiledRouterFn;
 /**
- * Disposable wrapper around the pipeline context.
+ * Disposable context object handed to the pipeline.
  *
- * Adapters use `using ctx = createContext()` so the context is released
- * automatically at scope exit — unless ownership has been transferred
- * elsewhere (e.g. to a streaming `Response` that keeps reading from
- * `ctx` after the handler returns). In that case the handler calls
- * `detachContext(ctx)` and the new owner is responsible for cleanup.
+ * Adapters use `using ctx = createContext()` so the context is
+ * disposed automatically at scope exit — unless ownership has been
+ * transferred elsewhere (e.g. to a streaming `Response` that keeps
+ * reading from `ctx` after the handler returns). In that case the
+ * handler calls `detachContext(ctx)` and the new owner is responsible
+ * for cleanup.
  */
 type PooledContext = Record<string, unknown> & Disposable;
 /**
- * Acquire a context object — from the pool when one is available,
- * otherwise a fresh null-prototype object. Null-prototype keeps user
- * keys from colliding with `Object.prototype` members and avoids a
- * prototype-chain walk on every property lookup.
+ * Allocate a fresh pipeline context.
+ *
+ * The object has a `null` prototype so user-supplied keys cannot
+ * accidentally shadow `Object.prototype` members and property lookups
+ * stay on the object itself.
+ *
+ * A `Symbol.dispose` slot is attached so `using ctx = createContext()`
+ * runs `releaseContext(ctx)` at scope exit. Streaming responses that
+ * outlive the handler scope swap that slot for a no-op via
+ * `detachContext` and take ownership.
+ *
+ * This used to draw from a recycled pool. The pool has been removed —
+ * the win was marginal, the indirection was loud, and the tests that
+ * pinned "pool readback" behaviour were observing an implementation
+ * detail, not a user-visible guarantee. The public API
+ * (`createContext` / `detachContext` / `releaseContext` /
+ * `PooledContext`) is preserved so existing call sites keep working;
+ * only the internals changed.
  */
 declare function createContext(): PooledContext;
 //#endregion

package/dist/compile.mjs

@@ -1,4 +1,4 @@
-import { validateSchema } from "./core/schema.mjs";
+import { SchemaValidatorCrash, validateSchema } from "./core/schema.mjs";
 import { SilgiError } from "./core/error.mjs";
 import { isProcedureDef } from "./core/router-utils.mjs";
 import { RAW_INPUT, ROOT_WRAPS } from "./core/ctx-symbols.mjs";
@@ -33,6 +33,87 @@ import { addRoute, createRouter, findRoute } from "rou3";
 function isThenable(value) {
 	return value !== null && typeof value === "object" && typeof value.then === "function";
 }
+/**
+* Defaults to `true` when `process` is unavailable (Workers/browser) so
+* crashes stay loud by default. Read per-crash so tests can flip
+* `NODE_ENV` at runtime — the crash path is cold, the cost is moot.
+*/
+function isDevEnv() {
+	if (typeof process === "undefined") return true;
+	return process.env?.NODE_ENV !== "production";
+}
+/**
+* Validate input. A validator that crashes (e.g. a misconstructed
+* Zod v4 schema) becomes a `BAD_REQUEST` with the original throw on
+* `cause` — the client sent something the validator couldn't even
+* evaluate. Soft `ValidationError` results pass through unchanged.
+*/
+function validateInput(schema, value) {
+	let validated;
+	try {
+		validated = validateSchema(schema, value);
+	} catch (e) {
+		if (e instanceof SchemaValidatorCrash) throw new SilgiError("BAD_REQUEST", {
+			message: "Input schema validator crashed",
+			cause: e.cause
+		});
+		throw e;
+	}
+	if (isThenable(validated)) return validated.catch((e) => {
+		if (e instanceof SchemaValidatorCrash) throw new SilgiError("BAD_REQUEST", {
+			message: "Input schema validator crashed",
+			cause: e.cause
+		});
+		throw e;
+	});
+	return validated;
+}
+/**
+* Validate output. A validator that crashes becomes an
+* `INTERNAL_SERVER_ERROR` (server bug, not user input) with the original
+* throw on `cause`. In dev the cause is also `console.error`'d so the
+* stack shows up in the server log — the only signal otherwise is a
+* generic 500.
+*/
+function validateOutput(schema, value) {
+	let validated;
+	try {
+		validated = validateSchema(schema, value);
+	} catch (e) {
+		if (e instanceof SchemaValidatorCrash) {
+			if (isDevEnv()) console.error("[silgi] output schema validator crashed:", e.cause);
+			throw new SilgiError("INTERNAL_SERVER_ERROR", {
+				message: "Output schema validator crashed",
+				cause: e.cause
+			});
+		}
+		throw e;
+	}
+	if (isThenable(validated)) return validated.catch((e) => {
+		if (e instanceof SchemaValidatorCrash) {
+			if (isDevEnv()) console.error("[silgi] output schema validator crashed:", e.cause);
+			throw new SilgiError("INTERNAL_SERVER_ERROR", {
+				message: "Output schema validator crashed",
+				cause: e.cause
+			});
+		}
+		throw e;
+	});
+	return validated;
+}
+/**
+* Wrap a subscription's iterator so each yielded item runs through
+* `validateOutput`. The pre-#26 path validated the iterator object
+* itself, which always 400'd because schemas can't find their declared
+* keys on an iterator. A schema crash mid-stream propagates as a thrown
+* error that the SSE encoder turns into an `error` event.
+*/
+async function* validateIteratorOutput(iterator, schema) {
+	for await (const item of iterator) {
+		const validated = validateOutput(schema, item);
+		yield isThenable(validated) ? await validated : validated;
+	}
+}
 function createFail(errors) {
 	return (code, data) => {
 		const def = errors[code];
@@ -143,49 +224,31 @@ function selectGuardRunner(guards) {
 	if (guards.length === 0) return void 0;
 	return (ctx) => runGuardsSequential(ctx, guards);
 }
-/** Call resolve, then validate output (sync-first, async fallback) */
-/**
-* Call the resolver, then validate the output. Stays sync when the
-* resolver is sync and there is no output schema; switches to
-* `.then()` chaining only once an async boundary appears.
-*/
-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, call the resolver, validate output.
+* Compile a procedure into its request handler.
 *
-* Everything that throws synchronously (input validation errors,
-* `fail()` calls inside the resolver, the resolver itself) is turned
-* into a rejected `Promise` so callers can rely on a single
-* `.then().catch()` chain no matter which branch the pipeline took.
-*/
-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.
+* The generated handler is built as two nested onions:
+*
+*   root-wrap onion (outer)
+*     └─ guards → input validation → procedure-wrap onion → resolver
+*        → output validation                                  (inner)
+*
+* The *inner* handler still selects one of three shapes up front:
 *
-* 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
+*   - fully sync fast-path when there are no procedure wraps and no
+*     input/output schemas;
+*   - semi-sync when validation is present but no procedure wraps;
+*   - full async onion when any procedure wrap is attached.
+*
+* The *outer* handler is only built when `rootWraps` is non-empty.
+* When no root wraps are configured we return the inner handler as
+* is — zero extra closures per request, every fast-path preserved.
+*
+* @param procedure  The procedure definition to compile.
+* @param rootWraps  Instance-level wraps (from `silgi({ wraps })`).
+*                   These wrap the *whole* inner pipeline, including
+*                   guards — that is the contract documented on
+*                   `SilgiConfig.wraps` (issue #14).
 */
 function compileProcedure(procedure, rootWraps) {
 	const middlewares = procedure.use ?? [];
@@ -198,6 +261,7 @@ function compileProcedure(procedure, rootWraps) {
 	const inputSchema = procedure.input;
 	const outputSchema = procedure.output;
 	const resolveFn = procedure.resolve;
+	const isSubscription = procedure.type === "subscription";
 	let mergedErrors = procedure.errors;
 	for (const guard of guards) if (guard.errors) mergedErrors = mergedErrors ? {
 		...mergedErrors,
@@ -205,43 +269,14 @@ function compileProcedure(procedure, rootWraps) {
 	} : guard.errors;
 	const failFn = mergedErrors ? createFail(mergedErrors) : noopFail;
 	const runGuards = selectGuardRunner(guards);
-	let innerHandler;
-	if (procedureWraps.length === 0 && !inputSchema && !outputSchema) innerHandler = (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);
+	const innerHandler = async (ctx, rawInput, signal) => {
+		if (runGuards) {
+			const guardResult = runGuards(ctx);
+			if (guardResult && isThenable(guardResult)) await guardResult;
 		}
-	};
-	else if (procedureWraps.length === 0) innerHandler = (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);
-		}
-	};
-	else innerHandler = async (ctx, rawInput, signal) => {
-		const guardResult = runGuards?.(ctx);
-		if (guardResult && isThenable(guardResult)) await guardResult;
 		let input;
 		if (inputSchema) {
-			const validated = validateSchema(inputSchema, rawInput ?? {});
+			const validated = validateInput(inputSchema, rawInput ?? {});
 			input = isThenable(validated) ? await validated : validated;
 		} else input = rawInput;
 		ctx[RAW_INPUT] = input;
@@ -262,12 +297,13 @@ function compileProcedure(procedure, rootWraps) {
 		}
 		const output = await execute();
 		if (!outputSchema) return output;
-		const validated = validateSchema(outputSchema, output);
+		if (isSubscription && output && typeof output === "object" && Symbol.asyncIterator in output) return validateIteratorOutput(output, outputSchema);
+		const validated = validateOutput(outputSchema, output);
 		return isThenable(validated) ? await validated : validated;
 	};
 	if (!hasRootWraps) return innerHandler;
 	return async (ctx, rawInput, signal) => {
-		let execute = async () => innerHandler(ctx, rawInput, signal);
+		let execute = () => Promise.resolve(innerHandler(ctx, rawInput, signal));
 		for (let i = rootWrapList.length - 1; i >= 0; i--) {
 			const wrapFn = rootWrapList[i].fn;
 			const next = execute;
@@ -310,48 +346,30 @@ function compileRouter(def) {
 	return (method, path) => findRoute(router, method, path);
 }
 /**
-* Small pool of recyclable context objects.
+* Allocate a fresh pipeline context.
 *
-* Each request allocates a context; rather than let every one become
-* GC pressure, released contexts with their properties wiped are
-* parked here and re-used on the next `createContext()` call. Capped
-* to prevent unbounded growth under burst traffic.
+* The object has a `null` prototype so user-supplied keys cannot
+* accidentally shadow `Object.prototype` members and property lookups
+* stay on the object itself.
 *
-* Externally-visible: `test/core/context-release.test.ts` relies on
-* the recycling behaviour to verify that `releaseContext` runs
-* exactly once on every request exit path.
-*/
-const CTX_POOL = [];
-const CTX_POOL_MAX = 128;
-/**
-* Acquire a context object — from the pool when one is available,
-* otherwise a fresh null-prototype object. Null-prototype keeps user
-* keys from colliding with `Object.prototype` members and avoids a
-* prototype-chain walk on every property lookup.
+* A `Symbol.dispose` slot is attached so `using ctx = createContext()`
+* runs `releaseContext(ctx)` at scope exit. Streaming responses that
+* outlive the handler scope swap that slot for a no-op via
+* `detachContext` and take ownership.
+*
+* This used to draw from a recycled pool. The pool has been removed —
+* the win was marginal, the indirection was loud, and the tests that
+* pinned "pool readback" behaviour were observing an implementation
+* detail, not a user-visible guarantee. The public API
+* (`createContext` / `detachContext` / `releaseContext` /
+* `PooledContext`) is preserved so existing call sites keep working;
+* only the internals changed.
 */
 function createContext() {
-	const ctx = CTX_POOL.length > 0 ? CTX_POOL.pop() : Object.create(null);
+	const ctx = Object.create(null);
 	ctx[Symbol.dispose] = disposeContext;
 	return ctx;
 }
-function disposeContext() {
-	releaseContext(this);
-}
-/**
-* Release a context. Called automatically at `using` scope exit and
-* explicitly by stream handlers when their stream ends.
-*
-* With the pool gone the object itself will be GC'd as soon as its
-* last reference drops, but we still wipe its properties here.
-* Callers (and tests) use "properties were cleared" as the observable
-* signal that release ran exactly once — notably
-* `test/core/context-release.test.ts` tags a context before handing
-* it off and checks the tag is gone once the 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);
-}
+function disposeContext() {}
 //#endregion
 export { compileProcedure, compileRouter, createContext };

package/dist/core/schema.d.mts

@@ -13,8 +13,21 @@ declare class ValidationError extends Error {
     issues: readonly SchemaIssue[];
   });
 }
+/**
+ * Thrown when a Standard Schema validator itself crashes (e.g. a
+ * misconstructed Zod v4 schema). Distinct from `ValidationError` —
+ * the *schema* is broken, not the value. `cause` holds the original
+ * throw. Only observable on direct `validateSchema()` calls; the
+ * pipeline rebrands these as `SilgiError` with `cause` preserved.
+ */
+declare class SchemaValidatorCrash extends Error {
+  constructor(options: {
+    message?: string;
+    cause: unknown;
+  });
+}
 /** 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 };
+export { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, SchemaValidatorCrash, ValidationError, type, validateSchema };

package/dist/core/schema.mjs

@@ -7,9 +7,27 @@ var ValidationError = class extends Error {
 		this.issues = options.issues;
 	}
 };
+/**
+* Thrown when a Standard Schema validator itself crashes (e.g. a
+* misconstructed Zod v4 schema). Distinct from `ValidationError` —
+* the *schema* is broken, not the value. `cause` holds the original
+* throw. Only observable on direct `validateSchema()` calls; the
+* pipeline rebrands these as `SilgiError` with `cause` preserved.
+*/
+var SchemaValidatorCrash = class extends Error {
+	constructor(options) {
+		super(options.message ?? "Schema validator crashed", { cause: options.cause });
+		this.name = "SchemaValidatorCrash";
+	}
+};
 /** Sync fast-path: Zod 4 validate() returns sync result — avoid Promise allocation */
 function validateSchema(schema, value) {
-	const result = schema["~standard"].validate(value);
+	let result;
+	try {
+		result = schema["~standard"].validate(value);
+	} catch (e) {
+		throw new SchemaValidatorCrash({ cause: e });
+	}
 	if (typeof result?.then !== "function") {
 		if ("issues" in result && result.issues) throw new ValidationError({ issues: result.issues });
 		return result.value;
@@ -17,6 +35,8 @@ function validateSchema(schema, value) {
 	return result.then((r) => {
 		if ("issues" in r && r.issues) throw new ValidationError({ issues: r.issues });
 		return r.value;
+	}, (e) => {
+		throw new SchemaValidatorCrash({ cause: e });
 	});
 }
 function type(...args) {
@@ -30,4 +50,4 @@ function type(...args) {
 	} };
 }
 //#endregion
-export { ValidationError, type, validateSchema };
+export { SchemaValidatorCrash, ValidationError, type, validateSchema };

package/dist/core/sse.mjs

@@ -1,4 +1,5 @@
 import { SilgiError } from "./error.mjs";
+import { AsyncIteratorClass } from "./iterator.mjs";
 //#region src/core/sse.ts
 /**
 * Server-Sent Events
@@ -60,6 +61,74 @@ function encodeEventMessage(msg) {
 	return lines.join("\n") + "\n\n";
 }
 /**
+* Incremental SSE decoder for chunked text input.
+*
+* Feed it text as it arrives from the network; it emits a full
+* `EventMessage` through the `onEvent` callback once it has seen a
+* blank-line terminator. The trailing partial event (if any) is held
+* over until the next `feed()` call — or flushed explicitly on stream
+* end via `flush()`.
+*/
+var EventDecoder = class {
+	#partial = "";
+	#onEvent;
+	constructor(onEvent) {
+		this.#onEvent = onEvent;
+	}
+	feed(chunk) {
+		this.#partial += chunk;
+		const blocks = this.#partial.split("\n\n");
+		this.#partial = blocks.pop() ?? "";
+		for (const block of blocks) {
+			if (!block.trim()) continue;
+			const msg = this.#parseBlock(block);
+			if (msg) this.#onEvent(msg);
+		}
+	}
+	/** Parse any remaining partial block. Call once at end-of-stream. */
+	flush() {
+		if (this.#partial.trim()) {
+			const msg = this.#parseBlock(this.#partial);
+			if (msg) this.#onEvent(msg);
+			this.#partial = "";
+		}
+	}
+	#parseBlock(block) {
+		const msg = {};
+		let hasContent = false;
+		for (const line of block.split("\n")) {
+			if (line.startsWith(":")) {
+				msg.comment = (msg.comment ? msg.comment + "\n" : "") + line.slice(2);
+				hasContent = true;
+				continue;
+			}
+			const colon = line.indexOf(":");
+			if (colon === -1) continue;
+			const field = line.slice(0, colon);
+			const value = line.slice(colon + 1).trimStart();
+			switch (field) {
+				case "event":
+					msg.event = value;
+					hasContent = true;
+					break;
+				case "data":
+					msg.data = (msg.data ? msg.data + "\n" : "") + value;
+					hasContent = true;
+					break;
+				case "id":
+					msg.id = value;
+					hasContent = true;
+					break;
+				case "retry":
+					msg.retry = parseInt(value, 10);
+					hasContent = true;
+					break;
+			}
+		}
+		return hasContent ? msg : null;
+	}
+};
+/**
 * Build an SSE `ReadableStream` that consumes an async iterator.
 *
 * Each yielded value becomes a `message` event; the iterator's return
@@ -146,5 +215,102 @@ function iteratorToEventStream(iterator, options = {}) {
 		}
 	}).pipeThrough(new TextEncoderStream());
 }
+/**
+* Turn an SSE `ReadableStream` back into an async iterator.
+*
+*   `message` events → yielded values (deserialized)
+*   `error`   events → thrown exceptions
+*   `done`    event  → normal iterator completion
+*
+* The decoder runs on its own microtask loop, buffering decoded events
+* into a queue that `next()` drains. The queue is needed because the
+* network read loop and the consumer run at different cadences.
+*/
+function eventStreamToIterator(stream, options = {}) {
+	const deserialize = options.deserialize ?? ((d) => JSON.parse(d));
+	const decodedStream = stream.pipeThrough(new TextDecoderStream());
+	const reader = decodedStream.getReader();
+	const events = [];
+	let wakeUp;
+	let done = false;
+	let error;
+	const decoder = new EventDecoder((msg) => {
+		events.push(msg);
+		wakeUp?.();
+		wakeUp = void 0;
+	});
+	/** Background reader — drains `stream` into `decoder` until end/err. */
+	const readLoop = async () => {
+		try {
+			while (true) {
+				const { done: readerDone, value } = await reader.read();
+				if (readerDone) {
+					decoder.flush();
+					done = true;
+					wakeUp?.();
+					return;
+				}
+				decoder.feed(value);
+			}
+		} catch (err) {
+			done = true;
+			error = err instanceof Error ? err : new Error(String(err));
+			wakeUp?.();
+		}
+	};
+	readLoop();
+	/** Wait until either a new event lands or the stream ends. */
+	const waitForEvent = () => new Promise((resolve) => {
+		wakeUp = resolve;
+	});
+	/** Translate one decoded `EventMessage` into an iterator step. */
+	const interpret = (msg) => {
+		switch (msg.event) {
+			case "message": {
+				const value = msg.data ? deserialize(msg.data) : void 0;
+				return {
+					done: false,
+					value: msg.id || msg.retry ? withEventMeta(value, {
+						id: msg.id,
+						retry: msg.retry
+					}) : value
+				};
+			}
+			case "error": {
+				const payload = msg.data ? JSON.parse(msg.data) : {};
+				throw new Error(payload.message ?? "Stream error");
+			}
+			case "done": return {
+				done: true,
+				value: void 0
+			};
+			default: return "skip";
+		}
+	};
+	return new AsyncIteratorClass(async () => {
+		while (true) {
+			if (events.length > 0) {
+				const step = interpret(events.shift());
+				if (step !== "skip") return step;
+				continue;
+			}
+			if (done) {
+				if (error) throw error;
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+			await waitForEvent();
+		}
+	}, async () => {
+		try {
+			await decodedStream.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	});
+}
 //#endregion
-export { encodeEventMessage, getEventMeta, iteratorToEventStream, withEventMeta };
+export { encodeEventMessage, eventStreamToIterator, getEventMeta, iteratorToEventStream, withEventMeta };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema } from "./core/schema.mjs";
+import { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, SchemaValidatorCrash, ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { CronRegistry, ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, createCronRegistry, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
 import { ConvertOptions, JSONSchema, SchemaConverter, SchemaRegistry, createSchemaRegistry, schemaToJsonSchema } from "./core/schema-converter.mjs";
@@ -18,4 +18,4 @@ import { mapInput } from "./map-input.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
 import { ProcedureSummary, collectProcedures, getProcedurePaths, isProcedureDef } from "./core/router-utils.mjs";
 import { LazyRouter, isLazy, lazy, resolveLazy } from "./lazy.mjs";
-export { type AnySchema, AsyncIteratorClass, type BaseContext, type CallableOptions, type ContextBridge, type ConvertOptions, type CronRegistry, type Driver, type ErrorDef, type ErrorDefItem, type EventMeta, type FailFn, type GuardDef, type GuardFn, type InferClient, type InferContextFromUse, type InferGuardOutput, type InferSchemaInput, type InferSchemaOutput, type JSONSchema, type LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureSummary, type ProcedureType, type ResolveContext, type RouterDef, type ScalarOptions, type ScheduledTaskInfo, type Schema, type SchemaConverter, type SchemaRegistry, type ServeOptions, type SilgiConfig, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, type SilgiErrorOptions, type SilgiInstance, type SilgiServer, type Storage, type StorageConfig, type StorageValue, type TaskDef, type TaskEvent, ValidationError, type WrapDef, type WrapFn, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };
+export { type AnySchema, AsyncIteratorClass, type BaseContext, type CallableOptions, type ContextBridge, type ConvertOptions, type CronRegistry, type Driver, type ErrorDef, type ErrorDefItem, type EventMeta, type FailFn, type GuardDef, type GuardFn, type InferClient, type InferContextFromUse, type InferGuardOutput, type InferSchemaInput, type InferSchemaOutput, type JSONSchema, type LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureSummary, type ProcedureType, type ResolveContext, type RouterDef, type ScalarOptions, type ScheduledTaskInfo, type Schema, type SchemaConverter, type SchemaRegistry, SchemaValidatorCrash, type ServeOptions, type SilgiConfig, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, type SilgiErrorOptions, type SilgiInstance, type SilgiServer, type Storage, type StorageConfig, type StorageValue, type TaskDef, type TaskEvent, ValidationError, type WrapDef, type WrapFn, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ValidationError, type, validateSchema } from "./core/schema.mjs";
+import { SchemaValidatorCrash, ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { collectCronTasks, createCronRegistry, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { SilgiError, isDefinedError, isSilgiError, toSilgiError } from "./core/error.mjs";
 import { collectProcedures, getProcedurePaths, isProcedureDef } from "./core/router-utils.mjs";
@@ -14,4 +14,4 @@ import { mapInput } from "./map-input.mjs";
 import { isLazy, lazy, resolveLazy } from "./lazy.mjs";
 import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { generateOpenAPI, scalarHTML } from "./scalar.mjs";
-export { AsyncIteratorClass, SilgiError, ValidationError, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };
+export { AsyncIteratorClass, SchemaValidatorCrash, SilgiError, ValidationError, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.53.1",
+  "version": "0.53.3",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [