@beignet/cli 0.0.51 → 0.0.53

package/dist/inspect.js

@@ -1,11 +1,16 @@
 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 { contractFactoryBindings, isImportedContractFactoryCall, } 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, } 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 { clientDirPath, clientFormsPath, clientIndexPath, defaultBeignetConfig, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
 import { renderDatabaseSchema, resolveDatabaseSchemaDialect } from "./db.js";
@@ -16,19 +21,72 @@ import { detectedProviderVariants, diagnosticPackageJsonFile, formatProviderEnvA
 import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, codeCharacterIndexes, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, outboxRegistryEntryState, outboxRegistryIdentifiers, } from "./registry-edits.js";
 import { currentGeneratedPackageScripts, externalVersions, isLegacyGeneratedPackageScript, legacyGeneratedPackageScripts, } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
+import { isAppTestFile } from "./test-discovery.js";
 import { getCliVersion } from "./version.js";
 export async function inspectApp(options = {}) {
     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;
-    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts);
+    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",
+                };
+            return config.framework === "web"
+                ? {
+                    ...route,
+                    handlerFile: config.paths.server,
+                    handlerSource: "web-server",
+                }
+                : route;
+        });
+    }
     const diagnostics = await inspectDiagnostics(targetDir, files, config, convention, contracts, matchedRoutes, Boolean(options.strict), 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,
@@ -83,7 +141,10 @@ async function buildDoctorFixPlan(options = {}) {
         : await loadBeignetConfig(targetDir, files);
     const convention = inspectConvention(files, config);
     const { contracts } = await readContracts(targetDir, files, config);
-    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts);
+    const sourceIndex = config.workspace.packages.length
+        ? createSourceIndex(await createAnalysisWorkspace(targetDir, { config }))
+        : undefined;
+    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts, sourceIndex);
     const operations = [];
     const packageFix = await planPackageScripts(targetDir, files, convention);
     if (packageFix)
@@ -437,14 +498,14 @@ async function readContracts(targetDir, files, config) {
         queryTransportDiagnostics,
     };
 }
-function inspectConvention(files, config) {
+function inspectConvention(files, config, sharedContracts = false) {
     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, [
@@ -485,7 +546,7 @@ function hasRequirement(files, requirement) {
 }
 function parseContracts(source, file) {
     const contracts = [];
-    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(file));
     const assignments = variableAssignments(sourceFile);
     const assignmentsByName = new Map(assignments.map((assignment) => [assignment.name, assignment.expression]));
     const factoryBindings = contractFactoryBindings(sourceFile);
@@ -926,19 +987,19 @@ function normalizeContractPath(routePath) {
     const segments = routePath.split("/").filter(Boolean);
     return segments.length === 0 ? "/" : `/${segments.join("/")}`;
 }
-async function readRouteExports(targetDir, routeFiles, config) {
+async function readRouteExports(targetDir, routeFiles, files, config, sourceIndex) {
     const routeExports = new Map();
     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(source, handlerFile, routePath, config) {
+async function parseRouteExports(source, handlerFile, routePath, files, config, sourceIndex) {
     const exports = [];
-    const sourceFile = ts.createSourceFile(handlerFile, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const imports = parseRouteNamedImports(sourceFile, config, handlerFile);
+    const sourceFile = ts.createSourceFile(handlerFile, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(handlerFile));
+    const imports = parseRouteNamedImports(sourceFile, config, handlerFile, files);
     for (const statement of sourceFile.statements) {
         if (!ts.isVariableStatement(statement) ||
             !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
@@ -973,11 +1034,13 @@ function parseRouteExports(source, handlerFile, routePath, config) {
         const localName = routeLocalContractIdentifier(declaration.initializer);
         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;
@@ -994,7 +1057,7 @@ function parseRouteExports(source, handlerFile, routePath, config) {
     }
     return exports;
 }
-function parseRouteNamedImports(sourceFile, config, handlerFile) {
+function parseRouteNamedImports(sourceFile, config, handlerFile, files) {
     const imports = new Map();
     for (const statement of sourceFile.statements) {
         if (!ts.isImportDeclaration(statement) ||
@@ -1004,7 +1067,7 @@ function parseRouteNamedImports(sourceFile, config, handlerFile) {
             !ts.isNamedImports(statement.importClause.namedBindings)) {
             continue;
         }
-        const contractFile = contractFileFromImport(statement.moduleSpecifier.text, config, handlerFile);
+        const contractFile = contractFileFromImport(statement.moduleSpecifier.text, config, handlerFile, files);
         for (const element of statement.importClause.namedBindings.elements) {
             if (element.isTypeOnly)
                 continue;
@@ -1065,12 +1128,12 @@ function catchAllRoutePrefix(routePath) {
     const prefixSegments = segments.slice(0, catchAllIndex);
     return prefixSegments.length === 0 ? "/" : `/${prefixSegments.join("/")}`;
 }
-function parseNamedImports(source, config, importerFile) {
+function parseNamedImports(source, config, importerFile, files) {
     const imports = new Map();
     const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
     for (const match of source.matchAll(importRegex)) {
         const sourcePath = match[2];
-        const contractFile = contractFileFromImport(sourcePath, config, importerFile);
+        const contractFile = contractFileFromImport(sourcePath, config, importerFile, files);
         for (const member of match[1].split(",")) {
             const parsed = parseImportMember(member);
             if (!parsed)
@@ -1120,9 +1183,7 @@ function parseImportMember(member) {
 }
 function sourceFileFromImport(sourcePath, importerFile = "index.ts", files) {
     const resolveCandidate = (candidate) => {
-        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];
@@ -1135,29 +1196,58 @@ function sourceFileFromImport(sourcePath, importerFile = "index.ts", files) {
     }
     return undefined;
 }
-function contractFileFromImport(sourcePath, config, importerFile) {
+function sourceFileCandidates(base, importerFile) {
+    const extensions = importerFile && isJavaScriptSourceFile(importerFile)
+        ? [
+            ...javascriptAnalysisSourceFileExtensions,
+            ...typescriptAnalysisSourceFileExtensions,
+        ]
+        : analysisSourceFileExtensions;
+    return [
+        ...extensions.map((extension) => `${base}${extension}`),
+        ...extensions.map((extension) => `${base}/index${extension}`),
+    ];
+}
+function sourceFileSpecifierCandidates(candidate, importerFile) {
+    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, name) {
+    return (isAnalysisSourceFile(file) &&
+        path.posix.basename(stripSourceFileExtension(file)) === name);
+}
+function directoryIndexSourceFile(file) {
+    const extension = path.posix.extname(file);
+    return `${stripSourceFileExtension(file)}/index${extension}`;
+}
+function contractFileFromImport(sourcePath, config, importerFile, files) {
     const resolveCandidate = (candidate) => {
-        const extension = path.extname(candidate).toLowerCase();
-        if (!extension)
-            return `${candidate}.ts`;
-        let sourceExtension;
-        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}/`;
@@ -1165,7 +1255,7 @@ function contractFileFromImport(sourcePath, config, importerFile) {
     const relativePrefix = `${contractsPath}/`;
     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));
@@ -1231,11 +1321,11 @@ function matchRoutes(contracts, routeExports) {
         unmatchedRouteHandlers,
     };
 }
-async function inspectRouteSurface(targetDir, files, config, contracts) {
+async function inspectRouteSurface(targetDir, files, config, contracts, sourceIndex) {
     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);
+            isNextRouteFile(file, config));
+        const routeExports = await readRouteExports(targetDir, routeFiles, files, config, sourceIndex);
         return matchRoutes(contracts, routeExports);
     }
     if (!files.includes(config.paths.server)) {
@@ -1272,11 +1362,12 @@ function findContract(contracts, routeExport) {
 }
 function findContracts(contracts, routeExport) {
     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] : [];
     }
     if (routeExport.catchAllPrefix) {
@@ -1372,6 +1463,7 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
         files.some((file) => file.startsWith(`${clientDir}/`)) ||
         [
             "@beignet/react-query",
+            "@beignet/react-form",
             "@beignet/react-hook-form",
             "@beignet/react-uploads",
             "@beignet/nuqs",
@@ -1408,11 +1500,12 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
             reason: `${clientIndex} should own the typed client and frontend adapter setup.`,
         });
     }
-    if (installedPackages.has("@beignet/react-hook-form") ||
+    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.`,
         });
     }
     for (const required of requiredFiles) {
@@ -1513,7 +1606,10 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
     }
     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;
         }
         const source = await readCachedSource(targetDir, file, sourceCache);
@@ -1783,7 +1879,7 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
     const schemaDir = `${infrastructurePath}/db/schema`;
     let hasSecurityHeadersHook = false;
     for (const file of files) {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         const source = await readCachedSource(targetDir, file, sourceCache);
         const routeServerOrInfra = isRouteServerOrInfraFile(file, config);
@@ -1802,7 +1898,7 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
             });
         }
         if (fileWithinDirectory(file, cronDirectory) &&
-            file.endsWith("/route.ts") &&
+            isNextRouteFile(file, config) &&
             !/\bCRON_SECRET\b/.test(source) &&
             !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
             !/\bcreateScheduleRoute\s*\(/.test(source)) {
@@ -1968,6 +2064,16 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
                 message: "@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((packageName) => readinessRelevantProviderPackages.has(packageName));
     if (installedReadinessProviders.length > 0 &&
@@ -1995,7 +2101,7 @@ async function uploadHasExplicitSizeLimit(targetDir, file, source, files, source
         const importedName = importedNameForLocalBinding(match[1] ?? "", fileReference);
         if (!importedName)
             continue;
-        const importedFile = resolveLocalTypeScriptModule(file, moduleName, files);
+        const importedFile = sourceFileFromImport(moduleName, file, files);
         if (!importedFile)
             continue;
         const importedSource = await readCachedSource(targetDir, importedFile, sourceCache);
@@ -2029,17 +2135,14 @@ function exportedObjectHasProperty(source, exportName, propertyName) {
     const initializer = source.slice(openIndex, closeIndex + 1);
     return new RegExp(`\\b${escapeRegExp(propertyName)}\\s*:`).test(initializer);
 }
-function resolveLocalTypeScriptModule(importer, moduleName, files) {
-    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, files, config, sourceCache) {
     const routesDir = directoryPath(config.paths.routes);
-    if (files.includes(`${routesDir}/ready/route.ts`))
+    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"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         if (!isRouteServerOrInfraFile(file, config))
             continue;
@@ -2394,12 +2497,193 @@ async function inspectInngestProductionPath(targetDir, files, config) {
     return diagnostics;
 }
 function isFeatureUploadDefinition(file, config) {
-    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(files, config) {
     return providerOperationalConfigFiles(files, config);
 }
+function declaredBetterAuthMayRequireIssuerSchema(packageJson) {
+    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, packageJson) {
+    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) {
+    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(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) {
+    let directory = targetDir;
+    while (true) {
+        const candidate = await readJsonIfExists(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, request) {
+    try {
+        return requireFromTarget.resolve(request);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function hasBetterAuthIssuerSchema(targetDir, files, sourceCache) {
+    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, source) {
+    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(node) &&
+            isBetterAuthAccountTableCall(node) &&
+            betterAuthAccountTableHasIssuerIdentity(node)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function isBetterAuthAccountTableCall(call) {
+    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) {
+    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) => {
+        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) {
+    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, tableName) {
+    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, files) {
     if (!files.includes("package.json"))
         return undefined;
@@ -2484,7 +2768,7 @@ async function usesEntitlementChecks(targetDir, files, sourceCache) {
 async function hasBillingEntitlementsProviderWiring(targetDir, files, config, sourceCache) {
     const infraPath = path.dirname(config.paths.portWiring);
     const serverPath = path.dirname(config.paths.server);
-    const candidateFiles = files.filter((file) => /\.(?:ts|tsx|mts|cts)$/.test(file) &&
+    const candidateFiles = files.filter((file) => isAnalysisSourceFile(file) &&
         !isTestSourceFile(file) &&
         (file.startsWith(`${infraPath}/`) || file.startsWith(`${serverPath}/`)));
     for (const file of candidateFiles) {
@@ -2496,8 +2780,7 @@ async function hasBillingEntitlementsProviderWiring(targetDir, files, config, so
     return false;
 }
 function isTestSourceFile(file) {
-    return (/(?:^|\/)tests\//.test(file) ||
-        /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(file));
+    return /(?:^|\/)tests\//.test(file) || isAppTestFile(file);
 }
 function exportedConstInitializer(source, exportName) {
     const declaration = new RegExp(`\\bexport\\s+const\\s+${escapeRegExp(exportName)}\\s*=`).exec(source);
@@ -2511,7 +2794,7 @@ function exportedConstInitializer(source, exportName) {
 }
 function featureNameFromContractFile(file, config) {
     const featuresPath = directoryPath(config.paths.features);
-    const match = new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/contracts\\.ts$`).exec(file);
+    const match = new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/contracts$`).exec(stripSourceFileExtension(file));
     return match?.[1];
 }
 function featureRuntimeFiles(files, featuresPath, feature) {
@@ -2523,7 +2806,7 @@ function featureRuntimeFiles(files, featuresPath, feature) {
         "use-cases",
     ];
     return files.filter((file) => {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             return false;
         return runtimeFolders.some((folder) => file.startsWith(`${featuresPath}/${feature}/${folder}/`));
     });
@@ -2531,10 +2814,11 @@ function featureRuntimeFiles(files, featuresPath, feature) {
 function featureTestFiles(files, featuresPath, feature, options = {}) {
     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))));
     });
 }
 function featureNamesFromContracts(contracts, config) {
@@ -2630,14 +2914,12 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
             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)) {
+        if (!isAnalysisSourceFile(file))
             continue;
-        }
         const misplaced = directFeatureTestMatch(file, featuresPath)
             ? undefined
             : misplacedFeatureLayer(file, config);
@@ -2651,8 +2933,6 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
         }
         if (isTestSourceFile(file))
             continue;
-        if (!file.endsWith(".ts"))
-            continue;
         if (isNotificationDefinitionFile(file, featuresPath) ||
             isInfraOrServerFile(file, config)) {
             continue;
@@ -2670,15 +2950,19 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
     return diagnostics;
 }
 function directFeatureTestMatch(file, featuresPath) {
-    return new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)\\.(?:ts|tsx|mts|cts)$`).exec(file);
+    if (!isAppTestFile(file))
+        return null;
+    return new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)$`).exec(stripSourceFileExtension(file));
 }
 function isFeatureArtifactFile(file, featuresPath, folder) {
-    const match = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)\\.ts$`).exec(file);
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file))
+        return false;
+    const match = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)$`).exec(stripSourceFileExtension(file));
     return Boolean(match && match[1] !== "index");
 }
 async function appHasUploadRoute(targetDir, files, config) {
     for (const file of files) {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         if (!isRouteServerOrInfraFile(file, config))
             continue;
@@ -3007,10 +3291,13 @@ async function readFeatureWorkflowRegistries(targetDir, files, config) {
     ];
     for (const kind of kinds) {
         const folder = kind === "events" ? "domain/events" : kind;
-        const pattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`);
+        const pattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index$`);
         for (const file of files) {
-            if (!pattern.test(file))
+            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);
             const exportRegex = new RegExp(`(?:^|\\n)export const\\s+([A-Za-z_$][\\w$]*${workflowRegistrySuffixes[kind]})\\s*=`, "g");
@@ -3052,9 +3339,7 @@ function exportedMemberFiles(source, indexFile, files) {
 async function readRuntimeManifestIdentifiers(targetDir, files) {
     const manifests = [];
     for (const file of files) {
-        if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
-            continue;
-        if (file.endsWith(".d.ts") || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file))
             continue;
         const source = await readFile(path.join(targetDir, file), "utf8");
         if (!source.includes("defineRuntimeManifest"))
@@ -3163,11 +3448,14 @@ function registeredWorkflowIdentifiers(source, kind) {
 }
 async function listenedEventNames(targetDir, files, config) {
     const featuresPath = directoryPath(config.paths.features);
-    const listenerPattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`);
+    const listenerPattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+$`);
     const listened = new Set();
     for (const file of files) {
-        if (!listenerPattern.test(file) || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) ||
+            isWorkflowTestFile(file) ||
+            !listenerPattern.test(stripSourceFileExtension(file))) {
             continue;
+        }
         const source = await readFile(path.join(targetDir, file), "utf8");
         const callPattern = /\bdefineListener\s*\(/g;
         for (const match of source.matchAll(callPattern)) {
@@ -3197,13 +3485,11 @@ async function listenerWiringReferences(targetDir, files, config, listenerRegist
     let centralListenerRegistryReferenced = false;
     const listenerRegistryFile = listenersFilePath(config);
     for (const file of files) {
-        if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
-            continue;
-        if (file.endsWith(".d.ts") || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file))
             continue;
         const source = await readFile(path.join(targetDir, file), "utf8");
         const namedImports = parseNamedImportSources(source);
-        const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(file));
         const registerListenersBindings = importedRegisterListenersBindings(source, namedImports);
         const calls = registerListenersCalls(sourceFile, registerListenersBindings);
         let foundRelevantCall = false;
@@ -3523,21 +3809,15 @@ function callReferencesCentralListenerRegistry(args) {
     return false;
 }
 function isWorkflowTestFile(file) {
-    return (file.endsWith(".test.ts") ||
-        file.endsWith(".test.tsx") ||
-        file.startsWith("tests/") ||
-        file.includes("/tests/"));
+    return (isAppTestFile(file) || file.startsWith("tests/") || file.includes("/tests/"));
 }
 async function inspectServerlessFootguns(targetDir, files, config, convention) {
     const diagnostics = [];
     const routeDirectory = directoryPath(config.paths.routes);
     const cronDirectory = path.posix.join(routeDirectory, "cron");
     for (const file of files) {
-        if (!file.endsWith(".ts") ||
-            file.endsWith(".test.ts") ||
-            file.endsWith(".d.ts")) {
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
-        }
         const source = await readFile(path.join(targetDir, file), "utf8");
         const isInfraOrServerFile = isRuntimeFile(file, config);
         const isProviderFile = isProviderLifecycleFile(file, source);
@@ -3642,16 +3922,18 @@ function fileWithinDirectory(file, directory) {
     return directory === "." || file.startsWith(`${directory}/`);
 }
 function isProviderLifecycleFile(file, source) {
-    return (/(^|\/)provider(s)?\.ts$/.test(file) ||
-        /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    const sourcePath = stripSourceFileExtension(file);
+    return (/(^|\/)provider(s)?$/.test(sourcePath) ||
+        /(^|\/)[^/]*provider[^/]*$/.test(sourcePath) ||
         /(^|\/)providers?\//.test(file) ||
         (source !== undefined && containsCallExpression(source, "createProvider")));
 }
 function isNextRouteFile(file, config) {
     const routesPath = directoryPath(config.paths.routes);
     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));
 }
 function importsEagerServer(source, importerFile, files, config) {
     const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
@@ -3737,6 +4019,9 @@ async function inspectPortProviderDrift(targetDir, files, config, convention) {
     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;
@@ -3754,7 +4039,9 @@ async function inspectPortProviderDrift(targetDir, files, config, convention) {
     for (const expected of providerPortRequirements) {
         if (!installedPackages.has(expected.packageName))
             continue;
-        if (portsSource.includes(`${expected.portName}:`))
+        if (sharedPorts
+            ? sharedPorts.declared.has(expected.portName)
+            : portsSource.includes(`${expected.portName}:`))
             continue;
         diagnostics.push({
             severity: "warning",
@@ -4882,7 +5169,9 @@ async function inspectFeatureRouteRegistration(targetDir, files, config, convent
         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);
         if (featureRouteGroups.length === 0) {
             diagnostics.push({
@@ -4948,11 +5237,11 @@ function contractsForRegisteredRouteGroups(contracts, routeGroups, registeredGro
 }
 async function readFeatureRouteGroups(targetDir, files, config) {
     const featuresPath = `${directoryPath(config.paths.features)}/`;
-    const routeFiles = files.filter((file) => file.startsWith(featuresPath) && file.endsWith("/routes.ts"));
+    const routeFiles = files.filter((file) => file.startsWith(featuresPath) && isSourceFileNamed(file, "routes"));
     const routeGroups = [];
     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));
     }
     return routeGroups;
@@ -5063,8 +5352,7 @@ function findRouteGroupContract(contracts, routeGroupContract) {
     return contracts.find((contract) => contract.exportName === routeGroupContract.exportName &&
         (!routeGroupContract.file ||
             contract.file === routeGroupContract.file ||
-            contract.file ===
-                routeGroupContract.file.replace(/\.ts$/, "/index.ts")));
+            contract.file === directoryIndexSourceFile(routeGroupContract.file)));
 }
 const managedDatabaseSchemaMarker = "// Managed by beignet db schema sync.";
 const databaseSchemaExports = {
@@ -5996,7 +6284,7 @@ async function readContractLists(targetDir, files, config) {
     const contractFiles = contractListSourceFiles(files, config);
     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);
         }
@@ -6006,29 +6294,36 @@ async function readContractLists(targetDir, files, config) {
 function contractSourceFiles(files, config) {
     const contractsPath = directoryPath(config.paths.contracts);
     if (usesFeatureOwnedContracts(config)) {
-        return files.filter((file) => new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`).test(file) && !file.endsWith(".test.ts"));
+        return files.filter((file) => 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(files, config) {
     const contractsPath = directoryPath(config.paths.contracts);
     if (usesFeatureOwnedContracts(config)) {
         return files.filter((file) => {
-            if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+            if (!isAnalysisSourceFile(file) || isAppTestFile(file))
                 return false;
-            if (file === `${contractsPath}/index.ts`)
+            const sourcePath = stripSourceFileExtension(file);
+            if (sourcePath === `${contractsPath}/index`)
                 return true;
-            if (file === `${contractsPath}/contracts.ts`)
+            if (sourcePath === `${contractsPath}/contracts`)
                 return true;
-            return new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`).test(file);
+            return new RegExp(`^${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(source, file, imports) {
     const lists = [];
@@ -6067,7 +6362,7 @@ function resolveContractList(lists, file, name, seen = new Set()) {
     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);
@@ -6439,7 +6734,7 @@ function nextRoutePath(file, routeRoot) {
     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("/");