@beignet/cli 0.0.7 → 0.0.9

package/dist/inspect.js

@@ -5,6 +5,7 @@ import { parseProviderPackageMetadata, } from "@beignet/core/providers";
 import { createPainter } from "./ansi.js";
 import { directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
 import { formatGithubAnnotation, } from "./github-annotations.js";
+import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, outboxRegistryValueInfo, } from "./registry-edits.js";
 import { getCliVersion } from "./version.js";
 export async function inspectApp(options = {}) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
@@ -52,6 +53,14 @@ export async function applyDoctorFixes(options = {}) {
     const routeGroupFix = await fixUnregisteredRouteGroups(targetDir, files, config);
     if (routeGroupFix)
         fixes.push(routeGroupFix);
+    const drift = await workflowRegistrationDrift(targetDir, files, config);
+    const scheduleFix = await fixUnregisteredSchedules(targetDir, files, drift, config);
+    if (scheduleFix)
+        fixes.push(scheduleFix);
+    const taskFix = await fixUnregisteredTasks(targetDir, files, drift, config);
+    if (taskFix)
+        fixes.push(taskFix);
+    fixes.push(...(await fixUnregisteredOutboxEntries(targetDir, files, drift, config)));
     const openApiFix = await fixDirectOpenApiArrayDrift(targetDir, files, config, convention, contracts, matchedRoutes);
     if (openApiFix)
         fixes.push(openApiFix);
@@ -775,7 +784,7 @@ async function inspectDiagnostics(targetDir, files, config, convention, contract
     for (const routeHandler of matchedRoutes.unmatchedRouteHandlers) {
         diagnostics.push(unmatchedRouteDiagnostic(routeHandler));
     }
-    diagnostics.push(...(await inspectPackageScripts(targetDir, files, convention)), ...(await inspectOpenApiDrift(targetDir, files, config, convention, contracts, matchedRoutes)), ...(await inspectFeatureRouteRegistration(targetDir, files, config, convention, contracts)), ...(await inspectRouteErrorCatalogDrift(targetDir, files, config, convention, contracts, strict)), ...(await inspectCanonicalConformance(targetDir, files, config, convention, strict)), ...(await inspectVersionSkew(targetDir, files)), ...(await inspectProviderMetadataDrift(targetDir, files, convention)), ...(await inspectPortProviderDrift(targetDir, files, config, convention)), ...(await inspectProviderRegistrationDrift(targetDir, files, config, convention)), ...(await inspectDatabaseLifecycleDrift(targetDir, files, config, convention, strict)), ...(await inspectAuthzAuditDrift(targetDir, files, config, convention, contracts)), ...(await inspectServerlessFootguns(targetDir, files)), ...(await inspectProductionReadiness(targetDir, files, config, convention)), ...(await inspectFeatureArtifactDrift(targetDir, files, config, convention)), ...(await inspectResourceSlices(targetDir, files, config, convention, strict)));
+    diagnostics.push(...(await inspectPackageScripts(targetDir, files, convention)), ...(await inspectOpenApiDrift(targetDir, files, config, convention, contracts, matchedRoutes)), ...(await inspectFeatureRouteRegistration(targetDir, files, config, convention, contracts)), ...(await inspectRouteErrorCatalogDrift(targetDir, files, config, convention, contracts, strict)), ...(await inspectCanonicalConformance(targetDir, files, config, convention, strict)), ...(await inspectVersionSkew(targetDir, files)), ...(await inspectProviderMetadataDrift(targetDir, files, convention)), ...(await inspectPortProviderDrift(targetDir, files, config, convention)), ...(await inspectProviderRegistrationDrift(targetDir, files, config, convention)), ...(await inspectDatabaseLifecycleDrift(targetDir, files, config, convention, strict)), ...(await inspectAuthzAuditDrift(targetDir, files, config, convention, contracts)), ...(await inspectServerlessFootguns(targetDir, files)), ...(await inspectProductionReadiness(targetDir, files, config, convention)), ...(await inspectFeatureArtifactDrift(targetDir, files, config, convention)), ...(await inspectWorkflowRegistrationDrift(targetDir, files, config, convention)), ...(await inspectResourceSlices(targetDir, files, config, convention, strict)));
     return dedupeDiagnostics(diagnostics);
 }
 async function inspectCanonicalConformance(targetDir, files, config, convention, strict) {
@@ -1205,9 +1214,28 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
             });
         }
     }
+    const providerEntries = await readProviderListEntries(targetDir, files, config, sourceCache);
     for (const provider of providerDoctorRules) {
         if (!installedPackages.has(provider.packageName))
             continue;
+        if (provider.variants !== undefined) {
+            // Multi-variant packages only require the env vars of the variants the
+            // app actually registers; an unused variant must not warn.
+            for (const variant of detectedProviderVariants(provider.variants, providerEntries)) {
+                for (const envVar of variant.requiredEnv) {
+                    if (await anyFileContains(targetDir, configFiles, envVar, sourceCache)) {
+                        continue;
+                    }
+                    diagnostics.push({
+                        severity: "warning",
+                        code: "BEIGNET_PROVIDER_ENV_MISSING",
+                        file: "package.json",
+                        message: `${provider.packageName} is installed and ${variant.displayName} is registered, but ${envVar} is not mentioned in app env/config files. ${variant.displayName} requires ${envVar}; add the environment variable or remove the provider registration.`,
+                    });
+                }
+            }
+            continue;
+        }
         for (const envVar of provider.requiredEnv ?? []) {
             if (await anyFileContains(targetDir, configFiles, envVar, sourceCache)) {
                 continue;
@@ -1351,17 +1379,31 @@ async function inspectProviderRegistrationDrift(targetDir, files, config, conven
     const providerDoctorRules = await providerDoctorRulesForInstalledPackages(targetDir, packageJson);
     const providerFiles = serverProviderFiles(files, config);
     const sourceCache = new Map();
-    const providerSource = (await Promise.all(providerFiles.map((file) => readCachedSource(targetDir, file, sourceCache)))).join("\n");
-    const providerListSource = extractProviderListSource(providerSource);
-    const providerEntries = providerListSource === undefined
-        ? []
-        : providerListEntries(providerListSource);
+    const providerEntries = await readProviderListEntries(targetDir, files, config, sourceCache);
     for (const provider of providerDoctorRules) {
+        if (!installedPackages.has(provider.packageName))
+            continue;
+        if (provider.variants !== undefined) {
+            if (detectedProviderVariants(provider.variants, providerEntries).length > 0) {
+                continue;
+            }
+            const severity = providerVariantRegistrationSeverity(provider.variants);
+            if (severity === undefined)
+                continue;
+            const hints = provider.variants
+                .filter((variant) => variant.tokens.length > 0)
+                .map((variant) => registrationTokenHint(variant.tokens));
+            diagnostics.push({
+                severity,
+                code: "BEIGNET_PROVIDER_REGISTRATION_MISSING",
+                file: providerFiles[0] ?? config.paths.server,
+                message: `${provider.packageName} is installed, but no ${provider.displayName} variant is registered in server/providers.ts. Register one of the available providers (${hints.join(", ")}) in the exported providers array or remove the unused package.`,
+            });
+            continue;
+        }
         const severity = provider.registrationSeverity;
         if (severity === undefined)
             continue;
-        if (!installedPackages.has(provider.packageName))
-            continue;
         if (provider.tokens.some((token) => providerEntries.some((entry) => entry.includes(token)))) {
             continue;
         }
@@ -1375,8 +1417,12 @@ async function inspectProviderRegistrationDrift(targetDir, files, config, conven
         });
     }
     const drizzleIndex = findProviderEntryIndex(providerEntries, [
-        "drizzleTursoProvider",
-        "createDrizzleTursoProvider",
+        "drizzleSqliteProvider",
+        "createDrizzleSqliteProvider",
+        "drizzlePostgresProvider",
+        "createDrizzlePostgresProvider",
+        "drizzleMysqlProvider",
+        "createDrizzleMysqlProvider",
     ]);
     const appDatabaseProviderIndex = findProviderEntryIndex(providerEntries, [
         "starterDatabaseProvider",
@@ -1391,7 +1437,7 @@ async function inspectProviderRegistrationDrift(targetDir, files, config, conven
             severity: "warning",
             code: "BEIGNET_PROVIDER_ORDER",
             file: providerFiles[0] ?? config.paths.server,
-            message: "An app database provider is registered before createDrizzleTursoProvider(...). Register the Drizzle/Turso provider first so app-owned database wiring can read ctx.ports.db during setup.",
+            message: "An app database provider is registered before the Drizzle database provider. Register the Drizzle database provider first so app-owned database wiring can read ctx.ports.db during setup.",
         });
     }
     return diagnostics;
@@ -1474,10 +1520,39 @@ function providerDoctorRuleFromMetadata(packageName, metadata) {
         tokens: registration?.tokens ?? [],
         appPorts: metadata.appPorts ?? [],
         requiredEnv: metadata.requiredEnv ?? [],
-        registrationSeverity: registration?.severity ??
-            (registration?.required === true ? "warning" : undefined),
+        registrationSeverity: registrationSeverityFromMetadata(registration),
+        variants: metadata.variants?.map((variant) => ({
+            name: variant.name,
+            displayName: variant.displayName ?? variant.name,
+            tokens: variant.registration?.tokens ?? [],
+            requiredEnv: variant.requiredEnv ?? [],
+            registrationSeverity: registrationSeverityFromMetadata(variant.registration),
+        })),
     };
 }
+function registrationSeverityFromMetadata(registration) {
+    return (registration?.severity ??
+        (registration?.required === true ? "warning" : undefined));
+}
+function detectedProviderVariants(variants, providerEntries) {
+    return variants.filter((variant) => variant.tokens.some((token) => providerEntries.some((entry) => entry.includes(token))));
+}
+function providerVariantRegistrationSeverity(variants) {
+    const severities = variants.map((variant) => variant.registrationSeverity);
+    if (severities.includes("warning"))
+        return "warning";
+    if (severities.includes("hint"))
+        return "hint";
+    return undefined;
+}
+async function readProviderListEntries(targetDir, files, config, sourceCache) {
+    const providerFiles = serverProviderFiles(files, config);
+    const providerSource = (await Promise.all(providerFiles.map((file) => readCachedSource(targetDir, file, sourceCache)))).join("\n");
+    const providerListSource = extractProviderListSource(providerSource);
+    return providerListSource === undefined
+        ? []
+        : providerListEntries(providerListSource);
+}
 function registrationTokenHint(tokens) {
     const token = tokens[0];
     if (!token)
@@ -1810,6 +1885,290 @@ function isInfraOrServerFile(file, config) {
 function containsCallExpression(source, name) {
     return new RegExp(`\\b${escapeRegExp(name)}\\s*(?:<[^;=(){}]*>\\s*)?\\(`).test(source);
 }
+const workflowRegistrySuffixes = {
+    schedules: "Schedules",
+    tasks: "Tasks",
+    events: "Events",
+    jobs: "Jobs",
+    listeners: "Listeners",
+};
+async function inspectWorkflowRegistrationDrift(targetDir, files, config, convention) {
+    if (!convention.resourceGenerator)
+        return [];
+    const drift = await workflowRegistrationDrift(targetDir, files, config);
+    const diagnostics = [];
+    for (const kind of ["schedules", "tasks"]) {
+        const { centralExists, unregistered } = drift[kind];
+        const centralFile = kind === "schedules" ? config.paths.schedules : config.paths.tasks;
+        const code = kind === "schedules"
+            ? "BEIGNET_SCHEDULE_UNREGISTERED"
+            : "BEIGNET_TASK_UNREGISTERED";
+        const registrationTarget = kind === "schedules" ? "the schedules array" : "defineTasks([...])";
+        const makeCommand = kind === "schedules" ? "beignet make schedule" : "beignet make task";
+        const noun = kind === "schedules" ? "schedule" : "task";
+        for (const { registry, missingMembers } of unregistered) {
+            for (const member of missingMembers) {
+                diagnostics.push({
+                    severity: "error",
+                    code,
+                    file: centralExists ? centralFile : registry.indexFile,
+                    message: centralExists
+                        ? `${workflowArtifactOrigin(registry, member)}, but it is not registered in ${registrationTarget} in ${centralFile}, so the ${noun} never runs. Import ${registry.registryName} and spread it into the ${kind} list.`
+                        : `${workflowArtifactOrigin(registry, member)}, but ${centralFile} does not exist, so the ${noun} never runs. Register ${registry.registryName} in ${centralFile} (or run \`${makeCommand}\` to create it).`,
+                });
+            }
+        }
+    }
+    if (drift.outbox.exists) {
+        for (const { registry, missingMembers } of drift.outbox.events) {
+            for (const member of missingMembers) {
+                diagnostics.push({
+                    severity: "warning",
+                    code: "BEIGNET_OUTBOX_EVENT_UNREGISTERED",
+                    file: config.paths.outbox,
+                    message: `${workflowArtifactOrigin(registry, member)} and listeners react to it, but it is not registered in the events list of defineOutboxRegistry({...}) in ${config.paths.outbox}, so outbox drain cannot deliver it. Import ${registry.registryName} and spread it into the events list.`,
+                });
+            }
+        }
+        for (const { registry, missingMembers } of drift.outbox.jobs) {
+            for (const member of missingMembers) {
+                diagnostics.push({
+                    severity: "warning",
+                    code: "BEIGNET_OUTBOX_JOB_UNREGISTERED",
+                    file: config.paths.outbox,
+                    message: `${workflowArtifactOrigin(registry, member)}, but it is not registered in the jobs list of defineOutboxRegistry({...}) in ${config.paths.outbox}, so outbox drain cannot deliver it. Import ${registry.registryName} and spread it into the jobs list.`,
+                });
+            }
+        }
+    }
+    const infraDir = directoryPath(path.dirname(config.paths.infrastructurePorts));
+    const listenerTarget = drift.listeners.wiringFile
+        ? `${drift.listeners.wiringFile}, which already calls registerListeners(...)`
+        : drift.listeners.eventBusFile
+            ? `${drift.listeners.eventBusFile}, which creates the event bus`
+            : `an infra provider under ${infraDir}/`;
+    for (const { registry, missingMembers } of drift.listeners.unregistered) {
+        for (const member of missingMembers) {
+            diagnostics.push({
+                severity: "warning",
+                code: "BEIGNET_LISTENER_UNREGISTERED",
+                file: drift.listeners.wiringFile ??
+                    drift.listeners.eventBusFile ??
+                    registry.indexFile,
+                message: `${workflowArtifactOrigin(registry, member)}, but no registerListeners(...) call references it, so the listener never receives events. Register ${registry.registryName} with registerListeners(...) in ${listenerTarget}.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+function workflowArtifactOrigin(registry, member) {
+    const memberFile = registry.memberFiles.get(member) ?? registry.indexFile;
+    if (memberFile === registry.indexFile) {
+        return `${registry.indexFile} declares ${member} in ${registry.registryName}`;
+    }
+    return `${memberFile} declares ${member} (exported through ${registry.registryName} in ${registry.indexFile})`;
+}
+async function workflowRegistrationDrift(targetDir, files, config) {
+    const registries = await readFeatureWorkflowRegistries(targetDir, files, config);
+    const byKind = (kind) => registries.filter((registry) => registry.kind === kind);
+    const drift = {
+        schedules: {
+            centralExists: files.includes(config.paths.schedules),
+            unregistered: [],
+        },
+        tasks: {
+            centralExists: files.includes(config.paths.tasks),
+            unregistered: [],
+        },
+        outbox: {
+            exists: files.includes(config.paths.outbox),
+            events: [],
+            jobs: [],
+        },
+        listeners: { unregistered: [] },
+    };
+    if (registries.length === 0)
+        return drift;
+    for (const kind of ["schedules", "tasks"]) {
+        const kindRegistries = byKind(kind);
+        if (kindRegistries.length === 0)
+            continue;
+        const central = drift[kind];
+        const registered = central.centralExists
+            ? registeredWorkflowIdentifiers(await readFile(path.join(targetDir, kind === "schedules"
+                ? config.paths.schedules
+                : config.paths.tasks), "utf8"), kind)
+            : new Set();
+        central.unregistered = unregisteredWorkflowRegistries(kindRegistries, registered);
+    }
+    if (drift.outbox.exists) {
+        const eventRegistries = byKind("events");
+        const jobRegistries = byKind("jobs");
+        if (eventRegistries.length > 0 || jobRegistries.length > 0) {
+            const outboxSource = await readFile(path.join(targetDir, config.paths.outbox), "utf8");
+            if (eventRegistries.length > 0) {
+                // Events without listeners have nothing to deliver on drain, so only
+                // record-only events stay out of the registry without a warning.
+                const listened = await listenedEventNames(targetDir, files, config);
+                const value = outboxRegistryValueInfo(outboxSource, "events");
+                const registered = value
+                    ? identifiersFromArrayExpression(value.text)
+                    : new Set();
+                drift.outbox.events = unregisteredWorkflowRegistries(eventRegistries, registered, (member) => listened.has(member));
+            }
+            if (jobRegistries.length > 0) {
+                const value = outboxRegistryValueInfo(outboxSource, "jobs");
+                const registered = value
+                    ? identifiersFromArrayExpression(value.text)
+                    : new Set();
+                drift.outbox.jobs = unregisteredWorkflowRegistries(jobRegistries, registered);
+            }
+        }
+    }
+    const listenerRegistries = byKind("listeners");
+    if (listenerRegistries.length > 0) {
+        const wiring = await listenerWiringReferences(targetDir, files);
+        drift.listeners = {
+            unregistered: unregisteredWorkflowRegistries(listenerRegistries, wiring.identifiers),
+            wiringFile: wiring.wiringFile,
+            eventBusFile: wiring.eventBusFile,
+        };
+    }
+    return drift;
+}
+function unregisteredWorkflowRegistries(registries, registered, memberApplies = () => true) {
+    const unregistered = [];
+    for (const registry of registries) {
+        if (registered.has(registry.registryName))
+            continue;
+        const missingMembers = registry.members.filter((member) => !registered.has(member) && memberApplies(member));
+        if (missingMembers.length === 0)
+            continue;
+        unregistered.push({
+            registry,
+            missingMembers,
+            fullyUnregistered: registry.members.every((member) => !registered.has(member)),
+        });
+    }
+    return unregistered;
+}
+async function readFeatureWorkflowRegistries(targetDir, files, config) {
+    const registries = [];
+    const featuresPath = directoryPath(config.paths.features);
+    const kinds = [
+        "schedules",
+        "tasks",
+        "events",
+        "jobs",
+        "listeners",
+    ];
+    for (const kind of kinds) {
+        const folder = kind === "events" ? "domain/events" : kind;
+        const pattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`);
+        for (const file of files) {
+            if (!pattern.test(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");
+            for (const exportMatch of source.matchAll(exportRegex)) {
+                const registryName = exportMatch[1];
+                const info = arrayInitializerInfo(source, registryName);
+                if (!info)
+                    continue;
+                const members = [...identifiersFromArrayExpression(info.text)];
+                if (members.length === 0)
+                    continue;
+                registries.push({
+                    kind,
+                    registryName,
+                    indexFile: file,
+                    members,
+                    memberFiles,
+                });
+            }
+        }
+    }
+    return registries;
+}
+function exportedMemberFiles(source, indexFile, files) {
+    const memberFiles = new Map();
+    const referenceRegex = /(?:import|export)\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+    for (const match of source.matchAll(referenceRegex)) {
+        const resolved = sourceFileFromImport(match[2], indexFile, files);
+        if (!resolved || !files.includes(resolved))
+            continue;
+        for (const member of match[1].split(",")) {
+            const parsed = parseImportMember(member);
+            if (parsed)
+                memberFiles.set(parsed.localName, resolved);
+        }
+    }
+    return memberFiles;
+}
+function registeredWorkflowIdentifiers(source, kind) {
+    if (kind === "tasks") {
+        const call = /\bdefineTasks\s*(?:<[^>]*>\s*)?\(/.exec(source);
+        if (call) {
+            const firstArg = firstCallArgInfo(source, call.index + call[0].length);
+            if (firstArg)
+                return identifiersFromArrayExpression(firstArg.text);
+        }
+    }
+    const info = arrayInitializerInfo(source, kind === "tasks" ? "tasks" : "schedules");
+    return info ? identifiersFromArrayExpression(info.text) : new Set();
+}
+async function listenedEventNames(targetDir, files, config) {
+    const featuresPath = directoryPath(config.paths.features);
+    const listenerPattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`);
+    const listened = new Set();
+    for (const file of files) {
+        if (!listenerPattern.test(file) || isWorkflowTestFile(file))
+            continue;
+        const source = await readFile(path.join(targetDir, file), "utf8");
+        for (const match of source.matchAll(/\bdefineListener\s*(?:<[^>]*>\s*)?\(\s*([A-Za-z_$][\w$]*)/g)) {
+            listened.add(match[1]);
+        }
+    }
+    return listened;
+}
+async function listenerWiringReferences(targetDir, files) {
+    const identifiers = new Set();
+    let wiringFile;
+    let eventBusFile;
+    for (const file of files) {
+        if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
+            continue;
+        if (file.endsWith(".d.ts") || isWorkflowTestFile(file))
+            continue;
+        const source = await readFile(path.join(targetDir, file), "utf8");
+        let foundCall = false;
+        for (const match of source.matchAll(/\bregisterListeners\s*\(/g)) {
+            const openParen = (match.index ?? 0) + match[0].length - 1;
+            const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
+            const argsText = closeParen === -1
+                ? source.slice(openParen)
+                : source.slice(openParen + 1, closeParen);
+            foundCall = true;
+            for (const identifier of identifiersFromArrayExpression(argsText)) {
+                identifiers.add(identifier);
+            }
+        }
+        if (foundCall) {
+            wiringFile ??= file;
+        }
+        else if (!eventBusFile && /\bcreate\w*EventBus\s*\(/.test(source)) {
+            eventBusFile = file;
+        }
+    }
+    return { identifiers, wiringFile, eventBusFile };
+}
+function isWorkflowTestFile(file) {
+    return (file.endsWith(".test.ts") ||
+        file.endsWith(".test.tsx") ||
+        file.startsWith("tests/") ||
+        file.includes("/tests/"));
+}
 async function inspectServerlessFootguns(targetDir, files) {
     const diagnostics = [];
     for (const file of files) {
@@ -2612,6 +2971,115 @@ async function fixUnregisteredRouteGroups(targetDir, files, config) {
             .join(", ")} in the central route list.`,
     };
 }
+async function fixUnregisteredSchedules(targetDir, files, drift, config) {
+    if (!drift.schedules.centralExists)
+        return undefined;
+    return applyWorkflowRegistryFix({
+        targetDir,
+        files,
+        centralFile: config.paths.schedules,
+        unregistered: drift.schedules.unregistered,
+        code: "BEIGNET_SCHEDULE_UNREGISTERED",
+        listName: "the schedules array",
+        importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+        append: (source, entry, importLine) => appendToNamedArray(source, "schedules", entry, importLine),
+    });
+}
+async function fixUnregisteredTasks(targetDir, files, drift, config) {
+    if (!drift.tasks.centralExists)
+        return undefined;
+    return applyWorkflowRegistryFix({
+        targetDir,
+        files,
+        centralFile: config.paths.tasks,
+        unregistered: drift.tasks.unregistered,
+        code: "BEIGNET_TASK_UNREGISTERED",
+        listName: "defineTasks([...])",
+        importSpecifier: (indexFile) => relativeModule(config.paths.tasks, indexFile),
+        append: (source, entry, importLine) => appendToNamedArray(source, "tasks", entry, importLine),
+    });
+}
+async function fixUnregisteredOutboxEntries(targetDir, files, drift, config) {
+    if (!drift.outbox.exists)
+        return [];
+    const fixes = [];
+    const eventFix = await applyWorkflowRegistryFix({
+        targetDir,
+        files,
+        centralFile: config.paths.outbox,
+        unregistered: drift.outbox.events,
+        code: "BEIGNET_OUTBOX_EVENT_UNREGISTERED",
+        listName: "the outbox events list",
+        importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+        append: (source, entry, importLine) => appendToOutboxRegistryArray(source, "events", entry, importLine),
+    });
+    if (eventFix)
+        fixes.push(eventFix);
+    const jobFix = await applyWorkflowRegistryFix({
+        targetDir,
+        files,
+        centralFile: config.paths.outbox,
+        unregistered: drift.outbox.jobs,
+        code: "BEIGNET_OUTBOX_JOB_UNREGISTERED",
+        listName: "the outbox jobs list",
+        importSpecifier: (indexFile) => `@/${modulePath(indexFile)}`,
+        append: (source, entry, importLine) => appendToOutboxRegistryArray(source, "jobs", entry, importLine),
+    });
+    if (jobFix)
+        fixes.push(jobFix);
+    return fixes;
+}
+/**
+ * Append `...<feature><Kind>` registry spreads to an existing central
+ * registry file.
+ *
+ * Bails without writing when an import for the registry name resolves to a
+ * different file, when the registry anchor is missing or unparseable, or when
+ * some members are already individually registered (appending the registry
+ * spread would run those members twice). The diagnostic stays in that case.
+ */
+async function applyWorkflowRegistryFix(options) {
+    const candidates = options.unregistered.filter((entry) => entry.fullyUnregistered);
+    if (candidates.length === 0)
+        return undefined;
+    const centralPath = path.join(options.targetDir, options.centralFile);
+    let original;
+    try {
+        original = await readFile(centralPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    let next = original;
+    const registeredNames = [];
+    for (const { registry } of candidates) {
+        const imported = parseNamedImportSources(next).get(registry.registryName);
+        let importLine;
+        if (imported) {
+            const importedFile = sourceFileFromImport(imported.sourcePath, options.centralFile, options.files);
+            if (importedFile !== registry.indexFile)
+                return undefined;
+        }
+        else {
+            importLine = `import { ${registry.registryName} } from "${options.importSpecifier(registry.indexFile)}";`;
+        }
+        const result = options.append(next, `...${registry.registryName}`, importLine);
+        if (result.kind === "missing")
+            return undefined;
+        if (result.kind === "updated") {
+            next = result.source;
+            registeredNames.push(registry.registryName);
+        }
+    }
+    if (next === original || registeredNames.length === 0)
+        return undefined;
+    await writeFile(centralPath, next);
+    return {
+        code: options.code,
+        file: options.centralFile,
+        message: `Registered ${registeredNames.join(", ")} in ${options.listName}.`,
+    };
+}
 function routeRegistryFileFromServerSource(source, serverFile, files) {
     const imports = parseNamedImportSources(source);
     for (const identifier of routeOptionIdentifiers(source)) {
@@ -2753,49 +3221,7 @@ function trimmedSlice(source, start, end) {
         end: trimmedEnd,
     };
 }
-function contractsFromArrayExpression(expression) {
-    const withoutBrackets = expression.replace(/^\[/, "").replace(/\]$/, "");
-    return new Set(Array.from(withoutBrackets.matchAll(/\b[A-Za-z_$][\w$]*\b/g), ([name]) => name));
-}
-function appendToArrayExpression(expression, names) {
-    const closingBracket = /\]\s*$/.exec(expression);
-    if (!closingBracket)
-        return expression;
-    const beforeClosingBracket = expression.slice(0, closingBracket.index);
-    const closingBracketText = expression.slice(closingBracket.index);
-    const inner = beforeClosingBracket.replace(/^\[/, "");
-    if (!inner.trim())
-        return `[${names.join(", ")}]`;
-    if (!expression.includes("\n")) {
-        const separator = /,\s*$/.test(inner) ? " " : ", ";
-        return `${beforeClosingBracket}${separator}${names.join(", ")}${closingBracketText}`;
-    }
-    const itemIndent = inner
-        .split("\n")
-        .find((line) => line.trim())
-        ?.match(/^[\t ]*/)?.[0] ?? "\t";
-    const closingIndent = inner.match(/\n([\t ]*)$/)?.[1] ?? "";
-    const trimmedBeforeClosingBracket = beforeClosingBracket.replace(/\s*$/, "");
-    const appendedNames = names.join(`,\n${itemIndent}`);
-    if (/,\s*$/.test(inner)) {
-        return `${trimmedBeforeClosingBracket}\n${itemIndent}${appendedNames},\n${closingIndent}${closingBracketText}`;
-    }
-    return `${trimmedBeforeClosingBracket},\n${itemIndent}${appendedNames}${closingBracketText}`;
-}
-function insertAfterImports(source, line) {
-    const lines = source.split("\n");
-    let lastImportIndex = -1;
-    for (let index = 0; index < lines.length; index++) {
-        if (lines[index].startsWith("import ")) {
-            lastImportIndex = index;
-        }
-    }
-    if (lastImportIndex === -1) {
-        return `${line}\n${source}`;
-    }
-    lines.splice(lastImportIndex + 1, 0, line);
-    return lines.join("\n");
-}
+const contractsFromArrayExpression = identifiersFromArrayExpression;
 function hasImportedIdentifier(source, identifier) {
     const importRegex = /import\s+\{([^}]+)\}\s+from\s+["'][^"']+["']/g;
     for (const match of source.matchAll(importRegex)) {