@anansi/core 0.20.39 → 0.20.41

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.20.41](/github.com/ntucker/anansi/compare/@anansi/core@0.20.40...@anansi/core@0.20.41) (2025-11-16)
+
+### 💅 Enhancement
+
+* Support more versions ([6cda65f](/github.com/ntucker/anansi/commit/6cda65f84f226404cba2572ff263cda5362d41c2))
+
+## [0.20.40](/github.com/ntucker/anansi/compare/@anansi/core@0.20.39...@anansi/core@0.20.40) (2025-11-15)
+
+### 🐛 Bug Fix
+
+* Properly handle fallbacks to node_modules in multiple directories ([#2864](/github.com/ntucker/anansi/issues/2864)) ([136bcb5](/github.com/ntucker/anansi/commit/136bcb5a2a3a895931200f16eeccd7c3b071b11b))
+
+### 📦 Package
+
+* Update all non-major dependencies ([#2866](/github.com/ntucker/anansi/issues/2866)) ([930d19a](/github.com/ntucker/anansi/commit/930d19aa7ff8768fb2ba9f220543374435c25fbf))
+
 ## [0.20.39](/github.com/ntucker/anansi/compare/@anansi/core@0.20.38...@anansi/core@0.20.39) (2025-11-09)
 
 ### 🐛 Bug Fix

package/lib/scripts/createHybridRequire.d.ts

@@ -0,0 +1,16 @@
+import { createFsRequire } from 'fs-require';
+import { type IUnionFs } from 'unionfs';
+/**
+ * Creates a hybrid require function that combines fs-require (for in-memory files)
+ * with Node's native require (for bare specifiers from project node_modules).
+ *
+ * This solves the issue where fs-require cannot resolve bare specifiers like
+ * `@anansi/core/server` from workspace node_modules when they're not in the
+ * memfs bundle.
+ *
+ * @param ufs - The unionfs instance (disk first, then memfs)
+ * @param projectRoot - Optional project root directory. Defaults to process.cwd()
+ * @returns A require function that tries memfs first, then falls back to project node_modules
+ */
+export declare function createHybridRequire(ufs: IUnionFs, projectRoot?: string): ReturnType<typeof createFsRequire>;
+//# sourceMappingURL=createHybridRequire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createHybridRequire.d.ts","sourceRoot":"","sources":["../../src/scripts/createHybridRequire.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAG7C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,QAAQ,EACb,WAAW,GAAE,MAAsB,GAClC,UAAU,CAAC,OAAO,eAAe,CAAC,CAqBpC"}

package/lib/scripts/createHybridRequire.js

@@ -0,0 +1,36 @@
+import { createFsRequire } from 'fs-require';
+import { createRequire } from 'module';
+import path from 'path';
+/**
+ * Creates a hybrid require function that combines fs-require (for in-memory files)
+ * with Node's native require (for bare specifiers from project node_modules).
+ *
+ * This solves the issue where fs-require cannot resolve bare specifiers like
+ * `@anansi/core/server` from workspace node_modules when they're not in the
+ * memfs bundle.
+ *
+ * @param ufs - The unionfs instance (disk first, then memfs)
+ * @param projectRoot - Optional project root directory. Defaults to process.cwd()
+ * @returns A require function that tries memfs first, then falls back to project node_modules
+ */
+export function createHybridRequire(ufs, projectRoot = process.cwd()) {
+  const fsRequire = createFsRequire(ufs);
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+  function hybridRequire(id) {
+    try {
+      return fsRequire(id);
+    } catch (error) {
+      const isBare = !id.startsWith('.') && !path.isAbsolute(id);
+      if (isBare && error?.code === 'MODULE_NOT_FOUND') {
+        return projectRequire(id);
+      }
+      throw error;
+    }
+  }
+
+  // Preserve cache and resolve properties from fsRequire
+  hybridRequire.cache = fsRequire.cache;
+  hybridRequire.resolve = fsRequire.resolve;
+  return hybridRequire;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/scripts/createHybridRequire.js

@@ -0,0 +1,36 @@
+import { createFsRequire } from 'fs-require';
+import { createRequire } from 'module';
+import path from 'path';
+/**
+ * Creates a hybrid require function that combines fs-require (for in-memory files)
+ * with Node's native require (for bare specifiers from project node_modules).
+ *
+ * This solves the issue where fs-require cannot resolve bare specifiers like
+ * `@anansi/core/server` from workspace node_modules when they're not in the
+ * memfs bundle.
+ *
+ * @param ufs - The unionfs instance (disk first, then memfs)
+ * @param projectRoot - Optional project root directory. Defaults to process.cwd()
+ * @returns A require function that tries memfs first, then falls back to project node_modules
+ */
+export function createHybridRequire(ufs, projectRoot = process.cwd()) {
+  const fsRequire = createFsRequire(ufs);
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+  function hybridRequire(id) {
+    try {
+      return fsRequire(id);
+    } catch (error) {
+      const isBare = !id.startsWith('.') && !path.isAbsolute(id);
+      if (isBare && error?.code === 'MODULE_NOT_FOUND') {
+        return projectRequire(id);
+      }
+      throw error;
+    }
+  }
+
+  // Preserve cache and resolve properties from fsRequire
+  hybridRequire.cache = fsRequire.cache;
+  hybridRequire.resolve = fsRequire.resolve;
+  return hybridRequire;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/scripts/startDevserver.js

@@ -3,7 +3,6 @@ Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, k
   return Object.prototype.hasOwnProperty.call(it, key);
 };
 import diskFs from 'fs';
-import { createFsRequire } from 'fs-require';
 import { createFsFromVolume, Volume } from 'memfs';
 import path from 'path';
 import sourceMapSupport from 'source-map-support';
@@ -14,6 +13,7 @@ import webpack from 'webpack';
 import logging from 'webpack/lib/logging/runtime.js';
 import WebpackDevServer from 'webpack-dev-server';
 import 'cross-fetch/dist/node-polyfill.js';
+import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
 // run directly from node
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -36,7 +36,7 @@ export default async function startDevServer(entrypoint, env = {}) {
   const volume = new Volume();
   const fs = createFsFromVolume(volume);
   ufs.use(diskFs).use(fs);
-  const fsRequire = createFsRequire(ufs);
+  const fsRequire = createHybridRequire(ufs);
   const readFile = promisify(ufs.readFile);
   // Generate a temporary file so we can hot reload from the root of the application
   function hotEntry(entryPath) {
@@ -229,4 +229,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","createFsRequire","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","getWebpackConfig","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","x","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","url","endsWith","statusCode","setHeader","send","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 { createFsRequire } from 'fs-require';\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 { getWebpackConfig } from './getWebpackConfig.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 = createFsRequire(ufs);\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 (x) {\n        next(x);\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","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","x","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","url","endsWith","statusCode","setHeader","send","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 { 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 (x) {\n        next(x);\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":[]}

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

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

package/lib/scripts/startDevserver.js

@@ -3,7 +3,6 @@ Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, k
   return Object.prototype.hasOwnProperty.call(it, key);
 };
 import diskFs from 'fs';
-import { createFsRequire } from 'fs-require';
 import { createFsFromVolume, Volume } from 'memfs';
 import path from 'path';
 import sourceMapSupport from 'source-map-support';
@@ -14,6 +13,7 @@ import webpack from 'webpack';
 import logging from 'webpack/lib/logging/runtime.js';
 import WebpackDevServer from 'webpack-dev-server';
 import 'cross-fetch/dist/node-polyfill.js';
+import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
 // run directly from node
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -36,7 +36,7 @@ export default async function startDevServer(entrypoint, env = {}) {
   const volume = new Volume();
   const fs = createFsFromVolume(volume);
   ufs.use(diskFs).use(fs);
-  const fsRequire = createFsRequire(ufs);
+  const fsRequire = createHybridRequire(ufs);
   const readFile = promisify(ufs.readFile);
   // Generate a temporary file so we can hot reload from the root of the application
   function hotEntry(entryPath) {
@@ -229,4 +229,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","createFsRequire","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","getWebpackConfig","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","x","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","url","endsWith","statusCode","setHeader","send","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 { createFsRequire } from 'fs-require';\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 { getWebpackConfig } from './getWebpackConfig.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 = createFsRequire(ufs);\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 (x) {\n        next(x);\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","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","x","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","url","endsWith","statusCode","setHeader","send","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 { 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 (x) {\n        next(x);\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":"AAAA;AACAA,MAAM,CAACC,MAAM,GACXD,MAAM,CAACC,MAAM,IACb,0BAA2B,SAASA,MAAMA,CAACC,EAAE,EAAEC,GAAG,EAAE;EAClD,OAAOH,MAAM,CAACI,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,EAAE,EAAEC,GAAG,CAAC;AACtD,CAAC;AAEH,OAAOI,MAAM,MAAM,IAAI;AAEvB,SAASC,kBAAkB,EAAEC,MAAM,QAAQ,OAAO;AAClD,OAAOC,IAAI,MAAM,MAAM;AACvB,OAAOC,gBAAgB,MAAM,oBAAoB;AACjD,OAAOC,GAAG,MAAM,KAAK;AACrB,SAASC,GAAG,QAAQ,SAAS;AAC7B,SAASC,SAAS,QAAQ,MAAM;AAChC,OAAOC,OAAO,MAAuD,SAAS;AAC9E,OAAOC,OAAO,MAAM,gCAAgC;AACpD,OAAOC,gBAAgB,MAAM,oBAAoB;AAEjD,OAAO,mCAAmC;AAC1C,SAASC,mBAAmB,QAAQ,0BAA0B;AAC9D,SAASC,gBAAgB,QAAQ,uBAAuB;AAGxD;AACA;AACA;AACA,IAAIC,MAAM,CAACC,IAAI,CAACC,IAAI,EAAE;EACpB,MAAMC,UAAU,GAAGC,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;EAElC,IAAI,CAACF,UAAU,EAAE;IACfG,OAAO,CAACC,GAAG,CAAC,uCAAuC,CAAC;IACpDH,OAAO,CAACI,IAAI,CAAC,CAAC,CAAC,CAAC;EAClB;EAEAC,cAAc,CAACN,UAAU,CAAC;AAC5B;AAEA,IAAIO,kBAAmC,GAAGC,OAAO,CAACC,OAAO,CAAC,EAAE,CAAC;AAC7D,IAAIC,WAAW,GAAG,EAAE;AAEpB,eAAe,eAAeJ,cAAcA,CAC1CN,UAAkB,EAClBW,GAA4B,GAAG,CAAC,CAAC,EACjC;EACA,MAAMC,aAAa,GAAG,MAAMhB,gBAAgB,CAAC,CAAC;EAE9C,MAAMQ,GAAG,GAAGX,OAAO,CAACoB,SAAS,CAAC,kBAAkB,CAAC;;EAEjD;EACA,MAAMC,MAAM,GAAG,IAAI5B,MAAM,CAAC,CAAC;EAC3B,MAAM6B,EAAE,GAAG9B,kBAAkB,CAAC6B,MAAM,CAAC;EACrCxB,GAAG,CAAC0B,GAAG,CAAChC,MAAM,CAAC,CAACgC,GAAG,CAACD,EAAS,CAAC;EAE9B,MAAME,SAAS,GAAGtB,mBAAmB,CAACL,GAAG,CAAC;EAE1C,MAAM4B,QAAQ,GAAG3B,SAAS,CAACD,GAAG,CAAC4B,QAAQ,CAAC;EACxC;EACA,SAASC,QAAQA,CAACC,SAAiB,EAAE;IACnC;IACA;IACA,MAAMC,mBAAmB,GAAGhC,GAAG,CAACiC,QAAQ,CAAC;MAAEC,OAAO,EAAE;IAAM,CAAC,CAAC;IAC5DvC,MAAM,CAACwC,SAAS,CACdH,mBAAmB,CAACI,EAAE,EACtB;AACN,uBAAuBtC,IAAI,CAACsB,OAAO,CAACR,OAAO,CAACyB,GAAG,CAAC,CAAC,EAAEN,SAAS,CAAC;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA,KACI,CAAC;IACD,OAAOC,mBAAmB;EAC5B;EAEA,MAAMM,cAA+B,GAAG,CACtCf,aAAa,CACX;IACE,GAAGD,GAAG;IACNiB,SAAS,EAAET,QAAQ,CAACnB,UAAU,CAAC,CAAC6B,IAAI;IACpCA,IAAI,EAAE;EACR,CAAC,EACD;IAAEC,IAAI,EAAE;EAAc,CACxB,CAAC,EACDlB,aAAa,CACX;IACE,GAAGD,GAAG;IACNiB,SAAS,EAAE5B,UAAU,CAAC+B,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC;IACpDF,IAAI,EAAE,QAAQ;IACdG,gBAAgB,EAAE;EACpB,CAAC,EACD;IAAEF,IAAI,EAAE,aAAa;IAAEG,MAAM,EAAE;EAAO,CACxC,CAAC,CACF;;EAED;EACA,MAAMC,QAAQ,GAAG1C,OAAO,CAACmC,cAA+C,CAAC;EACzE,IAAI,CAACO,QAAQ,EAAE;IACb9B,GAAG,CAAC+B,KAAK,CAAC,2CAA2C,CAAC;IACtDlC,OAAO,CAACI,IAAI,CAAC,CAAC,CAAC,CAAC;EAClB;EAEAjB,gBAAgB,CAACgD,OAAO,CAAC;IAAEC,WAAW,EAAE;EAAK,CAAC,CAAC;EAE/C,SAASC,eAAeA,CAACC,WAA0B,EAAE;IACnD,MAAMC,UAAU,GAAGD,WAAW,CAACE,MAAM,CAAC;MAAEC,MAAM,EAAE;IAAK,CAAC,CAAC;IACvD,OAAOvD,IAAI,CAACwD,IAAI,CAACH,UAAU,CAACI,UAAU,IAAI,EAAE,EAAE,WAAW,CAAC;EAC5D;EACA,SAASC,YAAYA,CAKnBC,EAAK,EAAE;IACP,OAAO,gBACLC,GAA8B,EAC9BC,GAA8B,EAC9BC,IAAkB,EAClB;MACA,IAAI;QACF,OAAO,MAAMH,EAAE,CAACC,GAAG,EAAEC,GAAG,CAAC;MAC3B,CAAC,CAAC,OAAOE,CAAC,EAAE;QACVD,IAAI,CAACC,CAAC,CAAC;MACT;IACF,CAAC;EACH;EAEA,IAAIC,UAES,GAAG,EAAE;EAClB,IAAIC,MAAmB,GAAGA,CAAC,GAAGC,IAAI,KAChC,IAAI7C,OAAO,CAACC,OAAO,IAAI;IACrB0C,UAAU,EAAEG,IAAI,CAAC;MAAED,IAAI;MAAE5C;IAAQ,CAAC,CAAC;EACrC,CAAC,CAAC;EAEJ,SAAS8C,YAAYA,CAACC,KAAsB,EAAE;IAC5C,MAAM,CAACC,WAAW,EAAElB,WAAW,CAAC,GAAGiB,KAAK;IACxC,IACEC,WAAW,EAAEC,WAAW,EAAEC,MAAM,EAAEC,MAAM,IACxCrB,WAAW,EAAEmB,WAAW,EAAEC,MAAM,EAAEC,MAAM,EACxC;MACAxD,GAAG,CAAC+B,KAAK,CAAC,2BAA2B,GAAGsB,WAAW,CAACC,WAAW,CAACC,MAAM,CAAC;MACvEvD,GAAG,CAAC+B,KAAK,CAAC,2BAA2B,GAAGI,WAAW,CAACmB,WAAW,CAACC,MAAM,CAAC;MACvE;MACA,IAAIE,KAAK,CAACC,OAAO,CAACX,UAAU,CAAC,EAAE;QAC7BlD,OAAO,CAACI,IAAI,CAAC,CAAC,CAAC,CAAC;MAClB;MACAD,GAAG,CAAC+B,KAAK,CAAC,uCAAuC,CAAC;MAClD;IACF,CAAC,MAAM;MACL/B,GAAG,CAAC2D,IAAI,CAAC,eAAe,CAAC;IAC3B;;IAEA;IACA,MAAMC,cAAc,GAAGP,WAAW,CAAChB,MAAM,CAAC,CAAC;IAE3C/B,WAAW,GAAG4B,eAAe,CAACC,WAAW,CAAC;IAC1ChC,kBAAkB,GAAGW,QAAQ,CAACR,WAAW,CAAC,CAACuD,IAAI,CAACC,GAAG,IAAIA,GAAG,CAACC,QAAQ,CAAC,CAAC,CAAC;IACtE;IACA1F,MAAM,CAAC2F,IAAI,CAACnD,SAAS,CAACoD,KAAK,CAAC,CAACC,OAAO,CAAC1F,GAAG,IAAI;MAC1C,OAAOqC,SAAS,CAACoD,KAAK,CAACzF,GAAG,CAAC;IAC7B,CAAC,CAAC;IACFwE,MAAM,GAAInC,SAAS,CAACP,WAAW,CAAC,CAAS6D,OAAO,CAACC,IAAI,CACnDC,SAAS,EACTT,cACF,CAAC;IACD;IACA,IAAIH,KAAK,CAACC,OAAO,CAACX,UAAU,CAAC,EAAE;MAC7BA,UAAU,CAACmB,OAAO,CAAC,MAAMI,IAAI,IAAI;QAC/B,IAAI;UACFtE,GAAG,CAAC2D,IAAI,CAAC,2BAA2B,CAAC;UACrC,MAAMX,MAAM,CAAC,GAAGsB,IAAI,CAACrB,IAAI,CAAC;UAC1BqB,IAAI,CAACjE,OAAO,CAAC,CAAC;QAChB,CAAC,CAAC,OAAOkE,CAAC,EAAE;UACVvE,GAAG,CAAC+B,KAAK,CAAC,iDAAiD,CAAC;UAC5D/B,GAAG,CAAC+B,KAAK,CAACwC,CAAC,CAAC;QACd;MACF,CAAC,CAAC;MACFxB,UAAU,GAAGsB,SAAS;IACxB;EACF;EAEA,MAAMG,SAAS,GAAG,IAAIlF,gBAAgB;EACpC;EACA;IACE,GAAGiC,cAAc,CAAC,CAAC,CAAC,CAACiD,SAAS;IAC9BC,aAAa,EAAE;MACb,GAAGlD,cAAc,CAAC,CAAC,CAAC,EAAEiD,SAAS,EAAEC,aAAa;MAC9CC,gBAAgB,EAAE;QAChB,GAAG/D,EAAE;QACL4B,IAAI,EAAExD,IAAI,CAACwD;MACb;IACF,CAAC;IACDoC,gBAAgB,EAAEA,CAACC,WAAW,EAAEJ,SAAS,KAAK;MAC5C,IAAI,CAACA,SAAS,EAAE;QACd,MAAM,IAAIK,KAAK,CAAC,mCAAmC,CAAC;MACtD;MAEA,MAAMC,WAAW,GAAG,CAClBjF,OAAO,CAACU,GAAG,CAACwE,mBAAmB,EAC/B,IAAIxD,cAAc,CAAC,CAAC,CAAC,CAACiD,SAAS,EAAEQ,KAAK,EAClCC,MAAM,CAACD,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,CAAC,EAC1CE,OAAO,CAACF,KAAK,IAAIA,KAAK,CAACG,OAAO,CAAC,IAAI,EAAE,CAAC,CAC3C;MACD;MACAX,SAAS,CAACY,GAAG,EAAEC,GAAG,CAChB,IAAIC,MAAM,CAAC,OAAOR,WAAW,CAACvC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAC3CE,YAAY,CAAC,gBAAgBE,GAAQ,EAAEC,GAAQ,EAAE;QAC/C,IAAID,GAAG,CAAC4C,GAAG,CAACC,QAAQ,CAAC,aAAa,CAAC,EAAE;UACnC5C,GAAG,CAAC6C,UAAU,GAAG,GAAG;UACpB7C,GAAG,CAAC8C,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC;UAC1C9C,GAAG,CAAC+C,IAAI,CAAC,WAAW,CAAC;UACrB;QACF;QACA/C,GAAG,CAACgD,MAAM,CAACC,EAAE,CAAC,OAAO,EAAG9D,KAAc,IAAK;UACzC/B,GAAG,CAAC+B,KAAK,CAAC,QAAQ,EAAEA,KAAK,CAAC;UAC1B,IAAKA,KAAK,CAAS+D,IAAI,KAAK,YAAY,EAAE;YACxC9F,GAAG,CAAC+B,KAAK,CACP,6DACF,CAAC;UACH;QACF,CAAC,CAAC;QAEF,MAAMiB,MAAM,CAACL,GAAG,EAAEC,GAAG,CAAC;MACxB,CAAC,CACH,CAAC;MAED,IAAIrB,cAAc,CAAC,CAAC,CAAC,CAACiD,SAAS,EAAEG,gBAAgB,EAAE;QACjD,OAAOpD,cAAc,CAAC,CAAC,CAAC,CAACiD,SAAS,CAACG,gBAAgB,CACjDC,WAAW,EACXJ,SACF,CAAC;MACH;MAEA,OAAOI,WAAW;IACpB;EACF,CAAC,EACD9C,QACF,CAAC;EACD,MAAMiE,SAAS,GAAG,MAAAA,CAAA,KAAY;IAC5B,MAAMvB,SAAS,CAACwB,KAAK,CAAC,CAAC;IACvBxB,SAAS,CAAC1C,QAAQ,CAACmE,KAAK,CAACC,IAAI,CAACC,GAAG,CAC/B,eAAe,EACdC,UAA8C,IAAK;MAClD,IAAI,CAACA,UAAU,EAAE;QACfpG,GAAG,CAAC+B,KAAK,CAAC,gBAAgB,CAAC;QAC3BlC,OAAO,CAACI,IAAI,CAAC,CAAC,CAAC,CAAC;MAClB;MAEA,IAAI,CAAC5B,MAAM,CAACC,MAAM,CAAC8H,UAAU,EAAE,OAAO,CAAC,EAAE;MACzC,IAAKA,UAAU,CAAwBhD,KAAK,CAACI,MAAM,GAAG,CAAC,EAAE;QACvD,IAAI;UACFL,YAAY,CAAEiD,UAAU,CAAwBhD,KAAK,CAAC;QACxD,CAAC,CAAC,OAAOmB,CAAM,EAAE;UACfvE,GAAG,CAAC+B,KAAK,CAAC,iCAAiC,CAAC;UAC5C,MAAMsE,MAAM,GAAG,IAAIf,MAAM,CAAC,GAAGhF,WAAW,oBAAoB,EAAE,GAAG,CAAC;UAClEH,kBAAkB,CAAC0D,IAAI,CAACyC,QAAQ,IAAI;YAClC,MAAMC,QAAQ,GAAGD,QAAQ,CAACE,KAAK,CAAC,IAAI,CAAC;YACrCxG,GAAG,CAAC+B,KAAK,CAAC,0CAA0C,CAAC;YACrD,KAAK,MAAM0E,KAAK,IAAIlC,CAAC,CAACmC,KAAK,CAACC,QAAQ,CAACN,MAAM,CAAC,IAAI,EAAE,EAAE;cAClD,MAAMO,GAAG,GAAGC,MAAM,CAACC,QAAQ,CAACL,KAAK,CAAC,CAAC,CAAC,CAAC;cACrC,MAAMM,GAAG,GAAGF,MAAM,CAACC,QAAQ,CAACL,KAAK,CAAC,CAAC,CAAC,CAAC;cACrCzG,GAAG,CAAC+B,KAAK,CAAChD,IAAI,CAACiI,QAAQ,CAAC1G,WAAW,CAAC,GAAG,GAAG,GAAGsG,GAAG,GAAG,GAAG,GAAGG,GAAG,CAAC;cAC7D/G,GAAG,CAAC+B,KAAK,CAACwE,QAAQ,CAACK,GAAG,GAAG,CAAC,CAAC,CAAC;cAC5B5G,GAAG,CAAC+B,KAAK,CAACwE,QAAQ,CAACK,GAAG,GAAG,CAAC,CAAC,CAAC;cAC5B5G,GAAG,CAAC+B,KAAK,CAAC0B,KAAK,CAACsD,GAAG,CAAC,CAACxE,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;cACrCvC,GAAG,CAAC+B,KAAK,CAACwE,QAAQ,CAACK,GAAG,CAAC,CAAC;cACxB5G,GAAG,CAAC+B,KAAK,CAACwE,QAAQ,CAACK,GAAG,GAAG,CAAC,CAAC,CAAC;cAC5B5G,GAAG,CAAC+B,KAAK,CAACwE,QAAQ,CAACK,GAAG,GAAG,CAAC,CAAC,CAAC;YAC9B;YACAhI,MAAM,CAACqI,aAAa,CAAC3G,WAAW,EAAEgG,QAAQ,CAAC;UAC7C,CAAC,CAAC;UAEF,MAAM/B,CAAC;QACT;MACF,CAAC,MAAM;QACLvE,GAAG,CAAC+B,KAAK,CAAC,wBAAwB,CAAC;MACrC;IACF,CACF,CAAC;EACH,CAAC;EACD,MAAMmF,UAAU,GAAG,MAAAA,CAAA,KAAY;IAC7BlH,GAAG,CAAC2D,IAAI,CAAC,oBAAoB,CAAC;IAC9B,MAAMa,SAAS,CAAC2C,IAAI,CAAC,CAAC;IACtBnH,GAAG,CAAC2D,IAAI,CAAC,eAAe,CAAC;EAC3B,CAAC;EAED9D,OAAO,CAACgG,EAAE,CAAC,QAAQ,EAAE,MAAM;IACzB7F,GAAG,CAACoH,IAAI,CAAC,0CAA0C,CAAC;IACpDF,UAAU,CAAC,CAAC;IACZrH,OAAO,CAACI,IAAI,CAAC,CAAC,CAAC,CAAC;EAClB,CAAC,CAAC;EAEF8F,SAAS,CAAC,CAAC;AACb","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anansi/core",
-  "version": "0.20.39",
+  "version": "0.20.41",
   "description": "React 19 Framework",
   "homepage": "https://github.com/ntucker/anansi/tree/master/packages/core#readme",
   "repository": {
@@ -71,8 +71,8 @@
     "@types/compression": "1.8.1",
     "@types/express": "^4.17.17",
     "@types/node": "^24.0.0",
-    "@types/react": "19.2.2",
-    "@types/react-dom": "19.2.2",
+    "@types/react": "19.2.5",
+    "@types/react-dom": "19.2.3",
     "@types/source-map-support": "0.5.10",
     "@types/tmp": "0.2.6",
     "@types/webpack-hot-middleware": "2.25.12",
@@ -102,7 +102,7 @@
   },
   "peerDependencies": {
     "@ant-design/cssinjs": "^1.5.1",
-    "@data-client/react": "^0.12.15 || ^0.13.0 || ^0.14.0",
+    "@data-client/react": "^0.12.15 || ^0.13.0 || ^0.14.0 || ^0.15.0",
     "@types/react": "*",
     "@types/react-dom": "*",
     "react": "^18.0.0 || ^19.0.0",

package/src/scripts/__tests__/hybridRequire.cwd.test.ts

@@ -0,0 +1,172 @@
+import diskFs from 'fs';
+import { createFsFromVolume, Volume } from 'memfs';
+import path from 'path';
+import tmp from 'tmp';
+import { ufs } from 'unionfs';
+
+import { createHybridRequire } from '../createHybridRequire';
+
+/**
+ * Regression test to ensure hybridRequire resolves from the initial
+ * working directory even if process.cwd() changes after initialization.
+ * This guards against future refactors that might call process.chdir.
+ */
+describe('hybridRequire - process.cwd() variance regression', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    tempDir = tmp.dirSync({ unsafeCleanup: true }).name;
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+  });
+
+  it('should capture projectRequire path at initialization time', () => {
+    const projectRoot = path.join(tempDir, 'project');
+    const otherDir = path.join(tempDir, 'other');
+
+    // Create project structure
+    diskFs.mkdirSync(projectRoot, { recursive: true });
+    diskFs.mkdirSync(otherDir, { recursive: true });
+
+    const nodeModulesDir = path.join(projectRoot, 'node_modules');
+    const testPackageDir = path.join(nodeModulesDir, 'test-package-cwd');
+    const testFile = path.join(testPackageDir, 'index.js');
+
+    diskFs.mkdirSync(testPackageDir, { recursive: true });
+    diskFs.writeFileSync(
+      testFile,
+      "module.exports = { default: 'from-project-root' };",
+    );
+    diskFs.writeFileSync(
+      path.join(testPackageDir, 'package.json'),
+      JSON.stringify({ name: 'test-package-cwd', main: 'index.js' }),
+    );
+
+    diskFs.writeFileSync(
+      path.join(projectRoot, 'package.json'),
+      JSON.stringify({ name: 'project' }),
+    );
+
+    // Create another package.json in otherDir (should not be used)
+    diskFs.writeFileSync(
+      path.join(otherDir, 'package.json'),
+      JSON.stringify({ name: 'other' }),
+    );
+
+    // Set up memfs WITHOUT diskFs to test fallback
+    const volume = new Volume();
+    const fs = createFsFromVolume(volume);
+    ufs.use(fs as any);
+
+    // Initialize hybridRequire while in projectRoot
+    process.chdir(projectRoot);
+    const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+    // Change to other directory
+    process.chdir(otherDir);
+
+    // Verify process.cwd() changed
+    expect(process.cwd()).toBe(otherDir);
+
+    // hybridRequire should still resolve from projectRoot (captured at init)
+    const result = hybridRequire('test-package-cwd');
+    expect(result.default).toBe('from-project-root');
+  });
+
+  it('should work correctly when process.cwd() is different from projectRoot', () => {
+    const projectRoot = path.join(tempDir, 'workspace', 'examples', 'app');
+    const nodeModulesDir = path.join(projectRoot, 'node_modules');
+    const testPackageDir = path.join(nodeModulesDir, 'test-package-nested');
+    const testFile = path.join(testPackageDir, 'index.js');
+
+    // Create nested structure
+    diskFs.mkdirSync(testPackageDir, { recursive: true });
+    diskFs.writeFileSync(
+      testFile,
+      "module.exports = { default: 'from-nested-workspace' };",
+    );
+    diskFs.writeFileSync(
+      path.join(testPackageDir, 'package.json'),
+      JSON.stringify({ name: 'test-package-nested', main: 'index.js' }),
+    );
+
+    diskFs.writeFileSync(
+      path.join(projectRoot, 'package.json'),
+      JSON.stringify({ name: 'app' }),
+    );
+
+    // Set up memfs WITHOUT diskFs to test fallback
+    const volume = new Volume();
+    const fs = createFsFromVolume(volume);
+    ufs.use(fs as any);
+
+    // Initialize from a different directory (simulating monorepo root)
+    const monorepoRoot = path.join(tempDir, 'workspace');
+    process.chdir(monorepoRoot);
+
+    // Create hybridRequire with explicit projectRoot (not process.cwd())
+    const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+    // Verify it resolves from projectRoot, not monorepoRoot
+    const result = hybridRequire('test-package-nested');
+    expect(result.default).toBe('from-nested-workspace');
+  });
+
+  it('should handle multiple chdir calls without breaking', () => {
+    const projectRoot = path.join(tempDir, 'project');
+    const dir1 = path.join(tempDir, 'dir1');
+    const dir2 = path.join(tempDir, 'dir2');
+
+    diskFs.mkdirSync(projectRoot, { recursive: true });
+    diskFs.mkdirSync(dir1, { recursive: true });
+    diskFs.mkdirSync(dir2, { recursive: true });
+
+    const nodeModulesDir = path.join(projectRoot, 'node_modules');
+    const testPackageDir = path.join(nodeModulesDir, 'test-package-stable');
+    const testFile = path.join(testPackageDir, 'index.js');
+
+    diskFs.mkdirSync(testPackageDir, { recursive: true });
+    diskFs.writeFileSync(
+      testFile,
+      "module.exports = { default: 'stable-reference' };",
+    );
+    diskFs.writeFileSync(
+      path.join(testPackageDir, 'package.json'),
+      JSON.stringify({ name: 'test-package-stable', main: 'index.js' }),
+    );
+
+    diskFs.writeFileSync(
+      path.join(projectRoot, 'package.json'),
+      JSON.stringify({ name: 'project' }),
+    );
+
+    // Set up memfs WITHOUT diskFs to test fallback
+    const volume = new Volume();
+    const fs = createFsFromVolume(volume);
+    ufs.use(fs as any);
+
+    // Initialize
+    process.chdir(projectRoot);
+    const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+    // Multiple chdir calls
+    process.chdir(dir1);
+    expect(hybridRequire('test-package-stable').default).toBe(
+      'stable-reference',
+    );
+
+    process.chdir(dir2);
+    expect(hybridRequire('test-package-stable').default).toBe(
+      'stable-reference',
+    );
+
+    process.chdir(projectRoot);
+    expect(hybridRequire('test-package-stable').default).toBe(
+      'stable-reference',
+    );
+  });
+});

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

@@ -0,0 +1,243 @@
+import diskFs from 'fs';
+import { createFsRequire } from 'fs-require';
+import { createFsFromVolume, Volume } from 'memfs';
+import path from 'path';
+import tmp from 'tmp';
+import { ufs } from 'unionfs';
+
+import { createHybridRequire } from '../createHybridRequire';
+
+describe('hybridRequire wrapper', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    tempDir = tmp.dirSync({ unsafeCleanup: true }).name;
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+  });
+
+  describe('unit tests - fallback resolver', () => {
+    it('should resolve bare specifiers from project node_modules when not in memfs', () => {
+      // Set up a temp directory with node_modules containing a test package
+      const projectRoot = tempDir;
+      const nodeModulesDir = path.join(projectRoot, 'node_modules');
+      const testPackageDir = path.join(nodeModulesDir, 'test-package');
+      const testFile = path.join(testPackageDir, 'index.js');
+
+      // Create directory structure with a unique package name to avoid conflicts
+      diskFs.mkdirSync(testPackageDir, { recursive: true });
+      diskFs.writeFileSync(
+        testFile,
+        "module.exports = { default: 'test-export-value', test: 'value' };",
+      );
+
+      // Create package.json for the test package
+      diskFs.writeFileSync(
+        path.join(testPackageDir, 'package.json'),
+        JSON.stringify({ name: 'test-package', main: 'index.js' }),
+      );
+
+      // Create package.json in project root
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      // Set up memfs WITHOUT diskFs to simulate memfs-only scenario
+      // This way fsRequire will fail (module not in memfs)
+      // and hybridRequire will fall back to projectRequire
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      // Only use memfs, not disk - this simulates the webpack output scenario
+      ufs.use(fs as any);
+
+      const fsRequire = createFsRequire(ufs);
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // Mock process.cwd to return our temp directory
+      const originalCwd = process.cwd;
+      process.cwd = jest.fn(() => projectRoot);
+
+      try {
+        // fsRequire should fail because test-package is not in memfs
+        expect(() => {
+          fsRequire('test-package');
+        }).toThrow();
+
+        // hybridRequire should succeed by falling back to project node_modules
+        const result = hybridRequire('test-package');
+        expect(result).toBeDefined();
+        expect(result.default).toBe('test-export-value');
+        expect(result.test).toBe('value');
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    it('should work with unionfs when module exists in both disk and memfs', () => {
+      const projectRoot = tempDir;
+      const nodeModulesDir = path.join(projectRoot, 'node_modules');
+      const testPackageDir = path.join(nodeModulesDir, 'test-package-union');
+      const testFile = path.join(testPackageDir, 'index.js');
+
+      // Create directory structure on disk
+      diskFs.mkdirSync(testPackageDir, { recursive: true });
+      diskFs.writeFileSync(
+        testFile,
+        "module.exports = { default: 'disk-version' };",
+      );
+      diskFs.writeFileSync(
+        path.join(testPackageDir, 'package.json'),
+        JSON.stringify({ name: 'test-package-union', main: 'index.js' }),
+      );
+
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      // Set up memfs with the same module (different version)
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      const memfsPath = path.join('/node_modules/test-package-union/index.js');
+      fs.mkdirSync(path.dirname(memfsPath), { recursive: true });
+      fs.writeFileSync(
+        memfsPath,
+        "module.exports = { default: 'memfs-version' };",
+      );
+
+      // unionfs checks disk first, then memfs (same as dev server)
+      ufs.use(diskFs).use(fs as any);
+
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // hybridRequire should get disk version (unionfs checks disk first)
+      // This verifies that hybridRequire correctly uses fsRequire with unionfs
+      const result = hybridRequire('test-package-union');
+      expect(result.default).toBe('disk-version');
+    });
+
+    it('should handle relative paths without fallback', () => {
+      const projectRoot = tempDir;
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      const relativeFile = '/relative.js';
+      fs.writeFileSync(
+        relativeFile,
+        "module.exports = { default: 'relative-export' };",
+      );
+
+      ufs.use(diskFs).use(fs as any);
+
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // Relative paths should work through memfs
+      const result = hybridRequire(relativeFile);
+      expect(result.default).toBe('relative-export');
+
+      // If relative path fails, it should throw (not fallback)
+      expect(() => hybridRequire('./nonexistent.js')).toThrow();
+    });
+
+    it('should throw non-MODULE_NOT_FOUND errors', () => {
+      const projectRoot = tempDir;
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      ufs.use(diskFs).use(fs as any);
+
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // Create a file that will cause a different error
+      const badFile = '/bad.js';
+      fs.writeFileSync(badFile, 'invalid syntax !!!');
+
+      // Should throw the original error, not attempt fallback
+      expect(() => hybridRequire(badFile)).toThrow();
+    });
+
+    it('should preserve cache and resolve properties', () => {
+      const projectRoot = tempDir;
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      ufs.use(diskFs).use(fs as any);
+
+      // Create hybridRequire (which creates fsRequire internally)
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // Verify cache and resolve are preserved from the internal fsRequire
+      expect(hybridRequire.cache).toBeDefined();
+      expect(typeof hybridRequire.cache).toBe('object');
+      expect(hybridRequire.resolve).toBeDefined();
+      expect(typeof hybridRequire.resolve).toBe('function');
+      // Verify resolve works
+      expect(() => hybridRequire.resolve('some-module')).not.toThrow();
+    });
+  });
+
+  describe('regression test - process.cwd variance', () => {
+    it('should resolve from initial working directory even after process.chdir', () => {
+      const projectRoot = tempDir;
+      const nodeModulesDir = path.join(projectRoot, 'node_modules');
+      const testPackageDir = path.join(nodeModulesDir, 'test-package-3');
+      const testFile = path.join(testPackageDir, 'index.js');
+
+      // Create directory structure
+      diskFs.mkdirSync(testPackageDir, { recursive: true });
+      diskFs.writeFileSync(
+        testFile,
+        "module.exports = { default: 'test-export-value' };",
+      );
+      diskFs.writeFileSync(
+        path.join(testPackageDir, 'package.json'),
+        JSON.stringify({ name: 'test-package-3', main: 'index.js' }),
+      );
+
+      diskFs.writeFileSync(
+        path.join(projectRoot, 'package.json'),
+        JSON.stringify({ name: 'test-project' }),
+      );
+
+      // Create another directory that we'll chdir to
+      const otherDir = tmp.dirSync({ unsafeCleanup: true }).name;
+      diskFs.writeFileSync(
+        path.join(otherDir, 'package.json'),
+        JSON.stringify({ name: 'other-project' }),
+      );
+
+      // Set up memfs WITHOUT diskFs to test fallback
+      const volume = new Volume();
+      const fs = createFsFromVolume(volume);
+      ufs.use(fs as any);
+
+      // Capture projectRequire at initial cwd
+      const hybridRequire = createHybridRequire(ufs, projectRoot);
+
+      // Change directory
+      process.chdir(otherDir);
+
+      // hybridRequire should still resolve from the original projectRoot
+      // because projectRequire was created with that path
+      const result = hybridRequire('test-package-3');
+      expect(result.default).toBe('test-export-value');
+    });
+  });
+});

package/src/scripts/__tests__/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.test.json"
+}
+

package/src/scripts/createHybridRequire.ts

@@ -0,0 +1,42 @@
+import { createFsRequire } from 'fs-require';
+import { createRequire } from 'module';
+import path from 'path';
+import { type IUnionFs } from 'unionfs';
+
+/**
+ * Creates a hybrid require function that combines fs-require (for in-memory files)
+ * with Node's native require (for bare specifiers from project node_modules).
+ *
+ * This solves the issue where fs-require cannot resolve bare specifiers like
+ * `@anansi/core/server` from workspace node_modules when they're not in the
+ * memfs bundle.
+ *
+ * @param ufs - The unionfs instance (disk first, then memfs)
+ * @param projectRoot - Optional project root directory. Defaults to process.cwd()
+ * @returns A require function that tries memfs first, then falls back to project node_modules
+ */
+export function createHybridRequire(
+  ufs: IUnionFs,
+  projectRoot: string = process.cwd(),
+): ReturnType<typeof createFsRequire> {
+  const fsRequire = createFsRequire(ufs);
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+
+  function hybridRequire(id: string) {
+    try {
+      return fsRequire(id);
+    } catch (error: any) {
+      const isBare = !id.startsWith('.') && !path.isAbsolute(id);
+      if (isBare && error?.code === 'MODULE_NOT_FOUND') {
+        return projectRequire(id);
+      }
+      throw error;
+    }
+  }
+
+  // Preserve cache and resolve properties from fsRequire
+  hybridRequire.cache = fsRequire.cache;
+  hybridRequire.resolve = fsRequire.resolve;
+
+  return hybridRequire as ReturnType<typeof createFsRequire>;
+}

package/src/scripts/startDevserver.ts

@@ -6,7 +6,6 @@ Object.hasOwn =
   };
 import type { NextFunction } from 'express';
 import diskFs from 'fs';
-import { createFsRequire } from 'fs-require';
 import { IncomingMessage, ServerResponse } from 'http';
 import { createFsFromVolume, Volume } from 'memfs';
 import path from 'path';
@@ -19,6 +18,7 @@ import logging from 'webpack/lib/logging/runtime.js';
 import WebpackDevServer from 'webpack-dev-server';
 
 import 'cross-fetch/dist/node-polyfill.js';
+import { createHybridRequire } from './createHybridRequire.js';
 import { getWebpackConfig } from './getWebpackConfig.js';
 import { BoundRender } from './types.js';
 
@@ -52,7 +52,8 @@ export default async function startDevServer(
   const fs = createFsFromVolume(volume);
   ufs.use(diskFs).use(fs as any);
 
-  const fsRequire = createFsRequire(ufs);
+  const fsRequire = createHybridRequire(ufs);
+
   const readFile = promisify(ufs.readFile);
   // Generate a temporary file so we can hot reload from the root of the application
   function hotEntry(entryPath: string) {