@silkweave/nextjs 3.2.0 → 4.0.0

package/build/index.d.mts

@@ -78,20 +78,6 @@ interface SilkweaveApp<Arr extends readonly Action[]> {
    */
   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

package/build/index.d.mts.map

@@ -1 +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"}
+{"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;;;;KChDN,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;EDlBkB;ECoBnE,GAAA,CAAI,OAAA,EAAS,eAAA,GAAkB,gBAAA;EDjBD;ECmB9B,IAAA,CAAK,OAAA,EAAS,gBAAA,GAAmB,iBAAA;EDPhB;;;;;EAAA,SCaR,MAAA,EAAQ,eAAA,CAAgB,SAAA,CAAU,GAAA;AAAA;AAAA,iBAqC7B,eAAA,4BAA2C,MAAA,GAAA,CACzD,OAAA,EAAS,sBAAA,CAAuB,GAAA,IAC/B,YAAA,CAAa,GAAA;;;;;;ADnEhB;;;;;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

@@ -1,125 +1,5 @@
-import { silkweave } from "@silkweave/core";
-import { edge } from "@silkweave/edge";
-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/edge` 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/edge` (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 } = edge({
-		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
+import { i as rewriteRequestPath, r as normalizeBasePath, t as buildMcpRoute } from "./mcpRoute-Bj68_Fem.mjs";
+import { t as buildTrpcRoute } from "./trpcRoute--ilYwTJu.mjs";
 //#region src/lib/defineSilkweave.ts
 /**
 * Define a Silkweave app from a single set of Actions and project it onto
@@ -135,11 +15,34 @@ function buildTrpcRoute(identity, actions, options) {
 * export type AppRouter = typeof app.Router
 * ```
 */
+/**
+* Build route handlers whose implementing module is `import()`ed lazily on first
+* request, so an app that mounts only one surface never loads the other's stack:
+* an MCP-only app never pulls in `@silkweave/trpc` (an optional peer), and a
+* tRPC-only app never pulls in `@silkweave/edge`. `build()` memoizes across
+* methods, so the underlying `silkweave().start()` runs at most once.
+*/
+function lazyHandlers(methods, load) {
+	let built;
+	const build = () => built ??= load();
+	const handlers = {};
+	for (const method of methods) handlers[method] = async (request) => (await build())[method](request);
+	return handlers;
+}
 function defineSilkweave(options) {
 	const { actions, ...identity } = options;
 	return {
-		mcp: (mcpOptions) => buildMcpRoute(identity, actions, mcpOptions),
-		trpc: (trpcOptions) => buildTrpcRoute(identity, actions, trpcOptions),
+		mcp: (mcpOptions) => lazyHandlers([
+			"GET",
+			"POST",
+			"DELETE",
+			"OPTIONS"
+		], async () => (await import("./mcpRoute-Bj68_Fem.mjs").then((n) => n.n)).buildMcpRoute(identity, actions, mcpOptions)),
+		trpc: (trpcOptions) => lazyHandlers([
+			"GET",
+			"POST",
+			"OPTIONS"
+		], async () => (await import("./trpcRoute--ilYwTJu.mjs").then((n) => n.n)).buildTrpcRoute(identity, actions, trpcOptions)),
 		Router: void 0
 	};
 }

package/build/index.mjs.map

@@ -1 +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/edge` 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 { edge } from '@silkweave/edge'\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/edge` (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 } = edge({\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,KAAK;EAChC,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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/lib/defineSilkweave.ts"],"sourcesContent":["import { Action, Silkweave, SilkweaveOptions } from '@silkweave/core'\nimport type { InferTrpcRouter } from '@silkweave/trpc'\nimport { McpRouteHandlers, McpRouteOptions, NextRouteHandler, TrpcRouteHandlers, TrpcRouteOptions } from '../types.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 */\n/**\n * Build route handlers whose implementing module is `import()`ed lazily on first\n * request, so an app that mounts only one surface never loads the other's stack:\n * an MCP-only app never pulls in `@silkweave/trpc` (an optional peer), and a\n * tRPC-only app never pulls in `@silkweave/edge`. `build()` memoizes across\n * methods, so the underlying `silkweave().start()` runs at most once.\n */\nfunction lazyHandlers<K extends string>(\n  methods: readonly K[],\n  load: () => Promise<Record<K, NextRouteHandler>>\n): Record<K, NextRouteHandler> {\n  let built: Promise<Record<K, NextRouteHandler>> | undefined\n  const build = () => (built ??= load())\n  const handlers = {} as Record<K, NextRouteHandler>\n  for (const method of methods) {\n    handlers[method] = async (request) => (await build())[method](request)\n  }\n  return handlers\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) => lazyHandlers(['GET', 'POST', 'DELETE', 'OPTIONS'], async () =>\n      (await import('./mcpRoute.js')).buildMcpRoute(identity, actions, mcpOptions)),\n    trpc: (trpcOptions) => lazyHandlers(['GET', 'POST', 'OPTIONS'], async () =>\n      (await import('./trpcRoute.js')).buildTrpcRoute(identity, actions, trpcOptions)),\n    Router: undefined as unknown as InferTrpcRouter<AppServer<Arr>>\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAS,aACP,SACA,MAC6B;CAC7B,IAAI;CACJ,MAAM,cAAe,UAAU,MAAM;CACrC,MAAM,WAAW,EAAE;AACnB,MAAK,MAAM,UAAU,QACnB,UAAS,UAAU,OAAO,aAAa,MAAM,OAAO,EAAE,QAAQ,QAAQ;AAExE,QAAO;;AAGT,SAAgB,gBACd,SACmB;CACnB,MAAM,EAAE,SAAS,GAAG,aAAa;AAEjC,QAAO;EACL,MAAM,eAAe,aAAa;GAAC;GAAO;GAAQ;GAAU;GAAU,EAAE,aACrE,MAAM,OAAO,2BAAA,MAAA,MAAA,EAAA,EAAA,EAAkB,cAAc,UAAU,SAAS,WAAW,CAAC;EAC/E,OAAO,gBAAgB,aAAa;GAAC;GAAO;GAAQ;GAAU,EAAE,aAC7D,MAAM,OAAO,4BAAA,MAAA,MAAA,EAAA,EAAA,EAAmB,eAAe,UAAU,SAAS,YAAY,CAAC;EAClF,QAAQ,KAAA;EACT"}

package/build/mcpRoute-Bj68_Fem.mjs

@@ -0,0 +1,79 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { silkweave } from "@silkweave/core";
+import { edge } from "@silkweave/edge";
+//#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/edge` 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
+var mcpRoute_exports = /* @__PURE__ */ __exportAll({ buildMcpRoute: () => buildMcpRoute });
+/**
+* Build the MCP route handlers for a single catch-all Next.js route file.
+*
+* Wires the actions through `@silkweave/edge` (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 } = edge({
+		auth: options.auth,
+		enableJsonResponse: options.enableJsonResponse
+	});
+	silkweave(identity).actions(actions).adapter(adapter).start().catch((error) => {
+		console.error("[silkweave/nextjs] MCP adapter failed to start:", error);
+	});
+	const route = (request) => handler(rewriteRequestPath(request, basePath));
+	return {
+		GET: route,
+		POST: route,
+		DELETE: route,
+		OPTIONS: route
+	};
+}
+//#endregion
+export { rewriteRequestPath as i, mcpRoute_exports as n, normalizeBasePath as r, buildMcpRoute as t };
+
+//# sourceMappingURL=mcpRoute-Bj68_Fem.mjs.map

package/build/mcpRoute-Bj68_Fem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpRoute-Bj68_Fem.mjs","names":[],"sources":["../src/lib/stripPrefix.ts","../src/lib/mcpRoute.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/edge` 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 { edge } from '@silkweave/edge'\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/edge` (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 } = edge({\n    auth: options.auth,\n    enableJsonResponse: options.enableJsonResponse\n  })\n\n  // Kick off the adapter's `_ready` promise (the handler awaits it internally).\n  // We don't await here - that would force a top-level `await` into the route\n  // module - but we MUST catch: an unhandled start() rejection (e.g. an invalid\n  // `disposition: 'structured'` action) would otherwise crash the Next server.\n  // On boot failure edge()'s `_ready` rejects, so requests get a 500, not a hang.\n  silkweave(identity).actions(actions).adapter(adapter).start().catch((error: unknown) => {\n    console.error('[silkweave/nextjs] MCP adapter failed to start:', error)\n  })\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"],"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,KAAK;EAChC,MAAM,QAAQ;EACd,oBAAoB,QAAQ;EAC7B,CAAC;AAOF,WAAU,SAAS,CAAC,QAAQ,QAAQ,CAAC,QAAQ,QAAQ,CAAC,OAAO,CAAC,OAAO,UAAmB;AACtF,UAAQ,MAAM,mDAAmD,MAAM;GACvE;CAEF,MAAM,SAAS,YAAwC,QAAQ,mBAAmB,SAAS,SAAS,CAAC;AAErG,QAAO;EAAE,KAAK;EAAO,MAAM;EAAO,QAAQ;EAAO,SAAS;EAAO"}

package/build/rolldown-runtime-wcPFST8Q.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/build/trpcRoute--ilYwTJu.mjs

@@ -0,0 +1,58 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { silkweave } from "@silkweave/core";
+import { trpcFetch } from "@silkweave/trpc";
+//#region src/lib/trpcRoute.ts
+var trpcRoute_exports = /* @__PURE__ */ __exportAll({ buildTrpcRoute: () => buildTrpcRoute });
+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().catch((error) => {
+		console.error("[silkweave/nextjs] tRPC adapter failed to start:", error);
+	});
+	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
+export { trpcRoute_exports as n, buildTrpcRoute as t };
+
+//# sourceMappingURL=trpcRoute--ilYwTJu.mjs.map

package/build/trpcRoute--ilYwTJu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpcRoute--ilYwTJu.mjs","names":[],"sources":["../src/lib/trpcRoute.ts"],"sourcesContent":["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  // Catch boot failures: an unhandled start() rejection would crash the Next\n  // server. trpcFetch's handler serves a 503 until `_ready` resolves.\n  silkweave(identity).actions(actions).adapter(adapter).start().catch((error: unknown) => {\n    console.error('[silkweave/nextjs] tRPC adapter failed to start:', error)\n  })\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"],"mappings":";;;;;AAIA,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;AAI5F,WAAU,SAAS,CAAC,QAAQ,QAAQ,CAAC,QAAQ,QAAQ,CAAC,OAAO,CAAC,OAAO,UAAmB;AACtF,UAAQ,MAAM,oDAAoD,MAAM;GACxE;CAEF,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silkweave/nextjs",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "description": "Silkweave Next.js App Router Adapter",
   "license": "MIT",
   "homepage": "https://www.silkweave.dev",
@@ -26,23 +26,35 @@
     }
   },
   "dependencies": {
-    "@trpc/server": "^11.7.1",
     "zod": "^3.25.0",
-    "@silkweave/auth": "3.2.0",
-    "@silkweave/core": "3.2.0",
-    "@silkweave/trpc": "3.2.0",
-    "@silkweave/edge": "3.2.0"
+    "@silkweave/auth": "4.0.0",
+    "@silkweave/core": "4.0.0",
+    "@silkweave/edge": "4.0.0"
+  },
+  "peerDependencies": {
+    "@trpc/server": "^11.7.1",
+    "@silkweave/trpc": "4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@silkweave/trpc": {
+      "optional": true
+    },
+    "@trpc/server": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@stylistic/eslint-plugin": "^5.10.0",
+    "@trpc/server": "^11.7.1",
     "@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"
+    "typescript-eslint": "^8.56.1",
+    "@silkweave/trpc": "4.0.0"
   },
   "scripts": {
     "clean": "rimraf build",