@dbx-tools/projen 0.9.32 → 0.9.37

package/src/python-node-bundle.ts

@@ -1,6 +1,5 @@
 import { Component, type Project, type Task } from "projen";
-import { taskScript } from "./project-js.ts";
-import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
+import { taskCommand } from "./project-js.ts";
 
 /** One function replaced only in a generated PythonMonkey bundle. */
 export interface PythonNodeFunctionOverride {
@@ -20,12 +19,8 @@ export interface PythonNodeBindingsOptions {
   readonly package: string;
   /** Optional portable package subpath to bind. Defaults to {@link package}. */
   readonly entrypoint?: string;
-  /** Generated bindings own the package or live under `_generated`. Defaults to `submodule`. */
-  readonly layout?: "package" | "submodule";
-  /** Keep generated symbols out of the generated package `__init__`. Defaults to false. */
-  readonly private?: boolean;
-  /** Repository-relative directory containing Node built-in shims. */
-  readonly shimRoot?: string;
+  /** Automatically generated root namespace modules to bind independently. */
+  readonly modules?: readonly string[];
   /** Functions replaced only while generating the Python runtime. */
   readonly functionOverrides?: readonly PythonNodeFunctionOverride[];
 }
@@ -38,55 +33,24 @@ export interface PythonNodeBundleOptions {
   readonly projectDirectory: string;
   /** Add the freshness check to the project's test task. Defaults to true. */
   readonly test?: boolean;
-  /** Regenerate during the root workspace watch loop. Defaults to false. */
-  readonly watch?: boolean;
 }
 
 /** Owns paired generation and freshness-check tasks for one Python package. */
 export class PythonNodeBundle extends Component {
   readonly buildTask: Task;
   readonly checkTask: Task;
-  readonly watchTask?: Task;
 
   constructor(project: Project, options: PythonNodeBundleOptions) {
     super(project);
-    const command = taskScript(
-      project,
-      "python-node-bindings.ts",
-      `--project ${shellQuote(options.projectDirectory)}`,
-    );
+    const command = taskCommand("python-node-bindings.ts", "--project", options.projectDirectory);
     this.buildTask = project.addTask(`${options.name}:python-runtime`, {
       description: `Generate Node bindings for Python package ${options.name}`,
-      exec: command,
+      execArgs: command,
     });
     this.checkTask = project.addTask(`${options.name}:python-runtime:check`, {
       description: `Verify generated Node bindings for Python package ${options.name}`,
-      exec: `${command} --check`,
+      execArgs: [...command, "--check"],
     });
     if (options.test ?? true) project.testTask.spawn(this.checkTask);
-    if (options.watch) {
-      this.watchTask = project.addTask(`${options.name}:python-runtime:watch`, {
-        description: `Regenerate Node bindings for Python package ${options.name} on changes`,
-        exec: taskScript(
-          project,
-          "python-node-bindings-watch.ts",
-          `--project ${shellQuote(options.projectDirectory)}`,
-        ),
-      });
-      if (isDBXToolsJavaScriptProject()(project)) {
-        const configured = project.dbxToolsConfig.pythonNodeBindings;
-        const projects = Array.isArray(configured)
-          ? configured.filter((value): value is string => typeof value === "string")
-          : [];
-        project.dbxToolsConfig.pythonNodeBindings = [
-          ...new Set([...projects, options.projectDirectory]),
-        ];
-      }
-    }
   }
 }
-
-function shellQuote(value: string): string {
-  if (/^[A-Za-z0-9_./:@=+#-]+$/.test(value)) return value;
-  return `'${value.replaceAll("'", `'\\''`)}'`;
-}

package/src/release-context.ts

@@ -1,4 +1,5 @@
 /** Verified release context shared by every job in the unified workflow. */
+import { github } from "projen";
 import type { JobStep } from "projen/lib/github/workflows-model";
 
 export const RELEASE_TAG = "${{ needs.verify-context.outputs.release_tag }}";
@@ -8,14 +9,13 @@ export const RELEASE_VERSION = "${{ needs.verify-context.outputs.release_version
 /** Check out and verify the immutable commit selected by the release tag. */
 export function releaseSourceSteps(): readonly JobStep[] {
   return [
-    {
+    github.WorkflowSteps.checkout({
       name: "Checkout release commit",
-      uses: "actions/checkout@v6",
       with: {
         ref: RELEASE_SHA,
-        "fetch-depth": 1,
+        fetchDepth: 1,
       },
-    },
+    }),
     {
       name: "Verify release source",
       shell: "bash",

package/src/release.ts

@@ -1,23 +1,18 @@
 /** Unified default-branch release workflow generation. */
 import { stringUtils } from "@dbx-tools/shared-core";
-import { Component } from "projen";
+import { Component, github } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission, type Job, type JobStep } from "projen/lib/github/workflows-model";
-import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
-import { projectReleaseBranch, type DBXToolsJavaScriptProject } from "./project-js.ts";
-import { applyTasks, taskScript } from "./project.ts";
+import { BUN_VERSION } from "./bun-workflow.ts";
+import { projectReleaseBranch, taskCommand, type DBXToolsJavaScriptProject } from "./project-js.ts";
 import { RELEASE_VERSION, releaseSourceSteps } from "./release-context.ts";
 
 const NODE_VERSION = "24";
 const NPM_VERSION = "11.4.2";
 const NPM_REGISTRY_URL = "https://registry.npmjs.org";
-const nodeReleaseProjects = new WeakSet<DBXToolsJavaScriptProject>();
 const releaseTagPrefixes = new WeakMap<DBXToolsJavaScriptProject, string>();
 const releaseWorkflows = new WeakMap<DBXToolsJavaScriptProject, GithubWorkflow>();
 
-/** Independently recoverable portions of the release workflow. */
-export type ReleaseStage = "all" | "node" | "python" | "docs";
-
 /** GitHub Pages configuration included in the unified release workflow. */
 export interface ReleaseDocsOptions {
   readonly siteUrl: string;
@@ -44,23 +39,11 @@ export interface DBXToolsReleaseOptions {
   readonly validationTasks?: readonly string[];
 }
 
-/** Locate the unified workflow so attached language workspaces can add jobs. */
-export function releaseWorkflow(project: DBXToolsJavaScriptProject): GithubWorkflow {
-  const workflow = releaseWorkflows.get(project);
-  if (!workflow) throw new Error("Release workflow is not configured");
-  return workflow;
-}
-
 /** Locate the unified workflow when release generation is enabled. */
 export function tryReleaseWorkflow(project: DBXToolsJavaScriptProject): GithubWorkflow | undefined {
   return releaseWorkflows.get(project);
 }
 
-/** Whether the unified workflow publishes the normal npm workspace. */
-export function hasNodeRelease(project: DBXToolsJavaScriptProject): boolean {
-  return nodeReleaseProjects.has(project);
-}
-
 /** Tag pattern created by release jobs and accepted by manual recovery. */
 export function releaseTagPattern(project: DBXToolsJavaScriptProject): string {
   const prefix = releaseTagPrefixes.get(project);
@@ -68,29 +51,17 @@ export function releaseTagPattern(project: DBXToolsJavaScriptProject): string {
   return `${prefix}*`;
 }
 
-/** Run a release stage after its prerequisite tag-build jobs succeed. */
-export function releaseStageCondition(
-  _stage: Exclude<ReleaseStage, "all">,
-  prerequisites: readonly string[] = [],
-): string {
+/** Run a release job after all explicit prerequisite results succeed. */
+export function releaseCondition(prerequisites: readonly string[] = []): string {
   if (prerequisites.length === 0) return "${{ success() }}";
   return `\${{ always() && ${prerequisites.map((condition) => `(${condition})`).join(" && ")} }}`;
 }
 
-/** Publish a release stage after its prerequisite tag-build jobs succeed. */
-export function releasePublishCondition(
-  _stage: Exclude<ReleaseStage, "all">,
-  prerequisites: readonly string[] = [],
-): string {
-  if (prerequisites.length === 0) return "${{ success() }}";
-  return `\${{ always() && ${prerequisites.map((condition) => `(${condition})`).join(" && ")} }}`;
-}
-
-/** Shared Bun, Node, cache, and install setup for Node release jobs. */
+/** Native project setup plus npm publication authentication. */
 export function nodeReleaseSetupSteps(project: DBXToolsJavaScriptProject): readonly JobStep[] {
   return [
     ...releaseSourceSteps(),
-    ...bunCacheRestoreSteps(project, { ignorePaths: project.workflowCacheIgnorePaths }),
+    ...project.renderWorkflowSetup({ mutable: false }),
     {
       name: "Setup Node.js",
       uses: "actions/setup-node@v6",
@@ -101,20 +72,9 @@ export function nodeReleaseSetupSteps(project: DBXToolsJavaScriptProject): reado
       },
     },
     { name: "Install npm CLI", run: `npm install --global npm@${NPM_VERSION}` },
-    { name: "Install", run: "bun install" },
-    bunCacheSaveStep(),
   ];
 }
 
-/** Token authentication, GitHub provenance, and dry-run values shared by npm publishers. */
-export function npmPublishEnvironment(): Record<string, string> {
-  return {
-    NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}",
-    NPM_CONFIG_PROVENANCE: "true",
-    DRY_RUN: "",
-  };
-}
-
 /** Install uv and restore its download/build cache using Python manifests. */
 export function uvSetupStep(): JobStep {
   return {
@@ -141,7 +101,9 @@ function refreshDocsRegistryDependencies(workflow: GithubWorkflow): void {
 /** Keep documentation publication behind every configured package registry. */
 export function refreshReleaseDocsDependencies(project: DBXToolsJavaScriptProject): void {
   const workflow = releaseWorkflows.get(project);
-  if (workflow) refreshDocsRegistryDependencies(workflow);
+  if (workflow) {
+    refreshDocsRegistryDependencies(workflow);
+  }
 }
 
 function verifyContextJob(
@@ -161,17 +123,14 @@ function verifyContextJob(
       release_version: { stepId: "release", outputName: "release_version" },
     },
     steps: [
-      {
+      github.WorkflowSteps.checkout({
         name: "Checkout release source",
-        uses: "actions/checkout@v6",
         with: {
           ref: "${{ github.ref_name }}",
-          "fetch-depth": 0,
+          fetchDepth: 0,
         },
-      },
-      ...bunCacheRestoreSteps(project, { ignorePaths: project.workflowCacheIgnorePaths }),
-      { name: "Install release validation dependencies", run: "bun install --frozen-lockfile" },
-      bunCacheSaveStep(),
+      }),
+      ...project.renderWorkflowSetup({ mutable: false }),
       {
         name: "Verify release context",
         id: "release",
@@ -210,7 +169,7 @@ function verifyContextJob(
 
 function nodePublishJob(project: DBXToolsJavaScriptProject): Job {
   return {
-    if: releaseStageCondition("node"),
+    if: releaseCondition(),
     needs: ["verify-context"],
     runsOn: ["ubuntu-latest"],
     permissions: { contents: JobPermission.READ, idToken: JobPermission.WRITE },
@@ -220,7 +179,11 @@ function nodePublishJob(project: DBXToolsJavaScriptProject): Job {
       ...nodeReleaseSetupSteps(project),
       {
         name: "Publish npm workspace",
-        env: { RELEASE_VERSION, ...npmPublishEnvironment() },
+        env: {
+          RELEASE_VERSION,
+          NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}",
+          NPM_CONFIG_PROVENANCE: "true",
+        },
         run: 'bun node_modules/@dbx-tools/projen/tasks/publish.ts "$RELEASE_VERSION" $DRY_RUN',
       },
     ],
@@ -233,7 +196,7 @@ function addDocsJobs(
   options: ReleaseDocsOptions,
 ): void {
   workflow.addJob("build-docs", {
-    if: releaseStageCondition("docs"),
+    if: releaseCondition(),
     needs: ["verify-context"],
     runsOn: ["ubuntu-latest"],
     permissions: {
@@ -249,9 +212,8 @@ function addDocsJobs(
     },
     steps: [
       ...releaseSourceSteps(),
-      ...bunCacheRestoreSteps(project, { ignorePaths: project.workflowCacheIgnorePaths }),
+      ...project.renderWorkflowSetup({ mutable: false }),
       ...options.prepareSteps,
-      bunCacheSaveStep(),
       ...options.buildSteps,
       {
         name: "Upload Pages artifact",
@@ -261,7 +223,7 @@ function addDocsJobs(
     ],
   });
   workflow.addJob("deploy-docs", {
-    if: releasePublishCondition("docs"),
+    if: releaseCondition(),
     needs: ["build-docs"],
     environment: {
       name: "github-pages",
@@ -288,31 +250,30 @@ export class DBXToolsRelease extends Component {
     const tagPrefix = options.tagPrefix ?? "v";
     const releaseBranch = projectReleaseBranch(project);
     releaseTagPrefixes.set(project, tagPrefix);
-    if (options.nodeRelease !== false) nodeReleaseProjects.add(project);
-    applyTasks(project, {
-      bump: {
-        exec: taskScript(project, "bump.ts"),
-        receiveArgs: true,
-        description: "Increment VERSION and synchronize generated workspace versions",
-      },
-      "version:check": {
-        exec: taskScript(project, "version-check.ts"),
-        description: "Verify every package and generated barrel matches VERSION",
-      },
-      ...(project.github
-        ? {
-            release: {
-              exec: taskScript(
-                project,
-                "release.ts",
-                `--prefix ${tagPrefix} --branch ${releaseBranch}`,
-              ),
-              receiveArgs: true,
-              description: "Run bump, commit it, and push an annotated release tag",
-            },
-          }
-        : {}),
+    project.addTask("bump", {
+      execArgs: taskCommand("bump.ts"),
+      receiveArgs: true,
+      description: "Increment VERSION and synchronize generated workspace versions",
+    });
+    project.addTask("version:check", {
+      execArgs: taskCommand("version-check.ts"),
+      description: "Verify every package and generated barrel matches VERSION",
     });
+    if (project.github) {
+      project.addTask("release", {
+        execArgs: taskCommand(
+          "release.ts",
+          "--prefix",
+          tagPrefix,
+          "--branch",
+          releaseBranch,
+          ...(options.pythonRoot ? ["--python-root", options.pythonRoot] : []),
+          ...(options.validationTasks ?? []).flatMap((task) => ["--validate", task]),
+        ),
+        receiveArgs: true,
+        description: "Run bump, commit it, and push an annotated release tag",
+      });
+    }
     if (!project.github) return;
 
     const workflow = new GithubWorkflow(project.github, "release", {
@@ -336,5 +297,6 @@ export class DBXToolsRelease extends Component {
     if (options.docs) {
       addDocsJobs(workflow, project, options.docs);
     }
+    refreshReleaseDocsDependencies(project);
   }
 }

package/src/tags.ts

@@ -14,18 +14,18 @@
  * callers add their own afterward.
  */
 import type { IMixin as ConstructsMixin } from "constructs";
-import { javascript } from "projen";
+import { DependencyType, javascript } from "projen";
 import { BunBuildFile, BunDevServerFile, BunfigFile } from "./bun-app.ts";
+import { BUN_VERSION } from "./bun-workflow.ts";
 import { create } from "./mixin.ts";
-import * as projectPredicate from "./project-predicate.ts";
 import {
   addPackageFiles,
   applyCompilerOptions,
   applyExports,
   applyIncludes,
-  applyTasks,
   srcModuleExports,
-} from "./project.ts";
+} from "./project-js.ts";
+import * as projectPredicate from "./project-predicate.ts";
 
 /** Node compiler options: ES2022 lib + node types, deliberately no DOM. */
 const NODE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
@@ -37,6 +37,10 @@ const NODE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
 /** The DOM-capable lib list shared by the browser tags (`ui`, `openapi`). */
 const DOM_LIB = ["ES2022", "DOM", "DOM.Iterable"];
 
+function removeNodeTypes(project: javascript.NodeProject): void {
+  project.deps.removeDependency("@types/node", DependencyType.BUILD);
+}
+
 /**
  * The agnostic floor every package gets at construction: ES2022 stdlib plus the
  * web-platform globals available in every JS runtime (browser, workers, Node 18+)
@@ -64,6 +68,7 @@ export const PACKAGE_TAG_MIXINS = {
   // compile (typecheck). No app build / index.html: a full browser app is an
   // `app`-tagged package (see below) that layers Bun's build tooling on top.
   ui: create(projectPredicate.hasTag("ui"), (p) => {
+    removeNodeTypes(p);
     p.addPeerDeps("react@catalog:", "react-dom@catalog:");
     p.addDevDeps(
       "react@catalog:",
@@ -79,13 +84,10 @@ export const PACKAGE_TAG_MIXINS = {
       target: "ES2022",
       lib: [...DOM_LIB],
     });
-    // A component library's standard subpath surface: `./react` (components),
-    // `./styles.css` (Tailwind entry), and `./package.json`. A package that
-    // ships more (e.g. ui-appkit's `./vite` preset) overrides this in its own
-    // mixin; an `app`-tagged package replaces it with a `.` root (see below).
+    // UI libraries are subpath-only. Their React entrypoint, optional stylesheet,
+    // and any other public source modules are discovered from the source tree.
     applyExports(p, {
-      "./react": "./src/react/index.ts",
-      "./styles.css": "./src/styles.css",
+      ...srcModuleExports(p),
       "./package.json": "./package.json",
     });
   }),
@@ -95,8 +97,10 @@ export const PACKAGE_TAG_MIXINS = {
   // `Bun.build`). Tailwind v4 is compiled by `bun-plugin-tailwind` (wired in the
   // generated `bunfig.toml`). No Vite.
   app: create(projectPredicate.hasTag("app"), (p) => {
+    removeNodeTypes(p);
     p.addDeps("react@catalog:", "react-dom@catalog:");
     p.addDevDeps(
+      `@types/bun@${BUN_VERSION}`,
       "@types/react@catalog:",
       "@types/react-dom@catalog:",
       // The Tailwind plugin the dev server + build load. Tailwind itself is a
@@ -121,10 +125,8 @@ export const PACKAGE_TAG_MIXINS = {
     // and `preview` serves the already-built bundle. `Bun.serve` builds on request,
     // so `preview` could only be spelled the same as `dev` - two names for one
     // command, and a reader would reasonably assume the second one served `dist/`.
-    applyTasks(p, {
-      dev: { exec: "bun dev.ts" },
-      build: { exec: "bun build.ts" },
-    });
+    (p.tasks.tryFind("dev") ?? p.addTask("dev")).reset("bun dev.ts");
+    p.compileTask.reset("bun build.ts");
     new BunfigFile(p);
     new BunDevServerFile(p);
     new BunBuildFile(p);
@@ -172,19 +174,19 @@ export const PACKAGE_TAG_MIXINS = {
     });
     // bun runs the server `.ts` directly (native TS, no tsx). `--watch` restarts
     // on change - the tsx-watch replacement.
-    applyTasks(p, {
-      dev: { exec: "bun --watch src/server.ts" },
-      start: { exec: "bun src/server.ts" },
-    });
+    (p.tasks.tryFind("dev") ?? p.addTask("dev")).reset("bun --watch src/server.ts");
+    (p.tasks.tryFind("start") ?? p.addTask("start")).reset("bun src/server.ts");
   }),
   node: create(projectPredicate.hasTag("node"), (p) => {
     p.addDevDeps("@types/node@catalog:");
     applyCompilerOptions(p, NODE_COMPILER_OPTIONS);
   }),
   shared: create(projectPredicate.hasTag("shared"), (p) => {
+    removeNodeTypes(p);
     applyCompilerOptions(p, AGNOSTIC_COMPILER_OPTIONS);
   }),
   openapi: create(projectPredicate.hasTag("openapi"), (p) => {
+    removeNodeTypes(p);
     p.addDeps("openapi-fetch@catalog:");
     applyCompilerOptions(p, { target: "ES2022", lib: [...DOM_LIB], types: [] });
     addPackageFiles(p, "openapi.json");

package/src/tsconfig.ts

@@ -34,6 +34,12 @@ const BASE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
  * Packages type-check against their own projen-generated tsconfigs via `compile`.
  */
 export class DBXToolsRootTsconfig extends Component {
+  /** Shared compiler floor inherited by the root program. */
+  readonly base?: javascript.TypescriptConfig;
+
+  /** Root program config inherited by the generated Projen config. */
+  readonly config?: javascript.TypescriptConfig;
+
   constructor(scope: Project) {
     super(scope);
 
@@ -41,13 +47,12 @@ export class DBXToolsRootTsconfig extends Component {
       return;
     }
 
-    const base = new javascript.TypescriptConfig(scope, {
+    this.base = new javascript.TypescriptConfig(scope, {
       fileName: "tsconfig.base.json",
       compilerOptions: BASE_COMPILER_OPTIONS,
     });
-    base.file.readonly = true;
-    const root = new javascript.TypescriptConfig(scope, {
-      extends: javascript.TypescriptConfigExtends.fromTypescriptConfigs([base]),
+    this.config = new javascript.TypescriptConfig(scope, {
+      extends: javascript.TypescriptConfigExtends.fromTypescriptConfigs([this.base]),
       compilerOptions: {
         lib: ["ESNext"],
         types: ["node"],
@@ -55,6 +60,5 @@ export class DBXToolsRootTsconfig extends Component {
       include: [".projenrc.ts"],
       exclude: ["node_modules", "**/dist", "**/node_modules"],
     });
-    root.file.readonly = true;
   }
 }

package/src/vscode.ts

@@ -5,65 +5,54 @@
  * is delivered by `.vscode/tasks.json` (`runOn: folderOpen`) - projen has no native
  * tasks.json component, so a `JsonFile` is the idiomatic emitter.
  */
-import { Component, JsonFile, javascript, vscode } from "projen";
+import { JsonFile, javascript } from "projen";
 
-/**
- * Configures root `.vscode/settings.json`, `extensions.json`, and `tasks.json`.
- * Only a tree ROOT constructs this component (see {@link DBXToolsNodeProject}).
- */
-export class DBXToolsVsCode extends Component {
-  /** projen's built-in VsCode component (settings + extension recommendations). */
-  readonly vsCode: vscode.VsCode;
-
-  constructor(scope: javascript.NodeProject) {
-    super(scope);
+/** Configure the native Projen VS Code component and the unsupported tasks file. */
+export function configureVsCode(scope: javascript.NodeProject): void {
+  const editor = scope.vscode;
+  if (!editor) return;
+  editor.settings.addSettings({
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "typescript.preferences.importModuleSpecifier": "non-relative",
+    "javascript.preferences.importModuleSpecifier": "non-relative",
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "files.watcherExclude": {
+      "**/node_modules/**": true,
+      "**/dist/**": true,
+    },
+  });
+  editor.extensions.addRecommendations("esbenp.prettier-vscode");
 
-    this.vsCode = scope.vscode ?? new vscode.VsCode(scope);
-    this.vsCode.settings.addSettings({
-      "typescript.tsdk": "node_modules/typescript/lib",
-      "typescript.preferences.importModuleSpecifier": "non-relative",
-      "javascript.preferences.importModuleSpecifier": "non-relative",
-      "editor.formatOnSave": true,
-      "editor.defaultFormatter": "esbenp.prettier-vscode",
-      "files.watcherExclude": {
-        "**/node_modules/**": true,
-        "**/dist/**": true,
-      },
-    });
-    this.vsCode.extensions.addRecommendations("esbenp.prettier-vscode");
-    this.vsCode.settings.file.readonly = true;
-    this.vsCode.extensions.file.readonly = true;
-
-    new JsonFile(scope, ".vscode/tasks.json", {
-      marker: false,
-      readonly: true,
-      obj: {
-        version: "2.0.0",
-        tasks: [
-          {
-            label: "sync",
-            detail:
-              "projen sync --watch - projenrc (.projenrc.ts + syncResynthPaths re-synth) + barrels + openapi watchers",
-            type: "shell",
-            command: "bun run sync -- --watch",
-            isBackground: true,
-            problemMatcher: [],
-            runOptions: { runOn: "folderOpen" },
-            presentation: {
-              reveal: "always",
-              panel: "dedicated",
-              group: "projen",
-            },
-          },
-          {
-            label: "synth",
-            detail: "projen - synthesize all generated config",
-            type: "shell",
-            command: "bun run default",
-            problemMatcher: [],
+  new JsonFile(scope, ".vscode/tasks.json", {
+    marker: false,
+    readonly: true,
+    obj: {
+      version: "2.0.0",
+      tasks: [
+        {
+          label: "sync",
+          detail:
+            "projen sync --watch - projenrc (.projenrc.ts + syncResynthPaths re-synth) + barrels + openapi watchers",
+          type: "shell",
+          command: "bun run sync -- --watch",
+          isBackground: true,
+          problemMatcher: [],
+          runOptions: { runOn: "folderOpen" },
+          presentation: {
+            reveal: "always",
+            panel: "dedicated",
+            group: "projen",
           },
-        ],
-      },
-    });
-  }
+        },
+        {
+          label: "synth",
+          detail: "projen - synthesize all generated config",
+          type: "shell",
+          command: "bun run default",
+          problemMatcher: [],
+        },
+      ],
+    },
+  });
 }

package/src/watch.ts

@@ -90,19 +90,13 @@ export interface WatchLoopOptions {
   check?: (changed: string[]) => boolean | Promise<boolean>;
 }
 
-function resolveWatchLoopOptions(config?: IgnoreGroupOptions | WatchLoopOptions): WatchLoopOptions {
-  if (!config) return {};
-  if ("check" in config || "ignoreOptions" in config) return config as WatchLoopOptions;
-  return { ignoreOptions: config as IgnoreGroupOptions };
-}
-
 export function watchLoop(
   tag: string,
   paths: string[],
   onBatch: (changed: string[]) => void | Promise<void>,
-  config?: IgnoreGroupOptions | WatchLoopOptions,
+  config: WatchLoopOptions = {},
 ): void {
-  const { ignoreOptions, check } = resolveWatchLoopOptions(config);
+  const { ignoreOptions, check } = config;
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | undefined;
   let running = false;

package/src/workspace-version.ts

@@ -110,17 +110,12 @@ export function syncWorkspaceManifestVersion(manifestPath: string, version: stri
   return true;
 }
 
-/** The checked-in version a release increment starts from. */
-export function resolveBaseVersion(root: string): string {
-  return readWorkspaceVersion(root);
-}
-
 /** Resolve the next release version without mutating the workspace. */
 export function resolveNextVersion(
   root: string,
   level: VersionLevel,
 ): { base: string; version: string } {
-  const base = resolveBaseVersion(root);
+  const base = readWorkspaceVersion(root);
   const parsed = parseSemver(base) ?? [0, 0, 1];
   return {
     base: parsed.join("."),