arcway 0.1.21 → 0.1.22

package/server/pages/lazy-context.js

@@ -0,0 +1,640 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { EventEmitter } from 'node:events';
+import esbuild from 'esbuild';
+import pLimit from 'p-limit';
+import {
+  buildPageManifestEntry,
+  discoverPages,
+  discoverLayouts,
+  discoverLoadings,
+  discoverPageMiddleware,
+  discoverErrorPages,
+  discoverStyles,
+  resolveLayoutChain,
+  resolveLoadingChain,
+  resolvePageMiddlewareChain,
+  mapFileToAffected,
+} from './discovery.js';
+import { buildWithCache } from './build-cache.js';
+import {
+  jsxEsbuildOptions,
+  plainEsbuildOptions,
+  patternToFileName,
+  layoutDirToFileName,
+  buildErrorPageBundles,
+} from './build-server.js';
+import { createClientBuildContext } from './build-client.js';
+import { buildCssBundle } from './build-css.js';
+import { resolveFonts } from './fonts.js';
+import { buildHmrRuntimeBundle } from './hmr.js';
+
+// Dev-mode build context that defers per-page/layout/middleware server-bundle
+// compilation to first request. Startup is cheap: discover routes, build the
+// client bundle + CSS + error pages eagerly (unavoidable — they're shared
+// across all routes), and emit an in-memory manifest where every server
+// entry is flagged `built: false`. Handler calls `ensurePageBuilt(pattern)`
+// before rendering; concurrent calls for the same pattern coalesce to one
+// build. A single shared `p-limit(cpuCount)` gates every buildWithCache call
+// so a request burst can't saturate CPU.
+//
+// Prod is untouched — `buildPages()` and `createPagesBuildContext()` still
+// fully build every server bundle upfront and atomically swap into place.
+
+async function createLazyPagesContext(options) {
+  const { rootDir } = options;
+  const pagesDir = options.pagesDir ?? path.join(rootDir, 'pages');
+  const outDir = path.resolve(rootDir, options.outDir ?? '.build/pages');
+  const serverTarget = options.serverTarget ?? 'node22';
+  const clientTarget = options.clientTarget ?? 'es2022';
+  const minify = options.minify ?? false;
+  const devMode = options.devMode ?? true;
+  const esbuildImpl = options.esbuild ?? esbuild;
+  // Cap per-context server-bundle concurrency so a request burst after a
+  // cold start can't spawn N pages × M esbuild Go workers simultaneously.
+  // Defaults to logical core count for parity with today's eager fan-out on
+  // a single-user dev box; callers override in tests to assert coalescing.
+  const maxConcurrency = options.concurrency ?? os.cpus().length;
+  const limit = pLimit(Math.max(1, maxConcurrency));
+
+  const events = new EventEmitter();
+  events.setMaxListeners(0);
+
+  let disposed = false;
+  let clientCtx = null;
+  let fontFaceCss;
+  let fontPreloadHtml;
+
+  if (options.fonts && options.fonts.length > 0) {
+    const publicDir = path.join(rootDir, 'public');
+    const fontResult = await resolveFonts(options.fonts, publicDir);
+    if (fontResult.fontFaceCss) fontFaceCss = fontResult.fontFaceCss;
+    if (fontResult.preloadHtml) fontPreloadHtml = fontResult.preloadHtml;
+  }
+
+  // Discover routes up front. Structural changes (new/deleted files) are
+  // picked up later via the watcher's re-discovery path (phase 5).
+  const [pages, layouts, loadings, middlewares, errorPages, stylesPath] = await Promise.all([
+    discoverPages(pagesDir),
+    discoverLayouts(pagesDir),
+    discoverLoadings(pagesDir),
+    discoverPageMiddleware(pagesDir),
+    discoverErrorPages(pagesDir),
+    discoverStyles(pagesDir),
+  ]);
+
+  await fs.mkdir(path.join(outDir, 'server'), { recursive: true });
+  await fs.mkdir(path.join(outDir, 'client'), { recursive: true });
+
+  const manifest = {
+    entries: pages.map((page) => buildPageManifestEntry(page, { layouts, middlewares, loadings })),
+    layouts: new Map(
+      layouts.map((l) => [
+        l.dirPath,
+        { srcPath: path.resolve(l.filePath), built: false, stale: false },
+      ]),
+    ),
+    middlewares: new Map(
+      middlewares.map((m) => [
+        m.dirPath,
+        { srcPath: path.resolve(m.filePath), built: false, stale: false },
+      ]),
+    ),
+    version: 0,
+  };
+
+  if (fontPreloadHtml) manifest.fontPreloadHtml = fontPreloadHtml;
+
+  // In-flight coalescing: when a burst of concurrent requests hits an unbuilt
+  // page, only the first triggers a build; the rest await the same promise.
+  const inFlightPages = new Map();
+  const inFlightLayouts = new Map();
+  const inFlightMiddlewares = new Map();
+
+  function bumpVersion() {
+    manifest.version += 1;
+  }
+
+  function emit(event, payload) {
+    events.emit(event, payload);
+  }
+
+  // Client bundle + CSS + error pages + HMR runtime are built eagerly at
+  // startup. They're shared across every request and their compilation cost
+  // is bounded (a single esbuild.context for the client, one esbuild.transform
+  // for CSS), so there's no win in deferring them.
+  async function eagerSharedBuilds() {
+    clientCtx = await createClientBuildContext(
+      pages,
+      layouts,
+      outDir,
+      clientTarget,
+      minify,
+      rootDir,
+      loadings,
+      minify ? 'production' : 'development',
+      devMode,
+    );
+    const [clientResult, cssBundle, errorBundles] = await Promise.all([
+      clientCtx.rebuild(),
+      buildCssBundle(pagesDir, outDir, minify, stylesPath, fontFaceCss, rootDir),
+      buildErrorPageBundles(errorPages, outDir, serverTarget, {
+        rootDir,
+        devMode,
+        minify,
+        limit,
+      }),
+      devMode ? buildHmrRuntimeBundle(outDir) : Promise.resolve(),
+    ]);
+
+    // Fold client bundle output into the manifest so renderPage() can find
+    // navBundle / layoutClientBundles / shared chunks immediately, the same
+    // as it would from a disk-backed prod manifest.
+    for (const entry of manifest.entries) {
+      const clientBundle = clientResult.bundles.get(entry.pattern);
+      const navBundle = clientResult.navBundles.get(entry.pattern);
+      if (clientBundle) entry.clientBundle = clientBundle;
+      if (navBundle) entry.navBundle = navBundle;
+      entry.layoutClientBundles = entry.layoutDirs
+        .map((d) => clientResult.layoutNavBundles.get(d))
+        .filter((v) => v !== undefined);
+      entry.loadingClientBundles = entry.loadingDirs
+        .map((d) => clientResult.loadingNavBundles.get(d))
+        .filter((v) => v !== undefined);
+      entry.sharedChunks = clientResult.entryChunks?.get(entry.pattern) ?? [];
+      entry.sharedCssChunks = clientResult.entryCssChunks?.get(entry.pattern) ?? [];
+    }
+    if (cssBundle) manifest.cssBundle = cssBundle;
+    if (errorBundles.error) manifest.errorBundle = errorBundles.error;
+    if (errorBundles.notFound) manifest.notFoundBundle = errorBundles.notFound;
+    bumpVersion();
+    emit('update', { type: 'startup', version: manifest.version });
+    return { clientMetafile: clientResult.metafile };
+  }
+
+  const startup = await eagerSharedBuilds();
+
+  function findEntry(pattern) {
+    return manifest.entries.find((e) => e.pattern === pattern) ?? null;
+  }
+
+  async function buildPageServer(entry) {
+    const outName = patternToFileName(entry.pattern);
+    const outFile = path.join(outDir, 'server', `${outName}.js`);
+    await buildWithCache({
+      rootDir,
+      kind: 'server',
+      entryPath: entry.srcPath,
+      outFile,
+      esbuildOptions: jsxEsbuildOptions(entry.srcPath, outFile, serverTarget),
+      esbuild: esbuildImpl,
+      devMode,
+      minify,
+    });
+    entry.serverBundle = path.relative(outDir, outFile).replace(/\\/g, '/');
+    entry.built = true;
+    entry.stale = false;
+    entry.lastBuiltAt = Date.now();
+  }
+
+  async function buildLayoutServer(dirPath) {
+    const layout = manifest.layouts.get(dirPath);
+    if (!layout) return;
+    const outName = layoutDirToFileName(dirPath);
+    const outFile = path.join(outDir, 'server', `_layout_${outName}.js`);
+    await buildWithCache({
+      rootDir,
+      kind: 'layout',
+      entryPath: layout.srcPath,
+      outFile,
+      esbuildOptions: jsxEsbuildOptions(layout.srcPath, outFile, serverTarget),
+      esbuild: esbuildImpl,
+      devMode,
+      minify,
+    });
+    layout.serverBundle = path.relative(outDir, outFile).replace(/\\/g, '/');
+    layout.built = true;
+    layout.stale = false;
+    layout.lastBuiltAt = Date.now();
+  }
+
+  async function buildMiddlewareServer(dirPath) {
+    const mw = manifest.middlewares.get(dirPath);
+    if (!mw) return;
+    const outName = layoutDirToFileName(dirPath);
+    const outFile = path.join(outDir, 'server', `_middleware_${outName}.js`);
+    await buildWithCache({
+      rootDir,
+      kind: 'middleware',
+      entryPath: mw.srcPath,
+      outFile,
+      esbuildOptions: plainEsbuildOptions(mw.srcPath, outFile, serverTarget),
+      esbuild: esbuildImpl,
+      devMode,
+      minify,
+    });
+    mw.serverBundle = path.relative(outDir, outFile).replace(/\\/g, '/');
+    mw.built = true;
+    mw.stale = false;
+    mw.lastBuiltAt = Date.now();
+  }
+
+  function ensureLayoutBuilt(dirPath) {
+    const layout = manifest.layouts.get(dirPath);
+    if (!layout) return Promise.reject(new Error(`Unknown layout dirPath: ${dirPath}`));
+    if (layout.built && !layout.stale) return Promise.resolve();
+    const existing = inFlightLayouts.get(dirPath);
+    if (existing) return existing;
+    const task = limit(() => buildLayoutServer(dirPath))
+      .then(() => {
+        emit('update', { type: 'built', kind: 'layout', dirPath, version: ++manifest.version });
+      })
+      .finally(() => inFlightLayouts.delete(dirPath));
+    inFlightLayouts.set(dirPath, task);
+    return task;
+  }
+
+  function ensureMiddlewareBuilt(dirPath) {
+    const mw = manifest.middlewares.get(dirPath);
+    if (!mw) return Promise.reject(new Error(`Unknown middleware dirPath: ${dirPath}`));
+    if (mw.built && !mw.stale) return Promise.resolve();
+    const existing = inFlightMiddlewares.get(dirPath);
+    if (existing) return existing;
+    const task = limit(() => buildMiddlewareServer(dirPath))
+      .then(() => {
+        emit('update', { type: 'built', kind: 'middleware', dirPath, version: ++manifest.version });
+      })
+      .finally(() => inFlightMiddlewares.delete(dirPath));
+    inFlightMiddlewares.set(dirPath, task);
+    return task;
+  }
+
+  function ensurePageBuilt(pattern) {
+    const entry = findEntry(pattern);
+    if (!entry) return Promise.reject(new Error(`Unknown page pattern: ${pattern}`));
+    if (entry.built && !entry.stale) {
+      // Still need to ensure layouts/middlewares stay current; they can be
+      // invalidated independently of the page itself.
+      return ensureChainBuilt(entry);
+    }
+    const existing = inFlightPages.get(pattern);
+    if (existing) return existing;
+    const task = Promise.all([
+      limit(() => buildPageServer(entry)),
+      ensureChainBuilt(entry),
+    ])
+      .then(() => {
+        entry.layoutServerBundles = entry.layoutDirs
+          .map((d) => manifest.layouts.get(d)?.serverBundle)
+          .filter((v) => v !== undefined);
+        entry.middlewareServerBundles = entry.middlewareDirs
+          .map((d) => manifest.middlewares.get(d)?.serverBundle)
+          .filter((v) => v !== undefined);
+        emit('update', { type: 'built', kind: 'page', pattern, version: ++manifest.version });
+      })
+      .finally(() => inFlightPages.delete(pattern));
+    inFlightPages.set(pattern, task);
+    return task;
+  }
+
+  function ensureChainBuilt(entry) {
+    const jobs = [];
+    for (const dirPath of entry.layoutDirs) jobs.push(ensureLayoutBuilt(dirPath));
+    for (const dirPath of entry.middlewareDirs) jobs.push(ensureMiddlewareBuilt(dirPath));
+    return Promise.all(jobs).then(() => {
+      // Re-stitch the page's bundle list after the chain settles so any
+      // layout that just finished building is reflected on the entry.
+      entry.layoutServerBundles = entry.layoutDirs
+        .map((d) => manifest.layouts.get(d)?.serverBundle)
+        .filter((v) => v !== undefined);
+      entry.middlewareServerBundles = entry.middlewareDirs
+        .map((d) => manifest.middlewares.get(d)?.serverBundle)
+        .filter((v) => v !== undefined);
+    });
+  }
+
+  // Mark every manifest entry affected by a source change as stale. Does not
+  // trigger rebuilds directly — the next `ensurePageBuilt()` call (driven by
+  // an incoming request) handles the actual work. Structural changes
+  // (add/remove files) are not handled here; the watcher will re-init the
+  // context or extend the manifest in phase 5.
+  function invalidate(filePath) {
+    const affected = mapFileToAffected(filePath, manifest);
+    let touched = false;
+    for (const pattern of affected.pages) {
+      const entry = findEntry(pattern);
+      if (entry) {
+        entry.stale = true;
+        entry.built = false;
+        touched = true;
+      }
+    }
+    for (const dirPath of affected.layouts) {
+      const layout = manifest.layouts.get(dirPath);
+      if (layout) {
+        layout.stale = true;
+        layout.built = false;
+        touched = true;
+      }
+    }
+    for (const dirPath of affected.middlewares) {
+      const mw = manifest.middlewares.get(dirPath);
+      if (mw) {
+        mw.stale = true;
+        mw.built = false;
+        touched = true;
+      }
+    }
+    if (touched) {
+      bumpVersion();
+      emit('update', { type: 'invalidate', filePath, affected, version: manifest.version });
+    }
+    return { touched, affected };
+  }
+
+  // ── Structural rediscovery ─────────────────────────────────────────────
+  // `invalidate()` handles content edits to known files; `rediscover()`
+  // handles add/delete of pages, layouts, and middlewares. Re-runs the same
+  // discovery helpers used at startup, diffs the result against the in-memory
+  // manifest, and applies adds/removes plus a cascade re-resolution of every
+  // surviving entry's chain (added/removed layouts and middlewares mutate
+  // descendants' chains). The client esbuild context is torn down and
+  // recreated when the page or layout set changes — middleware-only changes
+  // don't touch the client bundle. Concurrent calls coalesce to a single
+  // in-flight discovery so a burst (e.g. `git checkout` swap) triggers one
+  // pass, not N.
+  let inFlightRediscover = null;
+
+  async function rediscover() {
+    if (disposed) throw new Error('Lazy pages context is disposed');
+    if (inFlightRediscover) return inFlightRediscover;
+    const task = (async () => {
+      const [
+        nextPages,
+        nextLayouts,
+        nextLoadings,
+        nextMiddlewares,
+      ] = await Promise.all([
+        discoverPages(pagesDir),
+        discoverLayouts(pagesDir),
+        discoverLoadings(pagesDir),
+        discoverPageMiddleware(pagesDir),
+      ]);
+
+      const result = {
+        added: { pages: [], layouts: [], middlewares: [] },
+        removed: { pages: [], layouts: [], middlewares: [] },
+        staleByCascade: [],
+        clientRebuilt: false,
+        version: manifest.version,
+      };
+
+      // ── Diff ─────────────────────────────────────────────────────────
+      const currentPagePatterns = new Set(manifest.entries.map((e) => e.pattern));
+      const nextPagePatterns = new Set(nextPages.map((p) => p.pattern));
+      const addedPages = nextPages.filter((p) => !currentPagePatterns.has(p.pattern));
+      const removedPages = manifest.entries.filter((e) => !nextPagePatterns.has(e.pattern));
+
+      const currentLayoutDirs = new Set(manifest.layouts.keys());
+      const nextLayoutDirs = new Set(nextLayouts.map((l) => l.dirPath));
+      const addedLayouts = nextLayouts.filter((l) => !currentLayoutDirs.has(l.dirPath));
+      const removedLayouts = [...currentLayoutDirs].filter((d) => !nextLayoutDirs.has(d));
+
+      const currentMwDirs = new Set(manifest.middlewares.keys());
+      const nextMwDirs = new Set(nextMiddlewares.map((m) => m.dirPath));
+      const addedMiddlewares = nextMiddlewares.filter((m) => !currentMwDirs.has(m.dirPath));
+      const removedMiddlewares = [...currentMwDirs].filter((d) => !nextMwDirs.has(d));
+
+      const noOp =
+        addedPages.length === 0 &&
+        removedPages.length === 0 &&
+        addedLayouts.length === 0 &&
+        removedLayouts.length === 0 &&
+        addedMiddlewares.length === 0 &&
+        removedMiddlewares.length === 0;
+      if (noOp) return result;
+
+      // ── Apply layout add/remove ──────────────────────────────────────
+      for (const layout of addedLayouts) {
+        manifest.layouts.set(layout.dirPath, {
+          srcPath: path.resolve(layout.filePath),
+          built: false,
+          stale: false,
+        });
+        result.added.layouts.push(layout.dirPath);
+      }
+      for (const dirPath of removedLayouts) {
+        manifest.layouts.delete(dirPath);
+        inFlightLayouts.delete(dirPath);
+        result.removed.layouts.push(dirPath);
+      }
+
+      // ── Apply middleware add/remove ──────────────────────────────────
+      for (const mw of addedMiddlewares) {
+        manifest.middlewares.set(mw.dirPath, {
+          srcPath: path.resolve(mw.filePath),
+          built: false,
+          stale: false,
+        });
+        result.added.middlewares.push(mw.dirPath);
+      }
+      for (const dirPath of removedMiddlewares) {
+        manifest.middlewares.delete(dirPath);
+        inFlightMiddlewares.delete(dirPath);
+        result.removed.middlewares.push(dirPath);
+      }
+
+      // ── Apply page add/remove ────────────────────────────────────────
+      const addedPagePatterns = new Set();
+      for (const page of addedPages) {
+        manifest.entries.push(
+          buildPageManifestEntry(page, {
+            layouts: nextLayouts,
+            middlewares: nextMiddlewares,
+            loadings: nextLoadings,
+          }),
+        );
+        result.added.pages.push(page.pattern);
+        addedPagePatterns.add(page.pattern);
+      }
+      for (const removed of removedPages) {
+        const idx = manifest.entries.findIndex((e) => e.pattern === removed.pattern);
+        if (idx >= 0) manifest.entries.splice(idx, 1);
+        inFlightPages.delete(removed.pattern);
+        result.removed.pages.push(removed.pattern);
+      }
+
+      // ── Cascade: re-resolve chains for surviving entries; mark stale on diff
+      for (const entry of manifest.entries) {
+        if (addedPagePatterns.has(entry.pattern)) continue; // freshly built, already current
+        const newLayoutDirs = resolveLayoutChain(entry.pattern, nextLayouts).map((l) => l.dirPath);
+        const newMwDirs = resolvePageMiddlewareChain(entry.pattern, nextMiddlewares).map(
+          (m) => m.dirPath,
+        );
+        const newLoadingDirs = resolveLoadingChain(entry.pattern, nextLoadings).map(
+          (l) => l.dirPath,
+        );
+        const changed =
+          !arraysEqual(entry.layoutDirs, newLayoutDirs) ||
+          !arraysEqual(entry.middlewareDirs, newMwDirs) ||
+          !arraysEqual(entry.loadingDirs, newLoadingDirs);
+        if (changed) {
+          entry.layoutDirs = newLayoutDirs;
+          entry.middlewareDirs = newMwDirs;
+          entry.loadingDirs = newLoadingDirs;
+          entry.stale = true;
+          entry.built = false;
+          result.staleByCascade.push(entry.pattern);
+        }
+      }
+
+      // ── Client bundle rebuild on page or layout structural changes ───
+      const needClientRebuild =
+        result.added.pages.length > 0 ||
+        result.removed.pages.length > 0 ||
+        result.added.layouts.length > 0 ||
+        result.removed.layouts.length > 0;
+      if (needClientRebuild) {
+        if (clientCtx) {
+          try {
+            await clientCtx.dispose();
+          } catch {
+            /* ignore — we're replacing it anyway */
+          }
+        }
+        clientCtx = await createClientBuildContext(
+          nextPages,
+          nextLayouts,
+          outDir,
+          clientTarget,
+          minify,
+          rootDir,
+          nextLoadings,
+          minify ? 'production' : 'development',
+          devMode,
+        );
+        const clientResult = await clientCtx.rebuild();
+        for (const entry of manifest.entries) {
+          const clientBundle = clientResult.bundles.get(entry.pattern);
+          const navBundle = clientResult.navBundles.get(entry.pattern);
+          if (clientBundle) entry.clientBundle = clientBundle;
+          if (navBundle) entry.navBundle = navBundle;
+          entry.layoutClientBundles = entry.layoutDirs
+            .map((d) => clientResult.layoutNavBundles.get(d))
+            .filter((v) => v !== undefined);
+          entry.loadingClientBundles = entry.loadingDirs
+            .map((d) => clientResult.loadingNavBundles.get(d))
+            .filter((v) => v !== undefined);
+          entry.sharedChunks = clientResult.entryChunks?.get(entry.pattern) ?? [];
+          entry.sharedCssChunks = clientResult.entryCssChunks?.get(entry.pattern) ?? [];
+        }
+        result.clientRebuilt = true;
+      }
+
+      // ── Version bump + event emission ────────────────────────────────
+      bumpVersion();
+      result.version = manifest.version;
+      for (const pattern of result.added.pages) {
+        emit('update', { type: 'add-page', pattern, version: manifest.version });
+      }
+      for (const pattern of result.removed.pages) {
+        emit('update', { type: 'remove-page', pattern, version: manifest.version });
+      }
+      for (const dirPath of result.added.layouts) {
+        emit('update', { type: 'add-layout', dirPath, version: manifest.version });
+      }
+      for (const dirPath of result.removed.layouts) {
+        emit('update', { type: 'remove-layout', dirPath, version: manifest.version });
+      }
+      for (const dirPath of result.added.middlewares) {
+        emit('update', { type: 'add-middleware', dirPath, version: manifest.version });
+      }
+      for (const dirPath of result.removed.middlewares) {
+        emit('update', { type: 'remove-middleware', dirPath, version: manifest.version });
+      }
+      if (result.clientRebuilt) {
+        emit('update', { type: 'client-rebuilt', version: manifest.version });
+      }
+
+      return result;
+    })().finally(() => {
+      inFlightRediscover = null;
+    });
+    inFlightRediscover = task;
+    return task;
+  }
+
+  function arraysEqual(a, b) {
+    if (a === b) return true;
+    if (!a || !b || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+
+  function on(event, cb) {
+    events.on(event, cb);
+    return () => events.off(event, cb);
+  }
+
+  // Public, serializable snapshot for the `/_arcway/manifest.json` endpoint
+  // (phase 4). Strips absolute source paths and internal bookkeeping so a
+  // dev overlay can't infer disk layout.
+  function getManifestJson() {
+    return {
+      version: manifest.version,
+      entries: manifest.entries.map((entry) => ({
+        pattern: entry.pattern,
+        built: entry.built,
+        stale: entry.stale,
+        ...(entry.lastBuiltAt ? { lastBuiltAt: entry.lastBuiltAt } : {}),
+      })),
+      layouts: Array.from(manifest.layouts.entries()).map(([dirPath, l]) => ({
+        dirPath,
+        built: l.built,
+        stale: l.stale,
+        ...(l.lastBuiltAt ? { lastBuiltAt: l.lastBuiltAt } : {}),
+      })),
+      middlewares: Array.from(manifest.middlewares.entries()).map(([dirPath, m]) => ({
+        dirPath,
+        built: m.built,
+        stale: m.stale,
+        ...(m.lastBuiltAt ? { lastBuiltAt: m.lastBuiltAt } : {}),
+      })),
+      ...(manifest.errorBundle ? { errorBundle: manifest.errorBundle } : {}),
+      ...(manifest.notFoundBundle ? { notFoundBundle: manifest.notFoundBundle } : {}),
+      ...(manifest.cssBundle ? { cssBundle: manifest.cssBundle } : {}),
+    };
+  }
+
+  async function dispose() {
+    if (disposed) return;
+    disposed = true;
+    if (clientCtx) {
+      await clientCtx.dispose();
+      clientCtx = null;
+    }
+    events.removeAllListeners();
+  }
+
+  return {
+    manifest,
+    outDir,
+    rootDir,
+    ensurePageBuilt,
+    ensureLayoutBuilt,
+    ensureMiddlewareBuilt,
+    invalidate,
+    rediscover,
+    dispose,
+    on,
+    getManifestJson,
+    get clientMetafile() {
+      return startup.clientMetafile;
+    },
+  };
+}
+
+export { createLazyPagesContext };