@dbx-tools/projen 0.9.17 → 0.9.18

package/src/project-js.ts

@@ -1064,18 +1064,14 @@ class GeneratedSource extends Component {
  *
  * projen gives a monorepo root empty `compile`/`test` tasks - a child's tasks
  * are the child's business - so `bun run build` at the root type-checked nothing
- * and ran no package tests. The fan-out is delegated to bun's own workspace
- * filter rather than one `exec` per member, which matters three ways: bun runs
- * the members in PARALLEL (measured ~2.5x faster across this repo than the
- * sequential per-`cwd` form), a member that does not define the script is
- * skipped instead of needing a guard, and the filter reads the workspace from
- * `package.json` - so it stays correct when a package is added without a
- * re-synth. A non-zero member exit still fails the run.
+ * and ran no package tests. Compilation groups ordinary `tsc --build` members
+ * into a few TypeScript processes and runs custom compile tasks alongside them. Tests
+ * still use Bun's filtered workspace fan-out. Both read the current workspace
+ * list from `package.json`, so a newly added member needs no re-synth.
  *
- * `*` matches every workspace MEMBER and never the root itself, so the root
+ * `*` matches every workspace MEMBER and never the root itself, so the test
  * task delegating to it cannot recurse. Members declared outside the scanned
- * package roots (`extraWorkspaceMembers`) are workspace members too, so they are
- * covered by the same filter.
+ * package roots (`extraWorkspaceMembers`) are covered by both tasks.
  */
 class WorkspaceValidationTasks extends Component {
   private configured = false;
@@ -1087,9 +1083,8 @@ class WorkspaceValidationTasks extends Component {
     if (project.subprojects.length === 0 && project.extraWorkspaceMembers.length === 0) {
       return;
     }
-    for (const task of [project.compileTask, project.testTask]) {
-      task.exec(`bun run --filter '*' ${task.name}`);
-    }
+    project.compileTask.exec(taskScript(project, "compile-workspace.ts"));
+    project.testTask.exec("bun run --filter '*' test");
   }
 }
 

package/src/project-py.ts

@@ -7,7 +7,7 @@ import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workf
 import { DBX_TOOLS_LICENSE, projectReleaseBranch, projectRepositoryUrl } from "./project-js.ts";
 import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
-import { RELEASE_VERSION, releaseSourceSteps } from "./release-dispatch.ts";
+import { RELEASE_TAG, RELEASE_VERSION, releaseSourceSteps } from "./release-dispatch.ts";
 import {
   independentReleaseSetupSteps,
   registerIndependentPublicationJob,
@@ -465,9 +465,9 @@ export class DBXToolsPythonWorkspace extends Component {
     if (project.releaseCatalog.mode === "independent") {
       workflow.addJob("build-python", {
         if: usesRustArtifacts
-          ? "${{ always() && needs.release-plan.outputs.python == 'true' && needs.rust-uniffi.result != 'failure' && needs.rust-uniffi.result != 'cancelled' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
+          ? "${{ always() && needs.release-plan.outputs.python == 'true' && needs.rust-build.result != 'failure' && needs.rust-build.result != 'cancelled' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
           : "${{ needs.release-plan.outputs.python == 'true' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}",
-        needs: ["release-plan", ...(usesRustArtifacts ? ["rust-uniffi"] : [])],
+        needs: ["release-plan", ...(usesRustArtifacts ? ["rust-build"] : [])],
         runsOn: ["ubuntu-latest"],
         permissions: { actions: JobPermission.READ, contents: JobPermission.READ },
         timeoutMinutes: 20,
@@ -546,9 +546,9 @@ export class DBXToolsPythonWorkspace extends Component {
     }
     workflow.addJob("build-python", {
       if: usesRustArtifacts
-        ? "${{ always() && needs.verify-context.result == 'success' && needs.rust-uniffi.result != 'failure' && needs.rust-uniffi.result != 'cancelled' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
+        ? "${{ always() && needs.verify-context.result == 'success' && needs.rust-assets.result == 'success' && (github.event_name == 'push' || inputs.stage == 'all' || inputs.stage == 'python') }}"
         : releaseStageCondition("python"),
-      needs: ["verify-context", ...(usesRustArtifacts ? ["rust-uniffi"] : [])],
+      needs: ["verify-context", ...(usesRustArtifacts ? ["rust-assets"] : [])],
       runsOn: ["ubuntu-latest"],
       permissions: { actions: JobPermission.READ, contents: JobPermission.READ },
       timeoutMinutes: 20,
@@ -567,8 +567,27 @@ export class DBXToolsPythonWorkspace extends Component {
             recoveredName: `Download recovered ${publication.distribution} native wheels`,
             pattern: `${publication.distribution}--*--python-wheel`,
             path: `dist/${publication.directory}`,
+            condition: "needs.verify-context.outputs.build_mode == 'remote'",
           }),
         ),
+        ...(uniffiPublications.length
+          ? [
+              {
+                name: "Download locally built native wheels",
+                if: "${{ needs.verify-context.outputs.build_mode == 'local' }}",
+                env: { GH_TOKEN: "${{ github.token }}", RELEASE_TAG },
+                shell: "bash",
+                run: [
+                  "mkdir -p dist/local-wheels",
+                  'gh release download "$RELEASE_TAG" --pattern "*.whl" --dir dist/local-wheels',
+                  ...uniffiPublications.flatMap((publication) => [
+                    `mkdir -p dist/${publication.directory}`,
+                    `cp dist/local-wheels/${publication.distribution.replaceAll("-", "_")}-*.whl dist/${publication.directory}/`,
+                  ]),
+                ].join("\n"),
+              },
+            ]
+          : []),
         {
           name: "Stamp workspace versions",
           env: { VERSION: RELEASE_VERSION },

package/src/project-rs.ts

@@ -4,6 +4,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { stringUtils } from "@dbx-tools/shared-core";
 import { Component, Project, TextFile, TomlFile, javascript } from "projen";
+import { releaseBinaryAssetName } from "./_release-platform.ts";
 import {
   RustProject,
   type CargoExampleOptions as RustCargoExampleOptions,
@@ -18,6 +19,7 @@ import {
   type RustOpenApiOptions as RustOpenApiConfiguration,
 } from "./_rust-project.ts";
 import {
+  rustAssetsJob,
   configureRustReleaseTask,
   independentRustCargoPublishJob,
   independentRustGitHubReleaseJob,
@@ -25,7 +27,6 @@ import {
   independentRustNodeFacadePublishJob,
   orderRustBindings,
   planRustRelease,
-  releaseBinaryAssetName,
   rustBuildJob,
   rustCargoPublishJob,
   rustGitHubReleaseJob,
@@ -118,6 +119,7 @@ export interface UniFFIReleaseTarget {
   readonly os: RustReleaseOs;
   readonly cpu: RustReleaseCpu;
   readonly libc?: "glibc";
+  readonly glibcVersion?: string;
 }
 
 /** Native targets built on matching GitHub-hosted runners. */
@@ -130,6 +132,7 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     os: RustReleaseOs.LINUX,
     cpu: RustReleaseCpu.X64,
     libc: "glibc",
+    glibcVersion: "2.35",
   },
   {
     runner: "ubuntu-24.04-arm",
@@ -139,6 +142,7 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     os: RustReleaseOs.LINUX,
     cpu: RustReleaseCpu.ARM64,
     libc: "glibc",
+    glibcVersion: "2.39",
   },
   {
     runner: "macos-15-intel",
@@ -1098,17 +1102,8 @@ export class DBXToolsRustWorkspace extends Component {
     }
     configureRustReleaseTask(project, plan);
     if (project.releaseCatalog.mode === "independent") {
-      if (plan.uniffiTargets.length) {
-        workflow.addJob(
-          "rust-uniffi",
-          rustBuildJob(plan, "uniffi", independentReleaseSetupSteps(project)),
-        );
-      }
-      if (plan.binaryTargets.length) {
-        workflow.addJob(
-          "rust-binaries",
-          rustBuildJob(plan, "binaries", independentReleaseSetupSteps(project)),
-        );
+      if (plan.targets.length) {
+        workflow.addJob("rust-build", rustBuildJob(plan, independentReleaseSetupSteps(project)));
       }
       if (plan.publicCrates.length) {
         workflow.addJob("publish-cargo", independentRustCargoPublishJob(project, plan));
@@ -1129,17 +1124,15 @@ export class DBXToolsRustWorkspace extends Component {
       }
       return;
     }
-    if (plan.uniffiTargets.length) {
-      workflow.addJob("rust-uniffi", rustBuildJob(plan, "uniffi"));
-    }
-    if (plan.binaryTargets.length) {
-      workflow.addJob("rust-binaries", rustBuildJob(plan, "binaries"));
+    if (plan.targets.length) {
+      workflow.addJob("rust-build", rustBuildJob(plan));
+      workflow.addJob("rust-assets", rustAssetsJob());
     }
     if (plan.publicCrates.length) {
       workflow.addJob("publish-cargo", rustCargoPublishJob(plan, false));
       workflow.addJob("publish-local-cargo", rustCargoPublishJob(plan, true));
     }
-    if (plan.releaseBinaries.length) {
+    if (plan.hasTargetOutputs) {
       workflow.addJob("publish-github-release", rustGitHubReleaseJob(plan));
     }
     if (plan.nodeBindings.length && hasNodeRelease(project)) {

package/src/release-github.ts

@@ -28,6 +28,29 @@ export interface GithubAuthenticatedAccount {
   scopes: string[];
 }
 
+/** Repository capabilities returned for one authenticated actor. */
+export interface GithubRepositoryPermissions {
+  readonly push: boolean;
+  readonly maintain: boolean;
+  readonly admin: boolean;
+}
+
+/** Read normalized repository permissions from a GitHub repository response. */
+export function githubRepositoryPermissions(value: unknown): GithubRepositoryPermissions {
+  const repository = object.isRecord(value) ? value : undefined;
+  const permissions = object.isRecord(repository?.permissions) ? repository.permissions : undefined;
+  return {
+    push: permissions?.push === true,
+    maintain: permissions?.maintain === true,
+    admin: permissions?.admin === true,
+  };
+}
+
+/** Whether the actor can manage releases rather than only push source. */
+export function githubRepositoryCanManage(permissions: GithubRepositoryPermissions): boolean {
+  return permissions.maintain || permissions.admin;
+}
+
 /** Parse successful GitHub CLI accounts with the active account first. */
 export function githubAuthenticatedAccounts(
   statusOutput: string,

package/src/release-plan.ts

@@ -47,10 +47,10 @@ export interface PlannedRustTarget {
   readonly runner: string;
   readonly python: string;
   readonly libc: string;
+  readonly glibcVersion: string;
   readonly packages: readonly string[];
   readonly binaries: readonly string[];
   readonly features: readonly string[];
-  readonly fingerprintConfig: string;
 }
 
 /** Complete plan persisted as a workflow artifact and used for recovery. */
@@ -62,8 +62,7 @@ export interface ReleasePlan {
   readonly pythonPackages: readonly PlannedPackage[];
   readonly rustPackages: readonly PlannedPackage[];
   readonly artifacts: readonly PlannedArtifact[];
-  readonly rustUniffiTargets: readonly PlannedRustTarget[];
-  readonly rustBinaryTargets: readonly PlannedRustTarget[];
+  readonly rustTargets: readonly PlannedRustTarget[];
   readonly stages: {
     readonly rust: boolean;
     readonly python: boolean;
@@ -133,53 +132,52 @@ export function buildReleasePlan(
       ]);
     }
   }
-  const rustTargetsByKind = {
-    uniffi: new Map<string, PlannedRustTarget>(),
-    binaries: new Map<string, PlannedRustTarget>(),
-  };
+  const rustTargets = new Map<string, PlannedRustTarget>();
   for (const artifact of artifacts) {
     const targets = artifact.data?.targets;
     if (!Array.isArray(targets)) continue;
-    const kind = artifact.kind === "github-binary" ? "binaries" : "uniffi";
+    const binary = artifact.kind === "github-binary";
     for (const value of targets) {
       if (!value || typeof value !== "object" || Array.isArray(value)) continue;
       const target = value as Record<string, unknown>;
       const required = ["os", "cpu", "node", "cargo", "runner", "python"] as const;
       if (!required.every((field) => typeof target[field] === "string")) continue;
       const key = String(target.node);
-      const targetsByKey = rustTargetsByKind[kind];
-      const currentTarget = targetsByKey.get(key);
+      const currentTarget = rustTargets.get(key);
       const packages = [
         ...new Set([
           ...(currentTarget?.packages ?? []),
           ...(rustPackagesByUnit.get(artifact.unit) ?? []),
         ]),
       ].sort();
-      const binaries =
-        kind === "binaries"
-          ? [
-              ...new Set([
-                ...(currentTarget?.binaries ?? []),
-                ...(typeof artifact.data?.binary === "string" ? [artifact.data.binary] : []),
-              ]),
-            ].sort()
-          : [];
+      const binaries = binary
+        ? [
+            ...new Set([
+              ...(currentTarget?.binaries ?? []),
+              ...(typeof artifact.data?.binary === "string" ? [artifact.data.binary] : []),
+            ]),
+          ].sort()
+        : (currentTarget?.binaries ?? []);
       const configuredFeatures = Array.isArray(artifact.data?.features)
         ? artifact.data.features.filter((feature): feature is string => typeof feature === "string")
         : [];
       const crate = typeof artifact.data?.crate === "string" ? artifact.data.crate : undefined;
-      const features =
-        kind === "uniffi"
-          ? packages.map((pkg) => `${pkg}/uniffi-bindgen`)
-          : [
-              ...new Set([
-                ...(currentTarget?.features ?? []),
-                ...(crate
-                  ? configuredFeatures.map((feature) => `${crate}/${feature}`)
-                  : configuredFeatures),
-              ]),
-            ].sort();
-      targetsByKey.set(key, {
+      const features = binary
+        ? [
+            ...new Set([
+              ...(currentTarget?.features ?? []),
+              ...(crate
+                ? configuredFeatures.map((feature) => `${crate}/${feature}`)
+                : configuredFeatures),
+            ]),
+          ].sort()
+        : [
+            ...new Set([
+              ...(currentTarget?.features ?? []),
+              ...packages.map((pkg) => `${pkg}/uniffi-bindgen`),
+            ]),
+          ].sort();
+      rustTargets.set(key, {
         os: String(target.os),
         cpu: String(target.cpu),
         node: String(target.node),
@@ -187,19 +185,14 @@ export function buildReleasePlan(
         runner: String(target.runner),
         python: String(target.python),
         libc: typeof target.libc === "string" ? target.libc : "",
+        glibcVersion: typeof target.glibcVersion === "string" ? target.glibcVersion : "",
         packages,
         binaries,
         features,
-        fingerprintConfig: JSON.stringify({ packages, binaries, features }),
       });
     }
   }
-  const rustUniffiTargets = [...rustTargetsByKind.uniffi.values()].sort((a, b) =>
-    a.node.localeCompare(b.node),
-  );
-  const rustBinaryTargets = [...rustTargetsByKind.binaries.values()].sort((a, b) =>
-    a.node.localeCompare(b.node),
-  );
+  const plannedRustTargets = [...rustTargets.values()].sort((a, b) => a.node.localeCompare(b.node));
   const publishBatches = current.publishBatches
     .map((batch) => batch.filter((unit) => selected.has(unit)))
     .filter((batch) => batch.length > 0);
@@ -226,8 +219,7 @@ export function buildReleasePlan(
     pythonPackages,
     rustPackages,
     artifacts,
-    rustUniffiTargets,
-    rustBinaryTargets,
+    rustTargets: plannedRustTargets,
     stages,
     omittedStages,
   };

package/src/release.ts

@@ -117,6 +117,7 @@ export function releaseArtifactSteps(options: {
   readonly recoveredName: string;
   readonly pattern: string;
   readonly path: string;
+  readonly condition?: string;
 }): readonly JobStep[] {
   const shared = {
     pattern: options.pattern,
@@ -126,13 +127,13 @@ export function releaseArtifactSteps(options: {
   return [
     {
       name: options.currentName,
-      if: "${{ inputs.source_run_id == '' }}",
+      if: `\${{ ${options.condition ? `${options.condition} && ` : ""}inputs.source_run_id == '' }}`,
       uses: "actions/download-artifact@v8",
       with: shared,
     },
     {
       name: options.recoveredName,
-      if: "${{ inputs.source_run_id != '' }}",
+      if: `\${{ ${options.condition ? `${options.condition} && ` : ""}inputs.source_run_id != '' }}`,
       uses: "actions/download-artifact@v8",
       with: {
         ...shared,
@@ -179,6 +180,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
       release_tag: { stepId: "release", outputName: "release_tag" },
       expected_sha: { stepId: "release", outputName: "expected_sha" },
       release_version: { stepId: "release", outputName: "release_version" },
+      build_mode: { stepId: "release", outputName: "build_mode" },
     },
     steps: [
       {
@@ -186,7 +188,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
         uses: "actions/checkout@v6",
         with: {
           ref: "${{ github.event_name == 'push' && github.sha || inputs.expected_sha }}",
-          "fetch-depth": 2,
+          "fetch-depth": 0,
         },
       },
       {
@@ -205,6 +207,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
           EXPECTED_SHA:
             "${{ github.event_name == 'workflow_dispatch' && inputs.expected_sha || '' }}",
           DRY_RUN: "${{ github.event_name == 'workflow_dispatch' && inputs.dry_run || false }}",
+          GH_TOKEN: "${{ github.token }}",
         },
         // prettier-ignore
         run: stringUtils.dedent(
@@ -246,9 +249,15 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
               case "\${{ inputs.source_run_id }}" in *[!0-9]*|"") exit 1 ;; esac
             fi
           fi
+          BUILD_MODE="$(git log -1 --format=%B -- VERSION | sed -n 's/^Release-Build: //p' | tail -1)"
+          case "$BUILD_MODE" in local|remote) ;; *) BUILD_MODE="remote" ;; esac
+          if [ "$BUILD_MODE" = "local" ] && ! gh release view "$RELEASE_TAG" >/dev/null 2>&1; then
+            gh release create "$RELEASE_TAG" --draft --title "$RELEASE_TAG" --target "$RELEASE_SHA"
+          fi
           echo "release_tag=$RELEASE_TAG" >> "$GITHUB_OUTPUT"
           echo "expected_sha=$RELEASE_SHA" >> "$GITHUB_OUTPUT"
           echo "release_version=$RELEASE_VERSION" >> "$GITHUB_OUTPUT"
+          echo "build_mode=$BUILD_MODE" >> "$GITHUB_OUTPUT"
         `
           // ============================================================================
         ),
@@ -591,8 +600,7 @@ function independentReleasePlanJob(project: DBXToolsJavaScriptProject): Job {
       python_packages: { stepId: "plan", outputName: "python_packages" },
       rust_packages: { stepId: "plan", outputName: "rust_packages" },
       artifacts: { stepId: "plan", outputName: "artifacts" },
-      rust_uniffi_targets: { stepId: "plan", outputName: "rust_uniffi_targets" },
-      rust_binary_targets: { stepId: "plan", outputName: "rust_binary_targets" },
+      rust_targets: { stepId: "plan", outputName: "rust_targets" },
     },
     steps: [
       {
@@ -1022,6 +1030,11 @@ export class DBXToolsRelease extends Component {
               description:
                 "Prepare, validate, locally publish, and automatically merge a release PR",
             },
+            "release:assets": {
+              exec: taskScript(project, "release-assets.ts"),
+              receiveArgs: true,
+              description: "Build and upload native assets for an existing GitHub Release",
+            },
           }
         : {}),
     });

package/tasks/compile-workspace.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env -S bun
+/** Compile source-first workspace packages in a few TypeScript processes. */
+import { existsSync, readFileSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import { join, resolve } from "node:path";
+import * as exec from "@dbx-tools/core/exec";
+
+interface PackageManifest {
+  readonly name?: string;
+  readonly scripts?: Record<string, string>;
+  readonly workspaces?: string[];
+}
+
+interface TaskManifest {
+  readonly tasks?: {
+    readonly compile?: {
+      readonly steps?: Array<{ readonly execArgs?: string[] }>;
+    };
+  };
+}
+
+export interface CompilePlan {
+  readonly typescriptConfigs: string[];
+  readonly customPackages: Array<{ readonly name: string; readonly directory: string }>;
+}
+
+function readJson<T>(path: string): T {
+  return JSON.parse(readFileSync(path, "utf8")) as T;
+}
+
+function plainTypeScriptBuild(steps: unknown): boolean {
+  if (!Array.isArray(steps) || steps.length !== 1) return false;
+  const step = steps[0] as { execArgs?: string[] };
+  if (!step || typeof step !== "object") return false;
+  return (
+    Object.keys(step).length === 1 &&
+    step.execArgs?.length === 2 &&
+    step.execArgs[0] === "tsc" &&
+    step.execArgs[1] === "--build"
+  );
+}
+
+/** Read the root's concrete workspace paths on every run, including newly added members. */
+export function compilePlan(root: string): CompilePlan {
+  const workspace = readJson<PackageManifest>(join(root, "package.json"));
+  const typescriptConfigs: string[] = [];
+  const customPackages: CompilePlan["customPackages"] = [];
+  for (const member of workspace.workspaces ?? []) {
+    const directory = resolve(root, member);
+    const manifest = readJson<PackageManifest>(join(directory, "package.json"));
+    const script = manifest.scripts?.compile;
+    if (!script) continue;
+    const taskPath = join(directory, ".projen", "tasks.json");
+    const steps = existsSync(taskPath)
+      ? readJson<TaskManifest>(taskPath).tasks?.compile?.steps
+      : undefined;
+    if (
+      script === "projen compile" &&
+      !manifest.scripts?.precompile &&
+      !manifest.scripts?.postcompile &&
+      plainTypeScriptBuild(steps)
+    ) {
+      typescriptConfigs.push(join(directory, "tsconfig.json"));
+    } else {
+      customPackages.push({ name: manifest.name ?? member, directory });
+    }
+  }
+  return { typescriptConfigs, customPackages };
+}
+
+const emoji = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
+
+async function main(): Promise<void> {
+  const root = process.cwd();
+  const plan = compilePlan(root);
+  const jobs: Array<{ name: string; result: Promise<exec.ExecResult> }> = [];
+  if (plan.typescriptConfigs.length > 0) {
+    const batchCount = Math.min(4, availableParallelism(), plan.typescriptConfigs.length);
+    const batches = Array.from({ length: batchCount }, () => [] as string[]);
+    plan.typescriptConfigs.forEach((config, index) => batches[index % batchCount]!.push(config));
+    console.log(
+      `Type-checking ${plan.typescriptConfigs.length} workspaces in ${batchCount} batches`,
+    );
+    for (const [index, batch] of batches.entries()) {
+      jobs.push({
+        name: `TypeScript batch ${index + 1}`,
+        result: exec.spawn("bunx", ["tsc", "--build", ...batch], {
+          cwd: root,
+          stdin: "ignore",
+          stdout: "inherit",
+          stderr: "inherit",
+        }),
+      });
+    }
+  }
+  for (const pkg of plan.customPackages) {
+    jobs.push({
+      name: pkg.name,
+      result: exec.spawn("bun", ["run", "compile"], {
+        cwd: pkg.directory,
+        stdin: "ignore",
+        stdout: (line) => console.log(`${pkg.name}: ${line.replace(emoji, "")}`),
+        stderr: (line) => console.error(`${pkg.name}: ${line.replace(emoji, "")}`),
+      }),
+    });
+  }
+  const results = await Promise.allSettled(jobs.map((job) => job.result));
+  let failed = false;
+  for (const [index, result] of results.entries()) {
+    if (result.status === "rejected") {
+      console.error(`${jobs[index]!.name} compile failed:`, result.reason);
+      failed = true;
+    } else if (result.value.exitCode !== 0) {
+      console.error(`${jobs[index]!.name} compile exited with ${result.value.exitCode}`);
+      failed = true;
+    }
+  }
+  if (failed) process.exitCode = 1;
+}
+
+if (import.meta.main) await main();