veryfront 0.1.72 → 0.1.74

package/src/src/server/handlers/request/ssr/ssr.handler.ts

@@ -26,7 +26,11 @@ import { serverLogger } from "../../../../utils/index.js";
 import { endRequest, startRequest } from "../../../../utils/index.js";
 import { tryNotFoundFallback } from "./not-found-fallback.js";
 import { tryErrorPageFallback } from "./error-page-fallback.js";
-import { type SSRRenderResult, SSRService } from "../../../services/rendering/ssr.service.js";
+import {
+  type SSRRenderResult,
+  SSRService,
+  type SSRServiceLike,
+} from "../../../services/rendering/ssr.service.js";
 import { ErrorPages } from "../../../utils/error-html.js";
 import { buildSSRResponse } from "./ssr-response-builder.js";
 
@@ -62,7 +66,12 @@ export class SSRHandler extends BaseHandler {
     patterns: [{ pattern: /^(?!\/_).*/, method: ["GET", "HEAD"] }],
   };
 
-  private ssrService = new SSRService();
+  private ssrService: SSRServiceLike;
+
+  constructor(ssrService?: SSRServiceLike) {
+    super();
+    this.ssrService = ssrService ?? new SSRService();
+  }
 
   handle(req: dntShim.Request, ctx: HandlerContext): Promise<HandlerResult> {
     const url = new URL(req.url);

package/src/src/server/runtime-handler/adapter-factory.ts

@@ -15,7 +15,11 @@ import { isExtendedFSAdapter } from "../../platform/adapters/fs/wrapper.js";
 import { getConfig } from "../../config/loader.js";
 import type { VeryfrontConfig } from "../../config/index.js";
 import { timeAsync } from "./request-lifecycle.js";
-import { findLocalProjectPath, localAdapterCache } from "./local-project-discovery.js";
+import {
+  defaultDiscoveryCache,
+  findLocalProjectPath,
+  type ProjectDiscoveryCache,
+} from "./local-project-discovery.js";
 import type { ParsedDomain } from "../utils/domain-parser.js";
 
 const baseLogger = getBaseLogger("SERVER");
@@ -60,6 +64,8 @@ interface AdapterResolutionOptions {
   headerProjectPath: string | undefined;
   /** Whether running in proxy mode */
   isProxyMode: boolean;
+  /** Optional injectable cache (defaults to module-level singleton) */
+  cache?: ProjectDiscoveryCache;
 }
 
 /**
@@ -71,6 +77,8 @@ interface AdapterResolutionOptions {
 export async function resolveAdapter(
   opts: AdapterResolutionOptions,
 ): Promise<AdapterResolutionResult> {
+  const cache = opts.cache ?? defaultDiscoveryCache;
+
   let effectiveProjectDir = opts.projectDir;
   let effectiveAdapter = opts.adapter;
   let effectiveConfig = opts.config;
@@ -81,7 +89,7 @@ export async function resolveAdapter(
   const trustedHeaderProjectPath = opts.isProxyMode ? opts.headerProjectPath : undefined;
   const shouldCheckLocalPath = opts.projectSlug && (!opts.isProxyMode || trustedHeaderProjectPath);
   const localProjectPath = shouldCheckLocalPath
-    ? await findLocalProjectPath(opts.projectSlug!, opts.adapter, trustedHeaderProjectPath)
+    ? await findLocalProjectPath(opts.projectSlug!, opts.adapter, trustedHeaderProjectPath, cache)
     : undefined;
 
   const isLocalProject = !!localProjectPath;
@@ -95,16 +103,16 @@ export async function resolveAdapter(
     });
 
     // Get or create local adapter
-    if (!localAdapterCache.has(effectiveProjectDir)) {
+    if (!cache.adapters.has(effectiveProjectDir)) {
       const baseAdapter = await runtime.get();
-      localAdapterCache.set(effectiveProjectDir, baseAdapter);
+      cache.adapters.set(effectiveProjectDir, baseAdapter);
       logger.debug("Created local adapter for project", {
         projectSlug: opts.projectSlug,
         projectDir: effectiveProjectDir,
       });
     }
 
-    effectiveAdapter = localAdapterCache.get(effectiveProjectDir)!;
+    effectiveAdapter = cache.adapters.get(effectiveProjectDir)!;
 
     // Load project-specific config
     try {

package/src/src/server/runtime-handler/index.ts

@@ -21,6 +21,7 @@ import { getErrorMessage } from "../../errors/veryfront-error.js";
 import { UNKNOWN_ERROR } from "../../errors/error-registry.js";
 import { errorToRFC9457Response } from "../../errors/middleware/http-error-boundary.js";
 import { RouteRegistry } from "../../routing/registry/index.js";
+import type { Handler } from "../../types/index.js";
 import { SecurityConfigLoader } from "../../security/http/config.js";
 
 // Re-export is at the bottom of the file
@@ -114,6 +115,136 @@ const baseLogger = getBaseLogger("SERVER");
 
 const logger = baseLogger.component("runtime-handler");
 
+/** Handler names in registration order. */
+export const HANDLER_NAMES = [
+  "AuthHandler",
+  "CsrfHandler",
+  "HMRHandler",
+  "CorsHandler",
+  "HealthHandler",
+  "MetricsHandler",
+  "MemoryDebugHandler",
+  "ClientLogHandler",
+  "DevEndpointsHandler",
+  "StylesCSSHandler",
+  "DebugContextHandler",
+  "OpenAPIHandler",
+  "OpenAPIDocsHandler",
+  "InternalAgentsListHandler",
+  "AgentStreamHandler",
+  "AgentRunResumeHandler",
+  "AgentRunCancelHandler",
+  "ChannelInvokeHandler",
+  "DevDashboardHandler",
+  "ProjectsHandler",
+  "StudioBridgeModulesHandler",
+  "CSSHandler",
+  "DevFileHandler",
+  "SnippetHandler",
+  "StaticHandler",
+  "LibModulesHandler",
+  "RSCHandler",
+  "ModuleHandler",
+  "ApiHandlerWrapper",
+  "MarkdownPreviewHandler",
+  "SSRHandler",
+  "NotFoundHandler",
+] as const;
+
+/** Union of all registered handler names. */
+export type HandlerName = (typeof HANDLER_NAMES)[number];
+
+/**
+ * Dependencies for handler registry creation.
+ * All fields are optional — when omitted, the real handler implementation is used.
+ * This allows tests to inject mock handlers for specific slots.
+ */
+export interface HandlerDependencies {
+  /** Override any handler by its typed name. */
+  overrides?: Partial<Record<HandlerName, Handler>>;
+  /** When true, log handler registration details. */
+  debug?: boolean;
+}
+
+/** Factory for each handler. Only called when no override is provided (lazy instantiation). */
+const handlerFactories: Record<
+  HandlerName,
+  (projectDir: string, adapter: RuntimeAdapter) => Handler
+> = {
+  AuthHandler: () => new AuthHandler(),
+  CsrfHandler: () => new CsrfHandler(),
+  HMRHandler: () => new HMRHandler(),
+  CorsHandler: () => new CorsHandler(),
+  HealthHandler: () => new HealthHandler(),
+  MetricsHandler: () => new MetricsHandler(),
+  MemoryDebugHandler: () => new MemoryDebugHandler(),
+  ClientLogHandler: () => new ClientLogHandler(),
+  DevEndpointsHandler: () => new DevEndpointsHandler(),
+  StylesCSSHandler: () => new StylesCSSHandler(),
+  DebugContextHandler: () => new DebugContextHandler(),
+  OpenAPIHandler: () => new OpenAPIHandler(),
+  OpenAPIDocsHandler: () => new OpenAPIDocsHandler(),
+  InternalAgentsListHandler: () => new InternalAgentsListHandler(),
+  AgentStreamHandler: () => new AgentStreamHandler(),
+  AgentRunResumeHandler: () => new AgentRunResumeHandler(),
+  AgentRunCancelHandler: () => new AgentRunCancelHandler(),
+  ChannelInvokeHandler: () => new ChannelInvokeHandler(),
+  DevDashboardHandler: () => new DevDashboardHandler(),
+  ProjectsHandler: () => new ProjectsHandler(),
+  StudioBridgeModulesHandler: () => new StudioBridgeModulesHandler(),
+  CSSHandler: () => new CSSHandler(),
+  DevFileHandler: () => new DevFileHandler(),
+  SnippetHandler: () => new SnippetHandler(),
+  StaticHandler: () => new StaticHandler(),
+  LibModulesHandler: () => new LibModulesHandler(),
+  RSCHandler: () => new RSCHandler(),
+  ModuleHandler: () => new ModuleHandler(),
+  ApiHandlerWrapper: (projectDir, adapter) => new ApiHandlerWrapper(projectDir, adapter),
+  MarkdownPreviewHandler: () => new MarkdownPreviewHandler(),
+  SSRHandler: () => new SSRHandler(),
+  NotFoundHandler: () => new NotFoundHandler(),
+};
+
+/**
+ * Creates a RouteRegistry populated with the standard handler chain.
+ *
+ * Handlers are instantiated lazily — overridden slots skip construction
+ * of the default handler entirely.
+ *
+ * @param projectDir - Root project directory
+ * @param adapter - Runtime adapter for environment access
+ * @param deps - Optional dependency overrides for testing
+ * @returns Object containing the registry and the api handler (for initialization)
+ */
+export function createHandlerRegistry(
+  projectDir: string,
+  adapter: RuntimeAdapter,
+  deps: HandlerDependencies = {},
+): { registry: RouteRegistry; apiHandler: ApiHandlerWrapper } {
+  const registry = new RouteRegistry({
+    debug: deps.debug,
+    enableMetrics: true,
+  });
+
+  const overrides = deps.overrides ?? {};
+
+  // Create the ApiHandlerWrapper first — it's special because callers need
+  // the returned instance for initialization regardless of overrides.
+  const apiHandler = overrides.ApiHandlerWrapper
+    ? (overrides.ApiHandlerWrapper as ApiHandlerWrapper)
+    : new ApiHandlerWrapper(projectDir, adapter);
+
+  const handlers = HANDLER_NAMES.map((name) => {
+    if (name === "ApiHandlerWrapper") return apiHandler;
+    if (overrides[name]) return overrides[name]!;
+    return handlerFactories[name](projectDir, adapter);
+  });
+
+  registry.registerAll(handlers);
+
+  return { registry, apiHandler };
+}
+
 export interface RuntimeHandlerOptions {
   projectDir: string;
   /** When true, expose additional debug logging. */
@@ -188,48 +319,10 @@ export function createVeryfrontHandler(
     }
   })();
 
-  const registry = new RouteRegistry({
+  const { registry, apiHandler } = createHandlerRegistry(projectDir, adapter, {
     debug: opts.debug,
-    enableMetrics: true,
   });
 
-  const apiHandler = new ApiHandlerWrapper(projectDir, adapter);
-
-  registry.registerAll([
-    new AuthHandler(),
-    new CsrfHandler(),
-    new HMRHandler(),
-    new CorsHandler(),
-    new HealthHandler(),
-    new MetricsHandler(),
-    new MemoryDebugHandler(),
-    new ClientLogHandler(),
-    new DevEndpointsHandler(),
-    new StylesCSSHandler(),
-    new DebugContextHandler(),
-    new OpenAPIHandler(),
-    new OpenAPIDocsHandler(),
-    new InternalAgentsListHandler(),
-    new AgentStreamHandler(),
-    new AgentRunResumeHandler(),
-    new AgentRunCancelHandler(),
-    new ChannelInvokeHandler(),
-    new DevDashboardHandler(),
-    new ProjectsHandler(),
-    new StudioBridgeModulesHandler(),
-    new CSSHandler(),
-    new DevFileHandler(),
-    new SnippetHandler(),
-    new StaticHandler(),
-    new LibModulesHandler(),
-    new RSCHandler(),
-    new ModuleHandler(),
-    apiHandler,
-    new MarkdownPreviewHandler(),
-    new SSRHandler(),
-    new NotFoundHandler(),
-  ]);
-
   const isProxyMode = opts.config?.fs?.veryfront?.proxyMode === true;
 
   const readyPromise = isProxyMode ? Promise.resolve() : apiHandler.initialize().catch((error) => {

package/src/src/server/runtime-handler/local-project-discovery.ts

@@ -17,24 +17,56 @@ const baseLogger = getBaseLogger("SERVER");
 
 const logger = baseLogger.component("runtime-handler");
 
-/** Cache of local adapters by project directory */
-export const localAdapterCache = new LRUCache<string, RuntimeAdapter>({
-  maxEntries: 50,
-});
+/**
+ * Injectable cache container for project discovery state.
+ *
+ * Wraps both the project-path cache (slug → absolute path) and the
+ * adapter cache (project dir → RuntimeAdapter) so that callers — especially
+ * tests — can supply an isolated instance instead of sharing global state.
+ */
+export class ProjectDiscoveryCache {
+  /** Cache of discovered local project paths by slug */
+  readonly projects: LRUCache<string, string>;
+  /** Cache of local adapters by project directory */
+  readonly adapters: LRUCache<string, RuntimeAdapter>;
+
+  constructor(opts?: { maxProjects?: number; maxAdapters?: number }) {
+    this.projects = new LRUCache<string, string>({
+      maxEntries: opts?.maxProjects ?? 100,
+    });
+    this.adapters = new LRUCache<string, RuntimeAdapter>({
+      maxEntries: opts?.maxAdapters ?? 50,
+    });
+  }
 
-// Register cache for monitoring
-registerLRUCache("local-adapter-cache", localAdapterCache);
+  /** Clear both caches */
+  clear(): void {
+    this.projects.clear();
+    this.adapters.clear();
+  }
+}
 
-/** Standard directories to search for local projects */
-export const standardProjectDirs = ["data/projects", "projects"];
+/** Default module-level cache instance (backward-compatible singleton) */
+export const defaultDiscoveryCache = new ProjectDiscoveryCache();
 
-/** Cache of discovered local project paths by slug */
-export const localProjectCache = new LRUCache<string, string>({
-  maxEntries: 100,
-});
+// Register the default caches for monitoring
+registerLRUCache("local-project-cache", defaultDiscoveryCache.projects);
+registerLRUCache("local-adapter-cache", defaultDiscoveryCache.adapters);
 
-// Register cache for monitoring
-registerLRUCache("local-project-cache", localProjectCache);
+/**
+ * @deprecated Use `defaultDiscoveryCache.adapters` instead.
+ * Kept for backward compatibility with existing consumers.
+ */
+export const localAdapterCache = defaultDiscoveryCache.adapters;
+
+/**
+ * @deprecated Use `defaultDiscoveryCache.projects` instead.
+ * Kept for backward compatibility with existing consumers.
+ */
+export const localProjectCache = defaultDiscoveryCache.projects;
+
+/** Standard directories to search for local projects */
+export const standardProjectDirs = ["data/projects", "projects"];
 
 function isNotFoundError(error: unknown): boolean {
   if (!(error instanceof Error)) return false;
@@ -78,12 +110,14 @@ async function isValidLocalProjectPath(path: string, adapter: RuntimeAdapter): P
  * @param slug - The project slug to find
  * @param adapter - The runtime adapter to use for filesystem operations
  * @param headerPath - Optional path from x-project-path header (takes precedence)
+ * @param cache - Optional cache instance (defaults to module-level singleton)
  * @returns The absolute path to the project, or undefined if not found
  */
 export async function findLocalProjectPath(
   slug: string,
   adapter: RuntimeAdapter,
   headerPath?: string,
+  cache: ProjectDiscoveryCache = defaultDiscoveryCache,
 ): Promise<string | undefined> {
   if (headerPath) {
     try {
@@ -92,7 +126,7 @@ export async function findLocalProjectPath(
         const absolutePath = normalizedPath.startsWith("/")
           ? normalizedPath
           : `${cwd()}/${normalizedPath}`;
-        localProjectCache.set(slug, absolutePath);
+        cache.projects.set(slug, absolutePath);
         return absolutePath;
       }
       logger.warn("Ignoring invalid x-project-path override", {
@@ -108,7 +142,7 @@ export async function findLocalProjectPath(
     }
   }
 
-  const cached = localProjectCache.get(slug);
+  const cached = cache.projects.get(slug);
   if (cached) return cached;
 
   for (const dir of standardProjectDirs) {
@@ -118,7 +152,7 @@ export async function findLocalProjectPath(
       if (!await isValidLocalProjectPath(projectPath, adapter)) continue;
 
       const absolutePath = projectPath.startsWith("/") ? projectPath : `${cwd()}/${projectPath}`;
-      localProjectCache.set(slug, absolutePath);
+      cache.projects.set(slug, absolutePath);
       logger.debug("Discovered local project", { slug, path: absolutePath });
       return absolutePath;
     } catch (error) {

package/src/src/server/services/rendering/ssr.service.ts

@@ -15,7 +15,7 @@ import {
   startRenderSession,
 } from "../../../transforms/mdx/esm-module-loader/module-fetcher/index.js";
 import { getErrorCollector } from "../../../observability/error-collector.js";
-import { ErrorOverlay } from "../../dev-server/error-overlay/index.js";
+import { ErrorOverlay, parseErrorLocation } from "../../dev-server/error-overlay/index.js";
 import { ErrorPages } from "../../utils/error-html.js";
 import {
   HTTP_INTERNAL_SERVER_ERROR,
@@ -27,6 +27,32 @@ import type { CacheRepository } from "../../../repositories/types.js";
 
 const logger = serverLogger.component("ssr-service");
 
+/**
+ * Provides a renderer for a given handler context.
+ * Extracted to allow dependency injection in tests.
+ */
+export interface RendererProvider {
+  getRenderer(ctx: HandlerContext): Promise<RendererAdapter>;
+}
+
+/**
+ * Minimal interface for SSRService consumers (e.g., SSRHandler).
+ * Allows dependency injection and mocking in tests.
+ */
+export interface SSRServiceLike {
+  checkMemoryPressure(): MemoryStatus;
+  renderPage(ctx: HandlerContext, options: SSRRenderOptions): Promise<SSRRenderResult>;
+  createMemoryPressureResult(slug: string): SSRRenderResult;
+}
+
+/**
+ * Default RendererProvider that delegates to the real getRendererForProject.
+ */
+const defaultRendererProvider: RendererProvider = {
+  getRenderer: (ctx: HandlerContext) =>
+    timeAsync("renderer-init", () => getRendererForProject(ctx)),
+};
+
 export interface SSRRenderResult {
   status: number;
   html?: string;
@@ -59,11 +85,16 @@ export interface MemoryStatus {
   heapUsedPercent: number;
 }
 
-export class SSRService {
+export class SSRService implements SSRServiceLike {
   private readonly cacheRepo?: CacheRepository<string>;
+  private readonly rendererProvider: RendererProvider;
 
-  constructor(options?: { cacheRepo?: CacheRepository<string> }) {
+  constructor(options?: {
+    cacheRepo?: CacheRepository<string>;
+    rendererProvider?: RendererProvider;
+  }) {
     this.cacheRepo = options?.cacheRepo;
+    this.rendererProvider = options?.rendererProvider ?? defaultRendererProvider;
   }
 
   checkMemoryPressure(): MemoryStatus {
@@ -78,7 +109,7 @@ export class SSRService {
   }
 
   async getRenderer(ctx: HandlerContext): Promise<RendererAdapter> {
-    return timeAsync("renderer-init", () => getRendererForProject(ctx));
+    return this.rendererProvider.getRenderer(ctx);
   }
 
   async renderPage(ctx: HandlerContext, options: SSRRenderOptions): Promise<SSRRenderResult> {
@@ -240,9 +271,16 @@ export class SSRService {
         slug,
       });
 
+      const sourceFile = (errorObj as Error & { sourceFile?: string }).sourceFile;
+      const location = sourceFile ? parseErrorLocation(errorObj, sourceFile) : {};
       return {
         status: HTTP_INTERNAL_SERVER_ERROR,
-        html: ErrorOverlay.createHTML({ error: errorObj, type: "runtime" }),
+        html: ErrorOverlay.createHTML({
+          error: errorObj,
+          type: "runtime",
+          ...(sourceFile ? { file: sourceFile } : {}),
+          ...location,
+        }, ctx.projectSlug),
         isStreaming: false,
         cacheStrategy: "no-cache",
         error: errorObj,

package/src/src/server/shared/renderer/adapter.ts

@@ -64,11 +64,95 @@ export interface RendererAdapter {
   destroy(): Promise<void>;
 }
 
-let rendererInitPromise: Promise<Renderer> | null = null;
+/**
+ * Abstraction over renderer initialization, allowing tests to inject
+ * a mock renderer without pulling in the full rendering subsystem.
+ */
+export interface RendererInitializer {
+  initialize(options: RendererOptions): Promise<Renderer>;
+  isInitialized(): boolean;
+  get(): Renderer;
+  destroy(): Promise<void>;
+}
+
+/**
+ * Default initializer that delegates to the real shared renderer
+ * singleton from `#veryfront/rendering/renderer.ts`.
+ */
+const defaultInitializer: RendererInitializer = {
+  initialize: initializeRenderer,
+  isInitialized: isRendererInitialized,
+  get: getRenderer,
+  destroy: destroySharedRenderer,
+};
+
+let activeInitializer: RendererInitializer = defaultInitializer;
+let rendererInitState: { initializer: RendererInitializer; promise: Promise<Renderer> } | null =
+  null;
+
+function scheduleInitializerDestroy(
+  initializer: RendererInitializer,
+  pendingPromise?: Promise<unknown>,
+): void {
+  const destroy = async () => {
+    try {
+      await initializer.destroy();
+    } catch (error) {
+      logger.warn("Failed to destroy renderer initializer", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+
+  if (pendingPromise) {
+    void pendingPromise
+      .catch(() => undefined)
+      .then(destroy);
+    return;
+  }
+
+  if (!initializer.isInitialized()) return;
+  void destroy();
+}
+
+/**
+ * Replace the renderer initializer used by the adapter layer.
+ * Pass `undefined` to restore the default (real) initializer.
+ *
+ * Returns a disposer that restores the previous initializer — use in
+ * `afterEach` or with `using` to prevent test pollution:
+ *
+ * ```ts
+ * afterEach(() => setRendererInitializer(undefined));
+ * ```
+ *
+ * @internal Test-only — not part of the public API.
+ */
+export function setRendererInitializer(
+  initializer?: RendererInitializer,
+): void {
+  const nextInitializer = initializer ?? defaultInitializer;
+  const previous = activeInitializer;
+  const previousPendingPromise = rendererInitState?.initializer === previous
+    ? rendererInitState.promise
+    : undefined;
+
+  activeInitializer = nextInitializer;
+
+  if (rendererInitState?.initializer !== activeInitializer) {
+    rendererInitState = null;
+  }
+
+  if (previous !== activeInitializer) {
+    scheduleInitializerDestroy(previous, previousPendingPromise);
+  }
+}
 
 async function getOrInitRenderer(): Promise<Renderer> {
-  if (isRendererInitialized()) return getRenderer();
-  if (rendererInitPromise) return rendererInitPromise;
+  if (activeInitializer.isInitialized()) return activeInitializer.get();
+  if (rendererInitState?.initializer === activeInitializer) {
+    return rendererInitState.promise;
+  }
 
   const isProxyMode = getEnvBoolean("PROXY_MODE", false, {
     trueValues: ["1"],
@@ -99,12 +183,19 @@ async function getOrInitRenderer(): Promise<Renderer> {
     cacheType: useApiCache ? "api-distributed" : "memory",
   });
 
-  rendererInitPromise = initializeRenderer(options);
+  const initializer = activeInitializer;
+  const initPromise = initializer.initialize(options);
+  rendererInitState = {
+    initializer,
+    promise: initPromise,
+  };
 
   try {
-    return await rendererInitPromise;
+    return await initPromise;
   } finally {
-    rendererInitPromise = null;
+    if (rendererInitState?.promise === initPromise) {
+      rendererInitState = null;
+    }
   }
 }
 
@@ -308,6 +399,14 @@ export async function getRendererForProject(ctx: HandlerContext): Promise<Render
 }
 
 export async function destroyRendererAdapter(): Promise<void> {
-  await destroySharedRenderer();
-  rendererInitPromise = null;
+  const pendingPromise = rendererInitState?.initializer === activeInitializer
+    ? rendererInitState.promise
+    : undefined;
+  rendererInitState = null;
+
+  if (pendingPromise) {
+    await pendingPromise.catch(() => undefined);
+  }
+
+  await activeInitializer.destroy();
 }

package/src/src/server/shared/renderer/index.ts

@@ -4,5 +4,11 @@
  * @module server/shared/renderer
  */
 
-export { destroyRendererAdapter, getRendererForProject, type RendererAdapter } from "./adapter.js";
+export {
+  destroyRendererAdapter,
+  getRendererForProject,
+  type RendererAdapter,
+  type RendererInitializer,
+  setRendererInitializer,
+} from "./adapter.js";
 export { shouldRejectDueToMemory } from "./memory/pressure.js";