@beignet/cli 0.0.51 → 0.0.53

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,7 +12,23 @@ import {
 } from "./analysis/contract-factories.js";
 import { canonicalFeatureLayerPath } from "./analysis/layers.js";
 import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
-import { exportedVariableDeclarations } from "./analysis/source-index.js";
+import {
+  analysisSourceFileExtensions,
+  isAnalysisSourceFile,
+  isAnalysisSourceFileExtension,
+  isJavaScriptSourceFile,
+  javascriptAnalysisSourceFileExtensions,
+  sourceFileScriptKind,
+  stripSourceFileExtension,
+  typescriptAnalysisSourceFileExtensions,
+} from "./analysis/source-files.js";
+import {
+  createSourceIndex,
+  exportedVariableDeclarations,
+  type SourceIndex,
+} from "./analysis/source-index.js";
+import { createAnalysisWorkspace, projectPath } from "./analysis/workspace.js";
+import { workspaceRouteContracts } from "./analysis/workspace-routes.js";
 import { createPainter } from "./ansi.js";
 import type { DatabaseSchemaDialect, DatabaseSchemaTable } from "./choices.js";
 import {
@@ -86,6 +104,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 = {
@@ -200,6 +219,7 @@ type RouteExport = {
   handlerFile: string;
   contractRef?: string;
   contractFile?: string;
+  contractUnresolved?: boolean;
   catchAllPrefix?: string;
   source: "next-route" | "route-local";
 };
@@ -248,19 +268,76 @@ export async function inspectApp(
   const targetDir = path.resolve(options.cwd ?? process.cwd());
   await assertDirectory(targetDir);
 
-  const files = await listFiles(targetDir);
-  const config = options.config
-    ? resolveConfig(options.config)
-    : await loadBeignetConfig(targetDir, files);
-  const convention = inspectConvention(files, config);
+  const workspace = await createAnalysisWorkspace(targetDir, {
+    config: options.config,
+  });
+  const { config } = workspace;
+  const files = workspace.projects[0].files;
   const inspectedContracts = await readContracts(targetDir, files, config);
+  for (const project of workspace.projects.slice(1)) {
+    const shared = await readContracts(
+      project.targetDir,
+      project.files,
+      project.config,
+    );
+    inspectedContracts.contracts.push(
+      ...shared.contracts.map((contract) => ({
+        ...contract,
+        file: projectPath(project, contract.file),
+      })),
+    );
+    inspectedContracts.queryTransportDiagnostics.push(
+      ...shared.queryTransportDiagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        ...(diagnostic.file
+          ? { file: projectPath(project, diagnostic.file) }
+          : {}),
+        ...(diagnostic.subject
+          ? {
+              subject: {
+                ...diagnostic.subject,
+                file: projectPath(project, diagnostic.subject.file),
+              },
+            }
+          : {}),
+      })),
+    );
+  }
   const { contracts } = inspectedContracts;
+  contracts.sort(compareContracts);
+  const convention = inspectConvention(
+    files,
+    config,
+    contracts.length > 0 && workspace.projects.length > 1,
+  );
   const matchedRoutes = await inspectRouteSurface(
     targetDir,
     files,
     config,
     contracts,
-  );
+    workspace.projects.length > 1 ? createSourceIndex(workspace) : undefined,
+  );
+  let workspaceRoutesUnresolved = false;
+  if (workspace.projects.length > 1) {
+    const registration = await workspaceRouteContracts(workspace);
+    workspaceRoutesUnresolved = registration.unresolved;
+    matchedRoutes.routes = matchedRoutes.routes.map((route) => {
+      if (route.handlerSource === "route-local") return route;
+      if (!registration.contracts.has(`${route.file}#${route.exportName}`))
+        return {
+          ...route,
+          handlerFile: undefined,
+          handlerSource: "missing" as const,
+        };
+      return config.framework === "web"
+        ? {
+            ...route,
+            handlerFile: config.paths.server,
+            handlerSource: "web-server" as const,
+          }
+        : route;
+    });
+  }
   const diagnostics = await inspectDiagnostics(
     targetDir,
     files,
@@ -272,6 +349,15 @@ export async function inspectApp(
     inspectedContracts.queryTransportDiagnostics,
   );
 
+  if (workspaceRoutesUnresolved)
+    diagnostics.push({
+      severity: "warning",
+      code: "BEIGNET_WORKSPACE_ROUTES_UNRESOLVED",
+      file: config.paths.server,
+      message:
+        "Could not fully resolve workspace route composition. Use explicit defineRoutes arrays and defineRouteGroup bindings reachable from the server routes option.",
+    });
+
   return {
     schemaVersion: 1,
     targetDir,
@@ -354,11 +440,15 @@ async function buildDoctorFixPlan(
     : await loadBeignetConfig(targetDir, files);
   const convention = inspectConvention(files, config);
   const { contracts } = await readContracts(targetDir, files, config);
+  const sourceIndex = config.workspace.packages.length
+    ? createSourceIndex(await createAnalysisWorkspace(targetDir, { config }))
+    : undefined;
   const matchedRoutes = await inspectRouteSurface(
     targetDir,
     files,
     config,
     contracts,
+    sourceIndex,
   );
   const operations: PlannedDoctorFixOperation[] = [];
 
@@ -883,14 +973,15 @@ async function readContracts(
 function inspectConvention(
   files: string[],
   config: ResolvedBeignetConfig,
+  sharedContracts = false,
 ): InspectConvention {
   const missingNextLayout = missingRequirements(files, [
-    `${directoryPath(config.paths.contracts)}/`,
+    ...(sharedContracts ? [] : [`${directoryPath(config.paths.contracts)}/`]),
     `${directoryPath(config.paths.routes)}/`,
     config.paths.server,
   ]);
   const missingWebLayout = missingRequirements(files, [
-    `${directoryPath(config.paths.contracts)}/`,
+    ...(sharedContracts ? [] : [`${directoryPath(config.paths.contracts)}/`]),
     config.paths.server,
   ]);
   const missingResourceGenerator = missingRequirements(files, [
@@ -946,7 +1037,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,34 +1647,53 @@ function normalizeContractPath(routePath: string): string {
 async function readRouteExports(
   targetDir: string,
   routeFiles: string[],
+  files: string[],
   config: ResolvedBeignetConfig,
+  sourceIndex?: SourceIndex,
 ): Promise<Map<string, RouteExport[]>> {
   const routeExports = new Map<string, RouteExport[]>();
 
   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,
+      await parseRouteExports(
+        source,
+        file,
+        routePath,
+        files,
+        config,
+        sourceIndex,
+      ),
+    );
   }
 
   return routeExports;
 }
 
-function parseRouteExports(
+async function parseRouteExports(
   source: string,
   handlerFile: string,
   routePath: string,
+  files: string[],
   config: ResolvedBeignetConfig,
-): RouteExport[] {
+  sourceIndex?: SourceIndex,
+): Promise<RouteExport[]> {
   const exports: RouteExport[] = [];
   const sourceFile = ts.createSourceFile(
     handlerFile,
     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 (
@@ -1628,11 +1738,17 @@ function parseRouteExports(
 
     if (localName) {
       const imported = imports.get(localName);
+      const resolved = await sourceIndex?.resolveValue(
+        handlerFile,
+        ts.factory.createIdentifier(localName),
+      );
       exports.push({
         method,
         handlerFile,
-        contractRef: imported?.importedName ?? localName,
-        contractFile: imported?.contractFile,
+        contractRef:
+          resolved?.exportName ?? imported?.importedName ?? localName,
+        contractFile: resolved?.file ?? imported?.contractFile,
+        ...(sourceIndex && !resolved ? { contractUnresolved: true } : {}),
         source: "route-local",
       });
       continue;
@@ -1656,6 +1772,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 +1794,7 @@ function parseRouteNamedImports(
       statement.moduleSpecifier.text,
       config,
       handlerFile,
+      files,
     );
     for (const element of statement.importClause.namedBindings.elements) {
       if (element.isTypeOnly) continue;
@@ -1757,6 +1875,7 @@ function parseNamedImports(
   source: string,
   config: ResolvedBeignetConfig,
   importerFile?: string,
+  files?: string[],
 ): Map<
   string,
   {
@@ -1779,6 +1898,7 @@ function parseNamedImports(
       sourcePath,
       config,
       importerFile,
+      files,
     );
     for (const member of match[1].split(",")) {
       const parsed = parseImportMember(member);
@@ -1849,9 +1969,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 +1988,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 +2066,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));
@@ -1997,14 +2158,21 @@ async function inspectRouteSurface(
   files: string[],
   config: ResolvedBeignetConfig,
   contracts: InspectedContract[],
+  sourceIndex?: SourceIndex,
 ): Promise<MatchedRoutesResult> {
   if (config.framework === "next") {
     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,
+      sourceIndex,
     );
-    const routeExports = await readRouteExports(targetDir, routeFiles, config);
     return matchRoutes(contracts, routeExports);
   }
 
@@ -2071,13 +2239,13 @@ function findContracts(
   routeExport: RouteExport,
 ): InspectedContract[] {
   if (routeExport.source === "route-local") {
+    if (routeExport.contractUnresolved) return [];
     const contract = contracts.find(
       (contract) =>
         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] : [];
   }
@@ -2319,6 +2487,7 @@ async function inspectCanonicalConformance(
     files.some((file) => file.startsWith(`${clientDir}/`)) ||
     [
       "@beignet/react-query",
+      "@beignet/react-form",
       "@beignet/react-hook-form",
       "@beignet/react-uploads",
       "@beignet/nuqs",
@@ -2365,12 +2534,13 @@ async function inspectCanonicalConformance(
   }
 
   if (
+    installedPackages.has("@beignet/react-form") ||
     installedPackages.has("@beignet/react-hook-form") ||
     files.includes(clientForms)
   ) {
     requiredFiles.push({
       file: clientForms,
-      reason: `${clientForms} should own React Hook Form adapter setup when form helpers are used.`,
+      reason: `${clientForms} should own form adapter setup (createReactForm or createReactHookForm) when form helpers are used.`,
     });
   }
 
@@ -2521,7 +2691,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 +3085,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 +3112,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 +3414,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 +3478,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 +3533,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 +3540,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 +4093,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 +4107,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 +4524,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 +4540,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 +4567,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 +4585,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 +4601,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 +4777,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 +4797,6 @@ async function inspectFeatureArtifactDrift(
     }
 
     if (isTestSourceFile(file)) continue;
-    if (!file.endsWith(".ts")) continue;
 
     if (
       isNotificationDefinitionFile(file, featuresPath) ||
@@ -4391,9 +4822,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 +4833,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 +4846,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 +5400,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 +5470,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 +5607,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 +5667,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 +5676,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 +6136,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 +6151,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 +6297,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 +6311,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)
   );
 }
 
@@ -6000,6 +6436,10 @@ async function inspectPortProviderDrift(
   const portsSource = files.includes(config.paths.ports)
     ? await readFile(path.join(targetDir, config.paths.ports), "utf8")
     : "";
+  const sharedPorts =
+    config.workspace.packages.length > 0
+      ? await analyzePortWiringFiles({ targetDir, files, config })
+      : undefined;
   const packageJson = files.includes("package.json")
     ? await readPackageJson(targetDir, files)
     : undefined;
@@ -6023,7 +6463,12 @@ async function inspectPortProviderDrift(
 
   for (const expected of providerPortRequirements) {
     if (!installedPackages.has(expected.packageName)) continue;
-    if (portsSource.includes(`${expected.portName}:`)) continue;
+    if (
+      sharedPorts
+        ? sharedPorts.declared.has(expected.portName)
+        : portsSource.includes(`${expected.portName}:`)
+    )
+      continue;
     diagnostics.push({
       severity: "warning",
       code: "BEIGNET_PROVIDER_PORT_MISSING",
@@ -7812,7 +8257,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 +8353,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 +8523,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 +9900,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 +9917,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 +9938,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 +10008,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 +10598,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("/");