@agent-native/core 0.90.3 → 0.90.4

package/bin/agent-native.js

@@ -1,17 +1,39 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const binDir = dirname(fileURLToPath(import.meta.url));
 const distEntry = join(binDir, "../dist/cli/index.js");
+const sourceEntry = join(binDir, "../src/cli/index.ts");
+const freshnessChecks = [
+  [sourceEntry, distEntry],
+  [
+    join(binDir, "../src/cli/design-connect.ts"),
+    join(binDir, "../dist/cli/design-connect.js"),
+  ],
+];
 
-if (existsSync(distEntry)) {
+function shouldUseSourceFallback() {
+  if (!existsSync(sourceEntry)) return false;
+  if (!existsSync(distEntry)) return true;
+  try {
+    return freshnessChecks.some(
+      ([source, dist]) =>
+        existsSync(source) &&
+        existsSync(dist) &&
+        statSync(source).mtimeMs > statSync(dist).mtimeMs,
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (!shouldUseSourceFallback() && existsSync(distEntry)) {
   await import(pathToFileURL(distEntry).href);
 } else {
-  const sourceEntry = join(binDir, "../src/cli/index.ts");
   if (!existsSync(sourceEntry)) {
     console.error(
       "agent-native CLI build output is missing. Run `pnpm --filter @agent-native/core build` and try again.",

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2144
-- template files: 4806
+- template files: 4817

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @agent-native/core
 
+## 0.90.4
+
+### Patch Changes
+
+- 9f396bc: Fail closed for unregistered History/Review resource types, allocate unique version numbers atomically, verify resolve/consume update counts, and prefer server snapshots over client-supplied ones.
+- 9f396bc: Add live visual-edit bridge support for localhost apps so Design can render editable live iframes instead of static HTML snapshots.
+- 9f396bc: Expire sticky provider auth-failure markers, skip rejected deploy env keys during engine auto-detect, and clear failure markers from the legacy save-key path.
+- 9f396bc: Keep React Router build packages installed for scaffolded app builds and report missing build dependencies before spawning the CLI.
+
 ## 0.90.3
 
 ### Patch Changes

package/corpus/core/bin/agent-native.js

@@ -1,17 +1,39 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const binDir = dirname(fileURLToPath(import.meta.url));
 const distEntry = join(binDir, "../dist/cli/index.js");
+const sourceEntry = join(binDir, "../src/cli/index.ts");
+const freshnessChecks = [
+  [sourceEntry, distEntry],
+  [
+    join(binDir, "../src/cli/design-connect.ts"),
+    join(binDir, "../dist/cli/design-connect.js"),
+  ],
+];
 
-if (existsSync(distEntry)) {
+function shouldUseSourceFallback() {
+  if (!existsSync(sourceEntry)) return false;
+  if (!existsSync(distEntry)) return true;
+  try {
+    return freshnessChecks.some(
+      ([source, dist]) =>
+        existsSync(source) &&
+        existsSync(dist) &&
+        statSync(source).mtimeMs > statSync(dist).mtimeMs,
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (!shouldUseSourceFallback() && existsSync(distEntry)) {
   await import(pathToFileURL(distEntry).href);
 } else {
-  const sourceEntry = join(binDir, "../src/cli/index.ts");
   if (!existsSync(sourceEntry)) {
     console.error(
       "agent-native CLI build output is missing. Run `pnpm --filter @agent-native/core build` and try again.",

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.90.3",
+  "version": "0.90.4",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/engine/index.ts

@@ -25,6 +25,7 @@ export {
   getStoredModelForEngine,
   normalizeModelForEngine,
   detectEngineFromEnv,
+  detectEngineFromEnvForRequest,
   detectEngineFromUserSecrets,
   isAgentEngineSettingConfigured,
   isAgentEnginePackageInstalled,

package/corpus/core/src/agent/engine/registry.ts

@@ -156,6 +156,10 @@ function assertAgentEnginePackageInstalled(entry: AgentEngineEntry): void {
  * on the first pass, so an explicit provider key (ANTHROPIC_API_KEY etc.)
  * is picked instead. Builder is still used as the fallback when no other
  * provider key is set.
+ *
+ * This sync helper is for CLI/status callers that cannot await settings. Prefer
+ * {@link detectEngineFromEnvForRequest} at request time so sticky auth-failure
+ * markers can skip rejected deploy keys.
  */
 export function detectEngineFromEnv(): AgentEngineEntry | null {
   const preferByo = /^(1|true)$/i.test(
@@ -196,6 +200,59 @@ export function detectEngineFromEnv(): AgentEngineEntry | null {
   return null;
 }
 
+async function envKeyUsableForEntry(
+  entry: AgentEngineEntry,
+  key: string,
+): Promise<boolean> {
+  if (
+    !(
+      canUseDeployCredentialFallbackForRequest(key) &&
+      !!readDeployCredentialEnv(key)
+    )
+  ) {
+    return false;
+  }
+  if (entry.name === "builder") {
+    return true;
+  }
+  const value = readDeployCredentialEnv(key);
+  if (!value) return false;
+  return !(await getProviderCredentialAuthFailure({ key, value }));
+}
+
+async function hasUsableEnvKeys(entry: AgentEngineEntry): Promise<boolean> {
+  if (!isAgentEnginePackageInstalled(entry)) return false;
+  if (entry.requiredEnvVars.length === 0) return false;
+  for (const key of entry.requiredEnvVars) {
+    if (!(await envKeyUsableForEntry(entry, key))) return false;
+  }
+  return true;
+}
+
+/**
+ * Request-aware env auto-detect. Same priority as {@link detectEngineFromEnv},
+ * but skips provider keys that currently have an auth-failure marker so a
+ * rejected deploy key does not permanently win selection and leave chat stuck
+ * on `missing_credentials`.
+ */
+export async function detectEngineFromEnvForRequest(): Promise<AgentEngineEntry | null> {
+  const preferByo = /^(1|true)$/i.test(
+    process.env.AGENT_ENGINE_PREFER_BYO_KEY ?? "",
+  );
+
+  if (preferByo) {
+    for (const entry of _registry.values()) {
+      if (entry.name === "builder") continue;
+      if (await hasUsableEnvKeys(entry)) return entry;
+    }
+  }
+
+  for (const entry of _registry.values()) {
+    if (await hasUsableEnvKeys(entry)) return entry;
+  }
+  return null;
+}
+
 function shouldTraceEngineDetection(): boolean {
   return /^(1|true)$/i.test(
     process.env.AGENT_NATIVE_DEBUG_AGENT_ENGINE_DETECT ??
@@ -399,6 +456,9 @@ async function engineCreateConfigForEntry(
  * AND an API key for it is reachable via the engine's required env vars.
  * Inline keys on the global settings row are ignored; see
  * `isAgentEngineSettingConfigured`.
+ *
+ * Sync helper for CLI/status. Prefer {@link isStoredEngineUsableForRequest}
+ * so sticky auth-failure markers are respected.
  */
 export function isStoredEngineUsable(
   stored: unknown,
@@ -618,8 +678,9 @@ export async function resolveEngine(
   }
 
   // 8. Auto-detect from any provider env var — so just dropping a key in
-  // .env works without also setting AGENT_ENGINE.
-  const detected = detectEngineFromEnv();
+  // .env works without also setting AGENT_ENGINE. Skip keys with active
+  // auth-failure markers so a rejected deploy key cannot permanently win.
+  const detected = await detectEngineFromEnvForRequest();
   if (detected) {
     return detected.create(await engineCreateConfigForEntry(detected, apiKey));
   }

package/corpus/core/src/cli/create.ts

@@ -27,6 +27,12 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES: Record<string, string> = {
   "@react-router/fs-routes": "8.1.0",
   "react-router": "8.1.0",
 };
+const REACT_ROUTER_BUILD_DEPENDENCIES = [
+  "@react-router/dev",
+  "@react-router/fs-routes",
+  "react-router",
+  "vite",
+] as const;
 const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = ['"@sentry/*"'];
 const FIRST_PARTY_TARBALL_SYMLINK_EXCLUDES = [
   "*/CLAUDE.md",
@@ -1045,6 +1051,7 @@ function postProcessStandalone(
       // under pnpm 10+ without prompting for `pnpm approve-builds`.
       pkg.dependencies = pkg.dependencies ?? {};
       pkg.dependencies.postgres ??= POSTGRES_DEPENDENCY_VERSION;
+      ensureReactRouterBuildDependencies(pkg);
 
       const requiredBuilt = ["better-sqlite3", "esbuild", "node-pty"];
       if (!pkg.pnpm || typeof pkg.pnpm !== "object") {
@@ -1105,6 +1112,34 @@ function postProcessStandalone(
   setupAgentSymlinks(targetDir);
 }
 
+function ensureReactRouterBuildDependencies(pkg: Record<string, any>): void {
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+  };
+  if (
+    !allDeps["@react-router/dev"] &&
+    !allDeps["react-router"] &&
+    !allDeps["@react-router/fs-routes"]
+  ) {
+    return;
+  }
+
+  pkg.dependencies = pkg.dependencies ?? {};
+  for (const key of REACT_ROUTER_BUILD_DEPENDENCIES) {
+    const existing =
+      pkg.dependencies[key] ??
+      pkg.devDependencies?.[key] ??
+      pkg.peerDependencies?.[key];
+    if (!existing) continue;
+    pkg.dependencies[key] =
+      STANDALONE_EXACT_DEPENDENCY_OVERRIDES[key] ?? existing;
+    delete pkg.devDependencies?.[key];
+    delete pkg.peerDependencies?.[key];
+  }
+}
+
 function fixStandaloneTsconfig(targetDir: string, templateName?: string): void {
   const tsconfigPath = path.join(targetDir, "tsconfig.json");
   if (!fs.existsSync(tsconfigPath)) return;

package/corpus/core/src/cli/design-connect.ts

@@ -507,6 +507,47 @@ function sendJson(
   res.end(`${JSON.stringify(body, null, 2)}\n`);
 }
 
+function sendText(
+  res: ServerResponse,
+  statusCode: number,
+  body: string,
+  contentType: string,
+) {
+  res.writeHead(statusCode, {
+    "content-type": contentType,
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, POST, OPTIONS",
+    "access-control-allow-headers": "content-type, x-bridge-token",
+    "access-control-allow-private-network": "true",
+  });
+  res.end(body);
+}
+
+function sendBytes(
+  res: ServerResponse,
+  statusCode: number,
+  body: Buffer,
+  headers: Headers,
+) {
+  const responseHeaders: Record<string, string> = {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, HEAD, POST, OPTIONS",
+    "access-control-allow-headers": "content-type, x-bridge-token",
+    "access-control-allow-private-network": "true",
+  };
+  for (const name of [
+    "content-type",
+    "cache-control",
+    "etag",
+    "last-modified",
+  ]) {
+    const value = headers.get(name);
+    if (value) responseHeaders[name] = value;
+  }
+  res.writeHead(statusCode, responseHeaders);
+  res.end(body);
+}
+
 function sameOrigin(a: string, b: string): boolean {
   try {
     return new URL(a).origin === new URL(b).origin;
@@ -531,6 +572,23 @@ function resolvePreviewSnapshotUrl(
   return parsed.toString();
 }
 
+function resolvePreviewProxyUrl(
+  devServerUrl: string,
+  requestUrl: string | undefined,
+): string {
+  const base = normalizeHttpUrl(devServerUrl);
+  const parsedRequest = new URL(requestUrl ?? "/", base);
+  const parsed = new URL(
+    `${parsedRequest.pathname}${parsedRequest.search}`,
+    `${base}/`,
+  );
+  parsed.hash = "";
+  if (!sameOrigin(parsed.toString(), base)) {
+    throw new Error("Proxy URL must stay on the connected dev server.");
+  }
+  return parsed.toString();
+}
+
 async function fetchPreviewSnapshot(
   devServerUrl: string,
   targetUrl: string,
@@ -579,6 +637,79 @@ async function fetchPreviewSnapshot(
   }
 }
 
+async function fetchPreviewProxyResource(
+  devServerUrl: string,
+  targetUrl: string,
+  redirects = 0,
+): Promise<{
+  url: string;
+  status: number;
+  headers: Headers;
+  body: Buffer;
+}> {
+  if (redirects > 5) {
+    throw new Error("Too many redirects while proxying preview resource.");
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 10_000);
+  try {
+    const response = await fetch(targetUrl, {
+      method: "GET",
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    const location = response.headers.get("location");
+    if (location && response.status >= 300 && response.status < 400) {
+      const redirected = new URL(location, targetUrl);
+      redirected.hash = "";
+      if (!sameOrigin(redirected.toString(), devServerUrl)) {
+        throw new Error("Proxy redirect left the connected dev server.");
+      }
+      return fetchPreviewProxyResource(
+        devServerUrl,
+        redirected.toString(),
+        redirects + 1,
+      );
+    }
+    return {
+      url: response.url || targetUrl,
+      status: response.status,
+      headers: response.headers,
+      body: Buffer.from(await response.arrayBuffer()),
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function addLiveEditBaseHref(html: string, href: string): string {
+  const escapedHref = href.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  const baseTag = `<base href="${escapedHref}">`;
+  if (/<base\b/i.test(html)) return html;
+  if (/<head\b[^>]*>/i.test(html)) {
+    return html.replace(/<head\b[^>]*>/i, (match) => `${match}${baseTag}`);
+  }
+  if (/<html\b[^>]*>/i.test(html)) {
+    return html.replace(
+      /<html\b[^>]*>/i,
+      (match) => `${match}<head>${baseTag}</head>`,
+    );
+  }
+  return `<!DOCTYPE html><html><head>${baseTag}<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head><body>${html}</body></html>`;
+}
+
+function injectLiveEditBridge(html: string, targetUrl: string, script: string) {
+  const withBase = addLiveEditBaseHref(html, targetUrl);
+  if (!script) return withBase;
+  if (withBase.includes("</body>")) {
+    return withBase.replace("</body>", `${script}</body>`);
+  }
+  if (withBase.includes("</html>")) {
+    return withBase.replace("</html>", `${script}</html>`);
+  }
+  return `${withBase}${script}`;
+}
+
 /** Read the full request body as a UTF-8 string. */
 async function readRequestBody(req: IncomingMessage): Promise<string> {
   return new Promise<string>((resolve, reject) => {
@@ -1046,6 +1177,7 @@ export async function startDesignConnectBridge(
   // an unauthenticated caller cannot read it.  The server-side grant action
   // obtains it out-of-band (via the exported bridge reference).
   const bridgeToken = crypto.randomBytes(32).toString("hex");
+  let liveEditBridgeScript = "";
 
   const server = http.createServer(
     (req: IncomingMessage, res: ServerResponse) => {
@@ -1077,6 +1209,95 @@ export async function startDesignConnectBridge(
         sendJson(res, 200, { ok: true, source: manifest.source });
         return;
       }
+      if (pathname === "/live-edit-bridge") {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
+        const tokenHeader = req.headers["x-bridge-token"];
+        const providedToken =
+          typeof tokenHeader === "string" ? tokenHeader : "";
+        let tokenValid = false;
+        try {
+          tokenValid =
+            providedToken.length === bridgeToken.length &&
+            crypto.timingSafeEqual(
+              Buffer.from(providedToken, "utf8"),
+              Buffer.from(bridgeToken, "utf8"),
+            );
+        } catch {
+          tokenValid = false;
+        }
+        if (!tokenValid) {
+          sendJson(res, 401, {
+            ok: false,
+            error: "invalid or missing bridge token",
+          });
+          return;
+        }
+        void (async () => {
+          try {
+            const raw = await readRequestBody(req);
+            const body = JSON.parse(raw) as Record<string, unknown>;
+            const script =
+              typeof body["script"] === "string" ? body["script"] : "";
+            if (!script.includes("agent-native:editor-chrome-ready")) {
+              sendJson(res, 400, {
+                ok: false,
+                error: "script must install the Agent Native editor bridge",
+              });
+              return;
+            }
+            liveEditBridgeScript = script;
+            sendJson(res, 200, { ok: true });
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
+      if (pathname === "/live-edit") {
+        if (req.method !== "GET") {
+          sendJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
+        void (async () => {
+          try {
+            const requestUrl = new URL(req.url ?? "/", manifest.bridgeUrl);
+            const targetUrl = resolvePreviewSnapshotUrl(
+              manifest.devServerUrl,
+              requestUrl.searchParams.get("url") ??
+                requestUrl.searchParams.get("path"),
+            );
+            const snapshot = await fetchPreviewSnapshot(
+              manifest.devServerUrl,
+              targetUrl,
+            );
+            const html = injectLiveEditBridge(
+              snapshot.html,
+              new URL("/", manifest.bridgeUrl).toString(),
+              liveEditBridgeScript,
+            );
+            sendText(
+              res,
+              snapshot.status >= 400 ? snapshot.status : 200,
+              html,
+              snapshot.contentType.includes("html")
+                ? snapshot.contentType
+                : "text/html; charset=utf-8",
+            );
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
       if (pathname === "/snapshot") {
         if (req.method !== "GET") {
           sendJson(res, 405, { ok: false, error: "method not allowed" });
@@ -1356,6 +1577,33 @@ export async function startDesignConnectBridge(
         return;
       }
 
+      if (req.method === "GET" || req.method === "HEAD") {
+        void (async () => {
+          try {
+            const targetUrl = resolvePreviewProxyUrl(
+              manifest.devServerUrl,
+              req.url,
+            );
+            const proxied = await fetchPreviewProxyResource(
+              manifest.devServerUrl,
+              targetUrl,
+            );
+            sendBytes(
+              res,
+              proxied.status >= 400 ? proxied.status : 200,
+              req.method === "HEAD" ? Buffer.alloc(0) : proxied.body,
+              proxied.headers,
+            );
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
+
       sendJson(res, 404, { ok: false, error: "not found" });
     },
   );

package/corpus/core/src/cli/index.ts

@@ -2,6 +2,7 @@
 
 import { execSync, spawn } from "child_process";
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
 
@@ -253,11 +254,20 @@ function handleScaffoldImportError(err: any): never {
   throw err;
 }
 
+function findBinUpwards(binName: string): string | undefined {
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    const candidate = path.join(dir, "node_modules", ".bin", binName);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
 function findViteBin(): string {
-  // Look for vite in node_modules/.bin
-  const localVite = path.resolve("node_modules/.bin/vite");
-  if (fs.existsSync(localVite)) return localVite;
-  return "vite"; // fallback to PATH
+  return findBinUpwards("vite") ?? "vite";
 }
 
 function findTsxBin(): string {
@@ -277,9 +287,7 @@ function findTypeScriptCompilerBin(): string {
 }
 
 function findReactRouterBin(): string {
-  const localBin = path.resolve("node_modules/.bin/react-router");
-  if (fs.existsSync(localBin)) return localBin;
-  return "react-router";
+  return findBinUpwards("react-router") ?? "react-router";
 }
 
 /** Check if the project uses React Router framework mode (has react-router.config.ts) */
@@ -290,6 +298,73 @@ function isReactRouterFramework(): boolean {
   );
 }
 
+function canResolveFromProject(specifier: string): boolean {
+  try {
+    const requireFromProject = createRequire(path.resolve("package.json"));
+    requireFromProject.resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function projectUsesFsRoutes(): boolean {
+  for (const file of [
+    path.resolve("app/routes.ts"),
+    path.resolve("app/routes.tsx"),
+    path.resolve("routes.ts"),
+    path.resolve("routes.tsx"),
+  ]) {
+    try {
+      if (
+        fs.existsSync(file) &&
+        fs.readFileSync(file, "utf-8").includes("@react-router/fs-routes")
+      ) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+
+function validateReactRouterBuildDependencies(): void {
+  const required: Array<[packageName: string, specifier: string]> = [
+    ["react-router", "react-router"],
+    ["@react-router/dev", "@react-router/dev/vite"],
+    ["vite", "vite"],
+  ];
+  if (projectUsesFsRoutes()) {
+    required.push(["@react-router/fs-routes", "@react-router/fs-routes"]);
+  }
+
+  const missing = required
+    .filter(([, specifier]) => !canResolveFromProject(specifier))
+    .map(([packageName]) => packageName);
+
+  if (missing.length === 0) return;
+
+  const packageManager = fs.existsSync(path.resolve("pnpm-lock.yaml"))
+    ? "pnpm"
+    : fs.existsSync(path.resolve("yarn.lock"))
+      ? "yarn"
+      : "npm";
+  const installCommand =
+    packageManager === "pnpm"
+      ? `pnpm add ${missing.join(" ")}`
+      : packageManager === "yarn"
+        ? `yarn add ${missing.join(" ")}`
+        : `npm install ${missing.join(" ")}`;
+
+  console.error(
+    [
+      "React Router framework mode requires build packages that are not installed from this app root.",
+      `Missing: ${missing.join(", ")}`,
+      `Install them with: ${installCommand}`,
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+
 function isWorkspaceRoot(): boolean {
   const pkgPath = path.resolve("package.json");
   if (!fs.existsSync(pkgPath)) return false;
@@ -488,6 +563,7 @@ switch (command) {
     // continuation only runs on success.
     (async () => {
       if (isReactRouterFramework()) {
+        validateReactRouterBuildDependencies();
         const rr = findReactRouterBin();
         console.log("Building (React Router framework mode)...");
         await runBuildStep(rr, ["build"], { label: "react-router-build" });
@@ -592,6 +668,7 @@ switch (command) {
     // Run TypeScript type checking
     // React Router framework mode generates route types first
     if (isReactRouterFramework()) {
+      validateReactRouterBuildDependencies();
       const rr = findReactRouterBin();
       try {
         execSync(`${rr} typegen`, { stdio: "inherit" });