@beignet/cli 0.0.47 → 0.0.49

package/src/preflight.ts

@@ -2,12 +2,15 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
 import { createJiti } from "jiti";
+import { runDatabaseStatus } from "./db.js";
 import {
   type InspectDiagnostic,
   inspectApp,
   productionHardeningDiagnosticCodes,
 } from "./inspect.js";
 import {
+  detectedProviderVariantsForRules,
+  formatProviderEnvAlternatives,
   installedPackageNames,
   type ProviderPackageJson,
   providerDoctorRulesForInstalledPackages,
@@ -46,8 +49,9 @@ export interface PreflightOptions {
    */
   doctor?: boolean;
   /**
-   * Boot the app server and run every port's `checkHealth()`. Needs network
-   * access and real credentials, so it is opt-in.
+   * Inspect database migration status, then boot the app server and run every
+   * port's `checkHealth()`. Needs network access and real credentials, so it
+   * is opt-in.
    */
   connect?: boolean;
   /**
@@ -56,9 +60,12 @@ export interface PreflightOptions {
    */
   serverModule?: string;
   /**
-   * Per-dependency health check timeout in milliseconds. Defaults to 5000.
+   * Per migration-status or dependency health check timeout in milliseconds.
+   * Defaults to 5000.
    */
   connectTimeoutMs?: number;
+  /** Cancel connected migration inspection and health checks on abort. */
+  signal?: AbortSignal;
 }
 
 export interface PreflightResult {
@@ -79,6 +86,15 @@ export interface PreflightResult {
    * Ports whose `checkHealth()` ran during a `connect` pass.
    */
   checkedDependencies: string[];
+  /**
+   * Database migration state observed before dependency checks.
+   */
+  migrationStatus:
+    | "not-checked"
+    | "current"
+    | "pending"
+    | "failed"
+    | "unavailable";
 }
 
 /**
@@ -175,6 +191,46 @@ function applyEnvToProcess(
   };
 }
 
+function appendProviderEnvFindings(options: {
+  owner: string;
+  required: readonly string[];
+  alternatives: readonly (readonly string[])[];
+  env: Readonly<Record<string, string | undefined>>;
+  requiredEnvKeys: Set<string>;
+  findings: PreflightFinding[];
+}): void {
+  for (const key of options.required) {
+    options.requiredEnvKeys.add(key);
+    const value = options.env[key];
+    if (value === undefined || value.trim() === "") {
+      options.findings.push({
+        severity: "error",
+        code: "BEIGNET_PREFLIGHT_ENV_MISSING",
+        message: `${key} is required by ${options.owner} but is not set.`,
+      });
+    }
+  }
+
+  for (const key of options.alternatives.flat()) {
+    options.requiredEnvKeys.add(key);
+  }
+  if (
+    options.alternatives.length > 0 &&
+    !options.alternatives.some((alternative) =>
+      alternative.every((key) => {
+        const value = options.env[key];
+        return value !== undefined && value.trim() !== "";
+      }),
+    )
+  ) {
+    options.findings.push({
+      severity: "error",
+      code: "BEIGNET_PREFLIGHT_ENV_MISSING",
+      message: `${options.owner} requires one complete environment configuration: ${formatProviderEnvAlternatives(options.alternatives)}.`,
+    });
+  }
+}
+
 /**
  * Validate the deploy environment against installed provider manifests, the
  * app's `.env.example` placeholders, and the app env schema module.
@@ -221,6 +277,7 @@ export async function runPreflight(
       envModuleChecked: false,
       doctorChecked: false,
       checkedDependencies: [],
+      migrationStatus: "not-checked",
     };
   }
 
@@ -230,19 +287,34 @@ export async function runPreflight(
   );
   const checkedProviders = rules.map((rule) => rule.packageName);
   const requiredEnvKeys = new Set<string>();
+  const detectedVariants = await detectedProviderVariantsForRules(
+    options.cwd,
+    rules,
+  );
 
   for (const rule of rules) {
-    for (const key of rule.requiredEnv ?? []) {
-      requiredEnvKeys.add(key);
-      const value = env[key];
-      if (value === undefined || value.trim() === "") {
-        findings.push({
-          severity: "error",
-          code: "BEIGNET_PREFLIGHT_ENV_MISSING",
-          message: `${key} is required by ${rule.packageName} but is not set.`,
+    if (rule.variants !== undefined) {
+      for (const variant of detectedVariants.get(rule.packageName) ?? []) {
+        appendProviderEnvFindings({
+          owner: `${rule.packageName} (${variant.displayName})`,
+          required: variant.requiredEnv,
+          alternatives: variant.requiredEnvAlternatives,
+          env,
+          requiredEnvKeys,
+          findings,
         });
       }
+      continue;
     }
+
+    appendProviderEnvFindings({
+      owner: rule.packageName,
+      required: rule.requiredEnv ?? [],
+      alternatives: rule.requiredEnvAlternatives ?? [],
+      env,
+      requiredEnvKeys,
+      findings,
+    });
   }
 
   const inngestDev = env.INNGEST_DEV?.trim().toLowerCase();
@@ -303,6 +375,7 @@ export async function runPreflight(
   let envModuleChecked = false;
   let doctorChecked = false;
   const checkedDependencies: string[] = [];
+  let migrationStatus: PreflightResult["migrationStatus"] = "not-checked";
   const restoreProcessEnv = applyEnvToProcess(env);
 
   try {
@@ -344,7 +417,67 @@ export async function runPreflight(
     }
 
     if (options.connect) {
-      await runDependencyChecks(options, findings, checkedDependencies);
+      if (!packageJson.scripts?.["db:status"]) {
+        migrationStatus = "unavailable";
+        findings.push({
+          severity: "note",
+          code: "BEIGNET_PREFLIGHT_DATABASE_STATUS_UNAVAILABLE",
+          message:
+            'No app-owned "db:status" script is configured; skipping pending migration detection.',
+        });
+      } else {
+        try {
+          const connectTimeoutMs = options.connectTimeoutMs ?? 5000;
+          const result = await runDatabaseStatus({
+            cwd: options.cwd,
+            captureOutput: true,
+            maxOutputBytes: 8 * 1024,
+            signal: options.signal,
+            timeoutMs: connectTimeoutMs,
+          });
+          migrationStatus = result.status;
+
+          if (result.status === "pending") {
+            findings.push({
+              severity: "error",
+              code: "BEIGNET_PREFLIGHT_DATABASE_MIGRATIONS_PENDING",
+              message: databaseStatusFindingMessage(
+                "Database migrations are pending. Run `beignet db migrate` in the serialized migration job before booting the app.",
+                result.stdout,
+                result.stderr,
+                result.outputTruncated,
+              ),
+            });
+          } else if (result.status === "failed") {
+            findings.push({
+              severity: "error",
+              code: "BEIGNET_PREFLIGHT_DATABASE_STATUS_FAILED",
+              message: databaseStatusFindingMessage(
+                result.timedOut
+                  ? `Database migration status inspection timed out after ${connectTimeoutMs}ms.`
+                  : "Database migration status inspection failed.",
+                result.stdout,
+                result.stderr,
+                result.outputTruncated,
+              ),
+            });
+          }
+        } catch (error) {
+          options.signal?.throwIfAborted();
+          migrationStatus = "failed";
+          findings.push({
+            severity: "error",
+            code: "BEIGNET_PREFLIGHT_DATABASE_STATUS_FAILED",
+            message: `Database migration status inspection failed: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          });
+        }
+      }
+
+      if (migrationStatus !== "pending" && migrationStatus !== "failed") {
+        await runDependencyChecks(options, findings, checkedDependencies);
+      }
     }
   } finally {
     restoreProcessEnv();
@@ -356,9 +489,26 @@ export async function runPreflight(
     envModuleChecked,
     doctorChecked,
     checkedDependencies,
+    migrationStatus,
   };
 }
 
+function databaseStatusFindingMessage(
+  summary: string,
+  stdout?: string,
+  stderr?: string,
+  outputTruncated?: boolean,
+): string {
+  const details = [
+    stdout?.trim() ? `stdout:\n${stdout.trim()}` : undefined,
+    stderr?.trim() ? `stderr:\n${stderr.trim()}` : undefined,
+  ].filter((value): value is string => value !== undefined);
+  if (outputTruncated) {
+    details.push("Output truncated; showing the retained tail.");
+  }
+  return [summary, ...details].join("\n");
+}
+
 interface HealthCheckable {
   checkHealth(): Promise<unknown>;
 }
@@ -381,10 +531,13 @@ async function withTimeout<T>(
   work: Promise<T>,
   ms: number,
   label: string,
+  signal?: AbortSignal,
 ): Promise<T> {
+  signal?.throwIfAborted();
   let timer: ReturnType<typeof setTimeout> | undefined;
+  let onAbort: (() => void) | undefined;
   try {
-    return await Promise.race([
+    const contenders: Promise<T>[] = [
       work,
       new Promise<never>((_, reject) => {
         timer = setTimeout(
@@ -392,9 +545,25 @@ async function withTimeout<T>(
           ms,
         );
       }),
-    ]);
+    ];
+    if (signal) {
+      contenders.push(
+        new Promise<never>((_, reject) => {
+          onAbort = () =>
+            reject(
+              signal.reason instanceof Error
+                ? signal.reason
+                : new Error("Connected preflight cancelled."),
+            );
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted) onAbort();
+        }),
+      );
+    }
+    return await Promise.race(contenders);
   } finally {
     if (timer !== undefined) clearTimeout(timer);
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
   }
 }
 
@@ -407,6 +576,7 @@ async function runDependencyChecks(
   findings: PreflightFinding[],
   checkedDependencies: string[],
 ): Promise<void> {
+  options.signal?.throwIfAborted();
   const serverModule = options.serverModule ?? "server/index.ts";
   const serverModulePath = path.resolve(options.cwd, serverModule);
   const timeoutMs = options.connectTimeoutMs ?? 5000;
@@ -424,6 +594,7 @@ async function runDependencyChecks(
     | { ports: Record<string, unknown>; stop?: () => Promise<void> }
     | undefined;
   try {
+    options.signal?.throwIfAborted();
     const jiti = createJiti(serverModulePath, {
       interopDefault: true,
       moduleCache: false,
@@ -452,6 +623,7 @@ async function runDependencyChecks(
       stop?: () => Promise<void>;
     };
   } catch (error) {
+    options.signal?.throwIfAborted();
     findings.push({
       severity: "error",
       code: "BEIGNET_PREFLIGHT_SERVER_BOOT_FAILED",
@@ -464,6 +636,7 @@ async function runDependencyChecks(
 
   try {
     for (const [name, port] of Object.entries(server.ports)) {
+      options.signal?.throwIfAborted();
       if (!isHealthCheckable(port)) continue;
       checkedDependencies.push(name);
       try {
@@ -471,6 +644,7 @@ async function runDependencyChecks(
           port.checkHealth(),
           timeoutMs,
           `${name}.checkHealth()`,
+          options.signal,
         );
         if (!healthResultOk(result)) {
           const message = (result as { message?: unknown }).message;
@@ -483,6 +657,7 @@ async function runDependencyChecks(
           });
         }
       } catch (error) {
+        options.signal?.throwIfAborted();
         findings.push({
           severity: "error",
           code: "BEIGNET_PREFLIGHT_DEPENDENCY_UNHEALTHY",
@@ -534,14 +709,18 @@ export function formatPreflight(result: PreflightResult, cwd: string): string {
   const dependencySummary = result.checkedDependencies.length
     ? `, ${result.checkedDependencies.length} dependency health check(s) run`
     : "";
+  const migrationSummary =
+    result.migrationStatus === "not-checked"
+      ? "migration status not checked"
+      : `migration status ${result.migrationStatus}`;
 
   if (errors.length === 0) {
     lines.push(
-      `Preflight passed in ${cwd}: ${providerSummary} checked, ${envSummary}, ${doctorSummary}${dependencySummary}.`,
+      `Preflight passed in ${cwd}: ${providerSummary} checked, ${envSummary}, ${doctorSummary}, ${migrationSummary}${dependencySummary}.`,
     );
   } else {
     lines.push(
-      `Preflight failed in ${cwd}: ${errors.length} error(s) across ${providerSummary}, ${envSummary}, ${doctorSummary}${dependencySummary}.`,
+      `Preflight failed in ${cwd}: ${errors.length} error(s) across ${providerSummary}, ${envSummary}, ${doctorSummary}, ${migrationSummary}${dependencySummary}.`,
     );
   }
 

package/src/provider-add.ts

@@ -1,5 +1,6 @@
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import ts from "typescript";
 import {
   type ProviderPresetName,
   providerPresetChoices,
@@ -164,7 +165,10 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "Add a worker entrypoint that runs createBullMQJobWorker(...) in a worker process; dispatched jobs do not execute without one. See the jobs docs page.",
       "Run beignet provider audit and beignet doctor --strict.",
     ],
-    conflictingProviderEntries: ["createInngestJobsProvider"],
+    conflictingProviderEntries: [
+      "createInngestJobsProvider",
+      "inlineJobsProvider",
+    ],
   },
   "jobs-inngest": {
     name: "jobs-inngest",
@@ -215,7 +219,10 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "For non-Next runtimes, call createAppInngestFunctions(...) after creating the app server, then mount the result with Inngest's host adapter.",
       "Run beignet provider audit and beignet doctor --strict.",
     ],
-    conflictingProviderEntries: ["createBullMQJobsProvider"],
+    conflictingProviderEntries: [
+      "createBullMQJobsProvider",
+      "inlineJobsProvider",
+    ],
   },
   "mail-resend": {
     name: "mail-resend",
@@ -276,7 +283,14 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       importName: "MailerPort",
       importFrom: "@beignet/core/mail",
     },
-    envVars: ["MAIL_HOST", "MAIL_PORT", "MAIL_USER", "MAIL_PASS", "MAIL_FROM"],
+    envVars: [
+      "MAIL_HOST",
+      "MAIL_PORT",
+      "MAIL_USER",
+      "MAIL_PASS",
+      "MAIL_FROM",
+      "MAIL_REQUIRE_TLS",
+    ],
     envExample: [
       "# SMTP mail provider",
       "MAIL_HOST=smtp.example.com",
@@ -284,6 +298,7 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "MAIL_USER=dev-placeholder-change-me",
       "MAIL_PASS=dev-placeholder-change-me",
       "MAIL_FROM=Beignet App <noreply@example.com>",
+      "MAIL_REQUIRE_TLS=true",
       "",
     ].join("\n"),
     docs: [
@@ -293,12 +308,13 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "- Peer dependency: `nodemailer`",
       "- The preset wires `createSmtpMailProvider()` in `server/providers.ts` and defers `mailer` in `infra/port-wiring.ts`.",
       "- `.env.example` ships dev placeholders so the app boots; set real `MAIL_*` values before sending mail.",
+      "- Encrypted transport is required by default: port 465 uses implicit TLS and other ports must negotiate STARTTLS.",
       "- Use `ctx.ports.mailer` in app code; `ctx.ports.smtp` is available as an escape hatch.",
       "",
     ].join("\n"),
     nextSteps: [
       "Run your package manager install command.",
-      "Set MAIL_HOST, MAIL_PORT, MAIL_USER, MAIL_PASS, and MAIL_FROM in .env.local or your deployment environment.",
+      "Set MAIL_HOST, MAIL_PORT, MAIL_USER, MAIL_PASS, and MAIL_FROM in .env.local or your deployment environment; keep MAIL_REQUIRE_TLS=true outside trusted local capture services.",
       "Run beignet provider audit and beignet doctor --strict.",
     ],
     conflictingProviderEntries: [
@@ -561,6 +577,7 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
     dependencies: (packageJson) => ({
       "@beignet/provider-storage-s3": beignetDependencyVersion(packageJson),
       "@aws-sdk/client-s3": externalVersions.awsSdkS3,
+      "@aws-sdk/lib-storage": externalVersions.awsSdkLibStorage,
       "@aws-sdk/s3-request-presigner": externalVersions.awsSdkS3,
     }),
     appPort: {
@@ -601,7 +618,7 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "## S3-compatible storage",
       "",
       "- Package: `@beignet/provider-storage-s3`",
-      "- Peer dependencies: `@aws-sdk/client-s3` and `@aws-sdk/s3-request-presigner`",
+      "- Peer dependencies: `@aws-sdk/client-s3`, `@aws-sdk/lib-storage`, and `@aws-sdk/s3-request-presigner`",
       "- The preset wires `createS3StorageProvider()` in `server/providers.ts` and defers `storage` in `infra/port-wiring.ts`.",
       "- Set `STORAGE_S3_BUCKET` before booting the app; set endpoint and credentials when using an S3-compatible host outside AWS defaults.",
       "- Use `ctx.ports.storage` in app code; `ctx.ports.s3Storage` is available as an escape hatch.",
@@ -639,6 +656,8 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "# Vercel Blob storage provider. Vercel sets BLOB_READ_WRITE_TOKEN",
       "# automatically on deployments with a connected Blob store.",
       "# BLOB_READ_WRITE_TOKEN=vercel_blob_rw_...",
+      "# OIDC alternative on Vercel: VERCEL_OIDC_TOKEN plus BLOB_STORE_ID.",
+      "# BLOB_STORE_ID=store_...",
       "# BLOB_ACCESS=private",
       "# BLOB_KEY_PREFIX=",
       "",
@@ -649,14 +668,14 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "- Package: `@beignet/provider-storage-vercel-blob`",
       "- Peer dependency: `@vercel/blob`",
       "- The preset wires `createVercelBlobStorageProvider()` in `server/providers.ts` and defers `storage` in `infra/port-wiring.ts`.",
-      "- On Vercel, connect a Blob store to the project and `BLOB_READ_WRITE_TOKEN` is set automatically; set it manually elsewhere.",
+      "- On Vercel, connect a Blob store to the project. Use its `BLOB_READ_WRITE_TOKEN`, or Vercel OIDC with `VERCEL_OIDC_TOKEN` plus `BLOB_STORE_ID`; set a read-write token manually outside Vercel.",
       "- The store is uniform-visibility (`BLOB_ACCESS`, default `private`): Vercel Blob does not report per-object access back, so mixed visibility needs a second store.",
       "- Use `ctx.ports.storage` in app code; `ctx.ports.vercelBlob` is available as an escape hatch.",
       "",
     ].join("\n"),
     nextSteps: [
       "Run your package manager install command.",
-      "Connect a Vercel Blob store to the project (or set BLOB_READ_WRITE_TOKEN manually).",
+      "Connect a Vercel Blob store and configure either BLOB_READ_WRITE_TOKEN or Vercel OIDC with BLOB_STORE_ID plus VERCEL_OIDC_TOKEN.",
       "Run beignet provider audit and beignet doctor --strict.",
     ],
     conflictingProviderEntries: [
@@ -689,6 +708,8 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "UPSTASH_REDIS_REST_TOKEN=dev-placeholder-change-me",
       "UPSTASH_PREFIX=beignet:ratelimit",
       "# UPSTASH_ALGORITHM=fixed-window",
+      "# UPSTASH_TIMEOUT_MS=5000",
+      "# UPSTASH_TIMEOUT_POLICY=fail-closed",
       "",
     ].join("\n"),
     docs: [
@@ -698,6 +719,7 @@ const presets: Record<ProviderPresetName, ProviderPreset> = {
       "- Peer dependencies: `@upstash/ratelimit` and `@upstash/redis`",
       "- The preset wires `createUpstashRateLimitProvider()` in `server/providers.ts` and defers `rateLimit` in `infra/port-wiring.ts`.",
       "- `.env.example` ships dev placeholders so the app boots; set real `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` values before rate limiting requests.",
+      "- Rate-limit checks time out after 5000ms and fail closed by default. Set `UPSTASH_TIMEOUT_POLICY=fail-open` only when availability is more important than enforcement during an Upstash outage.",
       "- Use `ctx.ports.rateLimit` in app code; `ctx.ports.upstash` is available as an escape hatch.",
       "",
     ].join("\n"),
@@ -1174,9 +1196,13 @@ function updatePackageJson(
 }
 
 function updateServerProviders(source: string, preset: ProviderPreset): string {
-  assertNoConflictingProviders(source, preset);
+  const withoutGeneratedFallback =
+    preset.appPort.key === "jobs"
+      ? removeGeneratedInlineJobsProvider(source)
+      : source;
+  assertNoConflictingProviders(withoutGeneratedFallback, preset);
 
-  let next = source;
+  let next = withoutGeneratedFallback;
   for (const importLine of preset.additionalImports ?? []) {
     if (!next.includes(importLine)) next = insertAfterImports(next, importLine);
   }
@@ -1200,6 +1226,164 @@ function updateServerProviders(source: string, preset: ProviderPreset): string {
   return result.kind === "updated" ? result.source : next;
 }
 
+function removeGeneratedInlineJobsProvider(source: string): string {
+  const marker = "// beignet:generated-inline-jobs-provider";
+  const sourceFile = ts.createSourceFile(
+    "providers.ts",
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const statement = sourceFile.statements.find((candidate) => {
+    if (!ts.isVariableStatement(candidate)) return false;
+    if (candidate.declarationList.declarations.length !== 1) return false;
+    const statementStart = candidate.getStart(sourceFile);
+    const markerStart = source.lastIndexOf(marker, statementStart);
+    if (
+      markerStart < 0 ||
+      source.slice(markerStart + marker.length, statementStart).trim() !== ""
+    ) {
+      return false;
+    }
+    const declaration = candidate.declarationList.declarations.find(
+      (item) =>
+        ts.isIdentifier(item.name) && item.name.text === "inlineJobsProvider",
+    );
+    if (!declaration?.initializer) return false;
+    const text = declaration.initializer.getText(sourceFile);
+    return (
+      /\bcreateProvider\b/.test(text) &&
+      /\bcreateInlineJobDispatcher\b/.test(text) &&
+      /\bname\s*:\s*["']inline-jobs["']/.test(text)
+    );
+  });
+  if (!statement) return source;
+
+  const statementStart = statement.getStart(sourceFile);
+  const markerStart = source.lastIndexOf(marker, statementStart);
+  const removeStart =
+    markerStart >= 0 &&
+    source.slice(markerStart + marker.length, statementStart).trim() === ""
+      ? markerStart
+      : statementStart;
+  let next = `${source.slice(0, removeStart)}${source.slice(statement.end)}`;
+  const registry = arrayInitializerInfo(next, "providers");
+  if (!registry) {
+    throw new Error(
+      "Could not remove the generated inline jobs provider because `export const providers = [...]` is missing.",
+    );
+  }
+  const lines = registry.text.split(/\r?\n/);
+  const entryIndex = lines.findIndex(
+    (line) =>
+      line.trim() === "inlineJobsProvider," ||
+      line.trim() === "inlineJobsProvider",
+  );
+  let nextRegistry: string | undefined;
+  if (entryIndex >= 0) {
+    lines.splice(entryIndex, 1);
+    nextRegistry = lines.join(registry.text.includes("\r\n") ? "\r\n" : "\n");
+  } else if (!registry.text.includes("\n")) {
+    const beforeFollowingEntry = /\binlineJobsProvider\s*,\s*/;
+    const afterPreviousEntry = /,\s*inlineJobsProvider\b/;
+    const onlyEntry = /^\[\s*inlineJobsProvider\s*\]$/;
+    if (onlyEntry.test(registry.text)) nextRegistry = "[]";
+    else if (beforeFollowingEntry.test(registry.text)) {
+      nextRegistry = registry.text.replace(beforeFollowingEntry, "");
+    } else if (afterPreviousEntry.test(registry.text)) {
+      nextRegistry = registry.text.replace(afterPreviousEntry, "");
+    }
+  }
+  if (nextRegistry === undefined) {
+    throw new Error(
+      "Could not remove the generated inline jobs provider from `export const providers = [...]`.",
+    );
+  }
+  next = `${next.slice(0, registry.start)}${nextRegistry}${next.slice(registry.end)}`;
+
+  return removeNamedProviderImport(
+    next,
+    "createInlineJobDispatcher",
+    "@beignet/core/jobs",
+  );
+}
+
+function removeNamedProviderImport(
+  source: string,
+  name: string,
+  moduleName: string,
+): string {
+  const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `import \\{([^}]*)\\} from ["']${escapedModule}["'];`,
+  );
+  const match = pattern.exec(source);
+  if (!match) return source;
+  const names = match[1]
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  if (!names.includes(name)) return source;
+  if (hasIdentifierReferenceOutsideImport(source, name, moduleName)) {
+    return source;
+  }
+  const remaining = names.filter((entry) => entry !== name);
+  if (remaining.length === 0) {
+    const lineBreak = source.startsWith("\r\n", match.index + match[0].length)
+      ? "\r\n"
+      : source[match.index + match[0].length] === "\n"
+        ? "\n"
+        : "";
+    return `${source.slice(0, match.index)}${source.slice(match.index + match[0].length + lineBreak.length)}`;
+  }
+  const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
+  const replacement = match[1].includes("\n")
+    ? `import {\n${indent}${remaining.join(`,\n${indent}`)},\n} from "${moduleName}";`
+    : `import { ${remaining.join(", ")} } from "${moduleName}";`;
+  return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
+}
+
+function hasIdentifierReferenceOutsideImport(
+  source: string,
+  name: string,
+  moduleName: string,
+): boolean {
+  const sourceFile = ts.createSourceFile(
+    "providers.ts",
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const importDeclaration = sourceFile.statements.find(
+    (statement): statement is ts.ImportDeclaration =>
+      ts.isImportDeclaration(statement) &&
+      ts.isStringLiteral(statement.moduleSpecifier) &&
+      statement.moduleSpecifier.text === moduleName &&
+      Boolean(
+        statement.importClause?.namedBindings &&
+          ts.isNamedImports(statement.importClause.namedBindings) &&
+          statement.importClause.namedBindings.elements.some(
+            (element) => !element.propertyName && element.name.text === name,
+          ),
+      ),
+  );
+  if (!importDeclaration) return true;
+
+  let referenced = false;
+  const visit = (node: ts.Node): void => {
+    if (node === importDeclaration || referenced) return;
+    if (ts.isIdentifier(node) && node.text === name) {
+      referenced = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return referenced;
+}
+
 function assertNoConflictingProviders(
   source: string,
   preset: ProviderPreset,