@beignet/cli 0.0.44 → 0.0.46

package/src/inspect.ts

@@ -2,6 +2,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
 import { createPainter } from "./ansi.js";
+import type { DatabaseSchemaDialect, DatabaseSchemaTable } from "./choices.js";
 import {
   type BeignetConfig,
   type BeignetDatabaseTables,
@@ -15,6 +16,7 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "./config.js";
+import { renderDatabaseSchema, resolveDatabaseSchemaDialect } from "./db.js";
 import {
   applyPlannedDoctorFixes,
   createDoctorFixPlan,
@@ -390,6 +392,36 @@ async function buildDoctorFixPlan(
   );
   if (listenerFix) operations.push(listenerFix);
 
+  const databaseFix = await planMissingProviderTables(targetDir, files, config);
+  if (databaseFix) operations.push(databaseFix);
+
+  const inngestFix = await planUnregisteredInngestJobs(
+    targetDir,
+    files,
+    config,
+  );
+  if (inngestFix) operations.push(inngestFix);
+
+  const nonOverlappingOperations =
+    nonOverlappingDoctorFixOperations(operations);
+  operations.splice(0, operations.length, ...nonOverlappingOperations);
+  const sourceOverrides = new Map<string, string>();
+  for (const operation of operations) {
+    for (const change of operation.changes) {
+      sourceOverrides.set(change.file, change.after);
+    }
+  }
+  const runtimeManifestFix = await planRuntimeManifestRegistries(
+    targetDir,
+    files,
+    config,
+    convention,
+    sourceOverrides,
+  );
+  if (runtimeManifestFix) {
+    addRuntimeManifestFix(operations, runtimeManifestFix);
+  }
+
   const openApiFix = await planDirectOpenApiArrayDrift(
     targetDir,
     files,
@@ -403,10 +435,77 @@ async function buildDoctorFixPlan(
   return createDoctorFixPlan({
     targetDir,
     strict: Boolean(options.strict),
-    operations,
+    operations: nonOverlappingDoctorFixOperations(operations),
   });
 }
 
+function nonOverlappingDoctorFixOperations(
+  operations: PlannedDoctorFixOperation[],
+): PlannedDoctorFixOperation[] {
+  const claimedFiles = new Set<string>();
+  const safeOperations: PlannedDoctorFixOperation[] = [];
+
+  for (const operation of operations) {
+    if (operation.changes.some((change) => claimedFiles.has(change.file))) {
+      continue;
+    }
+    safeOperations.push(operation);
+    for (const change of operation.changes) claimedFiles.add(change.file);
+  }
+
+  return safeOperations;
+}
+
+const workflowDoctorFixOperationIds = new Set<DoctorFixOperationId>([
+  "schedules.register-missing",
+  "tasks.register-missing",
+  "workflows.register-missing",
+  "outbox.register-missing",
+  "listeners.register-missing",
+  "inngest.register-missing",
+  "runtime-manifest.register-missing",
+]);
+
+function addRuntimeManifestFix(
+  operations: PlannedDoctorFixOperation[],
+  runtimeManifestFix: PlannedDoctorFixOperation,
+): void {
+  const runtimeChange = runtimeManifestFix.changes[0];
+  if (!runtimeChange) return;
+
+  const overlappingOperation = operations.find((operation) =>
+    operation.changes.some((change) => change.file === runtimeChange.file),
+  );
+  if (!overlappingOperation) {
+    operations.push(runtimeManifestFix);
+    return;
+  }
+  if (!workflowDoctorFixOperationIds.has(overlappingOperation.id)) return;
+
+  overlappingOperation.id = "workflows.register-missing";
+  overlappingOperation.fixes.push(...runtimeManifestFix.fixes);
+  overlappingOperation.changes = overlappingOperation.changes.map((change) =>
+    change.file === runtimeChange.file
+      ? planDoctorFixFileChange({
+          file: change.file,
+          before: change.before,
+          after: runtimeChange.after,
+        })
+      : change,
+  );
+
+  const existingWorkflowOperation = operations.find(
+    (operation) =>
+      operation !== overlappingOperation &&
+      operation.id === "workflows.register-missing",
+  );
+  if (!existingWorkflowOperation) return;
+
+  existingWorkflowOperation.fixes.push(...overlappingOperation.fixes);
+  existingWorkflowOperation.changes.push(...overlappingOperation.changes);
+  operations.splice(operations.indexOf(overlappingOperation), 1);
+}
+
 /**
  * Format inspected routes as a CLI table.
  */
@@ -2347,6 +2446,10 @@ async function inspectProductionReadiness(
     packageJson,
   );
   const configFiles = operationalConfigFiles(files, config);
+  const cronDirectory = path.posix.join(
+    directoryPath(config.paths.routes),
+    "cron",
+  );
   const infrastructurePath = directoryPath(
     path.dirname(config.paths.portWiring),
   );
@@ -2380,16 +2483,17 @@ async function inspectProductionReadiness(
     }
 
     if (
-      file.startsWith("app/api/cron/") &&
+      fileWithinDirectory(file, cronDirectory) &&
       file.endsWith("/route.ts") &&
       !/\bCRON_SECRET\b/.test(source) &&
-      !/\bcreateOutboxDrainRoute\s*\(/.test(source)
+      !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
+      !/\bcreateScheduleRoute\s*\(/.test(source)
     ) {
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_CRON_SECRET_MISSING",
         file,
-        message: `${file} looks like a cron route that does not reference CRON_SECRET. Protect cron entrypoints with a shared secret or a framework helper such as createOutboxDrainRoute(...).`,
+        message: `${file} looks like a cron route that does not reference CRON_SECRET. Protect cron entrypoints with a shared secret or a framework helper such as createOutboxDrainRoute(...) or createScheduleRoute(...).`,
       });
     }
 
@@ -3264,27 +3368,28 @@ async function inspectInngestProductionPath(
       "utf8",
     );
     const registry = arrayInitializerInfo(registrySource, "inngestJobs");
-    const registeredJobs = registry
-      ? identifiersFromArrayExpression(registry.text)
-      : new Set<string>();
-    const featureRoot = directoryPath(config.paths.features);
-    const jobIndexes = files.filter((file) =>
-      new RegExp(`^${escapeRegExp(featureRoot)}/[^/]+/jobs/index\\.ts$`).test(
-        file,
-      ),
+    const featureJobs = (
+      await readFeatureWorkflowRegistries(targetDir, files, config)
+    ).filter((entry) => entry.kind === "jobs");
+    const registeredJobs = canonicalRegisteredWorkflowIdentifiers({
+      source: registrySource,
+      registered: registry
+        ? identifiersFromArrayExpression(registry.text)
+        : new Set<string>(),
+      centralFile: registryFile,
+      files,
+      registries: featureJobs,
+    });
+    const unregisteredJobs = unregisteredWorkflowRegistries(
+      featureJobs,
+      registeredJobs,
     );
-    for (const jobIndex of jobIndexes) {
-      const source = await readFile(path.join(targetDir, jobIndex), "utf8");
-      const match = source.match(/export const\s+([A-Za-z_$][\w$]*Jobs)\s*=/);
-      const registryName = match?.[1];
-      if (!registryName || registeredJobs.has(registryName)) {
-        continue;
-      }
+    for (const { registry: featureRegistry } of unregisteredJobs) {
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_INNGEST_JOB_REGISTRATION_MISSING",
         file: registryFile,
-        message: `${jobIndex} exports ${registryName}, but it is not registered in inngestJobs in ${registryFile}. Add ...${registryName} so Inngest can execute the job.`,
+        message: `${featureRegistry.indexFile} exports ${featureRegistry.registryName}, but it is not registered in inngestJobs in ${registryFile}. Add ...${featureRegistry.registryName} so Inngest can execute the job.`,
       });
     }
   }
@@ -3882,9 +3987,15 @@ function isInfraOrServerFile(
 }
 
 function containsCallExpression(source: string, name: string): boolean {
-  return new RegExp(
+  const codeIndexes = new Set(codeCharacterIndexes(source));
+  const pattern = new RegExp(
     `\\b${escapeRegExp(name)}\\s*(?:<[^;=(){}]*>\\s*)?\\(`,
-  ).test(source);
+    "g",
+  );
+
+  return [...source.matchAll(pattern)].some(
+    (match) => match.index !== undefined && codeIndexes.has(match.index),
+  );
 }
 
 type WorkflowRegistryKind =
@@ -4053,6 +4164,10 @@ async function inspectRuntimeManifestDrift(
     files,
     config,
   );
+  const manifestSource = await readFile(
+    path.join(targetDir, manifest.file),
+    "utf8",
+  );
   const diagnostics: InspectDiagnostic[] = [];
 
   const checks: readonly {
@@ -4094,9 +4209,18 @@ async function inspectRuntimeManifestDrift(
   ];
 
   for (const check of checks) {
+    const kindRegistries = registries.filter(
+      (registry) => registry.kind === check.kind,
+    );
     const missing = unregisteredWorkflowRegistries(
-      registries.filter((registry) => registry.kind === check.kind),
-      check.registered,
+      kindRegistries,
+      canonicalRegisteredWorkflowIdentifiers({
+        source: manifestSource,
+        registered: check.registered,
+        centralFile: manifest.file,
+        files,
+        registries: kindRegistries,
+      }),
     );
 
     for (const { registry, missingMembers } of missing) {
@@ -4271,6 +4395,48 @@ function unregisteredWorkflowRegistries(
   return unregistered;
 }
 
+function canonicalRegisteredWorkflowIdentifiers(options: {
+  source: string;
+  registered: Set<string>;
+  centralFile: string;
+  files: string[];
+  registries: FeatureWorkflowRegistry[];
+}): Set<string> {
+  const canonical = new Set(options.registered);
+  const imports = parseNamedImportSources(options.source);
+
+  for (const identifier of options.registered) {
+    const imported = imports.get(identifier);
+    if (!imported) continue;
+
+    const importedFile = sourceFileFromImport(
+      imported.sourcePath,
+      options.centralFile,
+      options.files,
+    );
+    if (!importedFile) continue;
+
+    for (const registry of options.registries) {
+      if (
+        imported.importedName === registry.registryName &&
+        importedFile === registry.indexFile
+      ) {
+        canonical.add(registry.registryName);
+      }
+
+      if (
+        registry.members.includes(imported.importedName) &&
+        (importedFile === registry.indexFile ||
+          registry.memberFiles.get(imported.importedName) === importedFile)
+      ) {
+        canonical.add(imported.importedName);
+      }
+    }
+  }
+
+  return canonical;
+}
+
 async function readFeatureWorkflowRegistries(
   targetDir: string,
   files: string[],
@@ -4350,6 +4516,8 @@ async function readRuntimeManifestIdentifiers(
   targetDir: string,
   files: string[],
 ): Promise<RuntimeManifestIdentifierSets | undefined> {
+  const manifests: RuntimeManifestIdentifierSets[] = [];
+
   for (const file of files) {
     if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
     if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
@@ -4357,25 +4525,29 @@ async function readRuntimeManifestIdentifiers(
     const source = await readFile(path.join(targetDir, file), "utf8");
     if (!source.includes("defineRuntimeManifest")) continue;
 
+    const calls = runtimeManifestCallMatches(source);
+    if (calls.length === 0) continue;
+    if (calls.length !== 1) return undefined;
     const identifiers = runtimeManifestIdentifiers(source);
     if (identifiers) {
-      return {
+      manifests.push({
         file,
         ...identifiers,
-      };
+      });
     }
   }
 
-  return undefined;
+  return manifests.length === 1 ? manifests[0] : undefined;
 }
 
 function runtimeManifestIdentifiers(
   source: string,
 ): Omit<RuntimeManifestIdentifierSets, "file"> | undefined {
-  const call = /\bdefineRuntimeManifest\s*(?:<[^>]*>\s*)?\(/.exec(source);
-  if (!call) return undefined;
+  const calls = runtimeManifestCallMatches(source);
+  if (calls.length !== 1) return undefined;
+  const call = calls[0];
 
-  const arg = firstCallArgInfo(source, call.index + call[0].length);
+  const arg = firstCallArgInfo(source, (call.index ?? 0) + call[0].length);
   if (!arg) return undefined;
 
   const outbox = objectPropertyValueInfo(arg.text, "outbox");
@@ -4393,6 +4565,15 @@ function runtimeManifestIdentifiers(
   };
 }
 
+function runtimeManifestCallMatches(source: string): RegExpMatchArray[] {
+  const codeIndexes = new Set(codeCharacterIndexes(source));
+  return [
+    ...source.matchAll(/\bdefineRuntimeManifest\s*(?:<[^>]*>\s*)?\(/g),
+  ].filter(
+    (match) => match.index !== undefined && codeIndexes.has(match.index),
+  );
+}
+
 function identifiersFromPropertyArray(
   source: string,
   property: string,
@@ -4406,24 +4587,48 @@ function objectPropertyValueInfo(
   source: string,
   property: string,
 ): { text: string; start: number; end: number } | undefined {
-  const propertyMatch = new RegExp(`\\b${property}\\s*:`).exec(source);
-  if (!propertyMatch) return undefined;
+  let depth = 0;
+
+  for (const index of codeCharacterIndexes(source)) {
+    const char = source[index];
+    if (char === "{" || char === "[" || char === "(") {
+      depth++;
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      depth--;
+      continue;
+    }
+    if (
+      depth !== 1 ||
+      source.slice(index, index + property.length) !== property ||
+      /[A-Za-z0-9_$]/.test(source[index - 1] ?? "")
+    ) {
+      continue;
+    }
 
-  let start = propertyMatch.index + propertyMatch[0].length;
-  while (start < source.length && /\s/.test(source[start])) start++;
+    let colon = index + property.length;
+    if (/[A-Za-z0-9_$]/.test(source[colon] ?? "")) continue;
+    while (colon < source.length && /\s/.test(source[colon])) colon++;
+    if (source[colon] !== ":") continue;
 
-  const open = source[start];
-  const close = open === "[" ? "]" : open === "{" ? "}" : undefined;
-  if (!close) return undefined;
+    let start = colon + 1;
+    while (start < source.length && /\s/.test(source[start])) start++;
+    const open = source[start];
+    const close = open === "[" ? "]" : open === "{" ? "}" : undefined;
+    if (!close) return undefined;
 
-  const end = matchingDelimiterIndex(source, start, open, close);
-  if (end === -1) return undefined;
+    const end = matchingDelimiterIndex(source, start, open, close);
+    if (end === -1) return undefined;
 
-  return {
-    text: source.slice(start, end + 1),
-    start,
-    end: end + 1,
-  };
+    return {
+      text: source.slice(start, end + 1),
+      start,
+      end: end + 1,
+    };
+  }
+
+  return undefined;
 }
 
 function registeredWorkflowIdentifiers(
@@ -4607,6 +4812,8 @@ async function inspectServerlessFootguns(
   convention: InspectConvention,
 ): Promise<InspectDiagnostic[]> {
   const diagnostics: InspectDiagnostic[] = [];
+  const routeDirectory = directoryPath(config.paths.routes);
+  const cronDirectory = path.posix.join(routeDirectory, "cron");
 
   for (const file of files) {
     if (
@@ -4617,12 +4824,9 @@ async function inspectServerlessFootguns(
       continue;
     }
 
-    const isInfraOrServerFile =
-      file.startsWith("infra/") || file.startsWith("server/");
-    const isProviderFile =
-      /(^|\/)provider(s)?\.ts$/.test(file) ||
-      /(^|\/)[^/]*provider[^/]*\.ts$/.test(file);
     const source = await readFile(path.join(targetDir, file), "utf8");
+    const isInfraOrServerFile = isRuntimeFile(file, config);
+    const isProviderFile = isProviderLifecycleFile(file, source);
 
     if (
       config.framework === "next" &&
@@ -4666,7 +4870,7 @@ async function inspectServerlessFootguns(
     }
 
     if (
-      file.startsWith("app/api/cron/") &&
+      fileWithinDirectory(file, cronDirectory) &&
       file.endsWith("/route.ts") &&
       !/\bauthorization\b/i.test(source) &&
       !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
@@ -4682,8 +4886,8 @@ async function inspectServerlessFootguns(
   }
 
   if (
-    hasOutboxRegistry(files) &&
-    !(await appHasOutboxDrainEntrypoint(targetDir, files))
+    hasOutboxRegistry(files, config) &&
+    !(await appHasOutboxDrainEntrypoint(targetDir, files, config))
   ) {
     diagnostics.push({
       severity: "warning",
@@ -4696,6 +4900,82 @@ async function inspectServerlessFootguns(
   return diagnostics;
 }
 
+function configuredRuntimeFiles(config: ResolvedBeignetConfig): string[] {
+  return [
+    config.paths.server,
+    config.paths.listeners,
+    config.paths.tasks,
+    config.paths.outbox,
+    config.paths.schedules,
+    config.paths.portWiring,
+  ];
+}
+
+function configuredRuntimeDirectories(config: ResolvedBeignetConfig): string[] {
+  const applicationDirectories = configuredApplicationDirectories(config);
+
+  return configuredRuntimeFiles(config)
+    .map((file) => directoryPath(path.posix.dirname(file)))
+    .filter((directory) => directory !== ".")
+    .filter(
+      (directory) =>
+        !applicationDirectories.some(
+          (applicationDirectory) =>
+            applicationDirectory !== directory &&
+            fileWithinDirectory(applicationDirectory, directory),
+        ),
+    )
+    .filter((directory, index, all) => all.indexOf(directory) === index);
+}
+
+function configuredApplicationDirectories(
+  config: ResolvedBeignetConfig,
+): string[] {
+  return [
+    config.paths.contracts,
+    config.paths.routes,
+    config.paths.features,
+    config.paths.policies,
+    config.paths.useCases,
+    config.paths.tests,
+  ]
+    .map(directoryPath)
+    .filter((directory) => directory !== ".")
+    .filter((directory, index, all) => all.indexOf(directory) === index);
+}
+
+function isRuntimeFile(file: string, config: ResolvedBeignetConfig): boolean {
+  if (configuredRuntimeFiles(config).includes(file)) return true;
+  if (
+    configuredApplicationDirectories(config).some((directory) =>
+      fileWithinDirectory(file, directory),
+    )
+  ) {
+    return false;
+  }
+
+  return (
+    fileWithinDirectory(file, "infra") ||
+    fileWithinDirectory(file, "server") ||
+    configuredRuntimeDirectories(config).some((directory) =>
+      fileWithinDirectory(file, directory),
+    )
+  );
+}
+
+function fileWithinDirectory(file: string, directory: string): boolean {
+  return directory === "." || file.startsWith(`${directory}/`);
+}
+
+function isProviderLifecycleFile(file: string, source?: string): boolean {
+  return (
+    /(^|\/)provider(s)?\.ts$/.test(file) ||
+    /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    /(^|\/)providers?\//.test(file) ||
+    (source !== undefined && containsCallExpression(source, "createProvider"))
+  );
+}
+
 function isNextRouteFile(file: string, config: ResolvedBeignetConfig): boolean {
   const routesPath = directoryPath(config.paths.routes);
 
@@ -4727,33 +5007,35 @@ function importsEagerServer(
   return false;
 }
 
-function hasOutboxRegistry(files: string[]): boolean {
-  return files.some(isOutboxRegistryFile);
-}
-
-function isOutboxRegistryFile(file: string): boolean {
-  return file === "server/outbox.ts";
+function hasOutboxRegistry(
+  files: string[],
+  config: ResolvedBeignetConfig,
+): boolean {
+  return files.includes(config.paths.outbox);
 }
 
 async function appHasOutboxDrainEntrypoint(
   targetDir: string,
   files: string[],
+  config: ResolvedBeignetConfig,
 ): Promise<boolean> {
+  const routesDirectory = directoryPath(config.paths.routes);
+
   for (const file of files) {
     if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
     if (
-      !file.startsWith("app/api/") &&
-      !file.startsWith("server/") &&
-      !file.startsWith("infra/")
+      !fileWithinDirectory(file, routesDirectory) &&
+      !isRuntimeFile(file, config)
     ) {
       continue;
     }
 
     const source = await readFile(path.join(targetDir, file), "utf8");
-    if (
-      /\bcreateOutboxDrainRoute\s*\(/.test(source) ||
-      /\bdrainOutbox\s*\(/.test(source)
-    ) {
+    if (containsCallExpression(source, "createOutboxDrainRoute")) {
+      return true;
+    }
+    if (isProviderLifecycleFile(file, source)) continue;
+    if (containsCallExpression(source, "drainOutbox")) {
       return true;
     }
   }
@@ -4948,7 +5230,9 @@ async function inspectDatabaseLifecycleDrift(
     );
     for (const schemaFile of schemaFiles) {
       const moduleName = path.basename(schemaFile, ".ts");
-      if (schemaIndexSource.includes(`"./${moduleName}"`)) continue;
+      if (schemaIndexExportKind(schemaIndexSource, `./${moduleName}`)) {
+        continue;
+      }
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_DB_SCHEMA_EXPORT_MISSING",
@@ -6815,6 +7099,467 @@ function findRouteGroupContract(
   );
 }
 
+const managedDatabaseSchemaMarker = "// Managed by beignet db schema sync.";
+const databaseSchemaExports: Record<DatabaseSchemaTable, string> = {
+  audit: "auditLog",
+  idempotency: "idempotencyRecords",
+  outbox: "outboxMessages",
+};
+
+async function planMissingProviderTables(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<PlannedDoctorFixOperation | undefined> {
+  const infrastructurePath = directoryPath(
+    path.dirname(config.paths.portWiring),
+  );
+  const schemaDir = `${infrastructurePath}/db/schema`;
+  const output = `${schemaDir}/beignet.ts`;
+  const indexFile = `${schemaDir}/index.ts`;
+  if (!files.includes(indexFile)) return undefined;
+
+  const sourceCache = new Map<string, string>();
+  const usageFiles = durableDrizzleUsageFiles(files, config);
+  const requiredDefaultTables: DatabaseSchemaTable[] = [];
+  const missingTables: DatabaseSchemaTable[] = [];
+  const fixes: InspectFix[] = [];
+
+  for (const requirement of durableDrizzleTableRequirements) {
+    const defaultTableName =
+      defaultBeignetConfig.database.tables[requirement.table];
+    if (config.database.tables[requirement.table] !== defaultTableName) {
+      continue;
+    }
+
+    const configuredTables = await configuredDurableDrizzleTableNames(
+      targetDir,
+      usageFiles,
+      config,
+      requirement,
+      sourceCache,
+    );
+    if (!configuredTables.has(defaultTableName)) continue;
+    requiredDefaultTables.push(requirement.table);
+
+    if (
+      await durableDrizzleTableExists(
+        targetDir,
+        files,
+        config,
+        infrastructurePath,
+        schemaDir,
+        requirement,
+        defaultTableName,
+        sourceCache,
+      )
+    ) {
+      continue;
+    }
+
+    missingTables.push(requirement.table);
+    fixes.push({
+      code: requirement.code,
+      file: output,
+      message: `Added the default ${defaultTableName} provider table export to ${output}.`,
+    });
+  }
+
+  const outputPath = path.join(targetDir, output);
+  let originalOutput: string | undefined;
+  try {
+    originalOutput = await readFile(outputPath, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  const existingTables =
+    originalOutput === undefined
+      ? []
+      : managedDatabaseSchemaTables(originalOutput);
+  if (existingTables === undefined) return undefined;
+  const originalIndex = await readFile(path.join(targetDir, indexFile), "utf8");
+  const managedExportKind = schemaIndexExportKind(originalIndex, "./beignet");
+  if (managedExportKind === "named") return undefined;
+  const needsManagedExport =
+    originalOutput !== undefined &&
+    existingTables.some((table) => requiredDefaultTables.includes(table)) &&
+    managedExportKind === undefined;
+  if (missingTables.length === 0 && !needsManagedExport) return undefined;
+  if (needsManagedExport) {
+    fixes.push({
+      code: "BEIGNET_DB_SCHEMA_EXPORT_MISSING",
+      file: indexFile,
+      message: `Exported ${output} from ${indexFile}.`,
+    });
+  }
+
+  const selectedTables = (
+    Object.keys(databaseSchemaExports) as DatabaseSchemaTable[]
+  ).filter(
+    (table) => existingTables.includes(table) || missingTables.includes(table),
+  );
+
+  let nextOutput = originalOutput;
+  if (missingTables.length > 0) {
+    let dialect: Awaited<ReturnType<typeof resolveDatabaseSchemaDialect>>;
+    try {
+      dialect = await resolveDatabaseSchemaDialect(targetDir, undefined);
+    } catch {
+      return undefined;
+    }
+    nextOutput = renderDatabaseSchema(dialect, selectedTables);
+  }
+  if (nextOutput === undefined) return undefined;
+
+  const addedExportNames = missingTables.map(
+    (table) => databaseSchemaExports[table],
+  );
+  const otherSchemaFiles = files.filter(
+    (file) =>
+      file.startsWith(`${schemaDir}/`) &&
+      file.endsWith(".ts") &&
+      file !== indexFile &&
+      file !== output,
+  );
+  for (const schemaFile of [indexFile, ...otherSchemaFiles]) {
+    const source =
+      schemaFile === indexFile
+        ? originalIndex
+        : await readFile(path.join(targetDir, schemaFile), "utf8");
+    if (addedExportNames.some((name) => exportsIdentifier(source, name))) {
+      return undefined;
+    }
+  }
+  const nextIndex =
+    managedExportKind === "all"
+      ? originalIndex
+      : `${originalIndex.trimEnd()}\nexport * from "./beignet";\n`;
+
+  const changes = [
+    ...(originalOutput === nextOutput
+      ? []
+      : [
+          planDoctorFixFileChange({
+            file: output,
+            before: originalOutput,
+            after: nextOutput,
+          }),
+        ]),
+    ...(originalIndex === nextIndex
+      ? []
+      : [
+          planDoctorFixFileChange({
+            file: indexFile,
+            before: originalIndex,
+            after: nextIndex,
+          }),
+        ]),
+  ];
+  if (changes.length === 0) return undefined;
+
+  return {
+    id: "database.sync-provider-tables",
+    fixes,
+    changes,
+  };
+}
+
+function schemaIndexExportKind(
+  source: string,
+  moduleSpecifier: string,
+): "all" | "named" | undefined {
+  const codeIndexes = new Set(codeCharacterIndexes(source));
+  const escaped = escapeRegExp(moduleSpecifier);
+  const allPattern = new RegExp(
+    `\\bexport\\s*\\*\\s*from\\s*["']${escaped}["']`,
+    "g",
+  );
+  if (
+    [...source.matchAll(allPattern)].some(
+      (match) => match.index !== undefined && codeIndexes.has(match.index),
+    )
+  ) {
+    return "all";
+  }
+
+  const customPatterns = [
+    new RegExp(
+      `\\bexport\\s*\\{[\\s\\S]*?\\}\\s*from\\s*["']${escaped}["']`,
+      "g",
+    ),
+    new RegExp(
+      `\\bexport\\s*\\*\\s+as\\s+[A-Za-z_$][\\w$]*\\s+from\\s*["']${escaped}["']`,
+      "g",
+    ),
+  ];
+  return customPatterns.some((pattern) =>
+    [...source.matchAll(pattern)].some(
+      (match) => match.index !== undefined && codeIndexes.has(match.index),
+    ),
+  )
+    ? "named"
+    : undefined;
+}
+
+function exportsIdentifier(source: string, identifier: string): boolean {
+  const executableSource = Array.from({ length: source.length }, () => " ");
+  for (const index of codeCharacterIndexes(source)) {
+    executableSource[index] = source.charAt(index);
+  }
+
+  const escaped = escapeRegExp(identifier);
+  const patterns = [
+    new RegExp(
+      `\\bexport\\s+(?:const|let|var|class|function)\\s+${escaped}\\b`,
+    ),
+    new RegExp(`\\bexport\\s*\\{[^}]*\\b${escaped}\\b[^}]*\\}`),
+  ];
+
+  const code = executableSource.join("");
+  return patterns.some((pattern) => pattern.test(code));
+}
+
+function managedDatabaseSchemaTables(
+  source: string,
+): DatabaseSchemaTable[] | undefined {
+  if (!source.startsWith(managedDatabaseSchemaMarker)) return undefined;
+
+  const dialect =
+    /@beignet\/provider-db-drizzle\/(sqlite|postgres|mysql)\/schema/.exec(
+      source,
+    )?.[1] as DatabaseSchemaDialect | undefined;
+  if (!dialect) return undefined;
+
+  const tables = (
+    Object.entries(databaseSchemaExports) as Array<
+      [DatabaseSchemaTable, string]
+    >
+  )
+    .filter(([, exportName]) =>
+      new RegExp(`\\b${escapeRegExp(exportName)}\\b`).test(source),
+    )
+    .map(([table]) => table);
+  if (tables.length === 0) return undefined;
+
+  return renderDatabaseSchema(dialect, tables) === source ? tables : undefined;
+}
+
+async function planUnregisteredInngestJobs(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<PlannedDoctorFixOperation | undefined> {
+  const packageJson = await readPackageJson(targetDir, files);
+  if (
+    !installedPackageNames(packageJson).has("@beignet/provider-jobs-inngest")
+  ) {
+    return undefined;
+  }
+
+  const serverDir = directoryPath(path.dirname(config.paths.server));
+  const registryFile = `${serverDir}/inngest.ts`;
+  if (!files.includes(registryFile)) return undefined;
+
+  const source = await readFile(path.join(targetDir, registryFile), "utf8");
+  const registry = arrayInitializerInfo(source, "inngestJobs");
+  if (!registry) return undefined;
+
+  const featureJobs = (
+    await readFeatureWorkflowRegistries(targetDir, files, config)
+  ).filter((entry) => entry.kind === "jobs");
+  const unregistered = unregisteredWorkflowRegistries(
+    featureJobs,
+    canonicalRegisteredWorkflowIdentifiers({
+      source,
+      registered: identifiersFromArrayExpression(registry.text),
+      centralFile: registryFile,
+      files,
+      registries: featureJobs,
+    }),
+  );
+
+  return planWorkflowRegistryOperation("inngest.register-missing", {
+    targetDir,
+    files,
+    centralFile: registryFile,
+    unregistered,
+    code: "BEIGNET_INNGEST_JOB_REGISTRATION_MISSING",
+    listName: "the Inngest jobs array",
+    importSpecifier: (indexFile) => relativeModule(registryFile, indexFile),
+    append: (nextSource, entry, importLine) =>
+      appendToNamedArray(nextSource, "inngestJobs", entry, importLine),
+  });
+}
+
+const runtimeManifestRepairChecks: readonly {
+  kind: WorkflowRegistryKind;
+  code: string;
+  listName: string;
+}[] = [
+  {
+    kind: "listeners",
+    code: "BEIGNET_RUNTIME_MANIFEST_LISTENER_MISSING",
+    listName: "the runtime manifest listeners array",
+  },
+  {
+    kind: "schedules",
+    code: "BEIGNET_RUNTIME_MANIFEST_SCHEDULE_MISSING",
+    listName: "the runtime manifest schedules array",
+  },
+  {
+    kind: "tasks",
+    code: "BEIGNET_RUNTIME_MANIFEST_TASK_MISSING",
+    listName: "the runtime manifest tasks array",
+  },
+  {
+    kind: "events",
+    code: "BEIGNET_RUNTIME_MANIFEST_OUTBOX_EVENT_MISSING",
+    listName: "the runtime manifest outbox events array",
+  },
+  {
+    kind: "jobs",
+    code: "BEIGNET_RUNTIME_MANIFEST_OUTBOX_JOB_MISSING",
+    listName: "the runtime manifest outbox jobs array",
+  },
+];
+
+async function planRuntimeManifestRegistries(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  convention: InspectConvention,
+  sourceOverrides: ReadonlyMap<string, string> = new Map(),
+): Promise<PlannedDoctorFixOperation | undefined> {
+  if (!convention.resourceGenerator) return undefined;
+
+  const manifest = await readRuntimeManifestIdentifiers(targetDir, files);
+  if (!manifest) return undefined;
+
+  const original =
+    sourceOverrides.get(manifest.file) ??
+    (await readFile(path.join(targetDir, manifest.file), "utf8"));
+  const registries = await readFeatureWorkflowRegistries(
+    targetDir,
+    files,
+    config,
+  );
+  let next = original;
+  const fixes: InspectFix[] = [];
+
+  for (const check of runtimeManifestRepairChecks) {
+    const parsedRegistered =
+      runtimeManifestIdentifiers(next)?.[
+        runtimeManifestIdentifierKey(check.kind)
+      ];
+    if (!parsedRegistered) continue;
+    const kindRegistries = registries.filter(
+      (registry) => registry.kind === check.kind,
+    );
+    const registered = canonicalRegisteredWorkflowIdentifiers({
+      source: next,
+      registered: parsedRegistered,
+      centralFile: manifest.file,
+      files,
+      registries: kindRegistries,
+    });
+
+    const edit = planWorkflowRegistryEdit({
+      files,
+      centralFile: manifest.file,
+      source: next,
+      unregistered: unregisteredWorkflowRegistries(kindRegistries, registered),
+      code: check.code,
+      listName: check.listName,
+      importSpecifier: (indexFile) => relativeModule(manifest.file, indexFile),
+      append: (nextSource, entry, importLine) =>
+        appendToRuntimeManifestArray(nextSource, check.kind, entry, importLine),
+    });
+    if (!edit) continue;
+    next = edit.after;
+    fixes.push(edit.fix);
+  }
+
+  if (fixes.length === 0 || next === original) return undefined;
+
+  return {
+    id: "runtime-manifest.register-missing",
+    fixes,
+    changes: [
+      planDoctorFixFileChange({
+        file: manifest.file,
+        before: original,
+        after: next,
+      }),
+    ],
+  };
+}
+
+function runtimeManifestIdentifierKey(
+  kind: WorkflowRegistryKind,
+): keyof Omit<RuntimeManifestIdentifierSets, "file"> {
+  return kind;
+}
+
+function runtimeManifestArrayInfo(
+  source: string,
+  kind: WorkflowRegistryKind,
+): { text: string; start: number; end: number } | undefined {
+  const calls = runtimeManifestCallMatches(source);
+  if (calls.length !== 1) return undefined;
+  const call = calls[0];
+
+  const arg = firstCallArgInfo(source, (call.index ?? 0) + call[0].length);
+  if (!arg) return undefined;
+
+  if (kind === "listeners" || kind === "schedules" || kind === "tasks") {
+    const value = objectPropertyValueInfo(arg.text, kind);
+    return value
+      ? {
+          text: value.text,
+          start: arg.start + value.start,
+          end: arg.start + value.end,
+        }
+      : undefined;
+  }
+
+  const outbox = objectPropertyValueInfo(arg.text, "outbox");
+  if (!outbox) return undefined;
+  const value = objectPropertyValueInfo(outbox.text, kind);
+  return value
+    ? {
+        text: value.text,
+        start: arg.start + outbox.start + value.start,
+        end: arg.start + outbox.start + value.end,
+      }
+    : undefined;
+}
+
+function appendToRuntimeManifestArray(
+  source: string,
+  kind: WorkflowRegistryKind,
+  entry: string,
+  importLine?: string,
+): AppendResult {
+  const value = runtimeManifestArrayInfo(source, kind);
+  if (!value?.text.startsWith("[")) return { kind: "missing" };
+
+  const entryName = entry.replace(/^\.{3}/, "").trim();
+  if (identifiersFromArrayExpression(value.text).has(entryName)) {
+    return { kind: "unchanged" };
+  }
+
+  const nextArray = appendToArrayExpression(value.text, [entry]);
+  let next = `${source.slice(0, value.start)}${nextArray}${source.slice(
+    value.end,
+  )}`;
+  if (importLine && !next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+  return next === source
+    ? { kind: "unchanged" }
+    : { kind: "updated", source: next };
+}
+
 async function planDirectOpenApiArrayDrift(
   targetDir: string,
   files: string[],
@@ -7372,7 +8117,8 @@ function planWorkflowRegistryEdit(
   const registeredNames: string[] = [];
 
   for (const { registry } of candidates) {
-    const imported = parseNamedImportSources(next).get(registry.registryName);
+    const imports = parseNamedImportSources(next);
+    const imported = imports.get(registry.registryName);
     let importLine: string | undefined;
 
     if (imported) {
@@ -7383,6 +8129,21 @@ function planWorkflowRegistryEdit(
       );
       if (importedFile !== registry.indexFile) return undefined;
     } else {
+      const aliasesRegistry = [...imports.entries()].some(
+        ([localName, candidate]) =>
+          localName !== registry.registryName &&
+          candidate.importedName === registry.registryName &&
+          sourceFileFromImport(
+            candidate.sourcePath,
+            options.centralFile,
+            options.files,
+          ) === registry.indexFile,
+      );
+      if (aliasesRegistry) return undefined;
+      if (sourceContainsCodeIdentifier(next, registry.registryName)) {
+        return undefined;
+      }
+
       importLine = `import { ${registry.registryName} } from "${options.importSpecifier(
         registry.indexFile,
       )}";`;
@@ -7412,6 +8173,22 @@ function planWorkflowRegistryEdit(
   };
 }
 
+function sourceContainsCodeIdentifier(
+  source: string,
+  identifier: string,
+): boolean {
+  const codeIndexes = new Set(codeCharacterIndexes(source));
+  const pattern = new RegExp(
+    `(^|[^A-Za-z0-9_$])${escapeRegExp(identifier)}(?![A-Za-z0-9_$])`,
+    "g",
+  );
+  return [...source.matchAll(pattern)].some(
+    (match) =>
+      match.index !== undefined &&
+      codeIndexes.has(match.index + (match[1]?.length ?? 0)),
+  );
+}
+
 function routeRegistryFileFromServerSource(
   source: string,
   serverFile: string,