@anansi/core 0.22.2 → 0.22.4

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.22.4](/github.com/ntucker/anansi/compare/@anansi/core@0.22.3...@anansi/core@0.22.4) (2026-01-10)
+
+### 📦 Package
+
+* Update all non-major dependencies ([#2930](/github.com/ntucker/anansi/issues/2930)) ([6162e2b](/github.com/ntucker/anansi/commit/6162e2bfff24989e670d57e62ec93d6a1d42d839))
+
+## [0.22.3](/github.com/ntucker/anansi/compare/@anansi/core@0.22.2...@anansi/core@0.22.3) (2026-01-02)
+
+### 💅 Enhancement
+
+* Improve webpack proxy handling ([0413bc6](/github.com/ntucker/anansi/commit/0413bc6ff3ea9eb107d4ca5259c21e1b7efef29c))
+
+### 📝 Documentation
+
+* Update readme ([b42d500](/github.com/ntucker/anansi/commit/b42d50069157979ac2c21fce92c4750f3219461a))
+
 ## [0.22.2](/github.com/ntucker/anansi/compare/@anansi/core@0.22.1...@anansi/core@0.22.2) (2025-12-31)
 
 ### 🐛 Bug Fix

package/README.md

@@ -1,7 +1,5 @@
 # @anansi/core
 
-<!--[![CircleCI](https://circleci.com/gh/notwillk/pojo-router.svg?style=shield)](https://circleci.com/gh/notwillk/pojo-router)-->
-
 [![npm downloads](https://img.shields.io/npm/dm/@anansi/core.svg?style=flat-square)](https://www.npmjs.com/package/@anansi/core)
 [![bundle size](https://img.shields.io/bundlephobia/minzip/@anansi/core?style=flat-square)](https://bundlephobia.com/result?p=@anansi/core)
 [![npm version](https://img.shields.io/npm/v/@anansi/core.svg?style=flat-square)](https://www.npmjs.com/package/@anansi/core)
@@ -12,106 +10,404 @@
 > Out came the sun, and dried up all the rain,
 > and the itsy bitsy spider went up the spout again
 
-## Entry
+React 19 framework with streaming SSR support, built on a composable "spouts" architecture.
+
+## Installation
+
+```bash
+yarn add @anansi/core
+```
+
+## Quick Start
+
+Anansi uses a dual-entry pattern for SSR: one entry for the server and one for the client.
 
 ```bash
-yarn start-anansi./src/index.tsx
+yarn start-anansi ./src/index.tsx
 ```
 
-This script uses two entry points for client/server.
+This automatically uses `./src/index.tsx` for the client and `./src/index.server.tsx` for the server.
+
+## Concepts
+
+### Spouts
+
+Spouts are composable middleware for building React applications. They handle concerns like routing, data fetching, document structure, and more.
 
-<details open><summary>index.server.tsx</summary>
+- **Server**: `laySpouts()` - Lays out the spouts for SSR, streaming React to the response
+- **Client**: `floodSpouts()` - Hydrates the application on the client
+
+The spout pattern allows you to compose functionality in a declarative, nested structure where each spout can:
+- Inject props to downstream spouts
+- Wrap the rendered application with providers
+- Serialize data for hydration
+
+## Entry Points
+
+### Client Entry (`index.tsx`)
 
 ```tsx
 import { useController } from '@data-client/react';
 import {
-  laySpouts,
+  floodSpouts,
   documentSpout,
   dataClientSpout,
-  prefetchSpout,
   routerSpout,
   JSONSpout,
   appSpout,
-} from '@anansi/core/server';
-
-import app from 'app';
+  navigatorSpout,
+} from '@anansi/core';
 
+import App from './App';
 import { createRouter } from './routing';
 
-const spouts = prefetchSpout('controller')(
-  documentSpout({ title: 'anansi' })(
-    JSONSpout()(
+const spouts = documentSpout({ title: 'My App' })(
+  JSONSpout()(
+    navigatorSpout()(
       dataClientSpout()(
         routerSpout({ useResolveWith: useController, createRouter })(
-          appSpout(app),
+          appSpout(<App />),
         ),
       ),
     ),
   ),
 );
 
-export default laySpouts(spouts);
+floodSpouts(spouts);
 ```
 
-</details>
-
-<details open><summary>index.tsx</summary>
+### Server Entry (`index.server.tsx`)
 
 ```tsx
 import { useController } from '@data-client/react';
 import {
-  floodSpouts,
+  laySpouts,
   documentSpout,
   dataClientSpout,
+  prefetchSpout,
   routerSpout,
   JSONSpout,
   appSpout,
-} from '@anansi/core';
-
-import app from 'app';
+  navigatorSpout,
+} from '@anansi/core/server';
 
+import App from './App';
 import { createRouter } from './routing';
 
-const appSpout = () => Promise.resolve({ app });
-
-const spouts = documentSpout({ title: 'anansi' })(
-  JSONSpout()(
-    dataClientSpout()(
-      routerSpout({ useResolveWith: useController, createRouter })(
-        appSpout(app),
+const spouts = prefetchSpout('controller')(
+  documentSpout({ title: 'My App' })(
+    JSONSpout()(
+      navigatorSpout()(
+        dataClientSpout()(
+          routerSpout({ useResolveWith: useController, createRouter })(
+            appSpout(<App />),
+          ),
+        ),
       ),
     ),
   ),
 );
 
-floodSpouts(spouts);
+export default laySpouts(spouts);
+```
+
+## Spouts Reference
+
+### appSpout
+
+The innermost spout that wraps your React application.
+
+```tsx
+import { appSpout } from '@anansi/core';
+
+appSpout(<App />)
+```
+
+### documentSpout
+
+Generates the HTML document structure with proper asset loading.
+
+```tsx
+import { documentSpout } from '@anansi/core';
+
+documentSpout({
+  title: 'My App',           // Page title
+  head?: ReactNode,          // Additional head elements
+  lang?: string,             // HTML lang attribute (default: undefined)
+  rootId?: string,           // Root element ID (default: 'anansi-root')
+  charSet?: string,          // Character set (default: 'utf-8')
+  csPolicy?: CSPolicy,       // Content Security Policy
+})
+```
+
+#### Content Security Policy
+
+The `csPolicy` option configures CSP headers. In production, it sets `Content-Security-Policy`; in development, it uses `Content-Security-Policy-Report-Only`.
+
+```tsx
+const csPolicy = {
+  'base-uri': "'self'",
+  'object-src': "'none'",
+  'script-src': ["'self'", "'unsafe-inline'"],
+  'style-src': ["'unsafe-inline'", "'self'"],
+};
+
+documentSpout({ title: 'My App', csPolicy })
 ```
 
-</details>
+Nonces are automatically injected into `script-src` for inline scripts.
+
+### routerSpout
 
-Anansi can quickly traverse spouts setup by a user.
+Integrates [@anansi/router](https://github.com/ntucker/anansi/tree/master/packages/router) for client-side navigation.
 
-The server lays the spouts for anansi to travel in. Once delivered to the client, the spouts can be flooded (hydration).
+```tsx
+import { routerSpout } from '@anansi/core';
+
+routerSpout({
+  useResolveWith: () => any,  // Hook returning data passed to route resolvers
+  createRouter: (history) => RouteController,  // Router factory function
+  onChange?: (update, callback) => void,  // Client-only: navigation callback
+})
+```
 
-In both cases, we need the route and application data.
+**Provides to downstream spouts:**
+- `matchedRoutes` - Array of matched route objects
+- `router` - RouteController instance
+- `searchParams` - URLSearchParams from the current URL
 
+### dataClientSpout
+
+Integrates [@data-client/react](https://dataclient.io) for data fetching with automatic SSR hydration.
+
+```tsx
+import { dataClientSpout } from '@anansi/core';
+
+dataClientSpout({
+  getManagers?: () => Manager[],  // Custom managers (default: [NetworkManager])
+})
+```
+
+Server-side, it creates a persisted store and serializes state for hydration. Client-side, it hydrates from the serialized state.
+
+### JSONSpout
+
+Serializes data from upstream spouts into `<script type="application/json">` tags for hydration.
+
+```tsx
+import { JSONSpout } from '@anansi/core';
+
+JSONSpout({
+  id?: string,  // Base ID for script tags (default: 'anansi-json')
+})
+```
+
+### navigatorSpout
+
+Provides browser navigator-like properties (language preferences) that work on both server and client.
+
+```tsx
+import { navigatorSpout, useNavigator } from '@anansi/core';
+
+// In spouts config
+navigatorSpout()
+
+// In components
+function MyComponent() {
+  const { language, languages } = useNavigator();
+  // language: string - Primary language (e.g., 'en-US')
+  // languages: readonly string[] - All accepted languages by preference
+}
+```
 
-## Scripts
+### prefetchSpout (Server Only)
+
+Prefetches route data before rendering. Must wrap `routerSpout`.
+
+```tsx
+import { prefetchSpout } from '@anansi/core/server';
+
+// 'controller' is the field name from dataClientSpout to use for resolving routes
+prefetchSpout('controller')(
+  // ... other spouts including routerSpout
+)
+```
+
+This calls `route.resolveData()` and `route.component.preload()` for all matched routes before SSR.
+
+### antdSpout (Ant Design)
+
+Integrates Ant Design's CSS-in-JS with SSR support.
+
+```tsx
+// Client
+import { antdSpout } from '@anansi/core/antd';
+
+// Server  
+import { antdSpout } from '@anansi/core/antd/server';
+
+antdSpout()
+```
+
+## Core Functions
+
+### laySpouts (Server)
+
+Wraps spouts for server-side rendering with streaming support.
+
+```tsx
+import { laySpouts } from '@anansi/core/server';
+
+export default laySpouts(spouts, {
+  timeoutMS?: number,  // SSR timeout (default: 10000)
+  onError?: (error) => void,  // Error callback
+});
+```
+
+Returns a render function compatible with Express: `(clientManifest, req, res) => Promise<void>`
+
+### floodSpouts (Client)
+
+Hydrates the application on the client.
+
+```tsx
+import { floodSpouts } from '@anansi/core';
+
+floodSpouts(spouts, {
+  rootId?: string,  // Root element ID (default: 'anansi-root')
+});
+```
+
+## CLI Commands
+
+### start-anansi
+
+Development server with hot module replacement for both client and server.
+
+```bash
+yarn start-anansi ./src/index.tsx
+```
+
+Features:
+- Dual webpack compilation (client + server)
+- In-memory filesystem for fast rebuilds
+- Hot reloading for both bundles
+- Automatic SSR on all non-asset routes
+- Proxy support from webpack devServer config
+
+### serve-anansi
+
+Production server for pre-built applications.
+
+```bash
+yarn serve-anansi ./dist-server/App.js
+```
+
+## Scripts API
+
+For programmatic usage:
+
+```ts
+import { serve, devServe } from '@anansi/core/scripts';
+```
 
 ### serve(entry, options?)
 
+Starts a production server.
+
+```ts
+serve('./dist-server/App.js', {
+  serveAssets?: boolean,  // Serve static assets (default: false)
+  serveProxy?: boolean,   // Enable proxy from webpack config (default: false)
+});
+```
+
+**Environment Variables:**
+- `PORT` - Server port (default: 8080)
+- `WEBPACK_PUBLIC_PATH` - Public path for assets
+
+#### Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `serveAssets` | `boolean` | Serve static assets from the build output. Useful for local validation; use a dedicated HTTP server in production. |
+| `serveProxy` | `boolean` | Enable proxying based on webpack devServer config. Useful for local validation; use a reverse proxy in production. |
+
+### devServe(entry, env?)
+
+Starts a development server with HMR.
+
+```ts
+devServe('./src/index.tsx', {
+  // Additional env variables passed to webpack config
+});
+```
+
+## Types
+
+### ServerProps
+
+Props available to server-side spouts:
+
+```ts
+interface ServerProps {
+  req: Request | IncomingMessage;
+  res: Response | ServerResponse;
+  clientManifest: StatsCompilation;
+  nonce: string;
+}
+```
+
+### Spout Types
+
 ```ts
-import { serve } from '@anansi/core/scripts';
+import type { Spout, ServerProps, NavigatorProperties } from '@anansi/core';
+```
+
+### CSPolicy
+
+Content Security Policy configuration:
 
-serve('./dist-server/App.js');
+```ts
+interface CSPolicy {
+  [directive: string]: string | string[];
+}
 ```
 
-#### serveAssets: boolean
+## Exports
+
+### `@anansi/core`
+
+Client-side exports:
+
+- `floodSpouts` - Hydrate the application
+- `documentSpout` - Document structure
+- `dataClientSpout` - Data Client integration
+- `routerSpout` - Router integration
+- `JSONSpout` - JSON serialization for hydration
+- `appSpout` - Application wrapper
+- `navigatorSpout` - Navigator properties
+- `useNavigator` - Hook for navigator properties
+
+### `@anansi/core/server`
+
+Server-side exports (all client exports plus):
+
+- `laySpouts` - SSR render function
+- `prefetchSpout` - Route data prefetching
+- `CSPolicy` - CSP type
+
+### `@anansi/core/scripts`
+
+Build/dev scripts:
+
+- `serve` - Production server
+- `devServe` - Development server
+
+### `@anansi/core/antd`
 
-Serves static assets. This is typically useful when validating server builds locally; but you
-typically want to use a dedicated HTTP server for static assets in production.
+Ant Design integration (client-side).
 
-#### serveProxy: boolean
+### `@anansi/core/antd/server`
 
-Proxy requested based on webpack config devConfig. Useful for validating server builds locally.
-In production it is much more performant to use a separate reverse proxy.
+Ant Design integration (server-side).

package/lib/scripts/proxyUtils.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyConfigArray } from 'webpack-dev-server';
+/**
+ * Extracts route patterns from webpack-dev-server proxy configuration.
+ *
+ * Handles the webpack-dev-server proxy array format:
+ * ```
+ * proxy: [
+ *   { context: ['/api'], target: 'http://localhost:3000' },
+ *   { context: '/ws', target: 'http://localhost:3001' },
+ *   { path: '/legacy', target: 'http://localhost:3002' },
+ * ]
+ * ```
+ *
+ * @see https://webpack.js.org/configuration/dev-server/#devserverproxy
+ */
+export declare function extractProxyRoutes(proxy: ProxyConfigArray | undefined): string[];
+//# sourceMappingURL=proxyUtils.d.ts.map

package/lib/scripts/proxyUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxyUtils.d.ts","sourceRoot":"","sources":["../../src/scripts/proxyUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAClC,MAAM,EAAE,CAgBV"}

package/lib/scripts/proxyUtils.js

@@ -0,0 +1,26 @@
+/**
+ * Extracts route patterns from webpack-dev-server proxy configuration.
+ *
+ * Handles the webpack-dev-server proxy array format:
+ * ```
+ * proxy: [
+ *   { context: ['/api'], target: 'http://localhost:3000' },
+ *   { context: '/ws', target: 'http://localhost:3001' },
+ *   { path: '/legacy', target: 'http://localhost:3002' },
+ * ]
+ * ```
+ *
+ * @see https://webpack.js.org/configuration/dev-server/#devserverproxy
+ */
+export function extractProxyRoutes(proxy) {
+  if (!proxy) return [];
+  return proxy.filter(item => typeof item === 'object' && item !== null).flatMap(item => {
+    // webpack-dev-server proxy supports both 'context' and 'path' properties
+    // and each can be a string or an array of strings
+    const context = item.context ?? item.path;
+    if (Array.isArray(context)) return context;
+    if (typeof context === 'string') return [context];
+    return [];
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/scripts/proxyUtils.js

@@ -0,0 +1,26 @@
+/**
+ * Extracts route patterns from webpack-dev-server proxy configuration.
+ *
+ * Handles the webpack-dev-server proxy array format:
+ * ```
+ * proxy: [
+ *   { context: ['/api'], target: 'http://localhost:3000' },
+ *   { context: '/ws', target: 'http://localhost:3001' },
+ *   { path: '/legacy', target: 'http://localhost:3002' },
+ * ]
+ * ```
+ *
+ * @see https://webpack.js.org/configuration/dev-server/#devserverproxy
+ */
+export function extractProxyRoutes(proxy) {
+  if (!proxy) return [];
+  return proxy.filter(item => typeof item === 'object' && item !== null).flatMap(item => {
+    // webpack-dev-server proxy supports both 'context' and 'path' properties
+    // and each can be a string or an array of strings
+    const context = item.context ?? item.path;
+    if (Array.isArray(context)) return context;
+    if (typeof context === 'string') return [context];
+    return [];
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/scripts/startDevserver.js

@@ -15,6 +15,7 @@ import WebpackDevServer from 'webpack-dev-server';
 import 'cross-fetch/dist/node-polyfill.js';
 import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
+import { extractProxyRoutes } from './proxyUtils.js';
 import { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';
 // run directly from node
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -171,7 +172,7 @@ export default async function startDevServer(entrypoint, env = {}) {
       if (!devServer) {
         throw new Error('webpack-dev-server is not defined');
       }
-      const otherRoutes = [process.env.WEBPACK_PUBLIC_PATH, ...(webpackConfigs[0].devServer?.proxy?.filter(proxy => typeof proxy === 'object')?.flatMap(proxy => proxy.context) ?? [])];
+      const otherRoutes = [process.env.WEBPACK_PUBLIC_PATH, ...extractProxyRoutes(webpackConfigs[0].devServer?.proxy)];
       // serve SSR for non-WEBPACK_PUBLIC_PATH
       devServer.app?.get(new RegExp(`^(?!${otherRoutes.join('|')})`), handleErrors(async function (req, res) {
         if (req.url.endsWith('favicon.ico')) {
@@ -243,4 +244,4 @@ export default async function startDevServer(entrypoint, env = {}) {
   });
   runServer();
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","diskFs","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","createHybridRequire","getWebpackConfig","getErrorStatus","renderErrorPage","import","meta","main","entrypoint","process","argv","console","log","exit","startDevServer","serverFileContents","Promise","resolve","serverEntry","env","webpackConfig","getLogger","volume","fs","use","fsRequire","readFile","hotEntry","entryPath","generatedEntrypoint","fileSync","postfix","writeSync","fd","cwd","webpackConfigs","entrypath","name","mode","replace","BROWSERSLIST_ENV","target","compiler","error","install","hookRequire","getServerBundle","serverStats","serverJson","toJson","assets","join","outputPath","handleErrors","fn","req","res","_next","expressRes","headersSent","statusCode","status","setHeader","send","url","showStack","badge","hint","initRender","render","args","push","importRender","stats","clientStats","compilation","errors","length","Array","isArray","info","clientManifest","then","buf","toString","keys","cache","forEach","default","bind","undefined","init","e","devServer","devMiddleware","outputFileSystem","setupMiddlewares","middlewares","Error","otherRoutes","WEBPACK_PUBLIC_PATH","proxy","filter","flatMap","context","app","get","RegExp","endsWith","socket","on","code","runServer","start","hooks","done","tap","multiStats","finder","fileText","textRows","split","match","stack","matchAll","row","Number","parseInt","col","basename","writeFileSync","stopServer","stop","warn"],"sources":["../../../src/scripts/startDevserver.ts"],"sourcesContent":["#!/usr/bin/env node\nObject.hasOwn =\n  Object.hasOwn ||\n  /* istanbul ignore next */ function hasOwn(it, key) {\n    return Object.prototype.hasOwnProperty.call(it, key);\n  };\nimport type { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { IncomingMessage, ServerResponse } from 'http';\nimport { createFsFromVolume, Volume } from 'memfs';\nimport path from 'path';\nimport sourceMapSupport from 'source-map-support';\nimport tmp from 'tmp';\nimport { ufs } from 'unionfs';\nimport { promisify } from 'util';\nimport webpack, { type Configuration, type MultiConfiguration } from 'webpack';\nimport logging from 'webpack/lib/logging/runtime.js';\nimport WebpackDevServer from 'webpack-dev-server';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport { createHybridRequire } from './createHybridRequire.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';\nimport { BoundRender } from './types.js';\n\n// run directly from node\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nif (import.meta.main) {\n  const entrypoint = process.argv[2];\n\n  if (!entrypoint) {\n    console.log(`Usage: start-anansi <entrypoint-file>`);\n    process.exit(-1);\n  }\n\n  startDevServer(entrypoint);\n}\n\nlet serverFileContents: Promise<string> = Promise.resolve('');\nlet serverEntry = '';\n\nexport default async function startDevServer(\n  entrypoint: string,\n  env: Record<string, unknown> = {},\n) {\n  const webpackConfig = await getWebpackConfig();\n\n  const log = logging.getLogger('anansi-devserver');\n\n  // Set up in memory filesystem\n  const volume = new Volume();\n  const fs = createFsFromVolume(volume);\n  ufs.use(diskFs).use(fs as any);\n\n  const fsRequire = createHybridRequire(ufs);\n\n  const readFile = promisify(ufs.readFile);\n  // Generate a temporary file so we can hot reload from the root of the application\n  function hotEntry(entryPath: string) {\n    // eslint-disable-next-line\n    // @ts-ignore for some reason it's not picking up that other options are optional\n    const generatedEntrypoint = tmp.fileSync({ postfix: '.js' });\n    diskFs.writeSync(\n      generatedEntrypoint.fd,\n      `\n  import entry from \"${path.resolve(process.cwd(), entryPath)}\";\n\n  if (import.meta.webpackHot) {\n    import.meta.webpackHot.accept();\n  }\n\n  export default entry;\n    `,\n    );\n    return generatedEntrypoint;\n  }\n\n  const webpackConfigs: Configuration[] = [\n    webpackConfig(\n      {\n        ...env,\n        entrypath: hotEntry(entrypoint).name,\n        name: 'client',\n      },\n      { mode: 'development' },\n    ),\n    webpackConfig(\n      {\n        ...env,\n        entrypath: entrypoint.replace('.tsx', '.server.tsx'),\n        name: 'server',\n        BROWSERSLIST_ENV: 'current node',\n      },\n      { mode: 'development', target: 'node' },\n    ),\n  ];\n\n  // initialize the webpack compiler\n  const compiler = webpack(webpackConfigs as unknown as MultiConfiguration);\n  if (!compiler) {\n    log.error('Failed to initialize the webpack compiler');\n    process.exit(-1);\n  }\n\n  sourceMapSupport.install({ hookRequire: true });\n\n  function getServerBundle(serverStats: webpack.Stats) {\n    const serverJson = serverStats.toJson({ assets: true });\n    return path.join(serverJson.outputPath ?? '', 'server.js');\n  }\n  function handleErrors<\n    F extends (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n    ) => Promise<void>,\n  >(fn: F) {\n    return async function (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n      _next: NextFunction,\n    ) {\n      try {\n        return await fn(req, res);\n      } catch (error: unknown) {\n        log.error('SSR rendering error:', error);\n\n        // Return error response with status from error if available\n        const expressRes = res as any;\n        if (!expressRes.headersSent) {\n          const statusCode = getErrorStatus(error);\n          expressRes.status(statusCode);\n          expressRes.setHeader('Content-Type', 'text/html');\n          expressRes.send(\n            renderErrorPage(error, req.url ?? '/', statusCode, {\n              showStack: true,\n              badge: 'DEV MODE',\n              hint: 'The dev server is still running. Fix the error and retry, or check the console for more details.',\n            }),\n          );\n        }\n      }\n    };\n  }\n\n  let initRender:\n    | { args: Parameters<BoundRender>; resolve: () => void }[]\n    | undefined = [];\n  let render: BoundRender = (...args) =>\n    new Promise(resolve => {\n      initRender?.push({ args, resolve });\n    });\n\n  function importRender(stats: webpack.Stats[]) {\n    const [clientStats, serverStats] = stats;\n    if (\n      clientStats?.compilation?.errors?.length ||\n      serverStats?.compilation?.errors?.length\n    ) {\n      log.error('Errors for client build: ' + clientStats.compilation.errors);\n      log.error('Errors for server build: ' + serverStats.compilation.errors);\n      // first time, rather than re-render\n      if (Array.isArray(initRender)) {\n        process.exit(-1);\n      }\n      log.error('Above compiler errors blocking reload');\n      return;\n    } else {\n      log.info('Launching SSR');\n    }\n\n    // ASSETS\n    const clientManifest = clientStats.toJson();\n\n    serverEntry = getServerBundle(serverStats);\n    serverFileContents = readFile(serverEntry).then(buf => buf.toString());\n    // reload modules\n    Object.keys(fsRequire.cache).forEach(key => {\n      delete fsRequire.cache[key];\n    });\n    render = (fsRequire(serverEntry) as any).default.bind(\n      undefined,\n      clientManifest,\n    );\n    // SERVER SIDE ENTRYPOINT\n    if (Array.isArray(initRender)) {\n      initRender.forEach(async init => {\n        try {\n          log.info('Resolving queued requests');\n          await render(...init.args);\n          init.resolve();\n        } catch (e) {\n          log.error('Error when attempting to render queued requests');\n          log.error(e);\n        }\n      });\n      initRender = undefined;\n    }\n  }\n\n  const devServer = new WebpackDevServer(\n    // write to memory filesystem so we can import\n    {\n      ...webpackConfigs[0].devServer,\n      devMiddleware: {\n        ...webpackConfigs[0]?.devServer?.devMiddleware,\n        outputFileSystem: {\n          ...fs,\n          join: path.join as any,\n        } as any,\n      },\n      setupMiddlewares: (middlewares, devServer) => {\n        if (!devServer) {\n          throw new Error('webpack-dev-server is not defined');\n        }\n\n        const otherRoutes = [\n          process.env.WEBPACK_PUBLIC_PATH,\n          ...(webpackConfigs[0].devServer?.proxy\n            ?.filter(proxy => typeof proxy === 'object')\n            ?.flatMap(proxy => proxy.context) ?? []),\n        ];\n        // serve SSR for non-WEBPACK_PUBLIC_PATH\n        devServer.app?.get(\n          new RegExp(`^(?!${otherRoutes.join('|')})`),\n          handleErrors(async function (req: any, res: any) {\n            if (req.url.endsWith('favicon.ico')) {\n              res.statusCode = 404;\n              res.setHeader('Content-type', 'text/html');\n              res.send('not found');\n              return;\n            }\n            res.socket.on('error', (error: unknown) => {\n              log.error('Fatal:', error);\n              if ((error as any).code === 'ECONNRESET') {\n                log.error(\n                  'ECONNRESET is usually due to browser closing the connection',\n                );\n              }\n            });\n\n            await render(req, res);\n          }),\n        );\n\n        if (webpackConfigs[0].devServer?.setupMiddlewares) {\n          return webpackConfigs[0].devServer.setupMiddlewares(\n            middlewares,\n            devServer,\n          );\n        }\n\n        return middlewares;\n      },\n    },\n    compiler,\n  );\n  const runServer = async () => {\n    await devServer.start();\n    devServer.compiler.hooks.done.tap(\n      'Anansi Server',\n      (multiStats: webpack.MultiStats | webpack.Stats) => {\n        if (!multiStats) {\n          log.error('stats not send');\n          process.exit(-1);\n        }\n\n        if (!Object.hasOwn(multiStats, 'stats')) return;\n        if ((multiStats as webpack.MultiStats).stats.length > 1) {\n          try {\n            importRender((multiStats as webpack.MultiStats).stats);\n          } catch (e: any) {\n            log.error('Failed to load serve entrypoint');\n            const finder = new RegExp(`${serverEntry}:([\\\\d]+):([\\\\d]+)`, 'g');\n            serverFileContents.then(fileText => {\n              const textRows = fileText.split('\\n');\n              log.error('>>> Stack Context [serve entrypoint] <<<');\n              for (const match of e.stack.matchAll(finder) ?? []) {\n                const row = Number.parseInt(match[1]);\n                const col = Number.parseInt(match[2]);\n                log.error(path.basename(serverEntry) + ' ' + row + ':' + col);\n                log.error(textRows[row - 2]);\n                log.error(textRows[row - 1]);\n                log.error(Array(col).join(' ') + '^');\n                log.error(textRows[row]);\n                log.error(textRows[row + 1]);\n                log.error(textRows[row + 2]);\n              }\n              diskFs.writeFileSync(serverEntry, fileText);\n            });\n\n            throw e;\n          }\n        } else {\n          log.error('Only compiler one stat');\n        }\n      },\n    );\n  };\n  const stopServer = async () => {\n    log.info('Stopping server...');\n    await devServer.stop();\n    log.info('Server closed');\n  };\n\n  process.on('SIGINT', () => {\n    log.warn('Received SIGINT, devserver shutting down');\n    stopServer();\n    process.exit(-1);\n  });\n\n  runServer();\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","diskFs","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","createHybridRequire","getWebpackConfig","extractProxyRoutes","getErrorStatus","renderErrorPage","import","meta","main","entrypoint","process","argv","console","log","exit","startDevServer","serverFileContents","Promise","resolve","serverEntry","env","webpackConfig","getLogger","volume","fs","use","fsRequire","readFile","hotEntry","entryPath","generatedEntrypoint","fileSync","postfix","writeSync","fd","cwd","webpackConfigs","entrypath","name","mode","replace","BROWSERSLIST_ENV","target","compiler","error","install","hookRequire","getServerBundle","serverStats","serverJson","toJson","assets","join","outputPath","handleErrors","fn","req","res","_next","expressRes","headersSent","statusCode","status","setHeader","send","url","showStack","badge","hint","initRender","render","args","push","importRender","stats","clientStats","compilation","errors","length","Array","isArray","info","clientManifest","then","buf","toString","keys","cache","forEach","default","bind","undefined","init","e","devServer","devMiddleware","outputFileSystem","setupMiddlewares","middlewares","Error","otherRoutes","WEBPACK_PUBLIC_PATH","proxy","app","get","RegExp","endsWith","socket","on","code","runServer","start","hooks","done","tap","multiStats","finder","fileText","textRows","split","match","stack","matchAll","row","Number","parseInt","col","basename","writeFileSync","stopServer","stop","warn"],"sources":["../../../src/scripts/startDevserver.ts"],"sourcesContent":["#!/usr/bin/env node\nObject.hasOwn =\n  Object.hasOwn ||\n  /* istanbul ignore next */ function hasOwn(it, key) {\n    return Object.prototype.hasOwnProperty.call(it, key);\n  };\nimport type { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { IncomingMessage, ServerResponse } from 'http';\nimport { createFsFromVolume, Volume } from 'memfs';\nimport path from 'path';\nimport sourceMapSupport from 'source-map-support';\nimport tmp from 'tmp';\nimport { ufs } from 'unionfs';\nimport { promisify } from 'util';\nimport webpack, { type Configuration, type MultiConfiguration } from 'webpack';\nimport logging from 'webpack/lib/logging/runtime.js';\nimport WebpackDevServer from 'webpack-dev-server';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport { createHybridRequire } from './createHybridRequire.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { extractProxyRoutes } from './proxyUtils.js';\nimport { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';\nimport { BoundRender } from './types.js';\n\n// run directly from node\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nif (import.meta.main) {\n  const entrypoint = process.argv[2];\n\n  if (!entrypoint) {\n    console.log(`Usage: start-anansi <entrypoint-file>`);\n    process.exit(-1);\n  }\n\n  startDevServer(entrypoint);\n}\n\nlet serverFileContents: Promise<string> = Promise.resolve('');\nlet serverEntry = '';\n\nexport default async function startDevServer(\n  entrypoint: string,\n  env: Record<string, unknown> = {},\n) {\n  const webpackConfig = await getWebpackConfig();\n\n  const log = logging.getLogger('anansi-devserver');\n\n  // Set up in memory filesystem\n  const volume = new Volume();\n  const fs = createFsFromVolume(volume);\n  ufs.use(diskFs).use(fs as any);\n\n  const fsRequire = createHybridRequire(ufs);\n\n  const readFile = promisify(ufs.readFile);\n  // Generate a temporary file so we can hot reload from the root of the application\n  function hotEntry(entryPath: string) {\n    // eslint-disable-next-line\n    // @ts-ignore for some reason it's not picking up that other options are optional\n    const generatedEntrypoint = tmp.fileSync({ postfix: '.js' });\n    diskFs.writeSync(\n      generatedEntrypoint.fd,\n      `\n  import entry from \"${path.resolve(process.cwd(), entryPath)}\";\n\n  if (import.meta.webpackHot) {\n    import.meta.webpackHot.accept();\n  }\n\n  export default entry;\n    `,\n    );\n    return generatedEntrypoint;\n  }\n\n  const webpackConfigs: Configuration[] = [\n    webpackConfig(\n      {\n        ...env,\n        entrypath: hotEntry(entrypoint).name,\n        name: 'client',\n      },\n      { mode: 'development' },\n    ),\n    webpackConfig(\n      {\n        ...env,\n        entrypath: entrypoint.replace('.tsx', '.server.tsx'),\n        name: 'server',\n        BROWSERSLIST_ENV: 'current node',\n      },\n      { mode: 'development', target: 'node' },\n    ),\n  ];\n\n  // initialize the webpack compiler\n  const compiler = webpack(webpackConfigs as unknown as MultiConfiguration);\n  if (!compiler) {\n    log.error('Failed to initialize the webpack compiler');\n    process.exit(-1);\n  }\n\n  sourceMapSupport.install({ hookRequire: true });\n\n  function getServerBundle(serverStats: webpack.Stats) {\n    const serverJson = serverStats.toJson({ assets: true });\n    return path.join(serverJson.outputPath ?? '', 'server.js');\n  }\n  function handleErrors<\n    F extends (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n    ) => Promise<void>,\n  >(fn: F) {\n    return async function (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n      _next: NextFunction,\n    ) {\n      try {\n        return await fn(req, res);\n      } catch (error: unknown) {\n        log.error('SSR rendering error:', error);\n\n        // Return error response with status from error if available\n        const expressRes = res as any;\n        if (!expressRes.headersSent) {\n          const statusCode = getErrorStatus(error);\n          expressRes.status(statusCode);\n          expressRes.setHeader('Content-Type', 'text/html');\n          expressRes.send(\n            renderErrorPage(error, req.url ?? '/', statusCode, {\n              showStack: true,\n              badge: 'DEV MODE',\n              hint: 'The dev server is still running. Fix the error and retry, or check the console for more details.',\n            }),\n          );\n        }\n      }\n    };\n  }\n\n  let initRender:\n    | { args: Parameters<BoundRender>; resolve: () => void }[]\n    | undefined = [];\n  let render: BoundRender = (...args) =>\n    new Promise(resolve => {\n      initRender?.push({ args, resolve });\n    });\n\n  function importRender(stats: webpack.Stats[]) {\n    const [clientStats, serverStats] = stats;\n    if (\n      clientStats?.compilation?.errors?.length ||\n      serverStats?.compilation?.errors?.length\n    ) {\n      log.error('Errors for client build: ' + clientStats.compilation.errors);\n      log.error('Errors for server build: ' + serverStats.compilation.errors);\n      // first time, rather than re-render\n      if (Array.isArray(initRender)) {\n        process.exit(-1);\n      }\n      log.error('Above compiler errors blocking reload');\n      return;\n    } else {\n      log.info('Launching SSR');\n    }\n\n    // ASSETS\n    const clientManifest = clientStats.toJson();\n\n    serverEntry = getServerBundle(serverStats);\n    serverFileContents = readFile(serverEntry).then(buf => buf.toString());\n    // reload modules\n    Object.keys(fsRequire.cache).forEach(key => {\n      delete fsRequire.cache[key];\n    });\n    render = (fsRequire(serverEntry) as any).default.bind(\n      undefined,\n      clientManifest,\n    );\n    // SERVER SIDE ENTRYPOINT\n    if (Array.isArray(initRender)) {\n      initRender.forEach(async init => {\n        try {\n          log.info('Resolving queued requests');\n          await render(...init.args);\n          init.resolve();\n        } catch (e) {\n          log.error('Error when attempting to render queued requests');\n          log.error(e);\n        }\n      });\n      initRender = undefined;\n    }\n  }\n\n  const devServer = new WebpackDevServer(\n    // write to memory filesystem so we can import\n    {\n      ...webpackConfigs[0].devServer,\n      devMiddleware: {\n        ...webpackConfigs[0]?.devServer?.devMiddleware,\n        outputFileSystem: {\n          ...fs,\n          join: path.join as any,\n        } as any,\n      },\n      setupMiddlewares: (middlewares, devServer) => {\n        if (!devServer) {\n          throw new Error('webpack-dev-server is not defined');\n        }\n\n        const otherRoutes = [\n          process.env.WEBPACK_PUBLIC_PATH,\n          ...extractProxyRoutes(webpackConfigs[0].devServer?.proxy),\n        ];\n        // serve SSR for non-WEBPACK_PUBLIC_PATH\n        devServer.app?.get(\n          new RegExp(`^(?!${otherRoutes.join('|')})`),\n          handleErrors(async function (req: any, res: any) {\n            if (req.url.endsWith('favicon.ico')) {\n              res.statusCode = 404;\n              res.setHeader('Content-type', 'text/html');\n              res.send('not found');\n              return;\n            }\n            res.socket.on('error', (error: unknown) => {\n              log.error('Fatal:', error);\n              if ((error as any).code === 'ECONNRESET') {\n                log.error(\n                  'ECONNRESET is usually due to browser closing the connection',\n                );\n              }\n            });\n\n            await render(req, res);\n          }),\n        );\n\n        if (webpackConfigs[0].devServer?.setupMiddlewares) {\n          return webpackConfigs[0].devServer.setupMiddlewares(\n            middlewares,\n            devServer,\n          );\n        }\n\n        return middlewares;\n      },\n    },\n    compiler,\n  );\n  const runServer = async () => {\n    await devServer.start();\n    devServer.compiler.hooks.done.tap(\n      'Anansi Server',\n      (multiStats: webpack.MultiStats | webpack.Stats) => {\n        if (!multiStats) {\n          log.error('stats not send');\n          process.exit(-1);\n        }\n\n        if (!Object.hasOwn(multiStats, 'stats')) return;\n        if ((multiStats as webpack.MultiStats).stats.length > 1) {\n          try {\n            importRender((multiStats as webpack.MultiStats).stats);\n          } catch (e: any) {\n            log.error('Failed to load serve entrypoint');\n            const finder = new RegExp(`${serverEntry}:([\\\\d]+):([\\\\d]+)`, 'g');\n            serverFileContents.then(fileText => {\n              const textRows = fileText.split('\\n');\n              log.error('>>> Stack Context [serve entrypoint] <<<');\n              for (const match of e.stack.matchAll(finder) ?? []) {\n                const row = Number.parseInt(match[1]);\n                const col = Number.parseInt(match[2]);\n                log.error(path.basename(serverEntry) + ' ' + row + ':' + col);\n                log.error(textRows[row - 2]);\n                log.error(textRows[row - 1]);\n                log.error(Array(col).join(' ') + '^');\n                log.error(textRows[row]);\n                log.error(textRows[row + 1]);\n                log.error(textRows[row + 2]);\n              }\n              diskFs.writeFileSync(serverEntry, fileText);\n            });\n\n            throw e;\n          }\n        } else {\n          log.error('Only compiler one stat');\n        }\n      },\n    );\n  };\n  const stopServer = async () => {\n    log.info('Stopping server...');\n    await devServer.stop();\n    log.info('Server closed');\n  };\n\n  process.on('SIGINT', () => {\n    log.warn('Received SIGINT, devserver shutting down');\n    stopServer();\n    process.exit(-1);\n  });\n\n  runServer();\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/scripts/startDevserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startDevserver.d.ts","sourceRoot":"","sources":["../../src/scripts/startDevserver.ts"],"names":[],"mappings":";AAmBA,OAAO,mCAAmC,CAAC;AAuB3C,wBAA8B,cAAc,CAC1C,UAAU,EAAE,MAAM,EAClB,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,iBA4QlC"}
+{"version":3,"file":"startDevserver.d.ts","sourceRoot":"","sources":["../../src/scripts/startDevserver.ts"],"names":[],"mappings":";AAmBA,OAAO,mCAAmC,CAAC;AAwB3C,wBAA8B,cAAc,CAC1C,UAAU,EAAE,MAAM,EAClB,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,iBA0QlC"}

package/lib/scripts/startDevserver.js

@@ -15,6 +15,7 @@ import WebpackDevServer from 'webpack-dev-server';
 import 'cross-fetch/dist/node-polyfill.js';
 import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
+import { extractProxyRoutes } from './proxyUtils.js';
 import { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';
 // run directly from node
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -171,7 +172,7 @@ export default async function startDevServer(entrypoint, env = {}) {
       if (!devServer) {
         throw new Error('webpack-dev-server is not defined');
       }
-      const otherRoutes = [process.env.WEBPACK_PUBLIC_PATH, ...(webpackConfigs[0].devServer?.proxy?.filter(proxy => typeof proxy === 'object')?.flatMap(proxy => proxy.context) ?? [])];
+      const otherRoutes = [process.env.WEBPACK_PUBLIC_PATH, ...extractProxyRoutes(webpackConfigs[0].devServer?.proxy)];
       // serve SSR for non-WEBPACK_PUBLIC_PATH
       devServer.app?.get(new RegExp(`^(?!${otherRoutes.join('|')})`), handleErrors(async function (req, res) {
         if (req.url.endsWith('favicon.ico')) {
@@ -243,4 +244,4 @@ export default async function startDevServer(entrypoint, env = {}) {
   });
   runServer();
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","diskFs","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","createHybridRequire","getWebpackConfig","getErrorStatus","renderErrorPage","import","meta","main","entrypoint","process","argv","console","log","exit","startDevServer","serverFileContents","Promise","resolve","serverEntry","env","webpackConfig","getLogger","volume","fs","use","fsRequire","readFile","hotEntry","entryPath","generatedEntrypoint","fileSync","postfix","writeSync","fd","cwd","webpackConfigs","entrypath","name","mode","replace","BROWSERSLIST_ENV","target","compiler","error","install","hookRequire","getServerBundle","serverStats","serverJson","toJson","assets","join","outputPath","handleErrors","fn","req","res","_next","expressRes","headersSent","statusCode","status","setHeader","send","url","showStack","badge","hint","initRender","render","args","push","importRender","stats","clientStats","compilation","errors","length","Array","isArray","info","clientManifest","then","buf","toString","keys","cache","forEach","default","bind","undefined","init","e","devServer","devMiddleware","outputFileSystem","setupMiddlewares","middlewares","Error","otherRoutes","WEBPACK_PUBLIC_PATH","proxy","filter","flatMap","context","app","get","RegExp","endsWith","socket","on","code","runServer","start","hooks","done","tap","multiStats","finder","fileText","textRows","split","match","stack","matchAll","row","Number","parseInt","col","basename","writeFileSync","stopServer","stop","warn"],"sources":["../../src/scripts/startDevserver.ts"],"sourcesContent":["#!/usr/bin/env node\nObject.hasOwn =\n  Object.hasOwn ||\n  /* istanbul ignore next */ function hasOwn(it, key) {\n    return Object.prototype.hasOwnProperty.call(it, key);\n  };\nimport type { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { IncomingMessage, ServerResponse } from 'http';\nimport { createFsFromVolume, Volume } from 'memfs';\nimport path from 'path';\nimport sourceMapSupport from 'source-map-support';\nimport tmp from 'tmp';\nimport { ufs } from 'unionfs';\nimport { promisify } from 'util';\nimport webpack, { type Configuration, type MultiConfiguration } from 'webpack';\nimport logging from 'webpack/lib/logging/runtime.js';\nimport WebpackDevServer from 'webpack-dev-server';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport { createHybridRequire } from './createHybridRequire.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';\nimport { BoundRender } from './types.js';\n\n// run directly from node\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nif (import.meta.main) {\n  const entrypoint = process.argv[2];\n\n  if (!entrypoint) {\n    console.log(`Usage: start-anansi <entrypoint-file>`);\n    process.exit(-1);\n  }\n\n  startDevServer(entrypoint);\n}\n\nlet serverFileContents: Promise<string> = Promise.resolve('');\nlet serverEntry = '';\n\nexport default async function startDevServer(\n  entrypoint: string,\n  env: Record<string, unknown> = {},\n) {\n  const webpackConfig = await getWebpackConfig();\n\n  const log = logging.getLogger('anansi-devserver');\n\n  // Set up in memory filesystem\n  const volume = new Volume();\n  const fs = createFsFromVolume(volume);\n  ufs.use(diskFs).use(fs as any);\n\n  const fsRequire = createHybridRequire(ufs);\n\n  const readFile = promisify(ufs.readFile);\n  // Generate a temporary file so we can hot reload from the root of the application\n  function hotEntry(entryPath: string) {\n    // eslint-disable-next-line\n    // @ts-ignore for some reason it's not picking up that other options are optional\n    const generatedEntrypoint = tmp.fileSync({ postfix: '.js' });\n    diskFs.writeSync(\n      generatedEntrypoint.fd,\n      `\n  import entry from \"${path.resolve(process.cwd(), entryPath)}\";\n\n  if (import.meta.webpackHot) {\n    import.meta.webpackHot.accept();\n  }\n\n  export default entry;\n    `,\n    );\n    return generatedEntrypoint;\n  }\n\n  const webpackConfigs: Configuration[] = [\n    webpackConfig(\n      {\n        ...env,\n        entrypath: hotEntry(entrypoint).name,\n        name: 'client',\n      },\n      { mode: 'development' },\n    ),\n    webpackConfig(\n      {\n        ...env,\n        entrypath: entrypoint.replace('.tsx', '.server.tsx'),\n        name: 'server',\n        BROWSERSLIST_ENV: 'current node',\n      },\n      { mode: 'development', target: 'node' },\n    ),\n  ];\n\n  // initialize the webpack compiler\n  const compiler = webpack(webpackConfigs as unknown as MultiConfiguration);\n  if (!compiler) {\n    log.error('Failed to initialize the webpack compiler');\n    process.exit(-1);\n  }\n\n  sourceMapSupport.install({ hookRequire: true });\n\n  function getServerBundle(serverStats: webpack.Stats) {\n    const serverJson = serverStats.toJson({ assets: true });\n    return path.join(serverJson.outputPath ?? '', 'server.js');\n  }\n  function handleErrors<\n    F extends (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n    ) => Promise<void>,\n  >(fn: F) {\n    return async function (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n      _next: NextFunction,\n    ) {\n      try {\n        return await fn(req, res);\n      } catch (error: unknown) {\n        log.error('SSR rendering error:', error);\n\n        // Return error response with status from error if available\n        const expressRes = res as any;\n        if (!expressRes.headersSent) {\n          const statusCode = getErrorStatus(error);\n          expressRes.status(statusCode);\n          expressRes.setHeader('Content-Type', 'text/html');\n          expressRes.send(\n            renderErrorPage(error, req.url ?? '/', statusCode, {\n              showStack: true,\n              badge: 'DEV MODE',\n              hint: 'The dev server is still running. Fix the error and retry, or check the console for more details.',\n            }),\n          );\n        }\n      }\n    };\n  }\n\n  let initRender:\n    | { args: Parameters<BoundRender>; resolve: () => void }[]\n    | undefined = [];\n  let render: BoundRender = (...args) =>\n    new Promise(resolve => {\n      initRender?.push({ args, resolve });\n    });\n\n  function importRender(stats: webpack.Stats[]) {\n    const [clientStats, serverStats] = stats;\n    if (\n      clientStats?.compilation?.errors?.length ||\n      serverStats?.compilation?.errors?.length\n    ) {\n      log.error('Errors for client build: ' + clientStats.compilation.errors);\n      log.error('Errors for server build: ' + serverStats.compilation.errors);\n      // first time, rather than re-render\n      if (Array.isArray(initRender)) {\n        process.exit(-1);\n      }\n      log.error('Above compiler errors blocking reload');\n      return;\n    } else {\n      log.info('Launching SSR');\n    }\n\n    // ASSETS\n    const clientManifest = clientStats.toJson();\n\n    serverEntry = getServerBundle(serverStats);\n    serverFileContents = readFile(serverEntry).then(buf => buf.toString());\n    // reload modules\n    Object.keys(fsRequire.cache).forEach(key => {\n      delete fsRequire.cache[key];\n    });\n    render = (fsRequire(serverEntry) as any).default.bind(\n      undefined,\n      clientManifest,\n    );\n    // SERVER SIDE ENTRYPOINT\n    if (Array.isArray(initRender)) {\n      initRender.forEach(async init => {\n        try {\n          log.info('Resolving queued requests');\n          await render(...init.args);\n          init.resolve();\n        } catch (e) {\n          log.error('Error when attempting to render queued requests');\n          log.error(e);\n        }\n      });\n      initRender = undefined;\n    }\n  }\n\n  const devServer = new WebpackDevServer(\n    // write to memory filesystem so we can import\n    {\n      ...webpackConfigs[0].devServer,\n      devMiddleware: {\n        ...webpackConfigs[0]?.devServer?.devMiddleware,\n        outputFileSystem: {\n          ...fs,\n          join: path.join as any,\n        } as any,\n      },\n      setupMiddlewares: (middlewares, devServer) => {\n        if (!devServer) {\n          throw new Error('webpack-dev-server is not defined');\n        }\n\n        const otherRoutes = [\n          process.env.WEBPACK_PUBLIC_PATH,\n          ...(webpackConfigs[0].devServer?.proxy\n            ?.filter(proxy => typeof proxy === 'object')\n            ?.flatMap(proxy => proxy.context) ?? []),\n        ];\n        // serve SSR for non-WEBPACK_PUBLIC_PATH\n        devServer.app?.get(\n          new RegExp(`^(?!${otherRoutes.join('|')})`),\n          handleErrors(async function (req: any, res: any) {\n            if (req.url.endsWith('favicon.ico')) {\n              res.statusCode = 404;\n              res.setHeader('Content-type', 'text/html');\n              res.send('not found');\n              return;\n            }\n            res.socket.on('error', (error: unknown) => {\n              log.error('Fatal:', error);\n              if ((error as any).code === 'ECONNRESET') {\n                log.error(\n                  'ECONNRESET is usually due to browser closing the connection',\n                );\n              }\n            });\n\n            await render(req, res);\n          }),\n        );\n\n        if (webpackConfigs[0].devServer?.setupMiddlewares) {\n          return webpackConfigs[0].devServer.setupMiddlewares(\n            middlewares,\n            devServer,\n          );\n        }\n\n        return middlewares;\n      },\n    },\n    compiler,\n  );\n  const runServer = async () => {\n    await devServer.start();\n    devServer.compiler.hooks.done.tap(\n      'Anansi Server',\n      (multiStats: webpack.MultiStats | webpack.Stats) => {\n        if (!multiStats) {\n          log.error('stats not send');\n          process.exit(-1);\n        }\n\n        if (!Object.hasOwn(multiStats, 'stats')) return;\n        if ((multiStats as webpack.MultiStats).stats.length > 1) {\n          try {\n            importRender((multiStats as webpack.MultiStats).stats);\n          } catch (e: any) {\n            log.error('Failed to load serve entrypoint');\n            const finder = new RegExp(`${serverEntry}:([\\\\d]+):([\\\\d]+)`, 'g');\n            serverFileContents.then(fileText => {\n              const textRows = fileText.split('\\n');\n              log.error('>>> Stack Context [serve entrypoint] <<<');\n              for (const match of e.stack.matchAll(finder) ?? []) {\n                const row = Number.parseInt(match[1]);\n                const col = Number.parseInt(match[2]);\n                log.error(path.basename(serverEntry) + ' ' + row + ':' + col);\n                log.error(textRows[row - 2]);\n                log.error(textRows[row - 1]);\n                log.error(Array(col).join(' ') + '^');\n                log.error(textRows[row]);\n                log.error(textRows[row + 1]);\n                log.error(textRows[row + 2]);\n              }\n              diskFs.writeFileSync(serverEntry, fileText);\n            });\n\n            throw e;\n          }\n        } else {\n          log.error('Only compiler one stat');\n        }\n      },\n    );\n  };\n  const stopServer = async () => {\n    log.info('Stopping server...');\n    await devServer.stop();\n    log.info('Server closed');\n  };\n\n  process.on('SIGINT', () => {\n    log.warn('Received SIGINT, devserver shutting down');\n    stopServer();\n    process.exit(-1);\n  });\n\n  runServer();\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","diskFs","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","createHybridRequire","getWebpackConfig","extractProxyRoutes","getErrorStatus","renderErrorPage","import","meta","main","entrypoint","process","argv","console","log","exit","startDevServer","serverFileContents","Promise","resolve","serverEntry","env","webpackConfig","getLogger","volume","fs","use","fsRequire","readFile","hotEntry","entryPath","generatedEntrypoint","fileSync","postfix","writeSync","fd","cwd","webpackConfigs","entrypath","name","mode","replace","BROWSERSLIST_ENV","target","compiler","error","install","hookRequire","getServerBundle","serverStats","serverJson","toJson","assets","join","outputPath","handleErrors","fn","req","res","_next","expressRes","headersSent","statusCode","status","setHeader","send","url","showStack","badge","hint","initRender","render","args","push","importRender","stats","clientStats","compilation","errors","length","Array","isArray","info","clientManifest","then","buf","toString","keys","cache","forEach","default","bind","undefined","init","e","devServer","devMiddleware","outputFileSystem","setupMiddlewares","middlewares","Error","otherRoutes","WEBPACK_PUBLIC_PATH","proxy","app","get","RegExp","endsWith","socket","on","code","runServer","start","hooks","done","tap","multiStats","finder","fileText","textRows","split","match","stack","matchAll","row","Number","parseInt","col","basename","writeFileSync","stopServer","stop","warn"],"sources":["../../src/scripts/startDevserver.ts"],"sourcesContent":["#!/usr/bin/env node\nObject.hasOwn =\n  Object.hasOwn ||\n  /* istanbul ignore next */ function hasOwn(it, key) {\n    return Object.prototype.hasOwnProperty.call(it, key);\n  };\nimport type { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { IncomingMessage, ServerResponse } from 'http';\nimport { createFsFromVolume, Volume } from 'memfs';\nimport path from 'path';\nimport sourceMapSupport from 'source-map-support';\nimport tmp from 'tmp';\nimport { ufs } from 'unionfs';\nimport { promisify } from 'util';\nimport webpack, { type Configuration, type MultiConfiguration } from 'webpack';\nimport logging from 'webpack/lib/logging/runtime.js';\nimport WebpackDevServer from 'webpack-dev-server';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport { createHybridRequire } from './createHybridRequire.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { extractProxyRoutes } from './proxyUtils.js';\nimport { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';\nimport { BoundRender } from './types.js';\n\n// run directly from node\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nif (import.meta.main) {\n  const entrypoint = process.argv[2];\n\n  if (!entrypoint) {\n    console.log(`Usage: start-anansi <entrypoint-file>`);\n    process.exit(-1);\n  }\n\n  startDevServer(entrypoint);\n}\n\nlet serverFileContents: Promise<string> = Promise.resolve('');\nlet serverEntry = '';\n\nexport default async function startDevServer(\n  entrypoint: string,\n  env: Record<string, unknown> = {},\n) {\n  const webpackConfig = await getWebpackConfig();\n\n  const log = logging.getLogger('anansi-devserver');\n\n  // Set up in memory filesystem\n  const volume = new Volume();\n  const fs = createFsFromVolume(volume);\n  ufs.use(diskFs).use(fs as any);\n\n  const fsRequire = createHybridRequire(ufs);\n\n  const readFile = promisify(ufs.readFile);\n  // Generate a temporary file so we can hot reload from the root of the application\n  function hotEntry(entryPath: string) {\n    // eslint-disable-next-line\n    // @ts-ignore for some reason it's not picking up that other options are optional\n    const generatedEntrypoint = tmp.fileSync({ postfix: '.js' });\n    diskFs.writeSync(\n      generatedEntrypoint.fd,\n      `\n  import entry from \"${path.resolve(process.cwd(), entryPath)}\";\n\n  if (import.meta.webpackHot) {\n    import.meta.webpackHot.accept();\n  }\n\n  export default entry;\n    `,\n    );\n    return generatedEntrypoint;\n  }\n\n  const webpackConfigs: Configuration[] = [\n    webpackConfig(\n      {\n        ...env,\n        entrypath: hotEntry(entrypoint).name,\n        name: 'client',\n      },\n      { mode: 'development' },\n    ),\n    webpackConfig(\n      {\n        ...env,\n        entrypath: entrypoint.replace('.tsx', '.server.tsx'),\n        name: 'server',\n        BROWSERSLIST_ENV: 'current node',\n      },\n      { mode: 'development', target: 'node' },\n    ),\n  ];\n\n  // initialize the webpack compiler\n  const compiler = webpack(webpackConfigs as unknown as MultiConfiguration);\n  if (!compiler) {\n    log.error('Failed to initialize the webpack compiler');\n    process.exit(-1);\n  }\n\n  sourceMapSupport.install({ hookRequire: true });\n\n  function getServerBundle(serverStats: webpack.Stats) {\n    const serverJson = serverStats.toJson({ assets: true });\n    return path.join(serverJson.outputPath ?? '', 'server.js');\n  }\n  function handleErrors<\n    F extends (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n    ) => Promise<void>,\n  >(fn: F) {\n    return async function (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n      _next: NextFunction,\n    ) {\n      try {\n        return await fn(req, res);\n      } catch (error: unknown) {\n        log.error('SSR rendering error:', error);\n\n        // Return error response with status from error if available\n        const expressRes = res as any;\n        if (!expressRes.headersSent) {\n          const statusCode = getErrorStatus(error);\n          expressRes.status(statusCode);\n          expressRes.setHeader('Content-Type', 'text/html');\n          expressRes.send(\n            renderErrorPage(error, req.url ?? '/', statusCode, {\n              showStack: true,\n              badge: 'DEV MODE',\n              hint: 'The dev server is still running. Fix the error and retry, or check the console for more details.',\n            }),\n          );\n        }\n      }\n    };\n  }\n\n  let initRender:\n    | { args: Parameters<BoundRender>; resolve: () => void }[]\n    | undefined = [];\n  let render: BoundRender = (...args) =>\n    new Promise(resolve => {\n      initRender?.push({ args, resolve });\n    });\n\n  function importRender(stats: webpack.Stats[]) {\n    const [clientStats, serverStats] = stats;\n    if (\n      clientStats?.compilation?.errors?.length ||\n      serverStats?.compilation?.errors?.length\n    ) {\n      log.error('Errors for client build: ' + clientStats.compilation.errors);\n      log.error('Errors for server build: ' + serverStats.compilation.errors);\n      // first time, rather than re-render\n      if (Array.isArray(initRender)) {\n        process.exit(-1);\n      }\n      log.error('Above compiler errors blocking reload');\n      return;\n    } else {\n      log.info('Launching SSR');\n    }\n\n    // ASSETS\n    const clientManifest = clientStats.toJson();\n\n    serverEntry = getServerBundle(serverStats);\n    serverFileContents = readFile(serverEntry).then(buf => buf.toString());\n    // reload modules\n    Object.keys(fsRequire.cache).forEach(key => {\n      delete fsRequire.cache[key];\n    });\n    render = (fsRequire(serverEntry) as any).default.bind(\n      undefined,\n      clientManifest,\n    );\n    // SERVER SIDE ENTRYPOINT\n    if (Array.isArray(initRender)) {\n      initRender.forEach(async init => {\n        try {\n          log.info('Resolving queued requests');\n          await render(...init.args);\n          init.resolve();\n        } catch (e) {\n          log.error('Error when attempting to render queued requests');\n          log.error(e);\n        }\n      });\n      initRender = undefined;\n    }\n  }\n\n  const devServer = new WebpackDevServer(\n    // write to memory filesystem so we can import\n    {\n      ...webpackConfigs[0].devServer,\n      devMiddleware: {\n        ...webpackConfigs[0]?.devServer?.devMiddleware,\n        outputFileSystem: {\n          ...fs,\n          join: path.join as any,\n        } as any,\n      },\n      setupMiddlewares: (middlewares, devServer) => {\n        if (!devServer) {\n          throw new Error('webpack-dev-server is not defined');\n        }\n\n        const otherRoutes = [\n          process.env.WEBPACK_PUBLIC_PATH,\n          ...extractProxyRoutes(webpackConfigs[0].devServer?.proxy),\n        ];\n        // serve SSR for non-WEBPACK_PUBLIC_PATH\n        devServer.app?.get(\n          new RegExp(`^(?!${otherRoutes.join('|')})`),\n          handleErrors(async function (req: any, res: any) {\n            if (req.url.endsWith('favicon.ico')) {\n              res.statusCode = 404;\n              res.setHeader('Content-type', 'text/html');\n              res.send('not found');\n              return;\n            }\n            res.socket.on('error', (error: unknown) => {\n              log.error('Fatal:', error);\n              if ((error as any).code === 'ECONNRESET') {\n                log.error(\n                  'ECONNRESET is usually due to browser closing the connection',\n                );\n              }\n            });\n\n            await render(req, res);\n          }),\n        );\n\n        if (webpackConfigs[0].devServer?.setupMiddlewares) {\n          return webpackConfigs[0].devServer.setupMiddlewares(\n            middlewares,\n            devServer,\n          );\n        }\n\n        return middlewares;\n      },\n    },\n    compiler,\n  );\n  const runServer = async () => {\n    await devServer.start();\n    devServer.compiler.hooks.done.tap(\n      'Anansi Server',\n      (multiStats: webpack.MultiStats | webpack.Stats) => {\n        if (!multiStats) {\n          log.error('stats not send');\n          process.exit(-1);\n        }\n\n        if (!Object.hasOwn(multiStats, 'stats')) return;\n        if ((multiStats as webpack.MultiStats).stats.length > 1) {\n          try {\n            importRender((multiStats as webpack.MultiStats).stats);\n          } catch (e: any) {\n            log.error('Failed to load serve entrypoint');\n            const finder = new RegExp(`${serverEntry}:([\\\\d]+):([\\\\d]+)`, 'g');\n            serverFileContents.then(fileText => {\n              const textRows = fileText.split('\\n');\n              log.error('>>> Stack Context [serve entrypoint] <<<');\n              for (const match of e.stack.matchAll(finder) ?? []) {\n                const row = Number.parseInt(match[1]);\n                const col = Number.parseInt(match[2]);\n                log.error(path.basename(serverEntry) + ' ' + row + ':' + col);\n                log.error(textRows[row - 2]);\n                log.error(textRows[row - 1]);\n                log.error(Array(col).join(' ') + '^');\n                log.error(textRows[row]);\n                log.error(textRows[row + 1]);\n                log.error(textRows[row + 2]);\n              }\n              diskFs.writeFileSync(serverEntry, fileText);\n            });\n\n            throw e;\n          }\n        } else {\n          log.error('Only compiler one stat');\n        }\n      },\n    );\n  };\n  const stopServer = async () => {\n    log.info('Stopping server...');\n    await devServer.stop();\n    log.info('Server closed');\n  };\n\n  process.on('SIGINT', () => {\n    log.warn('Received SIGINT, devserver shutting down');\n    stopServer();\n    process.exit(-1);\n  });\n\n  runServer();\n}\n"],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anansi/core",
-  "version": "0.22.2",
+  "version": "0.22.4",
   "description": "React 19 Framework",
   "homepage": "https://github.com/ntucker/anansi/tree/master/packages/core#readme",
   "repository": {
@@ -82,7 +82,7 @@
     "@types/compression": "1.8.1",
     "@types/express": "^4.17.17",
     "@types/node": "^24.0.0",
-    "@types/react": "19.2.7",
+    "@types/react": "19.2.8",
     "@types/react-dom": "19.2.3",
     "@types/source-map-support": "0.5.10",
     "@types/tmp": "0.2.6",

package/src/scripts/__tests__/proxyUtils.test.ts

@@ -0,0 +1,89 @@
+import { extractProxyRoutes } from '../proxyUtils';
+
+describe('extractProxyRoutes', () => {
+  it('should return empty array for undefined proxy', () => {
+    expect(extractProxyRoutes(undefined)).toEqual([]);
+  });
+
+  it('should return empty array for empty proxy array', () => {
+    expect(extractProxyRoutes([])).toEqual([]);
+  });
+
+  it('should extract context as array of strings', () => {
+    const proxy = [{ context: ['/api'], target: 'http://localhost:3000' }];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api']);
+  });
+
+  it('should extract multiple contexts from array', () => {
+    const proxy = [
+      { context: ['/api', '/graphql'], target: 'http://localhost:3000' },
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api', '/graphql']);
+  });
+
+  it('should extract context as single string', () => {
+    const proxy = [{ context: '/api', target: 'http://localhost:3000' }];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api']);
+  });
+
+  it('should extract path property (legacy format)', () => {
+    const proxy = [{ path: '/legacy', target: 'http://localhost:3000' }];
+    expect(extractProxyRoutes(proxy)).toEqual(['/legacy']);
+  });
+
+  it('should extract path as array', () => {
+    const proxy = [
+      { path: ['/legacy', '/old-api'], target: 'http://localhost:3000' },
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/legacy', '/old-api']);
+  });
+
+  it('should prefer context over path', () => {
+    const proxy = [
+      { context: '/api', path: '/legacy', target: 'http://localhost:3000' },
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api']);
+  });
+
+  it('should handle multiple proxy entries', () => {
+    const proxy = [
+      { context: ['/api'], target: 'http://localhost:3000' },
+      { context: '/ws', target: 'http://localhost:3001' },
+      { path: '/legacy', target: 'http://localhost:3002' },
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api', '/ws', '/legacy']);
+  });
+
+  it('should skip function entries', () => {
+    const proxy = [
+      { context: ['/api'], target: 'http://localhost:3000' },
+      () => ({ context: '/dynamic', target: 'http://localhost:3001' }),
+    ];
+    // Functions are filtered out since we can't statically analyze them
+    expect(extractProxyRoutes(proxy as any)).toEqual(['/api']);
+  });
+
+  it('should skip entries without context or path', () => {
+    const proxy = [
+      { context: ['/api'], target: 'http://localhost:3000' },
+      { target: 'http://localhost:3001', router: {} }, // router-based proxy without context
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api']);
+  });
+
+  it('should handle null entries gracefully', () => {
+    const proxy = [
+      { context: ['/api'], target: 'http://localhost:3000' },
+      null as any,
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api']);
+  });
+
+  it('should handle mixed context types across entries', () => {
+    const proxy = [
+      { context: ['/api', '/graphql'], target: 'http://localhost:3000' },
+      { context: '/ws', target: 'http://localhost:3001' },
+    ];
+    expect(extractProxyRoutes(proxy)).toEqual(['/api', '/graphql', '/ws']);
+  });
+});

package/src/scripts/proxyUtils.ts

@@ -0,0 +1,35 @@
+import type { ProxyConfigArray } from 'webpack-dev-server';
+
+/**
+ * Extracts route patterns from webpack-dev-server proxy configuration.
+ *
+ * Handles the webpack-dev-server proxy array format:
+ * ```
+ * proxy: [
+ *   { context: ['/api'], target: 'http://localhost:3000' },
+ *   { context: '/ws', target: 'http://localhost:3001' },
+ *   { path: '/legacy', target: 'http://localhost:3002' },
+ * ]
+ * ```
+ *
+ * @see https://webpack.js.org/configuration/dev-server/#devserverproxy
+ */
+export function extractProxyRoutes(
+  proxy: ProxyConfigArray | undefined,
+): string[] {
+  if (!proxy) return [];
+
+  return proxy
+    .filter(
+      (item): item is Record<string, unknown> =>
+        typeof item === 'object' && item !== null,
+    )
+    .flatMap(item => {
+      // webpack-dev-server proxy supports both 'context' and 'path' properties
+      // and each can be a string or an array of strings
+      const context = item.context ?? item.path;
+      if (Array.isArray(context)) return context as string[];
+      if (typeof context === 'string') return [context];
+      return [];
+    });
+}

package/src/scripts/startDevserver.ts

@@ -20,6 +20,7 @@ import WebpackDevServer from 'webpack-dev-server';
 import 'cross-fetch/dist/node-polyfill.js';
 import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
+import { extractProxyRoutes } from './proxyUtils.js';
 import { getErrorStatus, renderErrorPage } from './ssrErrorHandler.js';
 import { BoundRender } from './types.js';
 
@@ -216,9 +217,7 @@ export default async function startDevServer(
 
         const otherRoutes = [
           process.env.WEBPACK_PUBLIC_PATH,
-          ...(webpackConfigs[0].devServer?.proxy
-            ?.filter(proxy => typeof proxy === 'object')
-            ?.flatMap(proxy => proxy.context) ?? []),
+          ...extractProxyRoutes(webpackConfigs[0].devServer?.proxy),
         ];
         // serve SSR for non-WEBPACK_PUBLIC_PATH
         devServer.app?.get(