silgi 0.43.29 → 0.50.1

package/README.md

@@ -1 +1,103 @@
-v0.0.0
+<p align="center">
+  <br>
+  <img src=".github/assets/cover.png" alt="Silgi — Type-safe RPC framework for TypeScript" width="100%">
+  <br><br>
+  <a href="https://npmjs.com/package/silgi"><img src="https://img.shields.io/npm/v/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="npm version"></a>
+  <a href="https://npmjs.com/package/silgi"><img src="https://img.shields.io/npm/dm/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="npm downloads"></a>
+  <a href="https://github.com/productdevbook/silgi/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/productdevbook/silgi/ci.yml?style=flat&colorA=0a0908&colorB=edc462" alt="CI"></a>
+  <a href="https://github.com/productdevbook/silgi/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="license"></a>
+</p>
+
+## Quick Start
+
+```bash
+npm install silgi
+```
+
+```ts
+import { silgi } from 'silgi'
+import { z } from 'zod'
+
+const s = silgi({ context: (req) => ({ db: getDB() }) })
+
+const appRouter = s.router({
+  users: {
+    list: k
+      .$input(z.object({ limit: z.number().optional() }))
+      .$resolve(({ input, ctx }) => ctx.db.users.find({ take: input.limit })),
+  },
+})
+
+s.serve(appRouter, { port: 3000, scalar: true })
+```
+
+## Features
+
+- **Single package** — server, client, 15 plugins, 14 adapters. One install.
+- **Compiled pipeline** — guards unrolled, handlers pre-linked at startup.
+- **Guard / Wrap** — guards enrich context (flat, sync fast-path). Wraps run before + after (onion).
+- **Content negotiation** — JSON, MessagePack, devalue. Automatic from `Accept` header.
+- **Contract-first** — define API shape, share types, implement separately.
+- **Standard Schema** — Zod, Valibot, ArkType.
+
+## Adapters
+
+| | Import |
+|---|---|
+| Standalone | `s.serve()` / `s.handler()` |
+| Nitro v3 | `serverEntry` + `s.handler()` |
+| Express | `silgi/express` |
+| Fastify | `silgi/fastify` |
+| Elysia | `silgi/elysia` |
+| Next.js | `silgi/nextjs` |
+| Nuxt | via Nitro `serverEntry` |
+| SvelteKit | `silgi/sveltekit` |
+| Remix | `silgi/remix` |
+| Astro | `silgi/astro` |
+| SolidStart | `silgi/solidstart` |
+| NestJS | `silgi/nestjs` |
+| AWS Lambda | `silgi/aws-lambda` |
+| MessagePort | `silgi/message-port` |
+
+## Ecosystem
+
+Built-in re-exports — no extra dependencies needed:
+
+| Import | Package | Use case |
+|---|---|---|
+| `silgi/unstorage` | unstorage | Key-value storage (Redis, KV, S3) |
+| `silgi/ocache` | ocache | Cached functions with TTL + SWR |
+| `silgi/ofetch` | ofetch | Universal fetch with auto-retry |
+| `silgi/srvx` | srvx | Universal server (Node, Deno, Bun) |
+
+## Integrations
+
+- **TanStack Query** — `queryOptions`, `mutationOptions`, `infiniteOptions`, `skipToken`
+- **React Server Actions** — `createAction`, `useServerAction`, `useOptimisticServerAction`
+- **AI SDK** — `routerToTools()` turns procedures into LLM tools
+- **tRPC Interop** — `fromTRPC()` for incremental migration
+
+## Examples
+
+```bash
+npx giget@latest gh:productdevbook/silgi/examples/standalone my-app
+npx giget@latest gh:productdevbook/silgi/examples/nextjs my-nextjs-app
+npx giget@latest gh:productdevbook/silgi/examples/nuxt my-nuxt-app
+```
+
+10 examples: standalone, bun, express, elysia, nitro, nitro-h3, nextjs, nuxt, sveltekit, client-react.
+
+## Documentation
+
+[silgi.dev](https://silgi.dev)
+
+## Credits
+
+- [oRPC](https://github.com/unnoq/orpc) — Pipeline architecture, client proxy, error handling, contract-first workflow
+- [tRPC](https://github.com/trpc/trpc) — Router/procedure model, end-to-end type inference
+- [Elysia](https://github.com/elysiajs/elysia) — Sucrose-style static handler analysis
+
+
+## License
+
+MIT

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __require };

package/dist/adapters/_fetch-adapter.d.mts

@@ -0,0 +1,18 @@
+//#region src/adapters/_fetch-adapter.d.ts
+interface FetchAdapterConfig<TCtx extends Record<string, unknown>> {
+  /** Route prefix to strip. Default: "/api/rpc" */
+  prefix?: string;
+  /** Context factory — receives the Request (or framework event via eventMap). */
+  context?: (req: Request) => TCtx | Promise<TCtx>;
+}
+/**
+ * For adapters where the context factory needs access to a framework event
+ * (SvelteKit RequestEvent, SolidStart event), use this extended config.
+ */
+interface FetchAdapterConfigWithEvent<TCtx extends Record<string, unknown>, TEvent = any> {
+  prefix?: string;
+  /** Context factory — receives the framework event, not raw Request. */
+  context?: (event: TEvent) => TCtx | Promise<TCtx>;
+}
+//#endregion
+export { FetchAdapterConfig, FetchAdapterConfigWithEvent };

package/dist/adapters/_fetch-adapter.mjs

@@ -0,0 +1,53 @@
+import { createFetchHandler } from "../core/handler.mjs";
+//#region src/adapters/_fetch-adapter.ts
+/**
+* Shared factory for fetch-passthrough adapters.
+*
+* Next.js, Astro, Remix, SvelteKit, and SolidStart all do the same thing:
+* strip URL prefix → rewrite request → dispatch to fetch handler.
+*
+* This module eliminates the duplication. Each adapter file becomes a thin
+* wrapper that extracts the framework-specific Request and calls this factory.
+*/
+/** Strip prefix from request URL and create a rewritten Request. */
+function rewriteRequest(request, prefix) {
+	const url = new URL(request.url);
+	let pathname = url.pathname;
+	if (pathname.startsWith(prefix)) {
+		pathname = pathname.slice(prefix.length);
+		if (!pathname.startsWith("/")) pathname = "/" + pathname;
+	}
+	return new Request(new URL(pathname + url.search, url.origin), request);
+}
+/**
+* Create a fetch-passthrough adapter that strips a prefix and delegates to handler.
+* Used by adapters that receive a standard Request (Next.js, Astro, Remix).
+*/
+function createFetchAdapter(router, options, defaultPrefix) {
+	const prefix = options.prefix ?? defaultPrefix;
+	const handler = createFetchHandler(router, options.context ?? (() => ({})));
+	return (request) => {
+		return handler(rewriteRequest(request, prefix));
+	};
+}
+/**
+* Create a fetch-passthrough adapter for frameworks that pass an event object
+* with a `.request` property (SvelteKit, SolidStart).
+* Uses a WeakMap to safely pass the event into the context factory per-request.
+*/
+function createEventFetchAdapter(router, options, defaultPrefix, extractRequest) {
+	const prefix = options.prefix ?? defaultPrefix;
+	const requestEventMap = /* @__PURE__ */ new WeakMap();
+	const handler = createFetchHandler(router, (_req) => {
+		const eventRef = requestEventMap.get(_req);
+		if (options.context && eventRef) return options.context(eventRef);
+		return {};
+	});
+	return (event) => {
+		const rewritten = rewriteRequest(extractRequest(event), prefix);
+		requestEventMap.set(rewritten, event);
+		return handler(rewritten);
+	};
+}
+//#endregion
+export { createEventFetchAdapter, createFetchAdapter };

package/dist/adapters/astro.d.mts

@@ -0,0 +1,15 @@
+import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfig } from "./_fetch-adapter.mjs";
+
+//#region src/adapters/astro.d.ts
+interface AstroAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfig<TCtx> {}
+/**
+ * Create an Astro API route handler.
+ * Astro passes { request, params } — we extract request and delegate.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
+  request: Request;
+  params: Record<string, string>;
+}) => Response | Promise<Response>;
+//#endregion
+export { AstroAdapterOptions, createHandler };

package/dist/adapters/astro.mjs

@@ -0,0 +1,31 @@
+import { createFetchAdapter } from "./_fetch-adapter.mjs";
+//#region src/adapters/astro.ts
+/**
+* Astro adapter — use Silgi with Astro API routes.
+*
+* @example
+* ```ts
+* // src/pages/api/rpc/[...path].ts
+* import { createHandler } from "silgi/astro"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   prefix: "/api/rpc",
+*   context: (req) => ({ db: getDB() }),
+* })
+*
+* export const GET = handler
+* export const POST = handler
+* export const ALL = handler
+* ```
+*/
+/**
+* Create an Astro API route handler.
+* Astro passes { request, params } — we extract request and delegate.
+*/
+function createHandler(router, options = {}) {
+	const handler = createFetchAdapter(router, options, "/api/rpc");
+	return ({ request }) => handler(request);
+}
+//#endregion
+export { createHandler };

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

@@ -0,0 +1,42 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/aws-lambda.d.ts
+interface LambdaAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Lambda event */
+  context?: (event: LambdaEvent) => TCtx | Promise<TCtx>;
+  /** Route prefix to strip. Default: none */
+  prefix?: string;
+}
+interface LambdaEvent {
+  httpMethod?: string;
+  path?: string;
+  version?: string;
+  rawPath?: string;
+  requestContext?: {
+    http?: {
+      method: string;
+      path: string;
+    };
+    [key: string]: unknown;
+  };
+  body: string | null;
+  headers: Record<string, string>;
+  queryStringParameters: Record<string, string> | null;
+  isBase64Encoded?: boolean;
+}
+interface LambdaContext {
+  getRemainingTimeInMillis?: () => number;
+}
+interface LambdaResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+}
+/**
+ * Create an AWS Lambda handler from a Silgi router.
+ *
+ * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResponse>;
+//#endregion
+export { LambdaAdapterOptions, createHandler };

package/dist/adapters/aws-lambda.mjs

@@ -0,0 +1,92 @@
+import { compileRouter } from "../compile.mjs";
+import { buildContext, isMethodAllowed, parseQueryData, serializeError } from "../core/dispatch.mjs";
+//#region src/adapters/aws-lambda.ts
+/**
+* AWS Lambda adapter — deploy Silgi as a Lambda function.
+*
+* @example
+* ```ts
+* import { createHandler } from "silgi/aws-lambda"
+*
+* export const handler = createHandler(appRouter, {
+*   context: (event) => ({ db: getDB(), userId: event.requestContext?.authorizer?.userId }),
+* })
+* ```
+*/
+/**
+* Create an AWS Lambda handler from a Silgi router.
+*
+* Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
+*/
+function createHandler(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	const prefix = options.prefix ?? "";
+	const JSON_HDR = { "content-type": "application/json" };
+	return async (event, context) => {
+		const isV2 = event.version === "2.0";
+		const method = isV2 ? event.requestContext?.http?.method ?? "GET" : event.httpMethod ?? "GET";
+		let pathname = isV2 ? event.rawPath ?? "/" : event.path ?? "/";
+		if (prefix && pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(method, "/" + pathname);
+		if (!match) return {
+			statusCode: 404,
+			headers: JSON_HDR,
+			body: JSON.stringify({
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			})
+		};
+		const route = match.data;
+		if (!isMethodAllowed(method, route.method)) return {
+			statusCode: 405,
+			headers: {
+				...JSON_HDR,
+				allow: route.method
+			},
+			body: JSON.stringify({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${method} not allowed`
+			})
+		};
+		try {
+			const ctx = buildContext(options.context ? await options.context(event) : void 0, match.params);
+			let input;
+			if (event.body) {
+				const body = event.isBase64Encoded ? Buffer.from(event.body, "base64").toString("utf-8") : event.body;
+				try {
+					input = JSON.parse(body);
+				} catch {
+					return {
+						statusCode: 400,
+						headers: JSON_HDR,
+						body: JSON.stringify({
+							code: "BAD_REQUEST",
+							status: 400,
+							message: "Invalid JSON body"
+						})
+					};
+				}
+			} else if (event.queryStringParameters?.data) input = parseQueryData(event.queryStringParameters.data);
+			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,
+				headers: JSON_HDR,
+				body: JSON.stringify(output)
+			};
+		} catch (error) {
+			const body = serializeError(error);
+			return {
+				statusCode: body.status,
+				headers: JSON_HDR,
+				body: JSON.stringify(body)
+			};
+		}
+	};
+}
+//#endregion
+export { createHandler };

package/dist/adapters/express.d.mts

@@ -0,0 +1,16 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/express.d.ts
+interface ExpressAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Express request */
+  context?: (req: any) => TCtx | Promise<TCtx>;
+}
+/**
+ * Create Express middleware that routes to Silgi procedures.
+ *
+ * Mount at a prefix — the remainder of the path is the procedure name.
+ * Requires `express.json()` middleware for POST body parsing.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
+//#endregion
+export { ExpressAdapterOptions, createHandler };

package/dist/adapters/express.mjs

@@ -0,0 +1,110 @@
+import { compileRouter } from "../compile.mjs";
+import { buildContext, isMethodAllowed, parseQueryData, serializeError } from "../core/dispatch.mjs";
+import { iteratorToEventStream } from "../core/sse.mjs";
+//#region src/adapters/express.ts
+/**
+* Express adapter — use Silgi as Express middleware.
+*
+* @example
+* ```ts
+* import express from "express"
+* import { createHandler } from "silgi/express"
+*
+* const app = express()
+* app.use("/rpc", createHandler(appRouter, {
+*   context: (req) => ({ db: getDB(), user: req.user }),
+* }))
+* app.listen(3000)
+* ```
+*/
+/**
+* Create Express middleware that routes to Silgi procedures.
+*
+* Mount at a prefix — the remainder of the path is the procedure name.
+* Requires `express.json()` middleware for POST body parsing.
+*/
+function createHandler(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	return (req, res, next) => {
+		let pathname = req.path ?? req.url ?? "";
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(req.method, "/" + pathname);
+		if (!match) return next();
+		const route = match.data;
+		if (!isMethodAllowed(req.method, route.method)) {
+			res.status(405).set("allow", route.method).json({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${req.method} not allowed`
+			});
+			return;
+		}
+		const handle = async () => {
+			try {
+				const ctx = buildContext(options.context ? await options.context(req) : void 0, match.params);
+				let input;
+				if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") input = req.body;
+				else if (req.query?.data) input = typeof req.query.data === "string" ? parseQueryData(req.query.data) : req.query.data;
+				const ac = new AbortController();
+				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();
+						req.on("close", () => reader.cancel());
+						try {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						} finally {
+							reader.releaseLock();
+						}
+					} 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();
+						req.on("close", () => reader.cancel());
+						try {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) {
+									res.end();
+									break;
+								}
+								res.write(value);
+							}
+						} finally {
+							reader.releaseLock();
+						}
+					} else res.json(output);
+				} finally {
+					req.removeListener("close", onClose);
+				}
+			} catch (error) {
+				const body = serializeError(error);
+				res.status(body.status).json(body);
+			}
+		};
+		handle().catch((error) => {
+			if (!res.headersSent) {
+				const body = serializeError(error);
+				res.status(body.status).json(body);
+			}
+		});
+	};
+}
+//#endregion
+export { createHandler };

package/dist/adapters/message-port.d.mts

@@ -0,0 +1,42 @@
+import { RouterDef } from "../types.mjs";
+import { ClientContext, ClientLink, ClientOptions } from "../client/types.mjs";
+
+//#region src/adapters/message-port.d.ts
+interface MessagePortAdapterOptions<TCtx extends Record<string, unknown>> {
+  context?: () => TCtx | Promise<TCtx>;
+}
+/**
+ * Attach Silgi to a MessagePort (server side).
+ * Listens for RPC messages and responds with results.
+ * Returns a dispose function to stop listening.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, port: {
+  postMessage(msg: unknown): void;
+  addEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+  removeEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+}, options?: MessagePortAdapterOptions<TCtx>): () => void;
+/**
+ * Client-side MessagePort link.
+ * Sends RPC messages and resolves promises when responses arrive.
+ */
+declare class MessagePortLink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(port: {
+    postMessage(msg: unknown): void;
+    addEventListener(type: 'message', handler: (event: {
+      data: unknown;
+    }) => void): void;
+    removeEventListener?(type: 'message', handler: (event: {
+      data: unknown;
+    }) => void): void;
+  });
+  call(path: readonly string[], input: unknown, options: ClientOptions<TCtx>): Promise<unknown>;
+  /** Reject all pending calls and stop listening. */
+  dispose(): void;
+}
+//#endregion
+export { MessagePortAdapterOptions, MessagePortLink, createHandler };

package/dist/adapters/message-port.mjs

@@ -0,0 +1,132 @@
+import { SilgiError } from "../core/error.mjs";
+import { compileRouter } from "../compile.mjs";
+import { buildContext, serializeError } from "../core/dispatch.mjs";
+//#region src/adapters/message-port.ts
+/**
+* Message Port adapter — use Silgi over MessagePort/MessageChannel.
+*
+* Works with Electron (main↔renderer), browser extensions (background↔popup),
+* Web Workers, and Node.js Worker Threads.
+*
+* @example
+* ```ts
+* // Worker / Electron main
+* import { createHandler } from "silgi/message-port"
+*
+* const dispose = createHandler(appRouter, port, {
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Client side
+* import { MessagePortLink } from "silgi/message-port"
+* import { createClient } from "silgi/client"
+*
+* const client = createClient<AppRouter>(new MessagePortLink(port))
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* Attach Silgi to a MessagePort (server side).
+* Listens for RPC messages and responds with results.
+* Returns a dispose function to stop listening.
+*/
+function createHandler(router, port, options = {}) {
+	const flatRouter = compileRouter(router);
+	const handler = async (event) => {
+		const msg = event.data;
+		if (!msg || typeof msg !== "object" || !msg.__silgi || msg.__type !== "request") return;
+		const match = flatRouter("POST", "/" + msg.path);
+		if (!match) {
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				error: {
+					code: "NOT_FOUND",
+					status: 404,
+					message: "Procedure not found"
+				}
+			});
+			return;
+		}
+		const route = match.data;
+		try {
+			const ctx = buildContext(options.context ? await options.context() : void 0, match.params);
+			const ac = new AbortController();
+			const result = await route.handler(ctx, msg.input, ac.signal);
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				result
+			});
+		} catch (error) {
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				error: serializeError(error)
+			});
+		}
+	};
+	port.addEventListener("message", handler);
+	return () => port.removeEventListener("message", handler);
+}
+/**
+* Client-side MessagePort link.
+* Sends RPC messages and resolves promises when responses arrive.
+*/
+var MessagePortLink = class {
+	#port;
+	#pending = /* @__PURE__ */ new Map();
+	#nextId = 1;
+	#messageHandler;
+	constructor(port) {
+		this.#port = port;
+		this.#messageHandler = (event) => {
+			const msg = event.data;
+			if (!msg || typeof msg !== "object" || !msg.__silgi || msg.__type !== "response") return;
+			const pending = this.#pending.get(msg.id);
+			if (!pending) return;
+			this.#pending.delete(msg.id);
+			if (msg.error) pending.reject(new SilgiError(msg.error.code, {
+				status: msg.error.status,
+				message: msg.error.message,
+				data: msg.error.data
+			}));
+			else pending.resolve(msg.result);
+		};
+		port.addEventListener("message", this.#messageHandler);
+	}
+	call(path, input, options) {
+		return new Promise((resolve, reject) => {
+			const id = String(this.#nextId++);
+			this.#pending.set(id, {
+				resolve,
+				reject
+			});
+			if (options.signal) options.signal.addEventListener("abort", () => {
+				const pending = this.#pending.get(id);
+				if (pending) {
+					this.#pending.delete(id);
+					pending.reject(new DOMException("Aborted", "AbortError"));
+				}
+			}, { once: true });
+			this.#port.postMessage({
+				__silgi: true,
+				__type: "request",
+				id,
+				path: path.join("/"),
+				input
+			});
+		});
+	}
+	/** Reject all pending calls and stop listening. */
+	dispose() {
+		for (const [, pending] of this.#pending) pending.reject(new DOMException("Link disposed", "AbortError"));
+		this.#pending.clear();
+		this.#port.removeEventListener?.("message", this.#messageHandler);
+	}
+};
+//#endregion
+export { MessagePortLink, createHandler };