arcway 0.1.26 → 0.1.28

package/server/jobs/runner.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { discoverModules } from '../discovery.js';
 import { buildContext } from '../context.js';
 import { parseCron, matchesCron } from './cron.js';
@@ -45,7 +44,10 @@ 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, plugins } = {},
+  ) {
     this._config = config;
     this._log = log;
     this._dispatcher = new JobDispatcher({
@@ -53,7 +55,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, plugins };
   }
 
   get dispatcher() {
@@ -75,13 +77,15 @@ class JobRunner {
     // Discover and register user jobs. `filePath` is captured so the
     // dispatcher can dynamic-import the handler inside a worker thread.
     const discovered = await discoverJobs(jobsDir);
-    for (const { definition, fileName, filePath } of discovered) {
+    const pluginJobs = (await this._appContext.plugins?.discoverJobs?.()) ?? [];
+    for (const { definition, fileName, filePath } of [...discovered, ...pluginJobs]) {
       this._dispatcher.register('app', definition, this._appContext, filePath);
       this._jobs.push({
         jobName: definition.name,
         fileName,
         schedule: definition.schedule,
         handler: definition.handler,
+        plugin: definition.plugin,
         cooldownMs: definition.cooldownMs,
         staleTimeout: definition.staleTimeout,
       });
@@ -96,6 +100,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);
@@ -109,6 +114,7 @@ class JobRunner {
         this._continuousJobs.push({
           qualifiedName: `app/${job.jobName}`,
           handler: job.handler,
+          plugin: job.plugin,
           cooldownMs: job.cooldownMs,
           appContext: this._appContext,
         });
@@ -191,6 +197,9 @@ class JobRunner {
       try {
         const start = Date.now();
         const ctx = buildContext(entry.appContext, { payload: void 0 });
+        if (entry.plugin) {
+          entry.appContext.plugins?.injectCapabilities(ctx, entry.plugin.requires);
+        }
         await entry.handler(ctx);
         consecutiveErrors = 0;
         const elapsed = Date.now() - start;

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/lib/vault/index.js

@@ -2,13 +2,33 @@ import { hashPassword, verifyPassword } from './password.js';
 import { generateUUID, generateNanoId } from './ids.js';
 import { encrypt, decrypt } from './encrypt.js';
 import { jwtEncode, jwtDecode } from './jwt.js';
+import {
+  decryptWithRotation,
+  deriveBytes,
+  deriveInfraSecret,
+  deriveInfraSecrets,
+  deriveVapidKeyPair,
+  encodeMasterSecret,
+  formatVaultKey,
+  normalizeMasterSecret,
+  validateVaultKey,
+} from './secrets.js';
 export {
+  decryptWithRotation,
   decrypt,
+  deriveBytes,
+  deriveInfraSecret,
+  deriveInfraSecrets,
+  deriveVapidKeyPair,
+  encodeMasterSecret,
   encrypt,
+  formatVaultKey,
   generateNanoId,
   generateUUID,
   hashPassword,
   jwtDecode,
   jwtEncode,
+  normalizeMasterSecret,
+  validateVaultKey,
   verifyPassword,
 };

package/server/lib/vault/secrets.js

@@ -0,0 +1,149 @@
+import { createECDH, hkdfSync, randomBytes } from 'node:crypto';
+
+const MASTER_VERSION = 'v1';
+const MASTER_BYTES = 32;
+const VAULT_KEY_BYTES = 32;
+const HKDF_SALT = 'arcway:infra-secrets:v1';
+
+const SECRET_NAMES = Object.freeze([
+  'session',
+  'plugin-vault',
+  'mcp-api',
+  'pty-api',
+  'pty-server-api',
+  'vapid',
+]);
+
+function base64Url(buffer) {
+  return Buffer.from(buffer).toString('base64url');
+}
+
+function encodeMasterSecret(key = randomBytes(MASTER_BYTES)) {
+  if (!Buffer.isBuffer(key) || key.length !== MASTER_BYTES) {
+    throw new Error(`Arcway master secret must be ${MASTER_BYTES} bytes`);
+  }
+  return `${MASTER_VERSION}:${key.toString('base64')}`;
+}
+
+function decodeVersionedSecret(value, label = 'Arcway master secret') {
+  const trimmed = String(value ?? '').trim();
+  const [version, encoded] = trimmed.split(':');
+  if (version !== MASTER_VERSION || !encoded || trimmed.split(':').length !== 2) {
+    throw new Error(
+      `${label} must use ${MASTER_VERSION}:<base64-32-byte-key> or a 32+ character string`,
+    );
+  }
+
+  const key = Buffer.from(encoded, 'base64');
+  if (key.length !== MASTER_BYTES || key.toString('base64') !== encoded) {
+    throw new Error(`${label} must decode to ${MASTER_BYTES} bytes`);
+  }
+  return key;
+}
+
+function normalizeMasterSecret(value, label = 'Arcway master secret') {
+  if (Buffer.isBuffer(value)) {
+    if (value.length < MASTER_BYTES)
+      throw new Error(`${label} must be at least ${MASTER_BYTES} bytes`);
+    return value;
+  }
+
+  if (typeof value !== 'string') {
+    throw new Error(`${label} must be a string or Buffer`);
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.startsWith(`${MASTER_VERSION}:`)) return decodeVersionedSecret(trimmed, label);
+  if (trimmed.length < MASTER_BYTES) {
+    throw new Error(`${label} must be at least ${MASTER_BYTES} characters`);
+  }
+  return Buffer.from(trimmed, 'utf8');
+}
+
+function deriveBytes(master, namespace, length = MASTER_BYTES) {
+  const key = normalizeMasterSecret(master);
+  return Buffer.from(hkdfSync('sha256', key, HKDF_SALT, `arcway:${namespace}`, length));
+}
+
+function formatVaultKey(bytes) {
+  const key = Buffer.from(bytes);
+  if (key.length !== VAULT_KEY_BYTES) {
+    throw new Error(`Vault key material must be ${VAULT_KEY_BYTES} bytes`);
+  }
+  return `${MASTER_VERSION}:${key.toString('base64')}`;
+}
+
+function validateVaultKey(value, label = 'plugin-vault secret') {
+  return formatVaultKey(decodeVersionedSecret(value, label));
+}
+
+function deriveVapidKeyPair(master) {
+  for (let i = 0; i < 32; i += 1) {
+    const privateKey = deriveBytes(master, `vapid:private:${i}`, 32);
+    try {
+      const ecdh = createECDH('prime256v1');
+      ecdh.setPrivateKey(privateKey);
+      return {
+        publicKey: base64Url(ecdh.getPublicKey(null, 'uncompressed')),
+        privateKey: base64Url(privateKey),
+      };
+    } catch {
+      // Try the next deterministic candidate.
+    }
+  }
+  throw new Error('Unable to derive a valid deterministic VAPID keypair');
+}
+
+function deriveInfraSecret(master, name) {
+  if (name === 'session') return base64Url(deriveBytes(master, name, 48));
+  if (name === 'plugin-vault') return formatVaultKey(deriveBytes(master, name, VAULT_KEY_BYTES));
+  if (name === 'mcp-api') return base64Url(deriveBytes(master, name, 48));
+  if (name === 'pty-api') return base64Url(deriveBytes(master, name, 48));
+  if (name === 'pty-server-api') return base64Url(deriveBytes(master, name, 48));
+  if (name === 'vapid') return deriveVapidKeyPair(master);
+  throw new Error(`Unknown Arcway infra secret namespace: ${name}`);
+}
+
+function deriveInfraSecrets(master) {
+  const values = {};
+  for (const name of SECRET_NAMES) {
+    values[name] = deriveInfraSecret(master, name);
+  }
+  return values;
+}
+
+function decryptWithRotation(ciphertext, { current, previous, decrypt, encrypt, onRotate } = {}) {
+  if (typeof decrypt !== 'function') throw new Error('decryptWithRotation requires decrypt');
+  if (typeof encrypt !== 'function') throw new Error('decryptWithRotation requires encrypt');
+  if (!current) throw new Error('decryptWithRotation requires current secret');
+
+  try {
+    return { plaintext: decrypt(ciphertext, current), rotated: false };
+  } catch (currentError) {
+    const previousValues = Array.isArray(previous)
+      ? previous.filter(Boolean)
+      : [previous].filter(Boolean);
+    for (const previousSecret of previousValues) {
+      try {
+        const plaintext = decrypt(ciphertext, previousSecret);
+        const rotatedCiphertext = encrypt(plaintext, current);
+        onRotate?.(rotatedCiphertext);
+        return { plaintext, rotated: true, rotatedCiphertext };
+      } catch {}
+    }
+    throw currentError;
+  }
+}
+
+export {
+  SECRET_NAMES,
+  decryptWithRotation,
+  deriveBytes,
+  deriveInfraSecret,
+  deriveInfraSecrets,
+  deriveVapidKeyPair,
+  encodeMasterSecret,
+  formatVaultKey,
+  normalizeMasterSecret,
+  validateVaultKey,
+};

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-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/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);
@@ -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>');
       }
     }
@@ -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/out-dir.js

@@ -1,6 +1,9 @@
 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');
@@ -8,4 +11,102 @@ function resolvePagesOutDir(config, rootDir, mode = 'production') {
   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,