@dbx-tools/projen 0.9.31 → 0.9.36

package/src/project-predicate.ts

@@ -9,9 +9,8 @@ import {
 } from "@dbx-tools/shared-core";
 import { IConstruct } from "constructs";
 import { Project } from "projen";
-import { project } from "..";
 import { toPosix } from "./packages.ts";
-import type { DBXToolsJavaScriptProject } from "./project-js.ts";
+import { identifier, type DBXToolsJavaScriptProject } from "./project-js.ts";
 import type { DBXToolsProject } from "./project.ts";
 
 /**
@@ -77,7 +76,7 @@ export function hasIdentifierPackageName(
 ): Predicate<IConstruct, Project> {
   const matchers = projectMatchers(...patterns);
   return isProject().and((p) => {
-    const packageName = project.identifier(p).packageName;
+    const packageName = identifier(p).packageName;
     return matchers.every((matcher) => matcher(packageName));
   });
 }
@@ -88,7 +87,7 @@ export function hasIdentifierName(
 ): Predicate<IConstruct, Project> {
   const matchers = projectMatchers(...patterns);
   return isProject().and((p) => {
-    const name = project.identifier(p).name;
+    const name = identifier(p).name;
     return matchers.every((matcher) => matcher(name));
   });
 }
@@ -99,7 +98,7 @@ export function hasIdentifierScope(
 ): Predicate<IConstruct, Project> {
   const matchers = projectMatchers(...patterns);
   return isProject().and((p) => {
-    const scope = project.identifier(p).scope;
+    const scope = identifier(p).scope;
     return scope && matchers.every((matcher) => matcher(scope));
   });
 }

package/src/project-py.ts

@@ -1,19 +1,18 @@
 /** Reusable uv workspace generation for Python packages hosted in a projen tree. */
 import * as projectUtils from "@dbx-tools/core/project-utils";
-import { stringUtils } from "@dbx-tools/shared-core";
-import { Component, License, TextFile, type Project, javascript, python, vscode } from "projen";
+import { stringUtils, type OneOrMany } from "@dbx-tools/shared-core";
+import { Component, License, TextFile, type Project, javascript, python } from "projen";
 import { JobPermission } from "projen/lib/github/workflows-model";
-import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
+import { BUN_VERSION } from "./bun-workflow.ts";
 import { DBX_TOOLS_LICENSE, projectRepositoryUrl } from "./project-js.ts";
 import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
-import { hasWorkspaceNodePackage } from "./python-node-bindings.ts";
-import { PythonNodeBundle, type PythonNodeBindingsOptions } from "./python-node-bundle.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
+import { PythonNodeBundle, type PythonNodeBindingsOptions } from "./python-node-bundle.ts";
 import { RELEASE_VERSION, releaseSourceSteps } from "./release-context.ts";
 import {
   refreshReleaseDocsDependencies,
+  releaseCondition,
   releaseTagPattern,
-  releasePublishCondition,
   tryReleaseWorkflow,
   uvSetupStep,
 } from "./release.ts";
@@ -38,12 +37,10 @@ export interface PythonPackageOptions extends DBXToolsProjectOptions {
   /** Workspace package directories rendered as standalone Git dependencies. */
   readonly internalDependencies?: readonly string[];
   readonly scripts?: Readonly<Record<string, string>>;
-  /** Build-time Node package embedded through PythonMonkey. */
-  readonly nodeBindings?: PythonNodeBindingsOptions;
+  /** One or more build-time Node packages embedded through PythonMonkey. */
+  readonly nodeBindings?: OneOrMany<PythonNodeBindingsOptions>;
   /** Generated source files excluded from strict static analysis. Package-relative. */
   readonly generatedSources?: readonly string[];
-  /** Trusted publisher used outside the standard Python release workflow. */
-  readonly trustedPublisher?: PythonTrustedPublisherOptions;
 }
 
 interface ResolvedPythonPackageOptions extends PythonPackageOptions {
@@ -51,12 +48,6 @@ interface ResolvedPythonPackageOptions extends PythonPackageOptions {
   readonly module: string;
 }
 
-/** GitHub Actions publisher for a Python package released by another workflow. */
-export interface PythonTrustedPublisherOptions {
-  readonly environment: string;
-  readonly artifacts?: string;
-}
-
 /** Options for one projen-native Python workspace member. */
 export interface DBXToolsPythonProjectOptions extends DBXToolsProjectOptions {
   readonly parent: Project;
@@ -78,7 +69,6 @@ interface PythonPublication {
   readonly directory: string;
   readonly distribution: string;
   readonly environment: string;
-  readonly artifacts?: string;
   readonly dependencies?: readonly string[];
 }
 
@@ -117,32 +107,11 @@ export function pythonPackagePath(repository: PythonRepositoryOptions, directory
   return `${repository.root ?? "packages/py"}/${directory}`;
 }
 
-/** PEP 508 dependency pointing at a sibling package in a Git repository. */
-export function pythonGitDependency(
-  repository: PythonRepositoryOptions,
-  name: string,
-  directory: string,
-): string {
-  return `${name} @ git+${repository.url}@${repository.ref ?? "main"}#subdirectory=${pythonPackagePath(repository, directory)}`;
-}
-
 /** Derive a dotted Python module from an npm-style scope and package directory. */
 export function pythonModuleName(scope: string, directory: string): string {
   return [scope, ...directory.split("/")].map((part) => part.replaceAll("-", "_")).join(".");
 }
 
-/** Published requirement for one internal Python dependency. */
-export function pythonReleaseRequirement(version: string, exact = false): string {
-  if (exact) return `==${version}`;
-  const [major, minor] = version.split(".").map(Number);
-  const upper = major === 0 ? `0.${minor + 1}.0` : `${major + 1}.0.0`;
-  return `>=${version},<${upper}`;
-}
-
-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;
@@ -151,6 +120,7 @@ export class DBXToolsPythonProject extends python.PythonProject implements DBXTo
 
   constructor(options: DBXToolsPythonProjectOptions) {
     const pkg = options.package;
+    const nodeBindings = pythonNodeBindings(pkg);
     super({
       parent: options.parent,
       outdir: pythonPackagePath(options.repository, pkg.directory),
@@ -182,6 +152,7 @@ export class DBXToolsPythonProject extends python.PythonProject implements DBXTo
           licenseFiles: ["LICENSE"],
           requiresPython: options.requiresPython,
           dependencies: [...(pkg.dependencies ?? [])],
+          scripts: pkg.scripts,
           urls: {
             Source: `${options.repository.url.replace(/\.git$/, "")}/tree/${options.repository.ref}/${pythonPackagePath(options.repository, pkg.directory)}`,
           },
@@ -193,8 +164,7 @@ export class DBXToolsPythonProject extends python.PythonProject implements DBXTo
         uv: {
           buildBackend: {
             moduleName: pkg.module,
-            moduleRoot:
-              pkg.moduleRoot ?? (pkg.nodeBindings?.layout === "package" ? "generated-src" : "src"),
+            moduleRoot: pkg.moduleRoot ?? "src",
             namespace: true,
           },
         },
@@ -206,29 +176,16 @@ export class DBXToolsPythonProject extends python.PythonProject implements DBXTo
       throw new Error(`Expected uv packaging for ${pkg.name}`);
     }
     this.uv = this.packagingManager;
+    this.tasks.removeTask("publish");
+    this.tasks.removeTask("publish:test");
     this.uv.file.addDeletionOverride("project.authors");
     this.uv.file.addDeletionOverride("dependency-groups");
-    if (pkg.scripts) {
-      this.uv.file.addOverride("project.scripts", pkg.scripts);
-    }
-    if (pkg.nodeBindings) {
-      this.uv.file.addOverride("tool.dbx_tools.node_bindings", {
-        package: pkg.nodeBindings.package,
-        ...(pkg.nodeBindings.entrypoint ? { entrypoint: pkg.nodeBindings.entrypoint } : {}),
-        ...(pkg.nodeBindings.layout ? { layout: pkg.nodeBindings.layout } : {}),
-        ...(pkg.nodeBindings.private ? { private: true } : {}),
-        ...(pkg.nodeBindings.shimRoot ? { shim_root: pkg.nodeBindings.shimRoot } : {}),
-        ...(pkg.nodeBindings.functionOverrides?.length
-          ? {
-              function_overrides: pkg.nodeBindings.functionOverrides.map((override) => ({
-                module: override.module,
-                export: override.export,
-                handler: override.handler,
-                ...(override.handlerExport ? { handler_export: override.handlerExport } : {}),
-              })),
-            }
-          : {}),
-      });
+    if (nodeBindings.length > 0) {
+      const rendered = nodeBindings.map(renderPythonNodeBindings);
+      this.uv.file.addOverride(
+        "tool.dbx_tools.node_bindings",
+        rendered.length === 1 ? rendered[0] : rendered,
+      );
     }
     this.uv.file.readonly = true;
 
@@ -286,7 +243,7 @@ export class DBXToolsPythonWorkspace extends Component {
               `Python package ${pkg.directory} references unknown internal package ${directory}`,
             );
           }
-          return pythonGitDependency(this.repository, dependency.name, dependency.directory);
+          return dependency.name;
         }),
       ],
     }));
@@ -301,53 +258,17 @@ export class DBXToolsPythonWorkspace extends Component {
           package: pkg,
           repository: this.repository,
           requiresPython: this.requiresPython,
-          version: isDBXToolsJavaScriptProject()(project)
-            ? project.releaseCatalog.versionForRegistration(
-                "python",
-                pkg.name,
-                pythonPackagePath(this.repository, pkg.directory),
-              )
-            : this.version,
+          version: this.version,
         }),
     );
     for (const pkg of this.packages) {
-      if (!pkg.packageOptions.nodeBindings) continue;
+      const bindings = pythonNodeBindings(pkg.packageOptions);
+      if (bindings.length === 0) continue;
       new PythonNodeBundle(project, {
         name: pkg.packageOptions.directory,
         projectDirectory: pythonPackagePath(this.repository, pkg.packageOptions.directory),
-        watch: hasWorkspaceNodePackage(project, pkg.packageOptions.nodeBindings.package),
       });
     }
-    if (isDBXToolsJavaScriptProject()(project)) {
-      for (const pkg of this.packages) {
-        project.releaseCatalog.registerProject(pkg, {
-          language: "python",
-          identity: pkg.packageOptions.name,
-          sourcePaths: [`${pythonPackagePath(this.repository, pkg.packageOptions.directory)}/src`],
-          dependencies: (pkg.packageOptions.internalDependencies ?? []).map((directory) => {
-            const dependency = packagesByDirectory.get(directory);
-            if (!dependency) {
-              throw new Error(
-                `Python package ${pkg.packageOptions.directory} references unknown internal package ${directory}`,
-              );
-            }
-            const version = project.releaseCatalog.versionForRegistration(
-              "python",
-              dependency.name,
-              pythonPackagePath(this.repository, dependency.directory),
-            );
-            return {
-              target: dependency.name,
-              kind: "runtime" as const,
-              requirement: pythonReleaseRequirement(version),
-              propagation: "outside-range" as const,
-              publishOrder: true,
-              internal: true,
-            };
-          }),
-        });
-      }
-    }
     for (const pkg of this.packages) {
       const pyproject = `/${pythonPackagePath(this.repository, pkg.packageOptions.directory)}/pyproject.toml`;
       project.gitignore.include(pyproject);
@@ -370,7 +291,7 @@ export class DBXToolsPythonWorkspace extends Component {
 
     const interpreterPath = options.interpreterPath ?? "${workspaceFolder}/.venv/bin/python";
     if (interpreterPath !== false) {
-      projectVscode(project)?.settings.addSetting("python.defaultInterpreterPath", interpreterPath);
+      project.vscode?.settings.addSetting("python.defaultInterpreterPath", interpreterPath);
     }
 
     if (options.release && this.packages.length > 0) {
@@ -383,11 +304,6 @@ export class DBXToolsPythonWorkspace extends Component {
     return pythonPackagePath(this.repository, directory);
   }
 
-  /** PEP 508 dependency pointing at a sibling package in the configured repository. */
-  gitDependency(name: string, directory: string): string {
-    return pythonGitDependency(this.repository, name, directory);
-  }
-
   private emitWorkspace(
     project: javascript.NodeProject,
     options: Omit<DBXToolsPythonWorkspaceOptions, "packages"> & {
@@ -490,7 +406,7 @@ export class DBXToolsPythonWorkspace extends Component {
         (dependency) => `publish-pypi-${dependency}`,
       );
       workflow.addJob(`publish-pypi-${publication.directory}`, {
-        if: releasePublishCondition("python", [
+        if: releaseCondition([
           "needs.verify-context.result == 'success'",
           ...dependencyJobs.map((job) => `needs['${job}'].result == 'success'`),
         ]),
@@ -507,12 +423,8 @@ export class DBXToolsPythonWorkspace extends Component {
         env: { BUN_VERSION },
         steps: [
           ...releaseSourceSteps(),
-          ...bunCacheRestoreSteps(project, {
-            ignorePaths: project.workflowCacheIgnorePaths,
-          }),
+          ...project.renderWorkflowSetup({ mutable: false }),
           uvSetupStep(),
-          { name: "Install release helpers", run: "bun install --frozen-lockfile" },
-          bunCacheSaveStep(),
           {
             name: `Build ${publication.distribution} distributions`,
             env: { RELEASE_VERSION },
@@ -547,31 +459,12 @@ export class DBXToolsPythonWorkspace extends Component {
     }));
   }
 
-  private trustedPublisherPublications(
-    options: PythonReleaseOptions,
-  ): readonly PythonPublication[] {
-    const standard = new Map(
-      this.publications(options).map((publication) => [publication.distribution, publication]),
-    );
-    for (const pkg of this.packages) {
-      const publisher = pkg.packageOptions.trustedPublisher;
-      if (!publisher || standard.has(pkg.packageOptions.name)) continue;
-      standard.set(pkg.packageOptions.name, {
-        directory: pkg.packageOptions.directory,
-        distribution: pkg.packageOptions.name,
-        environment: publisher.environment,
-        artifacts: publisher.artifacts,
-      });
-    }
-    return [...standard.values()];
-  }
-
   private addTrustedPublisherInstructionsTask(
     project: javascript.NodeProject,
     options: PythonReleaseOptions,
   ): void {
     const repository = this.githubRepository();
-    const publications = this.trustedPublisherPublications(options);
+    const publications = this.publications(options);
     const releaseTag =
       isDBXToolsJavaScriptProject()(project) && tryReleaseWorkflow(project)
         ? releaseTagPattern(project)
@@ -641,7 +534,6 @@ export class DBXToolsPythonWorkspace extends Component {
           "- Workflow name: release.yml",
           `- Environment name: ${publication.environment}`,
           `- GitHub environment tag: ${releaseTag}`,
-          ...(publication.artifacts ? [`- Artifacts: ${publication.artifacts}`] : []),
           "",
         ];
       }),
@@ -689,16 +581,35 @@ export class DBXToolsPythonWorkspace extends Component {
   }
 }
 
-function pythonNodeGeneratedSources(pkg: ResolvedPythonPackageOptions): string[] {
+function pythonNodeBindings(
+  pkg: Pick<PythonPackageOptions, "nodeBindings">,
+): readonly PythonNodeBindingsOptions[] {
   if (!pkg.nodeBindings) return [];
-  const moduleRoot =
-    pkg.moduleRoot ?? (pkg.nodeBindings.layout === "package" ? "generated-src" : "src");
+  return Array.isArray(pkg.nodeBindings) ? pkg.nodeBindings : [pkg.nodeBindings];
+}
+
+function renderPythonNodeBindings(binding: PythonNodeBindingsOptions): Record<string, unknown> {
+  return {
+    package: binding.package,
+    ...(binding.entrypoint ? { entrypoint: binding.entrypoint } : {}),
+    ...(binding.modules?.length ? { modules: binding.modules } : {}),
+    ...(binding.functionOverrides?.length
+      ? {
+          function_overrides: binding.functionOverrides.map((override) => ({
+            module: override.module,
+            export: override.export,
+            handler: override.handler,
+            ...(override.handlerExport ? { handler_export: override.handlerExport } : {}),
+          })),
+        }
+      : {}),
+  };
+}
+
+function pythonNodeGeneratedSources(pkg: ResolvedPythonPackageOptions): string[] {
+  const bindings = pythonNodeBindings(pkg);
+  if (bindings.length === 0) return [];
+  const moduleRoot = pkg.moduleRoot ?? "src";
   const moduleDirectory = `${moduleRoot}/${pkg.module.replaceAll(".", "/")}`;
-  const generatedDirectory =
-    pkg.nodeBindings.layout === "package" ? moduleDirectory : `${moduleDirectory}/_generated`;
-  return [
-    `${generatedDirectory}/_runtime.js`,
-    `${generatedDirectory}/node_bindings.py`,
-    `${generatedDirectory}/__init__.py`,
-  ];
+  return [`${moduleDirectory}/_generated/**`];
 }

package/src/publish.ts

@@ -29,8 +29,8 @@
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
+import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project-js.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. */
 export const COMPILED_DIR = "lib";

package/src/python-node-bindings.ts

@@ -1,10 +1,12 @@
 /** Shared pyproject-backed configuration for PythonMonkey Node bindings. */
-import { readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { object } from "@dbx-tools/shared-core";
-import type { Project } from "projen";
+import { readFileSync, rmSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { find } from "@dbx-tools/path";
+import { object, stringUtils } from "@dbx-tools/shared-core";
 import { parse } from "smol-toml";
-import { workspaceDependencyDirectories } from "./packages.ts";
+import { runTaskCommand } from "./_task-command.ts";
+import { resolveRepoRoot, workspaceDependencyDirectories } from "./packages.ts";
 
 export interface ResolvedPythonNodeFunctionOverride {
   readonly handlerExport: string;
@@ -14,82 +16,142 @@ export interface ResolvedPythonNodeFunctionOverride {
 }
 
 export interface ResolvedPythonNodeBindings {
-  readonly bindingsPackageOutput: string;
-  readonly bindingsOutput: string;
+  readonly bindingDirectory: string;
+  readonly bindingName: string;
   readonly functionOverrides: readonly ResolvedPythonNodeFunctionOverride[];
   readonly entrypoint: string;
   readonly moduleDirectory: string;
-  readonly layout: "package" | "submodule";
-  readonly private: boolean;
+  readonly modules: readonly string[];
   readonly package: string;
   readonly project: string;
   readonly projectDirectory: string;
   readonly pyproject: string;
   readonly runtimeOutput: string;
-  readonly shimRoot?: string;
   readonly workspaceDirectories: readonly string[];
 }
 
-/** Resolve one Python package's Node binding configuration and conventional outputs. */
+/** Standard PythonMonkey host adapters shipped with the binding generator. */
+export const PYTHON_NODE_SHIM_ROOT = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../shims/python-node",
+);
+
+/** Regenerate every pyproject-configured Node binding in a repository. */
+export function generatePythonNodeBindings(projectRoot: string = resolveRepoRoot()): void {
+  const task = resolve(dirname(fileURLToPath(import.meta.url)), "../tasks/python-node-bindings.ts");
+  const configuredProjects = pythonNodeBindingProjects(projectRoot);
+  const directories = new Set<string>();
+  for (const project of configuredProjects) {
+    for (const config of resolvePythonNodeBindings(projectRoot, project)) {
+      directories.add(relative(projectRoot, join(config.moduleDirectory, "_generated", "node")));
+    }
+  }
+  for (const directory of existingBindingDirectories(projectRoot)) {
+    if (!directories.has(directory)) {
+      rmSync(resolve(projectRoot, directory), { recursive: true, force: true });
+    }
+  }
+  for (const project of configuredProjects) {
+    runTaskCommand(projectRoot, "bun", [task, "--root", projectRoot, "--project", project]);
+  }
+}
+
+function pythonNodeBindingProjects(projectRoot: string): string[] {
+  return [
+    ...find
+      .findFiles("**/pyproject.toml", { cwd: projectRoot })
+      .filter((file) => {
+        const manifest = parse(readFileSync(resolve(projectRoot, file), "utf8")) as {
+          tool?: { dbx_tools?: { node_bindings?: unknown } };
+        };
+        return manifest.tool?.dbx_tools?.node_bindings !== undefined;
+      })
+      .map((file) => dirname(file)),
+  ].sort();
+}
+
+function existingBindingDirectories(projectRoot: string): string[] {
+  const directories = new Set<string>();
+  for (const file of find.findFiles("**/_generated/node/**/*", {
+    cwd: projectRoot,
+    ignore: () => false,
+  })) {
+    const segments = file.split("/");
+    const generated = segments.lastIndexOf("_generated");
+    if (generated >= 0 && segments[generated + 1] === "node") {
+      directories.add(segments.slice(0, generated + 2).join("/"));
+    }
+  }
+  return [...directories].sort();
+}
+
+/** Resolve one Python package's Node binding configurations and conventional outputs. */
 export function resolvePythonNodeBindings(
   root: string,
   project: string,
-): ResolvedPythonNodeBindings {
+): ResolvedPythonNodeBindings[] {
   const projectDirectory = resolve(root, project);
   const pyproject = resolve(projectDirectory, "pyproject.toml");
   const manifest = record(parse(readFileSync(pyproject, "utf8")), "pyproject.toml");
   const tool = record(manifest.tool, "tool");
   const dbxTools = record(tool.dbx_tools, "tool.dbx_tools");
-  const bindings = record(dbxTools.node_bindings, "tool.dbx_tools.node_bindings");
+  const configuredBindings = Array.isArray(dbxTools.node_bindings)
+    ? dbxTools.node_bindings
+    : [dbxTools.node_bindings];
+  if (configuredBindings.length === 0) {
+    throw new Error("tool.dbx_tools.node_bindings must contain at least one table");
+  }
   const uv = record(tool.uv, "tool.uv");
   const backend = record(uv["build-backend"], "tool.uv.build-backend");
-  const packageName = requiredString(bindings.package, "tool.dbx_tools.node_bindings.package");
-  const entrypoint =
-    optionalString(bindings.entrypoint, "tool.dbx_tools.node_bindings.entrypoint") ?? packageName;
-  const layout = nodeBindingsLayout(bindings.layout);
   const moduleName = requiredString(backend["module-name"], "tool.uv.build-backend.module-name");
   const moduleRoot = requiredString(backend["module-root"], "tool.uv.build-backend.module-root");
-  const configuredOverrides = bindings.function_overrides ?? [];
-  if (!Array.isArray(configuredOverrides)) {
-    throw new Error("tool.dbx_tools.node_bindings.function_overrides must be an array");
-  }
   const moduleDirectory = resolve(projectDirectory, moduleRoot, ...moduleName.split("."));
-  const generatedDirectory =
-    layout === "package" ? moduleDirectory : join(moduleDirectory, "_generated");
-  const shimRoot = optionalString(bindings.shim_root, "tool.dbx_tools.node_bindings.shim_root");
-  return {
-    project,
-    projectDirectory,
-    pyproject,
-    package: packageName,
-    entrypoint,
-    layout,
-    private: optionalBoolean(bindings.private, "tool.dbx_tools.node_bindings.private") ?? false,
-    moduleDirectory,
-    runtimeOutput: join(generatedDirectory, "_runtime.js"),
-    bindingsOutput: join(generatedDirectory, "node_bindings.py"),
-    bindingsPackageOutput: join(generatedDirectory, "__init__.py"),
-    ...(shimRoot ? { shimRoot: resolve(root, shimRoot) } : {}),
-    functionOverrides: configuredOverrides.map((candidate, index) => {
-      const path = `tool.dbx_tools.node_bindings.function_overrides[${index}]`;
-      const override = record(candidate, path);
-      const targetExport = requiredString(override.export, `${path}.export`);
-      return {
-        targetModule: requiredString(override.module, `${path}.module`),
-        targetExport,
-        handlerFile: resolve(root, requiredString(override.handler, `${path}.handler`)),
-        handlerExport:
-          optionalString(override.handler_export, `${path}.handler_export`) ?? targetExport,
-      };
-    }),
-    workspaceDirectories: workspaceDependencyDirectories(packageName, root),
-  };
-}
-
-function nodeBindingsLayout(value: unknown): "package" | "submodule" {
-  if (value === undefined) return "submodule";
-  if (value === "package" || value === "submodule") return value;
-  throw new Error("tool.dbx_tools.node_bindings.layout must be package or submodule");
+  const configs = configuredBindings.map((candidate, bindingIndex) => {
+    const bindingPath = Array.isArray(dbxTools.node_bindings)
+      ? `tool.dbx_tools.node_bindings[${bindingIndex}]`
+      : "tool.dbx_tools.node_bindings";
+    const bindings = record(candidate, bindingPath);
+    const packageName = requiredString(bindings.package, `${bindingPath}.package`);
+    const entrypoint =
+      optionalString(bindings.entrypoint, `${bindingPath}.entrypoint`) ?? packageName;
+    const modules = optionalStrings(bindings.modules, `${bindingPath}.modules`);
+    if (bindings.layout !== undefined || bindings.private !== undefined) {
+      throw new Error(`${bindingPath} no longer supports layout or private`);
+    }
+    const configuredOverrides = bindings.function_overrides ?? [];
+    if (!Array.isArray(configuredOverrides)) {
+      throw new Error(`${bindingPath}.function_overrides must be an array`);
+    }
+    const bindingName = nodePackageName(packageName);
+    const bindingDirectory = join(moduleDirectory, "_generated", "node", bindingName);
+    return {
+      project,
+      projectDirectory,
+      pyproject,
+      package: packageName,
+      entrypoint,
+      modules,
+      bindingName,
+      bindingDirectory,
+      moduleDirectory,
+      runtimeOutput: join(moduleDirectory, "_generated", "node", "_runtime.js"),
+      functionOverrides: configuredOverrides.map((overrideCandidate, overrideIndex) => {
+        const path = `${bindingPath}.function_overrides[${overrideIndex}]`;
+        const override = record(overrideCandidate, path);
+        const targetExport = requiredString(override.export, `${path}.export`);
+        return {
+          targetModule: requiredString(override.module, `${path}.module`),
+          targetExport,
+          handlerFile: resolve(root, requiredString(override.handler, `${path}.handler`)),
+          handlerExport:
+            optionalString(override.handler_export, `${path}.handler_export`) ?? targetExport,
+        };
+      }),
+      workspaceDirectories: workspaceDependencyDirectories(packageName, root),
+    };
+  });
+  validateBindings(configs);
+  return configs;
 }
 
 /** All paths that can change a workspace-backed generated Node runtime. */
@@ -100,16 +162,26 @@ export function pythonNodeBindingWatchInputs(config: ResolvedPythonNodeBindings)
   return [
     config.pyproject,
     ...config.workspaceDirectories,
-    ...(config.shimRoot ? [config.shimRoot] : []),
+    PYTHON_NODE_SHIM_ROOT,
     ...config.functionOverrides.map(({ handlerFile }) => handlerFile),
   ];
 }
 
-/** Whether a Projen tree already contains the configured Node package. */
-export function hasWorkspaceNodePackage(project: Project, packageName: string): boolean {
-  return (
-    project.name === packageName || project.subprojects.some((child) => child.name === packageName)
-  );
+function validateBindings(configs: readonly ResolvedPythonNodeBindings[]): void {
+  const names = configs.map(({ bindingName }) => bindingName);
+  if (new Set(names).size !== names.length) {
+    throw new Error("tool.dbx_tools.node_bindings package names must be unique");
+  }
+  for (const config of configs) {
+    if (new Set(config.modules).size !== config.modules.length) {
+      throw new Error(`${config.package} Node binding module names must be unique`);
+    }
+  }
+}
+
+function nodePackageName(packageName: string): string {
+  const unscoped = packageName.split("/").at(-1) ?? packageName;
+  return stringUtils.toIdentifierWithOptions({ delimiter: "_" }, unscoped);
 }
 
 function record(value: unknown, path: string): Record<string, unknown> {
@@ -131,8 +203,9 @@ function optionalString(value: unknown, path: string): string | undefined {
   return value.trim();
 }
 
-function optionalBoolean(value: unknown, path: string): boolean | undefined {
-  if (value === undefined) return undefined;
-  if (typeof value !== "boolean") throw new Error(`${path} must be a boolean`);
-  return value;
+function optionalStrings(value: unknown, path: string): string[] {
+  if (value === undefined) return [];
+  if (typeof value === "string") return [requiredString(value, path)];
+  if (!Array.isArray(value)) throw new Error(`${path} must be a string or array`);
+  return value.map((candidate, index) => requiredString(candidate, `${path}[${index}]`));
 }