@beignet/cli 0.0.51 → 0.0.52

package/src/inspect.ts

@@ -1,6 +1,8 @@
 import { readdir, readFile, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
+import semver from "semver";
 import ts from "typescript";
 import {
   type ContractFactoryBindings,
@@ -10,6 +12,16 @@ import {
 } from "./analysis/contract-factories.js";
 import { canonicalFeatureLayerPath } from "./analysis/layers.js";
 import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
+import {
+  analysisSourceFileExtensions,
+  isAnalysisSourceFile,
+  isAnalysisSourceFileExtension,
+  isJavaScriptSourceFile,
+  javascriptAnalysisSourceFileExtensions,
+  sourceFileScriptKind,
+  stripSourceFileExtension,
+  typescriptAnalysisSourceFileExtensions,
+} from "./analysis/source-files.js";
 import { exportedVariableDeclarations } from "./analysis/source-index.js";
 import { createPainter } from "./ansi.js";
 import type { DatabaseSchemaDialect, DatabaseSchemaTable } from "./choices.js";
@@ -86,6 +98,7 @@ import {
   legacyGeneratedPackageScripts,
 } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
+import { isAppTestFile } from "./test-discovery.js";
 import { getCliVersion } from "./version.js";
 
 type InspectAppOptions = {
@@ -946,7 +959,7 @@ function parseContracts(source: string, file: string): ParsedContract[] {
     source,
     ts.ScriptTarget.Latest,
     true,
-    ts.ScriptKind.TS,
+    sourceFileScriptKind(file),
   );
   const assignments = variableAssignments(sourceFile);
   const assignmentsByName = new Map(
@@ -1556,6 +1569,7 @@ function normalizeContractPath(routePath: string): string {
 async function readRouteExports(
   targetDir: string,
   routeFiles: string[],
+  files: string[],
   config: ResolvedBeignetConfig,
 ): Promise<Map<string, RouteExport[]>> {
   const routeExports = new Map<string, RouteExport[]>();
@@ -1563,7 +1577,10 @@ async function readRouteExports(
   for (const file of routeFiles) {
     const routePath = nextRoutePath(file, config.paths.routes);
     const source = await readFile(path.join(targetDir, file), "utf8");
-    routeExports.set(file, parseRouteExports(source, file, routePath, config));
+    routeExports.set(
+      file,
+      parseRouteExports(source, file, routePath, files, config),
+    );
   }
 
   return routeExports;
@@ -1573,6 +1590,7 @@ function parseRouteExports(
   source: string,
   handlerFile: string,
   routePath: string,
+  files: string[],
   config: ResolvedBeignetConfig,
 ): RouteExport[] {
   const exports: RouteExport[] = [];
@@ -1581,9 +1599,14 @@ function parseRouteExports(
     source,
     ts.ScriptTarget.Latest,
     true,
-    ts.ScriptKind.TS,
+    sourceFileScriptKind(handlerFile),
+  );
+  const imports = parseRouteNamedImports(
+    sourceFile,
+    config,
+    handlerFile,
+    files,
   );
-  const imports = parseRouteNamedImports(sourceFile, config, handlerFile);
 
   for (const statement of sourceFile.statements) {
     if (
@@ -1656,6 +1679,7 @@ function parseRouteNamedImports(
   sourceFile: ts.SourceFile,
   config: ResolvedBeignetConfig,
   handlerFile: string,
+  files: string[],
 ): Map<string, { importedName: string; contractFile?: string }> {
   const imports = new Map<
     string,
@@ -1677,6 +1701,7 @@ function parseRouteNamedImports(
       statement.moduleSpecifier.text,
       config,
       handlerFile,
+      files,
     );
     for (const element of statement.importClause.namedBindings.elements) {
       if (element.isTypeOnly) continue;
@@ -1757,6 +1782,7 @@ function parseNamedImports(
   source: string,
   config: ResolvedBeignetConfig,
   importerFile?: string,
+  files?: string[],
 ): Map<
   string,
   {
@@ -1779,6 +1805,7 @@ function parseNamedImports(
       sourcePath,
       config,
       importerFile,
+      files,
     );
     for (const member of match[1].split(",")) {
       const parsed = parseImportMember(member);
@@ -1849,9 +1876,7 @@ function sourceFileFromImport(
   files?: string[],
 ): string | undefined {
   const resolveCandidate = (candidate: string) => {
-    if (path.extname(candidate)) return candidate;
-
-    const candidates = [`${candidate}.ts`, `${candidate}/index.ts`];
+    const candidates = sourceFileSpecifierCandidates(candidate, importerFile);
     return files
       ? candidates.find((file) => files.includes(file))
       : candidates[0];
@@ -1870,33 +1895,76 @@ function sourceFileFromImport(
   return undefined;
 }
 
+function sourceFileCandidates(base: string, importerFile?: string): string[] {
+  const extensions =
+    importerFile && isJavaScriptSourceFile(importerFile)
+      ? [
+          ...javascriptAnalysisSourceFileExtensions,
+          ...typescriptAnalysisSourceFileExtensions,
+        ]
+      : analysisSourceFileExtensions;
+  return [
+    ...extensions.map((extension) => `${base}${extension}`),
+    ...extensions.map((extension) => `${base}/index${extension}`),
+  ];
+}
+
+function sourceFileSpecifierCandidates(
+  candidate: string,
+  importerFile?: string,
+): string[] {
+  const extension = path.posix.extname(candidate).toLowerCase();
+  if (!extension) return sourceFileCandidates(candidate, importerFile);
+  if (!isAnalysisSourceFileExtension(extension)) return [candidate];
+
+  const sourceExtensions =
+    extension === ".js"
+      ? [".ts", ".tsx"]
+      : extension === ".jsx"
+        ? [".tsx"]
+        : extension === ".mjs"
+          ? [".mts"]
+          : extension === ".cjs"
+            ? [".cts"]
+            : [];
+  const sourceCandidates = sourceExtensions.map(
+    (sourceExtension) =>
+      `${candidate.slice(0, -extension.length)}${sourceExtension}`,
+  );
+  const directCandidates =
+    importerFile && isJavaScriptSourceFile(importerFile)
+      ? [candidate, ...sourceCandidates]
+      : [...sourceCandidates, candidate];
+  return [
+    ...new Set([
+      ...directCandidates,
+      ...directCandidates.map(directoryIndexSourceFile),
+    ]),
+  ];
+}
+
+function isSourceFileNamed(file: string, name: string): boolean {
+  return (
+    isAnalysisSourceFile(file) &&
+    path.posix.basename(stripSourceFileExtension(file)) === name
+  );
+}
+
+function directoryIndexSourceFile(file: string): string {
+  const extension = path.posix.extname(file);
+  return `${stripSourceFileExtension(file)}/index${extension}`;
+}
+
 function contractFileFromImport(
   sourcePath: string,
   config: ResolvedBeignetConfig,
   importerFile?: string,
+  files?: string[],
 ): string | undefined {
   const resolveCandidate = (candidate: string) => {
-    const extension = path.extname(candidate).toLowerCase();
-    if (!extension) return `${candidate}.ts`;
-
-    let sourceExtension: string | undefined;
-    switch (extension) {
-      case ".js":
-        sourceExtension = ".ts";
-        break;
-      case ".jsx":
-        sourceExtension = ".tsx";
-        break;
-      case ".mjs":
-        sourceExtension = ".mts";
-        break;
-      case ".cjs":
-        sourceExtension = ".cts";
-        break;
-    }
-    return sourceExtension
-      ? `${candidate.slice(0, -extension.length)}${sourceExtension}`
-      : candidate;
+    const candidates = sourceFileSpecifierCandidates(candidate, importerFile);
+    if (!files) return candidates[0];
+    return candidates.find((file) => files.includes(file)) ?? candidates[0];
   };
   const contractsPath = directoryPath(config.paths.contracts);
   const aliasPrefix = `@/${contractsPath}/`;
@@ -1905,7 +1973,7 @@ function contractFileFromImport(
   const relativeExact = contractsPath;
 
   if (sourcePath === aliasExact || sourcePath === relativeExact) {
-    return `${contractsPath}/index.ts`;
+    return resolveCandidate(`${contractsPath}/index`);
   }
   if (sourcePath.startsWith(aliasPrefix)) {
     return resolveCandidate(sourcePath.slice("@/".length));
@@ -2002,9 +2070,14 @@ async function inspectRouteSurface(
     const routeFiles = files.filter(
       (file) =>
         file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-        file.endsWith("/route.ts"),
+        isNextRouteFile(file, config),
+    );
+    const routeExports = await readRouteExports(
+      targetDir,
+      routeFiles,
+      files,
+      config,
     );
-    const routeExports = await readRouteExports(targetDir, routeFiles, config);
     return matchRoutes(contracts, routeExports);
   }
 
@@ -2076,8 +2149,7 @@ function findContracts(
         contract.exportName === routeExport.contractRef &&
         (!routeExport.contractFile ||
           contract.file === routeExport.contractFile ||
-          contract.file ===
-            routeExport.contractFile.replace(/\.ts$/, "/index.ts")),
+          contract.file === directoryIndexSourceFile(routeExport.contractFile)),
     );
     return contract ? [contract] : [];
   }
@@ -2521,7 +2593,12 @@ async function inspectCanonicalConformance(
 
   const featureRoutesPath = `${featuresPath}/`;
   for (const file of files) {
-    if (!file.startsWith(featureRoutesPath) || !file.endsWith("/routes.ts")) {
+    if (
+      !file.startsWith(featureRoutesPath) ||
+      !isAnalysisSourceFile(file) ||
+      isAppTestFile(file) ||
+      !stripSourceFileExtension(file).endsWith("/routes")
+    ) {
       continue;
     }
 
@@ -2910,7 +2987,7 @@ async function inspectProductionReadiness(
   let hasSecurityHeadersHook = false;
 
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
 
     const source = await readCachedSource(targetDir, file, sourceCache);
     const routeServerOrInfra = isRouteServerOrInfraFile(file, config);
@@ -2937,7 +3014,7 @@ async function inspectProductionReadiness(
 
     if (
       fileWithinDirectory(file, cronDirectory) &&
-      file.endsWith("/route.ts") &&
+      isNextRouteFile(file, config) &&
       !/\bCRON_SECRET\b/.test(source) &&
       !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
       !/\bcreateScheduleRoute\s*\(/.test(source)
@@ -3239,6 +3316,25 @@ async function inspectProductionReadiness(
           "@beignet/provider-auth-better-auth is installed, but BETTER_AUTH_TRUSTED_ORIGINS is not mentioned in app env/config files. Add it before deploying across multiple origins or document why the app is single-origin only.",
       });
     }
+
+    if (
+      (await betterAuthRequiresIssuerSchema(targetDir, packageJson)) &&
+      (await anyFileContains(
+        targetDir,
+        configFiles,
+        "drizzleAdapter",
+        sourceCache,
+      )) &&
+      !(await hasBetterAuthIssuerSchema(targetDir, files, sourceCache))
+    ) {
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_BETTER_AUTH_ISSUER_SCHEMA_MISSING",
+        file: schemaDir,
+        message:
+          "This app uses Better Auth 1.7 or a version range that can install it with the Drizzle adapter, but its account schema does not include the required issuer field and unique (issuer, accountId) index. Complete the provider-specific account identity backfill, run bunx auth generate, and apply the reviewed migration before deploying Better Auth 1.7.",
+      });
+    }
   }
 
   const installedReadinessProviders = [...installedPackages].filter(
@@ -3284,7 +3380,7 @@ async function uploadHasExplicitSizeLimit(
     );
     if (!importedName) continue;
 
-    const importedFile = resolveLocalTypeScriptModule(file, moduleName, files);
+    const importedFile = sourceFileFromImport(moduleName, file, files);
     if (!importedFile) continue;
 
     const importedSource = await readCachedSource(
@@ -3339,20 +3435,6 @@ function exportedObjectHasProperty(
   return new RegExp(`\\b${escapeRegExp(propertyName)}\\s*:`).test(initializer);
 }
 
-function resolveLocalTypeScriptModule(
-  importer: string,
-  moduleName: string,
-  files: string[],
-): string | undefined {
-  const base = normalizePath(
-    path.posix.normalize(
-      path.posix.join(path.posix.dirname(importer), moduleName),
-    ),
-  );
-  const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}/index.ts`];
-  return candidates.find((candidate) => files.includes(candidate));
-}
-
 async function hasReadinessCheck(
   targetDir: string,
   files: string[],
@@ -3360,10 +3442,18 @@ async function hasReadinessCheck(
   sourceCache: Map<string, string>,
 ): Promise<boolean> {
   const routesDir = directoryPath(config.paths.routes);
-  if (files.includes(`${routesDir}/ready/route.ts`)) return true;
+  if (
+    files.some(
+      (file) =>
+        path.posix.dirname(file) === `${routesDir}/ready` &&
+        isNextRouteFile(file, config),
+    )
+  ) {
+    return true;
+  }
 
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
     if (!isRouteServerOrInfraFile(file, config)) continue;
 
     const source = await readCachedSource(targetDir, file, sourceCache);
@@ -3905,10 +3995,11 @@ function isFeatureUploadDefinition(
   file: string,
   config: ResolvedBeignetConfig,
 ): boolean {
-  const featuresPath = directoryPath(config.paths.features);
-  return new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/uploads/[^/]+\\.ts$`,
-  ).test(file);
+  return isFeatureArtifactFile(
+    file,
+    directoryPath(config.paths.features),
+    "uploads",
+  );
 }
 
 function operationalConfigFiles(
@@ -3918,17 +4009,263 @@ function operationalConfigFiles(
   return providerOperationalConfigFiles(files, config);
 }
 
-async function readPackageJson(
+type InspectedPackageJson = {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+};
+
+function declaredBetterAuthMayRequireIssuerSchema(
+  packageJson: InspectedPackageJson | undefined,
+): boolean {
+  const version =
+    packageJson?.dependencies?.["better-auth"] ??
+    packageJson?.devDependencies?.["better-auth"] ??
+    packageJson?.peerDependencies?.["better-auth"];
+  if (!version) return false;
+
+  const normalized = version.trim();
+  const workspaceRange = normalized.startsWith("workspace:")
+    ? normalized.slice("workspace:".length)
+    : normalized;
+  const npmAlias = /^npm:better-auth@(.+)$/.exec(workspaceRange);
+  const candidate = npmAlias?.[1] ?? workspaceRange;
+  const range = semver.validRange(candidate);
+
+  // Tags, catalogs, local paths, and other non-semver declarations can resolve
+  // to 1.7. Prefer a migration warning until an installed version is readable.
+  if (!range) return true;
+
+  return semver.intersects(range, ">=1.7.0");
+}
+
+async function betterAuthRequiresIssuerSchema(
+  targetDir: string,
+  packageJson: InspectedPackageJson | undefined,
+): Promise<boolean> {
+  const installed = await readInstalledBetterAuthPackageJson(targetDir);
+  if (installed?.version) {
+    const version = semver.valid(installed.version.trim());
+    if (version) return semver.gte(version, "1.7.0");
+  }
+
+  return declaredBetterAuthMayRequireIssuerSchema(packageJson);
+}
+
+async function readInstalledBetterAuthPackageJson(
+  targetDir: string,
+): Promise<{ name?: string; version?: string } | undefined> {
+  const nodeModulesPackage =
+    await readBetterAuthPackageFromNodeModules(targetDir);
+  if (nodeModulesPackage) return nodeModulesPackage;
+
+  const requireFromTarget = createRequire(path.join(targetDir, "package.json"));
+  const packageJsonPath = resolveModuleFromTarget(
+    requireFromTarget,
+    "better-auth/package.json",
+  );
+  if (packageJsonPath) {
+    return readJsonIfExists(packageJsonPath);
+  }
+
+  const entryPath = resolveModuleFromTarget(requireFromTarget, "better-auth");
+  if (!entryPath) return undefined;
+
+  let directory = path.dirname(entryPath);
+  while (true) {
+    const candidate = await readJsonIfExists<{
+      name?: string;
+      version?: string;
+    }>(path.join(directory, "package.json"));
+    if (candidate?.name === "better-auth") return candidate;
+
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+async function readBetterAuthPackageFromNodeModules(
+  targetDir: string,
+): Promise<{ name?: string; version?: string } | undefined> {
+  let directory = targetDir;
+  while (true) {
+    const candidate = await readJsonIfExists<{
+      name?: string;
+      version?: string;
+    }>(path.join(directory, "node_modules", "better-auth", "package.json"));
+    if (candidate?.name === "better-auth") return candidate;
+
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+function resolveModuleFromTarget(
+  requireFromTarget: ReturnType<typeof createRequire>,
+  request: string,
+): string | undefined {
+  try {
+    return requireFromTarget.resolve(request);
+  } catch {
+    return undefined;
+  }
+}
+
+async function hasBetterAuthIssuerSchema(
   targetDir: string,
   files: string[],
-): Promise<
-  | {
-      dependencies?: Record<string, string>;
-      devDependencies?: Record<string, string>;
-      peerDependencies?: Record<string, string>;
+  sourceCache: Map<string, string>,
+): Promise<boolean> {
+  const schemaFiles = files.filter(
+    (file) =>
+      !isTestSourceFile(file) &&
+      /\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(file),
+  );
+
+  for (const file of schemaFiles) {
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    if (sourceHasBetterAuthIssuerSchema(file, source)) return true;
+  }
+
+  return false;
+}
+
+function sourceHasBetterAuthIssuerSchema(
+  file: string,
+  source: string,
+): boolean {
+  const sourceFile = ts.createSourceFile(
+    file,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isCallExpression(node) &&
+      isBetterAuthAccountTableCall(node) &&
+      betterAuthAccountTableHasIssuerIdentity(node)
+    ) {
+      found = true;
+      return;
     }
-  | undefined
-> {
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+
+function isBetterAuthAccountTableCall(call: ts.CallExpression): boolean {
+  const callee = unwrapContractExpression(call.expression);
+  const factoryName = ts.isIdentifier(callee)
+    ? callee.text
+    : ts.isPropertyAccessExpression(callee)
+      ? callee.name.text
+      : undefined;
+  return (
+    factoryName !== undefined &&
+    ["mysqlTable", "pgTable", "sqliteTable"].includes(factoryName) &&
+    staticString(call.arguments[0]) === "account"
+  );
+}
+
+function betterAuthAccountTableHasIssuerIdentity(
+  call: ts.CallExpression,
+): boolean {
+  const columns = call.arguments[1];
+  if (!columns || !ts.isObjectLiteralExpression(columns)) return false;
+  const issuer = columns.properties.find(
+    (property) =>
+      ts.isPropertyAssignment(property) &&
+      staticPropertyName(property.name) === "issuer",
+  );
+  if (!issuer || !ts.isPropertyAssignment(issuer)) return false;
+  if (!isBetterAuthIssuerColumn(issuer.initializer)) return false;
+
+  const constraints = call.arguments[2];
+  if (
+    !constraints ||
+    (!ts.isArrowFunction(constraints) &&
+      !ts.isFunctionExpression(constraints)) ||
+    constraints.parameters.length === 0 ||
+    !ts.isIdentifier(constraints.parameters[0]?.name)
+  ) {
+    return false;
+  }
+
+  const tableName = constraints.parameters[0].name.text;
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isCallExpression(node) &&
+      isBetterAuthIssuerAccountUniqueConstraint(node, tableName)
+    ) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(constraints.body);
+  return found;
+}
+
+function isBetterAuthIssuerColumn(expression: ts.Expression): boolean {
+  let current = unwrapContractExpression(expression);
+  while (ts.isCallExpression(current)) {
+    const callee = unwrapContractExpression(current.expression);
+    if (
+      ts.isIdentifier(callee) &&
+      ["text", "varchar"].includes(callee.text) &&
+      staticString(current.arguments[0]) === "issuer"
+    ) {
+      return true;
+    }
+    if (!ts.isPropertyAccessExpression(callee)) return false;
+    current = unwrapContractExpression(callee.expression);
+  }
+  return false;
+}
+
+function isBetterAuthIssuerAccountUniqueConstraint(
+  call: ts.CallExpression,
+  tableName: string,
+): boolean {
+  const callee = unwrapContractExpression(call.expression);
+  if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "on") {
+    return false;
+  }
+
+  const factoryCall = unwrapContractExpression(callee.expression);
+  if (!ts.isCallExpression(factoryCall)) return false;
+  const factory = unwrapContractExpression(factoryCall.expression);
+  if (
+    !ts.isIdentifier(factory) ||
+    !["unique", "uniqueIndex"].includes(factory.text)
+  ) {
+    return false;
+  }
+
+  if (call.arguments.length !== 2) return false;
+  const columnNames = call.arguments.map((argument) => {
+    const column = unwrapContractExpression(argument);
+    return ts.isPropertyAccessExpression(column) &&
+      ts.isIdentifier(column.expression) &&
+      column.expression.text === tableName
+      ? column.name.text
+      : undefined;
+  });
+  return columnNames.includes("issuer") && columnNames.includes("accountId");
+}
+
+async function readPackageJson(
+  targetDir: string,
+  files: string[],
+): Promise<InspectedPackageJson | undefined> {
   if (!files.includes("package.json")) return undefined;
 
   return JSON.parse(
@@ -4089,7 +4426,7 @@ async function hasBillingEntitlementsProviderWiring(
   const serverPath = path.dirname(config.paths.server);
   const candidateFiles = files.filter(
     (file) =>
-      /\.(?:ts|tsx|mts|cts)$/.test(file) &&
+      isAnalysisSourceFile(file) &&
       !isTestSourceFile(file) &&
       (file.startsWith(`${infraPath}/`) || file.startsWith(`${serverPath}/`)),
   );
@@ -4105,10 +4442,7 @@ async function hasBillingEntitlementsProviderWiring(
 }
 
 function isTestSourceFile(file: string): boolean {
-  return (
-    /(?:^|\/)tests\//.test(file) ||
-    /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(file)
-  );
+  return /(?:^|\/)tests\//.test(file) || isAppTestFile(file);
 }
 
 function exportedConstInitializer(
@@ -4135,8 +4469,8 @@ function featureNameFromContractFile(
 ): string | undefined {
   const featuresPath = directoryPath(config.paths.features);
   const match = new RegExp(
-    `^${escapeRegExp(featuresPath)}/([^/]+)/contracts\\.ts$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/([^/]+)/contracts$`,
+  ).exec(stripSourceFileExtension(file));
   return match?.[1];
 }
 
@@ -4153,7 +4487,7 @@ function featureRuntimeFiles(
     "use-cases",
   ];
   return files.filter((file) => {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) return false;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
     return runtimeFolders.some((folder) =>
       file.startsWith(`${featuresPath}/${feature}/${folder}/`),
     );
@@ -4169,11 +4503,16 @@ function featureTestFiles(
   return files.filter((file) => {
     if (
       !file.startsWith(`${featuresPath}/${feature}/`) ||
-      !file.endsWith(".test.ts")
+      !isAppTestFile(file)
     ) {
       return false;
     }
-    return !options.policyOnly || file.endsWith("/policy.test.ts");
+    return (
+      !options.policyOnly ||
+      ["policy.test", "policy.spec"].includes(
+        path.posix.basename(stripSourceFileExtension(file)),
+      )
+    );
   });
 }
 
@@ -4340,17 +4679,12 @@ async function inspectFeatureArtifactDrift(
       severity: "warning",
       code: "BEIGNET_FEATURE_TEST_PLACEMENT",
       file,
-      message: `${file} places a test directly under ${featuresPath}/${match[1]}/. Move feature behavior tests into ${featuresPath}/${match[1]}/tests/ so feature suites stay in the canonical folder; adjacent *.test.ts files are for infra and server modules.`,
+      message: `${file} places a test directly under ${featuresPath}/${match[1]}/. Move feature behavior tests into ${featuresPath}/${match[1]}/tests/ so feature suites stay in the canonical folder; adjacent test files are for infra and server modules.`,
     });
   }
 
   for (const file of files) {
-    if (
-      !/\.(?:ts|tsx|mts|cts)$/.test(file) ||
-      /\.d\.(?:ts|mts|cts)$/.test(file)
-    ) {
-      continue;
-    }
+    if (!isAnalysisSourceFile(file)) continue;
 
     const misplaced = directFeatureTestMatch(file, featuresPath)
       ? undefined
@@ -4365,7 +4699,6 @@ async function inspectFeatureArtifactDrift(
     }
 
     if (isTestSourceFile(file)) continue;
-    if (!file.endsWith(".ts")) continue;
 
     if (
       isNotificationDefinitionFile(file, featuresPath) ||
@@ -4391,9 +4724,10 @@ function directFeatureTestMatch(
   file: string,
   featuresPath: string,
 ): RegExpExecArray | null {
+  if (!isAppTestFile(file)) return null;
   return new RegExp(
-    `^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)\\.(?:ts|tsx|mts|cts)$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)$`,
+  ).exec(stripSourceFileExtension(file));
 }
 
 function isFeatureArtifactFile(
@@ -4401,9 +4735,10 @@ function isFeatureArtifactFile(
   featuresPath: string,
   folder: "uploads" | "notifications",
 ): boolean {
+  if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
   const match = new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)\\.ts$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)$`,
+  ).exec(stripSourceFileExtension(file));
   return Boolean(match && match[1] !== "index");
 }
 
@@ -4413,7 +4748,7 @@ async function appHasUploadRoute(
   config: ResolvedBeignetConfig,
 ): Promise<boolean> {
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
     if (!isRouteServerOrInfraFile(file, config)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
@@ -4967,11 +5302,17 @@ async function readFeatureWorkflowRegistries(
   for (const kind of kinds) {
     const folder = kind === "events" ? "domain/events" : kind;
     const pattern = new RegExp(
-      `^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`,
+      `^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index$`,
     );
 
     for (const file of files) {
-      if (!pattern.test(file)) continue;
+      if (
+        !isAnalysisSourceFile(file) ||
+        isWorkflowTestFile(file) ||
+        !pattern.test(stripSourceFileExtension(file))
+      ) {
+        continue;
+      }
 
       const source = await readFile(path.join(targetDir, file), "utf8");
       const memberFiles = exportedMemberFiles(source, file, files);
@@ -5031,8 +5372,7 @@ async function readRuntimeManifestIdentifiers(
   const manifests: RuntimeManifestIdentifierSets[] = [];
 
   for (const file of files) {
-    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
-    if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
+    if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     if (!source.includes("defineRuntimeManifest")) continue;
@@ -5169,12 +5509,18 @@ async function listenedEventNames(
 ): Promise<Set<string>> {
   const featuresPath = directoryPath(config.paths.features);
   const listenerPattern = new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`,
+    `^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+$`,
   );
   const listened = new Set<string>();
 
   for (const file of files) {
-    if (!listenerPattern.test(file) || isWorkflowTestFile(file)) continue;
+    if (
+      !isAnalysisSourceFile(file) ||
+      isWorkflowTestFile(file) ||
+      !listenerPattern.test(stripSourceFileExtension(file))
+    ) {
+      continue;
+    }
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const callPattern = /\bdefineListener\s*\(/g;
@@ -5223,8 +5569,7 @@ async function listenerWiringReferences(
   const listenerRegistryFile = listenersFilePath(config);
 
   for (const file of files) {
-    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
-    if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
+    if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const namedImports = parseNamedImportSources(source);
@@ -5233,7 +5578,7 @@ async function listenerWiringReferences(
       source,
       ts.ScriptTarget.Latest,
       true,
-      file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+      sourceFileScriptKind(file),
     );
     const registerListenersBindings = importedRegisterListenersBindings(
       source,
@@ -5693,10 +6038,7 @@ function callReferencesCentralListenerRegistry(args: {
 
 function isWorkflowTestFile(file: string): boolean {
   return (
-    file.endsWith(".test.ts") ||
-    file.endsWith(".test.tsx") ||
-    file.startsWith("tests/") ||
-    file.includes("/tests/")
+    isAppTestFile(file) || file.startsWith("tests/") || file.includes("/tests/")
   );
 }
 
@@ -5711,13 +6053,7 @@ async function inspectServerlessFootguns(
   const cronDirectory = path.posix.join(routeDirectory, "cron");
 
   for (const file of files) {
-    if (
-      !file.endsWith(".ts") ||
-      file.endsWith(".test.ts") ||
-      file.endsWith(".d.ts")
-    ) {
-      continue;
-    }
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const isInfraOrServerFile = isRuntimeFile(file, config);
@@ -5863,9 +6199,10 @@ function fileWithinDirectory(file: string, directory: string): boolean {
 }
 
 function isProviderLifecycleFile(file: string, source?: string): boolean {
+  const sourcePath = stripSourceFileExtension(file);
   return (
-    /(^|\/)provider(s)?\.ts$/.test(file) ||
-    /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    /(^|\/)provider(s)?$/.test(sourcePath) ||
+    /(^|\/)[^/]*provider[^/]*$/.test(sourcePath) ||
     /(^|\/)providers?\//.test(file) ||
     (source !== undefined && containsCallExpression(source, "createProvider"))
   );
@@ -5876,8 +6213,9 @@ function isNextRouteFile(file: string, config: ResolvedBeignetConfig): boolean {
 
   return (
     file.startsWith(`${routesPath}/`) &&
-    file.endsWith("/route.ts") &&
-    !file.endsWith(".test.ts")
+    isSourceFileNamed(file, "route") &&
+    [".js", ".jsx", ".ts", ".tsx"].includes(path.posix.extname(file)) &&
+    !isAppTestFile(file)
   );
 }
 
@@ -7812,7 +8150,13 @@ async function inspectFeatureRouteRegistration(
     const feature = featureNameFromContractFile(contract.file, config);
     if (!feature) continue;
 
-    const routeFile = `${featuresPath}/${feature}/routes.ts`;
+    const routeStem = `${featuresPath}/${feature}/routes`;
+    const routeFile =
+      files.find(
+        (file) =>
+          isAnalysisSourceFile(file) &&
+          stripSourceFileExtension(file) === routeStem,
+      ) ?? `${routeStem}${path.posix.extname(contract.file) || ".ts"}`;
     const featureRouteGroups = routeGroups.filter(
       (routeGroup) => routeGroup.file === routeFile,
     );
@@ -7902,13 +8246,14 @@ async function readFeatureRouteGroups(
 ): Promise<FeatureRouteGroup[]> {
   const featuresPath = `${directoryPath(config.paths.features)}/`;
   const routeFiles = files.filter(
-    (file) => file.startsWith(featuresPath) && file.endsWith("/routes.ts"),
+    (file) =>
+      file.startsWith(featuresPath) && isSourceFileNamed(file, "routes"),
   );
   const routeGroups: FeatureRouteGroup[] = [];
 
   for (const file of routeFiles) {
     const source = await readFile(path.join(targetDir, file), "utf8");
-    const imports = parseNamedImports(source, config, file);
+    const imports = parseNamedImports(source, config, file, files);
     routeGroups.push(...parseFeatureRouteGroups(source, file, imports));
   }
 
@@ -8071,8 +8416,7 @@ function findRouteGroupContract(
       contract.exportName === routeGroupContract.exportName &&
       (!routeGroupContract.file ||
         contract.file === routeGroupContract.file ||
-        contract.file ===
-          routeGroupContract.file.replace(/\.ts$/, "/index.ts")),
+        contract.file === directoryIndexSourceFile(routeGroupContract.file)),
   );
 }
 
@@ -9449,7 +9793,7 @@ async function readContractLists(
 
   for (const file of contractFiles) {
     const source = await readFile(path.join(targetDir, file), "utf8");
-    const imports = parseNamedImports(source, config, file);
+    const imports = parseNamedImports(source, config, file, files);
     for (const list of parseContractLists(source, file, imports)) {
       lists.set(contractListKey(list.file, list.name), list);
     }
@@ -9466,18 +9810,18 @@ function contractSourceFiles(
   if (usesFeatureOwnedContracts(config)) {
     return files.filter(
       (file) =>
-        new RegExp(
-          `^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`,
-        ).test(file) && !file.endsWith(".test.ts"),
+        isAnalysisSourceFile(file) &&
+        !isAppTestFile(file) &&
+        new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts$`).test(
+          stripSourceFileExtension(file),
+        ),
     );
   }
 
-  return files.filter(
-    (file) =>
-      file.startsWith(`${contractsPath}/`) &&
-      file.endsWith(".ts") &&
-      !file.endsWith(".test.ts"),
-  );
+  return files.filter((file) => {
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+    return stripSourceFileExtension(file).startsWith(`${contractsPath}/`);
+  });
 }
 
 function contractListSourceFiles(
@@ -9487,22 +9831,23 @@ function contractListSourceFiles(
   const contractsPath = directoryPath(config.paths.contracts);
   if (usesFeatureOwnedContracts(config)) {
     return files.filter((file) => {
-      if (!file.endsWith(".ts") || file.endsWith(".test.ts")) return false;
-      if (file === `${contractsPath}/index.ts`) return true;
-      if (file === `${contractsPath}/contracts.ts`) return true;
+      if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+      const sourcePath = stripSourceFileExtension(file);
+      if (sourcePath === `${contractsPath}/index`) return true;
+      if (sourcePath === `${contractsPath}/contracts`) return true;
       return new RegExp(
-        `^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`,
-      ).test(file);
+        `^${escapeRegExp(contractsPath)}/[^/]+/contracts$`,
+      ).test(sourcePath);
     });
   }
 
-  return files.filter(
-    (file) =>
-      (file === `${contractsPath}.ts` ||
-        file.startsWith(`${contractsPath}/`)) &&
-      file.endsWith(".ts") &&
-      !file.endsWith(".test.ts"),
-  );
+  return files.filter((file) => {
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+    const sourcePath = stripSourceFileExtension(file);
+    return (
+      sourcePath === contractsPath || sourcePath.startsWith(`${contractsPath}/`)
+    );
+  });
 }
 
 function parseContractLists(
@@ -9556,7 +9901,7 @@ function resolveContractList(
   if (seen.has(key)) return new Set();
   const list =
     lists.get(key) ??
-    lists.get(contractListKey(file.replace(/\.ts$/, "/index.ts"), name));
+    lists.get(contractListKey(directoryIndexSourceFile(file), name));
   if (!list) return undefined;
 
   seen.add(key);
@@ -10146,7 +10491,7 @@ function nextRoutePath(file: string, routeRoot: string): string {
   const normalizedRouteRoot = directoryPath(routeRoot);
   const routeSegments = file
     .slice(normalizedRouteRoot.length + 1)
-    .replace(/\/route\.ts$/, "")
+    .replace(/\/route\.(?:js|jsx|ts|tsx)$/, "")
     .split("/")
     .filter(Boolean);
   const apiPath = routeSegments.map(nextSegmentToContractSegment).join("/");