arcway 0.1.25 → 0.1.27

package/server/events/handler.js

@@ -11,8 +11,10 @@ function listenerPathToEvent(relativePath) {
 
 function validateHandler(item, filePath, index) {
   const label = index !== undefined ? `[${index}]` : '';
-  if (typeof item === 'function') return item;
-  if (typeof item === 'object' && item !== null && typeof item.handler === 'function') return item.handler;
+  if (typeof item === 'function') return { handler: item };
+  if (typeof item === 'object' && item !== null && typeof item.handler === 'function') {
+    return { handler: item.handler, consumerGroup: item.consumerGroup };
+  }
   throw new Error(
     `Listener at ${filePath}${label} must be a function or an object with a "handler" function`,
   );
@@ -54,11 +56,23 @@ class EventHandler {
 
       const items = Array.isArray(exported) ? exported : [exported];
       for (let i = 0; i < items.length; i++) {
-        const handler = validateHandler(items[i], filePath, items.length > 1 ? i : undefined);
-        this._events.subscribe(event, (_eventName, payload) => {
-          const ctx = buildContext(this._appContext, { event: { name: _eventName, payload } });
-          handler(ctx);
-        });
+        const { handler, consumerGroup } = validateHandler(
+          items[i],
+          filePath,
+          items.length > 1 ? i : undefined,
+        );
+        const groupName =
+          consumerGroup === false
+            ? undefined
+            : consumerGroup ?? `listener:${relativePath}:${items.length > 1 ? i : 0}`;
+        this._events.subscribe(
+          event,
+          (payload, _eventName) => {
+            const ctx = buildContext(this._appContext, { event: { name: _eventName, payload } });
+            return handler(ctx);
+          },
+          { consumerGroup: groupName },
+        );
         this._listeners.push({ event, fileName: relativePath });
       }
       this._log?.info(`  ${relativePath} → ${event}${items.length > 1 ? ` (${items.length} listeners)` : ''}`);

package/server/events/index.js

@@ -18,8 +18,8 @@ class Events {
     }
   }
 
-  subscribe(pattern, handler) {
-    this._transport.subscribe(pattern, handler);
+  subscribe(pattern, handler, options) {
+    return this._transport.subscribe(pattern, handler, options);
   }
 
   async emit(eventName, payload) {

package/server/index.js

@@ -1,8 +1,7 @@
-import { type } from 'arktype';
-import { buildContext } from './context.js';
-import * as vault from './lib/vault/index.js';
-import boot from './boot.js';
-import {
+export { type } from 'arktype';
+export { buildContext } from './context.js';
+export { default as boot } from './boot.js';
+export {
   Arcway,
   Solo,
   createTestContext,
@@ -13,41 +12,16 @@ import {
   createMailStub,
   createLoggerStub,
 } from './testing/index.js';
-import {
+export {
   createRateLimitMiddleware,
   MemoryRateLimitStore,
   RedisRateLimitStore,
 } from './rate-limit/index.js';
-import { wsSendToSocket, wsBroadcastToPath } from './ws/registry.js';
-import {
+export { wsSendToSocket, wsBroadcastToPath } from './ws/registry.js';
+export {
   SYSTEM_JOB_DOMAIN,
   addSystemJobEntry,
   registerSystemJobs,
   validateNoSystemJobCollision,
   getApplicableSystemJobs,
 } from './system-jobs/index.js';
-export {
-  MemoryRateLimitStore,
-  RedisRateLimitStore,
-  Arcway,
-  SYSTEM_JOB_DOMAIN,
-  Solo,
-  addSystemJobEntry,
-  boot,
-  buildContext,
-  createCacheStub,
-  createEventStub,
-  createFilesStub,
-  createLoggerStub,
-  createMailStub,
-  createQueueStub,
-  createRateLimitMiddleware,
-  createTestContext,
-  getApplicableSystemJobs,
-  registerSystemJobs,
-  type,
-  validateNoSystemJobCollision,
-  vault,
-  wsBroadcastToPath,
-  wsSendToSocket,
-};

package/server/jobs/runner.js

@@ -45,7 +45,7 @@ class JobRunner {
   _stopped = false;
   _lastEnqueuedMinute = new Map();
 
-  constructor(config, { db, queue, cache, files, mail, events, log, workerPool } = {}) {
+  constructor(config, { db, queue, cache, files, mail, events, log, meta, workerPool } = {}) {
     this._config = config;
     this._log = log;
     this._dispatcher = new JobDispatcher({
@@ -53,7 +53,7 @@ class JobRunner {
       staleTimeoutMs: config?.staleTimeoutMs,
       workerPool,
     });
-    this._appContext = { db, queue, cache, files, mail, events, log };
+    this._appContext = { db, queue, cache, files, mail, events, log, meta };
   }
 
   get dispatcher() {
@@ -96,6 +96,7 @@ class JobRunner {
       cache: this._appContext.cache?.withNamespace(SYSTEM_JOB_DOMAIN),
       files: this._appContext.files?.withNamespace(SYSTEM_JOB_DOMAIN),
       mail: this._appContext.mail,
+      meta: this._appContext.meta,
       log: this._log.extend({ logger: SYSTEM_JOB_DOMAIN }),
     };
     const systemJobs = registerSystemJobs(this._config, this._dispatcher, systemContext);

package/server/jobs/worker-config.js

@@ -0,0 +1,58 @@
+import { makeConfig } from '../config/loader.js';
+
+function isPlainObject(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
+
+function stripFunctions(value) {
+  if (typeof value === 'function') return undefined;
+  if (Array.isArray(value)) return value.map(stripFunctions);
+  if (!isPlainObject(value)) return value;
+
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    const stripped = stripFunctions(child);
+    if (stripped !== undefined) result[key] = stripped;
+  }
+  return result;
+}
+
+function mergeConfig(base, override) {
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override === undefined ? base : override;
+  }
+
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    result[key] = mergeConfig(result[key], value);
+  }
+  return result;
+}
+
+function createWorkerData({ config, rootDir, mode, meta } = {}) {
+  return {
+    config: stripFunctions(config),
+    configRootDir: rootDir,
+    mode,
+    meta: stripFunctions(meta),
+  };
+}
+
+async function resolveWorkerConfig(workerData) {
+  if (!workerData?.configRootDir) {
+    if (!workerData?.config) {
+      throw new Error('Worker started without workerData.config — cannot build job context');
+    }
+    return workerData.config;
+  }
+
+  const appConfig = await makeConfig(workerData.configRootDir, { mode: workerData.mode });
+  return mergeConfig(appConfig, workerData.config);
+}
+
+export { createWorkerData, mergeConfig, resolveWorkerConfig, stripFunctions };

package/server/jobs/worker-entry.js

@@ -1,6 +1,7 @@
 import { parentPort, workerData } from 'node:worker_threads';
 import { pathToFileURL } from 'node:url';
 import { serializeError } from './worker-pool.js';
+import { resolveWorkerConfig } from './worker-config.js';
 import { buildContext } from '../context.js';
 import { createInfrastructure, destroyInfrastructure } from '../boot/infrastructure.js';
 
@@ -21,16 +22,12 @@ let shuttingDown = false;
 async function ensureInfrastructure() {
   if (infrastructure) return infrastructure;
   if (!infrastructurePromise) {
-    const config = workerData?.config;
-    if (!config) {
-      throw new Error('Worker started without workerData.config — cannot build job context');
-    }
-    infrastructurePromise = createInfrastructure(config, { runMigrations: false }).then(
-      (services) => {
+    infrastructurePromise = resolveWorkerConfig(workerData)
+      .then((config) => createInfrastructure(config, { runMigrations: false }))
+      .then((services) => {
         infrastructure = services;
         return services;
-      },
-    );
+      });
   }
   return infrastructurePromise;
 }
@@ -55,9 +52,7 @@ async function loadHandler(handlerPath, handlerExport) {
         ? exported.handler
         : null;
   if (!fn) {
-    throw new Error(
-      `Worker handler export "${exportName}" in ${handlerPath} is not a function`,
-    );
+    throw new Error(`Worker handler export "${exportName}" in ${handlerPath} is not a function`);
   }
   return fn;
 }
@@ -71,7 +66,7 @@ async function runTask(task) {
   // and any future cpu-only caller) gets the raw payload — no DB spin-up.
   if (withContext) {
     const services = await ensureInfrastructure();
-    const ctx = buildContext(services, { payload });
+    const ctx = buildContext({ ...services, meta: workerData?.meta }, { payload });
     return fn(ctx);
   }
   return fn(payload);

package/server/meta.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function runGit(rootDir, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: rootDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeMeta(meta = {}) {
+  const sha = meta.sha ?? null;
+  const shortSha = meta.shortSha ?? (sha ? sha.slice(0, 7) : null);
+  const packageVersion = meta.packageVersion ?? null;
+
+  return {
+    builtAt: meta.builtAt ?? null,
+    version: meta.version ?? shortSha ?? packageVersion,
+    buildNumber: meta.buildNumber ?? null,
+    branch: meta.branch ?? null,
+    tag: meta.tag ?? null,
+    dirty: meta.dirty ?? null,
+    environment: meta.environment ?? process.env.NODE_ENV ?? 'development',
+    nodeVersion: meta.nodeVersion ?? process.version,
+    shortSha,
+    sha,
+    packageVersion,
+  };
+}
+
+function resolveEnvSha() {
+  return (
+    process.env.GIT_COMMIT ||
+    process.env.GITHUB_SHA ||
+    process.env.VERCEL_GIT_COMMIT_SHA ||
+    process.env.CI_COMMIT_SHA ||
+    null
+  );
+}
+
+function resolveGitSha(rootDir) {
+  const envSha = resolveEnvSha();
+  if (envSha) return envSha.trim();
+  return runGit(rootDir, ['rev-parse', 'HEAD']);
+}
+
+function resolveBuildNumber(rootDir) {
+  const count = runGit(rootDir, ['rev-list', '--count', 'HEAD']);
+  if (!count) return null;
+
+  const parsed = Number(count);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function resolveGitBranch(rootDir) {
+  return runGit(rootDir, ['rev-parse', '--abbrev-ref', 'HEAD']);
+}
+
+function resolveGitTag(rootDir) {
+  const tag = runGit(rootDir, ['describe', '--tags', '--abbrev=0']);
+  return tag || null;
+}
+
+function resolveDirty(rootDir) {
+  const status = runGit(rootDir, ['status', '--porcelain']);
+  if (status === null) return null;
+  return status.length > 0;
+}
+
+async function resolvePackageVersion(rootDir) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(path.join(rootDir, 'package.json'), 'utf8'));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+async function collectRuntimeMeta(rootDir, { builtAt = new Date().toISOString() } = {}) {
+  const sha = resolveGitSha(rootDir);
+  const buildNumber = resolveBuildNumber(rootDir);
+  const branch = resolveGitBranch(rootDir);
+  const tag = resolveGitTag(rootDir);
+  const dirty = resolveDirty(rootDir);
+  const packageVersion = await resolvePackageVersion(rootDir);
+
+  return normalizeMeta({
+    builtAt,
+    buildNumber,
+    branch,
+    tag,
+    dirty,
+    environment: process.env.NODE_ENV ?? 'development',
+    nodeVersion: process.version,
+    sha,
+    packageVersion,
+  });
+}
+
+export { collectRuntimeMeta, normalizeMeta };

package/server/pages/build-client.js

@@ -18,7 +18,7 @@ import { computeEntryChunks } from './chunk-graph.js';
 // Bump when the shape produced by `extractMetadata` / the serialized cache
 // payload changes in a way that would make an old cache entry decode into a
 // broken manifest. Prevents a stale v1 cache from ever satisfying a v2 build.
-const METADATA_VERSION = 3;
+const METADATA_VERSION = 4;
 
 // Build a deterministic plan of the hydration entries that will be written
 // into the staging dir. Computed up-front so we can derive a cache key

package/server/pages/build-plugins.js

@@ -57,7 +57,8 @@ function clientIsolationPlugin() {
           args.path === 'arcway/lib/client' ||
           args.path.startsWith('arcway/lib/client/') ||
           args.path === 'arcway/ui' ||
-          args.path.startsWith('arcway/ui/')
+          args.path.startsWith('arcway/ui/') ||
+          args.path === 'arcway/dynamic'
         ) {
           return void 0;
         }

package/server/pages/chunk-graph.js

@@ -39,6 +39,7 @@ function computeEntryChunks(metafile, clientDir) {
       const meta = outputs[cur];
       if (!meta) continue;
       for (const imp of meta.imports ?? []) {
+        if (imp.kind === 'dynamic-import') continue;
         const target = imp.path;
         if (!target || visited.has(target)) continue;
         visited.add(target);

package/server/pages/fonts.js

@@ -36,6 +36,19 @@ const NAMED_WEIGHTS = {
   black: 900,
   heavy: 900,
 };
+const NAMED_WEIGHT_KEYS = Object.keys(NAMED_WEIGHTS).sort((a, b) => b.length - a.length);
+
+function resolveNamedWeight(baseName) {
+  if (!baseName) return void 0;
+  const normalized = baseName.toLowerCase().replace(/[\s._-]+/g, '');
+  for (const key of NAMED_WEIGHT_KEYS) {
+    if (normalized === key || normalized.endsWith(key)) {
+      return NAMED_WEIGHTS[key];
+    }
+  }
+  return void 0;
+}
+
 async function scanFontDirectory(srcDir, publicDir) {
   const dirPath = path.join(publicDir, srcDir);
   let entries;
@@ -54,7 +67,7 @@ async function scanFontDirectory(srcDir, publicDir) {
     if (!isNaN(numericWeight) && numericWeight >= 1 && numericWeight <= 999) {
       weight = numericWeight;
     } else {
-      weight = NAMED_WEIGHTS[baseName];
+      weight = resolveNamedWeight(baseName);
     }
     if (weight === void 0) continue;
     files.push({

package/server/pages/handler.js

@@ -16,10 +16,21 @@ import {
 import { MIME_TYPES } from './static.js';
 import { createArcwayDevEndpoint } from './arcway-endpoint.js';
 import { buildViteClientManifestJson, buildViteRoute } from './vite-dev.js';
+
+function getHtmlHeaders() {
+  return {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Cache-Control': 'no-store',
+  };
+}
 function createPagesHandler(options) {
   const rootDir = options.rootDir;
-  const outDir = path.resolve(rootDir, options.outDir ?? '.build/pages');
-  const manifestPath = path.join(outDir, 'pages-manifest.json');
+  const resolveOutDir =
+    typeof options.resolveOutDir === 'function'
+      ? () => path.resolve(options.resolveOutDir())
+      : () => path.resolve(rootDir, options.outDir ?? '.build/pages');
+  let outDir = resolveOutDir();
+  let manifestPath = path.join(outDir, 'pages-manifest.json');
   const sessionConfig = options.session;
   const appContext = options.appContext ?? null;
   const mode = options.mode ?? 'production';
@@ -87,6 +98,11 @@ function createPagesHandler(options) {
       refreshFromLazy();
       return;
     }
+    const nextOutDir = resolveOutDir();
+    if (nextOutDir !== outDir) {
+      outDir = nextOutDir;
+      manifestPath = path.join(outDir, 'pages-manifest.json');
+    }
     if (!fs.existsSync(manifestPath)) return;
     manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     routes = compileRoutes(manifest, { rootDir, outDir, viteDev });
@@ -132,6 +148,7 @@ function createPagesHandler(options) {
     }
     // Pick up any invalidations or completed builds that landed since the
     // last request before we resolve the route.
+    if (!lazyContext) reload();
     refreshFromLazy();
     const matched = matchPageRoute(routes, pathname);
     if (!matched) {
@@ -198,7 +215,7 @@ function createPagesHandler(options) {
         }
         const status = middlewareResult.status ?? 403;
         const headers = {
-          'Content-Type': 'text/html; charset=utf-8',
+          ...getHtmlHeaders(),
           ...middlewareResult.headers,
         };
         res.writeHead(status, headers);
@@ -225,7 +242,7 @@ function createPagesHandler(options) {
       if (manifest.errorBundle && !res.headersSent) {
         const errorMessage = devMode
           ? err instanceof Error
-            ? err.message
+            ? err.stack || err.message
             : String(err)
           : 'An unexpected error occurred';
         await renderErrorPage(
@@ -240,7 +257,7 @@ function createPagesHandler(options) {
           projectReact,
         );
       } else if (!res.headersSent) {
-        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.writeHead(500, getHtmlHeaders());
         res.end('<h1>500 - Internal Server Error</h1>');
       }
     }
@@ -270,7 +287,7 @@ async function renderDevBuildError(
   cacheVersion,
   projectReact,
 ) {
-  const errorMessage = err instanceof Error ? err.message : String(err);
+  const errorMessage = err instanceof Error ? err.stack || err.message : String(err);
   if (manifest.errorBundle && !res.headersSent) {
     await renderErrorPage(
       manifest.errorBundle,
@@ -290,7 +307,7 @@ async function renderDevBuildError(
       .replace(/&/g, '&amp;')
       .replace(/</g, '&lt;')
       .replace(/>/g, '&gt;');
-    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.writeHead(500, getHtmlHeaders());
     res.end(`<h1>500 - Build Error</h1><pre>${escaped}</pre>`);
   }
 }
@@ -353,6 +370,7 @@ async function runPageMiddleware(
         queue: appContext.queue,
         files: appContext.files,
         mail: appContext.mail,
+        meta: appContext.meta,
       }
     : { page };
   for (const bundlePath of route.middlewareServerBundles) {

package/server/pages/lazy-context.js

@@ -161,7 +161,7 @@ async function createLazyPagesContext(options) {
           minify,
           limit,
         }),
-        syncViteHydrationEntries({ manifest, outDir }),
+        syncViteHydrationEntries({ manifest, outDir, fontFaceCss }),
       ]);
       if (errorBundles.error) manifest.errorBundle = errorBundles.error;
       if (errorBundles.notFound) manifest.notFoundBundle = errorBundles.notFound;
@@ -708,7 +708,7 @@ async function createLazyPagesContext(options) {
       if (viteDev) {
         const nextStylesPath = await discoverStyles(pagesDir);
         manifest.stylesPath = nextStylesPath ? path.resolve(nextStylesPath) : null;
-        await syncViteHydrationEntries({ manifest, outDir });
+        await syncViteHydrationEntries({ manifest, outDir, fontFaceCss });
       }
 
       // ── Version bump + event emission ────────────────────────────────

package/server/pages/out-dir.js

@@ -1,11 +1,112 @@
 import path from 'node:path';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import crypto from 'node:crypto';
 
-function resolvePagesOutDir(config, rootDir, mode = 'production') {
+function resolvePagesBaseOutDir(config, rootDir, mode = 'production') {
   const pages = config?.pages ?? {};
   const isDev = mode === 'development';
   const prodOutDir = pages.outDir ?? path.resolve(rootDir, '.build/pages');
-  const devOutDir = pages.devOutDir ?? path.resolve(rootDir, '.build-dev/pages');
+  const devOutDir = pages.devOutDir ?? path.resolve(rootDir, '.build/dev/pages');
   return isDev ? devOutDir : prodOutDir;
 }
 
-export { resolvePagesOutDir };
+function getPagesBuildPaths(baseOutDir) {
+  const parentDir = path.dirname(baseOutDir);
+  return {
+    baseOutDir,
+    buildsDir: parentDir,
+    metaPath: path.join(parentDir, 'meta.json'),
+  };
+}
+
+function readActivePagesBuildHash(baseOutDir) {
+  const { metaPath } = getPagesBuildPaths(baseOutDir);
+  try {
+    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    return typeof meta?.pagesBuildHash === 'string' && meta.pagesBuildHash.length > 0
+      ? meta.pagesBuildHash
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveActivePagesOutDir(baseOutDir) {
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  const buildHash = readActivePagesBuildHash(baseOutDir);
+  if (buildHash) {
+    const candidate = path.join(buildsDir, buildHash);
+    if (fs.existsSync(path.join(candidate, 'pages-manifest.json'))) return candidate;
+  }
+  return baseOutDir;
+}
+
+function resolvePagesOutDir(config, rootDir, mode = 'production') {
+  const baseOutDir = resolvePagesBaseOutDir(config, rootDir, mode);
+  return mode === 'development' ? baseOutDir : resolveActivePagesOutDir(baseOutDir);
+}
+
+function createPagesBuildHash(now = new Date()) {
+  const iso = now
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}Z$/, 'Z');
+  return `${iso}-${crypto.randomBytes(4).toString('hex')}`;
+}
+
+async function createPagesVersionedBuildTarget(baseOutDir, buildHash = createPagesBuildHash()) {
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  await fsp.mkdir(buildsDir, { recursive: true });
+  return {
+    buildHash,
+    outDir: path.join(buildsDir, buildHash),
+  };
+}
+
+async function pruneOldPagesBuilds(baseOutDir, keepCount = 5) {
+  if (!Number.isInteger(keepCount) || keepCount < 1) return;
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  const activeHash = readActivePagesBuildHash(baseOutDir);
+  let entries = [];
+  try {
+    entries = await fsp.readdir(buildsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const builds = await Promise.all(
+    entries
+      .filter((entry) => entry.isDirectory())
+      .map(async (entry) => {
+        const fullPath = path.join(buildsDir, entry.name);
+        const manifestPath = path.join(fullPath, 'pages-manifest.json');
+        try {
+          const stat = await fsp.stat(manifestPath);
+          return { buildHash: entry.name, fullPath, mtimeMs: stat.mtimeMs };
+        } catch {
+          return null;
+        }
+      }),
+  );
+  const sorted = builds
+    .filter(Boolean)
+    .sort((a, b) => b.mtimeMs - a.mtimeMs || b.buildHash.localeCompare(a.buildHash));
+  const retained = new Set(sorted.slice(0, keepCount).map((entry) => entry.buildHash));
+  if (activeHash) retained.add(activeHash);
+  await Promise.all(
+    sorted
+      .filter((entry) => !retained.has(entry.buildHash))
+      .map((entry) => fsp.rm(entry.fullPath, { recursive: true, force: true })),
+  );
+}
+
+export {
+  createPagesBuildHash,
+  createPagesVersionedBuildTarget,
+  getPagesBuildPaths,
+  pruneOldPagesBuilds,
+  readActivePagesBuildHash,
+  resolveActivePagesOutDir,
+  resolvePagesBaseOutDir,
+  resolvePagesOutDir,
+};

package/server/pages/pages-router.js

@@ -26,7 +26,8 @@ class PagesRouter {
     const { config, rootDir, log, mode, fileWatcher } = this;
     const isDev = mode === 'development';
     const viteDev = isDev && config.pages?.vite?.enabled === true;
-    const outDir = resolvePagesOutDir(config, rootDir, mode);
+    const resolveOutDir = () => resolvePagesOutDir(config, rootDir, mode);
+    const outDir = resolveOutDir();
 
     if (isDev) {
       // Dev mode: `createLazyPagesContext()` builds only the shared bits
@@ -51,7 +52,7 @@ class PagesRouter {
 
     this.handler = createPagesHandler({
       rootDir,
-      outDir,
+      ...(isDev ? { outDir } : { resolveOutDir }),
       session: config.session,
       appContext: this.appContext,
       mode,