veryfront 0.1.128 → 0.1.129

package/src/src/tool/types.ts

@@ -111,20 +111,3 @@ export interface ToolDefinition {
   description: string;
   parameters: JsonSchema;
 }
-
-/**
- * Tool registry entry
- */
-interface ToolRegistryEntry {
-  /** Tool ID */
-  id: string;
-
-  /** Tool instance */
-  tool: Tool;
-
-  /** File path where tool was defined */
-  filePath?: string;
-
-  /** Auto-discovered */
-  autoDiscovered: boolean;
-}

package/src/src/transforms/esm/package-registry.ts

@@ -18,6 +18,14 @@ import {
 // Re-export constants from unified source
 export { CSSTYPE_VERSION, DEFAULT_REACT_VERSION, TAILWIND_VERSION };
 
+interface CachedDependencyVersions {
+  mtimeMs: number | null;
+  react?: string;
+  veryfront?: string;
+}
+
+const dependencyVersionCache = new Map<string, CachedDependencyVersions>();
+
 /**
  * Validate React version format (semver: X.Y.Z).
  */
@@ -88,8 +96,48 @@ export function stripSemverRange(version: string): string {
  * Compatibility no-op. Kept for tests and older call sites.
  */
 export function clearReactVersionCache(): void {
-  // Intentionally empty: resolveProjectReactVersion reads package.json per call
-  // to avoid stale version values in long-lived processes.
+  dependencyVersionCache.clear();
+}
+
+function getPackageJsonPath(projectDir: string): string {
+  return `${projectDir}/package.json`;
+}
+
+function getMtimeMs(mtime: Date | null | undefined): number | null {
+  return mtime instanceof Date ? mtime.getTime() : null;
+}
+
+export async function readProjectDependencyVersions(
+  projectDir: string,
+): Promise<{ react?: string; veryfront?: string }> {
+  const packageJsonPath = getPackageJsonPath(projectDir);
+
+  try {
+    const { createFileSystem } = await import("../../platform/compat/fs.js");
+    const fs = createFileSystem();
+    const stat = await fs.stat(packageJsonPath);
+    const mtimeMs = getMtimeMs(stat.mtime);
+    const cached = dependencyVersionCache.get(packageJsonPath);
+
+    if (cached && cached.mtimeMs === mtimeMs) {
+      return { react: cached.react, veryfront: cached.veryfront };
+    }
+
+    const content = await fs.readTextFile(packageJsonPath);
+    const pkg = JSON.parse(content) as {
+      dependencies?: Record<string, string>;
+      devDependencies?: Record<string, string>;
+    };
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const react = deps.react ? normalizeReactVersion(stripSemverRange(deps.react)) : undefined;
+    const veryfront = deps.veryfront ? stripSemverRange(deps.veryfront) : undefined;
+
+    dependencyVersionCache.set(packageJsonPath, { mtimeMs, react, veryfront });
+
+    return { react, veryfront };
+  } catch (_) {
+    return {};
+  }
 }
 
 /**
@@ -119,24 +167,8 @@ export async function resolveProjectReactVersion(options: {
 
   // 2. Detect from package.json
   if (projectDir) {
-    try {
-      const { createFileSystem } = await import("../../platform/compat/fs.js");
-      const fs = createFileSystem();
-      const content = await fs.readTextFile(`${projectDir}/package.json`);
-      const pkg = JSON.parse(content) as {
-        dependencies?: Record<string, string>;
-        devDependencies?: Record<string, string>;
-      };
-
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      const rawVersion = deps.react;
-      if (rawVersion) {
-        const stripped = stripSemverRange(rawVersion);
-        return normalizeReactVersion(stripped);
-      }
-    } catch (_) {
-      /* expected: package.json may not exist or be unreadable */
-    }
+    const detected = await readProjectDependencyVersions(projectDir);
+    if (detected.react) return detected.react;
   }
 
   // 3. Fallback to default

package/src/src/transforms/import-rewriter/strategies/veryfront-strategy.ts

@@ -54,7 +54,8 @@ export class VeryfrontStrategy implements ImportRewriteStrategy {
     // Handle #veryfront/* (internal framework imports)
     if (specifier.startsWith("#veryfront/")) {
       const path = specifier.slice("#veryfront/".length);
-      // Try resolving via deno.json mappings first (veryfront/head → react/components/Head.js)
+      // Try resolving via deno.json mappings first (for example,
+      // veryfront/head → react/runtime/core.js).
       const mapped = resolveVeryfrontModuleUrl(`veryfront/${path}`);
       if (mapped) {
         if (ctx.target === "ssr") return { specifier: `${mapped}?ssr=true` };

package/src/src/transforms/mdx/esm-module-loader/cache-format.ts

@@ -2,12 +2,35 @@ import { hashCodeHex } from "../../../utils/hash-utils.js";
 import { createCacheNamespace } from "../../../utils/cache-namespace.js";
 import { REACT_DEFAULT_VERSION } from "../../../utils/constants/cdn.js";
 import { VERSION } from "../../../utils/version.js";
+import {
+  resolveVeryfrontModuleTarget,
+  resolveVeryfrontModuleUrl,
+} from "../../veryfront-module-urls.js";
 import { UNRESOLVED_VF_MODULES_PATTERN } from "./constants.js";
 import { hashString } from "./utils/hash.js";
 
 const ALL_FILE_URL_PATTERN_SOURCE = /file:\/\/([^"'\s]+)/.source;
 const MJS_FILE_URL_PATTERN_SOURCE = /file:\/\/([^"'\s]+\.mjs)/.source;
 const CACHE_NAMESPACE_SENTINEL = "__vf_cache_namespace__";
+const PUBLIC_RUNTIME_SPECIFIERS = [
+  "veryfront/head",
+  "veryfront/router",
+  "veryfront/context",
+] as const;
+
+function buildPublicRuntimeAliasSchema(
+  overrides?: Partial<Record<(typeof PUBLIC_RUNTIME_SPECIFIERS)[number], string>>,
+) {
+  return Object.fromEntries(
+    PUBLIC_RUNTIME_SPECIFIERS.map((specifier) => [
+      specifier,
+      {
+        target: overrides?.[specifier] ?? resolveVeryfrontModuleTarget(specifier),
+        url: resolveVeryfrontModuleUrl(specifier),
+      },
+    ]),
+  );
+}
 
 function formatMdxEsmTransformCacheKey(
   namespace: string,
@@ -84,6 +107,11 @@ function buildMdxEsmCacheSchemaSample() {
       hashString("_vf_modules/pages/index.jsexport default 1;"),
       hashString("/tmp/project/Button.tsx"),
     ],
+    publicRuntimeAliases: buildPublicRuntimeAliasSchema({
+      "veryfront/head": "./src/react/runtime/core.ts",
+      "veryfront/router": "./src/react/runtime/core.ts",
+      "veryfront/context": "./src/react/runtime/core.ts",
+    }),
     frameworkVersion: VERSION,
   };
 }
@@ -92,10 +120,15 @@ function buildFrameworkVfModuleCacheSchemaSample() {
   return {
     moduleFile: formatFrameworkVfModuleCacheFileName(
       CACHE_NAMESPACE_SENTINEL,
-      hashCodeHex("_vf_modules/_veryfront/react/components/Head.js"),
+      hashCodeHex("/_vf_modules/_veryfront/react/runtime/core.js"),
       hashCodeHex("/app/.cache/veryfront-mdx-esm").slice(0, 8),
       hashCodeHex("export default function Head() {}"),
     ),
+    publicRuntimeAliases: buildPublicRuntimeAliasSchema({
+      "veryfront/head": "./src/react/runtime/core.ts",
+      "veryfront/router": "./src/react/runtime/core.ts",
+      "veryfront/context": "./src/react/runtime/core.ts",
+    }),
   };
 }
 

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/index.ts

@@ -37,7 +37,7 @@ import { cacheModule, normalizePath } from "./module-cache.js";
 
 // Re-export extracted modules for backward compatibility
 export { rewriteDntImports } from "./import-rewriter.js";
-export { endRenderSession, startRenderSession } from "./render-sessions.js";
+export { endRenderSession, hasRenderSession, startRenderSession } from "./render-sessions.js";
 
 /**
  * Maximum time allowed for the entire transform tree (recursive module resolution).

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/render-sessions.ts

@@ -76,6 +76,10 @@ export function endRenderSession(sessionId: string): void {
   renderSessions.delete(sessionId);
 }
 
+export function hasRenderSession(sessionId: string): boolean {
+  return renderSessions.has(sessionId);
+}
+
 /**
  * Get the current active render session (if any).
  * Used to record modules during fetch and for per-session in-flight deduplication.

package/src/src/transforms/pipeline/stages/ssr-vf-modules/index.ts

@@ -1,7 +1,7 @@
 /**
  * SSR VF Modules Stage - resolves /_vf_modules/_veryfront/ paths to framework source.
  *
- * The SSR import map rewrites "veryfront/head" -> "/_vf_modules/_veryfront/react/components/Head.js?ssr=true"
+ * The SSR import map rewrites "veryfront/head" -> "/_vf_modules/_veryfront/react/runtime/core.js?ssr=true"
  * This stage resolves those paths to actual framework source files, transforms them
  * (including React import rewriting), and rewrites imports to file:// paths.
  *

package/src/src/transforms/veryfront-module-urls.ts

@@ -39,6 +39,7 @@ function addMapping(
   index: ModuleTargetIndex,
   specifier: string,
   target: string,
+  options?: { preserveExistingExact?: boolean },
 ): void {
   if (!target.startsWith(SRC_PREFIX)) return;
 
@@ -50,6 +51,7 @@ function addMapping(
     return;
   }
 
+  if (options?.preserveExistingExact && index.exactTargets.has(specifier)) return;
   index.exactTargets.set(specifier, target);
 }
 
@@ -91,12 +93,14 @@ for (const [key, target] of Object.entries(config.exports ?? {})) {
   if (typeof target !== "string") continue;
 
   if (key === ".") {
-    addMapping(veryfrontTargetIndex, "veryfront", target);
+    addMapping(veryfrontTargetIndex, "veryfront", target, { preserveExistingExact: true });
     continue;
   }
 
   if (!key.startsWith("./")) continue;
-  addMapping(veryfrontTargetIndex, `veryfront/${key.slice(2)}`, target);
+  addMapping(veryfrontTargetIndex, `veryfront/${key.slice(2)}`, target, {
+    preserveExistingExact: true,
+  });
 }
 
 finalizeIndex(veryfrontTargetIndex);

package/src/src/types/entities/getEntityInfo.ts

@@ -16,6 +16,12 @@ const logger = baseLogger.component("get-entity-by-slug");
 
 const entityInfoScope = createErrorScope("getEntityInfo");
 const fs = createFileSystem();
+const PAGE_FILE_EXTENSIONS = ["mdx", "md", "tsx", "jsx", "ts"] as const;
+const DIRECT_ROUTE_EXTENSIONS = ["mdx", "md", "tsx", "ts"] as const;
+const LAYOUT_FILE_EXTENSIONS = ["mdx", "md", "tsx", "jsx", "ts", "js"] as const;
+const DYNAMIC_PAGE_ENTRY_PATTERN = /\[.+\]\.(mdx|md|tsx|jsx|ts|js)$/;
+
+type DirectoryEntry = { name: string; isFile: boolean; isDirectory: boolean };
 
 export async function getEntityInfo(
   filePath: string,
@@ -204,7 +210,7 @@ export async function getEntityBySlug(
           basePaths,
         });
 
-        const pathResults = await parallelMap(basePaths, async (basePath) => {
+        const candidateResults = await parallelMap(basePaths, async (basePath) => {
           const resolvedPath = await resolveFile.call(adapter.fs, basePath);
           logger.debug("resolveFile result", {
             basePath,
@@ -214,7 +220,7 @@ export async function getEntityBySlug(
           return await getEntityInfo(resolvedPath, adapter);
         });
 
-        for (const info of pathResults) {
+        for (const info of candidateResults) {
           if (info?.entity.isPage) {
             logger.debug("Found page via resolveFile", {
               slug,
@@ -225,147 +231,44 @@ export async function getEntityBySlug(
           }
         }
 
-        const slugParts = normalizedSlug === "" ? [] : normalizedSlug.split("/");
-        for (let depth = slugParts.length - 1; depth >= 0; depth--) {
-          const parentPath = slugParts.slice(0, depth).join("/");
-          const pagesDir = parentPath
-            ? pathHelper.join(projectDir, "pages", parentPath)
-            : pathHelper.join(projectDir, "pages");
-
-          try {
-            let dirExists = false;
-            try {
-              const stat = await withFallback(
-                () => adapter.fs.stat(pagesDir),
-                () => fs.stat(pagesDir),
-                { operationName: "stat:getEntityBySlug", logError: false },
-              );
-              dirExists = stat.isDirectory;
-            } catch (_) {
-              /* expected: stat may fail for non-existent directories */
-              dirExists = false;
-            }
-
-            if (!dirExists) continue;
-
-            const entries: { name: string; isFile: boolean; isDirectory: boolean }[] = [];
-            for await (const entry of adapter.fs.readDir(pagesDir)) {
-              entries.push(entry);
-            }
-
-            const dynamicEntries = entries.filter(
-              (entry) => entry.isFile && /\[.+\]\.(mdx|md|tsx|jsx|ts|js)$/.test(entry.name),
-            );
-
-            const dynamicResults = await parallelMap(dynamicEntries, async (entry) => {
-              const dynamicPath = pathHelper.join(pagesDir, entry.name);
-              return await getEntityInfo(dynamicPath, adapter);
-            });
-
-            for (const info of dynamicResults) {
-              if (info?.entity.isPage) return info;
-            }
-          } catch (_) {
-            /* expected: directory may not exist or readDir may fail */
-          }
-        }
+        const dynamicPage = await findDynamicPageEntity(projectDir, normalizedSlug, adapter);
+        if (dynamicPage) return dynamicPage;
 
         logger.debug("No page found via resolveFile branch", { slug, normalizedSlug });
         return null;
       }
 
-      const possiblePaths = [
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}.mdx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}.md`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}.tsx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}.jsx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}.ts`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.mdx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.md`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.tsx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.jsx`),
-        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.ts`),
+      const candidatePaths = [
+        ...buildFileCandidates(projectDir, ["pages"], normalizedSlug, PAGE_FILE_EXTENSIONS),
+        ...buildFileCandidates(
+          projectDir,
+          ["pages"],
+          `${normalizedSlug}/index`,
+          PAGE_FILE_EXTENSIONS,
+        ),
       ];
 
       if (isVeryfrontRoute) {
-        possiblePaths.unshift(
-          pathHelper.join(projectDir, `${normalizedSlug}.mdx`),
-          pathHelper.join(projectDir, `${normalizedSlug}.md`),
-          pathHelper.join(projectDir, `${normalizedSlug}.tsx`),
-          pathHelper.join(projectDir, `${normalizedSlug}.ts`),
+        candidatePaths.unshift(
+          ...buildFileCandidates(projectDir, [], normalizedSlug, DIRECT_ROUTE_EXTENSIONS),
         );
       }
 
       if (normalizedSlug === "index" || normalizedSlug === "") {
-        possiblePaths.unshift(
-          pathHelper.join(projectDir, "pages", "index.mdx"),
-          pathHelper.join(projectDir, "pages", "index.md"),
-          pathHelper.join(projectDir, "pages", "index.tsx"),
-          pathHelper.join(projectDir, "pages", "index.ts"),
+        candidatePaths.unshift(
+          ...buildFileCandidates(projectDir, ["pages"], "index", DIRECT_ROUTE_EXTENSIONS),
         );
       }
 
-      const pathResults = await parallelMap(possiblePaths, async (p) => {
-        return await getEntityInfo(p, adapter);
+      const candidateResults = await parallelMap(candidatePaths, async (candidatePath) => {
+        return await getEntityInfo(candidatePath, adapter);
       });
 
-      for (const info of pathResults) {
+      for (const info of candidateResults) {
         if (info?.entity.isPage) return info;
       }
 
-      const slugParts = normalizedSlug === "" ? [] : normalizedSlug.split("/");
-      for (let depth = slugParts.length - 1; depth >= 0; depth--) {
-        const parentPath = slugParts.slice(0, depth).join("/");
-        const pagesDir = parentPath
-          ? pathHelper.join(projectDir, "pages", parentPath)
-          : pathHelper.join(projectDir, "pages");
-
-        try {
-          let dirExists = false;
-          if (adapter) {
-            try {
-              const stat = await withFallback(
-                () => adapter.fs.stat(pagesDir),
-                () => fs.stat(pagesDir),
-                { operationName: "stat:getEntityBySlug", logError: false },
-              );
-              dirExists = stat.isDirectory;
-            } catch (_) {
-              /* expected: stat may fail for non-existent directories */
-              dirExists = false;
-            }
-          } else {
-            dirExists = await fs.exists(pagesDir);
-          }
-
-          if (!dirExists) continue;
-
-          const entries: { name: string; isFile: boolean; isDirectory: boolean }[] = [];
-          const dirIterator = adapter?.fs.readDir
-            ? adapter.fs.readDir(pagesDir)
-            : fs.readDir(pagesDir);
-          for await (const entry of dirIterator) {
-            entries.push(entry);
-          }
-
-          const dynamicEntries = entries.filter(
-            (entry) => entry.isFile && /\[.+\]\.(mdx|md|tsx|jsx|ts|js)$/.test(entry.name),
-          );
-
-          const dynamicResults = await parallelMap(dynamicEntries, async (entry) => {
-            const dynamicPath = pathHelper.join(pagesDir, entry.name);
-            return await getEntityInfo(dynamicPath, adapter);
-          });
-
-          for (const info of dynamicResults) {
-            if (info?.entity.isPage) return info;
-          }
-        } catch (_) {
-          /* expected: directory may not exist or readDir may fail */
-        }
-      }
-
-      return null;
+      return await findDynamicPageEntity(projectDir, normalizedSlug, adapter);
     },
     {
       "entity.slug": slug,
@@ -399,43 +302,38 @@ export async function getLayoutEntity(
       }
 
       // Files in layouts/ are treated as layouts by convention (any extension)
-      const layoutsDirPaths = [
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.mdx`),
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.md`),
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.tsx`),
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.jsx`),
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.ts`),
-        pathHelper.join(projectDir, "layouts", `${resolvedLayoutName}.js`),
-      ];
+      const layoutCandidatePaths = buildFileCandidates(
+        projectDir,
+        ["layouts"],
+        resolvedLayoutName,
+        LAYOUT_FILE_EXTENSIONS,
+      );
 
       // Files in components/ must be detected as layouts by name/frontmatter
-      const componentsPaths = [
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.mdx`),
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.md`),
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.tsx`),
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.jsx`),
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.ts`),
-        pathHelper.join(projectDir, "components", `${resolvedLayoutName}Layout.js`),
-        pathHelper.join(projectDir, "components", "Layout.mdx"),
-        pathHelper.join(projectDir, "components", "Layout.md"),
-        pathHelper.join(projectDir, "components", "Layout.tsx"),
-        pathHelper.join(projectDir, "components", "Layout.jsx"),
-        pathHelper.join(projectDir, "components", "Layout.ts"),
-        pathHelper.join(projectDir, "components", "Layout.js"),
+      const componentCandidatePaths = [
+        ...buildFileCandidates(
+          projectDir,
+          ["components"],
+          `${resolvedLayoutName}Layout`,
+          LAYOUT_FILE_EXTENSIONS,
+        ),
+        ...buildFileCandidates(projectDir, ["components"], "Layout", LAYOUT_FILE_EXTENSIONS),
       ];
 
-      const allPaths = [...layoutsDirPaths, ...componentsPaths];
-      const pathResults = await parallelMap(allPaths, async (p) => {
-        return await getEntityInfo(p, adapter);
-      });
+      const candidateResults = await parallelMap(
+        [...layoutCandidatePaths, ...componentCandidatePaths],
+        async (candidatePath) => {
+          return await getEntityInfo(candidatePath, adapter);
+        },
+      );
 
-      const layoutsDirCount = layoutsDirPaths.length;
-      for (let i = 0; i < pathResults.length; i++) {
-        const info = pathResults[i];
+      const layoutCandidateCount = layoutCandidatePaths.length;
+      for (let i = 0; i < candidateResults.length; i++) {
+        const info = candidateResults[i];
         if (!info) continue;
         // layouts/ dir: any valid entity is a layout
         // components/ dir: must be detected as layout by name/frontmatter
-        if (i < layoutsDirCount || info.entity.isLayout) {
+        if (i < layoutCandidateCount || info.entity.isLayout) {
           return {
             entity: {
               ...info.entity,
@@ -454,6 +352,87 @@ export async function getLayoutEntity(
   );
 }
 
+function buildFileCandidates(
+  projectDir: string,
+  segments: string[],
+  relativeStem: string,
+  extensions: readonly string[],
+): string[] {
+  return extensions.map((extension) =>
+    pathHelper.join(projectDir, ...segments, `${relativeStem}.${extension}`)
+  );
+}
+
+async function findDynamicPageEntity(
+  projectDir: string,
+  normalizedSlug: string,
+  adapter?: RuntimeAdapter,
+): Promise<EntityInfo | null> {
+  const slugParts = normalizedSlug === "" ? [] : normalizedSlug.split("/");
+  for (let depth = slugParts.length - 1; depth >= 0; depth--) {
+    const parentPath = slugParts.slice(0, depth).join("/");
+    const pagesDir = parentPath
+      ? pathHelper.join(projectDir, "pages", parentPath)
+      : pathHelper.join(projectDir, "pages");
+
+    try {
+      const canReadDirectory = await pagesDirectoryExists(pagesDir, adapter);
+      if (!canReadDirectory) continue;
+
+      const entries = await readDirectoryEntries(pagesDir, adapter);
+      const dynamicEntries = entries.filter(
+        (entry) => entry.isFile && DYNAMIC_PAGE_ENTRY_PATTERN.test(entry.name),
+      );
+
+      const candidateResults = await parallelMap(dynamicEntries, async (entry) => {
+        const candidatePath = pathHelper.join(pagesDir, entry.name);
+        return await getEntityInfo(candidatePath, adapter);
+      });
+
+      for (const info of candidateResults) {
+        if (info?.entity.isPage) return info;
+      }
+    } catch (_) {
+      /* expected: directory may not exist or readDir may fail */
+    }
+  }
+
+  return null;
+}
+
+async function pagesDirectoryExists(
+  pagesDir: string,
+  adapter?: RuntimeAdapter,
+): Promise<boolean> {
+  if (!adapter) return await fs.exists(pagesDir);
+
+  try {
+    const stat = await withFallback(
+      () => adapter.fs.stat(pagesDir),
+      () => fs.stat(pagesDir),
+      { operationName: "stat:getEntityBySlug", logError: false },
+    );
+    return stat.isDirectory;
+  } catch (_) {
+    /* expected: stat may fail for non-existent directories */
+    return false;
+  }
+}
+
+async function readDirectoryEntries(
+  pagesDir: string,
+  adapter?: RuntimeAdapter,
+): Promise<DirectoryEntry[]> {
+  const entries: DirectoryEntry[] = [];
+  const iterator = adapter?.fs.readDir ? adapter.fs.readDir(pagesDir) : fs.readDir(pagesDir);
+
+  for await (const entry of iterator) {
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
 function getSlugFromPath(filePath: string): string {
   const parts = filePath.split(pathHelper.sep);
   const fileName = parts[parts.length - 1] ?? "";

package/src/src/utils/path-utils.ts

@@ -1,4 +1,5 @@
 import { normalize } from "../platform/compat/path/index.js";
+import { base64urlEncode } from "./base64url.js";
 import { logger } from "./logger/logger.js";
 
 function stripTrailingSlash(pathname: string): string {
@@ -72,21 +73,29 @@ export function getEsbuildLoader(filePath: string): "tsx" | "jsx" | "ts" | "js"
 
 export { isAbsolute as isAbsolutePath } from "../platform/compat/path/index.js";
 
-export function toBase64Url(s: string): string {
-  return btoa(s).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+export function toBase64Url(input: string): string {
+  return base64urlEncode(input);
 }
 
-function getBase64Padding(length: number): string {
-  if (length % 4 === 2) return "==";
-  if (length % 4 === 3) return "=";
-  return "";
+function getRequiredBase64Padding(length: number): string | undefined {
+  const remainder = length % 4;
+  if (remainder === 0) return "";
+  if (remainder === 2) return "==";
+  if (remainder === 3) return "=";
+  return undefined;
 }
 
 export function fromBase64Url(encoded: string): string {
   const b64 = encoded.replaceAll("-", "+").replaceAll("_", "/");
+  const padding = getRequiredBase64Padding(b64.length);
+
+  if (padding === undefined) {
+    logger.debug(`Failed to decode base64url string "${encoded}": invalid length`);
+    return "";
+  }
 
   try {
-    return atob(b64 + getBase64Padding(b64.length));
+    return atob(b64 + padding);
   } catch (error) {
     logger.debug(`Failed to decode base64url string "${encoded}":`, error);
     return "";

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.128";
+export const VERSION = "0.1.129";

package/src/src/utils/version.ts

@@ -32,7 +32,6 @@ export const RUNTIME_VERSION = resolveRuntimeVersion({
   veryfrontVersion: getVersionEnv("VERYFRONT_VERSION"),
   releaseVersion: getVersionEnv("RELEASE_VERSION"),
   denoVersion: typeof denoConfig.version === "string" ? denoConfig.version : undefined,
-  fallbackVersion: VERSION,
 });
 
 export const SERVER_START_TIME: number = Date.now();