arcway 0.1.15 → 0.1.17

package/client/page-loader.js

@@ -1,3 +1,5 @@
+import { compileRoutePattern, extractRouteParams } from './route-pattern.js';
+
 const moduleCache = new Map();
 const patternCache = new Map();
 
@@ -34,43 +36,11 @@ function readClientManifest() {
   }
 }
 
-function compilePattern(pattern) {
-  const paramNames = [];
-  let catchAllParam;
-
-  const regexStr = pattern.replace(
-    /\/:([^/]+)|\/\*(\w+)\?|\/\*(\w+)/g,
-    (match, singleParam, optCatchAll, reqCatchAll) => {
-      if (singleParam) {
-        paramNames.push(singleParam);
-        return '/([^/]+)';
-      }
-      if (optCatchAll) {
-        paramNames.push(optCatchAll);
-        catchAllParam = optCatchAll;
-        return '(?:/(.+))?';
-      }
-      if (reqCatchAll) {
-        paramNames.push(reqCatchAll);
-        catchAllParam = reqCatchAll;
-        return '/(.+)';
-      }
-      return match;
-    },
-  );
-
-  return {
-    regex: new RegExp(`^${regexStr}\\/?$`),
-    paramNames,
-    catchAllParam,
-  };
-}
-
 function matchClientRoute(manifest, pathname) {
   for (const route of manifest.routes) {
     let compiled = patternCache.get(route.pattern);
     if (!compiled) {
-      compiled = compilePattern(route.pattern);
+      compiled = compileRoutePattern(route.pattern);
       patternCache.set(route.pattern, compiled);
     }
     const { regex, paramNames, catchAllParam } = compiled;
@@ -78,20 +48,8 @@ function matchClientRoute(manifest, pathname) {
     const match = regex.exec(pathname);
     if (!match) continue;
 
-    const params = {};
-    try {
-      for (let i = 0; i < paramNames.length; i++) {
-        const name = paramNames[i];
-        const raw = match[i + 1];
-        if (name === catchAll) {
-          params[name] = raw ? raw.split('/').map(decodeURIComponent) : [];
-        } else {
-          params[name] = decodeURIComponent(raw);
-        }
-      }
-    } catch {
-      continue;
-    }
+    const params = extractRouteParams(match, paramNames, catchAll);
+    if (!params) continue;
 
     return { route, params };
   }
@@ -146,7 +104,6 @@ async function loadPage(manifest, pathname) {
 }
 
 export {
-  compilePattern,
   loadLoadingComponents,
   loadPage,
   matchClientRoute,

package/client/route-pattern.js

@@ -0,0 +1,48 @@
+function compileRoutePattern(pattern) {
+  const paramNames = [];
+  let catchAllParam;
+  let isOptionalCatchAll = false;
+  const regexStr = pattern.replace(
+    /\/:([^/]+)|\/\*(\w+)\?|\/\*(\w+)/g,
+    (match, singleParam, optCatchAll, reqCatchAll) => {
+      if (singleParam) {
+        paramNames.push(singleParam);
+        return '/([^/]+)';
+      }
+      if (optCatchAll) {
+        paramNames.push(optCatchAll);
+        catchAllParam = optCatchAll;
+        isOptionalCatchAll = true;
+        return '(?:/(.+))?';
+      }
+      if (reqCatchAll) {
+        paramNames.push(reqCatchAll);
+        catchAllParam = reqCatchAll;
+        return '/(.+)';
+      }
+      return match;
+    },
+  );
+  const regex = new RegExp(`^${regexStr}/?$`);
+  return { regex, paramNames, catchAllParam, isOptionalCatchAll };
+}
+
+function extractRouteParams(match, paramNames, catchAllParam) {
+  const params = {};
+  try {
+    for (let i = 0; i < paramNames.length; i++) {
+      const name = paramNames[i];
+      const raw = match[i + 1];
+      if (name === catchAllParam) {
+        params[name] = raw ? raw.split('/').map(decodeURIComponent) : [];
+      } else {
+        params[name] = decodeURIComponent(raw);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return params;
+}
+
+export { compileRoutePattern, extractRouteParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcway",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "A convention-based framework for building modular monoliths with strict domain boundaries.",
   "license": "MIT",
   "type": "module",
@@ -96,7 +96,6 @@
     "swr": "^2.3.3",
     "tailwind-merge": "^3.4.1",
     "tailwindcss": "^4.1.18",
-    "tailwindcss-animate": "^1.0.7",
     "vaul": "^1.1.2",
     "ws": "^8.19.0",
     "zod": "^3.24.0"
@@ -114,10 +113,8 @@
     }
   },
   "devDependencies": {
-    "@chromatic-com/storybook": "^5.0.1",
     "@storybook/addon-a11y": "^10.2.8",
     "@storybook/addon-docs": "^10.2.8",
-    "@storybook/addon-onboarding": "^10.2.8",
     "@storybook/addon-vitest": "^10.2.8",
     "@storybook/react-vite": "^10.2.8",
     "@tailwindcss/vite": "^4.1.18",

package/server/docs/openapi.js

@@ -50,6 +50,89 @@ function buildQueryParameters(route) {
     return [];
   }
 }
+function buildOperationId(method, openApiPath) {
+  const path = openApiPath.replace(/[{}\/]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
+  return `${method}_${path}`;
+}
+
+function tryConvertSchema(schema) {
+  if (!schema) return undefined;
+  try {
+    return typeToOpenAPISchema(schema);
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveTags(route) {
+  const tags = route.config.meta?.tags;
+  if (tags && tags.length > 0) return tags;
+  return [route.pattern.split('/')[1] || 'default'];
+}
+
+function buildRequestBody(bodySchema) {
+  const converted = tryConvertSchema(bodySchema);
+  if (!converted) return undefined;
+  return {
+    required: true,
+    content: { 'application/json': { schema: converted } },
+  };
+}
+
+const VALIDATION_ERROR_RESPONSE = {
+  description: 'Validation error',
+  content: {
+    'application/json': {
+      schema: {
+        type: 'object',
+        properties: {
+          error: {
+            type: 'object',
+            properties: {
+              code: { type: 'string' },
+              message: { type: 'string' },
+              details: {},
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+const DEFAULT_SUCCESS_SCHEMA = { type: 'object', properties: { data: {} } };
+
+function buildResponses(routeSchema) {
+  const successSchema = tryConvertSchema(routeSchema?.response) ?? DEFAULT_SUCCESS_SCHEMA;
+  const responses = {
+    200: {
+      description: 'Successful response',
+      content: { 'application/json': { schema: successSchema } },
+    },
+  };
+  if (routeSchema?.body || routeSchema?.query) {
+    responses[400] = VALIDATION_ERROR_RESPONSE;
+  }
+  return responses;
+}
+
+function buildOperation(route, method, openApiPath) {
+  const operation = { operationId: buildOperationId(method, openApiPath) };
+  const meta = route.config.meta;
+  if (meta?.summary) operation.summary = meta.summary;
+  if (meta?.description) operation.description = meta.description;
+  operation.tags = resolveTags(route);
+
+  const parameters = [...buildPathParameters(route), ...buildQueryParameters(route)];
+  if (parameters.length > 0) operation.parameters = parameters;
+
+  const requestBody = buildRequestBody(route.config.schema?.body);
+  if (requestBody) operation.requestBody = requestBody;
+
+  operation.responses = buildResponses(route.config.schema);
+  return operation;
+}
+
 function generateOpenAPISpec(routes, info) {
   const spec = {
     openapi: '3.0.3',
@@ -63,90 +146,8 @@ function generateOpenAPISpec(routes, info) {
   for (const route of routes) {
     const openApiPath = toOpenAPIPath(route.pattern);
     const method = route.method.toLowerCase();
-    if (!spec.paths[openApiPath]) {
-      spec.paths[openApiPath] = {};
-    }
-    const operation = {
-      operationId: `${method}_${openApiPath
-        .replace(/[{}\/]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, '')}`,
-    };
-    const meta = route.config.meta;
-    if (meta?.summary) operation.summary = meta.summary;
-    if (meta?.description) operation.description = meta.description;
-    if (meta?.tags && meta.tags.length > 0) {
-      operation.tags = meta.tags;
-    } else {
-      const firstSegment = route.pattern.split('/')[1] || 'default';
-      operation.tags = [firstSegment];
-    }
-    const parameters = [...buildPathParameters(route), ...buildQueryParameters(route)];
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (route.config.schema?.body) {
-      try {
-        const bodySchema = typeToOpenAPISchema(route.config.schema.body);
-        operation.requestBody = {
-          required: true,
-          content: {
-            'application/json': {
-              schema: bodySchema,
-            },
-          },
-        };
-      } catch {}
-    }
-    const responseSchema = route.config.schema?.response
-      ? (() => {
-          try {
-            return typeToOpenAPISchema(route.config.schema.response);
-          } catch {
-            return void 0;
-          }
-        })()
-      : void 0;
-    operation.responses = {
-      200: {
-        description: 'Successful response',
-        content: {
-          'application/json': {
-            schema: responseSchema ?? {
-              type: 'object',
-              properties: {
-                data: {},
-              },
-            },
-          },
-        },
-      },
-      ...(route.config.schema?.body || route.config.schema?.query
-        ? {
-            400: {
-              description: 'Validation error',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      error: {
-                        type: 'object',
-                        properties: {
-                          code: { type: 'string' },
-                          message: { type: 'string' },
-                          details: {},
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          }
-        : {}),
-    };
-    spec.paths[openApiPath][method] = operation;
+    if (!spec.paths[openApiPath]) spec.paths[openApiPath] = {};
+    spec.paths[openApiPath][method] = buildOperation(route, method, openApiPath);
   }
   return spec;
 }

package/server/logger/index.js

@@ -22,6 +22,23 @@ function wrapPino(p) {
   };
 }
 
+const QUERY_FILTERS = {
+  level: (v) => (e) => e.level === v,
+  logger: (v) => (e) => e.logger === v,
+  requestId: (v) => (e) => e.data?.requestId === v,
+  message: (v) => (e) => e.message === v,
+  method: (v) => (e) => e.data?.method === v.toUpperCase(),
+  path: (v) => (e) => e.data?.path?.includes(v),
+  status: (v) => (e) => e.data?.status === v,
+  minDurationMs: (v) => (e) => e.data?.durationMs >= v,
+  eventName: (v) => (e) =>
+    e.data?.eventName === v || e.data?.eventName?.includes(v),
+  since: (v) => {
+    const sinceTs = new Date(v).getTime();
+    return (e) => new Date(e.timestamp).getTime() >= sinceTs;
+  },
+};
+
 class Logger {
   _base;
   _ring;
@@ -89,22 +106,13 @@ class Logger {
   query(filters) {
     if (!this._ring) return [];
     let entries = this._ring.toArray();
-    if (filters?.level) entries = entries.filter((e) => e.level === filters.level);
-    if (filters?.logger) entries = entries.filter((e) => e.logger === filters.logger);
-    if (filters?.requestId) entries = entries.filter((e) => e.data?.requestId === filters.requestId);
-    if (filters?.message) entries = entries.filter((e) => e.message === filters.message);
-    if (filters?.method) entries = entries.filter((e) => e.data?.method === filters.method.toUpperCase());
-    if (filters?.path) entries = entries.filter((e) => e.data?.path?.includes(filters.path));
-    if (filters?.status) entries = entries.filter((e) => e.data?.status === filters.status);
-    if (filters?.minDurationMs) entries = entries.filter((e) => e.data?.durationMs >= filters.minDurationMs);
-    if (filters?.eventName) {
-      entries = entries.filter((e) => e.data?.eventName === filters.eventName || e.data?.eventName?.includes(filters.eventName));
-    }
-    if (filters?.since) {
-      const sinceTs = new Date(filters.since).getTime();
-      entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceTs);
+    if (!filters) return entries;
+    for (const [key, makePredicate] of Object.entries(QUERY_FILTERS)) {
+      const value = filters[key];
+      if (value === undefined || value === null || value === '' || value === false) continue;
+      entries = entries.filter(makePredicate(value));
     }
-    if (filters?.limit && filters.limit > 0) entries = entries.slice(-filters.limit);
+    if (filters.limit && filters.limit > 0) entries = entries.slice(-filters.limit);
     return entries;
   }
 

package/server/pages/build-cache.js

@@ -91,6 +91,18 @@ async function cpAtomic(src, dst) {
   }
 }
 
+// Best-effort LRU timestamp bump. File mtime is what enforceCacheBudget orders
+// by, so this is how we record "recently used" for cache hits. Swallow errors —
+// a concurrent evictor may have removed the file already; that's fine.
+async function touchMeta(metaPath) {
+  const now = new Date();
+  try {
+    await fs.utimes(metaPath, now, now);
+  } catch {
+    // Ignore: entry may have been evicted concurrently.
+  }
+}
+
 async function lookupBundle({ rootDir, entryPath, configHash, kind }) {
   const bucket = bucketDir(rootDir, kind);
   const key = entryKey(entryPath);
@@ -113,6 +125,7 @@ async function lookupBundle({ rootDir, entryPath, configHash, kind }) {
   } catch {
     return { hit: false, key, bucket, metaPath, jsPath, mapPath };
   }
+  await touchMeta(metaPath);
   return { hit: true, key, bucket, metaPath, jsPath, mapPath };
 }
 
@@ -194,10 +207,26 @@ async function buildWithCache({
   return { cacheHit: false, metafile: result.metafile };
 }
 
+// Canonical, order-independent hash of a virtualInputs list so stored/current
+// sets can be compared without worrying about caller ordering.
+function hashVirtualInputs(virtualInputs) {
+  if (!virtualInputs || virtualInputs.length === 0) return '';
+  const sorted = [...virtualInputs]
+    .map((v) => ({ name: v.name, digest: v.digest }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  return sha256(JSON.stringify(sorted));
+}
+
 // Multi-file cache for bundles with several output files (client build with
 // code-splitting). Each cache entry lives under <bucket>/<coarseKey>/ and the
 // index is a sidecar <bucket>/<coarseKey>.meta.json.
-async function lookupMultiFileCache({ rootDir, kind, coarseKey }) {
+//
+// `virtualInputs` (optional) are caller-computed digests that can't be
+// represented as a file path — e.g. the set of class-name tokens extracted
+// from a source tree. Each entry is `{ name, digest }`. The caller must
+// re-compute and pass current values on every lookup; the stored and current
+// digest sets must match exactly for a hit.
+async function lookupMultiFileCache({ rootDir, kind, coarseKey, virtualInputs }) {
   const bucket = bucketDir(rootDir, kind);
   const metaPath = path.join(bucket, `${coarseKey}.meta.json`);
   const cacheDir = path.join(bucket, coarseKey);
@@ -207,6 +236,14 @@ async function lookupMultiFileCache({ rootDir, kind, coarseKey }) {
   if (currentHash === null || currentHash !== meta.inputsHash) {
     return { hit: false, bucket, cacheDir, metaPath };
   }
+  // Compare virtual-input digest sets. If the stored entry has virtualInputs
+  // but the caller omitted them, treat as a miss — a silent hit would serve
+  // stale output for whatever derived state the virtual digest tracks.
+  const storedVirtualHash = meta.virtualInputsHash ?? '';
+  const currentVirtualHash = hashVirtualInputs(virtualInputs);
+  if (storedVirtualHash !== currentVirtualHash) {
+    return { hit: false, bucket, cacheDir, metaPath };
+  }
   // Sanity-check every recorded output file still exists in the cache dir.
   for (const rel of meta.outputs) {
     try {
@@ -215,6 +252,7 @@ async function lookupMultiFileCache({ rootDir, kind, coarseKey }) {
       return { hit: false, bucket, cacheDir, metaPath };
     }
   }
+  await touchMeta(metaPath);
   return { hit: true, bucket, cacheDir, metaPath, meta };
 }
 
@@ -236,6 +274,7 @@ async function storeMultiFileCache({
   destDir,
   outputs,
   inputs,
+  virtualInputs,
   metadata,
 }) {
   const cacheDir = path.join(bucket, coarseKey);
@@ -250,25 +289,224 @@ async function storeMultiFileCache({
     }),
   );
   const inputsHash = await hashInputs(inputs);
+  const virtualInputsHash = hashVirtualInputs(virtualInputs);
   const metaPath = path.join(bucket, `${coarseKey}.meta.json`);
   await writeJsonAtomic(metaPath, {
     inputs,
     inputsHash,
+    virtualInputs: virtualInputs ?? [],
+    virtualInputsHash,
     outputs,
     metadata,
     mtime: Date.now(),
   });
 }
 
+// Default cap for the on-disk cache. Override with ARCWAY_PAGES_CACHE_MAX_BYTES
+// (bytes as an integer). Anything over the cap is LRU-evicted after each store.
+const DEFAULT_CACHE_MAX_BYTES = 500 * 1024 * 1024;
+
+// Newly-written entries are protected from eviction for this many milliseconds
+// to avoid racing with in-flight stores from sibling forks. 5s comfortably
+// exceeds a typical per-entry store (cpAtomic + writeJsonAtomic).
+const DEFAULT_CACHE_GRACE_PERIOD_MS = 5000;
+
+function cacheMaxBytes() {
+  const raw = Number(process.env.ARCWAY_PAGES_CACHE_MAX_BYTES);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CACHE_MAX_BYTES;
+}
+
+async function statOrNull(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch {
+    return null;
+  }
+}
+
+// Recursively measure a directory's total size and the most-recent mtime of any
+// file/subdir inside it. Used for multi-file cache entries whose body lives in a
+// sibling dir. Returns {size: 0, mtime: 0} when the dir is missing.
+async function measureDir(dir) {
+  let size = 0;
+  let mtime = 0;
+  let items;
+  try {
+    items = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return { size, mtime };
+  }
+  for (const item of items) {
+    const abs = path.join(dir, item.name);
+    if (item.isDirectory()) {
+      const sub = await measureDir(abs);
+      size += sub.size;
+      if (sub.mtime > mtime) mtime = sub.mtime;
+    } else {
+      const s = await statOrNull(abs);
+      if (s) {
+        size += s.size;
+        if (s.mtimeMs > mtime) mtime = s.mtimeMs;
+      }
+    }
+  }
+  return { size, mtime };
+}
+
+// Enumerate every cache entry across all kinds. Each entry is identified by its
+// sidecar `<key>.meta.json` file. Single-file entries have an accompanying
+// `<key>.js` (+ optional `.js.map`); multi-file entries have a `<coarseKey>/`
+// dir. We collect paths for both shapes so removal is unconditional.
+async function collectCacheEntries(rootDir) {
+  const root = cacheRoot(rootDir);
+  let kindDirs;
+  try {
+    kindDirs = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const kindEnt of kindDirs) {
+    if (!kindEnt.isDirectory()) continue;
+    const bucket = path.join(root, kindEnt.name);
+    let files;
+    try {
+      files = await fs.readdir(bucket);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith('.meta.json')) continue;
+      const baseKey = file.slice(0, -'.meta.json'.length);
+      const metaPath = path.join(bucket, file);
+      const jsPath = path.join(bucket, `${baseKey}.js`);
+      const mapPath = path.join(bucket, `${baseKey}.js.map`);
+      const dirPath = path.join(bucket, baseKey);
+
+      const metaStat = await statOrNull(metaPath);
+      if (!metaStat) continue;
+      const jsStat = await statOrNull(jsPath);
+      const mapStat = await statOrNull(mapPath);
+      const dirInfo = await measureDir(dirPath);
+
+      const size = metaStat.size + (jsStat?.size ?? 0) + (mapStat?.size ?? 0) + dirInfo.size;
+      // Use the most recent mtime across meta + dir contents. A concurrent
+      // multi-file store rewrites `.meta.json` last but populates the dir
+      // first, so dir mtime can be newer than meta mtime during a store.
+      const mtime = Math.max(metaStat.mtimeMs, dirInfo.mtime);
+      entries.push({ metaPath, jsPath, mapPath, dirPath, size, mtime });
+    }
+  }
+  return entries;
+}
+
+async function removeCacheEntry(entry) {
+  await Promise.allSettled([
+    fs.rm(entry.metaPath, { force: true }),
+    fs.rm(entry.jsPath, { force: true }),
+    fs.rm(entry.mapPath, { force: true }),
+    fs.rm(entry.dirPath, { recursive: true, force: true }),
+  ]);
+}
+
+// Enforce a byte-budget over the on-disk cache. Oldest (by filesystem mtime)
+// entries are evicted first; entries whose mtime is within `gracePeriodMs` of
+// `now` are protected so an in-flight concurrent store isn't yanked out from
+// under a sibling fork. Lock-free and idempotent: multiple forks may run this
+// concurrently and at worst slightly over-evict, which self-corrects on the
+// next cold build.
+async function enforceCacheBudget({
+  rootDir,
+  maxBytes = cacheMaxBytes(),
+  gracePeriodMs = DEFAULT_CACHE_GRACE_PERIOD_MS,
+  now = Date.now(),
+} = {}) {
+  const entries = await collectCacheEntries(rootDir);
+  const totalSize = entries.reduce((s, e) => s + e.size, 0);
+  if (totalSize <= maxBytes) {
+    return { evicted: 0, kept: entries.length, bytesFreed: 0, bytesRemaining: totalSize };
+  }
+
+  const candidates = entries
+    .filter((e) => now - e.mtime >= gracePeriodMs)
+    .sort((a, b) => a.mtime - b.mtime);
+
+  let remaining = totalSize;
+  let freed = 0;
+  let evicted = 0;
+  for (const cand of candidates) {
+    if (remaining <= maxBytes) break;
+    await removeCacheEntry(cand);
+    remaining -= cand.size;
+    freed += cand.size;
+    evicted += 1;
+  }
+  return {
+    evicted,
+    kept: entries.length - evicted,
+    bytesFreed: freed,
+    bytesRemaining: remaining,
+  };
+}
+
+// Walk every cache entry in <rootDir>/node_modules/.cache/arcway-pages/<kind>
+// and drop any whose recorded inputs no longer hash to the stored value (or
+// whose inputs are gone). Used by tests that intentionally mutate fixture
+// sources to keep cross-fork cache state consistent. Best-effort: missing
+// bucket → returns {removed: 0, kept: 0}; individual unlink failures are
+// swallowed since a concurrent worker may already be removing the same entry.
+async function pruneStaleCache({ rootDir, kind }) {
+  const bucket = bucketDir(rootDir, kind);
+  let entries;
+  try {
+    entries = await fs.readdir(bucket);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { removed: 0, kept: 0 };
+    throw err;
+  }
+
+  const metaFiles = entries.filter((f) => f.endsWith('.meta.json'));
+  let removed = 0;
+  let kept = 0;
+
+  for (const metaFile of metaFiles) {
+    const metaPath = path.join(bucket, metaFile);
+    const meta = await readJson(metaPath);
+    const stale =
+      !meta ||
+      !Array.isArray(meta.inputs) ||
+      (await hashInputs(meta.inputs)) !== meta.inputsHash;
+
+    if (!stale) {
+      kept += 1;
+      continue;
+    }
+
+    const baseKey = metaFile.slice(0, -'.meta.json'.length);
+    await Promise.allSettled([
+      fs.rm(metaPath, { force: true }),
+      fs.rm(path.join(bucket, `${baseKey}.js`), { force: true }),
+      fs.rm(path.join(bucket, `${baseKey}.js.map`), { force: true }),
+      fs.rm(path.join(bucket, baseKey), { recursive: true, force: true }),
+    ]);
+    removed += 1;
+  }
+
+  return { removed, kept };
+}
+
 export {
   buildWithCache,
   computeConfigHash,
   cacheRoot,
+  DEFAULT_CACHE_MAX_BYTES,
+  enforceCacheBudget,
   entryKey,
   ESBUILD_VERSION,
   sha256,
   hashInputs,
   lookupMultiFileCache,
+  pruneStaleCache,
   restoreMultiFileCache,
   storeMultiFileCache,
 };