silgi 0.43.28 → 0.50.0

package/dist/core/serve.mjs

@@ -0,0 +1,76 @@
+import { createFetchHandler } from "./handler.mjs";
+import { serve } from "srvx";
+//#region src/core/serve.ts
+async function createServeHandler(routerDef, contextFactory, hooks, options) {
+	const port = options?.port ?? 3e3;
+	const hostname = options?.hostname ?? "127.0.0.1";
+	let handler = createFetchHandler(routerDef, contextFactory, hooks);
+	if (options?.scalar) {
+		const { wrapWithScalar } = await import("../scalar.mjs");
+		const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
+		handler = wrapWithScalar(handler, routerDef, scalarOpts);
+	}
+	if (options?.analytics) {
+		const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
+		const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
+		handler = wrapWithAnalytics(handler, analyticsOpts);
+	}
+	const shutdownOpt = options?.gracefulShutdown ?? true;
+	let gracefulShutdown;
+	if (typeof shutdownOpt === "object") gracefulShutdown = {
+		gracefulTimeout: shutdownOpt.timeout,
+		forceTimeout: shutdownOpt.forceTimeout
+	};
+	else gracefulShutdown = shutdownOpt;
+	const server = await serve({
+		port,
+		hostname,
+		fetch: handler,
+		gracefulShutdown,
+		silent: true,
+		...options?.http2 && { tls: {
+			cert: options.http2.cert,
+			key: options.http2.key
+		} }
+	});
+	await server.ready();
+	let resolvedPort = port;
+	if (server.node?.server) {
+		const addr = server.node.server.address();
+		if (addr && typeof addr === "object") resolvedPort = addr.port;
+	}
+	const protocol = options?.http2 ? "https" : "http";
+	const rawUrl = server.url || `${protocol}://${hostname}:${resolvedPort}`;
+	const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
+	if (options?.ws && server.node?.server) {
+		const { attachWebSocket } = await import("../ws.mjs");
+		const wsOpts = typeof options.ws === "object" ? options.ws : void 0;
+		await attachWebSocket(server.node.server, routerDef, wsOpts);
+	}
+	console.log(`\nSilgi server running at ${url}`);
+	if (options?.http2) console.log(`  HTTP/2 enabled (with HTTP/1.1 fallback)`);
+	if (options?.ws) console.log(`  WebSocket RPC at ws://${hostname}:${resolvedPort}`);
+	if (options?.scalar) console.log(`  Scalar API Reference at ${url}/api/reference`);
+	if (options?.analytics) console.log(`  Analytics dashboard at ${url}/api/analytics`);
+	console.log();
+	await hooks.callHook("serve:start", {
+		url,
+		port: resolvedPort,
+		hostname
+	});
+	return {
+		url,
+		port: resolvedPort,
+		hostname,
+		async close(forceCloseConnections = false) {
+			await server.close(forceCloseConnections);
+			await hooks.callHook("serve:stop", {
+				url,
+				port: resolvedPort,
+				hostname
+			});
+		}
+	};
+}
+//#endregion
+export { createServeHandler };

package/dist/core/sse.d.mts

@@ -0,0 +1,18 @@
+//#region src/core/sse.d.ts
+interface EventMeta {
+  id?: string;
+  retry?: number;
+}
+/**
+ * Attach SSE metadata (id, retry) to a value.
+ *
+ * Only works with object values (arrays, plain objects, etc.).
+ * Primitives cannot carry metadata — wrap them in an object first.
+ */
+declare function withEventMeta<T>(value: T, meta: EventMeta): T;
+/**
+ * Read SSE metadata from a value (if attached).
+ */
+declare function getEventMeta(value: unknown): EventMeta | undefined;
+//#endregion
+export { EventMeta, getEventMeta, withEventMeta };

package/dist/core/sse.mjs

@@ -0,0 +1,110 @@
+import { SilgiError } from "./error.mjs";
+//#region src/core/sse.ts
+/**
+* Server-Sent Events (SSE) encoding/decoding.
+*
+* Supports three event types:
+* - message: a yielded value
+* - error: an error event with data
+* - done: the return value (stream complete)
+*
+* Event metadata (id, retry) can be attached to object values
+* via withEventMeta() using a WeakMap side-channel.
+*/
+const _eventMeta = /* @__PURE__ */ new WeakMap();
+/**
+* Attach SSE metadata (id, retry) to a value.
+*
+* Only works with object values (arrays, plain objects, etc.).
+* Primitives cannot carry metadata — wrap them in an object first.
+*/
+function withEventMeta(value, meta) {
+	if (typeof value === "object" && value !== null) _eventMeta.set(value, meta);
+	return value;
+}
+/**
+* Read SSE metadata from a value (if attached).
+*/
+function getEventMeta(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return _eventMeta.get(value);
+}
+/**
+* Encode an EventMessage into SSE wire format.
+*/
+function encodeEventMessage(msg) {
+	const lines = [];
+	if (msg.comment !== void 0) for (const line of msg.comment.split("\n")) lines.push(`: ${line}`);
+	if (msg.event !== void 0) lines.push(`event: ${msg.event}`);
+	if (msg.id !== void 0) lines.push(`id: ${msg.id}`);
+	if (msg.retry !== void 0) lines.push(`retry: ${msg.retry}`);
+	if (msg.data !== void 0) for (const line of msg.data.split("\n")) lines.push(`data: ${line}`);
+	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".
+*/
+function iteratorToEventStream(iterator, options = {}) {
+	const serialize = options.serialize ?? JSON.stringify;
+	const keepAliveMs = options.keepAliveMs ?? 3e4;
+	let keepAliveTimer;
+	let cancelled = false;
+	return new ReadableStream({
+		start(controller) {
+			if (options.initialComment !== void 0) controller.enqueue(encodeEventMessage({ comment: options.initialComment }));
+			keepAliveTimer = setInterval(() => {
+				if (!cancelled) controller.enqueue(encodeEventMessage({ comment: "keepalive" }));
+			}, keepAliveMs);
+		},
+		async pull(controller) {
+			try {
+				const result = await iterator.next();
+				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.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));
+			} 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.close();
+			}
+		},
+		async cancel() {
+			cancelled = true;
+			clearInterval(keepAliveTimer);
+			await iterator.return?.();
+		}
+	}).pipeThrough(new TextEncoderStream());
+}
+//#endregion
+export { encodeEventMessage, getEventMeta, iteratorToEventStream, withEventMeta };

package/dist/core/storage.d.mts

@@ -1,7 +1,20 @@
-import { Storage } from "unstorage";
-import { Silgi, SilgiStorageBase } from "silgi/types";
+import { Driver, Storage, StorageValue } from "unstorage";
 
 //#region src/core/storage.d.ts
-declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage["mount"]>[1]) => T;
+/** Storage config — map of mount path → driver instance, or a pre-built Storage */
+type StorageConfig = Storage | Record<string, Driver>;
+/**
+ * Get the storage instance with optional prefix.
+ * Creates default storage with `data` and `cache` mounts on first call.
+ */
+declare function useStorage<T extends StorageValue = StorageValue>(base?: string): Storage<T>;
+/**
+ * Initialize storage from config — call once at startup.
+ */
+declare function initStorage(config?: StorageConfig): Storage;
+/**
+ * Reset storage — for testing.
+ */
+declare function resetStorage(): void;
 //#endregion
-export { storageMount as storageMount$1 };
+export { type Driver, type Storage, StorageConfig, type StorageValue, initStorage, resetStorage, useStorage };

package/dist/core/storage.mjs

@@ -1,15 +1,62 @@
-import { useSilgi } from "./unctx.mjs";
-
+import { createStorage, prefixStorage } from "unstorage";
+import memoryDriver from "unstorage/drivers/memory";
 //#region src/core/storage.ts
-function storageMount(silgi) {
-	const _silgi = silgi || useSilgi();
-	return (base, driver) => {
-		const existingStorage = _silgi.storage.getMount(base);
-		if (existingStorage) return existingStorage.driver;
-		const storage = _silgi.storage.mount(base, driver);
-		return storage;
-	};
-}
-
+/**
+* Storage — Nitro-style global storage with unstorage.
+*
+* Two default mounts are created automatically:
+* - `data`  — persistent data (analytics, sessions, etc.)
+* - `cache` — ephemeral cache (query results, SWR, etc.)
+*
+* Both use in-memory drivers by default. Override with custom drivers:
+*
+* ```ts
+* import redisDriver from 'unstorage/drivers/redis'
+* import fsDriver from 'unstorage/drivers/fs'
+*
+* const s = silgi({
+*   context: () => ({}),
+*   storage: {
+*     data: fsDriver({ base: '.data' }),
+*     cache: redisDriver({ url: 'redis://localhost' }),
+*   },
+* })
+*
+* // In procedures:
+* const data = useStorage('data')
+* const cache = useStorage('cache')
+* ```
+*/
+function _initStorage(config) {
+	if (config && "getItem" in config) return config;
+	const storage = createStorage({});
+	const configKeys = config ? new Set(Object.keys(config)) : null;
+	if (!configKeys?.has("data")) storage.mount("data", memoryDriver());
+	if (!configKeys?.has("cache")) storage.mount("cache", memoryDriver());
+	if (config) for (const [path, driver] of Object.entries(config)) storage.mount(path, driver);
+	return storage;
+}
+/**
+* Get the storage instance with optional prefix.
+* Creates default storage with `data` and `cache` mounts on first call.
+*/
+function useStorage(base = "") {
+	const storage = useStorage._storage ??= _initStorage();
+	return base ? prefixStorage(storage, base) : storage;
+}
+/**
+* Initialize storage from config — call once at startup.
+*/
+function initStorage(config) {
+	const storage = _initStorage(config);
+	useStorage._storage = storage;
+	return storage;
+}
+/**
+* Reset storage — for testing.
+*/
+function resetStorage() {
+	useStorage._storage = void 0;
+}
 //#endregion
-export { storageMount };
+export { initStorage, resetStorage, useStorage };

package/dist/core/task.d.mts

@@ -0,0 +1,62 @@
+import { AnySchema } from "./schema.mjs";
+import { MiddlewareDef } from "../types.mjs";
+
+//#region src/core/task.d.ts
+interface TaskEvent<TInput = unknown, TCtx = unknown> {
+  input: TInput;
+  ctx: TCtx;
+  name: string;
+  scheduledTime?: number;
+}
+interface TaskDef<TInput = unknown, TOutput = unknown> {
+  readonly _tag: 'task';
+  readonly type: 'mutation';
+  readonly cron: string | null;
+  readonly input: AnySchema | null;
+  readonly output: null;
+  readonly errors: null;
+  readonly use: readonly MiddlewareDef[] | null;
+  readonly resolve: Function;
+  readonly route: {
+    summary?: string;
+    tags?: string[];
+  } | 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: undefined extends TInput ? (input?: TInput, ctx?: Record<string, unknown>) => Promise<TOutput> : (input: TInput, ctx?: Record<string, unknown>) => Promise<TOutput>;
+}
+type TaskCompleteCallback = (entry: {
+  taskName: string;
+  trigger: 'dispatch' | 'cron' | 'http';
+  timestamp: number;
+  durationMs: number;
+  status: 'success' | 'error';
+  error?: string;
+  input?: unknown;
+  output?: unknown;
+  spans?: unknown[];
+}) => 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>;
+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;
+  description?: string;
+  nextRun: number | null;
+  lastRun: number | null;
+  runs: number;
+  errors: number;
+}
+declare function getScheduledTasks(): ScheduledTaskInfo[];
+declare function stopCronJobs(): void;
+//#endregion
+export { ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/task.mjs

@@ -0,0 +1,165 @@
+import { validateSchema } from "./schema.mjs";
+//#region src/core/task.ts
+/**
+* Task API — type-safe background tasks built on the procedure builder.
+*
+* Tasks are procedures with dispatch + cron capabilities:
+*   s.$use(auth).$input(schema).$task({ name: 'send-email', resolve })
+*/
+let _onTaskComplete = null;
+function setTaskAnalytics(cb) {
+	_onTaskComplete = cb;
+}
+function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFactory) {
+	const { name, cron = null, description } = config;
+	if (!name) throw new TypeError("Task name is required");
+	const taskResolve = async (opts) => {
+		return resolveFn({
+			input: opts.input,
+			ctx: opts.ctx,
+			name,
+			scheduledTime: void 0
+		});
+	};
+	const dispatch = async (rawInput, parentCtx) => {
+		const input = inputSchema ? await validateSchema(inputSchema, rawInput) : rawInput;
+		const ctx = contextFactory ? await contextFactory() : {};
+		const parentTrace = parentCtx?.__analyticsTrace;
+		const spanStart = parentTrace ? performance.now() : 0;
+		let reqTrace = null;
+		try {
+			const { RequestTrace } = await import("../plugins/analytics.mjs");
+			reqTrace = new RequestTrace();
+			ctx.__analyticsTrace = reqTrace;
+		} catch {}
+		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({
+				taskName: name,
+				trigger: "dispatch",
+				timestamp: Date.now(),
+				durationMs: Math.round((performance.now() - t0) * 100) / 100,
+				status: "success",
+				input,
+				output,
+				spans: reqTrace?.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({
+				taskName: name,
+				trigger: "dispatch",
+				timestamp: Date.now(),
+				durationMs: Math.round((performance.now() - t0) * 100) / 100,
+				status: "error",
+				error: err instanceof Error ? err.message : String(err),
+				input,
+				spans: reqTrace?.spans
+			});
+			throw err;
+		}
+	};
+	return {
+		_tag: "task",
+		type: "mutation",
+		cron,
+		input: inputSchema,
+		output: null,
+		errors: null,
+		use,
+		resolve: taskResolve,
+		route: description ? {
+			summary: description,
+			tags: ["Tasks"]
+		} : null,
+		meta: null,
+		_contextFactory: contextFactory,
+		dispatch
+	};
+}
+const _running = /* @__PURE__ */ new Map();
+async function runTask(task, ...args) {
+	const existing = _running.get(task);
+	if (existing) return existing;
+	const promise = task.dispatch(args[0]);
+	_running.set(task, promise);
+	try {
+		return await promise;
+	} finally {
+		_running.delete(task);
+	}
+}
+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);
+			});
+		});
+		_cronEntries.push(entry);
+	}
+}
+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 = [];
+}
+//#endregion
+export { collectCronTasks, createTaskFromProcedure, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/trace-map.d.mts

@@ -0,0 +1,13 @@
+//#region src/core/trace-map.d.ts
+/**
+ * Shared WeakMap for passing analytics traces between handler and analytics plugin.
+ *
+ * Lives in core/ so the dependency direction is correct:
+ *   core/handler.ts → core/trace-map.ts ← plugins/analytics.ts
+ *
+ * The WeakMap maps Request → RequestTrace, allowing the handler to inject
+ * trace data into context without importing the analytics plugin.
+ */
+declare const analyticsTraceMap: WeakMap<Request, unknown>;
+//#endregion
+export { analyticsTraceMap };

package/dist/core/trace-map.mjs

@@ -0,0 +1,13 @@
+//#region src/core/trace-map.ts
+/**
+* Shared WeakMap for passing analytics traces between handler and analytics plugin.
+*
+* Lives in core/ so the dependency direction is correct:
+*   core/handler.ts → core/trace-map.ts ← plugins/analytics.ts
+*
+* The WeakMap maps Request → RequestTrace, allowing the handler to inject
+* trace data into context without importing the analytics plugin.
+*/
+const analyticsTraceMap = /* @__PURE__ */ new WeakMap();
+//#endregion
+export { analyticsTraceMap };

package/dist/core/url.mjs

@@ -0,0 +1,28 @@
+//#region src/core/url.ts
+/**
+* URL path extraction — fast, no URL constructor.
+*
+* Shared by handler.ts and analytics to avoid duplicating
+* the manual indexOf-based path parsing logic.
+*/
+/**
+* Extract the full path (with leading slash) from a URL string.
+* Returns the path portion without query string.
+*
+* Uses manual indexOf — no `new URL()` overhead.
+*/
+function parseUrlPath(url) {
+	const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+	const qMark = url.indexOf("?", pathStart);
+	return qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
+}
+/**
+* Extract pathname without leading slash from a URL string.
+* Used for route matching where paths are slash-stripped.
+*/
+function parseUrlPathname(url) {
+	const fullPath = parseUrlPath(url);
+	return fullPath.length > 1 ? fullPath.slice(1) : "";
+}
+//#endregion
+export { parseUrlPath, parseUrlPathname };

package/dist/core/utils.mjs

@@ -0,0 +1,24 @@
+//#region src/core/utils.ts
+/**
+* Core utilities — minimal, zero-allocation where possible.
+*/
+function sequential(fn) {
+	let pending = Promise.resolve();
+	return (...args) => {
+		const result = pending.then(() => fn(...args), () => fn(...args));
+		pending = result;
+		return result;
+	};
+}
+function parseEmptyableJSON(text) {
+	if (text === "") return void 0;
+	return JSON.parse(text);
+}
+function stringifyJSON(value) {
+	return JSON.stringify(value, (_key, val) => {
+		if (typeof val === "bigint") return val.toString();
+		return val;
+	});
+}
+//#endregion
+export { parseEmptyableJSON, sequential, stringifyJSON };

package/dist/index.d.mts

@@ -1,21 +1,17 @@
-import { updateRuntimeStorage$1 as updateRuntimeStorage, useRuntime$1 as useRuntime } from "./core/context.mjs";
-import { createSilgi$1 as createSilgi } from "./core/createSilgi.mjs";
-import { SilgiError$1 as SilgiError, createError$1 as createError, isError$1 as isError } from "./core/error.mjs";
-import { SilgiHttpEvent$1 as SilgiHttpEvent } from "./core/event.mjs";
-import { handleResponse$1 as handleResponse, kHandled$1 as kHandled, kNotFound$1 as kNotFound } from "./core/response.mjs";
-import { getWebsocket$1 as getWebsocket, handler$1 as handler, middleware$1 as middleware, silgiFetch$1 as silgiFetch } from "./core/silgi.mjs";
-import { silgiCLICtx$1 as silgiCLICtx, tryUseSilgiCLI$1 as tryUseSilgiCLI, useSilgiCLI$1 as useSilgiCLI } from "./core/silgiApp.mjs";
-import { storageMount$1 as storageMount } from "./core/storage.mjs";
-import { silgiCtx$1 as silgiCtx, tryUseSilgi$1 as tryUseSilgi, useSilgi$1 as useSilgi } from "./core/unctx.mjs";
-import { createEventStream$1 as createEventStream } from "./core/utils/event-stream.mjs";
-import { getEvent$1 as getEvent, getEventContext$1 as getEventContext } from "./core/utils/event.mjs";
-import { deepMergeObjects$1 as deepMergeObjects } from "./core/utils/merge.mjs";
-import { createMiddleware$1 as createMiddleware } from "./core/utils/middleware.mjs";
-import { createResolver$3 as createResolver, getUrlPrefix$1 as getUrlPrefix } from "./core/utils/resolver.mjs";
-import { replaceRuntimeValues$1 as replaceRuntimeValues } from "./core/utils/runtime.mjs";
-import { createSchema$1 as createSchema } from "./core/utils/schema.mjs";
-import { createService$1 as createService, createWebSocket$1 as createWebSocket, defineServiceSetup$1 as defineServiceSetup } from "./core/utils/service.mjs";
-import { createShared$1 as createShared } from "./core/utils/shared.mjs";
-import { createStorage$1 as createStorage, useSilgiStorage$1 as useSilgiStorage } from "./core/utils/storage.mjs";
-import { autoImportTypes } from "./core/index.mjs";
-export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };
+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 { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
+import { ProcedureBuilder, ProcedureBuilderWithOutput } from "./builder.mjs";
+import { ScalarOptions, generateOpenAPI, scalarHTML } from "./scalar.mjs";
+import { ServeOptions, SilgiServer } from "./core/serve.mjs";
+import { Driver, Storage, StorageConfig, StorageValue, initStorage, resetStorage, useStorage } from "./core/storage.mjs";
+import { SilgiConfig, SilgiInstance, silgi } from "./silgi.mjs";
+import { SilgiError, SilgiErrorCode, SilgiErrorJSON, SilgiErrorOptions, isDefinedError, toSilgiError } from "./core/error.mjs";
+import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
+import { EventMeta, getEventMeta, withEventMeta } from "./core/sse.mjs";
+import { CallableOptions, callable } from "./callable.mjs";
+import { LifecycleHooks, lifecycleWrap } from "./lifecycle.mjs";
+import { mapInput } from "./map-input.mjs";
+import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
+import { LazyRouter, isLazy, lazy, resolveLazy } from "./lazy.mjs";
+export { type AnySchema, AsyncIteratorClass, type CallableOptions, 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 LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureType, type ResolveContext, type RouterDef, type ScalarOptions, type ScheduledTaskInfo, type Schema, 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, compileProcedure, compileRouter, createContext, generateOpenAPI, getEventMeta, getScheduledTasks, initStorage, isDefinedError, isLazy, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };