@beignet/cli 0.0.45 → 0.0.47

package/dist/inspect.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
 import { createPainter } from "./ansi.js";
 import { clientDirPath, clientFormsPath, clientIndexPath, defaultBeignetConfig, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
+import { renderDatabaseSchema, resolveDatabaseSchemaDialect } from "./db.js";
 import { applyPlannedDoctorFixes, createDoctorFixPlan, planDoctorFixFileChange, publicDoctorFixPlan, } from "./doctor-fixes.js";
 import { formatGithubAnnotation, } from "./github-annotations.js";
 import { createListenersRegistrySource, listenersFilePath, providersFilePath, updateListenersRegistrySource, wireListenersProviderSource, } from "./make/shared.js";
@@ -104,15 +105,83 @@ async function buildDoctorFixPlan(options = {}) {
     const listenerFix = await planUnregisteredListeners(targetDir, files, drift, config);
     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();
+    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, config, convention, contracts, matchedRoutes);
     if (openApiFix)
         operations.push(openApiFix);
     return createDoctorFixPlan({
         targetDir,
         strict: Boolean(options.strict),
-        operations,
+        operations: nonOverlappingDoctorFixOperations(operations),
     });
 }
+function nonOverlappingDoctorFixOperations(operations) {
+    const claimedFiles = new Set();
+    const safeOperations = [];
+    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([
+    "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, runtimeManifestFix) {
+    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.
  */
@@ -1967,23 +2036,23 @@ async function inspectInngestProductionPath(targetDir, files, config) {
     else {
         const registrySource = await readFile(path.join(targetDir, registryFile), "utf8");
         const registry = arrayInitializerInfo(registrySource, "inngestJobs");
-        const registeredJobs = registry
-            ? identifiersFromArrayExpression(registry.text)
-            : new Set();
-        const featureRoot = directoryPath(config.paths.features);
-        const jobIndexes = files.filter((file) => new RegExp(`^${escapeRegExp(featureRoot)}/[^/]+/jobs/index\\.ts$`).test(file));
-        for (const jobIndex of jobIndexes) {
-            const source = await readFile(path.join(targetDir, jobIndex), "utf8");
-            const match = source.match(/export const\s+([A-Za-z_$][\w$]*Jobs)\s*=/);
-            const registryName = match?.[1];
-            if (!registryName || registeredJobs.has(registryName)) {
-                continue;
-            }
+        const featureJobs = (await readFeatureWorkflowRegistries(targetDir, files, config)).filter((entry) => entry.kind === "jobs");
+        const registeredJobs = canonicalRegisteredWorkflowIdentifiers({
+            source: registrySource,
+            registered: registry
+                ? identifiersFromArrayExpression(registry.text)
+                : new Set(),
+            centralFile: registryFile,
+            files,
+            registries: featureJobs,
+        });
+        const unregisteredJobs = unregisteredWorkflowRegistries(featureJobs, registeredJobs);
+        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.`,
             });
         }
     }
@@ -2416,6 +2485,7 @@ async function inspectRuntimeManifestDrift(targetDir, files, config, convention)
     if (!manifest)
         return [];
     const registries = await readFeatureWorkflowRegistries(targetDir, files, config);
+    const manifestSource = await readFile(path.join(targetDir, manifest.file), "utf8");
     const diagnostics = [];
     const checks = [
         {
@@ -2450,7 +2520,14 @@ async function inspectRuntimeManifestDrift(targetDir, files, config, convention)
         },
     ];
     for (const check of checks) {
-        const missing = unregisteredWorkflowRegistries(registries.filter((registry) => registry.kind === check.kind), check.registered);
+        const kindRegistries = registries.filter((registry) => registry.kind === check.kind);
+        const missing = unregisteredWorkflowRegistries(kindRegistries, canonicalRegisteredWorkflowIdentifiers({
+            source: manifestSource,
+            registered: check.registered,
+            centralFile: manifest.file,
+            files,
+            registries: kindRegistries,
+        }));
         for (const { registry, missingMembers } of missing) {
             for (const member of missingMembers) {
                 diagnostics.push({
@@ -2561,6 +2638,30 @@ function unregisteredWorkflowRegistries(registries, registered, memberApplies =
     }
     return unregistered;
 }
+function canonicalRegisteredWorkflowIdentifiers(options) {
+    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, files, config) {
     const registries = [];
     const featuresPath = directoryPath(config.paths.features);
@@ -2616,6 +2717,7 @@ function exportedMemberFiles(source, indexFile, files) {
     return memberFiles;
 }
 async function readRuntimeManifestIdentifiers(targetDir, files) {
+    const manifests = [];
     for (const file of files) {
         if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
             continue;
@@ -2624,21 +2726,27 @@ async function readRuntimeManifestIdentifiers(targetDir, files) {
         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) {
-    const call = /\bdefineRuntimeManifest\s*(?:<[^>]*>\s*)?\(/.exec(source);
-    if (!call)
+    const calls = runtimeManifestCallMatches(source);
+    if (calls.length !== 1)
         return undefined;
-    const arg = firstCallArgInfo(source, call.index + call[0].length);
+    const call = calls[0];
+    const arg = firstCallArgInfo(source, (call.index ?? 0) + call[0].length);
     if (!arg)
         return undefined;
     const outbox = objectPropertyValueInfo(arg.text, "outbox");
@@ -2654,6 +2762,12 @@ function runtimeManifestIdentifiers(source) {
             : new Set(),
     };
 }
+function runtimeManifestCallMatches(source) {
+    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, property) {
     const value = objectPropertyValueInfo(source, property);
     if (!value?.text.startsWith("["))
@@ -2661,24 +2775,46 @@ function identifiersFromPropertyArray(source, property) {
     return identifiersFromArrayExpression(value.text);
 }
 function objectPropertyValueInfo(source, property) {
-    const propertyMatch = new RegExp(`\\b${property}\\s*:`).exec(source);
-    if (!propertyMatch)
-        return undefined;
-    let start = propertyMatch.index + propertyMatch[0].length;
-    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;
-    return {
-        text: source.slice(start, end + 1),
-        start,
-        end: end + 1,
-    };
+    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 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;
+        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;
+        return {
+            text: source.slice(start, end + 1),
+            start,
+            end: end + 1,
+        };
+    }
+    return undefined;
 }
 function registeredWorkflowIdentifiers(source, kind) {
     if (kind === "tasks") {
@@ -3084,8 +3220,9 @@ async function inspectDatabaseLifecycleDrift(targetDir, files, config, conventio
         const schemaIndexSource = await readFile(path.join(targetDir, schemaIndexFile), "utf8");
         for (const schemaFile of schemaFiles) {
             const moduleName = path.basename(schemaFile, ".ts");
-            if (schemaIndexSource.includes(`"./${moduleName}"`))
+            if (schemaIndexExportKind(schemaIndexSource, `./${moduleName}`)) {
                 continue;
+            }
             diagnostics.push({
                 severity: "warning",
                 code: "BEIGNET_DB_SCHEMA_EXPORT_MISSING",
@@ -4276,6 +4413,333 @@ function findRouteGroupContract(contracts, routeGroupContract) {
             contract.file ===
                 routeGroupContract.file.replace(/\.ts$/, "/index.ts")));
 }
+const managedDatabaseSchemaMarker = "// Managed by beignet db schema sync.";
+const databaseSchemaExports = {
+    audit: "auditLog",
+    idempotency: "idempotencyRecords",
+    outbox: "outboxMessages",
+};
+async function planMissingProviderTables(targetDir, files, config) {
+    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();
+    const usageFiles = durableDrizzleUsageFiles(files, config);
+    const requiredDefaultTables = [];
+    const missingTables = [];
+    const fixes = [];
+    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;
+    try {
+        originalOutput = await readFile(outputPath, "utf8");
+    }
+    catch (error) {
+        if (error.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).filter((table) => existingTables.includes(table) || missingTables.includes(table));
+    let nextOutput = originalOutput;
+    if (missingTables.length > 0) {
+        let dialect;
+        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, moduleSpecifier) {
+    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, identifier) {
+    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) {
+    if (!source.startsWith(managedDatabaseSchemaMarker))
+        return undefined;
+    const dialect = /@beignet\/provider-db-drizzle\/(sqlite|postgres|mysql)\/schema/.exec(source)?.[1];
+    if (!dialect)
+        return undefined;
+    const tables = Object.entries(databaseSchemaExports)
+        .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, files, config) {
+    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 = [
+    {
+        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, files, config, convention, sourceOverrides = new Map()) {
+    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 = [];
+    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) {
+    return kind;
+}
+function runtimeManifestArrayInfo(source, kind) {
+    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, kind, entry, importLine) {
+    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, files, config, convention, contracts, matchedRoutes) {
     const routePath = path.join(targetDir, config.paths.openapiRoute);
     let source;
@@ -4679,7 +5143,8 @@ function planWorkflowRegistryEdit(options) {
     let next = options.source;
     const registeredNames = [];
     for (const { registry } of candidates) {
-        const imported = parseNamedImportSources(next).get(registry.registryName);
+        const imports = parseNamedImportSources(next);
+        const imported = imports.get(registry.registryName);
         let importLine;
         if (imported) {
             const importedFile = sourceFileFromImport(imported.sourcePath, options.centralFile, options.files);
@@ -4687,6 +5152,14 @@ function planWorkflowRegistryEdit(options) {
                 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)}";`;
         }
         const result = options.append(next, `...${registry.registryName}`, importLine);
@@ -4708,6 +5181,12 @@ function planWorkflowRegistryEdit(options) {
         },
     };
 }
+function sourceContainsCodeIdentifier(source, identifier) {
+    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, serverFile, files) {
     const imports = parseNamedImportSources(source);
     for (const identifier of routeOptionIdentifiers(source)) {