@beignet/cli 0.0.39 → 0.0.41

package/src/framework.ts

@@ -0,0 +1,13 @@
+import type { ResolvedBeignetConfig } from "./config.js";
+
+export function assertNextFramework(
+  config: ResolvedBeignetConfig,
+  command: string,
+  generatedSurface: string,
+): void {
+  if (config.framework === "next") return;
+
+  throw new Error(
+    `${command} currently supports framework: "next" because it generates ${generatedSurface}. For framework: "web", define the framework-neutral artifact directly and mount its HTTP entrypoint through @beignet/web.`,
+  );
+}

package/src/index.ts

@@ -13,6 +13,7 @@ import {
   type StricliProcess,
   text_en,
 } from "@stricli/core";
+import { type AppMapNodeKind, appMapNodeKinds } from "./app-map-schema.js";
 import {
   type CompletionShell,
   type CreateProviderName,
@@ -36,6 +37,7 @@ import {
 } from "./choices.js";
 // Type-only: the runtime module stays behind the create command's lazy loader.
 import type { CreateSelections } from "./create-prompts.js";
+import type { ExplainTargetKind } from "./explain.js";
 import type { AddProviderPresetResult } from "./provider-add.js";
 import { getCliVersion } from "./version.js";
 
@@ -106,6 +108,13 @@ type RoutesFlags = {
   cwd?: string;
 };
 
+type MapFlags = RoutesFlags & {
+  feature?: string;
+  kind?: readonly AppMapNodeKind[];
+};
+
+type ExplainFlags = RoutesFlags;
+
 type LintFlags = {
   json?: boolean;
   cwd?: string;
@@ -366,6 +375,21 @@ const routesFlagParameters = {
   cwd: cwdFlag,
 } satisfies FlagParametersForType<RoutesFlags, CliContext>;
 
+const mapFlagParameters = {
+  json: jsonFlag,
+  feature: parsedStringFlag(
+    "Project one feature and its direct relationships.",
+  ),
+  kind: {
+    kind: "enum",
+    values: appMapNodeKinds,
+    optional: true,
+    variadic: ",",
+    brief: "Include only these node kinds. Accepts comma-separated values.",
+  },
+  cwd: cwdFlag,
+} satisfies FlagParametersForType<MapFlags, CliContext>;
+
 const lintFlagParameters = {
   json: jsonFlag,
   cwd: cwdFlag,
@@ -585,6 +609,19 @@ const providerPresetPositional = {
   ],
 } as const;
 
+function explainTargetPositional(kind: ExplainTargetKind) {
+  return {
+    kind: "tuple",
+    parameters: [
+      {
+        parse: parseString,
+        placeholder: kind,
+        brief: `${kind[0]?.toUpperCase()}${kind.slice(1)} to explain.`,
+      },
+    ],
+  } as const;
+}
+
 function resolveOutputFormat(flags: {
   json?: boolean;
   format?: OutputFormat;
@@ -829,6 +866,77 @@ const routesCommand = buildCommand<RoutesFlags, [], CliContext>({
   },
 });
 
+const mapCommand = buildCommand<MapFlags, [], CliContext>({
+  docs: {
+    brief: "Map the app's architecture and registered workflows.",
+    fullDescription:
+      "Build a deterministic graph of features, HTTP contracts, routes, use cases, policies, workflows, ports, providers, OpenAPI, tests, dependencies, and doctor findings.",
+  },
+  parameters: {
+    flags: mapFlagParameters,
+  },
+  loader: async () => {
+    const { formatAppMap, mapApp, projectAppMap } = await import(
+      "./app-map.js"
+    );
+
+    return async function runMap(this: CliContext, flags: MapFlags) {
+      const result = projectAppMap(
+        await mapApp({ cwd: flags.cwd, strict: true }),
+        {
+          feature: flags.feature,
+          kinds: flags.kind,
+        },
+      );
+      writeOutput(
+        this,
+        flags.json ? JSON.stringify(result, null, 2) : formatAppMap(result),
+      );
+    };
+  },
+});
+
+function explainCommand(kind: ExplainTargetKind) {
+  return buildCommand<ExplainFlags, [string], CliContext>({
+    docs: {
+      brief: `Explain one mapped Beignet ${kind}.`,
+      fullDescription:
+        "Returns source-backed relationships, conventions, findings, suggested files, and follow-up commands without generating advice or changing the app.",
+    },
+    parameters: {
+      flags: routesFlagParameters,
+      positional: explainTargetPositional(kind),
+    },
+    loader: async () => {
+      const { explainApp, formatExplain } = await import("./explain.js");
+
+      return async function runExplain(
+        this: CliContext,
+        flags: ExplainFlags,
+        target: string,
+      ) {
+        const result = await explainApp({ kind, target, cwd: flags.cwd });
+        writeOutput(
+          this,
+          flags.json ? JSON.stringify(result, null, 2) : formatExplain(result),
+        );
+      };
+    },
+  });
+}
+
+const explainRoutes = buildRouteMap({
+  docs: {
+    brief: "Explain mapped Beignet app concepts with source evidence.",
+  },
+  routes: {
+    diagnostic: explainCommand("diagnostic"),
+    feature: explainCommand("feature"),
+    provider: explainCommand("provider"),
+    route: explainCommand("route"),
+  },
+});
+
 const doctorCommand = buildCommand<DoctorFlags, [], CliContext>({
   docs: {
     brief: "Inspect app wiring and framework conventions.",
@@ -1035,7 +1143,7 @@ const lintCommand = buildCommand<LintFlags, [], CliContext>({
 const mcpCommand = buildCommand<McpFlags, [], CliContext>({
   docs: {
     brief:
-      "Run a Model Context Protocol server exposing this app's routes, doctor, lint, and generators over stdio.",
+      "Run a Model Context Protocol server exposing the app map, validation, and generators over stdio.",
   },
   parameters: {
     flags: {
@@ -2109,7 +2217,7 @@ const makeRoutes = buildRouteMap({
 const rootRoutes = buildRouteMap({
   docs: {
     brief: "Beignet CLI",
-    fullDescription: `Create apps, generate framework files, inspect routes, and check Beignet conventions.
+    fullDescription: `Create apps, generate framework files, map and explain architecture, inspect routes, and check Beignet conventions.
 
 Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
   },
@@ -2119,7 +2227,9 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     create: createCommand,
     db: dbRoutes,
     doctor: doctorCommand,
+    explain: explainRoutes,
     lint: lintCommand,
+    map: mapCommand,
     make: makeRoutes,
     mcp: mcpCommand,
     outbox: outboxRoutes,
@@ -2431,6 +2541,7 @@ ${openStep}
 
 Inspect the app:
   ${cli} routes
+  ${cli} map
   ${cli} check
 
 Generate a feature:

package/src/inspect.ts

@@ -105,7 +105,7 @@ type InspectedCatalogErrorRef = {
 export type InspectedRoute = InspectedContract & {
   handlerFile?: string;
   handlerExport?: HttpMethod;
-  handlerSource: "next-route" | "route-local" | "missing";
+  handlerSource: "next-route" | "route-local" | "web-server" | "missing";
 };
 
 /**
@@ -132,11 +132,13 @@ export type InspectFix = {
  * Detected app convention and missing convention files.
  */
 export type InspectConvention = {
-  kind: "standard" | "next" | "custom";
+  kind: "standard" | "next" | "web" | "custom";
   nextLayout: boolean;
+  webLayout: boolean;
   resourceGenerator: boolean;
   configFile?: string;
   missingNextLayout: string[];
+  missingWebLayout: string[];
   missingResourceGenerator: string[];
 };
 
@@ -204,13 +206,12 @@ export async function inspectApp(
     : await loadBeignetConfig(targetDir, files);
   const convention = inspectConvention(files, config);
   const contracts = await readContracts(targetDir, files, config);
-  const routeFiles = files.filter(
-    (file) =>
-      file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-      file.endsWith("/route.ts"),
+  const matchedRoutes = await inspectRouteSurface(
+    targetDir,
+    files,
+    config,
+    contracts,
   );
-  const routeExports = await readRouteExports(targetDir, routeFiles, config);
-  const matchedRoutes = matchRoutes(contracts, routeExports);
   const diagnostics = await inspectDiagnostics(
     targetDir,
     files,
@@ -246,13 +247,12 @@ export async function applyDoctorFixes(
     : await loadBeignetConfig(targetDir, files);
   const convention = inspectConvention(files, config);
   const contracts = await readContracts(targetDir, files, config);
-  const routeFiles = files.filter(
-    (file) =>
-      file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-      file.endsWith("/route.ts"),
+  const matchedRoutes = await inspectRouteSurface(
+    targetDir,
+    files,
+    config,
+    contracts,
   );
-  const routeExports = await readRouteExports(targetDir, routeFiles, config);
-  const matchedRoutes = matchRoutes(contracts, routeExports);
   const fixes: InspectFix[] = [];
 
   const packageFix = await fixPackageScripts(targetDir, files, convention);
@@ -318,7 +318,9 @@ export function formatRoutes(result: InspectAppResult): string {
     handler:
       route.handlerSource === "missing"
         ? "missing"
-        : `${route.handlerFile ?? "unknown"}:${route.handlerExport ?? route.method}`,
+        : route.handlerSource === "web-server"
+          ? `${route.handlerFile ?? "unknown"}:registry`
+          : `${route.handlerFile ?? "unknown"}:${route.handlerExport ?? route.method}`,
   }));
 
   return table([
@@ -556,6 +558,10 @@ function inspectConvention(
     `${directoryPath(config.paths.routes)}/`,
     config.paths.server,
   ]);
+  const missingWebLayout = missingRequirements(files, [
+    `${directoryPath(config.paths.contracts)}/`,
+    config.paths.server,
+  ]);
   const missingResourceGenerator = missingRequirements(files, [
     config.paths.appContext,
     config.paths.portWiring,
@@ -564,14 +570,23 @@ function inspectConvention(
     config.paths.useCaseBuilder,
   ]);
   const nextLayout = missingNextLayout.length === 0;
+  const webLayout = missingWebLayout.length === 0;
   const resourceGenerator = missingResourceGenerator.length === 0;
 
   return {
-    kind: resourceGenerator ? "standard" : nextLayout ? "next" : "custom",
+    kind: resourceGenerator
+      ? "standard"
+      : config.framework === "web" && webLayout
+        ? "web"
+        : nextLayout
+          ? "next"
+          : "custom",
     nextLayout,
+    webLayout,
     resourceGenerator,
     configFile: config.configFile,
     missingNextLayout,
+    missingWebLayout,
     missingResourceGenerator,
   };
 }
@@ -603,7 +618,7 @@ function parseContracts(source: string, file: string): InspectedContract[] {
   for (const exportMatch of source.matchAll(exportRegex)) {
     const block = exportMatch[2];
     const methodMatch =
-      /([A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*\([^)]*\))*\s*\.\s*(get|post|put|patch|delete|head|options)\(\s*["']([^"']+)["']\s*\)/.exec(
+      /([A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*\([^)]*\))*\s*\.\s*(get|post|put|patch|delete|head|options)\(\s*["']([^"']+)["'](?:\s*,\s*["'][^"']+["'])?\s*\)/.exec(
         block,
       );
     if (methodMatch) {
@@ -1289,6 +1304,73 @@ function matchRoutes(
   };
 }
 
+async function inspectRouteSurface(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  contracts: InspectedContract[],
+): Promise<MatchedRoutesResult> {
+  if (config.framework === "next") {
+    const routeFiles = files.filter(
+      (file) =>
+        file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
+        file.endsWith("/route.ts"),
+    );
+    const routeExports = await readRouteExports(targetDir, routeFiles, config);
+    return matchRoutes(contracts, routeExports);
+  }
+
+  if (!files.includes(config.paths.server)) {
+    return {
+      routes: contracts.map((contract) => ({
+        ...contract,
+        handlerSource: "missing",
+      })),
+      unmatchedRouteHandlers: [],
+    };
+  }
+
+  const serverSource = await readFile(
+    path.join(targetDir, config.paths.server),
+    "utf8",
+  );
+  const routeGroups = await readFeatureRouteGroups(targetDir, files, config);
+  const registeredGroups = await registeredRouteGroupsForServer(
+    targetDir,
+    files,
+    config,
+    serverSource,
+  );
+  const registeredContracts = contractsForRegisteredRouteGroups(
+    contracts,
+    routeGroups,
+    registeredGroups,
+  );
+  const registeredKeys = new Set(registeredContracts.map(contractKey));
+  const handlerFile =
+    routeRegistryFileFromServerSource(
+      serverSource,
+      config.paths.server,
+      files,
+    ) ?? config.paths.server;
+
+  return {
+    routes: contracts.map((contract) =>
+      registeredKeys.has(contractKey(contract))
+        ? {
+            ...contract,
+            handlerFile,
+            handlerSource: "web-server" as const,
+          }
+        : {
+            ...contract,
+            handlerSource: "missing" as const,
+          },
+    ),
+    unmatchedRouteHandlers: [],
+  };
+}
+
 function findContract(
   contracts: InspectedContract[],
   routeExport: RouteExport,
@@ -1349,28 +1431,53 @@ async function inspectDiagnostics(
   strict: boolean,
 ): Promise<InspectDiagnostic[]> {
   const diagnostics: InspectDiagnostic[] = [];
-
-  if (!convention.nextLayout) {
+  const frameworkLayout =
+    config.framework === "next" ? convention.nextLayout : convention.webLayout;
+  const missingFrameworkLayout =
+    config.framework === "next"
+      ? convention.missingNextLayout
+      : convention.missingWebLayout;
+
+  if (!frameworkLayout) {
+    const expectedLayout =
+      config.framework === "next"
+        ? `${directoryPath(config.paths.contracts)}/, ${directoryPath(config.paths.routes)}/, and ${config.paths.server}`
+        : `${directoryPath(config.paths.contracts)}/ and ${config.paths.server}`;
+    const layoutName =
+      config.framework === "next"
+        ? "standard Beignet app layout"
+        : "standard Beignet web app layout";
     diagnostics.push({
       severity: "warning",
       code: "BEIGNET_APP_LAYOUT_NOT_FOUND",
-      message: `This directory does not match the standard Beignet app layout. CLI inspection expects ${directoryPath(config.paths.contracts)}/, ${directoryPath(config.paths.routes)}/, and ${config.paths.server}. Missing: ${convention.missingNextLayout.join(", ")}. Add the missing app files or configure their paths in beignet.config.ts.`,
+      message: `This directory does not match the ${layoutName}. CLI inspection expects ${expectedLayout}. Missing: ${missingFrameworkLayout.join(", ")}. Add the missing app files or configure their paths in beignet.config.ts.`,
     });
   }
 
-  for (const route of matchedRoutes.routes) {
-    if (route.handlerSource !== "missing") continue;
-    diagnostics.push({
-      severity: "error",
-      code: "BEIGNET_ROUTE_MISSING",
-      file: route.file,
-      contract: route.exportName,
-      message: `${route.exportName} (${route.method} ${route.path}) has no matching Next route handler. Add ${methodArticle(route.method)} ${route.method} export to ${directoryPath(config.paths.routes)}/[[...path]]/route.ts or a matching route file, or remove the unused contract.`,
-    });
+  diagnostics.push(
+    ...(await inspectFrameworkAdapter(targetDir, files, config)),
+  );
+
+  if (config.framework === "next" || !convention.resourceGenerator) {
+    for (const route of matchedRoutes.routes) {
+      if (route.handlerSource !== "missing") continue;
+      diagnostics.push({
+        severity: "error",
+        code: "BEIGNET_ROUTE_MISSING",
+        file: route.file,
+        contract: route.exportName,
+        message:
+          config.framework === "next"
+            ? `${route.exportName} (${route.method} ${route.path}) has no matching Next route handler. Add ${methodArticle(route.method)} ${route.method} export to ${directoryPath(config.paths.routes)}/[[...path]]/route.ts or a matching route file, or remove the unused contract.`
+            : `${route.exportName} (${route.method} ${route.path}) is not registered in the route surface passed to createFetchServer(...). Register the contract through defineRoutes(...) or remove the unused contract.`,
+      });
+    }
   }
 
-  for (const routeHandler of matchedRoutes.unmatchedRouteHandlers) {
-    diagnostics.push(unmatchedRouteDiagnostic(routeHandler));
+  if (config.framework === "next") {
+    for (const routeHandler of matchedRoutes.unmatchedRouteHandlers) {
+      diagnostics.push(unmatchedRouteDiagnostic(routeHandler));
+    }
   }
 
   diagnostics.push(
@@ -1414,6 +1521,7 @@ async function inspectDiagnostics(
       config,
       convention,
     )),
+    ...(await inspectInngestProductionPath(targetDir, files, config)),
     ...(await inspectDatabaseLifecycleDrift(
       targetDir,
       files,
@@ -1460,6 +1568,39 @@ async function inspectDiagnostics(
   return dedupeDiagnostics(diagnostics);
 }
 
+async function inspectFrameworkAdapter(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<InspectDiagnostic[]> {
+  if (!files.includes(config.paths.server)) return [];
+
+  const source = await readFile(
+    path.join(targetDir, config.paths.server),
+    "utf8",
+  );
+  const expectedFactory =
+    config.framework === "next" ? "createNextServer" : "createFetchServer";
+  const otherFactory =
+    config.framework === "next" ? "createFetchServer" : "createNextServer";
+
+  if (
+    containsCallExpression(source, expectedFactory) ||
+    !containsCallExpression(source, otherFactory)
+  ) {
+    return [];
+  }
+
+  return [
+    {
+      severity: "error",
+      code: "BEIGNET_FRAMEWORK_MISMATCH",
+      file: config.paths.server,
+      message: `${config.configFile ?? "beignet.config.*"} selects framework: "${config.framework}", but ${config.paths.server} calls ${otherFactory}(...). Use ${expectedFactory}(...) or update the configured framework profile.`,
+    },
+  ];
+}
+
 async function inspectCanonicalConformance(
   targetDir: string,
   files: string[],
@@ -1626,11 +1767,13 @@ async function inspectCanonicalConformance(
     }
 
     if (!importsAppContext(serverSource, config.paths.server, config, files)) {
+      const serverFactory =
+        config.framework === "next" ? "createNextServer" : "createFetchServer";
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_SERVER_APP_CONTEXT",
         file: config.paths.server,
-        message: `${config.paths.server} should import type { AppContext } from ${config.paths.appContext} and thread that context through createNextServer and hooks.`,
+        message: `${config.paths.server} should import type { AppContext } from ${config.paths.appContext} and thread that context through ${serverFactory} and hooks.`,
       });
     }
 
@@ -2333,7 +2476,7 @@ async function inspectProductionReadiness(
   }
 
   if (installedPackages.has("@beignet/provider-auth-better-auth")) {
-    if (!hasBetterAuthRoute(files, config)) {
+    if (config.framework === "next" && !hasBetterAuthRoute(files, config)) {
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_AUTH_ROUTE_MISSING",
@@ -2589,7 +2732,10 @@ async function inspectPaymentsProductionReadiness(
     });
   }
 
-  if (!(await hasPaymentWebhookRoute(targetDir, files, config, sourceCache))) {
+  if (
+    config.framework === "next" &&
+    !(await hasPaymentWebhookRoute(targetDir, files, config, sourceCache))
+  ) {
     diagnostics.push({
       severity: "warning",
       code: "BEIGNET_PAYMENTS_WEBHOOK_ROUTE_MISSING",
@@ -2950,6 +3096,73 @@ async function inspectProviderRegistrationDrift(
   return diagnostics;
 }
 
+async function inspectInngestProductionPath(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<InspectDiagnostic[]> {
+  const packageJson = await readPackageJson(targetDir, files);
+  if (
+    !installedPackageNames(packageJson).has("@beignet/provider-jobs-inngest")
+  ) {
+    return [];
+  }
+
+  const diagnostics: InspectDiagnostic[] = [];
+  const serverDir = directoryPath(path.dirname(config.paths.server));
+  const registryFile = `${serverDir}/inngest.ts`;
+  const routeFile = `${directoryPath(config.paths.routes)}/inngest/route.ts`;
+
+  if (!files.includes(registryFile)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "BEIGNET_INNGEST_REGISTRY_MISSING",
+      file: registryFile,
+      message: `@beignet/provider-jobs-inngest is installed, but ${registryFile} is missing. Run beignet provider add jobs-inngest or create a central createInngestJobFunctions(...) registry so dispatched jobs can execute.`,
+    });
+  } else {
+    const registrySource = await readFile(
+      path.join(targetDir, registryFile),
+      "utf8",
+    );
+    const registry = arrayInitializerInfo(registrySource, "inngestJobs");
+    const registeredJobs = registry
+      ? identifiersFromArrayExpression(registry.text)
+      : new Set<string>();
+    const featureRoot = directoryPath(config.paths.features);
+    const jobIndexes = files.filter((file) =>
+      new RegExp(`^${escapeRegExp(featureRoot)}/[^/]+/jobs/index\\.ts$`).test(
+        file,
+      ),
+    );
+    for (const jobIndex of jobIndexes) {
+      const source = await readFile(path.join(targetDir, jobIndex), "utf8");
+      const match = source.match(/export const\s+([A-Za-z_$][\w$]*Jobs)\s*=/);
+      const registryName = match?.[1];
+      if (!registryName || registeredJobs.has(registryName)) {
+        continue;
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_INNGEST_JOB_REGISTRATION_MISSING",
+        file: registryFile,
+        message: `${jobIndex} exports ${registryName}, but it is not registered in inngestJobs in ${registryFile}. Add ...${registryName} so Inngest can execute the job.`,
+      });
+    }
+  }
+
+  if (config.framework === "next" && !files.includes(routeFile)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "BEIGNET_INNGEST_ROUTE_MISSING",
+      file: routeFile,
+      message: `@beignet/provider-jobs-inngest is installed in a Next.js app, but ${routeFile} is missing. Expose the shared Inngest client and function registry with serve(...) so Inngest can discover and invoke jobs.`,
+    });
+  }
+
+  return diagnostics;
+}
+
 function isFeatureUploadDefinition(
   file: string,
   config: ResolvedBeignetConfig,
@@ -4213,7 +4426,7 @@ function callReferencesCentralListenerRegistry(args: {
 
   for (const identifier of args.callIdentifiers) {
     const imported = args.namedImports.get(identifier);
-    if (!imported || imported.importedName !== "listeners") continue;
+    if (imported?.importedName !== "listeners") continue;
 
     const importedFile = sourceFileFromImport(
       imported.sourcePath,
@@ -4260,6 +4473,7 @@ async function inspectServerlessFootguns(
     const source = await readFile(path.join(targetDir, file), "utf8");
 
     if (
+      config.framework === "next" &&
       convention.resourceGenerator &&
       isNextRouteFile(file, config) &&
       importsEagerServer(source, file, files, config)
@@ -6461,15 +6675,19 @@ async function registeredRouteGroupsForServer(
   serverSource: string,
 ): Promise<Set<string>> {
   const registeredGroups = registeredRouteGroups(serverSource);
-  const imports = parseNamedImports(serverSource, config, config.paths.server);
+  const imports = parseNamedImportSources(serverSource);
 
   for (const identifier of routeOptionIdentifiers(serverSource)) {
     const imported = imports.get(identifier);
-    if (!imported?.contractFile || !files.includes(imported.contractFile)) {
-      continue;
-    }
+    if (!imported) continue;
+    const importedFile = sourceFileFromImport(
+      imported.sourcePath,
+      config.paths.server,
+      files,
+    );
+    if (!importedFile || !files.includes(importedFile)) continue;
 
-    const source = await readFile(path.join(targetDir, imported.contractFile), {
+    const source = await readFile(path.join(targetDir, importedFile), {
       encoding: "utf8",
     });
     for (const routeGroup of registeredRouteGroups(source)) {
@@ -7458,6 +7676,7 @@ async function inspectResourceSlices(
       );
     }
     if (
+      config.framework === "next" &&
       !hasRequirement(files, routeFile) &&
       !hasRequirement(files, catchAllRouteFile)
     ) {