@silkweave/trpc 1.7.0

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+
+> @silkweave/trpc@1.6.0 build /Users/atomic/projects/ai/silkweave/packages/trpc
+> tsdown
+
+ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ config file: /Users/atomic/projects/ai/silkweave/packages/trpc/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 4 files
+ℹ build/index.mjs        4.83 kB │ gzip: 1.85 kB
+ℹ build/index.mjs.map    9.85 kB │ gzip: 3.49 kB
+ℹ build/index.d.mts.map  1.11 kB │ gzip: 0.47 kB
+ℹ build/index.d.mts      2.67 kB │ gzip: 1.09 kB
+ℹ 4 files, total: 18.46 kB
+✔ Build complete in 606ms

package/.turbo/turbo-check.log

@@ -0,0 +1,13 @@
+
+
+> @silkweave/trpc@1.6.0 check /Users/atomic/projects/ai/silkweave/packages/trpc
+> pnpm lint && pnpm typecheck
+
+
+> @silkweave/trpc@1.6.0 lint /Users/atomic/projects/ai/silkweave/packages/trpc
+> eslint
+
+
+> @silkweave/trpc@1.6.0 typecheck /Users/atomic/projects/ai/silkweave/packages/trpc
+> tsc --noEmit
+

package/.turbo/turbo-prepack.log

@@ -0,0 +1,24 @@
+
+
+> @silkweave/trpc@1.6.0 prepack /Users/atomic/projects/ai/silkweave/packages/trpc
+> pnpm clean && pnpm build
+
+
+> @silkweave/trpc@1.6.0 clean /Users/atomic/projects/ai/silkweave/packages/trpc
+> rimraf build
+
+
+> @silkweave/trpc@1.6.0 build /Users/atomic/projects/ai/silkweave/packages/trpc
+> tsdown
+
+ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ config file: /Users/atomic/projects/ai/silkweave/packages/trpc/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ build/index.mjs         7.67 kB │ gzip: 2.62 kB
+ℹ build/index.mjs.map    15.99 kB │ gzip: 4.89 kB
+ℹ build/index.d.mts.map   1.40 kB │ gzip: 0.56 kB
+ℹ build/index.d.mts       3.82 kB │ gzip: 1.50 kB
+ℹ 4 files, total: 28.88 kB
+✔ Build complete in 572ms

package/README.md

@@ -0,0 +1,184 @@
+# @silkweave/trpc
+
+tRPC adapter for [Silkweave](https://github.com/silkweave/silkweave) - expose your actions as fully-typed tRPC procedures with end-to-end TypeScript inference for your client.
+
+## Install
+
+```bash
+pnpm add @silkweave/core @silkweave/trpc
+```
+
+## Usage
+
+```typescript
+// server.ts
+import { silkweave } from '@silkweave/core'
+import { trpc, type InferTrpcRouter } from '@silkweave/trpc'
+import { GreetAction } from './actions/greet.js'
+import { ListThingsAction } from './actions/list-things.js'
+
+const server = silkweave({ name: 'my-api', description: 'My tRPC API', version: '1.0.0' })
+  .adapter(trpc({ host: 'localhost', port: 8080 }))
+  .action(GreetAction)
+  .action(ListThingsAction)
+
+export type AppRouter = InferTrpcRouter<typeof server>
+
+await server.start()
+```
+
+Client:
+
+```typescript
+// client.ts
+import { createTRPCClient, httpBatchLink } from '@trpc/client'
+import type { AppRouter } from './server.js'
+
+const client = createTRPCClient<AppRouter>({
+  links: [httpBatchLink({ url: 'http://localhost:8080/trpc' })]
+})
+
+// Fully typed: input and return types are inferred from the action's Zod schemas
+const hello = await client.greet.mutate({ name: 'World' })
+//    ^? { message: string }
+
+const things = await client.listThings.query({ contains: 'saw' })
+//    ^? { items: string[] }
+```
+
+## Type Safety
+
+The adapter is paired with the generic `Silkweave<Actions>` builder so that `typeof server` carries the full action map through your `.action()` / `.actions()` calls. `InferTrpcRouter<typeof server>` then produces a `TRPCBuiltRouter` type where:
+
+- Each `Action<I, O, N, K>` becomes a `camelCase(N)` procedure
+- `kind: 'query'` dispatches to `.query()` (GET, cacheable); default is `.mutation()` (POST)
+- Input type is `z.infer<typeof action.input>`
+- Output type is `Awaited<ReturnType<typeof action.run>>` (narrower than the optional `action.output` Zod type when `run` returns a subtype)
+
+There is **no code generation** - the types flow statically through the TypeScript compiler. Just `export type AppRouter = InferTrpcRouter<typeof server>` and import it on the client.
+
+## Queries vs. Mutations
+
+Actions default to `kind: 'mutation'` (tRPC `.mutation()`, HTTP `POST`). Mark side-effect-free read actions with `kind: 'query'` to get GET-cacheable tRPC queries:
+
+```typescript
+createAction({
+  name: 'list-things',
+  description: 'List things, optionally filtered',
+  kind: 'query',
+  input: z.object({ contains: z.string().optional() }),
+  output: z.object({ items: z.array(z.string()) }),
+  run: async ({ contains }) => ({ items: [/* ... */] })
+})
+```
+
+The literal `'query'` is preserved through `createAction` (generic over `K extends 'query' | 'mutation'`), so `InferTrpcRouter` produces the correct `TRPCQueryProcedure` type - calling `.mutate()` on a query (or vice-versa) is a compile-time error.
+
+## Name Conversion
+
+Action names are converted to tRPC procedure keys using `camelCase` from `change-case`:
+
+| `action.name` | Procedure key |
+|---------------|---------------|
+| `greet` | `client.greet` |
+| `list-things` | `client.listThings` |
+| `get_user_by_id` | `client.getUserById` |
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `host` | `string` | `'0.0.0.0'` | Bind address |
+| `port` | `number` | `8080` | Listen port |
+| `endpoint` | `string` | `'/trpc/'` | URL prefix stripped before tRPC routing (trailing slash is normalized) |
+| `cors` | `CorsOptions \| boolean` | `true` | `false` to disable. `true`/omit for permissive defaults (`origin: '*'`). Or a [cors](https://www.npmjs.com/package/cors) options object. |
+| `auth` | `AuthConfig` | `undefined` | `@silkweave/auth` config. Enables bearer-token validation; `authInfo` is threaded into the action context as `context.get('auth')`. |
+
+## Serverless / Fetch runtimes (`trpcFetch`)
+
+`trpc()` binds a Node HTTP server, which isn't compatible with serverless runtimes like Vercel Functions, Cloudflare Workers, or Astro API routes. For those, use `trpcFetch()`. It returns a fetch-compatible `(Request) => Promise<Response>` handler instead of listening on a port.
+
+```typescript
+// server.ts
+import { silkweave } from '@silkweave/core'
+import { trpcFetch, type InferTrpcRouter } from '@silkweave/trpc'
+import { GreetAction } from './actions/greet.js'
+
+const { adapter, handler } = trpcFetch({ endpoint: '/api/trpc' })
+
+export const server = silkweave({ name: 'my-api', version: '1.0.0' })
+  .adapter(adapter)
+  .action(GreetAction)
+
+export type AppRouter = InferTrpcRouter<typeof server>
+export { handler }
+
+await server.start()
+```
+
+```typescript
+// Astro API route: src/pages/api/trpc/[trpc].ts
+import type { APIRoute } from 'astro'
+import { handler } from '../../../server/silkweave.js'
+
+export const GET: APIRoute = ({ request }) => handler(request)
+export const POST: APIRoute = ({ request }) => handler(request)
+```
+
+```typescript
+// Vercel Edge function: api/trpc/[trpc].ts
+import { handler } from '../../lib/silkweave.js'
+export { handler as GET, handler as POST }
+```
+
+```typescript
+// Cloudflare Worker
+import { handler } from './silkweave.js'
+export default { fetch: handler }
+```
+
+### `trpcFetch` options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `endpoint` | `string` | `'/trpc'` | URL prefix stripped before tRPC routing |
+| `auth` | `AuthConfig` | `undefined` | Same semantics as `trpc()`. On auth failure the handler returns a `401 Response` with `WWW-Authenticate` headers |
+
+### Return shape
+
+```ts
+{
+  adapter: AdapterGenerator                         // pass to .adapter()
+  handler: (request: Request) => Promise<Response>  // primary dispatch
+  GET: (request: Request) => Promise<Response>      // alias for Astro-style method exports
+  POST: (request: Request) => Promise<Response>     // alias for Astro-style method exports
+}
+```
+
+### Notes
+
+- **CORS**: not handled by `trpcFetch`. Configure it in your host framework (Astro middleware, `vercel.json` headers, Cloudflare Worker response headers, etc).
+- **Cold-start safety**: an internal `_ready` promise gates the handler until `server.start()` has completed the router build, so the first invocation from a cold serverless function won't race the module-top `await server.start()`.
+- **`server.start()` is still required**. It's what builds the tRPC router from your registered actions. It just doesn't `listen()` in fetch mode.
+
+## Errors
+
+Thrown `SilkweaveError` instances are mapped to `TRPCError` by status code:
+
+| `SilkweaveError.statusCode` | `TRPCError.code` |
+|-----------------------------|------------------|
+| `400` | `BAD_REQUEST` |
+| `401` | `UNAUTHORIZED` |
+| `403` | `FORBIDDEN` |
+| `404` | `NOT_FOUND` |
+| `409` | `CONFLICT` |
+| `429` | `TOO_MANY_REQUESTS` |
+| `500` (default) | `INTERNAL_SERVER_ERROR` |
+
+Zod validation errors from the input schema are automatically returned as `BAD_REQUEST`. Any other thrown value falls through to `INTERNAL_SERVER_ERROR`.
+
+## See Also
+
+- [Silkweave README](https://github.com/silkweave/silkweave) - Full documentation
+- [`@silkweave/core`](https://www.npmjs.com/package/@silkweave/core) - Core library
+- [tRPC documentation](https://trpc.io/) - Client setup, React Query integration, subscriptions, and more

package/build/index.d.mts

@@ -0,0 +1,91 @@
+import * as _$_trpc_server0 from "@trpc/server";
+import { AnyTRPCRootTypes, TRPCBuiltRouter, TRPCError, TRPCMutationProcedure, TRPCQueryProcedure } from "@trpc/server";
+import { Action, AdapterFactory, AdapterGenerator, Silkweave, SilkweaveContext } from "@silkweave/core";
+import { z } from "zod";
+import { AuthConfig } from "@silkweave/auth";
+import { CorsOptions } from "cors";
+
+//#region src/adapter/fetch.d.ts
+interface TrpcFetchAdapterOptions {
+  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc`. */
+  endpoint?: string;
+  auth?: AuthConfig;
+}
+type FetchHandler = (request: Request) => Promise<Response>;
+interface TrpcFetchAdapter {
+  adapter: AdapterGenerator;
+  handler: FetchHandler;
+  GET: FetchHandler;
+  POST: FetchHandler;
+}
+/**
+ * Creates a tRPC adapter that exposes a fetch-compatible handler instead of
+ * binding its own HTTP server. Use in Astro API routes, Vercel serverless
+ * functions, Cloudflare Workers, or any Web Standard runtime.
+ *
+ * The returned `handler` waits for `server.start()` to complete (via an internal
+ * `_ready` promise) before dispatching requests, so it's safe to call from a
+ * cold-started serverless invocation.
+ *
+ * CORS is intentionally not configured here - handle it in your host framework
+ * (Astro middleware, `vercel.json` headers, Worker response headers, etc).
+ */
+declare function trpcFetch(options?: TrpcFetchAdapterOptions): TrpcFetchAdapter;
+//#endregion
+//#region src/adapter/trpc.d.ts
+interface TrpcAdapterOptions {
+  host?: string;
+  port?: number;
+  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc/`. */
+  endpoint?: string;
+  /** CORS configuration. `false` to disable, `true`/`undefined` for permissive defaults, or a CorsOptions object. */
+  cors?: CorsOptions | boolean;
+  auth?: AuthConfig;
+}
+declare const trpc: AdapterFactory<TrpcAdapterOptions>;
+//#endregion
+//#region src/lib/buildRouter.d.ts
+interface TrpcHandlerContext {
+  silkweaveContext: SilkweaveContext;
+}
+declare function buildRouter(actions: Action[]): _$_trpc_server0.TRPCBuiltRouter<{
+  ctx: TrpcHandlerContext;
+  meta: object;
+  errorShape: _$_trpc_server0.TRPCDefaultErrorShape;
+  transformer: false;
+}, _$_trpc_server0.TRPCDecorateCreateRouterOptions<Record<string, any>>>;
+//#endregion
+//#region src/lib/errors.d.ts
+declare function mapError(error: unknown): TRPCError;
+//#endregion
+//#region src/lib/inferRouter.d.ts
+type CamelCase<S extends string> = S extends `${infer A}-${infer B}` ? `${A}${Capitalize<CamelCase<B>>}` : S extends `${infer A}_${infer B}` ? `${A}${Capitalize<CamelCase<B>>}` : S;
+type ActionToProcedure<A extends Action> = 'query' extends NonNullable<A['kind']> ? TRPCQueryProcedure<{
+  meta: object;
+  input: z.infer<A['input']>;
+  output: Awaited<ReturnType<A['run']>>;
+}> : TRPCMutationProcedure<{
+  meta: object;
+  input: z.infer<A['input']>;
+  output: Awaited<ReturnType<A['run']>>;
+}>;
+type ActionsToRouterRecord<Actions extends Record<string, Action>> = { [K in keyof Actions & string as CamelCase<Actions[K]['name']>]: ActionToProcedure<Actions[K]> };
+type TrpcRootTypes = {
+  ctx: object;
+  meta: object;
+  errorShape: unknown;
+  transformer: false;
+} & AnyTRPCRootTypes;
+/**
+ * Extracts a fully-typed tRPC router from a Silkweave builder instance.
+ *
+ * Usage:
+ * ```ts
+ * const server = silkweave(opts).adapter(trpc({ port: 8080 })).action(HelloAction)
+ * export type AppRouter = InferTrpcRouter<typeof server>
+ * ```
+ */
+type InferTrpcRouter<S> = S extends Silkweave<infer Actions> ? TRPCBuiltRouter<TrpcRootTypes, ActionsToRouterRecord<Actions>> : never;
+//#endregion
+export { FetchHandler, type InferTrpcRouter, TrpcAdapterOptions, TrpcFetchAdapter, TrpcFetchAdapterOptions, type TrpcHandlerContext, buildRouter, mapError, trpc, trpcFetch };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/adapter/fetch.ts","../src/adapter/trpc.ts","../src/lib/buildRouter.ts","../src/lib/errors.ts","../src/lib/inferRouter.ts"],"mappings":";;;;;;;;UAMiB,uBAAA;;EAEf,QAAA;EACA,IAAA,GAAO,UAAA;AAAA;AAAA,KAGG,YAAA,IAAgB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;AAAA,UAExC,gBAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA,EAAS,YAAA;EACT,GAAA,EAAK,YAAA;EACL,IAAA,EAAM,YAAA;AAAA;;;;AANR;;;;;;;;;iBAqBgB,SAAA,CAAU,OAAA,GAAS,uBAAA,GAA+B,gBAAA;;;UCzBjD,kBAAA;EACf,IAAA;EACA,IAAA;;EAEA,QAAA;EDNe;ECQf,IAAA,GAAO,WAAA;EACP,IAAA,GAAO,UAAA;AAAA;AAAA,cAWI,IAAA,EAAM,cAAA,CAAe,kBAAA;;;UCpBjB,kBAAA;EACf,gBAAA,EAAkB,gBAAA;AAAA;AAAA,iBAGJ,WAAA,CAAY,OAAA,EAAS,MAAA,qBAAQ,eAAA;;;;;;;;iBCc7B,QAAA,CAAS,KAAA,YAAiB,SAAA;;;KCfrC,SAAA,qBAA8B,CAAA,sCAC5B,CAAA,GAAI,UAAA,CAAW,SAAA,CAAU,CAAA,OAC5B,CAAA,sCACK,CAAA,GAAI,UAAA,CAAW,SAAA,CAAU,CAAA,OAC5B,CAAA;AAAA,KAED,iBAAA,WAA4B,MAAA,oBAA0B,WAAA,CAAY,CAAA,YACnE,kBAAA;EACA,IAAA;EACA,KAAA,EAAO,CAAA,CAAE,KAAA,CAAM,CAAA;EACf,MAAA,EAAQ,OAAA,CAAQ,UAAA,CAAW,CAAA;AAAA,KAE3B,qBAAA;EACA,IAAA;EACA,KAAA,EAAO,CAAA,CAAE,KAAA,CAAM,CAAA;EACf,MAAA,EAAQ,OAAA,CAAQ,UAAA,CAAW,CAAA;AAAA;AAAA,KAG1B,qBAAA,iBAAsC,MAAA,SAAe,MAAA,mBAC5C,OAAA,aAAoB,SAAA,CAAU,OAAA,CAAQ,CAAA,aAAc,iBAAA,CAAkB,OAAA,CAAQ,CAAA;AAAA,KAGvF,aAAA;EACH,GAAA;EACA,IAAA;EACA,UAAA;EACA,WAAA;AAAA,IACE,gBAAA;;;;;;;;;;KAWQ,eAAA,MAAqB,CAAA,SAAU,SAAA,kBACvC,eAAA,CAAgB,aAAA,EAAe,qBAAA,CAAsB,OAAA"}

package/build/index.mjs

@@ -0,0 +1,267 @@
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+import { TRPCError, initTRPC } from "@trpc/server";
+import { camelCase } from "change-case";
+import { SilkweaveError } from "@silkweave/core";
+import { z } from "zod";
+import { validateToken } from "@silkweave/auth";
+import { buildLogLevels } from "@silkweave/logger";
+import { createHTTPHandler } from "@trpc/server/adapters/standalone";
+import cors from "cors";
+import http from "http";
+//#region src/lib/errors.ts
+const CODE_MAP = {
+	400: "BAD_REQUEST",
+	401: "UNAUTHORIZED",
+	403: "FORBIDDEN",
+	404: "NOT_FOUND",
+	408: "TIMEOUT",
+	409: "CONFLICT",
+	412: "PRECONDITION_FAILED",
+	413: "PAYLOAD_TOO_LARGE",
+	429: "TOO_MANY_REQUESTS",
+	499: "CLIENT_CLOSED_REQUEST",
+	500: "INTERNAL_SERVER_ERROR",
+	501: "NOT_IMPLEMENTED",
+	502: "BAD_GATEWAY",
+	503: "SERVICE_UNAVAILABLE",
+	504: "GATEWAY_TIMEOUT"
+};
+function mapError(error) {
+	if (error instanceof TRPCError) return error;
+	if (error instanceof z.ZodError) return new TRPCError({
+		code: "BAD_REQUEST",
+		message: error.message,
+		cause: error
+	});
+	if (error instanceof SilkweaveError) return new TRPCError({
+		code: CODE_MAP[error.statusCode] ?? "INTERNAL_SERVER_ERROR",
+		message: error.message,
+		cause: error
+	});
+	return new TRPCError({
+		code: "INTERNAL_SERVER_ERROR",
+		message: error instanceof Error ? error.message : "Internal error",
+		cause: error instanceof Error ? error : void 0
+	});
+}
+//#endregion
+//#region src/lib/buildRouter.ts
+function buildRouter(actions) {
+	const t = initTRPC.context().create();
+	const record = {};
+	for (const action of actions) {
+		const key = camelCase(action.name);
+		const base = t.procedure.input(action.input);
+		const handler = async ({ input, ctx }) => {
+			try {
+				return await action.run(input, ctx.silkweaveContext);
+			} catch (error) {
+				throw mapError(error);
+			}
+		};
+		record[key] = action.kind === "query" ? base.query(handler) : base.mutation(handler);
+	}
+	return t.router(record);
+}
+//#endregion
+//#region src/lib/createContext.ts
+const CONSOLE_LEVEL_MAP = {
+	emergency: "error",
+	alert: "error",
+	critical: "error",
+	error: "error",
+	warning: "warn",
+	notice: "info",
+	info: "info",
+	debug: "log"
+};
+function createActionLogger() {
+	return {
+		...buildLogLevels((level, data) => {
+			console[CONSOLE_LEVEL_MAP[level]](data);
+		}),
+		progress: () => {}
+	};
+}
+async function resolveAuth(auth, authHeader, context) {
+	if (!auth) return { kind: "ok" };
+	const result = await validateToken(authHeader, auth, context);
+	if (result.error) return {
+		kind: "error",
+		error: result.error
+	};
+	return {
+		kind: "ok",
+		authInfo: result.auth
+	};
+}
+//#endregion
+//#region src/adapter/fetch.ts
+/**
+* Creates a tRPC adapter that exposes a fetch-compatible handler instead of
+* binding its own HTTP server. Use in Astro API routes, Vercel serverless
+* functions, Cloudflare Workers, or any Web Standard runtime.
+*
+* The returned `handler` waits for `server.start()` to complete (via an internal
+* `_ready` promise) before dispatching requests, so it's safe to call from a
+* cold-started serverless invocation.
+*
+* CORS is intentionally not configured here - handle it in your host framework
+* (Astro middleware, `vercel.json` headers, Worker response headers, etc).
+*/
+function trpcFetch(options = {}) {
+	const endpoint = (options.endpoint ?? "/trpc").replace(/\/$/, "");
+	let resolveReady;
+	const ready = new Promise((resolve) => {
+		resolveReady = resolve;
+	});
+	let handler = async () => new Response(JSON.stringify({
+		error: "not_ready",
+		message: "tRPC adapter has not started yet"
+	}), {
+		status: 503,
+		headers: { "Content-Type": "application/json" }
+	});
+	const adapter = (_silkweaveOptions, baseContext) => {
+		const context = baseContext.fork({ adapter: "trpc" });
+		return {
+			context,
+			start: async (actions) => {
+				const router = buildRouter(actions);
+				const logger = createActionLogger();
+				const createContext = async (opts) => {
+					const resolved = await resolveAuth(options.auth, opts.req.headers.get("authorization"), context.fork({ request: opts.req }));
+					if (resolved.kind === "error") {
+						const err = /* @__PURE__ */ new Error("Unauthorized");
+						err.silkweaveAuthError = resolved.error;
+						throw err;
+					}
+					return { silkweaveContext: context.fork({
+						logger,
+						request: opts.req,
+						...resolved.authInfo ? { auth: resolved.authInfo } : {}
+					}) };
+				};
+				handler = async (request) => {
+					try {
+						return await fetchRequestHandler({
+							endpoint,
+							req: request,
+							router,
+							createContext
+						});
+					} catch (error) {
+						const authError = error.silkweaveAuthError;
+						if (authError) return new Response(JSON.stringify(authError.body), {
+							status: authError.statusCode,
+							headers: {
+								"Content-Type": "application/json",
+								...authError.headers
+							}
+						});
+						throw error;
+					}
+				};
+				resolveReady();
+			},
+			stop: async () => {}
+		};
+	};
+	const dispatch = async (request) => {
+		await ready;
+		return handler(request);
+	};
+	return {
+		adapter,
+		handler: dispatch,
+		GET: dispatch,
+		POST: dispatch
+	};
+}
+//#endregion
+//#region src/adapter/trpc.ts
+function resolveCors(corsConfig) {
+	if (corsConfig === false) return null;
+	return cors({
+		origin: "*",
+		...corsConfig === true || corsConfig === void 0 ? {} : corsConfig
+	});
+}
+const trpc = (options) => {
+	return (_silkweaveOptions, baseContext) => {
+		const context = baseContext.fork({ adapter: "trpc" });
+		const host = options.host ?? "0.0.0.0";
+		const port = options.port ?? 8080;
+		const endpoint = (options.endpoint ?? "/trpc/").replace(/\/?$/, "/");
+		let server;
+		return {
+			context,
+			start: async (actions) => {
+				const router = buildRouter(actions);
+				const corsMiddleware = resolveCors(options.cors);
+				const logger = createActionLogger();
+				const createContext = async (opts) => {
+					const resolved = await resolveAuth(options.auth, opts.req.headers.authorization, context.fork({ request: opts.req }));
+					if (resolved.kind === "error") {
+						for (const [key, value] of Object.entries(resolved.error.headers)) opts.res.setHeader(key, value);
+						opts.res.statusCode = resolved.error.statusCode;
+						opts.res.setHeader("Content-Type", "application/json");
+						opts.res.end(JSON.stringify(resolved.error.body));
+						throw new Error("Unauthorized");
+					}
+					return { silkweaveContext: context.fork({
+						logger,
+						request: opts.req,
+						...resolved.authInfo ? { auth: resolved.authInfo } : {}
+					}) };
+				};
+				const trpcHandler = createHTTPHandler({
+					router,
+					basePath: endpoint,
+					createContext
+				});
+				const handler = (req, res) => {
+					if (!req.url?.startsWith(endpoint)) {
+						res.statusCode = 404;
+						res.setHeader("Content-Type", "application/json");
+						res.end(JSON.stringify({
+							error: "not_found",
+							message: `No route for ${req.url}`
+						}));
+						return;
+					}
+					trpcHandler(req, res);
+				};
+				server = http.createServer((req, res) => {
+					if (corsMiddleware) corsMiddleware(req, res, () => {
+						if (req.method === "OPTIONS") {
+							res.statusCode = 204;
+							res.end();
+							return;
+						}
+						handler(req, res);
+					});
+					else handler(req, res);
+				});
+				await new Promise((resolve) => {
+					server.listen(port, host, () => {
+						resolve();
+					});
+				});
+			},
+			stop: async () => {
+				if (!server) return;
+				await new Promise((resolve, reject) => {
+					server.close((err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+			}
+		};
+	};
+};
+//#endregion
+export { buildRouter, mapError, trpc, trpcFetch };
+
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/lib/errors.ts","../src/lib/buildRouter.ts","../src/lib/createContext.ts","../src/adapter/fetch.ts","../src/adapter/trpc.ts"],"sourcesContent":["import { SilkweaveError } from '@silkweave/core'\nimport { TRPCError } from '@trpc/server'\nimport { z } from 'zod'\n\ntype TRPCErrorCode = TRPCError['code']\n\nconst CODE_MAP: Record<number, TRPCErrorCode> = {\n  400: 'BAD_REQUEST',\n  401: 'UNAUTHORIZED',\n  403: 'FORBIDDEN',\n  404: 'NOT_FOUND',\n  408: 'TIMEOUT',\n  409: 'CONFLICT',\n  412: 'PRECONDITION_FAILED',\n  413: 'PAYLOAD_TOO_LARGE',\n  429: 'TOO_MANY_REQUESTS',\n  499: 'CLIENT_CLOSED_REQUEST',\n  500: 'INTERNAL_SERVER_ERROR',\n  501: 'NOT_IMPLEMENTED',\n  502: 'BAD_GATEWAY',\n  503: 'SERVICE_UNAVAILABLE',\n  504: 'GATEWAY_TIMEOUT'\n}\n\nexport function mapError(error: unknown): TRPCError {\n  if (error instanceof TRPCError) { return error }\n  if (error instanceof z.ZodError) {\n    return new TRPCError({ code: 'BAD_REQUEST', message: error.message, cause: error })\n  }\n  if (error instanceof SilkweaveError) {\n    return new TRPCError({\n      code: CODE_MAP[error.statusCode] ?? 'INTERNAL_SERVER_ERROR',\n      message: error.message,\n      cause: error\n    })\n  }\n  return new TRPCError({\n    code: 'INTERNAL_SERVER_ERROR',\n    message: error instanceof Error ? error.message : 'Internal error',\n    cause: error instanceof Error ? error : undefined\n  })\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Action, SilkweaveContext } from '@silkweave/core'\nimport { initTRPC } from '@trpc/server'\nimport { camelCase } from 'change-case'\nimport { mapError } from './errors.js'\n\nexport interface TrpcHandlerContext {\n  silkweaveContext: SilkweaveContext\n}\n\nexport function buildRouter(actions: Action[]) {\n  const t = initTRPC.context<TrpcHandlerContext>().create()\n  const record: Record<string, any> = {}\n  for (const action of actions) {\n    const key = camelCase(action.name)\n    const base = t.procedure.input(action.input)\n    const handler = async ({ input, ctx }: { input: object; ctx: TrpcHandlerContext }) => {\n      try {\n        return await action.run(input, ctx.silkweaveContext)\n      } catch (error) {\n        throw mapError(error)\n      }\n    }\n    record[key] = action.kind === 'query' ? base.query(handler) : base.mutation(handler)\n  }\n  return t.router(record)\n}\n","import { AuthConfig, AuthInfo, validateToken } from '@silkweave/auth'\nimport { SilkweaveContext } from '@silkweave/core'\nimport { buildLogLevels, Logger, LogLevel } from '@silkweave/logger'\n\nconst CONSOLE_LEVEL_MAP: Record<LogLevel, 'log' | 'info' | 'warn' | 'error'> = {\n  emergency: 'error',\n  alert: 'error',\n  critical: 'error',\n  error: 'error',\n  warning: 'warn',\n  notice: 'info',\n  info: 'info',\n  debug: 'log'\n}\n\nexport function createActionLogger(): Logger {\n  return {\n    ...buildLogLevels((level, data) => {\n      console[CONSOLE_LEVEL_MAP[level]](data)\n    }),\n    progress: () => { /* progress notifications not supported on tRPC HTTP */ }\n  }\n}\n\nexport interface AuthErrorPayload {\n  statusCode: number\n  headers: Record<string, string>\n  body: { error: string; error_description: string }\n}\n\nexport type ResolvedAuth =\n  | { kind: 'ok'; authInfo?: AuthInfo }\n  | { kind: 'error'; error: AuthErrorPayload }\n\nexport async function resolveAuth(\n  auth: AuthConfig | undefined,\n  authHeader: string | null | undefined,\n  context: SilkweaveContext\n): Promise<ResolvedAuth> {\n  if (!auth) { return { kind: 'ok' } }\n  const result = await validateToken(authHeader, auth, context)\n  if (result.error) { return { kind: 'error', error: result.error } }\n  return { kind: 'ok', authInfo: result.auth }\n}\n","import { AuthConfig } from '@silkweave/auth'\nimport { Adapter, AdapterGenerator, SilkweaveOptions } from '@silkweave/core'\nimport { fetchRequestHandler } from '@trpc/server/adapters/fetch'\nimport { buildRouter, TrpcHandlerContext } from '../lib/buildRouter.js'\nimport { createActionLogger, resolveAuth } from '../lib/createContext.js'\n\nexport interface TrpcFetchAdapterOptions {\n  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc`. */\n  endpoint?: string\n  auth?: AuthConfig\n}\n\nexport type FetchHandler = (request: Request) => Promise<Response>\n\nexport interface TrpcFetchAdapter {\n  adapter: AdapterGenerator\n  handler: FetchHandler\n  GET: FetchHandler\n  POST: FetchHandler\n}\n\n/**\n * Creates a tRPC adapter that exposes a fetch-compatible handler instead of\n * binding its own HTTP server. Use in Astro API routes, Vercel serverless\n * functions, Cloudflare Workers, or any Web Standard runtime.\n *\n * The returned `handler` waits for `server.start()` to complete (via an internal\n * `_ready` promise) before dispatching requests, so it's safe to call from a\n * cold-started serverless invocation.\n *\n * CORS is intentionally not configured here - handle it in your host framework\n * (Astro middleware, `vercel.json` headers, Worker response headers, etc).\n */\nexport function trpcFetch(options: TrpcFetchAdapterOptions = {}): TrpcFetchAdapter {\n  const endpoint = (options.endpoint ?? '/trpc').replace(/\\/$/, '')\n\n  let resolveReady!: () => void\n  const ready = new Promise<void>((resolve) => { resolveReady = resolve })\n\n  let handler: FetchHandler = async () => new Response(\n    JSON.stringify({ error: 'not_ready', message: 'tRPC adapter has not started yet' }),\n    { status: 503, headers: { 'Content-Type': 'application/json' } }\n  )\n\n  const adapter: AdapterGenerator = (_silkweaveOptions: SilkweaveOptions, baseContext): Adapter => {\n    const context = baseContext.fork({ adapter: 'trpc' })\n    return {\n      context,\n      start: async (actions) => {\n        const router = buildRouter(actions)\n        const logger = createActionLogger()\n\n        const createContext = async (\n          opts: { req: Request }\n        ): Promise<TrpcHandlerContext> => {\n          const resolved = await resolveAuth(\n            options.auth,\n            opts.req.headers.get('authorization'),\n            context.fork({ request: opts.req })\n          )\n          if (resolved.kind === 'error') {\n            const err = new Error('Unauthorized') as Error & { silkweaveAuthError?: typeof resolved.error }\n            err.silkweaveAuthError = resolved.error\n            throw err\n          }\n          return {\n            silkweaveContext: context.fork({\n              logger,\n              request: opts.req,\n              ...(resolved.authInfo ? { auth: resolved.authInfo } : {})\n            })\n          }\n        }\n\n        handler = async (request: Request): Promise<Response> => {\n          try {\n            return await fetchRequestHandler({\n              endpoint,\n              req: request,\n              router,\n              createContext\n            })\n          } catch (error) {\n            const authError = (error as { silkweaveAuthError?: { statusCode: number; headers: Record<string, string>; body: object } }).silkweaveAuthError\n            if (authError) {\n              return new Response(JSON.stringify(authError.body), {\n                status: authError.statusCode,\n                headers: { 'Content-Type': 'application/json', ...authError.headers }\n              })\n            }\n            throw error\n          }\n        }\n\n        resolveReady()\n      },\n      stop: async () => { /* no-op for fetch adapter */ }\n    }\n  }\n\n  const dispatch: FetchHandler = async (request) => {\n    await ready\n    return handler(request)\n  }\n\n  return {\n    adapter,\n    handler: dispatch,\n    GET: dispatch,\n    POST: dispatch\n  }\n}\n","import { AuthConfig } from '@silkweave/auth'\nimport { AdapterFactory } from '@silkweave/core'\nimport { createHTTPHandler } from '@trpc/server/adapters/standalone'\nimport cors, { CorsOptions } from 'cors'\nimport http, { IncomingMessage, ServerResponse } from 'http'\nimport { buildRouter, TrpcHandlerContext } from '../lib/buildRouter.js'\nimport { createActionLogger, resolveAuth } from '../lib/createContext.js'\n\nexport interface TrpcAdapterOptions {\n  host?: string\n  port?: number\n  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc/`. */\n  endpoint?: string\n  /** CORS configuration. `false` to disable, `true`/`undefined` for permissive defaults, or a CorsOptions object. */\n  cors?: CorsOptions | boolean\n  auth?: AuthConfig\n}\n\ntype CorsMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void\n\nfunction resolveCors(corsConfig: CorsOptions | boolean | undefined): CorsMiddleware | null {\n  if (corsConfig === false) { return null }\n  const userConfig = corsConfig === true || corsConfig === undefined ? {} : corsConfig\n  return cors({ origin: '*', ...userConfig }) as CorsMiddleware\n}\n\nexport const trpc: AdapterFactory<TrpcAdapterOptions> = (options) => {\n  return (_silkweaveOptions, baseContext) => {\n    const context = baseContext.fork({ adapter: 'trpc' })\n    const host = options.host ?? '0.0.0.0'\n    const port = options.port ?? 8080\n    const endpoint = (options.endpoint ?? '/trpc/').replace(/\\/?$/, '/')\n    let server: http.Server | undefined\n\n    return {\n      context,\n      start: async (actions) => {\n        const router = buildRouter(actions)\n        const corsMiddleware = resolveCors(options.cors)\n        const logger = createActionLogger()\n\n        const createContext = async (\n          opts: { req: IncomingMessage; res: ServerResponse }\n        ): Promise<TrpcHandlerContext> => {\n          const resolved = await resolveAuth(\n            options.auth,\n            opts.req.headers.authorization,\n            context.fork({ request: opts.req })\n          )\n          if (resolved.kind === 'error') {\n            for (const [key, value] of Object.entries(resolved.error.headers)) {\n              opts.res.setHeader(key, value)\n            }\n            opts.res.statusCode = resolved.error.statusCode\n            opts.res.setHeader('Content-Type', 'application/json')\n            opts.res.end(JSON.stringify(resolved.error.body))\n            throw new Error('Unauthorized')\n          }\n          return {\n            silkweaveContext: context.fork({\n              logger,\n              request: opts.req,\n              ...(resolved.authInfo ? { auth: resolved.authInfo } : {})\n            })\n          }\n        }\n\n        const trpcHandler = createHTTPHandler({ router, basePath: endpoint, createContext })\n\n        const handler = (req: IncomingMessage, res: ServerResponse) => {\n          if (!req.url?.startsWith(endpoint)) {\n            res.statusCode = 404\n            res.setHeader('Content-Type', 'application/json')\n            res.end(JSON.stringify({ error: 'not_found', message: `No route for ${req.url}` }))\n            return\n          }\n          trpcHandler(req, res)\n        }\n\n        server = http.createServer((req, res) => {\n          if (corsMiddleware) {\n            corsMiddleware(req, res, () => {\n              if (req.method === 'OPTIONS') { res.statusCode = 204; res.end(); return }\n              handler(req, res)\n            })\n          } else {\n            handler(req, res)\n          }\n        })\n\n        await new Promise<void>((resolve) => {\n          server!.listen(port, host, () => { resolve() })\n        })\n      },\n      stop: async () => {\n        if (!server) { return }\n        await new Promise<void>((resolve, reject) => {\n          server!.close((err) => {\n            if (err) { reject(err) } else { resolve() }\n          })\n        })\n      }\n    }\n  }\n}\n"],"mappings":"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"}