@silkweave/nextjs 2.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Silkweave
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# @silkweave/nextjs
+
+Next.js **App Router** adapter for Silkweave. Define a set of Actions once and
+project them onto Next.js route handlers - **MCP tools** for agents and a
+**tRPC endpoint** for your own frontend - from a single source of truth.
+
+This package is action-first and additive: it adds route files to an existing
+Next.js app, it doesn't restructure anything. Under the hood it wraps
+[`@silkweave/vercel`](../vercel) (MCP over Web-Standard Streamable HTTP) and
+[`@silkweave/trpc`](../trpc) (fetch handler), adding the Next.js glue -
+catch-all path normalization, ergonomic route factories, and end-to-end tRPC
+types.
+
+## Install
+
+```bash
+pnpm add @silkweave/nextjs @silkweave/core
+# for the typed tRPC client on the frontend:
+pnpm add @trpc/client
+```
+
+Requires Next.js 13.4+ (App Router). The package itself has no `next`/`react`
+dependency - it only deals with Web-Standard `Request`/`Response`.
+
+## Usage
+
+### 1. Define your actions and the app (single source of truth)
+
+```ts
+// silkweave/actions.ts
+import { createAction } from '@silkweave/core'
+import { z } from 'zod'
+
+export const listUsers = createAction({
+  name: 'list-users',
+  kind: 'query',
+  description: 'List users',
+  input: z.object({ activeOnly: z.boolean().optional() }),
+  run: async ({ activeOnly }) => ({ users: activeOnly ? [] : [{ id: '1' }] })
+})
+
+export const banUser = createAction({
+  name: 'ban-user',
+  description: 'Ban a user',
+  input: z.object({ id: z.string(), reason: z.string().min(3) }),
+  run: async ({ id, reason }) => ({ banned: id, reason })
+})
+```
+
+```ts
+// silkweave/server.ts
+import { defineSilkweave } from '@silkweave/nextjs'
+import { banUser, listUsers } from './actions'
+
+export const app = defineSilkweave({
+  name: 'my-app',
+  description: 'My app exposed to agents + frontend',
+  version: '1.0.0',
+  actions: [listUsers, banUser]
+})
+
+// Type-only export for the tRPC client:
+export type AppRouter = typeof app.Router
+```
+
+### 2. Mount the MCP route (one catch-all file)
+
+```ts
+// app/api/mcp/[[...mcp]]/route.ts
+import { app } from '@/silkweave/server'
+
+export const { GET, POST, DELETE, OPTIONS } = app.mcp({ basePath: '/api/mcp' })
+
+export const dynamic = 'force-dynamic'
+export const runtime = 'nodejs'
+```
+
+The single `[[...mcp]]` catch-all file serves the MCP transport (`/api/mcp`)
+plus any OAuth and protected-resource-metadata sub-paths
+(`/api/mcp/.well-known/...`, `/api/mcp/authorize`, ...). `basePath` is stripped
+from incoming requests so the underlying MCP handler - which matches absolute
+paths - resolves correctly regardless of where you mount it.
+
+### 3. Mount the tRPC route
+
+```ts
+// app/api/trpc/[trpc]/route.ts
+import { app } from '@/silkweave/server'
+
+export const { GET, POST, OPTIONS } = app.trpc({ endpoint: '/api/trpc' })
+
+export const dynamic = 'force-dynamic'
+export const runtime = 'nodejs'
+```
+
+### 4. Call it from your frontend with full type safety
+
+```ts
+// lib/trpc.ts
+import { createTRPCClient, httpBatchLink } from '@trpc/client'
+import type { AppRouter } from '@/silkweave/server'
+
+export const trpc = createTRPCClient<AppRouter>({
+  links: [httpBatchLink({ url: '/api/trpc' })]
+})
+
+// const { users } = await trpc.listUsers.query({ activeOnly: true })
+```
+
+## API
+
+### `defineSilkweave(options)`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `name` / `description` / `version` | `string` | Server identity (`SilkweaveOptions`). |
+| `actions` | `Action[]` | The action set projected onto every surface. |
+
+Returns a `SilkweaveApp` with `.mcp()`, `.trpc()`, and a type-only `Router`
+phantom for client inference (`typeof app.Router`).
+
+### `app.mcp(options)` → `{ GET, POST, DELETE, OPTIONS }`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `basePath` | `string` | - (required) | URL prefix; **must equal the route file's directory** (e.g. `/api/mcp`). |
+| `auth` | `AuthConfig` | - | Bearer-token / OAuth 2.1 config (see `@silkweave/auth`). |
+| `enableJsonResponse` | `boolean` | `false` | Return a single JSON response instead of an SSE stream when possible. |
+
+### `app.trpc(options)` → `{ GET, POST, OPTIONS }`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `endpoint` | `string` | - (required) | tRPC prefix; **must equal the route file's directory minus `[trpc]`** (e.g. `/api/trpc`). |
+| `auth` | `AuthConfig` | - | Bearer-token / OAuth 2.1 config. |
+| `cors` | `boolean` | `false` | Add permissive CORS + an `OPTIONS` handler. Enable only for cross-origin clients - a same-origin Next.js frontend needs none. |
+
+Lower-level building blocks are also exported (`buildMcpRoute`,
+`buildTrpcRoute`, `normalizeBasePath`, `rewriteRequestPath`) for custom wiring.
+
+## Notes & gotchas
+
+- **`basePath` must match the file location.** There's no reliable way to read
+  the mounted URL at module load, so you pass it explicitly and it must equal
+  the route directory (`/api/mcp` ⇄ `app/api/mcp/[[...mcp]]/route.ts`).
+- **Runtime.** Use `runtime = 'nodejs'` (the MCP transport needs Node APIs) and
+  `dynamic = 'force-dynamic'` (these handlers are never statically cached).
+- **RFC 9728 well-known location.** Mounting under `/api/mcp` serves the
+  protected-resource metadata under that prefix. MCP discovery is driven by the
+  URLs you advertise in `auth`, so self-consistent mounting works. For strict
+  spec compliance you can additionally serve
+  `/.well-known/oauth-protected-resource` from a root route file.
+- **Streaming actions over tRPC** register as subscriptions; consuming them
+  needs an SSE/WS tRPC link, not `httpBatchLink`. MCP streams via progress
+  notifications as usual.
+- **One source, many surfaces.** `.mcp()` and `.trpc()` each build their own
+  internal Silkweave instance, so mounting both from the same `app` is safe.
+
+## License
+
+ISC

package/build/index.d.mts

@@ -0,0 +1,141 @@
+import { Action, Silkweave, SilkweaveOptions } from "@silkweave/core";
+import { InferTrpcRouter } from "@silkweave/trpc";
+import { AuthConfig } from "@silkweave/auth";
+
+//#region src/types.d.ts
+/** A Next.js App Router route handler: receives a Web `Request`, returns a `Response`. */
+type NextRouteHandler = (request: Request) => Promise<Response>;
+/** Options for `app.mcp()` - mounts MCP Streamable HTTP under a catch-all route. */
+interface McpRouteOptions {
+  /**
+   * The URL prefix this route is mounted at - it MUST equal the route file's
+   * directory. For `app/api/mcp/[[...mcp]]/route.ts` this is `'/api/mcp'`.
+   *
+   * The adapter strips this prefix from incoming requests so the MCP transport
+   * (`/api/mcp`), OAuth routes (`/api/mcp/authorize`, `/api/mcp/token`, ...) and
+   * the protected-resource metadata (`/api/mcp/.well-known/...`) all resolve
+   * from this single catch-all file.
+   */
+  basePath: string;
+  /** Optional bearer-token / OAuth 2.1 configuration (see `@silkweave/auth`). */
+  auth?: AuthConfig;
+  /** Return a single JSON response instead of an SSE stream when possible. */
+  enableJsonResponse?: boolean;
+}
+/** Options for `app.trpc()` - mounts a tRPC endpoint under a `[trpc]` route. */
+interface TrpcRouteOptions {
+  /**
+   * The tRPC endpoint prefix - it MUST equal the route file's directory minus
+   * the `[trpc]` segment. For `app/api/trpc/[trpc]/route.ts` this is
+   * `'/api/trpc'`. tRPC strips this prefix itself when routing procedures.
+   */
+  endpoint: string;
+  /** Optional bearer-token / OAuth 2.1 configuration (see `@silkweave/auth`). */
+  auth?: AuthConfig;
+  /**
+   * Add permissive CORS headers + an `OPTIONS` preflight handler. Default
+   * `false` - a Next.js frontend calling its own `/api/trpc` is same-origin and
+   * needs no CORS. Enable only for cross-origin tRPC clients.
+   */
+  cors?: boolean;
+}
+/** Handlers to re-export from `app/api/mcp/[[...mcp]]/route.ts`. */
+interface McpRouteHandlers {
+  GET: NextRouteHandler;
+  POST: NextRouteHandler;
+  DELETE: NextRouteHandler;
+  OPTIONS: NextRouteHandler;
+}
+/** Handlers to re-export from `app/api/trpc/[trpc]/route.ts`. */
+interface TrpcRouteHandlers {
+  GET: NextRouteHandler;
+  POST: NextRouteHandler;
+  OPTIONS: NextRouteHandler;
+}
+//#endregion
+//#region src/lib/defineSilkweave.d.ts
+/** Maps the actions tuple into the `Record<name, Action>` shape `Silkweave` carries. */
+type ActionsRecord<Arr extends readonly Action[]> = { [K in Arr[number] as K['name']]: K };
+/** The typed `Silkweave` instance equivalent to `silkweave(...).actions(arr)`. */
+type AppServer<Arr extends readonly Action[]> = Silkweave<ActionsRecord<Arr>>;
+/** Configuration for {@link defineSilkweave}: server identity + the action set. */
+type DefineSilkweaveOptions<Arr extends readonly Action[]> = SilkweaveOptions & {
+  actions: Arr;
+};
+/**
+ * A Silkweave app projected onto Next.js App Router route handlers. Define it
+ * once, then mount the surfaces you need from their respective route files.
+ */
+interface SilkweaveApp<Arr extends readonly Action[]> {
+  /** Build handlers for `app/<basePath>/[[...slug]]/route.ts` (MCP tools). */
+  mcp(options: McpRouteOptions): McpRouteHandlers;
+  /** Build handlers for `app/<endpoint>/[trpc]/route.ts` (tRPC procedures). */
+  trpc(options: TrpcRouteOptions): TrpcRouteHandlers;
+  /**
+   * Type-only phantom for the tRPC client. Use as
+   * `export type AppRouter = typeof app.Router`. Accessing the value at runtime
+   * returns `undefined` - it exists purely to carry the inferred router type.
+   */
+  readonly Router: InferTrpcRouter<AppServer<Arr>>;
+}
+/**
+ * Define a Silkweave app from a single set of Actions and project it onto
+ * Next.js App Router route handlers - MCP (for agents) and tRPC (for your
+ * frontend) - from one source of truth.
+ *
+ * ```ts
+ * // silkweave/server.ts
+ * export const app = defineSilkweave({
+ *   name: 'my-app', description: '...', version: '1.0.0',
+ *   actions: [listUsers, getUser]
+ * })
+ * export type AppRouter = typeof app.Router
+ * ```
+ */
+declare function defineSilkweave<const Arr extends readonly Action[]>(options: DefineSilkweaveOptions<Arr>): SilkweaveApp<Arr>;
+//#endregion
+//#region src/lib/mcpRoute.d.ts
+/**
+ * Build the MCP route handlers for a single catch-all Next.js route file.
+ *
+ * Wires the actions through `@silkweave/vercel` (stateless MCP over Web Standard
+ * Streamable HTTP) and wraps its handler with a prefix-stripping rewrite so the
+ * transport, OAuth routes and protected-resource metadata all resolve from one
+ * `app/<basePath>/[[...slug]]/route.ts` file.
+ */
+declare function buildMcpRoute(identity: SilkweaveOptions, actions: readonly Action[], options: McpRouteOptions): McpRouteHandlers;
+//#endregion
+//#region src/lib/trpcRoute.d.ts
+/**
+ * Build the tRPC route handlers for a `[trpc]` Next.js route file.
+ *
+ * Wires the actions through `@silkweave/trpc`'s fetch handler. tRPC strips the
+ * `endpoint` prefix itself, so no URL rewriting is needed. CORS is opt-in
+ * (`options.cors`) since a Next.js frontend hitting its own `/api/trpc` is
+ * same-origin.
+ */
+declare function buildTrpcRoute(identity: SilkweaveOptions, actions: readonly Action[], options: TrpcRouteOptions): TrpcRouteHandlers;
+//#endregion
+//#region src/lib/stripPrefix.d.ts
+/**
+ * Normalize a user-supplied mount path: ensure a single leading slash and no
+ * trailing slash. `'api/mcp/'` -> `'/api/mcp'`, `'/'` -> `''`.
+ */
+declare function normalizeBasePath(basePath: string): string;
+/**
+ * Rewrite a Web `Request`'s URL so the inner `@silkweave/vercel` MCP handler -
+ * which matches absolute pathnames (`/mcp`, `/authorize`, `/.well-known/...`) -
+ * sees canonical paths regardless of where the Next.js route is mounted.
+ *
+ * Given `basePath = '/api/mcp'`:
+ *   `/api/mcp`                              -> `/mcp`   (the transport root)
+ *   `/api/mcp/authorize`                    -> `/authorize`
+ *   `/api/mcp/.well-known/oauth-...`        -> `/.well-known/oauth-...`
+ *
+ * The method, headers, body and abort signal are preserved. A streaming body
+ * requires `duplex: 'half'` under Node's undici `fetch` implementation.
+ */
+declare function rewriteRequestPath(request: Request, basePath: string, fallback?: string): Request;
+//#endregion
+export { type DefineSilkweaveOptions, type McpRouteHandlers, type McpRouteOptions, type NextRouteHandler, type SilkweaveApp, type TrpcRouteHandlers, type TrpcRouteOptions, buildMcpRoute, buildTrpcRoute, defineSilkweave, normalizeBasePath, rewriteRequestPath };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/lib/defineSilkweave.ts","../src/lib/mcpRoute.ts","../src/lib/trpcRoute.ts","../src/lib/stripPrefix.ts"],"mappings":";;;;;;KAGY,gBAAA,IAAoB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;;UAG5C,eAAA;EAHL;;;;;;;;;EAaV,QAAA;EAbmD;EAenD,IAAA,GAAO,UAAA;EAf4D;EAiBnE,kBAAA;AAAA;;UAIe,gBAAA;EANE;;;;;EAYjB,QAAA;EAVkB;EAYlB,IAAA,GAAO,UAAA;EARwB;;;;;EAc/B,IAAA;AAAA;;UAIe,gBAAA;EACf,GAAA,EAAK,gBAAA;EACL,IAAA,EAAM,gBAAA;EACN,MAAA,EAAQ,gBAAA;EACR,OAAA,EAAS,gBAAA;AAAA;;UAIM,iBAAA;EACf,GAAA,EAAK,gBAAA;EACL,IAAA,EAAM,gBAAA;EACN,OAAA,EAAS,gBAAA;AAAA;;;;KC9CN,aAAA,sBAAmC,MAAA,cAChC,GAAA,YAAe,CAAA,WAAY,CAAA;;KAI9B,SAAA,sBAA+B,MAAA,MAAY,SAAA,CAAU,aAAA,CAAc,GAAA;;KAG5D,sBAAA,sBAA4C,MAAA,MAAY,gBAAA;EAClE,OAAA,EAAS,GAAA;AAAA;;;;;UAOM,YAAA,sBAAkC,MAAA;EDpBkB;ECsBnE,GAAA,CAAI,OAAA,EAAS,eAAA,GAAkB,gBAAA;EDnBD;ECqB9B,IAAA,CAAK,OAAA,EAAS,gBAAA,GAAmB,iBAAA;EDThB;;;;;EAAA,SCeR,MAAA,EAAQ,eAAA,CAAgB,SAAA,CAAU,GAAA;AAAA;ADT7C;;;;;;;;;;AAkBA;;;;AAlBA,iBC0BgB,eAAA,4BAA2C,MAAA,GAAA,CACzD,OAAA,EAAS,sBAAA,CAAuB,GAAA,IAC/B,YAAA,CAAa,GAAA;;;;;;ADjDhB;;;;;iBEUgB,aAAA,CACd,QAAA,EAAU,gBAAA,EACV,OAAA,WAAkB,MAAA,IAClB,OAAA,EAAS,eAAA,GACR,gBAAA;;;;;;AFdH;;;;;iBGyBgB,cAAA,CACd,QAAA,EAAU,gBAAA,EACV,OAAA,WAAkB,MAAA,IAClB,OAAA,EAAS,gBAAA,GACR,iBAAA;;;;;;;iBC5Ba,iBAAA,CAAkB,QAAA;AJDlC;;;;;;;;;;;;;AAAA,iBIoBgB,kBAAA,CAAmB,OAAA,EAAS,OAAA,EAAS,QAAA,UAAkB,QAAA,YAAoB,OAAA"}

package/build/index.mjs

@@ -0,0 +1,149 @@
+import { silkweave } from "@silkweave/core";
+import { vercel } from "@silkweave/vercel";
+import { trpcFetch } from "@silkweave/trpc";
+//#region src/lib/stripPrefix.ts
+/**
+* Normalize a user-supplied mount path: ensure a single leading slash and no
+* trailing slash. `'api/mcp/'` -> `'/api/mcp'`, `'/'` -> `''`.
+*/
+function normalizeBasePath(basePath) {
+	const trimmed = basePath.trim().replace(/\/+$/, "");
+	if (trimmed === "" || trimmed === "/") return "";
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+/**
+* Rewrite a Web `Request`'s URL so the inner `@silkweave/vercel` MCP handler -
+* which matches absolute pathnames (`/mcp`, `/authorize`, `/.well-known/...`) -
+* sees canonical paths regardless of where the Next.js route is mounted.
+*
+* Given `basePath = '/api/mcp'`:
+*   `/api/mcp`                              -> `/mcp`   (the transport root)
+*   `/api/mcp/authorize`                    -> `/authorize`
+*   `/api/mcp/.well-known/oauth-...`        -> `/.well-known/oauth-...`
+*
+* The method, headers, body and abort signal are preserved. A streaming body
+* requires `duplex: 'half'` under Node's undici `fetch` implementation.
+*/
+function rewriteRequestPath(request, basePath, fallback = "/mcp") {
+	const base = normalizeBasePath(basePath);
+	const url = new URL(request.url);
+	let rest = url.pathname;
+	if (base !== "") {
+		if (rest === base) rest = fallback;
+		else if (rest.startsWith(`${base}/`)) rest = rest.slice(base.length);
+	}
+	if (rest === "" || rest === "/") rest = fallback;
+	url.pathname = rest;
+	const init = {
+		method: request.method,
+		headers: request.headers,
+		signal: request.signal
+	};
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		init.body = request.body;
+		init.duplex = "half";
+	}
+	return new Request(url.toString(), init);
+}
+//#endregion
+//#region src/lib/mcpRoute.ts
+/**
+* Build the MCP route handlers for a single catch-all Next.js route file.
+*
+* Wires the actions through `@silkweave/vercel` (stateless MCP over Web Standard
+* Streamable HTTP) and wraps its handler with a prefix-stripping rewrite so the
+* transport, OAuth routes and protected-resource metadata all resolve from one
+* `app/<basePath>/[[...slug]]/route.ts` file.
+*/
+function buildMcpRoute(identity, actions, options) {
+	const basePath = normalizeBasePath(options.basePath);
+	const { adapter, handler } = vercel({
+		auth: options.auth,
+		enableJsonResponse: options.enableJsonResponse
+	});
+	silkweave(identity).actions(actions).adapter(adapter).start();
+	const route = (request) => handler(rewriteRequestPath(request, basePath));
+	return {
+		GET: route,
+		POST: route,
+		DELETE: route,
+		OPTIONS: route
+	};
+}
+//#endregion
+//#region src/lib/trpcRoute.ts
+const CORS_HEADERS = {
+	"Access-Control-Allow-Origin": "*",
+	"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+	"Access-Control-Allow-Headers": "*",
+	"Access-Control-Max-Age": "86400"
+};
+function withCors(handler) {
+	return async (request) => {
+		const response = await handler(request);
+		const headers = new Headers(response.headers);
+		for (const [key, value] of Object.entries(CORS_HEADERS)) headers.set(key, value);
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	};
+}
+/**
+* Build the tRPC route handlers for a `[trpc]` Next.js route file.
+*
+* Wires the actions through `@silkweave/trpc`'s fetch handler. tRPC strips the
+* `endpoint` prefix itself, so no URL rewriting is needed. CORS is opt-in
+* (`options.cors`) since a Next.js frontend hitting its own `/api/trpc` is
+* same-origin.
+*/
+function buildTrpcRoute(identity, actions, options) {
+	const { adapter, GET, POST } = trpcFetch({
+		endpoint: options.endpoint,
+		auth: options.auth
+	});
+	silkweave(identity).actions(actions).adapter(adapter).start();
+	const optionsHandler = () => Promise.resolve(new Response(null, {
+		status: 204,
+		headers: options.cors ? CORS_HEADERS : {}
+	}));
+	if (!options.cors) return {
+		GET,
+		POST,
+		OPTIONS: optionsHandler
+	};
+	return {
+		GET: withCors(GET),
+		POST: withCors(POST),
+		OPTIONS: optionsHandler
+	};
+}
+//#endregion
+//#region src/lib/defineSilkweave.ts
+/**
+* Define a Silkweave app from a single set of Actions and project it onto
+* Next.js App Router route handlers - MCP (for agents) and tRPC (for your
+* frontend) - from one source of truth.
+*
+* ```ts
+* // silkweave/server.ts
+* export const app = defineSilkweave({
+*   name: 'my-app', description: '...', version: '1.0.0',
+*   actions: [listUsers, getUser]
+* })
+* export type AppRouter = typeof app.Router
+* ```
+*/
+function defineSilkweave(options) {
+	const { actions, ...identity } = options;
+	return {
+		mcp: (mcpOptions) => buildMcpRoute(identity, actions, mcpOptions),
+		trpc: (trpcOptions) => buildTrpcRoute(identity, actions, trpcOptions),
+		Router: void 0
+	};
+}
+//#endregion
+export { buildMcpRoute, buildTrpcRoute, defineSilkweave, normalizeBasePath, rewriteRequestPath };
+
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/lib/stripPrefix.ts","../src/lib/mcpRoute.ts","../src/lib/trpcRoute.ts","../src/lib/defineSilkweave.ts"],"sourcesContent":["/**\n * Normalize a user-supplied mount path: ensure a single leading slash and no\n * trailing slash. `'api/mcp/'` -> `'/api/mcp'`, `'/'` -> `''`.\n */\nexport function normalizeBasePath(basePath: string): string {\n  const trimmed = basePath.trim().replace(/\\/+$/, '')\n  if (trimmed === '' || trimmed === '/') { return '' }\n  return trimmed.startsWith('/') ? trimmed : `/${trimmed}`\n}\n\n/**\n * Rewrite a Web `Request`'s URL so the inner `@silkweave/vercel` MCP handler -\n * which matches absolute pathnames (`/mcp`, `/authorize`, `/.well-known/...`) -\n * sees canonical paths regardless of where the Next.js route is mounted.\n *\n * Given `basePath = '/api/mcp'`:\n *   `/api/mcp`                              -> `/mcp`   (the transport root)\n *   `/api/mcp/authorize`                    -> `/authorize`\n *   `/api/mcp/.well-known/oauth-...`        -> `/.well-known/oauth-...`\n *\n * The method, headers, body and abort signal are preserved. A streaming body\n * requires `duplex: 'half'` under Node's undici `fetch` implementation.\n */\nexport function rewriteRequestPath(request: Request, basePath: string, fallback = '/mcp'): Request {\n  const base = normalizeBasePath(basePath)\n  const url = new URL(request.url)\n\n  let rest = url.pathname\n  if (base !== '') {\n    if (rest === base) {\n      rest = fallback\n    } else if (rest.startsWith(`${base}/`)) {\n      rest = rest.slice(base.length)\n    }\n  }\n  if (rest === '' || rest === '/') { rest = fallback }\n  url.pathname = rest\n\n  const init: RequestInit & { duplex?: 'half' } = {\n    method: request.method,\n    headers: request.headers,\n    signal: request.signal\n  }\n  if (request.method !== 'GET' && request.method !== 'HEAD') {\n    init.body = request.body\n    init.duplex = 'half'\n  }\n  return new Request(url.toString(), init)\n}\n","import { Action, silkweave, SilkweaveOptions } from '@silkweave/core'\nimport { vercel } from '@silkweave/vercel'\nimport { McpRouteHandlers, McpRouteOptions } from '../types.js'\nimport { normalizeBasePath, rewriteRequestPath } from './stripPrefix.js'\n\n/**\n * Build the MCP route handlers for a single catch-all Next.js route file.\n *\n * Wires the actions through `@silkweave/vercel` (stateless MCP over Web Standard\n * Streamable HTTP) and wraps its handler with a prefix-stripping rewrite so the\n * transport, OAuth routes and protected-resource metadata all resolve from one\n * `app/<basePath>/[[...slug]]/route.ts` file.\n */\nexport function buildMcpRoute(\n  identity: SilkweaveOptions,\n  actions: readonly Action[],\n  options: McpRouteOptions\n): McpRouteHandlers {\n  const basePath = normalizeBasePath(options.basePath)\n  const { adapter, handler } = vercel({\n    auth: options.auth,\n    enableJsonResponse: options.enableJsonResponse\n  })\n\n  // Resolve the adapter's `_ready` promise. The handler awaits it internally, so\n  // we don't need to await here - a floating start is safe and avoids forcing a\n  // top-level `await` into the consumer's route module.\n  void silkweave(identity).actions(actions).adapter(adapter).start()\n\n  const route = (request: Request): Promise<Response> => handler(rewriteRequestPath(request, basePath))\n\n  return { GET: route, POST: route, DELETE: route, OPTIONS: route }\n}\n","import { Action, silkweave, SilkweaveOptions } from '@silkweave/core'\nimport { trpcFetch } from '@silkweave/trpc'\nimport { NextRouteHandler, TrpcRouteHandlers, TrpcRouteOptions } from '../types.js'\n\nconst CORS_HEADERS: Record<string, string> = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',\n  'Access-Control-Allow-Headers': '*',\n  'Access-Control-Max-Age': '86400'\n}\n\nfunction withCors(handler: NextRouteHandler): NextRouteHandler {\n  return async (request) => {\n    const response = await handler(request)\n    const headers = new Headers(response.headers)\n    for (const [key, value] of Object.entries(CORS_HEADERS)) { headers.set(key, value) }\n    return new Response(response.body, { status: response.status, statusText: response.statusText, headers })\n  }\n}\n\n/**\n * Build the tRPC route handlers for a `[trpc]` Next.js route file.\n *\n * Wires the actions through `@silkweave/trpc`'s fetch handler. tRPC strips the\n * `endpoint` prefix itself, so no URL rewriting is needed. CORS is opt-in\n * (`options.cors`) since a Next.js frontend hitting its own `/api/trpc` is\n * same-origin.\n */\nexport function buildTrpcRoute(\n  identity: SilkweaveOptions,\n  actions: readonly Action[],\n  options: TrpcRouteOptions\n): TrpcRouteHandlers {\n  const { adapter, GET, POST } = trpcFetch({ endpoint: options.endpoint, auth: options.auth })\n\n  void silkweave(identity).actions(actions).adapter(adapter).start()\n\n  const optionsHandler: NextRouteHandler = () =>\n    Promise.resolve(new Response(null, { status: 204, headers: options.cors ? CORS_HEADERS : {} }))\n\n  if (!options.cors) {\n    return { GET, POST, OPTIONS: optionsHandler }\n  }\n  return { GET: withCors(GET), POST: withCors(POST), OPTIONS: optionsHandler }\n}\n","import { Action, Silkweave, SilkweaveOptions } from '@silkweave/core'\nimport type { InferTrpcRouter } from '@silkweave/trpc'\nimport { McpRouteHandlers, McpRouteOptions, TrpcRouteHandlers, TrpcRouteOptions } from '../types.js'\nimport { buildMcpRoute } from './mcpRoute.js'\nimport { buildTrpcRoute } from './trpcRoute.js'\n\n/** Maps the actions tuple into the `Record<name, Action>` shape `Silkweave` carries. */\ntype ActionsRecord<Arr extends readonly Action[]> = {\n  [K in Arr[number] as K['name']]: K\n}\n\n/** The typed `Silkweave` instance equivalent to `silkweave(...).actions(arr)`. */\ntype AppServer<Arr extends readonly Action[]> = Silkweave<ActionsRecord<Arr>>\n\n/** Configuration for {@link defineSilkweave}: server identity + the action set. */\nexport type DefineSilkweaveOptions<Arr extends readonly Action[]> = SilkweaveOptions & {\n  actions: Arr\n}\n\n/**\n * A Silkweave app projected onto Next.js App Router route handlers. Define it\n * once, then mount the surfaces you need from their respective route files.\n */\nexport interface SilkweaveApp<Arr extends readonly Action[]> {\n  /** Build handlers for `app/<basePath>/[[...slug]]/route.ts` (MCP tools). */\n  mcp(options: McpRouteOptions): McpRouteHandlers\n  /** Build handlers for `app/<endpoint>/[trpc]/route.ts` (tRPC procedures). */\n  trpc(options: TrpcRouteOptions): TrpcRouteHandlers\n  /**\n   * Type-only phantom for the tRPC client. Use as\n   * `export type AppRouter = typeof app.Router`. Accessing the value at runtime\n   * returns `undefined` - it exists purely to carry the inferred router type.\n   */\n  readonly Router: InferTrpcRouter<AppServer<Arr>>\n}\n\n/**\n * Define a Silkweave app from a single set of Actions and project it onto\n * Next.js App Router route handlers - MCP (for agents) and tRPC (for your\n * frontend) - from one source of truth.\n *\n * ```ts\n * // silkweave/server.ts\n * export const app = defineSilkweave({\n *   name: 'my-app', description: '...', version: '1.0.0',\n *   actions: [listUsers, getUser]\n * })\n * export type AppRouter = typeof app.Router\n * ```\n */\nexport function defineSilkweave<const Arr extends readonly Action[]>(\n  options: DefineSilkweaveOptions<Arr>\n): SilkweaveApp<Arr> {\n  const { actions, ...identity } = options\n\n  return {\n    mcp: (mcpOptions) => buildMcpRoute(identity, actions, mcpOptions),\n    trpc: (trpcOptions) => buildTrpcRoute(identity, actions, trpcOptions),\n    Router: undefined as unknown as InferTrpcRouter<AppServer<Arr>>\n  }\n}\n"],"mappings":";;;;;;;;AAIA,SAAgB,kBAAkB,UAA0B;CAC1D,MAAM,UAAU,SAAS,MAAM,CAAC,QAAQ,QAAQ,GAAG;AACnD,KAAI,YAAY,MAAM,YAAY,IAAO,QAAO;AAChD,QAAO,QAAQ,WAAW,IAAI,GAAG,UAAU,IAAI;;;;;;;;;;;;;;;AAgBjD,SAAgB,mBAAmB,SAAkB,UAAkB,WAAW,QAAiB;CACjG,MAAM,OAAO,kBAAkB,SAAS;CACxC,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;CAEhC,IAAI,OAAO,IAAI;AACf,KAAI,SAAS;MACP,SAAS,KACX,QAAO;WACE,KAAK,WAAW,GAAG,KAAK,GAAG,CACpC,QAAO,KAAK,MAAM,KAAK,OAAO;;AAGlC,KAAI,SAAS,MAAM,SAAS,IAAO,QAAO;AAC1C,KAAI,WAAW;CAEf,MAAM,OAA0C;EAC9C,QAAQ,QAAQ;EAChB,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EACjB;AACD,KAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,QAAQ;AACzD,OAAK,OAAO,QAAQ;AACpB,OAAK,SAAS;;AAEhB,QAAO,IAAI,QAAQ,IAAI,UAAU,EAAE,KAAK;;;;;;;;;;;;AClC1C,SAAgB,cACd,UACA,SACA,SACkB;CAClB,MAAM,WAAW,kBAAkB,QAAQ,SAAS;CACpD,MAAM,EAAE,SAAS,YAAY,OAAO;EAClC,MAAM,QAAQ;EACd,oBAAoB,QAAQ;EAC7B,CAAC;AAKG,WAAU,SAAS,CAAC,QAAQ,QAAQ,CAAC,QAAQ,QAAQ,CAAC,OAAO;CAElE,MAAM,SAAS,YAAwC,QAAQ,mBAAmB,SAAS,SAAS,CAAC;AAErG,QAAO;EAAE,KAAK;EAAO,MAAM;EAAO,QAAQ;EAAO,SAAS;EAAO;;;;AC3BnE,MAAM,eAAuC;CAC3C,+BAA+B;CAC/B,gCAAgC;CAChC,gCAAgC;CAChC,0BAA0B;CAC3B;AAED,SAAS,SAAS,SAA6C;AAC7D,QAAO,OAAO,YAAY;EACxB,MAAM,WAAW,MAAM,QAAQ,QAAQ;EACvC,MAAM,UAAU,IAAI,QAAQ,SAAS,QAAQ;AAC7C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,aAAa,CAAI,SAAQ,IAAI,KAAK,MAAM;AAClF,SAAO,IAAI,SAAS,SAAS,MAAM;GAAE,QAAQ,SAAS;GAAQ,YAAY,SAAS;GAAY;GAAS,CAAC;;;;;;;;;;;AAY7G,SAAgB,eACd,UACA,SACA,SACmB;CACnB,MAAM,EAAE,SAAS,KAAK,SAAS,UAAU;EAAE,UAAU,QAAQ;EAAU,MAAM,QAAQ;EAAM,CAAC;AAEvF,WAAU,SAAS,CAAC,QAAQ,QAAQ,CAAC,QAAQ,QAAQ,CAAC,OAAO;CAElE,MAAM,uBACJ,QAAQ,QAAQ,IAAI,SAAS,MAAM;EAAE,QAAQ;EAAK,SAAS,QAAQ,OAAO,eAAe,EAAE;EAAE,CAAC,CAAC;AAEjG,KAAI,CAAC,QAAQ,KACX,QAAO;EAAE;EAAK;EAAM,SAAS;EAAgB;AAE/C,QAAO;EAAE,KAAK,SAAS,IAAI;EAAE,MAAM,SAAS,KAAK;EAAE,SAAS;EAAgB;;;;;;;;;;;;;;;;;;ACO9E,SAAgB,gBACd,SACmB;CACnB,MAAM,EAAE,SAAS,GAAG,aAAa;AAEjC,QAAO;EACL,MAAM,eAAe,cAAc,UAAU,SAAS,WAAW;EACjE,OAAO,gBAAgB,eAAe,UAAU,SAAS,YAAY;EACrE,QAAQ,KAAA;EACT"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@silkweave/nextjs",
+  "version": "2.4.0",
+  "description": "Silkweave Next.js App Router Adapter",
+  "license": "MIT",
+  "homepage": "https://www.silkweave.dev",
+  "bugs": {
+    "url": "https://github.com/silkweave/silkweave/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/silkweave/silkweave.git",
+    "directory": "packages/nextjs"
+  },
+  "type": "module",
+  "main": "./build/index.mjs",
+  "types": "./build/index.d.mts",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "@silkweave/source": "./src/index.ts",
+      "types": "./build/index.d.mts",
+      "default": "./build/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@trpc/server": "^11.7.1",
+    "zod": "^3.25.0",
+    "@silkweave/auth": "2.4.0",
+    "@silkweave/core": "2.4.0",
+    "@silkweave/trpc": "2.4.0",
+    "@silkweave/vercel": "2.4.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^10.4.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.8",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint",
+    "check": "pnpm lint && pnpm typecheck"
+  }
+}