veryfront 0.1.73 → 0.1.75

package/src/cli/commands/knowledge/command.ts

@@ -1,6 +1,6 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { z } from "zod";
-import { createFileSystem } from "../../../src/platform/index.js";
+import { createFileSystem, getEnv } from "../../../src/platform/index.js";
 import { basename, extname, join, normalize, relative } from "../../../src/platform/compat/path/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
 import { cliLogger } from "../../utils/index.js";
@@ -9,6 +9,7 @@ import type { ParsedArgs } from "../../shared/types.js";
 import { downloadUploadToFile, listAllUploads, type UploadItem } from "../uploads/command.js";
 import { putRemoteFileFromLocal } from "../files/command.js";
 import { knowledgeIngestPythonSource } from "./parser-source.js";
+import { createJobUserLogger, type Logger, serverLogger } from "../../../src/utils/index.js";
 
 const SUPPORTED_EXTENSIONS = new Set([
   ".pdf",
@@ -59,10 +60,12 @@ type KnowledgeSource =
 
 type DownloadResult = { uploadPath: string; localPath: string; bytes?: number };
 
+const knowledgeJobLogger = serverLogger.component("knowledge-ingest");
+
 const KnowledgeIngestArgsSchema = z.object({
   projectSlug: z.string().optional(),
   projectDir: z.string().optional(),
-  source: z.string().optional(),
+  sources: z.array(z.string()).default([]),
   path: z.string().optional(),
   all: z.boolean().default(false),
   recursive: z.boolean().default(false),
@@ -72,6 +75,44 @@ const KnowledgeIngestArgsSchema = z.object({
   slug: z.string().optional(),
   json: z.boolean().default(false),
   quiet: z.boolean().default(false),
+}).superRefine((value, ctx) => {
+  const hasExplicitSources = value.sources.length > 0;
+  const hasPath = typeof value.path === "string" && value.path.length > 0;
+
+  if (hasExplicitSources && (hasPath || value.all)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Use either explicit source paths or --path with --all, not both.",
+    });
+  }
+
+  if (!hasExplicitSources && !hasPath && !value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provide one or more source paths or use --path with --all.",
+    });
+  }
+
+  if (hasPath && !value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--path requires --all.",
+    });
+  }
+
+  if (!hasPath && value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--all requires --path.",
+    });
+  }
+
+  if (value.slug && value.sources.length !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--slug can only be used with a single explicit source.",
+    });
+  }
 });
 
 export type KnowledgeIngestOptions = z.infer<typeof KnowledgeIngestArgsSchema>;
@@ -92,12 +133,33 @@ function printJson(value: unknown): void {
   console.log(JSON.stringify(value, null, 2));
 }
 
+function createKnowledgeIngestEventLogger(): Logger | null {
+  const projectId = getEnv("TENANT_PROJECT_ID");
+  const jobId = getEnv("JOB_ID");
+
+  if (!projectId || !jobId) {
+    return null;
+  }
+
+  return createJobUserLogger(knowledgeJobLogger, {
+    projectId,
+    jobId,
+    batchId: getEnv("JOB_BATCH_ID") ?? undefined,
+    jobTarget: getEnv("JOB_TARGET") ?? undefined,
+    task: "knowledge-ingest",
+  });
+}
+
+function buildKnowledgeSourceName(source: KnowledgeSource): string {
+  return basename(source.kind === "upload" ? source.uploadPath : source.localPath);
+}
+
 function showKnowledgeUsage(): void {
   console.log(`
 Veryfront Knowledge
 
 Usage:
-  veryfront knowledge ingest <source> [options]
+  veryfront knowledge ingest <source...> [options]
   veryfront knowledge ingest --path <prefix-or-dir> --all [options]
 
 Subcommands:
@@ -111,7 +173,7 @@ export function parseKnowledgeIngestArgs(
   return KnowledgeIngestArgsSchema.safeParse({
     projectSlug: getStringArg(args, "project", "p", "project-slug"),
     projectDir: getStringArg(args, "project-dir", "dir", "d"),
-    source: typeof args._[2] === "string" ? args._[2] : undefined,
+    sources: args._.slice(2).filter((value): value is string => typeof value === "string"),
     path: getStringArg(args, "path"),
     all: getBooleanArg(args, "all"),
     recursive: getBooleanArg(args, "recursive"),
@@ -273,6 +335,7 @@ export async function runKnowledgeParser(input: {
   description?: string;
   slug?: string;
   sourceReference?: string;
+  env?: Record<string, string>;
 }): Promise<KnowledgeParserResult> {
   const tempDir = await dntShim.Deno.makeTempDir({ prefix: "veryfront-knowledge-parser-" });
   const inputJsonPath = `${tempDir}/input.json`;
@@ -296,6 +359,7 @@ export async function runKnowledgeParser(input: {
     try {
       result = await new dntShim.Deno.Command("python3", {
         args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
+        ...(input.env ? { env: input.env } : {}),
         stdout: "piped",
         stderr: "piped",
       }).output();
@@ -321,7 +385,7 @@ export async function runKnowledgeParser(input: {
 }
 
 export async function collectKnowledgeSources(
-  options: Pick<KnowledgeIngestOptions, "source" | "path" | "all" | "recursive">,
+  options: Pick<KnowledgeIngestOptions, "sources" | "path" | "all" | "recursive">,
   deps: {
     client: ApiClient;
     projectSlug: string;
@@ -330,29 +394,68 @@ export async function collectKnowledgeSources(
 ): Promise<KnowledgeSource[]> {
   const fs = createFileSystem();
 
-  if (options.source) {
-    if (!isProjectUploadReference(options.source) && await fs.exists(options.source)) {
-      const localFiles = await collectLocalFiles(options.source, options.recursive);
-      if (!localFiles.length) throw new Error(`No supported files found at ${options.source}`);
-      return localFiles.map((localPath) => ({ kind: "local", input: options.source!, localPath }));
+  if (options.sources.length > 0) {
+    const explicitSources: Array<
+      | { kind: "local"; sources: KnowledgeSource[] }
+      | { kind: "upload"; input: string; uploadPath: string }
+    > = [];
+    const uploadTargets: string[] = [];
+
+    for (const input of options.sources) {
+      if (!isProjectUploadReference(input) && await fs.exists(input)) {
+        const localFiles = await collectLocalFiles(input, options.recursive);
+        if (!localFiles.length) throw new Error(`No supported files found at ${input}`);
+        explicitSources.push({
+          kind: "local",
+          sources: localFiles.map((localPath) => ({ kind: "local", input, localPath })),
+        });
+        continue;
+      }
+
+      if (isLikelyLocalPath(input)) {
+        throw new Error(`Local file not found: ${input}`);
+      }
+
+      const uploadPath = normalizeProjectUploadPath(input);
+      explicitSources.push({ kind: "upload", input, uploadPath });
+      uploadTargets.push(uploadPath);
     }
 
-    if (isLikelyLocalPath(options.source)) {
-      throw new Error(`Local file not found: ${options.source}`);
+    const downloads = uploadTargets.length > 0 ? await deps.downloadUploads(uploadTargets) : [];
+    const downloadsByPath = new Map<string, DownloadResult[]>();
+
+    for (const download of downloads) {
+      const existing = downloadsByPath.get(download.uploadPath) ?? [];
+      existing.push(download);
+      downloadsByPath.set(download.uploadPath, existing);
     }
 
-    const uploadPath = normalizeProjectUploadPath(options.source);
-    const downloads = await deps.downloadUploads([uploadPath]);
-    return downloads.map((download) => ({
-      kind: "upload",
-      input: options.source!,
-      uploadPath: download.uploadPath,
-      localPath: download.localPath,
-    }));
+    const resolvedSources: KnowledgeSource[] = [];
+    for (const source of explicitSources) {
+      if (source.kind === "local") {
+        resolvedSources.push(...source.sources);
+        continue;
+      }
+
+      const matchingDownloads = downloadsByPath.get(source.uploadPath);
+      const download = matchingDownloads?.shift();
+      if (!download) {
+        throw new Error(`Upload not found: ${formatKnowledgeUploadSource(source.uploadPath)}`);
+      }
+
+      resolvedSources.push({
+        kind: "upload",
+        input: source.input,
+        uploadPath: download.uploadPath,
+        localPath: download.localPath,
+      });
+    }
+
+    return resolvedSources;
   }
 
   if (!options.path || !options.all) {
-    throw new Error("Provide a source path or use --path with --all.");
+    throw new Error("Provide one or more source paths or use --path with --all.");
   }
 
   if (!isProjectUploadReference(options.path) && await fs.exists(options.path)) {
@@ -405,12 +508,24 @@ export async function ingestResolvedSources(
     outputDir: string;
     runParser: typeof runKnowledgeParser;
     uploadKnowledgeFile: (remotePath: string, localPath: string) => Promise<{ path: string }>;
+    eventLogger?: Logger | null;
   },
 ): Promise<KnowledgeIngestFileResult[]> {
-  const slugs = options.slug && sources.length === 1 ? [options.slug] : ensureUniqueSlugs(sources);
+  if (options.slug && sources.length !== 1) {
+    throw new Error("--slug can only be used with a single explicit source.");
+  }
+
+  const slugs = options.slug ? [options.slug] : ensureUniqueSlugs(sources);
   const results: KnowledgeIngestFileResult[] = [];
 
   for (const [index, source] of sources.entries()) {
+    deps.eventLogger?.info("Processing knowledge source", {
+      phase: "file_processing",
+      progress_current: index + 1,
+      progress_total: sources.length,
+      source_name: buildKnowledgeSourceName(source),
+    });
+
     const parser = await deps.runParser({
       filePath: source.localPath,
       outputDir: deps.outputDir,
@@ -424,6 +539,26 @@ export async function ingestResolvedSources(
       options.knowledgePath,
     );
     const uploaded = await deps.uploadKnowledgeFile(remotePath, parser.sandbox_output_path);
+
+    deps.eventLogger?.info("Knowledge source ingested", {
+      phase: "file_completed",
+      progress_current: index + 1,
+      progress_total: sources.length,
+      source_name: buildKnowledgeSourceName(source),
+      remote_path: uploaded.path,
+      warning_count: parser.warnings.length,
+    });
+
+    if (parser.warnings.length > 0) {
+      deps.eventLogger?.warn("Knowledge source emitted warnings", {
+        phase: "file_warning",
+        progress_current: index + 1,
+        progress_total: sources.length,
+        source_name: buildKnowledgeSourceName(source),
+        warning_count: parser.warnings.length,
+      });
+    }
+
     results.push(
       createKnowledgeIngestResult({
         source: buildSourceReference(source),
@@ -462,8 +597,14 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
         const outputDir = options.outputDir ?? await defaultOutputRoot();
         const shouldCleanupOutputDir = options.outputDir === undefined;
         const downloadOutputDir = resolveKnowledgeDownloadOutputDir(outputDir);
+        const eventLogger = createKnowledgeIngestEventLogger();
 
         try {
+          eventLogger?.info("Starting knowledge ingest", {
+            phase: "started",
+            mode: options.path ? "path_prefix" : "explicit_sources",
+          });
+
           const sources = await collectKnowledgeSources(options, {
             client,
             projectSlug: config.projectSlug,
@@ -475,15 +616,27 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
               ),
           });
 
+          eventLogger?.info("Resolved knowledge sources", {
+            phase: "sources_resolved",
+            progress_total: sources.length,
+          });
+
           const results = await ingestResolvedSources(sources, options, {
             client,
             projectSlug: config.projectSlug,
             outputDir,
             runParser: runKnowledgeParser,
+            eventLogger,
             uploadKnowledgeFile: (remotePath, localPath) =>
               putRemoteFileFromLocal(client, config.projectSlug, remotePath, localPath),
           });
 
+          eventLogger?.info("Completed knowledge ingest", {
+            phase: "completed",
+            progress_current: results.length,
+            progress_total: results.length,
+          });
+
           if (options.json) {
             printJson(results);
             return;
@@ -495,6 +648,11 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
               cliLogger.info(`  ${result.summary}`);
             }
           }
+        } catch (error) {
+          eventLogger?.error("Knowledge ingest failed", {
+            phase: "failed",
+          });
+          throw error;
         } finally {
           if (shouldCleanupOutputDir) {
             await Promise.all([

package/src/cli/commands/knowledge/parser-source.ts

@@ -3,6 +3,7 @@ import argparse
 import csv
 import json
 import re
+import subprocess
 from datetime import date
 from pathlib import Path
 from typing import Any, Optional
@@ -71,6 +72,107 @@ def build_frontmatter(source: str, source_type: str, description: str) -> str:
     ])
 
 
+def metadata_int(metadata: dict[str, Any], *keys: str) -> Optional[int]:
+    for key in keys:
+        value = metadata.get(key)
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value
+    return None
+
+
+def metadata_string_list(metadata: dict[str, Any], *keys: str) -> Optional[list[str]]:
+    for key in keys:
+        value = metadata.get(key)
+        if isinstance(value, list) and all(isinstance(item, str) for item in value):
+            return value
+    return None
+
+
+def build_kreuzberg_stats(source_type: str, content: str, metadata: dict[str, Any]):
+    stats: dict[str, Any] = {
+        "characters": len(content),
+        "lines": len(content.splitlines()) if content else 0,
+        "engine": "kreuzberg",
+    }
+
+    if isinstance(metadata.get("mime_type"), str):
+        stats["mime_type"] = metadata["mime_type"]
+
+    if source_type == "pdf":
+        stats["pages"] = metadata_int(metadata, "page_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type in {"xlsx", "xls"}:
+        stats["sheets"] = metadata_int(metadata, "sheet_count") or 0
+        stats["rows"] = metadata_int(metadata, "row_count") or 0
+        stats["sheet_names"] = metadata_string_list(metadata, "sheet_names") or []
+    elif source_type == "docx":
+        stats["paragraphs"] = metadata_int(metadata, "paragraph_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type == "pptx":
+        stats["slides"] = metadata_int(metadata, "slide_count", "page_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type == "html":
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+
+    return stats
+
+
+def parse_with_kreuzberg(path: str, source_type: str):
+    warnings: list[str] = []
+    completed = subprocess.run(
+        [
+            "kreuzberg",
+            "extract",
+            path,
+            "--format",
+            "json",
+            "--output-format",
+            "markdown",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip() or f"exit code {completed.returncode}"
+        raise RuntimeError(f"kreuzberg extract failed: {detail}")
+
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise RuntimeError(f"kreuzberg extract returned invalid JSON: {error}") from error
+
+    content = payload.get("content", "")
+    if not isinstance(content, str):
+        raise RuntimeError("kreuzberg extract did not return string content")
+
+    metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
+    normalized_content = clean_text(content)
+    stats = build_kreuzberg_stats(source_type, normalized_content, metadata)
+
+    return normalized_content or "_No extractable text found in document._", stats, warnings
+
+
+def prefer_kreuzberg(source_type: str, fallback_parser):
+    def parser(path: str):
+        try:
+            return parse_with_kreuzberg(path, source_type)
+        except FileNotFoundError as error:
+            if getattr(error, "filename", "") == "kreuzberg":
+                return fallback_parser(path)
+            raise
+        except RuntimeError as error:
+            content, stats, warnings = fallback_parser(path)
+            warnings.append(
+                "kreuzberg extraction failed; fell back to the built-in parser: "
+                + str(error)
+            )
+            return content, stats, warnings
+
+    return parser
+
+
 def parse_csv_like(path: str, delimiter: str = ","):
     warnings: list[str] = []
     with open(path, newline="", encoding="utf-8-sig") as file:
@@ -305,18 +407,19 @@ def parse_json(path: str):
 def select_parser(path: Path):
     ext = path.suffix.lower()
     if ext == ".pdf":
-        return "pdf", parse_pdf
+        return "pdf", prefer_kreuzberg("pdf", parse_pdf)
     if ext in {".csv", ".tsv"}:
         delimiter = "\t" if ext == ".tsv" else ","
         return ext.lstrip("."), lambda file_path: parse_csv_like(file_path, delimiter)
     if ext in {".xlsx", ".xls"}:
-        return ext.lstrip("."), parse_excel
+        source_type = ext.lstrip(".")
+        return source_type, prefer_kreuzberg(source_type, parse_excel)
     if ext == ".docx":
-        return "docx", parse_docx
+        return "docx", prefer_kreuzberg("docx", parse_docx)
     if ext == ".pptx":
-        return "pptx", parse_pptx
+        return "pptx", prefer_kreuzberg("pptx", parse_pptx)
     if ext in {".html", ".htm"}:
-        return "html", parse_html
+        return "html", prefer_kreuzberg("html", parse_html)
     if ext in {".txt", ".md", ".mdx"}:
         return ext.lstrip("."), parse_text
     if ext == ".json":
@@ -325,6 +428,8 @@ def select_parser(path: Path):
 
 
 def build_summary(source_type: str, stats: dict[str, Any]) -> str:
+    if stats.get("engine") == "kreuzberg":
+        return f"Converted {source_type.upper()} to markdown ({stats.get('characters', 0)} chars)."
     if source_type in {"csv", "tsv"}:
         return f"Parsed {stats.get('rows', 0)} rows across {stats.get('columns', 0)} columns."
     if source_type in {"xlsx", "xls"}:

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [
@@ -34,6 +34,7 @@ export default {
     "./resource": "./src/resource/index.ts",
     "./mcp": "./src/mcp/index.ts",
     "./middleware": "./src/middleware/index.ts",
+    "./utils": "./src/utils/index.ts",
     "./oauth": "./src/oauth/index.ts",
     "./provider": "./src/provider/index.ts",
     "./fs": "./src/fs/index.ts",
@@ -71,6 +72,7 @@ export default {
     "veryfront/workflow/claude-code": "./src/workflow/claude-code/index.ts",
     "veryfront/workflow/claude-code/react": "./src/workflow/claude-code/react/index.ts",
     "veryfront/workflow/discovery": "./src/workflow/discovery/index.ts",
+    "veryfront/utils": "./src/utils/index.ts",
     "veryfront/utils/box": "./src/utils/box.ts",
     "veryfront/utils/case-utils": "./src/utils/case-utils.ts",
     "veryfront/utils/constants/server": "./src/utils/constants/server.ts",

package/src/src/data/data-fetcher.ts

@@ -1,11 +1,22 @@
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../observability/tracing/span-names.js";
 import { CacheManager } from "./data-fetching-cache.js";
-import { ServerDataFetcher } from "./server-data-fetcher.js";
+import { ServerDataFetcher, type ServerDataFetchOptions } from "./server-data-fetcher.js";
 import { StaticDataFetcher } from "./static-data-fetcher.js";
 import { StaticPathsFetcher } from "./static-paths-fetcher.js";
 import type { DataContext, DataResult, PageWithData, StaticPathsResult } from "./types.js";
 
+/**
+ * Options for isolated data fetching. Passed through to ServerDataFetcher
+ * when worker isolation is enabled.
+ */
+export interface FetchDataOptions {
+  /** Absolute path to the module containing getServerData */
+  modulePath?: string;
+  /** Project directory for worker scoping */
+  projectDir?: string;
+}
+
 export class DataFetcher {
   private cacheManager: CacheManager;
   private serverFetcher: ServerDataFetcher;
@@ -23,6 +34,7 @@ export class DataFetcher {
     pageModule: PageWithData,
     context: DataContext,
     mode: "development" | "production" = "development",
+    options?: FetchDataOptions,
   ): Promise<DataResult> {
     const preferServerData = mode === "development" || !pageModule.getStaticData;
     const useServer = preferServerData && !!pageModule.getServerData;
@@ -34,10 +46,14 @@ export class DataFetcher {
       ? "static"
       : "none";
 
+    const isolationOptions: ServerDataFetchOptions | undefined = options
+      ? { modulePath: options.modulePath, projectDir: options.projectDir }
+      : undefined;
+
     return withSpan(
       SpanNames.DATA_FETCH,
       () => {
-        if (useServer) return this.serverFetcher.fetch(pageModule, context);
+        if (useServer) return this.serverFetcher.fetch(pageModule, context, isolationOptions);
         if (useStatic) return this.staticFetcher.fetch(pageModule, context);
         return Promise.resolve({ props: {} });
       },

package/src/src/data/index.ts

@@ -13,5 +13,5 @@ export type {
   PageWithData,
   StaticPathsResult,
 } from "./types.js";
-export { DataFetcher } from "./data-fetcher.js";
+export { DataFetcher, type FetchDataOptions } from "./data-fetcher.js";
 export { notFound, redirect } from "./helpers.js";

package/src/src/data/server-data-fetcher.ts

@@ -1,12 +1,29 @@
+import * as dntShim from "../../_dnt.shims.js";
 import type { DataContext, DataResult, PageWithData } from "./types.js";
 import { serverLogger } from "../utils/index.js";
 import { DATA_FETCH_TIMEOUT_MS } from "../config/defaults.js";
 import { TimeoutError, withTimeoutThrow } from "../rendering/utils/stream-utils.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { CircuitBreakerOpen, getCircuitBreaker } from "../utils/circuit-breaker.js";
+import { getWorkerPool, isDataIsolationEnabled } from "../security/sandbox/worker-pool.js";
+import type { WorkerResponse } from "../security/sandbox/worker-types.js";
+
+/**
+ * Options for isolated data fetching through Worker pool.
+ */
+export interface ServerDataFetchOptions {
+  /** Absolute path to the module containing getServerData */
+  modulePath?: string;
+  /** Project directory for worker scoping */
+  projectDir?: string;
+}
 
 export class ServerDataFetcher {
-  fetch(pageModule: PageWithData, context: DataContext): Promise<DataResult> {
+  fetch(
+    pageModule: PageWithData,
+    context: DataContext,
+    options?: ServerDataFetchOptions,
+  ): Promise<DataResult> {
     if (typeof pageModule.getServerData !== "function") {
       return Promise.resolve({ props: {} });
     }
@@ -20,6 +37,11 @@ export class ServerDataFetcher {
       successThreshold: 2,
     });
 
+    // Choose isolated or direct execution
+    const useIsolation = isDataIsolationEnabled() &&
+      !!options?.modulePath &&
+      !!options?.projectDir;
+
     return withSpan(
       "data.fetch_server",
       async () => {
@@ -28,7 +50,9 @@ export class ServerDataFetcher {
         try {
           const result = await circuitBreaker.execute(() =>
             withTimeoutThrow(
-              Promise.resolve(pageModule.getServerData!(context)),
+              useIsolation
+                ? this.fetchIsolated(options!.modulePath!, options!.projectDir!, context)
+                : Promise.resolve(pageModule.getServerData!(context)),
               DATA_FETCH_TIMEOUT_MS,
               `getServerData for ${pathname}`,
             )
@@ -59,7 +83,11 @@ export class ServerDataFetcher {
             throw error;
           }
 
-          this.logError("DATA_FETCH_ERROR getServerData failed", error, { pathname, durationMs });
+          this.logError("DATA_FETCH_ERROR getServerData failed", error, {
+            pathname,
+            durationMs,
+            isolated: useIsolation,
+          });
           throw error;
         }
       },
@@ -68,8 +96,55 @@ export class ServerDataFetcher {
         "data.pathname": pathname,
         "data.timeout_ms": DATA_FETCH_TIMEOUT_MS,
         "data.project_id": projectId,
+        "data.isolated": useIsolation,
+      },
+    );
+  }
+
+  /**
+   * Execute getServerData in a per-project Worker.
+   */
+  private async fetchIsolated(
+    modulePath: string,
+    projectDir: string,
+    context: DataContext,
+  ): Promise<DataResult> {
+    const pool = getWorkerPool();
+    const body = context.request?.body ? new Uint8Array(await context.request.arrayBuffer()) : null;
+
+    const workerResponse: WorkerResponse = await pool.execute(
+      projectDir,
+      [projectDir],
+      {
+        type: "fetch-data",
+        id: dntShim.crypto.randomUUID(),
+        modulePath,
+        context: {
+          params: context.params,
+          query: context.query?.toString() ?? "",
+          request: {
+            url: context.request?.url ?? context.url?.toString() ?? "http://localhost",
+            method: context.request?.method ?? "GET",
+            headers: context.request ? [...context.request.headers.entries()] : [],
+            body,
+          },
+          url: context.url?.toString() ?? "http://localhost",
+        },
       },
     );
+
+    if (workerResponse.type === "error") {
+      const err = new Error(workerResponse.error.message);
+      err.name = workerResponse.error.name;
+      throw err;
+    }
+
+    if (workerResponse.type === "data-result") {
+      return workerResponse.result as DataResult;
+    }
+
+    // Unexpected response type — shouldn't happen but be defensive
+    throw new Error(`Unexpected worker response type: ${workerResponse.type}`);
   }
 
   /**