silgi 0.52.2 → 0.53.1

package/dist/core/sse.mjs

@@ -1,36 +1,54 @@
 import { SilgiError } from "./error.mjs";
 //#region src/core/sse.ts
 /**
-* Server-Sent Events (SSE) encoding/decoding.
+* Server-Sent Events
+* -------------------
 *
-* Supports three event types:
-* - message: a yielded value
-* - error: an error event with data
-* - done: the return value (stream complete)
+* silgi subscriptions are yielded to the client as an SSE event stream.
+* This module holds the encoder, the streaming decoder (for client-side
+* consumption), and the iterator ↔ stream bridges in both directions.
 *
-* Event metadata (id, retry) can be attached to object values
-* via withEventMeta() using a WeakMap side-channel.
+* Wire vocabulary
+* ---------------
+*
+*   `event: message`  → one yielded value
+*   `event: error`    → resolver threw (sanitized for undefined errors)
+*   `event: done`     → generator returned; `data` is the return value
+*   `: <comment>`     → keepalive or boot marker; ignored by clients
+*
+* Event metadata (SSE `id` / `retry`) can be attached to any object
+* value via `withEventMeta()` and round-trips through the decoder.
+*/
+/**
+* Metadata store for SSE `id` / `retry` fields.
+*
+* This `WeakMap` is module-scoped (i.e. shared across every subscription
+* in the process). That is safe: entries are keyed by the *value object*
+* the user passes in, and GC reclaims entries as soon as those objects
+* become unreachable. A per-iterator store would add plumbing for
+* nothing — two subscriptions yielding distinct objects never collide.
 */
-const _eventMeta = /* @__PURE__ */ new WeakMap();
+const metaStore = /* @__PURE__ */ new WeakMap();
 /**
-* Attach SSE metadata (id, retry) to a value.
+* Attach SSE `id` / `retry` metadata to a yielded value.
 *
-* Only works with object values (arrays, plain objects, etc.).
-* Primitives cannot carry metadata — wrap them in an object first.
+* Only object-shaped values can carry metadata; primitives cannot be
+* keyed in the `WeakMap` and are returned unchanged. Wrap primitives
+* in a one-field object when you need metadata on them.
 */
 function withEventMeta(value, meta) {
-	if (typeof value === "object" && value !== null) _eventMeta.set(value, meta);
+	if (typeof value === "object" && value !== null) metaStore.set(value, meta);
 	return value;
 }
-/**
-* Read SSE metadata from a value (if attached).
-*/
+/** Read SSE metadata previously attached via `withEventMeta`. */
 function getEventMeta(value) {
 	if (typeof value !== "object" || value === null) return void 0;
-	return _eventMeta.get(value);
+	return metaStore.get(value);
 }
 /**
-* Encode an EventMessage into SSE wire format.
+* Serialize an `EventMessage` into SSE wire format (one event terminated
+* by a blank line). Multi-line `data` and `comment` are split across
+* multiple fields per the SSE spec so embedded newlines survive.
 */
 function encodeEventMessage(msg) {
 	const lines = [];
@@ -42,15 +60,60 @@ function encodeEventMessage(msg) {
 	return lines.join("\n") + "\n\n";
 }
 /**
-* Convert an async iterator to an SSE ReadableStream.
-* Each yielded value becomes a "message" event.
-* Errors become "error" events. Return value becomes "done".
+* Build an SSE `ReadableStream` that consumes an async iterator.
+*
+* Each yielded value becomes a `message` event; the iterator's return
+* value becomes the `done` event; a thrown error becomes an `error`
+* event (and only the message is exposed when the error is not a
+* `SilgiError` flagged `defined` — undefined errors must not leak
+* internals).
+*
+* A comment-only `keepalive` event is emitted every `keepAliveMs` so
+* intermediaries (proxies, load balancers) do not close the connection
+* while the resolver is quiet.
 */
 function iteratorToEventStream(iterator, options = {}) {
 	const serialize = options.serialize ?? JSON.stringify;
 	const keepAliveMs = options.keepAliveMs ?? 3e4;
 	let keepAliveTimer;
 	let cancelled = false;
+	/** Build the wire form of one yielded value, carrying any attached meta. */
+	const encodeValue = (value) => {
+		const meta = getEventMeta(value);
+		return encodeEventMessage({
+			event: "message",
+			data: serialize(value),
+			id: meta?.id,
+			retry: meta?.retry
+		});
+	};
+	/** Build the wire form of the terminal `done` event, if a return value was yielded. */
+	const encodeDone = (value) => {
+		return encodeEventMessage({
+			event: "done",
+			data: value !== void 0 ? serialize(value) : void 0
+		});
+	};
+	/**
+	* Build the wire form of an `error` event.
+	*
+	* Only `SilgiError` with `defined === true` surfaces its `code` and
+	* `message` to the wire — the author opted into publishing those by
+	* declaring the error. Everything else collapses to a generic 500
+	* shape so we do not leak stack traces or internal codes.
+	*/
+	const encodeError = (err) => {
+		return encodeEventMessage({
+			event: "error",
+			data: err instanceof SilgiError && err.defined ? JSON.stringify({
+				message: err.message,
+				code: err.code
+			}) : JSON.stringify({
+				message: "Internal server error",
+				code: "INTERNAL_SERVER_ERROR"
+			})
+		});
+	};
 	return new ReadableStream({
 		start(controller) {
 			if (options.initialComment !== void 0) controller.enqueue(encodeEventMessage({ comment: options.initialComment }));
@@ -64,38 +127,15 @@ function iteratorToEventStream(iterator, options = {}) {
 				if (cancelled) return;
 				if (result.done) {
 					clearInterval(keepAliveTimer);
-					const data = result.value !== void 0 ? serialize(result.value) : void 0;
-					controller.enqueue(encodeEventMessage({
-						event: "done",
-						data
-					}));
+					controller.enqueue(encodeDone(result.value));
 					controller.close();
 					return;
 				}
-				const meta = getEventMeta(result.value);
-				const msg = {
-					event: "message",
-					data: serialize(result.value),
-					id: meta?.id,
-					retry: meta?.retry
-				};
-				controller.enqueue(encodeEventMessage(msg));
+				controller.enqueue(encodeValue(result.value));
 			} catch (error) {
 				clearInterval(keepAliveTimer);
 				if (cancelled) return;
-				let errorData;
-				if (error instanceof SilgiError && error.defined) errorData = JSON.stringify({
-					message: error.message,
-					code: error.code
-				});
-				else errorData = JSON.stringify({
-					message: "Internal server error",
-					code: "INTERNAL_SERVER_ERROR"
-				});
-				controller.enqueue(encodeEventMessage({
-					event: "error",
-					data: errorData
-				}));
+				controller.enqueue(encodeError(error));
 				controller.close();
 			}
 		},

package/dist/core/task.d.mts

@@ -23,7 +23,10 @@ interface TaskDef<TInput = unknown, TOutput = unknown> {
   } | null;
   readonly meta: null;
   readonly _contextFactory: (() => unknown | Promise<unknown>) | null;
-  /** Dispatch the task. Pass ctx from a procedure to auto-record a trace span. */
+  /**
+   * Dispatch the task. Pass the *parent* request's `ctx` as the second
+   * argument to fold the dispatch into that request's trace span.
+   */
   dispatch: undefined extends TInput ? (input?: TInput, ctx?: Record<string, unknown>) => Promise<TOutput> : (input: TInput, ctx?: Record<string, unknown>) => Promise<TOutput>;
 }
 type TaskCompleteCallback = (entry: {
@@ -39,14 +42,15 @@ type TaskCompleteCallback = (entry: {
 }) => void;
 declare function setTaskAnalytics(cb: TaskCompleteCallback | null): void;
 declare function runTask<TInput, TOutput>(task: TaskDef<TInput, TOutput>, ...args: undefined extends TInput ? [input?: TInput] : [input: TInput]): Promise<TOutput>;
+/**
+ * Walk a router tree and collect every task that has a `cron` field set.
+ * Nested namespaces are recursed into; we stop at any node already
+ * tagged as a task so a task's internal structure is never inspected.
+ */
 declare function collectCronTasks(def: Record<string, unknown>): Array<{
   cron: string;
   task: TaskDef<any, any>;
 }>;
-declare function startCronJobs(cronTasks: Array<{
-  cron: string;
-  task: TaskDef<any, any>;
-}>): Promise<void>;
 interface ScheduledTaskInfo {
   name: string;
   cron: string;
@@ -56,7 +60,31 @@ interface ScheduledTaskInfo {
   runs: number;
   errors: number;
 }
-declare function getScheduledTasks(): ScheduledTaskInfo[];
-declare function stopCronJobs(): void;
+interface CronRegistry {
+  start: (cronTasks: Array<{
+    cron: string;
+    task: TaskDef<any, any>;
+  }>) => Promise<void>;
+  stop: () => void;
+  list: () => ScheduledTaskInfo[];
+}
+/**
+ * Create an isolated cron registry.
+ *
+ * Each silgi instance owns one, so `server.close()` on instance A
+ * never stops instance B's jobs and `list()` never returns jobs from
+ * another instance. The module-default registry below keeps the
+ * legacy top-level exports working.
+ */
+declare function createCronRegistry(): CronRegistry;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const startCronJobs: (cronTasks: Array<{
+  cron: string;
+  task: TaskDef<any, any>;
+}>) => Promise<void>;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const stopCronJobs: () => void;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const getScheduledTasks: () => ScheduledTaskInfo[];
 //#endregion
-export { ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };
+export { CronRegistry, ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, createCronRegistry, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/task.mjs

@@ -1,19 +1,104 @@
 import { validateSchema } from "./schema.mjs";
 //#region src/core/task.ts
 /**
-* Task API — type-safe background tasks built on the procedure builder.
+* Background tasks
+* ------------------
+*
+* A *task* is a procedure with two extra capabilities:
+*
+*   1. Programmatic `dispatch(input)` — call it directly, outside the
+*      HTTP pipeline. Used for async work (send-email, rebuild-index)
+*      and as the callback target for cron schedules.
+*   2. Optional `cron` spec — when set, the task is auto-registered
+*      with a `croner` job at `serve()` time.
+*
+* Tasks are built via the procedure builder:
 *
-* Tasks are procedures with dispatch + cron capabilities:
 *   s.$use(auth).$input(schema).$task({ name: 'send-email', resolve })
+*
+* Dispatch runs through the same root-wrap onion as the HTTP pipeline
+* so tenant scoping, trace propagation, and similar cross-cutting
+* concerns apply uniformly. When no root wraps are configured the
+* dispatch path reduces to a direct `await resolveFn(…)`.
 */
-let _onTaskComplete = null;
+/**
+* Module-global sink for task completion events. This is shared across
+* every silgi instance in the process — analytics is currently wired
+* through the process-default cron registry for the same reason.
+* Per-instance analytics is a future refactor; `setTaskAnalytics(null)`
+* detaches the sink.
+*/
+let onTaskComplete = null;
 function setTaskAnalytics(cb) {
-	_onTaskComplete = cb;
+	onTaskComplete = cb;
 }
-function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFactory) {
+/** Round a millisecond duration to two decimal places — matches dashboard display. */
+const round2 = (ms) => Math.round(ms * 100) / 100;
+/**
+* Wrap `run` in the root-wrap onion. Root wraps are outermost-first, so
+* we fold from the end of the list: the last wrap wraps `run`, the one
+* before wraps that, and so on. When there are no wraps we just return
+* `run` unchanged — zero onion overhead.
+*
+* Same shape as `composeWraps` in `compile.ts`; kept here privately to
+* avoid a core → compile import cycle.
+*/
+function applyRootWraps(ctx, wraps, run) {
+	let chain = run;
+	for (let i = wraps.length - 1; i >= 0; i--) {
+		const wrap = wraps[i];
+		const next = chain;
+		chain = () => Promise.resolve(wrap.fn(ctx, next));
+	}
+	return chain();
+}
+/**
+* Lazy-loaded `RequestTrace` constructor. The analytics module is
+* optional — missing it must not break task dispatch — so we attempt
+* the import once and cache the outcome. `null` means "we've tried;
+* analytics is not available in this build".
+*/
+let requestTraceCtor;
+async function getRequestTrace() {
+	if (requestTraceCtor !== void 0) return requestTraceCtor;
+	try {
+		requestTraceCtor = (await import("../plugins/analytics.mjs")).RequestTrace;
+	} catch {
+		requestTraceCtor = null;
+	}
+	return requestTraceCtor;
+}
+/** Record this dispatch as a span on the parent request's trace, if one exists. */
+function recordParentSpan(parentTrace, name, spanStart, err) {
+	if (!parentTrace) return;
+	const span = {
+		name: `task:${name}`,
+		kind: "queue",
+		durationMs: round2(performance.now() - spanStart),
+		startOffsetMs: round2(spanStart - parentTrace.t0),
+		detail: `dispatch ${name}`
+	};
+	if (err !== void 0) span.error = err instanceof Error ? err.message : String(err);
+	parentTrace.spans.push(span);
+}
+/**
+* Build a `TaskDef` from the procedure builder's `.$task()` configuration.
+*
+* @param rootWrapsGetter A *live* getter so a task constructed before
+*   `s.router()` stamps wraps still picks them up at dispatch time. The
+*   silgi instance threads a closure over its own rootWraps reference.
+*   Pass `null` when no wraps are configured — dispatch then skips the
+*   onion entirely.
+*/
+function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFactory, rootWrapsGetter = null) {
 	const { name, cron = null, description } = config;
 	if (!name) throw new TypeError("Task name is required");
-	const taskResolve = async (opts) => {
+	/**
+	* Resolver called by the *HTTP* pipeline when the task is reachable
+	* through the router tree. `ctx` already carries everything the
+	* pipeline set up (base context, guards, trace), so we just forward.
+	*/
+	const pipelineResolve = async (opts) => {
 		return resolveFn({
 			input: opts.input,
 			ctx: opts.ctx,
@@ -21,61 +106,52 @@ function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFac
 			scheduledTime: void 0
 		});
 	};
+	/**
+	* Programmatic dispatch — the one users call from another procedure
+	* or a cron callback. Validates input, builds its own context, runs
+	* the root-wrap onion around the resolver, records analytics.
+	*/
 	const dispatch = async (rawInput, parentCtx) => {
 		const input = inputSchema ? await validateSchema(inputSchema, rawInput) : rawInput;
 		const ctx = contextFactory ? await contextFactory() : {};
 		const parentTrace = parentCtx?.trace;
 		const spanStart = parentTrace ? performance.now() : 0;
-		let reqTrace = null;
-		try {
-			const { RequestTrace } = await import("../plugins/analytics.mjs");
-			reqTrace = new RequestTrace();
-			ctx.trace = reqTrace;
-		} catch {}
+		const RequestTrace = await getRequestTrace();
+		const selfTrace = RequestTrace ? new RequestTrace() : null;
+		if (selfTrace) ctx.trace = selfTrace;
+		const runResolver = () => Promise.resolve(resolveFn({
+			input,
+			ctx,
+			name,
+			scheduledTime: void 0
+		}));
+		const wraps = rootWrapsGetter?.() ?? null;
 		const t0 = performance.now();
 		try {
-			const output = await resolveFn({
-				input,
-				ctx,
-				name,
-				scheduledTime: void 0
-			});
-			if (parentTrace) parentTrace.spans.push({
-				name: `task:${name}`,
-				kind: "queue",
-				durationMs: Math.round((performance.now() - spanStart) * 100) / 100,
-				startOffsetMs: Math.round((spanStart - parentTrace.t0) * 100) / 100,
-				detail: `dispatch ${name}`
-			});
-			if (_onTaskComplete) _onTaskComplete({
+			const output = wraps && wraps.length > 0 ? await applyRootWraps(ctx, wraps, runResolver) : await runResolver();
+			recordParentSpan(parentTrace, name, spanStart);
+			onTaskComplete?.({
 				taskName: name,
 				trigger: "dispatch",
 				timestamp: Date.now(),
-				durationMs: Math.round((performance.now() - t0) * 100) / 100,
+				durationMs: round2(performance.now() - t0),
 				status: "success",
 				input,
 				output,
-				spans: reqTrace?.spans
+				spans: selfTrace?.spans
 			});
 			return output;
 		} catch (err) {
-			if (parentTrace) parentTrace.spans.push({
-				name: `task:${name}`,
-				kind: "queue",
-				durationMs: Math.round((performance.now() - spanStart) * 100) / 100,
-				startOffsetMs: Math.round((spanStart - parentTrace.t0) * 100) / 100,
-				detail: `dispatch ${name}`,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			if (_onTaskComplete) _onTaskComplete({
+			recordParentSpan(parentTrace, name, spanStart, err);
+			onTaskComplete?.({
 				taskName: name,
 				trigger: "dispatch",
 				timestamp: Date.now(),
-				durationMs: Math.round((performance.now() - t0) * 100) / 100,
+				durationMs: round2(performance.now() - t0),
 				status: "error",
 				error: err instanceof Error ? err.message : String(err),
 				input,
-				spans: reqTrace?.spans
+				spans: selfTrace?.spans
 			});
 			throw err;
 		}
@@ -88,7 +164,7 @@ function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFac
 		output: null,
 		errors: null,
 		use,
-		resolve: taskResolve,
+		resolve: pipelineResolve,
 		route: description ? {
 			summary: description,
 			tags: ["Tasks"]
@@ -98,68 +174,112 @@ function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFac
 		dispatch
 	};
 }
-const _running = /* @__PURE__ */ new Map();
+/**
+* In-flight dispatches keyed by task object.
+*
+* `runTask` coalesces concurrent calls so two callers asking for the
+* same task at once share a single execution. Useful for idempotent
+* background jobs that can be kicked off from multiple places.
+*/
+const running = /* @__PURE__ */ new Map();
 async function runTask(task, ...args) {
-	const existing = _running.get(task);
+	const existing = running.get(task);
 	if (existing) return existing;
 	const promise = task.dispatch(args[0]);
-	_running.set(task, promise);
+	running.set(task, promise);
 	try {
 		return await promise;
 	} finally {
-		_running.delete(task);
+		running.delete(task);
 	}
 }
+/**
+* Walk a router tree and collect every task that has a `cron` field set.
+* Nested namespaces are recursed into; we stop at any node already
+* tagged as a task so a task's internal structure is never inspected.
+*/
 function collectCronTasks(def) {
 	const result = [];
-	for (const value of Object.values(def)) if (value && typeof value === "object") {
-		if ("_tag" in value && value._tag === "task" && value.cron) result.push({
-			cron: value.cron,
-			task: value
-		});
-		else if (!("_tag" in value)) result.push(...collectCronTasks(value));
-	}
-	return result;
-}
-let _cronEntries = [];
-async function startCronJobs(cronTasks) {
-	if (cronTasks.length === 0) return;
-	const { Cron } = await import("croner");
-	for (const { cron, task } of cronTasks) {
-		const entry = {
-			name: task.route?.summary || cron,
-			cron,
-			description: task.route?.summary,
-			job: null,
-			lastRun: null,
-			runs: 0,
-			errors: 0
-		};
-		entry.job = new Cron(cron, async () => {
-			entry.lastRun = Date.now();
-			entry.runs++;
-			task.dispatch(void 0).catch((err) => {
-				entry.errors++;
-				console.error(`[silgi] Cron task failed:`, err instanceof Error ? err.message : err);
+	for (const value of Object.values(def)) {
+		if (!value || typeof value !== "object") continue;
+		if ("_tag" in value && value._tag === "task") {
+			const task = value;
+			if (task.cron) result.push({
+				cron: task.cron,
+				task
 			});
-		});
-		_cronEntries.push(entry);
+		} else if (!("_tag" in value)) result.push(...collectCronTasks(value));
 	}
+	return result;
 }
-function getScheduledTasks() {
-	return _cronEntries.map((e) => ({
-		name: e.name,
-		cron: e.cron,
-		description: e.description,
-		nextRun: e.job.nextRun()?.getTime() ?? null,
-		lastRun: e.lastRun,
-		runs: e.runs,
-		errors: e.errors
-	}));
-}
-function stopCronJobs() {
-	for (const e of _cronEntries) e.job.stop();
-	_cronEntries = [];
+/**
+* Create an isolated cron registry.
+*
+* Each silgi instance owns one, so `server.close()` on instance A
+* never stops instance B's jobs and `list()` never returns jobs from
+* another instance. The module-default registry below keeps the
+* legacy top-level exports working.
+*/
+function createCronRegistry() {
+	const entries = [];
+	return {
+		async start(cronTasks) {
+			if (cronTasks.length === 0) return;
+			const { Cron } = await import("croner");
+			for (const { cron, task } of cronTasks) {
+				const entry = {
+					name: task.route?.summary || cron,
+					cron,
+					description: task.route?.summary,
+					job: null,
+					lastRun: null,
+					runs: 0,
+					errors: 0
+				};
+				entry.job = new Cron(cron, async () => {
+					entry.lastRun = Date.now();
+					entry.runs++;
+					task.dispatch(void 0).catch((err) => {
+						entry.errors++;
+						console.error(`[silgi] Cron task failed:`, err instanceof Error ? err.message : err);
+					});
+				});
+				entries.push(entry);
+			}
+		},
+		stop() {
+			for (const entry of entries) entry.job.stop();
+			entries.length = 0;
+		},
+		list() {
+			return entries.map((entry) => ({
+				name: entry.name,
+				cron: entry.cron,
+				description: entry.description,
+				nextRun: entry.job.nextRun()?.getTime() ?? null,
+				lastRun: entry.lastRun,
+				runs: entry.runs,
+				errors: entry.errors
+			}));
+		}
+	};
 }
+/**
+* Process-default cron registry.
+*
+* @deprecated
+* Shared state. Prefer {@link createCronRegistry} and give each silgi
+* instance its own. The module-default registry is retained so
+* existing imports of `startCronJobs` / `stopCronJobs` /
+* `getScheduledTasks` keep working; a future major will remove these
+* top-level re-exports.
+*/
+const defaultRegistry = createCronRegistry();
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const startCronJobs = defaultRegistry.start;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const stopCronJobs = defaultRegistry.stop;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const getScheduledTasks = defaultRegistry.list;
 //#endregion
-export { collectCronTasks, createTaskFromProcedure, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };
+export { collectCronTasks, createCronRegistry, createTaskFromProcedure, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/url.mjs

@@ -10,9 +10,27 @@
 * Returns the path portion without query string.
 *
 * Uses manual indexOf — no `new URL()` overhead.
+*
+* @remarks
+* Handles both absolute URLs (`http://host/path?q`) and bare paths
+* (`/path?q`). The latter shape is produced by adapters that strip the
+* origin before calling the handler, and by test harnesses constructing
+* synthetic requests. Without the bare-path branch, a missing `//`
+* caused `indexOf('//') + 2 = 1` and `indexOf('/', 1)` returned a bogus
+* offset that silently produced the wrong path.
 */
 function parseUrlPath(url) {
-	const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+	if (url.length > 0 && url.charCodeAt(0) === 47) {
+		const qMark = url.indexOf("?");
+		return qMark === -1 ? url : url.slice(0, qMark);
+	}
+	const schemeEnd = url.indexOf("//");
+	if (schemeEnd === -1) {
+		const qMark = url.indexOf("?");
+		return qMark === -1 ? url : url.slice(0, qMark);
+	}
+	const pathStart = url.indexOf("/", schemeEnd + 2);
+	if (pathStart === -1) return "/";
 	const qMark = url.indexOf("?", pathStart);
 	return qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
 }

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema } from "./core/schema.mjs";
-import { ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.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";
 import { ScalarOptions, generateOpenAPI, scalarHTML } from "./scalar.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 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, 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, 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,5 +1,5 @@
 import { ValidationError, type, validateSchema } from "./core/schema.mjs";
-import { collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.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";
 import { compileProcedure, compileRouter, createContext } from "./compile.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, 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, 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 };