feat: local dataset paths, API route, and versioned fetch routing

.gitignore

@@ -0,0 +1,8 @@
+node_modules
+.next
+out
+tsconfig.tsbuildinfo
+next-env.d.ts
+.env*.local
+*.log
+.DS_Store

.prettierignore

@@ -0,0 +1,3 @@
+.next
+node_modules
+tsconfig.tsbuildinfo

src/app/[org]/[dataset]/[episode]/episode-viewer.tsx

@@ -34,6 +34,7 @@ import {
   type CrossEpisodeVarianceData,
 } from "./fetch-data";
 import { getDatasetVersionAndInfo } from "@/utils/versionUtils";
+import { isLocalRepoId } from "@/utils/localDataset";
 import type { DatasetMetadata } from "@/utils/parquetUtils";
 
 const URDFViewer = lazy(() => import("@/components/urdf-viewer"));
@@ -614,14 +615,24 @@ function EpisodeViewerInner({
                 </a>
 
                 <div>
-                  <a
-                    href={`https://huggingface.co/datasets/${datasetInfo.repoId}`}
-                    target="_blank"
-                  >
-                    <p className="text-lg font-semibold">
-                      {datasetInfo.repoId}
+                  {isLocalRepoId(datasetInfo.repoId) ? (
+                    <p
+                      className="text-lg font-semibold text-left max-w-md break-all"
+                      title={datasetInfo.localDiskPath}
+                    >
+                      {datasetInfo.displayLabel ?? datasetInfo.repoId}
                     </p>
-                  </a>
+                  ) : (
+                    <a
+                      href={`https://huggingface.co/datasets/${datasetInfo.repoId}`}
+                      target="_blank"
+                      rel="noopener noreferrer"
+                    >
+                      <p className="text-lg font-semibold">
+                        {datasetInfo.displayLabel ?? datasetInfo.repoId}
+                      </p>
+                    </a>
+                  )}
 
                   <p className="font-mono text-lg font-semibold">
                     episode {episodeId}
@@ -701,6 +712,7 @@ function EpisodeViewerInner({
             <Suspense fallback={<Loading />}>
               <FilteringPanel
                 repoId={datasetInfo.repoId}
+                localDiskPath={datasetInfo.localDiskPath}
                 crossEpisodeData={crossEpData}
                 crossEpisodeLoading={insightsLoading}
                 episodeLengthStats={episodeLengthStats}

src/app/[org]/[dataset]/[episode]/fetch-data.ts

@@ -20,6 +20,7 @@ import {
   buildV3EpisodesMetadataPath,
 } from "@/utils/stringFormatting";
 import { bigIntToNumber } from "@/utils/typeGuards";
+import { LOCAL_ORG, decodeLocalDatasetSegment } from "@/utils/localDataset";
 import type { VideoInfo, AdjacentEpisodeVideos } from "@/types";
 
 const SERIES_NAME_DELIMITER = CHART_CONFIG.SERIES_NAME_DELIMITER;
@@ -28,6 +29,10 @@ export type CameraInfo = { name: string; width: number; height: number };
 
 export type DatasetDisplayInfo = {
   repoId: string;
+  /** Shown in the UI for local datasets (includes absolute path). */
+  displayLabel?: string;
+  /** Decoded dataset root on disk when using a local dataset. */
+  localDiskPath?: string;
   total_frames: number;
   total_episodes: number;
   fps: number;
@@ -321,6 +326,9 @@ export async function getEpisodeData(
       .filter(([, f]) => f.dtype === "video" && f.shape.length >= 2)
       .map(([name, f]) => ({ name, height: f.shape[0], width: f.shape[1] }));
 
+    const decodedPath =
+      org === LOCAL_ORG ? decodeLocalDatasetSegment(dataset) : null;
+
     result.datasetInfo = {
       ...result.datasetInfo,
       robot_type: rawInfo.robot_type ?? null,
@@ -333,6 +341,8 @@ export async function getEpisodeData(
             10,
         ) / 10,
       cameras,
+      displayLabel: decodedPath !== null ? `Local: ${decodedPath}` : undefined,
+      localDiskPath: decodedPath ?? undefined,
     };
 
     const progressGroup = await loadEpisodeProgressGroup(

src/app/[org]/[dataset]/[episode]/page.tsx

@@ -1,5 +1,6 @@
 import EpisodeViewer from "./episode-viewer";
 import { Suspense } from "react";
+import { LOCAL_ORG, decodeLocalDatasetSegment } from "@/utils/localDataset";
 
 export const dynamic = "force-dynamic";
 
@@ -9,8 +10,12 @@ export async function generateMetadata({
   params: Promise<{ org: string; dataset: string; episode: string }>;
 }) {
   const { org, dataset, episode } = await params;
+  const label =
+    org === LOCAL_ORG
+      ? (decodeLocalDatasetSegment(dataset) ?? `${org}/${dataset}`)
+      : `${org}/${dataset}`;
   return {
-    title: `${org}/${dataset} | episode ${episode}`,
+    title: `${label} | episode ${episode}`,
   };
 }
 

src/app/api/local-dataset/file/route.ts

@@ -0,0 +1,14 @@
+import { readLocalDatasetFileResponse } from "@/lib/local-dataset-fs";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const rootEncoded = searchParams.get("root");
+  const rel = searchParams.get("rel");
+  if (!rootEncoded || !rel) {
+    return Response.json(
+      { error: "Missing root or rel query parameter" },
+      { status: 400 },
+    );
+  }
+  return readLocalDatasetFileResponse(rootEncoded, rel, request);
+}

src/app/page.tsx

@@ -3,6 +3,11 @@ import { useEffect, useRef, useState, useCallback, Suspense } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import { useSearchParams } from "next/navigation";
+import {
+  encodeLocalDatasetRoot,
+  looksLikeAbsoluteFilesystemPath,
+  normalizeUserLocalPathInput,
+} from "@/utils/localDataset";
 
 declare global {
   interface Window {
@@ -189,10 +194,16 @@ function HomeInner() {
 
   const handleSubmit = (e: { preventDefault: () => void }) => {
     e.preventDefault();
+    const typed = query.trim();
+    if (looksLikeAbsoluteFilesystemPath(typed)) {
+      const path = normalizeUserLocalPathInput(typed);
+      navigate(`/local/${encodeLocalDatasetRoot(path)}`);
+      return;
+    }
     const target =
       activeIndex >= 0 && suggestions[activeIndex]
         ? suggestions[activeIndex]
-        : query.trim();
+        : typed;
     if (target) navigate(target);
   };
 
@@ -261,7 +272,7 @@ function HomeInner() {
               onChange={(e) => setQuery(e.target.value)}
               onKeyDown={handleKeyDown}
               onFocus={() => query.trim() && setShowSuggestions(true)}
-              placeholder="Enter dataset id (e.g. lerobot/pusht)"
+              placeholder="Dataset id or local path (e.g. /tmp/my_dataset)"
               className="pl-10 pr-4 py-2.5 rounded-md text-base text-white bg-white/10 backdrop-blur-sm border border-white/30 focus:outline-none focus:border-sky-400 focus:bg-white/15 w-[380px] shadow-md placeholder:text-white/40 transition-colors"
               autoComplete="off"
             />

src/components/filtering-panel.tsx

@@ -225,6 +225,8 @@ function EpisodeLengthFilter({ episodes }: { episodes: EpisodeLengthInfo[] }) {
 
 interface FilteringPanelProps {
   repoId: string;
+  /** When set, Hugging Face CLI snippets are hidden (local folder dataset). */
+  localDiskPath?: string;
   crossEpisodeData: CrossEpisodeVarianceData | null;
   crossEpisodeLoading: boolean;
   episodeLengthStats: EpisodeLengthStats | null;
@@ -234,9 +236,11 @@ interface FilteringPanelProps {
 
 function FlaggedIdsCopyBar({
   repoId,
+  localDiskPath,
   onViewEpisodes,
 }: {
   repoId: string;
+  localDiskPath?: string;
   onViewEpisodes?: () => void;
 }) {
   const { flagged, count, clear } = useFlaggedEpisodes();
@@ -331,19 +335,32 @@ function FlaggedIdsCopyBar({
         </button>
       )}
       <div className="bg-slate-900/60 rounded-md px-3 py-2 border border-slate-700/60 space-y-2.5">
-        <p className="text-xs text-slate-400">
-          <a
-            href="https://github.com/huggingface/lerobot"
-            target="_blank"
-            rel="noopener noreferrer"
-            className="text-orange-400 underline"
-          >
-            LeRobot CLI
-          </a>{" "}
-          — delete flagged episodes:
-        </p>
-        <pre className="text-xs text-slate-300 bg-slate-950/50 rounded px-2 py-1.5 overflow-x-auto select-all">{`# Delete episodes (modifies original dataset)\nlerobot-edit-dataset \\\n    --repo_id ${repoId} \\\n    --operation.type delete_episodes \\\n    --operation.episode_indices "[${ids.join(", ")}]"`}</pre>
-        <pre className="text-xs text-slate-300 bg-slate-950/50 rounded px-2 py-1.5 overflow-x-auto select-all">{`# Delete episodes and save to a new dataset (preserves original)\nlerobot-edit-dataset \\\n    --repo_id ${repoId} \\\n    --new_repo_id ${repoId}_filtered \\\n    --operation.type delete_episodes \\\n    --operation.episode_indices "[${ids.join(", ")}]"`}</pre>
+        {localDiskPath ? (
+          <p className="text-xs text-slate-400 leading-relaxed">
+            This is a local folder dataset (not a Hugging Face repo). Flagged
+            indices are listed above; edit or remove episodes on disk under{" "}
+            <span className="text-slate-200 font-mono break-all">
+              {localDiskPath}
+            </span>
+            .
+          </p>
+        ) : (
+          <>
+            <p className="text-xs text-slate-400">
+              <a
+                href="https://github.com/huggingface/lerobot"
+                target="_blank"
+                rel="noopener noreferrer"
+                className="text-orange-400 underline"
+              >
+                LeRobot CLI
+              </a>{" "}
+              — delete flagged episodes:
+            </p>
+            <pre className="text-xs text-slate-300 bg-slate-950/50 rounded px-2 py-1.5 overflow-x-auto select-all">{`# Delete episodes (modifies original dataset)\nlerobot-edit-dataset \\\n    --repo_id ${repoId} \\\n    --operation.type delete_episodes \\\n    --operation.episode_indices "[${ids.join(", ")}]"`}</pre>
+            <pre className="text-xs text-slate-300 bg-slate-950/50 rounded px-2 py-1.5 overflow-x-auto select-all">{`# Delete episodes and save to a new dataset (preserves original)\nlerobot-edit-dataset \\\n    --repo_id ${repoId} \\\n    --new_repo_id ${repoId}_filtered \\\n    --operation.type delete_episodes \\\n    --operation.episode_indices "[${ids.join(", ")}]"`}</pre>
+          </>
+        )}
       </div>
     </div>
   );
@@ -351,6 +368,7 @@ function FlaggedIdsCopyBar({
 
 function FilteringPanel({
   repoId,
+  localDiskPath,
   crossEpisodeData,
   crossEpisodeLoading,
   episodeLengthStats,
@@ -369,6 +387,7 @@ function FilteringPanel({
 
       <FlaggedIdsCopyBar
         repoId={repoId}
+        localDiskPath={localDiskPath}
         onViewEpisodes={onViewFlaggedEpisodes}
       />
 

src/components/stats-panel.tsx

@@ -123,8 +123,8 @@ function StatsPanel({
       <div>
         <h2 className="text-xl text-slate-100">
           <span className="font-bold">Dataset Statistics:</span>{" "}
-          <span className="font-normal text-slate-400">
-            {datasetInfo.repoId}
+          <span className="font-normal text-slate-400 break-all">
+            {datasetInfo.displayLabel ?? datasetInfo.repoId}
           </span>
         </h2>
       </div>

src/lib/local-dataset-fs.ts

@@ -0,0 +1,143 @@
+import fs from "fs/promises";
+import path from "path";
+import { decodeLocalDatasetSegment } from "@/utils/localDataset";
+
+export function resolveLocalDatasetRoot(rootEncoded: string): string | null {
+  const decoded = decodeLocalDatasetSegment(rootEncoded);
+  if (!decoded) return null;
+  return path.resolve(decoded);
+}
+
+/**
+ * Join `rel` under `root` and ensure the result stays inside `root` (no path traversal).
+ */
+export function safePathUnderRoot(root: string, rel: string): string | null {
+  if (!rel || rel.includes("\0")) return null;
+  const relNorm = rel.replace(/\\/g, "/");
+  const segments = relNorm.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return null;
+  if (segments.some((s) => s === "..")) return null;
+
+  const rootResolved = path.resolve(root);
+  const joined = path.resolve(rootResolved, ...segments);
+
+  const prefix =
+    rootResolved.endsWith(path.sep) || rootResolved.endsWith("/")
+      ? rootResolved
+      : rootResolved + path.sep;
+  if (joined !== rootResolved && !joined.startsWith(prefix)) {
+    return null;
+  }
+  return joined;
+}
+
+function guessContentType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".json":
+      return "application/json";
+    case ".jsonl":
+      return "application/x-ndjson";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".parquet":
+      return "application/octet-stream";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+function parseBytesRange(
+  rangeHeader: string | null,
+  size: number,
+): { start: number; end: number } | null {
+  if (!rangeHeader || !rangeHeader.startsWith("bytes=")) return null;
+  const spec = rangeHeader.slice(6).split(",")[0]?.trim();
+  if (!spec) return null;
+  const dash = spec.indexOf("-");
+  if (dash < 0) return null;
+  const startStr = spec.slice(0, dash);
+  const endStr = spec.slice(dash + 1);
+
+  let start: number;
+  let end: number;
+
+  if (startStr === "") {
+    const suffix = parseInt(endStr, 10);
+    if (!Number.isFinite(suffix) || suffix <= 0) return null;
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    start = parseInt(startStr, 10);
+    end = endStr !== "" ? parseInt(endStr, 10) : size - 1;
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+    end = Math.min(end, size - 1);
+    if (start > end || start < 0 || start >= size) return null;
+  }
+
+  return { start, end };
+}
+
+export async function readLocalDatasetFileResponse(
+  rootEncoded: string,
+  rel: string,
+  request: Request,
+): Promise<Response> {
+  const root = resolveLocalDatasetRoot(rootEncoded);
+  if (!root) {
+    return Response.json({ error: "Invalid root" }, { status: 400 });
+  }
+
+  const fullPath = safePathUnderRoot(root, rel);
+  if (!fullPath) {
+    return Response.json({ error: "Invalid path" }, { status: 400 });
+  }
+
+  let stat;
+  try {
+    stat = await fs.stat(fullPath);
+  } catch {
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+
+  if (!stat.isFile()) {
+    return Response.json({ error: "Not a file" }, { status: 400 });
+  }
+
+  const size = stat.size;
+  const contentType = guessContentType(fullPath);
+  const range = parseBytesRange(request.headers.get("range"), size);
+
+  if (range && contentType.startsWith("video/")) {
+    const { start, end } = range;
+    const length = end - start + 1;
+    const fh = await fs.open(fullPath, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      await fh.read(buf, 0, length, start);
+      return new Response(new Uint8Array(buf), {
+        status: 206,
+        headers: {
+          "Content-Type": contentType,
+          "Content-Length": String(length),
+          "Content-Range": `bytes ${start}-${end}/${size}`,
+          "Accept-Ranges": "bytes",
+        },
+      });
+    } finally {
+      await fh.close();
+    }
+  }
+
+  const body = await fs.readFile(fullPath);
+  return new Response(new Uint8Array(body), {
+    status: 200,
+    headers: {
+      "Content-Type": contentType,
+      "Content-Length": String(size),
+      "Accept-Ranges": "bytes",
+    },
+  });
+}

src/utils/__tests__/localDataset.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import {
+  decodeLocalDatasetSegment,
+  encodeLocalDatasetRoot,
+  isLocalRepoId,
+  localDatasetFileApiPath,
+  localRepoIdFromAbsolutePath,
+  looksLikeAbsoluteFilesystemPath,
+  normalizeUserLocalPathInput,
+  tryParseLocalDatasetFileApiUrl,
+} from "@/utils/localDataset";
+
+describe("localDataset", () => {
+  test("encode/decode round trip for unix path", () => {
+    const p = "/tmp/aic_lerobot";
+    const enc = encodeLocalDatasetRoot(p);
+    expect(decodeLocalDatasetSegment(enc)).toBe(p);
+  });
+
+  test("localRepoIdFromAbsolutePath and isLocalRepoId", () => {
+    const id = localRepoIdFromAbsolutePath("/data/foo");
+    expect(isLocalRepoId(id)).toBe(true);
+    expect(isLocalRepoId("lerobot/pusht")).toBe(false);
+  });
+
+  test("looksLikeAbsoluteFilesystemPath", () => {
+    expect(looksLikeAbsoluteFilesystemPath("/tmp/x")).toBe(true);
+    expect(looksLikeAbsoluteFilesystemPath("file:///tmp/x")).toBe(true);
+    expect(looksLikeAbsoluteFilesystemPath("C:\\data\\x")).toBe(true);
+    expect(looksLikeAbsoluteFilesystemPath("lerobot/foo")).toBe(false);
+  });
+
+  test("normalizeUserLocalPathInput strips file://", () => {
+    expect(normalizeUserLocalPathInput("file:///tmp/a")).toBe("/tmp/a");
+  });
+
+  test("localDatasetFileApiPath builds query string", () => {
+    const q = localDatasetFileApiPath("abc", "meta/info.json");
+    expect(q).toContain("/api/local-dataset/file?");
+    expect(q).toContain("root=abc");
+    expect(q).toContain("rel=");
+  });
+
+  test("tryParseLocalDatasetFileApiUrl", () => {
+    const u =
+      "http://127.0.0.1:3000/api/local-dataset/file?root=x&rel=meta%2Finfo.json";
+    expect(tryParseLocalDatasetFileApiUrl(u)).toEqual({
+      rootEncoded: "x",
+      relPath: "meta/info.json",
+    });
+    expect(
+      tryParseLocalDatasetFileApiUrl(
+        "/api/local-dataset/file?root=y&rel=data%2F0.parquet",
+      ),
+    ).toEqual({ rootEncoded: "y", relPath: "data/0.parquet" });
+  });
+});

src/utils/__tests__/versionUtils.test.ts

@@ -55,6 +55,14 @@ describe("buildVersionedUrl", () => {
       "https://huggingface.co/datasets/myorg/mydataset/resolve/main/meta/info.json",
     );
   });
+
+  test("builds local API URL for dataset files", () => {
+    const url = buildVersionedUrl("local/abc123", "v3.0", "meta/info.json");
+    expect(url.startsWith("/api/local-dataset/file?")).toBe(true);
+    const params = new URLSearchParams(url.split("?")[1]!);
+    expect(params.get("root")).toBe("abc123");
+    expect(params.get("rel")).toBe("meta/info.json");
+  });
 });
 
 // ---------------------------------------------------------------------------

src/utils/internalFetch.ts

@@ -0,0 +1,12 @@
+/**
+ * Server-side code (e.g. server actions) cannot use relative fetch URLs; prefix with the app origin.
+ */
+export function resolveInternalFetchUrl(url: string): string {
+  if (typeof window !== "undefined") return url;
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  if (!url.startsWith("/")) return url;
+  const base =
+    process.env.NEXT_PUBLIC_APP_URL?.replace(/\/$/, "") ??
+    `http://127.0.0.1:${process.env.PORT ?? "3000"}`;
+  return `${base}${url}`;
+}

src/utils/localDataset.ts

@@ -0,0 +1,116 @@
+/**
+ * Local LeRobot dataset roots (absolute filesystem paths) are encoded in URLs as
+ * `/local/<base64url(utf8 path)>/episode_0`. File bytes are served via
+ * `/api/local-dataset/file?root=...&rel=...`.
+ */
+
+export const LOCAL_ORG = "local";
+export const LOCAL_REPO_PREFIX = `${LOCAL_ORG}/`;
+
+function utf8ToBase64Url(s: string): string {
+  const bytes = new TextEncoder().encode(s);
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) {
+    bin += String.fromCharCode(bytes[i]!);
+  }
+  const b64 =
+    typeof btoa !== "undefined"
+      ? btoa(bin)
+      : Buffer.from(bytes).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function base64UrlToUtf8(s: string): string {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - (s.length % 4));
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  let bin: string;
+  if (typeof atob !== "undefined") {
+    bin = atob(b64);
+  } else {
+    bin = Buffer.from(b64, "base64").toString("binary");
+  }
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) {
+    bytes[i] = bin.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+export function normalizeUserLocalPathInput(input: string): string {
+  const t = input.trim();
+  if (t.startsWith("file://")) {
+    try {
+      const u = new URL(t);
+      return decodeURIComponent(u.pathname);
+    } catch {
+      return t;
+    }
+  }
+  return t;
+}
+
+export function looksLikeAbsoluteFilesystemPath(input: string): boolean {
+  const t = normalizeUserLocalPathInput(input);
+  if (!t) return false;
+  if (t.startsWith("/")) return true;
+  return /^[A-Za-z]:[\\/]/.test(t);
+}
+
+export function encodeLocalDatasetRoot(absolutePath: string): string {
+  return utf8ToBase64Url(absolutePath);
+}
+
+export function decodeLocalDatasetSegment(
+  encodedSegment: string,
+): string | null {
+  if (!encodedSegment) return null;
+  try {
+    return base64UrlToUtf8(encodedSegment);
+  } catch {
+    return null;
+  }
+}
+
+export function localRepoIdFromAbsolutePath(absolutePath: string): string {
+  return `${LOCAL_REPO_PREFIX}${encodeLocalDatasetRoot(absolutePath)}`;
+}
+
+export function isLocalRepoId(repoId: string): boolean {
+  return (
+    repoId.startsWith(LOCAL_REPO_PREFIX) &&
+    repoId.length > LOCAL_REPO_PREFIX.length
+  );
+}
+
+export function localDatasetFileApiPath(
+  rootEncoded: string,
+  relPath: string,
+): string {
+  const q = new URLSearchParams({
+    root: rootEncoded,
+    rel: relPath,
+  });
+  return `/api/local-dataset/file?${q.toString()}`;
+}
+
+/** Parse our local file API URL (absolute or relative) for server-side fs shortcut. */
+export function tryParseLocalDatasetFileApiUrl(
+  url: string,
+): { rootEncoded: string; relPath: string } | null {
+  const marker = "/api/local-dataset/file";
+  const idx = url.indexOf(marker);
+  if (idx === -1) return null;
+  const after = url.slice(idx + marker.length);
+  const queryStart = after.indexOf("?");
+  if (queryStart === -1) return null;
+  const search = after.slice(queryStart + 1);
+  try {
+    const params = new URLSearchParams(search);
+    const root = params.get("root");
+    const rel = params.get("rel");
+    if (!root || !rel) return null;
+    return { rootEncoded: root, relPath: rel };
+  } catch {
+    return null;
+  }
+}

src/utils/parquetUtils.ts

@@ -5,6 +5,7 @@ import {
   parquetReadObjects,
   type AsyncBuffer,
 } from "hyparquet";
+import { resolveInternalFetchUrl } from "@/utils/internalFetch";
 
 export interface DatasetMetadata {
   codebase_version: string;
@@ -56,8 +57,9 @@ export async function fetchParquetFile(url: string): Promise<ParquetFile> {
   const cached = parquetFileCache.get(url);
   if (cached) return cached;
 
+  const fetchUrl = resolveInternalFetchUrl(url);
   const file = await asyncBufferFromUrl({
-    url,
+    url: fetchUrl,
     requestInit: { cache: "no-store" },
   });
   const wrapped = cachedAsyncBuffer(file);

src/utils/versionUtils.ts

@@ -2,6 +2,13 @@
  * Utility functions for checking dataset version compatibility
  */
 
+import {
+  isLocalRepoId,
+  localDatasetFileApiPath,
+  LOCAL_REPO_PREFIX,
+} from "@/utils/localDataset";
+import { resolveInternalFetchUrl } from "@/utils/internalFetch";
+
 const DATASET_URL =
   process.env.DATASET_URL || "https://huggingface.co/datasets";
 
@@ -73,16 +80,26 @@ export async function getDatasetInfo(repoId: string): Promise<DatasetInfo> {
   console.log(`[perf] getDatasetInfo cache MISS for ${repoId} — fetching`);
 
   try {
-    const testUrl = `${DATASET_URL}/${repoId}/resolve/main/meta/info.json`;
-
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000);
 
-    const response = await fetch(testUrl, {
-      method: "GET",
-      cache: "no-store",
-      signal: controller.signal,
-    });
+    let response: Response;
+    if (isLocalRepoId(repoId)) {
+      const rootEncoded = repoId.slice(LOCAL_REPO_PREFIX.length);
+      const localUrl = localDatasetFileApiPath(rootEncoded, "meta/info.json");
+      response = await fetch(resolveInternalFetchUrl(localUrl), {
+        method: "GET",
+        cache: "no-store",
+        signal: controller.signal,
+      });
+    } else {
+      const testUrl = `${DATASET_URL}/${repoId}/resolve/main/meta/info.json`;
+      response = await fetch(testUrl, {
+        method: "GET",
+        cache: "no-store",
+        signal: controller.signal,
+      });
+    }
 
     clearTimeout(timeoutId);
 
@@ -149,5 +166,9 @@ export function buildVersionedUrl(
   version: string,
   path: string,
 ): string {
+  if (isLocalRepoId(repoId)) {
+    const rootEncoded = repoId.slice(LOCAL_REPO_PREFIX.length);
+    return localDatasetFileApiPath(rootEncoded, path);
+  }
   return `${DATASET_URL}/${repoId}/resolve/main/${path}`;
 }