@dbx-tools/projen 0.6.77 → 0.6.78

package/index.ts

@@ -36,11 +36,11 @@ export { repoRoot, DEFAULT_PACKAGE_ROOTS, DiscoveredPackage } from "./src/packag
 export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
 export type { Catalog, AllowBuilds, DBXToolsPNPMWorkspaceOptions } from "./src/pnpm-workspace.ts";
-export type { ApplyToProjectsOptions } from "./src/project.ts";
+export type { DBXToolsProjectLanguage, DBXToolsProjectOptions, DBXToolsProject, ApplyToProjectsOptions } from "./src/project.ts";
 export { PackageIdentifier, PROJEN_VERSION, DBXToolsNodeProject, ROOT_INSTALL_ONLY_MIXIN, DBXToolsTypeScriptProject } from "./src/project-js.ts";
-export type { DBXToolsProject, DBXToolsProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
-export { DBXToolsPythonWorkspace } from "./src/project-py.ts";
-export type { PythonRepositoryOptions, PythonPackageOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
+export type { DBXToolsJavaScriptProject, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
+export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
+export type { PythonRepositoryOptions, PythonPackageOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.ts";

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.77",
-    "@dbx-tools/path": "0.6.77",
-    "@dbx-tools/shared-core": "0.6.77",
+    "@dbx-tools/core": "0.6.78",
+    "@dbx-tools/path": "0.6.78",
+    "@dbx-tools/shared-core": "0.6.78",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -47,7 +47,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.77",
+  "version": "0.6.78",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/pnpm-workspace.ts

@@ -250,6 +250,7 @@ export class PnpmWorkspaceState {
    */
   public resolveMembers(project: Project, extraMembers: readonly string[] = []): void {
     const members = project.subprojects
+      .filter((sub): sub is javascript.NodeProject => sub instanceof javascript.NodeProject)
       .map((sub) => toPosix(relative(project.outdir, sub.outdir)))
       .filter(Boolean);
     // `extraMembers` are workspace siblings NOT attached as subprojects (e.g. the

package/src/project-js.ts

@@ -1,10 +1,10 @@
 /**
  * The dbx-tools project surface plus package tooling: the single
- * {@link DBXToolsProject} interface, the projen Node/TypeScript project classes,
+ * {@link DBXToolsJavaScriptProject} interface, the projen Node/TypeScript project classes,
  * naming, guards, manifest fields, and the shared root init.
  *
  * {@link DBXToolsNodeProject} (monorepo root) and {@link DBXToolsTypeScriptProject}
- * (a package, or a standalone compiling root) both implement {@link DBXToolsProject}.
+ * (a package, or a standalone compiling root) both implement {@link DBXToolsJavaScriptProject}.
  */
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
@@ -41,13 +41,14 @@ import { DBXToolsRelease, type StandaloneRelease } from "./release.ts";
 import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
 import { DBXToolsRootTsconfig } from "./tsconfig.ts";
 import { DBXToolsVsCode } from "./vscode.ts";
+import type { DBXToolsProject, DBXToolsProjectOptions as CommonProjectOptions } from "./project.ts";
 
 /**
  * The dbx-tools project surface, backed by projen's Node toolchain. A single
  * interface for both the monorepo root and each package: it carries the
  * `dbxToolsConfig` component plus the npm-naming and root-only file components.
  */
-export interface DBXToolsProject extends javascript.NodeProject {
+export interface DBXToolsJavaScriptProject extends DBXToolsProject, javascript.NodeProject {
   /** The package's `dbxToolsConfig` component (tags + `package.json` config). */
   readonly dbxToolsConfig: DBXToolsConfig;
   /** npm scope (the `@scope` in `@scope/pkg`), without the leading `@`. */
@@ -342,7 +343,9 @@ export const PROJEN_VERSION = "^0.101.16";
  * inherits the root's config rather than emitting its own. `name`/`defaultReleaseBranch`
  * are resolved/applied by the caller.
  */
-function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProjectOptions {
+function defaultProjectOptions(
+  options: DBXToolsJavaScriptProjectOptions,
+): DBXToolsJavaScriptProjectOptions {
   const isRoot = options.parent === undefined;
   return {
     // Bun owns install/run/build/test locally and in CI. projen renders
@@ -420,7 +423,7 @@ function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProject
  * pristine array to seed a child's fresh one. Spread AFTER `...options`.
  */
 function copiedGitIgnoreOptions(
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): Pick<javascript.NodeProjectOptions, "gitIgnoreOptions"> {
   if (!options.gitIgnoreOptions?.ignorePatterns) return {};
   return {
@@ -460,8 +463,9 @@ function defaultTypeScriptProjectOptions(
 const DEV_DEPS_ROOT: string[] = ["typescript@^5.9.3", "@types/bun@^1.3.14"];
 
 /** Options for {@link DBXToolsNodeProject} (the monorepo root). */
-export interface DBXToolsProjectOptions
+export interface DBXToolsJavaScriptProjectOptions
   extends
+    CommonProjectOptions,
     Partial<javascript.NodeProjectOptions>,
     DBXToolsConfigOptions,
     DBXToolsPNPMWorkspaceOptions {
@@ -529,7 +533,7 @@ export interface DBXToolsProjectOptions
 
 /** Options for {@link DBXToolsTypeScriptProject} (a package, or a compiling root). */
 export interface DBXToolsTypeScriptProjectOptions
-  extends Partial<typescript.TypeScriptProjectOptions>, DBXToolsProjectOptions {
+  extends Partial<typescript.TypeScriptProjectOptions>, DBXToolsJavaScriptProjectOptions {
   /** Emit the projen-owned bun app scaffolding (`bunfig.toml`/`dev.ts`/`build.ts`). */
   readonly bunApp?: boolean;
 }
@@ -539,7 +543,11 @@ export interface DBXToolsTypeScriptProjectOptions
  * {@link DBXToolsTypeScriptProject} per `src`-bearing folder, then emits the
  * shared config, tasks, `pnpm-workspace.yaml`, and barrels-on-synth.
  */
-export class DBXToolsNodeProject extends javascript.NodeProject implements DBXToolsProject {
+export class DBXToolsNodeProject
+  extends javascript.NodeProject
+  implements DBXToolsJavaScriptProject
+{
+  readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
   pnpmWorkspace?: PnpmWorkspaceState;
@@ -548,7 +556,7 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
   private readonly extraWorkspaceMembers: readonly string[];
   private readonly rootInstallOnly: boolean;
 
-  constructor(options: DBXToolsProjectOptions = {}) {
+  constructor(options: DBXToolsJavaScriptProjectOptions = {}) {
     const { name, scope } = resolveIdentity(options);
     const releaseDefaults =
       options.release && options.releaseTrigger === undefined
@@ -622,8 +630,9 @@ export const ROOT_INSTALL_ONLY_MIXIN = mixin.create(
  */
 export class DBXToolsTypeScriptProject
   extends typescript.TypeScriptProject
-  implements DBXToolsProject
+  implements DBXToolsJavaScriptProject
 {
+  readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
   pnpmWorkspace?: PnpmWorkspaceState;
@@ -816,7 +825,7 @@ class PrettierIgnoreGenerated extends Component {
 /** Default leading path segment stripped from a package's name (not its tag). */
 const DEFAULT_OMIT_RELATIVE_PREFIX = ["node"];
 
-/** Normalize the {@link DBXToolsProjectOptions.omitRelativePrefix} option to a slug list. */
+/** Normalize the {@link DBXToolsJavaScriptProjectOptions.omitRelativePrefix} option to a slug list. */
 function resolveOmitRelativePrefix(option: OneOrMany<string> | undefined): string[] {
   const raw = option === undefined ? DEFAULT_OMIT_RELATIVE_PREFIX : option;
   const list = Array.isArray(raw) ? raw : [raw];
@@ -943,7 +952,7 @@ export function taskScript(_project: javascript.NodeProject, script: string, arg
  */
 function initProject(
   project: DBXToolsNodeProject | DBXToolsTypeScriptProject,
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): void {
   // projen's GithubProject seeds a `# replace this` SampleReadme on every
   // project. READMEs are hand-written and owned outside projen, so drop the
@@ -1101,7 +1110,7 @@ function initProject(
 
   // Already-attached subprojects, keyed by repo-relative member path.
   const rootAbs = resolve(project.outdir);
-  const existing = new Map<string, DBXToolsProject>();
+  const existing = new Map<string, DBXToolsJavaScriptProject>();
   for (const sub of project.subprojects) {
     if (sub instanceof DBXToolsNodeProject || sub instanceof DBXToolsTypeScriptProject) {
       existing.set(toPosix(relative(rootAbs, sub.outdir)), sub);
@@ -1182,7 +1191,7 @@ class ChildGitignore extends IgnoreFile {
  */
 function swapChildGitignore(
   project: javascript.NodeProject,
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): void {
   project.tryRemoveFile(".gitignore");
   const fresh = new ChildGitignore(project, ".gitignore", {

package/src/project-predicate.ts

@@ -11,7 +11,8 @@ import { IConstruct } from "constructs";
 import { Project } from "projen";
 import { project } from "..";
 import { toPosix } from "./packages.ts";
-import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project-js.ts";
+import type { DBXToolsProject } from "./project.ts";
+import type { DBXToolsJavaScriptProject } from "./project-js.ts";
 
 /**
  * Guard: the construct is a projen {@link Project} - the base every builder here
@@ -27,11 +28,19 @@ export function isProject(): Predicate<IConstruct, Project> {
   return predicate.create((c: IConstruct): c is Project => Project.isProject(c));
 }
 
-/** Guard: the construct is a {@link DBXToolsProject} (a DBXTools Node or TypeScript project). */
+/** Guard: the construct implements the language-agnostic {@link DBXToolsProject} contract. */
 export function isDBXToolsProject(): Predicate<IConstruct, DBXToolsProject> {
   return isProject().and(
     (project): project is DBXToolsProject =>
-      project instanceof DBXToolsNodeProject || project instanceof DBXToolsTypeScriptProject,
+      (project as Partial<DBXToolsProject>).language === "javascript" ||
+      (project as Partial<DBXToolsProject>).language === "python",
+  );
+}
+
+/** Guard: the construct is a dbx-tools JavaScript/TypeScript project. */
+export function isDBXToolsJavaScriptProject(): Predicate<IConstruct, DBXToolsJavaScriptProject> {
+  return isDBXToolsProject().and(
+    (project): project is DBXToolsJavaScriptProject => project.language === "javascript",
   );
 }
 
@@ -97,14 +106,16 @@ export function hasIdentifierScope(
 
 /**
  * Matches DBXTools packages carrying every listed tag (`dbxToolsConfig.tags`), narrowing
- * {@link Project} to {@link DBXToolsProject} (tags live only on DBXTools packages). Also the
+ * {@link Project} to {@link DBXToolsJavaScriptProject} (tags live only on JavaScript packages). Also the
  * guard backing each built-in {@link PACKAGE_TAG_MIXINS} entry. Keep it in the SAME `.and(...)`
  * as any name/path filter (or last when chaining) - a later non-tag `.and` re-widens to
  * {@link Project} and drops the narrowing.
  */
-export function hasTag(...tags: OneOrMany<PathMatchInput>): Predicate<IConstruct, DBXToolsProject> {
+export function hasTag(
+  ...tags: OneOrMany<PathMatchInput>
+): Predicate<IConstruct, DBXToolsJavaScriptProject> {
   const matchers = projectMatchers(...tags);
-  return isDBXToolsProject().and((project) =>
+  return isDBXToolsJavaScriptProject().and((project) =>
     matchers.every((matcher) => project.dbxToolsConfig.tags.some((tag) => matcher(tag))),
   );
 }

package/src/project-py.ts

@@ -1,8 +1,9 @@
 /** Reusable uv workspace generation for Python packages hosted in a projen tree. */
 import { string } from "@dbx-tools/shared-core";
-import { Component, TextFile, type Project, javascript, vscode } from "projen";
+import { Component, type Project, javascript, python, vscode } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission } from "projen/lib/github/workflows-model";
+import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
 
 /** Git location used by direct `#subdirectory=` package dependencies. */
 export interface PythonRepositoryOptions {
@@ -12,7 +13,7 @@ export interface PythonRepositoryOptions {
 }
 
 /** One independently installable Python package in the uv workspace. */
-export interface PythonPackageOptions {
+export interface PythonPackageOptions extends DBXToolsProjectOptions {
   readonly directory: string;
   readonly name: string;
   readonly module: string;
@@ -20,10 +21,19 @@ export interface PythonPackageOptions {
   readonly dependencies?: readonly string[];
 }
 
+/** Options for one projen-native Python workspace member. */
+export interface DBXToolsPythonProjectOptions extends DBXToolsProjectOptions {
+  readonly parent: Project;
+  readonly package: PythonPackageOptions;
+  readonly repository: Required<PythonRepositoryOptions>;
+  readonly requiresPython: string;
+}
+
 /** Python release workflow configuration. */
 export interface PythonReleaseOptions {
   readonly workflowName?: string;
-  readonly environment?: string;
+  /** GitHub environment by Python distribution name. Defaults to `pypi-<name>`. */
+  readonly environments?: Readonly<Record<string, string>>;
   readonly environmentUrl?: string;
 }
 
@@ -69,27 +79,112 @@ function projectVscode(project: Project): vscode.VsCode | undefined {
   return (project as Project & { readonly vscode?: vscode.VsCode }).vscode;
 }
 
+/** A Python package implemented with projen's `PythonProject` and uv backend. */
+export class DBXToolsPythonProject extends python.PythonProject implements DBXToolsProject {
+  readonly language = "python" as const;
+  readonly packageOptions: PythonPackageOptions;
+  readonly uv: python.Uv;
+
+  constructor(options: DBXToolsPythonProjectOptions) {
+    const pkg = options.package;
+    super({
+      parent: options.parent,
+      outdir: pythonPackagePath(options.repository, pkg.directory),
+      name: pkg.name,
+      moduleName: pkg.module,
+      authorName: "",
+      authorEmail: "",
+      version: "0.0.0",
+      description: pkg.description,
+      github: false,
+      sample: false,
+      pytest: false,
+      projenrcPython: false,
+      projenrcJs: false,
+      projenrcTs: false,
+      pip: false,
+      venv: false,
+      setuptools: false,
+      poetry: false,
+      uv: true,
+      projenCommand: options.parent.projenCommand,
+      uvOptions: {
+        project: {
+          name: pkg.name,
+          version: "0.0.0",
+          description: pkg.description,
+          readme: "README.md",
+          requiresPython: options.requiresPython,
+          dependencies: [...(pkg.dependencies ?? [])],
+          urls: {
+            Source: `${options.repository.url.replace(/\.git$/, "")}/tree/${options.repository.ref}/${pythonPackagePath(options.repository, pkg.directory)}`,
+          },
+        },
+        buildSystem: {
+          requires: ["uv_build>=0.11.28,<0.12.0"],
+          buildBackend: "uv_build",
+        },
+        uv: {
+          buildBackend: {
+            moduleName: pkg.module,
+            moduleRoot: "src",
+            namespace: true,
+          },
+        },
+      },
+    });
+    this.packageOptions = pkg;
+    if (!(this.packagingManager instanceof python.Uv)) {
+      throw new Error(`Expected uv packaging for ${pkg.name}`);
+    }
+    this.uv = this.packagingManager;
+    this.uv.file.addDeletionOverride("project.authors");
+    this.uv.file.addDeletionOverride("dependency-groups");
+    this.uv.file.readonly = true;
+
+    for (const path of [".gitattributes", ".gitignore"]) {
+      this.tryRemoveFile(path);
+    }
+  }
+
+  /** The root workspace owns dependency installation for every member. */
+  public override postSynthesize(): void {}
+}
+
 /**
- * Generates a root uv workspace, member package metadata, Python tasks, editor
- * interpreter selection, and an optional trusted-publishing workflow.
+ * Generates a root uv workspace, projen-native Python member projects, Python
+ * tasks, editor interpreter selection, and an optional publishing workflow.
  */
 export class DBXToolsPythonWorkspace extends Component {
-  readonly packages: readonly PythonPackageOptions[];
+  readonly packages: readonly DBXToolsPythonProject[];
   readonly repository: Required<PythonRepositoryOptions>;
   readonly requiresPython: string;
+  readonly file: python.PyprojectTomlFile;
 
   constructor(project: javascript.NodeProject, options: DBXToolsPythonWorkspaceOptions) {
     super(project);
-    this.packages = options.packages;
     this.repository = {
       url: options.repository.url,
       ref: options.repository.ref ?? "main",
       root: options.repository.root ?? "packages/py",
     };
     this.requiresPython = options.requiresPython ?? ">=3.10";
-
-    this.emitWorkspace(project, options);
-    this.emitPackages(project);
+    this.file = this.emitWorkspace(project, options);
+    this.packages = options.packages.map(
+      (pkg) =>
+        new DBXToolsPythonProject({
+          parent: project,
+          package: pkg,
+          repository: this.repository,
+          requiresPython: this.requiresPython,
+        }),
+    );
+    for (const pkg of this.packages) {
+      const pyproject = `/${pythonPackagePath(this.repository, pkg.packageOptions.directory)}/pyproject.toml`;
+      project.gitignore.include(pyproject);
+      project.gitattributes.addAttributes(pyproject, "linguist-generated");
+      project.prettier?.addIgnorePattern(pyproject.slice(1));
+    }
     this.addTasks(project, options);
 
     const interpreterPath = options.interpreterPath ?? "${workspaceFolder}/.venv/bin/python";
@@ -115,81 +210,45 @@ export class DBXToolsPythonWorkspace extends Component {
   private emitWorkspace(
     project: javascript.NodeProject,
     options: DBXToolsPythonWorkspaceOptions,
-  ): void {
-    const devDependencies = options.devDependencies ?? DEFAULT_DEV_DEPENDENCIES;
+  ): python.PyprojectTomlFile {
     const testPaths = options.testPaths ?? [this.repository.root];
-    const ruffTarget = options.ruffTarget ?? "py310";
     const perFileIgnores = options.ruffPerFileIgnores ?? {};
-    new TextFile(project, "pyproject.toml", {
-      marker: false,
-      readonly: true,
-      lines: [
-        '# ~~ Generated by projen. To modify, edit .projenrc.ts and run "bunx projen".',
-        "[project]",
-        `name = ${quote(options.workspaceName ?? `${string.toSlug(project.name)}-python-workspace`)}`,
-        'version = "0.0.0"',
-        `requires-python = ${quote(this.requiresPython)}`,
-        "dependencies = []",
-        "",
-        "[dependency-groups]",
-        `dev = [${devDependencies.map(quote).join(", ")}]`,
-        "",
-        "[tool.uv]",
-        "package = false",
-        "",
-        "[tool.uv.workspace]",
-        `members = [${quote(`${this.repository.root}/*`)}]`,
-        "",
-        "[tool.uv.sources]",
-        ...this.packages.map((pkg) => `${pkg.name} = { workspace = true }`),
-        "",
-        "[tool.pytest.ini_options]",
-        'asyncio_mode = "auto"',
-        `testpaths = [${testPaths.map(quote).join(", ")}]`,
-        "",
-        "[tool.ruff]",
-        `target-version = ${quote(ruffTarget)}`,
-        "line-length = 100",
-        "",
-        "[tool.ruff.lint.per-file-ignores]",
-        ...Object.entries(perFileIgnores).map(
-          ([path, rules]) => `${quote(path)} = [${rules.map(quote).join(", ")}]`,
-        ),
-        "",
-      ],
+    const file = new python.PyprojectTomlFile(project, {
+      project: {
+        name: options.workspaceName ?? `${string.toSlug(project.name)}-python-workspace`,
+        version: "0.0.0",
+        requiresPython: this.requiresPython,
+        dependencies: [],
+      },
+      dependencyGroups: {
+        dev: [...(options.devDependencies ?? DEFAULT_DEV_DEPENDENCIES)],
+      },
+      tool: {
+        uv: python.uvConfig.toJson_UvConfiguration({
+          package: false,
+          workspace: { members: [`${this.repository.root}/*`] },
+        }),
+        pytest: {
+          ini_options: {
+            asyncio_mode: "auto",
+            testpaths: testPaths,
+          },
+        },
+        ruff: {
+          "target-version": options.ruffTarget ?? "py310",
+          "line-length": 100,
+          lint: {
+            "per-file-ignores": perFileIgnores,
+          },
+        },
+      },
     });
-  }
-
-  private emitPackages(project: javascript.NodeProject): void {
-    for (const pkg of this.packages) {
-      new TextFile(project, `${this.packagePath(pkg.directory)}/pyproject.toml`, {
-        marker: false,
-        readonly: true,
-        lines: [
-          '# ~~ Generated by projen. To modify, edit .projenrc.ts and run "bunx projen".',
-          "[project]",
-          `name = ${quote(pkg.name)}`,
-          'version = "0.0.0"',
-          `description = ${quote(pkg.description)}`,
-          'readme = "README.md"',
-          `requires-python = ${quote(this.requiresPython)}`,
-          `dependencies = [${(pkg.dependencies ?? []).map(quote).join(", ")}]`,
-          "",
-          "[project.urls]",
-          `Source = ${quote(`${this.repository.url.replace(/\.git$/, "")}/tree/${this.repository.ref}/${this.packagePath(pkg.directory)}`)}`,
-          "",
-          "[build-system]",
-          'requires = ["uv_build>=0.11.28,<0.12.0"]',
-          'build-backend = "uv_build"',
-          "",
-          "[tool.uv.build-backend]",
-          `module-name = ${quote(pkg.module)}`,
-          'module-root = "src"',
-          "namespace = true",
-          "",
-        ],
-      });
-    }
+    file.addOverride(
+      "tool.uv.sources",
+      Object.fromEntries(options.packages.map((pkg) => [pkg.name, { workspace: true }])),
+    );
+    file.readonly = true;
+    return file;
   }
 
   private addTasks(project: javascript.NodeProject, options: DBXToolsPythonWorkspaceOptions): void {
@@ -247,12 +306,20 @@ export class DBXToolsPythonWorkspace extends Component {
           env: { VERSION: "${{ inputs.version }}" },
           run: this.renderVersionStampScript(),
         },
-        { name: "Build distributions", run: "uv build --all-packages" },
+        {
+          name: "Build distributions",
+          run: this.packages
+            .map(
+              (pkg) =>
+                `uv build --package ${pkg.packageOptions.name} --out-dir dist/${pkg.packageOptions.directory}`,
+            )
+            .join("\n"),
+        },
         {
           name: "Validate distributions",
           run: [
-            `test "$(find dist -maxdepth 1 -type f | wc -l | tr -d ' ')" -eq ${this.packages.length * 2}`,
-            "uvx twine check dist/*",
+            `test "$(find dist -type f \\( -name '*.whl' -o -name '*.tar.gz' \\) | wc -l | tr -d ' ')" -eq ${this.packages.length * 2}`,
+            "uvx twine check dist/*/*.whl dist/*/*.tar.gz",
           ].join("\n"),
         },
         {
@@ -262,29 +329,34 @@ export class DBXToolsPythonWorkspace extends Component {
         },
       ],
     });
-    workflow.addJob("publish", {
-      if: "${{ inputs.publish }}",
-      needs: ["build"],
-      environment: {
-        name: options.environment ?? "pypi",
-        url: options.environmentUrl ?? "https://pypi.org/",
-      },
-      runsOn: ["ubuntu-latest"],
-      permissions: { idToken: JobPermission.WRITE },
-      timeoutMinutes: 10,
-      steps: [
-        {
-          name: "Download distributions",
-          uses: "actions/download-artifact@v8",
-          with: { name: "python-distributions", path: "dist" },
-        },
-        {
-          name: "Publish to PyPI",
-          uses: "pypa/gh-action-pypi-publish@release/v1",
-          with: { "packages-dir": "dist" },
+    for (const pkg of this.packages) {
+      workflow.addJob(`publish-${pkg.packageOptions.directory}`, {
+        if: "${{ inputs.publish }}",
+        needs: ["build"],
+        environment: {
+          name:
+            options.environments?.[pkg.packageOptions.name] ?? `pypi-${pkg.packageOptions.name}`,
+          url:
+            options.environmentUrl ??
+            `https://pypi.org/project/${pkg.packageOptions.name.replaceAll("_", "-")}/`,
         },
-      ],
-    });
+        runsOn: ["ubuntu-latest"],
+        permissions: { idToken: JobPermission.WRITE },
+        timeoutMinutes: 10,
+        steps: [
+          {
+            name: "Download distributions",
+            uses: "actions/download-artifact@v8",
+            with: { name: "python-distributions", path: "dist" },
+          },
+          {
+            name: `Publish ${pkg.packageOptions.name} to PyPI`,
+            uses: "pypa/gh-action-pypi-publish@release/v1",
+            with: { "packages-dir": `dist/${pkg.packageOptions.directory}` },
+          },
+        ],
+      });
+    }
   }
 
   private renderVersionStampScript(): string {

package/src/project.ts

@@ -5,14 +5,27 @@
 import { type PathMatchInput } from "@dbx-tools/path";
 import { object, type OneOrMany } from "@dbx-tools/shared-core";
 import { type IConstruct } from "constructs";
-import { Project } from "projen";
+import { Project, type ProjectOptions } from "projen";
 import * as mixin from "./mixin.ts";
 import * as projectPredicate from "./project-predicate.ts";
-import type { DBXToolsProject } from "./project-js.ts";
+import type { DBXToolsJavaScriptProject } from "./project-js.ts";
 
 export * from "./project-js.ts";
 export * from "./project-py.ts";
 
+/** Runtime family implemented by a dbx-tools project. */
+export type DBXToolsProjectLanguage = "javascript" | "python";
+
+/** Options shared by every dbx-tools project implementation. */
+export interface DBXToolsProjectOptions extends Partial<
+  Pick<ProjectOptions, "name" | "parent" | "outdir">
+> {}
+
+/** Minimal language-agnostic project contract. */
+export interface DBXToolsProject extends Project {
+  readonly language: DBXToolsProjectLanguage;
+}
+
 /** Filters selecting which projects an {@link applyToProjects} call runs against. */
 export interface ApplyToProjectsOptions {
   /** Include plain projen projects. Defaults to DBXTools projects only. */
@@ -45,8 +58,8 @@ type ApplyToAllProjectsOptions = Omit<ApplyToProjectsOptions, "includeNonDBXTool
 export function applyToProjects(
   construct: IConstruct,
   ...args:
-    | [ApplyToDBXToolsProjectsOptions, ...OneOrMany<(project: DBXToolsProject) => void>]
-    | OneOrMany<(project: DBXToolsProject) => void>
+    | [ApplyToDBXToolsProjectsOptions, ...OneOrMany<(project: DBXToolsJavaScriptProject) => void>]
+    | OneOrMany<(project: DBXToolsJavaScriptProject) => void>
 ): void;
 
 export function applyToProjects(
@@ -71,7 +84,7 @@ export function applyToProjects<P extends Project>(
   const callbacks = (hasOptions ? rest : args) as OneOrMany<(project: Project) => void>;
   let predicate = projectPredicate.isProject();
   if (!options?.includeNonDBXToolsProjects) {
-    predicate = predicate.and(projectPredicate.isDBXToolsProject());
+    predicate = predicate.and(projectPredicate.isDBXToolsJavaScriptProject());
   }
   if (!options?.includeRoots) predicate = predicate.and((project) => project.parent != null);
   if (options?.identifierPackageName) {

package/src/publish.ts

@@ -29,7 +29,7 @@
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
-import { isDBXToolsProject } from "./project-predicate.ts";
+import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 
 /** Directory `tsc` emits into, and the root of every published entry point. */
@@ -63,7 +63,7 @@ export const COMPILED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
  */
 export function publishesCompiled(pkg: javascript.NodeProject): boolean {
   if (!(pkg instanceof typescript.TypeScriptProject) || !pkg.parent) return false;
-  return isDBXToolsProject()(pkg) && !pkg.dbxToolsConfig.tags.includes("ui");
+  return isDBXToolsJavaScriptProject()(pkg) && !pkg.dbxToolsConfig.tags.includes("ui");
 }
 
 /** The `./lib/...` stem of a source path, or `undefined` if it is not TypeScript. */