@analogjs/vite-plugin-nitro 3.0.0-alpha.64 → 3.0.0-alpha.65

package/src/lib/utils/inject-server-fn-ids.js

@@ -0,0 +1,94 @@
+import { deriveServerFnId } from "./derive-server-fn-id.js";
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
+//#region packages/vite-plugin-nitro/src/lib/utils/inject-server-fn-ids.ts
+var SERVER_FN_SOURCE = "@analogjs/router/server";
+/**
+* Server/SSR-build transform: injects the derived `id` into each
+* `export const NAME = serverFn(config, handler)` so the function registers
+* under the same opaque id the client proxy dispatches to. Unlike the client
+* scrub this keeps the handler and every other statement intact — it only edits
+* the config object — so the server module still runs the real implementation.
+*
+* Returns `null` when the module defines no server function.
+*/
+function injectServerFnIds(code, fileId) {
+	if (!code.includes("serverFn")) return null;
+	const { program } = parseSync(fileId, code);
+	const body = program.body;
+	const serverFnLocalNames = collectServerFnLocalNames(body);
+	const magic = new MagicString(code);
+	const ids = [];
+	for (const node of body) {
+		if (node.type !== "ExportNamedDeclaration" || node.declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of node.declaration.declarations) {
+			if (declarator.id?.type !== "Identifier" || declarator.init?.type !== "CallExpression" || declarator.init.callee?.type !== "Identifier" || !serverFnLocalNames.has(declarator.init.callee.name)) continue;
+			const name = declarator.id.name;
+			const id = deriveServerFnId(fileId, name);
+			ids.push({
+				name,
+				id
+			});
+			const args = declarator.init.arguments ?? [];
+			const arg0 = args[0];
+			const idProp = `id: ${JSON.stringify(id)}`;
+			if (arg0?.type === "ObjectExpression") {
+				assertMethodInputCompatible(arg0, name, fileId);
+				injectId(magic, arg0, id);
+			} else if (isFunctionNode(arg0)) magic.appendLeft(arg0.start, `{ ${idProp} }, `);
+			else if (arg0 && args.length >= 2) {
+				magic.appendLeft(arg0.start, `{ ${idProp}, input: `);
+				magic.appendRight(arg0.end, ` }`);
+			} else throw new Error(`[analog] serverFn "${name}" in ${fileId} must be called as serverFn(handler), serverFn(schema, handler), or serverFn(config, handler).`);
+		}
+	}
+	if (ids.length === 0) return null;
+	return {
+		code: magic.toString(),
+		ids
+	};
+}
+/**
+* Insert (or replace) `id: "<derived>"` in the config object. Authors do not
+* supply an id; a stray one is overwritten so the route is always the derived,
+* non-enumerable digest — never an author-controlled value.
+*/
+function injectId(magic, configArg, id) {
+	const existing = (configArg.properties ?? []).find((prop) => prop.type === "Property" && (prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value) === "id");
+	if (existing) {
+		magic.overwrite(existing.value.start, existing.value.end, JSON.stringify(id));
+		return;
+	}
+	magic.appendRight(configArg.start + 1, ` id: ${JSON.stringify(id)},`);
+}
+/**
+* Reject `method: 'GET'` alongside an `input` schema at build time: GET carries
+* no body, so a GET function can never receive validated input.
+*/
+function assertMethodInputCompatible(configArg, name, fileId) {
+	let method;
+	let hasInput = false;
+	for (const prop of configArg.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const key = prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value;
+		if (key === "method" && prop.value?.type === "Literal") method = prop.value.value;
+		else if (key === "input") hasInput = true;
+	}
+	if (method === "GET" && hasInput) throw new Error(`[analog] serverFn "${name}" in ${fileId} declares method: 'GET' with an input schema; GET carries no body. Use POST (the default when input is present) or drop the input.`);
+}
+function isFunctionNode(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function collectServerFnLocalNames(body) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration" || node.source?.value !== SERVER_FN_SOURCE) continue;
+		for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier" && spec.imported?.name === "serverFn") names.add(spec.local.name);
+	}
+	if (names.size === 0) names.add("serverFn");
+	return names;
+}
+//#endregion
+export { injectServerFnIds };
+
+//# sourceMappingURL=inject-server-fn-ids.js.map

package/src/lib/utils/inject-server-fn-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-server-fn-ids.js","names":[],"sources":["../../../../src/lib/utils/inject-server-fn-ids.ts"],"sourcesContent":["import MagicString from 'magic-string';\nimport { parseSync } from 'oxc-parser';\n\nimport { deriveServerFnId } from './derive-server-fn-id.js';\n\nconst SERVER_FN_SOURCE = '@analogjs/router/server';\n\nexport interface InjectServerFnIdsResult {\n  code: string;\n  ids: { name: string; id: string }[];\n}\n\n/**\n * Server/SSR-build transform: injects the derived `id` into each\n * `export const NAME = serverFn(config, handler)` so the function registers\n * under the same opaque id the client proxy dispatches to. Unlike the client\n * scrub this keeps the handler and every other statement intact — it only edits\n * the config object — so the server module still runs the real implementation.\n *\n * Returns `null` when the module defines no server function.\n */\nexport function injectServerFnIds(\n  code: string,\n  fileId: string,\n): InjectServerFnIdsResult | null {\n  if (!code.includes('serverFn')) {\n    return null;\n  }\n\n  const { program } = parseSync(fileId, code);\n  const body = (program as { body: any[] }).body;\n  const serverFnLocalNames = collectServerFnLocalNames(body);\n\n  const magic = new MagicString(code);\n  const ids: { name: string; id: string }[] = [];\n\n  for (const node of body) {\n    if (\n      node.type !== 'ExportNamedDeclaration' ||\n      node.declaration?.type !== 'VariableDeclaration'\n    ) {\n      continue;\n    }\n    for (const declarator of node.declaration.declarations) {\n      if (\n        declarator.id?.type !== 'Identifier' ||\n        declarator.init?.type !== 'CallExpression' ||\n        declarator.init.callee?.type !== 'Identifier' ||\n        !serverFnLocalNames.has(declarator.init.callee.name)\n      ) {\n        continue;\n      }\n\n      const name = declarator.id.name;\n      const id = deriveServerFnId(fileId, name);\n      ids.push({ name, id });\n\n      const args = declarator.init.arguments ?? [];\n      const arg0 = args[0];\n      const idProp = `id: ${JSON.stringify(id)}`;\n\n      if (arg0?.type === 'ObjectExpression') {\n        // serverFn({ … }, handler) — inject the id into the config object.\n        assertMethodInputCompatible(arg0, name, fileId);\n        injectId(magic, arg0, id);\n      } else if (isFunctionNode(arg0)) {\n        // serverFn(handler) — synthesize a config: `{ id }, handler`.\n        magic.appendLeft(arg0.start, `{ ${idProp} }, `);\n      } else if (arg0 && args.length >= 2) {\n        // serverFn(schema, handler) — wrap the schema into `{ id, input: <schema> }`.\n        magic.appendLeft(arg0.start, `{ ${idProp}, input: `);\n        magic.appendRight(arg0.end, ` }`);\n      } else {\n        throw new Error(\n          `[analog] serverFn \"${name}\" in ${fileId} must be called as serverFn(handler), serverFn(schema, handler), or serverFn(config, handler).`,\n        );\n      }\n    }\n  }\n\n  if (ids.length === 0) {\n    return null;\n  }\n\n  return { code: magic.toString(), ids };\n}\n\n/**\n * Insert (or replace) `id: \"<derived>\"` in the config object. Authors do not\n * supply an id; a stray one is overwritten so the route is always the derived,\n * non-enumerable digest — never an author-controlled value.\n */\nfunction injectId(magic: MagicString, configArg: any, id: string): void {\n  const existing = (configArg.properties ?? []).find(\n    (prop: any) =>\n      prop.type === 'Property' &&\n      (prop.key?.type === 'Identifier' ? prop.key.name : prop.key?.value) ===\n        'id',\n  );\n\n  if (existing) {\n    magic.overwrite(\n      existing.value.start,\n      existing.value.end,\n      JSON.stringify(id),\n    );\n    return;\n  }\n\n  // Insert as the first property, right after the opening brace.\n  magic.appendRight(configArg.start + 1, ` id: ${JSON.stringify(id)},`);\n}\n\n/**\n * Reject `method: 'GET'` alongside an `input` schema at build time: GET carries\n * no body, so a GET function can never receive validated input.\n */\nfunction assertMethodInputCompatible(\n  configArg: any,\n  name: string,\n  fileId: string,\n): void {\n  let method: string | undefined;\n  let hasInput = false;\n  for (const prop of configArg.properties ?? []) {\n    if (prop.type !== 'Property') continue;\n    const key =\n      prop.key?.type === 'Identifier' ? prop.key.name : prop.key?.value;\n    if (key === 'method' && prop.value?.type === 'Literal') {\n      method = prop.value.value;\n    } else if (key === 'input') {\n      hasInput = true;\n    }\n  }\n  if (method === 'GET' && hasInput) {\n    throw new Error(\n      `[analog] serverFn \"${name}\" in ${fileId} declares method: 'GET' with an input schema; GET carries no body. Use POST (the default when input is present) or drop the input.`,\n    );\n  }\n}\n\nfunction isFunctionNode(node: any): boolean {\n  return (\n    node?.type === 'ArrowFunctionExpression' ||\n    node?.type === 'FunctionExpression'\n  );\n}\n\nfunction collectServerFnLocalNames(body: any[]): Set<string> {\n  const names = new Set<string>();\n  for (const node of body) {\n    if (\n      node.type !== 'ImportDeclaration' ||\n      node.source?.value !== SERVER_FN_SOURCE\n    ) {\n      continue;\n    }\n    for (const spec of node.specifiers ?? []) {\n      if (\n        spec.type === 'ImportSpecifier' &&\n        spec.imported?.name === 'serverFn'\n      ) {\n        names.add(spec.local.name);\n      }\n    }\n  }\n  if (names.size === 0) {\n    names.add('serverFn');\n  }\n  return names;\n}\n"],"mappings":";;;;AAKA,IAAM,mBAAmB;;;;;;;;;;AAgBzB,SAAgB,kBACd,MACA,QACgC;AAChC,KAAI,CAAC,KAAK,SAAS,WAAW,CAC5B,QAAO;CAGT,MAAM,EAAE,YAAY,UAAU,QAAQ,KAAK;CAC3C,MAAM,OAAQ,QAA4B;CAC1C,MAAM,qBAAqB,0BAA0B,KAAK;CAE1D,MAAM,QAAQ,IAAI,YAAY,KAAK;CACnC,MAAM,MAAsC,EAAE;AAE9C,MAAK,MAAM,QAAQ,MAAM;AACvB,MACE,KAAK,SAAS,4BACd,KAAK,aAAa,SAAS,sBAE3B;AAEF,OAAK,MAAM,cAAc,KAAK,YAAY,cAAc;AACtD,OACE,WAAW,IAAI,SAAS,gBACxB,WAAW,MAAM,SAAS,oBAC1B,WAAW,KAAK,QAAQ,SAAS,gBACjC,CAAC,mBAAmB,IAAI,WAAW,KAAK,OAAO,KAAK,CAEpD;GAGF,MAAM,OAAO,WAAW,GAAG;GAC3B,MAAM,KAAK,iBAAiB,QAAQ,KAAK;AACzC,OAAI,KAAK;IAAE;IAAM;IAAI,CAAC;GAEtB,MAAM,OAAO,WAAW,KAAK,aAAa,EAAE;GAC5C,MAAM,OAAO,KAAK;GAClB,MAAM,SAAS,OAAO,KAAK,UAAU,GAAG;AAExC,OAAI,MAAM,SAAS,oBAAoB;AAErC,gCAA4B,MAAM,MAAM,OAAO;AAC/C,aAAS,OAAO,MAAM,GAAG;cAChB,eAAe,KAAK,CAE7B,OAAM,WAAW,KAAK,OAAO,KAAK,OAAO,MAAM;YACtC,QAAQ,KAAK,UAAU,GAAG;AAEnC,UAAM,WAAW,KAAK,OAAO,KAAK,OAAO,WAAW;AACpD,UAAM,YAAY,KAAK,KAAK,KAAK;SAEjC,OAAM,IAAI,MACR,sBAAsB,KAAK,OAAO,OAAO,gGAC1C;;;AAKP,KAAI,IAAI,WAAW,EACjB,QAAO;AAGT,QAAO;EAAE,MAAM,MAAM,UAAU;EAAE;EAAK;;;;;;;AAQxC,SAAS,SAAS,OAAoB,WAAgB,IAAkB;CACtE,MAAM,YAAY,UAAU,cAAc,EAAE,EAAE,MAC3C,SACC,KAAK,SAAS,eACb,KAAK,KAAK,SAAS,eAAe,KAAK,IAAI,OAAO,KAAK,KAAK,WAC3D,KACL;AAED,KAAI,UAAU;AACZ,QAAM,UACJ,SAAS,MAAM,OACf,SAAS,MAAM,KACf,KAAK,UAAU,GAAG,CACnB;AACD;;AAIF,OAAM,YAAY,UAAU,QAAQ,GAAG,QAAQ,KAAK,UAAU,GAAG,CAAC,GAAG;;;;;;AAOvE,SAAS,4BACP,WACA,MACA,QACM;CACN,IAAI;CACJ,IAAI,WAAW;AACf,MAAK,MAAM,QAAQ,UAAU,cAAc,EAAE,EAAE;AAC7C,MAAI,KAAK,SAAS,WAAY;EAC9B,MAAM,MACJ,KAAK,KAAK,SAAS,eAAe,KAAK,IAAI,OAAO,KAAK,KAAK;AAC9D,MAAI,QAAQ,YAAY,KAAK,OAAO,SAAS,UAC3C,UAAS,KAAK,MAAM;WACX,QAAQ,QACjB,YAAW;;AAGf,KAAI,WAAW,SAAS,SACtB,OAAM,IAAI,MACR,sBAAsB,KAAK,OAAO,OAAO,oIAC1C;;AAIL,SAAS,eAAe,MAAoB;AAC1C,QACE,MAAM,SAAS,6BACf,MAAM,SAAS;;AAInB,SAAS,0BAA0B,MAA0B;CAC3D,MAAM,wBAAQ,IAAI,KAAa;AAC/B,MAAK,MAAM,QAAQ,MAAM;AACvB,MACE,KAAK,SAAS,uBACd,KAAK,QAAQ,UAAU,iBAEvB;AAEF,OAAK,MAAM,QAAQ,KAAK,cAAc,EAAE,CACtC,KACE,KAAK,SAAS,qBACd,KAAK,UAAU,SAAS,WAExB,OAAM,IAAI,KAAK,MAAM,KAAK;;AAIhC,KAAI,MAAM,SAAS,EACjB,OAAM,IAAI,WAAW;AAEvB,QAAO"}

package/src/lib/utils/register-i18n-watcher.js

@@ -0,0 +1,27 @@
+//#region packages/vite-plugin-nitro/src/lib/utils/register-i18n-watcher.ts
+/**
+* Registers a file watcher that triggers a full page reload
+* when translation files are added or modified.
+*
+* Matches files in i18n directories with .json, .xlf, .xmb, or .arb extensions.
+*
+* @param viteServer The Vite development server instance
+*/
+function registerI18nWatcher(viteServer) {
+	const triggerReload = (path) => {
+		if (isTranslationFile(path)) viteServer.ws.send({ type: "full-reload" });
+	};
+	viteServer.watcher.on("change", triggerReload);
+	viteServer.watcher.on("add", triggerReload);
+}
+/**
+* Checks whether a file path looks like a translation file
+* based on its location in an i18n directory and its extension.
+*/
+function isTranslationFile(path) {
+	return /i18n.*\.(json|xlf|xmb|arb)$/.test(path);
+}
+//#endregion
+export { registerI18nWatcher };
+
+//# sourceMappingURL=register-i18n-watcher.js.map

package/src/lib/utils/register-i18n-watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-i18n-watcher.js","names":[],"sources":["../../../../src/lib/utils/register-i18n-watcher.ts"],"sourcesContent":["import { ViteDevServer } from 'vite';\n\n/**\n * Registers a file watcher that triggers a full page reload\n * when translation files are added or modified.\n *\n * Matches files in i18n directories with .json, .xlf, .xmb, or .arb extensions.\n *\n * @param viteServer The Vite development server instance\n */\nexport function registerI18nWatcher(viteServer: ViteDevServer): void {\n  const triggerReload = (path: string) => {\n    if (isTranslationFile(path)) {\n      viteServer.ws.send({ type: 'full-reload' });\n    }\n  };\n\n  viteServer.watcher.on('change', triggerReload);\n  viteServer.watcher.on('add', triggerReload);\n}\n\n/**\n * Checks whether a file path looks like a translation file\n * based on its location in an i18n directory and its extension.\n */\nexport function isTranslationFile(path: string): boolean {\n  return /i18n.*\\.(json|xlf|xmb|arb)$/.test(path);\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,oBAAoB,YAAiC;CACnE,MAAM,iBAAiB,SAAiB;AACtC,MAAI,kBAAkB,KAAK,CACzB,YAAW,GAAG,KAAK,EAAE,MAAM,eAAe,CAAC;;AAI/C,YAAW,QAAQ,GAAG,UAAU,cAAc;AAC9C,YAAW,QAAQ,GAAG,OAAO,cAAc;;;;;;AAO7C,SAAgB,kBAAkB,MAAuB;AACvD,QAAO,8BAA8B,KAAK,KAAK"}

package/src/lib/utils/renderers.d.ts

@@ -31,23 +31,3 @@ export declare function ssrRenderer(): string;
 * for every route, letting the client-side Angular router handle navigation.
 */
 export declare function clientRenderer(): string;
-/**
-* API middleware virtual module content.
-*
-* Intercepts requests matching the configured API prefix and either:
-* - Uses event-bound internal forwarding for GET requests (except .xml routes)
-* - Uses request proxying for all other methods to forward the full request
-*
-* h3 v2 idiomatic APIs used:
-* - defineHandler (replaces defineEventHandler / eventHandler)
-* - event.path (replaces event.node.req.url)
-* - event.method (replaces event.node.req.method)
-* - proxyRequest is retained internally because it preserves Nitro route
-*   matching for event-bound server requests during SSR/prerender
-* - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
-*
-* `fetchWithEvent` keeps the active event context while forwarding to a
-* rewritten path, which avoids falling through to the HTML renderer when
-* SSR code makes relative API requests.
-*/
-export declare const apiMiddleware = "\nimport { createError, defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';\nimport { useRuntimeConfig } from 'nitro/runtime-config';\n\nexport default defineHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = `${prefix}/${useRuntimeConfig().apiPrefix}`;\n\n  const path = event.path || '';\n\n  // only match the prefix on a path boundary, otherwise a URL such as\n  // '/apihttp://internal-host' would pass startsWith() and be forwarded verbatim\n  if (\n    path === apiPrefix ||\n    path.startsWith(`${apiPrefix}/`) ||\n    path.startsWith(`${apiPrefix}?`)\n  ) {\n    let reqUrl = path.slice(apiPrefix.length);\n    if (reqUrl === '' || reqUrl.startsWith('?')) {\n      reqUrl = `/${reqUrl}`;\n    }\n\n    // reject absolute and protocol-relative targets to prevent SSRF\n    if (!reqUrl.startsWith('/') || reqUrl.startsWith('//')) {\n      throw createError({ statusCode: 400, statusMessage: 'Invalid API route' });\n    }\n\n    if (\n      event.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.path?.endsWith('.xml')\n    ) {\n      return fetchWithEvent(event, reqUrl, {\n        headers: Object.fromEntries(event.req.headers.entries()),\n      });\n    }\n\n    return proxyRequest(event, reqUrl);\n  }\n});";

package/src/lib/utils/renderers.js

@@ -93,67 +93,7 @@ export default defineHandler(async (event) => {
 });
 `;
 }
-/**
-* API middleware virtual module content.
-*
-* Intercepts requests matching the configured API prefix and either:
-* - Uses event-bound internal forwarding for GET requests (except .xml routes)
-* - Uses request proxying for all other methods to forward the full request
-*
-* h3 v2 idiomatic APIs used:
-* - defineHandler (replaces defineEventHandler / eventHandler)
-* - event.path (replaces event.node.req.url)
-* - event.method (replaces event.node.req.method)
-* - proxyRequest is retained internally because it preserves Nitro route
-*   matching for event-bound server requests during SSR/prerender
-* - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
-*
-* `fetchWithEvent` keeps the active event context while forwarding to a
-* rewritten path, which avoids falling through to the HTML renderer when
-* SSR code makes relative API requests.
-*/
-var apiMiddleware = `
-import { createError, defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';
-import { useRuntimeConfig } from 'nitro/runtime-config';
-
-export default defineHandler(async (event) => {
-  const prefix = useRuntimeConfig().prefix;
-  const apiPrefix = \`\${prefix}/\${useRuntimeConfig().apiPrefix}\`;
-
-  const path = event.path || '';
-
-  // only match the prefix on a path boundary, otherwise a URL such as
-  // '/apihttp://internal-host' would pass startsWith() and be forwarded verbatim
-  if (
-    path === apiPrefix ||
-    path.startsWith(\`\${apiPrefix}/\`) ||
-    path.startsWith(\`\${apiPrefix}?\`)
-  ) {
-    let reqUrl = path.slice(apiPrefix.length);
-    if (reqUrl === '' || reqUrl.startsWith('?')) {
-      reqUrl = \`/\${reqUrl}\`;
-    }
-
-    // reject absolute and protocol-relative targets to prevent SSRF
-    if (!reqUrl.startsWith('/') || reqUrl.startsWith('//')) {
-      throw createError({ statusCode: 400, statusMessage: 'Invalid API route' });
-    }
-
-    if (
-      event.method === 'GET' &&
-      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers
-      // and can render the XML correctly as a static asset
-      !event.path?.endsWith('.xml')
-    ) {
-      return fetchWithEvent(event, reqUrl, {
-        headers: Object.fromEntries(event.req.headers.entries()),
-      });
-    }
-
-    return proxyRequest(event, reqUrl);
-  }
-});`;
 //#endregion
-export { SERVER_FETCH_FACTORY_SNIPPET, apiMiddleware, clientRenderer, ssrRenderer };
+export { SERVER_FETCH_FACTORY_SNIPPET, clientRenderer, ssrRenderer };
 
 //# sourceMappingURL=renderers.js.map

package/src/lib/utils/renderers.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderers.js","names":[],"sources":["../../../../src/lib/utils/renderers.ts"],"sourcesContent":["/**\n * Code snippet emitted into virtual modules to create a request-scoped\n * fetch using ofetch's `createFetch` + h3's `fetchWithEvent`.\n *\n * Shared between the SSR renderer and page-endpoint virtual modules so\n * the fetch-wiring logic stays in sync.\n *\n * The emitted variable is named `serverFetch` — callers should reference it\n * by that name.\n */\nexport const SERVER_FETCH_FACTORY_SNIPPET = `\n  const serverFetch = createFetch({\n    fetch: (resource, init) => {\n      const url = resource instanceof Request ? resource.url : resource.toString();\n      return fetchWithEvent(event, url, init);\n    }\n  });`;\n\n/**\n * SSR renderer virtual module content.\n *\n * This code runs inside Nitro's server runtime (Node.js context) where\n * event.node is always populated. In h3 v2, event.node is typed as optional,\n * so we use h3's first-class event properties (event.path, event.method) where\n * possible and apply optional chaining when accessing the Node.js context for\n * the Angular renderer which requires raw req/res objects.\n *\n * h3 v2 idiomatic APIs used:\n * - defineHandler (replaces defineEventHandler / eventHandler)\n * - event.path (replaces event.node.req.url)\n * - getResponseHeader compat shim (still available in h3 v2)\n */\nexport function ssrRenderer() {\n  return `\nimport { createFetch } from 'ofetch';\nimport { defineHandler, fetchWithEvent } from 'nitro/h3';\n// @ts-ignore\nimport renderer from '#analog/ssr';\nimport template from '#analog/index';\n\nconst normalizeHtmlRequestUrl = (url) =>\n  url.replace(/\\\\/index\\\\.html(?=$|[?#])/, '/');\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  const noSSR = event.res.headers.get('x-analog-no-ssr');\n  const requestPath = normalizeHtmlRequestUrl(event.path);\n\n  if (noSSR === 'true') {\n    return template;\n  }\n\n  // event.path is the canonical h3 v2 way to access the request URL.\n  // event.node?.req and event.node?.res are needed by the Angular SSR renderer\n  // which operates on raw Node.js request/response objects.\n  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.\n  // The Angular renderer requires a req object with at least { headers, url },\n  // so we provide a minimal stub to avoid runtime errors in prerender context.\n  const req = event.node?.req\n    ? {\n        ...event.node.req,\n        url: requestPath,\n        originalUrl: requestPath,\n      }\n    : {\n    headers: { host: 'localhost' },\n    url: requestPath,\n    originalUrl: requestPath,\n    connection: {},\n  };\n  const res = event.node?.res;\n${SERVER_FETCH_FACTORY_SNIPPET}\n\n  const html = await renderer(requestPath, template, { req, res, fetch: serverFetch });\n\n  return html;\n});`;\n}\n\n/**\n * Client-only renderer virtual module content.\n *\n * Used when SSR is disabled — simply serves the static index.html template\n * for every route, letting the client-side Angular router handle navigation.\n */\nexport function clientRenderer() {\n  return `\nimport { defineHandler } from 'nitro/h3';\nimport template from '#analog/index';\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  return template;\n});\n`;\n}\n\n/**\n * API middleware virtual module content.\n *\n * Intercepts requests matching the configured API prefix and either:\n * - Uses event-bound internal forwarding for GET requests (except .xml routes)\n * - Uses request proxying for all other methods to forward the full request\n *\n * h3 v2 idiomatic APIs used:\n * - defineHandler (replaces defineEventHandler / eventHandler)\n * - event.path (replaces event.node.req.url)\n * - event.method (replaces event.node.req.method)\n * - proxyRequest is retained internally because it preserves Nitro route\n *   matching for event-bound server requests during SSR/prerender\n * - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access\n *\n * `fetchWithEvent` keeps the active event context while forwarding to a\n * rewritten path, which avoids falling through to the HTML renderer when\n * SSR code makes relative API requests.\n */\nexport const apiMiddleware = `\nimport { createError, defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';\nimport { useRuntimeConfig } from 'nitro/runtime-config';\n\nexport default defineHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = \\`\\${prefix}/\\${useRuntimeConfig().apiPrefix}\\`;\n\n  const path = event.path || '';\n\n  // only match the prefix on a path boundary, otherwise a URL such as\n  // '/apihttp://internal-host' would pass startsWith() and be forwarded verbatim\n  if (\n    path === apiPrefix ||\n    path.startsWith(\\`\\${apiPrefix}/\\`) ||\n    path.startsWith(\\`\\${apiPrefix}?\\`)\n  ) {\n    let reqUrl = path.slice(apiPrefix.length);\n    if (reqUrl === '' || reqUrl.startsWith('?')) {\n      reqUrl = \\`/\\${reqUrl}\\`;\n    }\n\n    // reject absolute and protocol-relative targets to prevent SSRF\n    if (!reqUrl.startsWith('/') || reqUrl.startsWith('//')) {\n      throw createError({ statusCode: 400, statusMessage: 'Invalid API route' });\n    }\n\n    if (\n      event.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.path?.endsWith('.xml')\n    ) {\n      return fetchWithEvent(event, reqUrl, {\n        headers: Object.fromEntries(event.req.headers.entries()),\n      });\n    }\n\n    return proxyRequest(event, reqUrl);\n  }\n});`;\n"],"mappings":";;;;;;;;;;;AAUA,IAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;AAsB5C,SAAgB,cAAc;AAC5B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCP,6BAA6B;;;;;;;;;;;;;AAc/B,SAAgB,iBAAiB;AAC/B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BT,IAAa,gBAAgB"}
+{"version":3,"file":"renderers.js","names":[],"sources":["../../../../src/lib/utils/renderers.ts"],"sourcesContent":["/**\n * Code snippet emitted into virtual modules to create a request-scoped\n * fetch using ofetch's `createFetch` + h3's `fetchWithEvent`.\n *\n * Shared between the SSR renderer and page-endpoint virtual modules so\n * the fetch-wiring logic stays in sync.\n *\n * The emitted variable is named `serverFetch` — callers should reference it\n * by that name.\n */\nexport const SERVER_FETCH_FACTORY_SNIPPET = `\n  const serverFetch = createFetch({\n    fetch: (resource, init) => {\n      const url = resource instanceof Request ? resource.url : resource.toString();\n      return fetchWithEvent(event, url, init);\n    }\n  });`;\n\n/**\n * SSR renderer virtual module content.\n *\n * This code runs inside Nitro's server runtime (Node.js context) where\n * event.node is always populated. In h3 v2, event.node is typed as optional,\n * so we use h3's first-class event properties (event.path, event.method) where\n * possible and apply optional chaining when accessing the Node.js context for\n * the Angular renderer which requires raw req/res objects.\n *\n * h3 v2 idiomatic APIs used:\n * - defineHandler (replaces defineEventHandler / eventHandler)\n * - event.path (replaces event.node.req.url)\n * - getResponseHeader compat shim (still available in h3 v2)\n */\nexport function ssrRenderer() {\n  return `\nimport { createFetch } from 'ofetch';\nimport { defineHandler, fetchWithEvent } from 'nitro/h3';\n// @ts-ignore\nimport renderer from '#analog/ssr';\nimport template from '#analog/index';\n\nconst normalizeHtmlRequestUrl = (url) =>\n  url.replace(/\\\\/index\\\\.html(?=$|[?#])/, '/');\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  const noSSR = event.res.headers.get('x-analog-no-ssr');\n  const requestPath = normalizeHtmlRequestUrl(event.path);\n\n  if (noSSR === 'true') {\n    return template;\n  }\n\n  // event.path is the canonical h3 v2 way to access the request URL.\n  // event.node?.req and event.node?.res are needed by the Angular SSR renderer\n  // which operates on raw Node.js request/response objects.\n  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.\n  // The Angular renderer requires a req object with at least { headers, url },\n  // so we provide a minimal stub to avoid runtime errors in prerender context.\n  const req = event.node?.req\n    ? {\n        ...event.node.req,\n        url: requestPath,\n        originalUrl: requestPath,\n      }\n    : {\n    headers: { host: 'localhost' },\n    url: requestPath,\n    originalUrl: requestPath,\n    connection: {},\n  };\n  const res = event.node?.res;\n${SERVER_FETCH_FACTORY_SNIPPET}\n\n  const html = await renderer(requestPath, template, { req, res, fetch: serverFetch });\n\n  return html;\n});`;\n}\n\n/**\n * Client-only renderer virtual module content.\n *\n * Used when SSR is disabled — simply serves the static index.html template\n * for every route, letting the client-side Angular router handle navigation.\n */\nexport function clientRenderer() {\n  return `\nimport { defineHandler } from 'nitro/h3';\nimport template from '#analog/index';\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  return template;\n});\n`;\n}\n"],"mappings":";;;;;;;;;;;AAUA,IAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;AAsB5C,SAAgB,cAAc;AAC5B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCP,6BAA6B;;;;;;;;;;;;;AAc/B,SAAgB,iBAAiB;AAC/B,QAAO"}

package/src/lib/utils/server-fn-endpoints.d.ts

@@ -0,0 +1,41 @@
+import type { NitroEventHandler } from "nitropack";
+import type { ServerFnHandlerModule } from "./get-server-fn-handlers";
+/**
+* Nitro virtual-module id for the generated server-function dispatch handler.
+* Referenced from `nitroConfig.handlers` and provided via `nitroConfig.virtual`.
+*/
+export declare const SERVER_FN_DISPATCH_VIRTUAL = "#ANALOG_SERVER_FN_DISPATCH";
+/** The single transport route all server functions dispatch through. */
+export declare const SERVER_FN_DISPATCH_ROUTE = "/_analog/fn/:id";
+/** URL prefix of that route, for matching requests before the id is known. */
+export declare const SERVER_FN_DISPATCH_PREFIX = "/_analog/fn/";
+/**
+* The Nitro handler registration for the server-function dispatch route.
+* Unlike page endpoints (one handler per file), every server function shares
+* this one `/_analog/fn/:id` route; the id selects the function at runtime.
+*
+* The route is fixed and NOT `/api`-prefixed: client proxies always call the
+* absolute `/_analog/fn/:id` URL, so an `/api` prefix (as page endpoints use)
+* would leave the handler unreachable in apps that have an API directory.
+*/
+export declare function getServerFnDispatchHandler(): NitroEventHandler;
+export type BuildServerFnDispatchModuleArgs = {
+	/** Discovered `*.server.ts` modules, imported for registration side-effects. */
+	modules: ServerFnHandlerModule[];
+	/**
+	* Absolute path to the app's server config module (`app.config.server.ts`),
+	* which exports the `ApplicationConfig` (as `config`) that `main.server.ts`
+	* renders with. Handlers bootstrap against it, so they see the same DI the
+	* app configured. When absent, handlers run with only `providedIn: 'root'`.
+	*/
+	appConfigModule?: string;
+};
+/**
+* Generates the source of the Nitro dispatch handler.
+*
+* The handler imports every discovered `*.server.ts` module so each
+* `serverFn(...)` registers itself, imports the app's server config, then on
+* each request looks up the function by id and runs it via `dispatchServerFn` —
+* the same call path the validation harnesses exercise.
+*/
+export declare function buildServerFnDispatchModule({ modules, appConfigModule }: BuildServerFnDispatchModuleArgs): string;

package/src/lib/utils/server-fn-endpoints.js

@@ -0,0 +1,57 @@
+import { normalizePath } from "vite";
+//#region packages/vite-plugin-nitro/src/lib/utils/server-fn-endpoints.ts
+/**
+* Nitro virtual-module id for the generated server-function dispatch handler.
+* Referenced from `nitroConfig.handlers` and provided via `nitroConfig.virtual`.
+*/
+var SERVER_FN_DISPATCH_VIRTUAL = "#ANALOG_SERVER_FN_DISPATCH";
+/** The single transport route all server functions dispatch through. */
+var SERVER_FN_DISPATCH_ROUTE = "/_analog/fn/:id";
+/**
+* The Nitro handler registration for the server-function dispatch route.
+* Unlike page endpoints (one handler per file), every server function shares
+* this one `/_analog/fn/:id` route; the id selects the function at runtime.
+*
+* The route is fixed and NOT `/api`-prefixed: client proxies always call the
+* absolute `/_analog/fn/:id` URL, so an `/api` prefix (as page endpoints use)
+* would leave the handler unreachable in apps that have an API directory.
+*/
+function getServerFnDispatchHandler() {
+	return {
+		route: SERVER_FN_DISPATCH_ROUTE,
+		handler: SERVER_FN_DISPATCH_VIRTUAL,
+		lazy: true
+	};
+}
+/**
+* Generates the source of the Nitro dispatch handler.
+*
+* The handler imports every discovered `*.server.ts` module so each
+* `serverFn(...)` registers itself, imports the app's server config, then on
+* each request looks up the function by id and runs it via `dispatchServerFn` —
+* the same call path the validation harnesses exercise.
+*/
+function buildServerFnDispatchModule({ modules, appConfigModule }) {
+	return `import '@angular/compiler';
+import 'zone.js/node';
+import '@angular/platform-server/init';
+import { createServerFnAppInjector, createServerFnEventHandler } from '@analogjs/router/server';
+
+// Discovered server-function modules (registration side-effects).
+${modules.map((m) => `import ${JSON.stringify(normalizePath(m.file))};`).join("\n")}
+
+${appConfigModule ? `import { config as serverFnAppConfig } from ${JSON.stringify(normalizePath(appConfigModule))};` : `const serverFnAppConfig = { providers: [] };`}
+
+// Bootstrapped once from the app's own server config, so a handler resolves the
+// same DI as an SSR render (\`providedIn: 'root'\` and listed providers alike).
+// No component is bootstrapped, so nothing renders and the router never
+// navigates. Only REQUEST/RESPONSE are rebuilt per call.
+export default createServerFnEventHandler(
+  createServerFnAppInjector(serverFnAppConfig),
+);
+`;
+}
+//#endregion
+export { buildServerFnDispatchModule, getServerFnDispatchHandler };
+
+//# sourceMappingURL=server-fn-endpoints.js.map

package/src/lib/utils/server-fn-endpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-fn-endpoints.js","names":[],"sources":["../../../../src/lib/utils/server-fn-endpoints.ts"],"sourcesContent":["import type { NitroEventHandler } from 'nitropack';\nimport { normalizePath } from 'vite';\n\nimport type { ServerFnHandlerModule } from './get-server-fn-handlers';\n\n/**\n * Nitro virtual-module id for the generated server-function dispatch handler.\n * Referenced from `nitroConfig.handlers` and provided via `nitroConfig.virtual`.\n */\nexport const SERVER_FN_DISPATCH_VIRTUAL = '#ANALOG_SERVER_FN_DISPATCH';\n\n/** The single transport route all server functions dispatch through. */\nexport const SERVER_FN_DISPATCH_ROUTE = '/_analog/fn/:id';\n\n/** URL prefix of that route, for matching requests before the id is known. */\nexport const SERVER_FN_DISPATCH_PREFIX = '/_analog/fn/';\n\n/**\n * The Nitro handler registration for the server-function dispatch route.\n * Unlike page endpoints (one handler per file), every server function shares\n * this one `/_analog/fn/:id` route; the id selects the function at runtime.\n *\n * The route is fixed and NOT `/api`-prefixed: client proxies always call the\n * absolute `/_analog/fn/:id` URL, so an `/api` prefix (as page endpoints use)\n * would leave the handler unreachable in apps that have an API directory.\n */\nexport function getServerFnDispatchHandler(): NitroEventHandler {\n  return {\n    route: SERVER_FN_DISPATCH_ROUTE,\n    handler: SERVER_FN_DISPATCH_VIRTUAL,\n    lazy: true,\n  };\n}\n\nexport type BuildServerFnDispatchModuleArgs = {\n  /** Discovered `*.server.ts` modules, imported for registration side-effects. */\n  modules: ServerFnHandlerModule[];\n  /**\n   * Absolute path to the app's server config module (`app.config.server.ts`),\n   * which exports the `ApplicationConfig` (as `config`) that `main.server.ts`\n   * renders with. Handlers bootstrap against it, so they see the same DI the\n   * app configured. When absent, handlers run with only `providedIn: 'root'`.\n   */\n  appConfigModule?: string;\n};\n\n/**\n * Generates the source of the Nitro dispatch handler.\n *\n * The handler imports every discovered `*.server.ts` module so each\n * `serverFn(...)` registers itself, imports the app's server config, then on\n * each request looks up the function by id and runs it via `dispatchServerFn` —\n * the same call path the validation harnesses exercise.\n */\nexport function buildServerFnDispatchModule({\n  modules,\n  appConfigModule,\n}: BuildServerFnDispatchModuleArgs): string {\n  const registrationImports = modules\n    .map((m) => `import ${JSON.stringify(normalizePath(m.file))};`)\n    .join('\\n');\n\n  // Bootstrap against the app's own server config so a handler resolves exactly\n  // the services, tokens, and interceptors the app configured — one config, no\n  // second provider list. Fall back to an empty config when the app has none.\n  const appConfig = appConfigModule\n    ? `import { config as serverFnAppConfig } from ${JSON.stringify(\n        normalizePath(appConfigModule),\n      )};`\n    : `const serverFnAppConfig = { providers: [] };`;\n\n  // `@analogjs/router/server` is a partially-compiled Angular library, and this\n  // module is bundled by Nitro rather than by the app's Angular pipeline, so the\n  // linker never runs over it. Loading the compiler gives it the JIT fallback.\n  // `zone.js` and the server platform init match the SSR entry, so bootstrapping\n  // the app injector below runs in the same environment a render would.\n  //\n  // The transport itself — id decoding, the malformed-body contract, dispatch,\n  // and response writing — lives in `createServerFnEventHandler`, so this module\n  // is only wiring: bootstrap the app injector from the app's server config, and\n  // hand it to that handler.\n  return `import '@angular/compiler';\nimport 'zone.js/node';\nimport '@angular/platform-server/init';\nimport { createServerFnAppInjector, createServerFnEventHandler } from '@analogjs/router/server';\n\n// Discovered server-function modules (registration side-effects).\n${registrationImports}\n\n${appConfig}\n\n// Bootstrapped once from the app's own server config, so a handler resolves the\n// same DI as an SSR render (\\`providedIn: 'root'\\` and listed providers alike).\n// No component is bootstrapped, so nothing renders and the router never\n// navigates. Only REQUEST/RESPONSE are rebuilt per call.\nexport default createServerFnEventHandler(\n  createServerFnAppInjector(serverFnAppConfig),\n);\n`;\n}\n"],"mappings":";;;;;;AASA,IAAa,6BAA6B;;AAG1C,IAAa,2BAA2B;;;;;;;;;;AAcxC,SAAgB,6BAAgD;AAC9D,QAAO;EACL,OAAO;EACP,SAAS;EACT,MAAM;EACP;;;;;;;;;;AAuBH,SAAgB,4BAA4B,EAC1C,SACA,mBAC0C;AAwB1C,QAAO;;;;;;EAvBqB,QACzB,KAAK,MAAM,UAAU,KAAK,UAAU,cAAc,EAAE,KAAK,CAAC,CAAC,GAAG,CAC9D,KAAK,KAAK,CA2BO;;EAtBF,kBACd,+CAA+C,KAAK,UAClD,cAAc,gBAAgB,CAC/B,CAAC,KACF,+CAoBM"}

package/src/lib/vite-plugin-nitro.js

@@ -1,9 +1,12 @@
 import { buildServer, isVercelPreset } from "./build-server.js";
 import { getBundleOptionsKey, isRolldown } from "./utils/rolldown.js";
 import { buildClientApp, buildSSRApp } from "./build-ssr.js";
-import { apiMiddleware, clientRenderer, ssrRenderer } from "./utils/renderers.js";
+import { clientRenderer, ssrRenderer } from "./utils/renderers.js";
 import { pageEndpointsPlugin } from "./plugins/page-endpoints.js";
+import { serverFnIdPlugin } from "./plugins/server-fn-id-plugin.js";
 import { getPageHandlers } from "./utils/get-page-handlers.js";
+import { getServerFnHandlers } from "./utils/get-server-fn-handlers.js";
+import { buildServerFnDispatchModule, getServerFnDispatchHandler } from "./utils/server-fn-endpoints.js";
 import { buildSitemap } from "./build-sitemap.js";
 import { toWebRequest, writeWebResponseToNode } from "./utils/node-web-bridge.js";
 import { devServerPlugin } from "./plugins/dev-server-plugin.js";
@@ -59,13 +62,6 @@ function cloneUserConfig(userConfig) {
 		}
 	};
 }
-function createNitroMiddlewareHandler(handler) {
-	return {
-		route: "/**",
-		handler,
-		middleware: true
-	};
-}
 /**
 * Creates a `rollup:before` hook that marks specified packages as external
 * in Nitro's bundler config (applied to both the server build and the
@@ -319,7 +315,6 @@ function nitro(options, nitroOptions) {
 	const baseURL = process.env["NITRO_APP_BASE_URL"] || "";
 	const prefix = baseURL ? baseURL.substring(0, baseURL.length - 1) : "";
 	const apiPrefix = `/${options?.apiPrefix || "api"}`;
-	const useAPIMiddleware = typeof options?.useAPIMiddleware !== "undefined" ? options?.useAPIMiddleware : true;
 	const viteRolldownOutput = options?.vite?.build?.rolldownOptions?.output;
 	const viteRolldownOutputConfig = viteRolldownOutput && !Array.isArray(viteRolldownOutput) ? viteRolldownOutput : void 0;
 	const codeSplitting = viteRolldownOutputConfig?.codeSplitting;
@@ -329,7 +324,7 @@ function nitro(options, nitroOptions) {
 	let config;
 	let nitroConfig;
 	let environmentBuild = false;
-	let hasAPIDir = false;
+	let hasServerFns = false;
 	let clientOutputPath = "";
 	let clientIndexHtml;
 	let legacyClientSubBuild = false;
@@ -360,14 +355,12 @@ function nitro(options, nitroOptions) {
 				for (const key of Object.keys(routeSourceFiles)) delete routeSourceFiles[key];
 				const resolvedConfigRoot = config.root ? resolve(workspaceRoot, config.root) : workspaceRoot;
 				rootDir = relative(workspaceRoot, resolvedConfigRoot) || ".";
-				hasAPIDir = existsSync(resolve(workspaceRoot, rootDir, `${sourceRoot}/server/routes/${options?.apiPrefix || "api"}`));
 				const buildPreset = process.env["BUILD_PRESET"] ?? nitroOptions?.preset ?? (process.env["VERCEL"] ? "vercel" : void 0);
 				const pageHandlers = getPageHandlers({
 					workspaceRoot,
 					sourceRoot,
 					rootDir,
-					additionalPagesDirs: options?.additionalPagesDirs,
-					hasAPIDir
+					additionalPagesDirs: options?.additionalPagesDirs
 				});
 				const resolvedClientOutputPath = resolveClientOutputPath(clientOutputPath, workspaceRoot, rootDir, config.build?.outDir);
 				debugNitro("nitro config resolved client output path", {
@@ -382,6 +375,19 @@ function nitro(options, nitroOptions) {
 					hasEnvironmentConfig: !!config.environments,
 					clientEnvironmentOutDir: config.environments?.["client"] && typeof config.environments["client"] === "object" && "build" in config.environments["client"] ? config.environments["client"].build?.outDir : void 0
 				});
+				const serverFnModules = getServerFnHandlers({
+					workspaceRoot,
+					sourceRoot,
+					rootDir,
+					additionalServerFnDirs: options?.additionalServerFnDirs
+				});
+				const serverFnAppConfigModule = resolveServerFnAppConfigModule(workspaceRoot, rootDir, sourceRoot);
+				hasServerFns = serverFnModules.length > 0;
+				hasServerFns && getServerFnDispatchHandler();
+				serverFnModules.length > 0 && buildServerFnDispatchModule({
+					modules: serverFnModules,
+					appConfigModule: serverFnAppConfigModule
+				});
 				nitroConfig = {
 					rootDir: normalizePath(rootDir),
 					preset: buildPreset,
@@ -406,14 +412,13 @@ function nitro(options, nitroOptions) {
 						onwarn(warning) {
 							if (warning.message.includes("empty chunk") && warning.message.endsWith(".server")) return;
 						},
-						plugins: [pageEndpointsPlugin()]
+						plugins: [pageEndpointsPlugin(), serverFnIdPlugin(normalizePath(resolve(workspaceRoot, rootDir)))]
 					},
-					handlers: [...hasAPIDir ? [] : useAPIMiddleware ? [createNitroMiddlewareHandler("#ANALOG_API_MIDDLEWARE")] : [], ...pageHandlers],
-					routeRules: hasAPIDir ? void 0 : useAPIMiddleware ? void 0 : { [`${prefix}${apiPrefix}/**`]: { proxy: { to: "/**" } } },
+					handlers: [...pageHandlers],
+					routeRules: void 0,
 					virtual: {
 						"#ANALOG_SSR_RENDERER": ssrRenderer(),
-						"#ANALOG_CLIENT_RENDERER": clientRenderer(),
-						...hasAPIDir ? {} : { "#ANALOG_API_MIDDLEWARE": apiMiddleware }
+						"#ANALOG_CLIENT_RENDERER": clientRenderer()
 					}
 				};
 				if (isVercelPreset(buildPreset)) nitroConfig = withVercelOutputAPI(nitroConfig, workspaceRoot);
@@ -493,15 +498,11 @@ function nitro(options, nitroOptions) {
 						rollupExternalEntries.push("rxjs", "node-fetch-native/dist/polyfill", "sharp");
 						nitroConfig = {
 							...nitroConfig,
-							handlers: [
-								...hasAPIDir ? [] : useAPIMiddleware ? [createNitroMiddlewareHandler("#ANALOG_API_MIDDLEWARE")] : [],
-								...pageHandlers,
-								{
-									handler: rendererHandler,
-									route: "/**",
-									lazy: true
-								}
-							]
+							handlers: [...pageHandlers, {
+								handler: rendererHandler,
+								route: "/**",
+								lazy: true
+							}]
 						};
 					}
 				}
@@ -643,16 +644,13 @@ function nitro(options, nitroOptions) {
 					const apiHandler = async (req, res) => {
 						await writeWebResponseToNode(res, await server.fetch(toWebRequest(req)));
 					};
-					if (hasAPIDir) viteServer.middlewares.use((req, res, next) => {
+					viteServer.middlewares.use((req, res, next) => {
 						if (req.url?.startsWith(`${prefix}${apiPrefix}`)) {
 							apiHandler(req, res).catch((error) => next(error));
 							return;
 						}
 						next();
 					});
-					else viteServer.middlewares.use(apiPrefix, (req, res, next) => {
-						apiHandler(req, res).catch((error) => next(error));
-					});
 					viteServer.httpServer?.once("listening", () => {
 						process.env["ANALOG_HOST"] = !viteServer.config.server.host ? "localhost" : viteServer.config.server.host;
 						process.env["ANALOG_PORT"] = `${viteServer.config.server.port}`;
@@ -804,6 +802,10 @@ var withAppHostingOutput = (nitroConfig) => {
 		}
 	};
 };
+function resolveServerFnAppConfigModule(workspaceRoot, rootDir, sourceRoot) {
+	const root = normalizePath(resolve(workspaceRoot, rootDir));
+	return [`${root}/${sourceRoot}/app/app.config.server.ts`, `${root}/${sourceRoot}/app.config.server.ts`].find((candidate) => existsSync(candidate));
+}
 var isNetlifyPreset = (buildPreset) => process.env["NETLIFY"] || buildPreset && buildPreset.toLowerCase().includes("netlify");
 var withNetlifyOutputAPI = (nitroConfig, workspaceRoot) => ({
 	...nitroConfig,