veryfront 0.1.215 → 0.1.217

package/src/src/rendering/orchestrator/pipeline-helpers.ts

@@ -0,0 +1,35 @@
+import type { LayoutItem } from "../../types/index.js";
+import { extractRelativePath as extractRelativePathShared } from "../../utils/route-path-utils.js";
+
+const RENDERED_CSS_HASH_RE = /href="\/_vf\/css\/([a-z0-9-]{1,16})\.css"/i;
+
+export function extractRenderedCssHash(html: string): string | undefined {
+  return html.match(RENDERED_CSS_HASH_RE)?.[1];
+}
+
+export function serializeLayouts(
+  nestedLayouts: LayoutItem[],
+  projectDir: string,
+): Array<{ kind: LayoutItem["kind"]; path: string }> {
+  return nestedLayouts
+    .filter((layout: LayoutItem) => layout.componentPath || layout.path)
+    .map((layout: LayoutItem) => ({
+      kind: layout.kind,
+      path: extractRelativePathShared(
+        layout.componentPath || layout.path || "",
+        projectDir,
+      ),
+    }));
+}
+
+export function serializeLayoutProps(
+  layoutProps: Map<string, Record<string, unknown>>,
+): Record<string, Record<string, unknown>> {
+  const serialized: Record<string, Record<string, unknown>> = {};
+
+  for (const [layoutId, props] of layoutProps.entries()) {
+    serialized[layoutId] = props;
+  }
+
+  return serialized;
+}

package/src/src/rendering/orchestrator/pipeline.ts

@@ -26,6 +26,11 @@ import {
   extractRelativePath as extractRelativePathShared,
   extractRouteParams as extractRouteParamsShared,
 } from "../../utils/route-path-utils.js";
+import {
+  extractRenderedCssHash,
+  serializeLayoutProps,
+  serializeLayouts,
+} from "./pipeline-helpers.js";
 import { join } from "../../platform/compat/path/index.js";
 import type { MdxBundle, PageBundle } from "../../types/index.js";
 import type { RuntimeAdapter } from "../../platform/adapters/base.js";
@@ -77,8 +82,6 @@ import {
 const renderPageLog = logger.component("render-page");
 const renderPipelineLog = logger.component("render-pipeline");
 const resolvePageDataLog = logger.component("resolve-page-data");
-const RENDERED_CSS_HASH_RE = /href="\/_vf\/css\/([a-z0-9-]{1,16})\.css"/i;
-
 // Re-export test helper for backward compatibility
 export { __injectCssCacheForTests } from "./css-cache.js";
 
@@ -159,15 +162,11 @@ export class RenderPipeline {
     return loadModule(filePath, this.moduleLoaderConfig);
   }
 
-  private extractRenderedCssHash(html: string): string | undefined {
-    return html.match(RENDERED_CSS_HASH_RE)?.[1];
-  }
-
   private async resolveCssFromRenderedHtml(
     html: string,
     projectSlug: string | undefined,
   ): Promise<string | undefined> {
-    const cssHash = this.extractRenderedCssHash(html);
+    const cssHash = extractRenderedCssHash(html);
     if (!cssHash) return undefined;
 
     const cachedCss = await getCSSByHashAsync(cssHash);
@@ -664,7 +663,7 @@ export class RenderPipeline {
 
     const pageProps: Record<string, unknown> = dataResolution.pageProps;
     const params = dataResolution.params;
-    const layoutProps = this.serializeLayoutProps(dataResolution.layoutProps);
+    const layoutProps = serializeLayoutProps(dataResolution.layoutProps);
 
     const { frontmatter, headings } = await this.extractMdxMetadata(
       pageType,
@@ -674,7 +673,7 @@ export class RenderPipeline {
       params,
     );
 
-    const layouts = this.serializeLayouts(layoutResult.nestedLayouts);
+    const layouts = serializeLayouts(layoutResult.nestedLayouts, this.config.projectDir);
 
     const providers: string[] = [];
 
@@ -756,32 +755,6 @@ export class RenderPipeline {
     }
   }
 
-  private serializeLayouts(
-    nestedLayouts: LayoutItem[],
-  ): Array<{ kind: LayoutItem["kind"]; path: string }> {
-    return nestedLayouts
-      .filter((layout: LayoutItem) => layout.componentPath || layout.path)
-      .map((layout: LayoutItem) => ({
-        kind: layout.kind,
-        path: extractRelativePathShared(
-          layout.componentPath || layout.path || "",
-          this.config.projectDir,
-        ),
-      }));
-  }
-
-  private serializeLayoutProps(
-    layoutProps: Map<string, Record<string, unknown>>,
-  ): Record<string, Record<string, unknown>> {
-    const serialized: Record<string, Record<string, unknown>> = {};
-
-    for (const [layoutId, props] of layoutProps.entries()) {
-      serialized[layoutId] = props;
-    }
-
-    return serialized;
-  }
-
   private async resolveAppPath(): Promise<string | undefined> {
     for (const ext of LAYOUT_EXTENSIONS) {
       const candidatePath = join(this.config.projectDir, `components/app.${ext}`);

package/src/src/routing/api/module-loader/loader-helpers.ts

@@ -0,0 +1,68 @@
+import * as pathHelper from "../../../platform/compat/path/index.js";
+import { createError, toError } from "../../../errors/veryfront-error.js";
+import { isWithinDirectory } from "../../../security/path-validation.js";
+
+const EXT_TO_LOADER: Record<string, "tsx" | "jsx" | "ts" | "js" | "json"> = {
+  tsx: "tsx",
+  jsx: "jsx",
+  ts: "ts",
+  json: "json",
+};
+
+export const FILE_EXTENSIONS: string[] = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
+
+/**
+ * Validates that a module path is contained within the project directory.
+ * Prevents path traversal attacks that could load arbitrary files from the host.
+ */
+export function validateModulePath(modulePath: string, projectDir: string): void {
+  const resolved = pathHelper.resolve(modulePath);
+  const resolvedProject = pathHelper.resolve(projectDir);
+
+  if (!isWithinDirectory(resolvedProject, resolved)) {
+    throw toError(
+      createError({
+        type: "api",
+        message: `[API] module path escapes project directory: ${modulePath}`,
+      }),
+    );
+  }
+}
+
+export function resolveExportEntry(entry: unknown): string | undefined {
+  if (typeof entry === "string") return entry;
+  if (entry && typeof entry === "object") {
+    const obj = entry as Record<string, unknown>;
+    for (const key of ["import", "default"]) {
+      const value = obj[key];
+      if (typeof value === "string") return value;
+      if (value && typeof value === "object") {
+        const nested = value as Record<string, unknown>;
+        if (typeof nested.default === "string") return nested.default;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function toCjsDestructureBindings(bindings: string): string {
+  const inner = bindings.trim().replace(/^\{\s*/, "").replace(/\s*\}$/, "");
+  if (!inner) return "{}";
+
+  const converted = inner
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => {
+      const aliasMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+      if (aliasMatch) return `${aliasMatch[1]}: ${aliasMatch[2]}`;
+      return part;
+    });
+
+  return `{ ${converted.join(", ")} }`;
+}
+
+export function getLoaderForFile(filePath: string): "tsx" | "jsx" | "ts" | "js" | "json" {
+  const ext = filePath.split(".").pop() ?? "";
+  return EXT_TO_LOADER[ext] ?? "js";
+}

package/src/src/routing/api/module-loader/loader.ts

@@ -12,6 +12,13 @@ import { getEsbuildLoader } from "../../../utils/path-utils.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import type { FileSystem } from "../../../platform/compat/fs.js";
 import * as pathHelper from "../../../platform/compat/path/index.js";
+import {
+  FILE_EXTENSIONS,
+  getLoaderForFile,
+  resolveExportEntry,
+  toCjsDestructureBindings,
+  validateModulePath,
+} from "./loader-helpers.js";
 import { isDeno, isNode } from "../../../platform/compat/runtime.js";
 import { withSpan } from "../../../observability/tracing/otlp-setup.js";
 import { isCompiledBinary } from "../../../utils/index.js";
@@ -21,23 +28,7 @@ import { rewriteNpmImports } from "../../../transforms/npm-import-rewrites.js";
 
 const logger = serverLogger.component("api");
 
-/**
- * Validates that a module path is contained within the project directory.
- * Prevents path traversal attacks that could load arbitrary files from the host.
- */
-function validateModulePath(modulePath: string, projectDir: string): void {
-  const resolved = pathHelper.resolve(modulePath);
-  const resolvedProject = pathHelper.resolve(projectDir);
-
-  if (!isWithinDirectory(resolvedProject, resolved)) {
-    throw toError(
-      createError({
-        type: "api",
-        message: `[API] module path escapes project directory: ${modulePath}`,
-      }),
-    );
-  }
-}
+export { toCjsDestructureBindings } from "./loader-helpers.js";
 
 /** Node.js built-in module names — shared across the CJS shim, esbuild externals, and Deno rewrites. */
 const NODE_BUILTINS = [
@@ -165,54 +156,6 @@ require.ensure = function(mods, cb) { cb(); };
 `.trim();
 }
 
-function resolveExportEntry(entry: unknown): string | undefined {
-  if (typeof entry === "string") return entry;
-  if (entry && typeof entry === "object") {
-    const obj = entry as Record<string, unknown>;
-    // Prefer import > default > first string value
-    for (const key of ["import", "default"]) {
-      const val = obj[key];
-      if (typeof val === "string") return val;
-      if (val && typeof val === "object") {
-        const nested = val as Record<string, unknown>;
-        if (typeof nested.default === "string") return nested.default;
-      }
-    }
-  }
-  return undefined;
-}
-
-export function toCjsDestructureBindings(bindings: string): string {
-  const inner = bindings.trim().replace(/^\{\s*/, "").replace(/\s*\}$/, "");
-  if (!inner) return "{}";
-
-  const converted = inner
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => {
-      const aliasMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
-      if (aliasMatch) return `${aliasMatch[1]}: ${aliasMatch[2]}`;
-      return part;
-    });
-
-  return `{ ${converted.join(", ")} }`;
-}
-
-const FILE_EXTENSIONS: string[] = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
-
-const EXT_TO_LOADER: Record<string, "tsx" | "jsx" | "ts" | "js" | "json"> = {
-  tsx: "tsx",
-  jsx: "jsx",
-  ts: "ts",
-  json: "json",
-};
-
-function getLoaderForFile(filePath: string): "tsx" | "jsx" | "ts" | "js" | "json" {
-  const ext = filePath.split(".").pop() ?? "";
-  return EXT_TO_LOADER[ext] ?? "js";
-}
-
 export function loadHandlerModule(options: LoadModuleOptions): Promise<APIRoute | null> {
   return withSpan(
     "api.loadHandlerModule",

package/src/src/server/bootstrap.ts

@@ -2,6 +2,7 @@ import type { RuntimeAdapter } from "../platform/adapters/base.js";
 import type { VeryfrontConfig } from "../config/index.js";
 import type { InvalidationProjectContext } from "../platform/adapters/fs/veryfront/types.js";
 import { clearConfigCache, getConfig } from "../config/index.js";
+import { type ExtensionLoader, orchestrateExtensions } from "../extensions/index.js";
 import {
   getEnvironmentConfig,
   refreshEnvironmentConfig,
@@ -41,8 +42,52 @@ export interface BootstrapResult {
   /** FSAdapter type (if used) */
   fsAdapterType?: string;
 
-  /** Dispose FSAdapter resources (WebSocket connections, caches) */
-  dispose?: () => void;
+  /**
+   * Extension loader that ran setup for all discovered extensions.
+   * Even when no extensions exist, a loader instance is present so callers
+   * can safely invoke `teardownAll()` unconditionally.
+   */
+  extensionLoader: ExtensionLoader;
+
+  /**
+   * Dispose bootstrap resources: tears down extensions (reverse order),
+   * then releases any FSAdapter resources (WebSocket connections, caches).
+   */
+  dispose?: () => void | Promise<void>;
+}
+
+function combineDispose(
+  extensionLoader: ExtensionLoader,
+  fsDispose?: () => void,
+): () => Promise<void> {
+  return async () => {
+    try {
+      await extensionLoader.teardownAll();
+    } finally {
+      if (fsDispose) fsDispose();
+    }
+  };
+}
+
+/**
+ * Run extension orchestration, disposing the FS adapter if orchestration fails.
+ *
+ * Exported for unit testing. In the FS-adapter path the caller has already
+ * allocated FS resources (WebSocket connections, caches) that must be
+ * released before the bootstrap error propagates.
+ *
+ * @internal
+ */
+export async function orchestrateOrDisposeFS(
+  orchestrate: () => Promise<ExtensionLoader>,
+  fsDispose: (() => void) | undefined,
+): Promise<ExtensionLoader> {
+  try {
+    return await orchestrate();
+  } catch (err) {
+    if (fsDispose) fsDispose();
+    throw err;
+  }
 }
 
 let envLogged = false;
@@ -115,7 +160,18 @@ export async function bootstrap(
 
   if (!needsFSAdapter) {
     bootstrapLog.debug("Using local filesystem (no FSAdapter needed)");
-    return { adapter, config, usingFSAdapter: false };
+    const extensionLoader = await orchestrateExtensions({
+      projectDir,
+      config,
+      logger: bootstrapLog,
+    });
+    return {
+      adapter,
+      config,
+      usingFSAdapter: false,
+      extensionLoader,
+      dispose: combineDispose(extensionLoader),
+    };
   }
 
   bootstrapLog.debug("Initializing FSAdapter", { type: fsType });
@@ -144,7 +200,18 @@ export async function bootstrap(
       fsAdapter: "local",
     });
 
-    return { adapter, config, usingFSAdapter: false };
+    const extensionLoader = await orchestrateExtensions({
+      projectDir,
+      config,
+      logger: bootstrapLog,
+    });
+    return {
+      adapter,
+      config,
+      usingFSAdapter: false,
+      extensionLoader,
+      dispose: combineDispose(extensionLoader),
+    };
   }
 
   const isProxyMode = config.fs?.veryfront?.proxyMode === true;
@@ -179,23 +246,37 @@ export async function bootstrap(
     fsAdapter: fsType,
   });
 
-  let dispose: (() => void) | undefined;
+  let fsDispose: (() => void) | undefined;
   if (isExtendedFSAdapter(enhancedAdapter.fs)) {
     const underlying = enhancedAdapter.fs.getUnderlyingAdapter();
     if (
       "dispose" in underlying &&
       typeof (underlying as { dispose?: () => void }).dispose === "function"
     ) {
-      dispose = () => (underlying as { dispose: () => void }).dispose();
+      fsDispose = () => (underlying as { dispose: () => void }).dispose();
     }
   }
 
+  // If extension orchestration fails after the FS adapter has been wired up,
+  // release the FS resources (WebSocket connections, caches) before
+  // propagating the error — otherwise the adapter would leak.
+  const extensionLoader = await orchestrateOrDisposeFS(
+    () =>
+      orchestrateExtensions({
+        projectDir,
+        config,
+        logger: bootstrapLog,
+      }),
+    fsDispose,
+  );
+
   return {
     adapter: enhancedAdapter,
     config,
     usingFSAdapter: true,
     fsAdapterType: fsType,
-    dispose,
+    extensionLoader,
+    dispose: combineDispose(extensionLoader, fsDispose),
   };
 }