@dbx-tools/projen 0.9.21 → 0.9.29

package/README.md

@@ -45,8 +45,12 @@ instead of creating a second owner. An explicit `outdir` is the workspace root
 for naming, Git metadata, package discovery, codegen, and barrels even when the
 calling process has a different current directory.
 
-The unified dbx-tools release surface is enabled by default. Set
-`releaseMode: "disabled"` to omit its workflow and bump/version/release tasks.
+The unified dbx-tools release surface is enabled by default. `bump` increments
+the local `VERSION` and synchronizes generated version surfaces. `release`
+commits that bump on the configured release branch, pushes it, and pushes an
+annotated version tag. The generated GitHub workflow runs only for matching tag
+pushes and publishes directly from that immutable commit. Set
+`releaseMode: "disabled"` to omit the workflow and bump/version/release tasks.
 The inherited Projen `release` and `releaseTrigger` options are intentionally
 not part of this engine's public options because they create a competing release
 workflow.
@@ -58,13 +62,8 @@ Repository policy stays in the consuming `.projenrc.ts`:
   artifact upload, and deployment without naming a docs script or output tree.
 - `releasePythonRoot` passes the actual Python package root to local release
   preparation. Omit it when the workspace has no standard Python packages.
-- `releaseValidationTasks` names repository tasks that must pass in the release
-  branch before Cargo tests, compilation, local publication, or approval.
-  Use it for repository-specific guards that also run in release CI.
-- `releaseSummary` controls versioned release notes. It defaults to Cursor,
-  Codex, Claude fallback order and writes a deterministic Git summary when every
-  configured provider is unavailable; pass `false` to disable or provide a
-  `providers` array to choose the order/subset.
+- `releaseValidationTasks` names repository tasks that must pass in tag CI
+  before release artifacts are built and published.
 - `pullRequestTitlePolicy` configures semantic title types and scope policy.
   Omit it or pass `false` to disable the title job.
 - `workflowCacheIgnorePaths` excludes generated output trees that may contain
@@ -124,178 +123,70 @@ without repeating repository coordinates. Pass `repository`, `name`, or
 VS Code component; dbx-tools reuses it rather than constructing a second
 `.vscode/settings.json` owner.
 
-## Add A Rust Workspace
-
-`DBXToolsRustWorkspace` discovers every source-bearing folder under its
-configurable `root` (default `packages/rs`), generates its Cargo manifest, and
-derives the crate name and repository from the parent project. A crate containing
-`uniffi::setup_scaffolding!()`
-automatically wires matching public Node and Python binding packages using the
-`<name>-rs` folder suffix. Node packages are named `@<scope>/<name>-rs`;
-Python distributions are named `<scope>-<name>-rs` and export generated values
-from `<scope>.<name>_rs`. Binding packages are always dedicated and
-never merge generated code into handwritten Node or Python packages.
-Repository-specific dependencies and features remain
-declarative options in `.projenrc.ts`; generated bindings are built separately
-from projen synthesis. Target-independent Node binding TypeScript is committed
-and remains generated/read-only, while native libraries stay ignored. Node
-facades compile to `lib/` and publish JavaScript entry points that plain Node
-can load from `node_modules`. A complete `bindings.ts` / `_bindings.ts` /
-`_bindings-ffi.ts` triplet is exported directly from the generated package
-barrel. Python keeps `bindings.py` as the generated implementation and leaves
-`__init__.py` as its generated package-root export. Node generation fails when
-direct binding names conflict.
-Do not create a `nodeExports` binding subpath or a handwritten type facade.
-
-Each discovered member is a native Projen `Project`, exposed as
-`DBXToolsRustProject`. The same class also owns standalone Cargo projects with
-the flat object-style options used by the Node and Python project classes:
+### Bundle Node Code For PythonMonkey
 
-```ts
-import { project } from "@dbx-tools/projen";
+Add `nodeBindings` to any `DBXToolsPythonWorkspace` package to generate a
+committed CommonJS runtime and async Python wrappers from a public Node package.
+The configuration is written to `pyproject.toml`, so the generation task also
+works in consuming repositories after `@dbx-tools/projen` is installed.
 
-new project.DBXToolsRustProject({
-  name: "my-apps-core",
-  outdir: "native/core",
-  version: "0.1.0",
-  description: "Shared native runtime",
-  repository: "https://github.com/example/my-apps",
+```ts
+new project.DBXToolsPythonWorkspace(root, {
+  root: "packages/py",
+  packages: [
+    {
+      directory: "auth",
+      description: "Python bindings for example auth",
+      nodeBindings: {
+        package: "@example/auth",
+        layout: "package",
+        private: false,
+        shimRoot: "projen/shims/python-node",
+        functionOverrides: [
+          {
+            module: "@example/core/file-lock",
+            export: "acquireFileLock",
+            handler: "projen/shims/python-node/file-lock.ts",
+          },
+        ],
+      },
+    },
+  ],
 });
 ```
 
-The project emits concrete standalone Cargo metadata plus `compile`, `test`,
-`package`, `lint`, `format`, and `format:check` tasks. A nested standalone
-project declares its own empty Cargo workspace so a surrounding repository
-workspace does not absorb it accidentally. The `examples` option emits explicit
-Cargo example targets and `required-features`, so an optional code generator is
-excluded from ordinary workspace tests until its feature is enabled.
-`DBXToolsRustWorkspace` constructs the same class with workspace-owned metadata
-and keeps aggregate binding and release coordination.
-`DBXToolsRustWorkspaceOptions.private` supplies the default Cargo publication
-policy for every discovered crate; a package-level `private` value overrides it.
-Cargo projects use the flat object-style constructor exclusively.
-
-Rust dependencies between binding-enabled workspace crates become Node
-`workspace:*` and Python `internalDependencies` automatically. Python generation
-selects the owning crate and supplies `external_packages` imports. UBRN currently
-emits every linked component; the generation task discards dependency outputs
-and rewrites their imports to the owning package root, including its generated
-`uniffiModule` converter table. It never copies a dependency's records or enums.
-Foreign callback adapters must first be wrapped in an object created by their
-own native library (`createStorageHandle` for auth), because callback registries
-are library-local. Release wheels replace sibling Git requirements with matching
-native-wheel versions, and dependent publishers wait for their dependencies.
-Each crate builds its own `<crate>-uniffi-bindgen` executable so one target row
-has no colliding binary outputs. The executable requires the generated
-`uniffi-bindgen` feature, which enables `uniffi/cli` only in the UniFFI matrix.
-Packaging runs that prebuilt executable.
-Cargo manifests, target config, and UniFFI config are generated from structured
-Projen `TomlFile` objects. Local and release Python generation share one
-dependency-free helper for generator arguments, target-specific executable
-names, generated headers, generated package-root exports, and native-library
-placement.
-
-`sync --watch` runs a focused Rust watcher beside the OpenAPI watcher. Changes
-inside an existing UniFFI crate regenerate that crate and its dependent bindings
-in dependency order; adding or
-removing a crate or `setup_scaffolding!()` marker triggers a full synth. Repos
-without Rust crates start no Rust watcher. When Rust projects are detected,
-Cargo is required and the focused task fails immediately if it is unavailable.
-`rs:bindings` is explicit rather than part of root `pre-compile`, so ordinary
-JavaScript PR builds type-check committed generated bindings without performing
-a host Rust build. Regenerate bindings through the focused watcher or explicit
-task while changing a UniFFI API. Release preparation runs Cargo workspace tests
-without invoking UBRN.
-
-Rust release configuration is generated at `.projen/rust-release.json` from the
-workspace model. The release tasks consume that file directly, so consumers do
-not need a repository-specific helper crate or handwritten target matrix.
-
-The workspace generates one `release.yml` workflow for every ecosystem. The
-root `VERSION` drives every Node, Python, Cargo, native, and GitHub artifact.
-`bun run release` prepares one reviewed PR into `main`; it enables automatic
-merge by default and accepts `--no-approve` for a human-controlled merge.
-
-Release generation writes `release.yml` without scanning for or removing other
-workflow files. Consumers explicitly delete exact workflow files they no longer
-want.
-
-Release preparation uses one checkout. It commits and pushes pending source
-work, switches to `release/v<version>`, increments `VERSION`, synthesizes and
-validates the repository, and opens the release PR. After merge it detaches at
-the exact merge SHA, builds the complete candidate once, optionally publishes
-that candidate to local registries, uploads the same files to a draft GitHub
-Release, and restores the original branch. A failed transaction stores
-uncommitted release-branch state in a `release-resume:<branch>` stash. No Git
-worktree or second production build is involved.
-
-The draft contains `release-manifest.json`, `SHA256SUMS`, every npm archive,
-every Python distribution, every native binding archive, and every Rust binary.
-The manifest records the version, annotated tag, exact Git commit SHA, file size,
-and SHA-256 for each artifact. Publishing the GitHub Release is the production
-promotion event.
-
-`release.yml` runs on `release.published`. Its context job resolves the annotated
-tag, verifies main ancestry, checks out the exact commit, checks `VERSION`, and
-downloads and verifies the approved candidate. npm publishes the approved
-archives directly with the repository `NPM_TOKEN` secret. The job pins npm
-`11.4.2` so token authentication and GitHub provenance do not depend on the npm
-version bundled with the runner's Node release or opt into trusted-publisher
-registry authentication. PyPI
-publishes the approved distributions through trusted-publisher environments.
-Cargo publishes from the verified source checkout with `cargo publish --locked`.
-GitHub-hosted runners do not rebuild native release artifacts.
-
-The workflow accepts stage-specific manual recovery only for an existing
-published tag. npm compares archive identity and content, PyPI uses hash-aware
-existing-file behavior, Cargo checks existing versions, and every stage remains
-bound to the same tag and SHA. Manual runs default to dry-run.
-
-Set a release binary's `cli` package option and the workspace `cliRegistryPath`
-to generate a typed `dbx` command registry from the configured release targets.
-The runtime command uses `@dbx-tools/core` `bin.ensure`; the core installer
-contains no product registry. `releaseExcludeOs` omits a release binary from an
-incompatible target. UniFFI crates still produce every configured target.
-
-Set `LOCAL_CARGO_REGISTRY` to a named Cargo registry such as a loopback
-[Kellnr](https://kellnr.io/) instance and provide `LOCAL_CARGO_TOKEN`. Public
-Cargo crates also publish directly to crates.io
-with `CARGO_REGISTRY_TOKEN`. Override `releaseTargets` only when a consumer has
-additional native runners; ordinary projects inherit the maintained matrix
-automatically. `bun run release` also accepts repeatable `--os` and `--arch`
-selectors; every selected operating system is crossed with every selected
-architecture. Omit both filters to regenerate the complete maintained matrix.
-`DBX_TOOLS_RELEASE_PLATFORMS` can select the generated matrix without repeating
-environment parsing in a consumer.
-
-A manager can rebuild an interrupted candidate from the exact source with
-`bun run release:assets --version <version> --tag <tag> --sha <commit> --upload`.
-Candidate upload is separate from candidate construction, so retries use the
-already-verified files rather than rebuilding them.
-
-Public UniFFI facades are marked with `dbxToolsConfig.uniffi = true` in Node
-manifests and `[tool.dbx_tools.config] uniffi = true` in Python manifests. The
-approved npm archives are dependency-ordered and published directly with the
-repository `NPM_TOKEN` secret with GitHub Actions provenance. Local Verdaccio
-publication does not enable provenance. Python publishes the exact approved wheels and source distributions
-through package-specific PyPI trusted-publisher environments; binding publishers
-wait for their dependencies. Trusted-publisher instructions name `release.yml`
-and the `v*` deployment tag policy. Cargo publication checks the approved source
-commit and skips an already-published version during recovery.
-The docs jobs generate README and TypeScript API content and deploy GitHub Pages
-from the same workflow. When a conventional Node binding path already belongs
-to a root subproject, Rust mapping reuses that project and adds binding
-dependencies and metadata to its existing manifest.
-
-The workspace npm publisher owns compilation for normal release publication. It
-selects every publishable package with compiled entry points, invokes one
-root-level filtered compile, then packs each package exactly once with lifecycle
-scripts disabled. It validates the archive identity, configured access,
-integrity, and repository metadata before publishing those same bytes. Local
-release preparation passes `--skip-compile` only after its immediately preceding
-validation compile and verifies every expected output exists before reuse.
-Package `prepack` tasks remain available for standalone publishes without
-multiplying `tsc --build` across the monorepo release flow.
+`layout: "package"` owns the complete Python package under `generated-src`.
+Use the default `layout: "submodule"` to place generated bindings under
+`<module>._generated` beside handwritten source. Generated wrappers convert
+public function names to `snake_case`, await promises, recursively convert plain
+records and arrays, and proxy returned JavaScript class instances with
+`snake_case` async methods.
+
+Set `private: true` to keep every generated symbol out of the generated
+`__init__.py`. The runtime and `node_bindings.py` remain available for a
+handwritten consuming package to import selectively. The default is `false`.
+
+Every function parameter is resolved through the TypeScript compiler API and
+rendered with its Python-equivalent name and type. Supported record types become
+keyword-only Python dataclasses, nested records become nested dataclasses, and a
+same-named exported companion's `defaults()` method supplies field defaults. A
+trailing optional record can be passed as the dataclass, a dictionary, or direct
+snake-case keyword fields. Generation fails with the property path when a type
+cannot be represented safely in Python.
+
+Return types use the same compiler model. Plain records become generated
+`TypedDict` responses, returned clients and class instances become `Protocol`
+types with typed async methods, and primitives, arrays, maps, promises, and
+optional values retain their corresponding Python annotations.
+
+The workspace creates `<name>:python-runtime`,
+`<name>:python-runtime:check`, and, for workspace Node dependencies,
+`<name>:python-runtime:watch`. The root sync watcher includes the watch task.
+Built-in shims can make ordinary Node imports work under PythonMonkey.
+`functionOverrides` replaces named exports only in the generated runtime, so the
+Node package does not gain Python callbacks or alternate source files. A
+replacement may use a different export name through `handlerExport`; every
+other export continues to come from the original module.
 
 ## Customize Packages With Mixins
 
@@ -484,35 +375,15 @@ list, so a new package is covered without a re-synth. Work from the root:
 | `bun run barrels`              | regenerate the read-only `index.ts` barrels          |
 | `bun run bump`                 | increment `VERSION` and regenerate version surfaces  |
 | `bun run version:check`        | verify every generated version against `VERSION`     |
-| `bun run release`              | validate, open, and automatically merge a release PR |
-| `bun run release --no-approve` | open the release PR without automatic merge          |
-
-`release` commits and pushes pending source work, switches to a release branch,
-increments `VERSION`, synthesizes manifests and registries, runs validation,
-writes the release summary, and opens one PR. After automatic merge it builds
-the candidate from the exact merge SHA, optionally publishes the same candidate
-to local registries, uploads it to a draft GitHub Release, and returns to the
-original branch. Publishing the draft starts registry deployment. Use
-`--no-approve` to leave the PR for manual merge, `--no-validate` to skip
-repository tests/compile, or `--no-local-publish` to skip local registry
-preflight. `VERSION` is the only base used to calculate the next version.
-The repository host and owner are derived from the Git remote. If the GitHub CLI
-has multiple accounts for that host, release preparation selects the first
-authenticated account with write access to the detected repository. Classic
-tokens must include the `workflow` scope so the release PR can update the
-generated workflow.
-
-The GitHub PR workflow runs the explicit `pr:validate` task through Projen's
-public `BuildWorkflow` `buildTask` option. That task runs synth plus the
-workspace TypeScript compile rather than the complete root build. Release
-preparation has already run Rust tests, workspace type-checking, and local
-package preflight before opening the PR. JavaScript behavior tests remain an
-explicit developer task.
-
-The generated workflow publishes the complete public workspace after the draft
-GitHub Release is published. Cargo, PyPI, npm, and docs share the verified tag,
-commit, manifest, and checksums. Documentation deployment runs only in this
-promotion workflow.
+| `bun run release`              | run the configured release transaction                |
+
+Run exactly `bun run release` from a clean `main`. It calls the existing `bump`
+task, commits the generated version changes, pushes `main`, and pushes the
+matching annotated `vX.Y.Z` tag. Pass `--no-bump` only to release an existing
+synchronized local bump. The tag workflow verifies that the tag points at the
+exact `origin/main` commit, publishes npm and PyPI directly from that checkout,
+then builds and deploys documentation. Local npm and Python registry publication
+remains available through the direct local publication tooling.
 
 Members intentionally keep only the tasks that something OTHER than a human
 invokes, so there is no second place to run the same thing:
@@ -541,7 +412,6 @@ from the root instead.
 ## Versioning
 
 `VERSION` is the language-neutral version seam. Real package manifests remain
-Projen-owned and reproduce it exactly across JavaScript, Python, Rust, UniFFI
-bindings, native package metadata, and runtime binary registries. Package and
+Projen-owned and reproduce it exactly across JavaScript and Python packages. Package and
 artifact discovery still supplies publication order and target inventory; it
 does not create independent version ownership.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.21";
+export const PACKAGE_VERSION = "0.9.29";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -21,17 +21,16 @@ export * as project from "./src/project.ts";
 export * as projectJs from "./src/project-js.ts";
 export * as projectPredicate from "./src/project-predicate.ts";
 export * as projectPy from "./src/project-py.ts";
-export * as projectRs from "./src/project-rs.ts";
 export * as projenVersion from "./src/projen-version.ts";
 export * as publish from "./src/publish.ts";
+export * as pythonNodeBindings from "./src/python-node-bindings.ts";
+export * as pythonNodeBundle from "./src/python-node-bundle.ts";
 export * as release from "./src/release.ts";
 export * as releaseCatalog from "./src/release-catalog.ts";
-export * as releaseDispatch from "./src/release-dispatch.ts";
-export * as releaseGithub from "./src/release-github.ts";
+export * as releaseContext from "./src/release-context.ts";
 export * as scaffold from "./src/scaffold.ts";
 export * as tags from "./src/tags.ts";
 export * as tsconfig from "./src/tsconfig.ts";
-export * as uniffi from "./src/uniffi.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
 export * as workspaceLock from "./src/workspace-lock.ts";
@@ -44,7 +43,7 @@ export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
 export { resolvePkgRoot } from "./src/engine-root.ts";
 export type { HeaderOpts } from "./src/generated.ts";
 export type { ConstructsMixin } from "./src/mixin.ts";
-export type { ModuleStatement, ModuleExport } from "./src/module-exports.ts";
+export type { ModuleStatement, ModuleExport, PublicFunctionExport } from "./src/module-exports.ts";
 export { repoRoot, DEFAULT_PACKAGE_ROOTS, DiscoveredPackage } from "./src/packages.ts";
 export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
@@ -54,22 +53,19 @@ export { PackageIdentifier, DBX_TOOLS_LICENSE, DBXToolsNodeProject, ROOT_INSTALL
 export type { DBXToolsJavaScriptProject, DBXToolsReleaseMode, PullRequestTitlePolicyOptions, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
-export { DBXToolsRustProject, RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, RustOpenApiOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustOpenApiMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
 export { PROJEN_VERSION } from "./src/projen-version.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
+export type { ResolvedPythonNodeFunctionOverride, ResolvedPythonNodeBindings } from "./src/python-node-bindings.ts";
+export { PythonNodeBundle } from "./src/python-node-bundle.ts";
+export type { PythonNodeFunctionOverride, PythonNodeBindingsOptions, PythonNodeBundleOptions } from "./src/python-node-bundle.ts";
 export { DBXToolsRelease } from "./src/release.ts";
-export type { ReleaseStage, ReleaseDocsOptions, ReleaseSummaryOptions, DBXToolsReleaseOptions } from "./src/release.ts";
+export type { ReleaseStage, ReleaseDocsOptions, DBXToolsReleaseOptions } from "./src/release.ts";
 export { DBXToolsReleaseCatalog } from "./src/release-catalog.ts";
 export type { ReleaseProjectLanguage, ReleaseArtifactKind, ReleaseEdgeKind, ReleasePropagation, ReleaseUnitRule, DBXToolsReleaseCatalogOptions, ReleaseDependencyInput, ReleaseProjectRegistration, ExternalReleaseProjectRegistration, ReleaseArtifactRegistration, ReleaseProjectNode, ReleaseArtifact, ReleaseDependencyEdge, ReleaseUnit, ReleaseUnitGraph } from "./src/release-catalog.ts";
-export { RELEASE_TAG, RELEASE_SHA, RELEASE_VERSION, RELEASE_SUMMARY_DIRECTORY, RELEASE_SUMMARY_PROVIDER_NAMES, RELEASE_SUMMARY_FILE } from "./src/release-dispatch.ts";
-export type { ReleaseSummaryProviderName } from "./src/release-dispatch.ts";
-export type { GithubRepositoryIdentity, GithubAuthenticatedAccount, GithubRepositoryPermissions } from "./src/release-github.ts";
+export { RELEASE_TAG, RELEASE_SHA, RELEASE_VERSION } from "./src/release-context.ts";
 export { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS } from "./src/tags.ts";
 export type { PackageTag } from "./src/tags.ts";
 export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
-export { makeDefaultedInterfaceParametersOptional, removeObsoleteInterfaceAliases, addTypeScriptExtensionsToBindingImports, addExplicitInterfaceReexports } from "./src/uniffi.ts";
-export type { TypeScriptBindingModule } from "./src/uniffi.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
 export type { IgnoreGroupOptions, WatchLoopOptions } from "./src/watch.ts";
 export type { WorkspaceMutationLockOptions } from "./src/workspace-lock.ts";

package/package.json

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

package/src/barrels.ts

@@ -16,11 +16,6 @@
  * takes priority. This keeps the barrel auto-generated while letting you add or
  * override individual exports.
  *
- * A UniFFI source triplet (`bindings.ts`, `_bindings.ts`, and
- * `_bindings-ffi.ts`) is one special case: the internal underscore modules stay
- * private, while `bindings.ts` is re-exported directly instead of under a
- * `bindings` namespace. Generation fails when one of those direct binding names
- * conflicts with another top-level package export.
  *
  * Each eligible module becomes `export * as <name> from "./src/x.ts"` (camelCase
  * namespace from its path segments; invalid identifiers suffixed with `Module`),
@@ -121,9 +116,6 @@ const PACKAGE_IDENTIFIER_LINE = `export const ${PACKAGE_IDENTIFIER_EXPORT} = "";
 const PACKAGE_VERSION_LINE = `export const ${PACKAGE_VERSION_EXPORT} = "";`;
 const PACKAGE_IDENTIFIER_LINE_RE = /^export const PACKAGE_IDENTIFIER = .*;$/m;
 const PACKAGE_VERSION_LINE_RE = /^export const PACKAGE_VERSION = .*;$/m;
-const UNIFFI_BINDINGS_FILE = "bindings.ts";
-const UNIFFI_GENERATED_FILE = "_bindings.ts";
-const UNIFFI_FFI_FILE = "_bindings-ffi.ts";
 
 /** `config-tools` / `config_tools` -> `configTools`; `local-fs` -> `localFS`. */
 function moduleSegmentToCamel(segment: string): string {
@@ -295,61 +287,6 @@ function isLegacyBindingsExport(file: string): boolean {
   return readFileSync(file, "utf8").trim() === 'export * from "./src/bindings.ts";';
 }
 
-function hasUniFFIBindings(srcDir: string): boolean {
-  return [UNIFFI_BINDINGS_FILE, UNIFFI_GENERATED_FILE, UNIFFI_FFI_FILE].every((file) =>
-    existsSync(join(srcDir, file)),
-  );
-}
-
-function bindingExportNames(srcDir: string): Set<string> {
-  return new Set(
-    [UNIFFI_BINDINGS_FILE, UNIFFI_GENERATED_FILE].flatMap((file) =>
-      moduleExports(join(srcDir, file)).map((entry) => entry.name),
-    ),
-  );
-}
-
-function barrelExportNames(content: string, customPath: string): Set<string> {
-  const names = new Set<string>([PACKAGE_IDENTIFIER_EXPORT, PACKAGE_VERSION_EXPORT]);
-  for (const match of content.matchAll(/^export \* as (\w+) from /gm)) {
-    names.add(match[1]!);
-  }
-  for (const match of content.matchAll(/^export(?: type)? \{([^}]+)\} from /gm)) {
-    for (const specifier of match[1]!.split(",")) {
-      const parts = specifier.trim().split(/\s+as\s+/);
-      const name = parts.at(-1);
-      if (name) names.add(name);
-    }
-  }
-  if (existsSync(customPath) && !isLegacyBindingsExport(customPath)) {
-    const statements = moduleStatements(customPath) as ReadonlyArray<{
-      type: string;
-      exported?: unknown;
-    }>;
-    if (
-      statements.some(
-        (statement) => statement.type === "ExportAllDeclaration" && !statement.exported,
-      )
-    ) {
-      throw new Error(
-        `Cannot verify UniFFI export conflicts through a bare export in ${customPath}`,
-      );
-    }
-    for (const name of customExportNames(customPath)) names.add(name);
-  }
-  return names;
-}
-
-function assertNoBindingExportConflicts(srcDir: string, content: string, customPath: string): void {
-  const other = barrelExportNames(content, customPath);
-  const conflicts = [...bindingExportNames(srcDir)].filter((name) => other.has(name)).sort();
-  if (conflicts.length > 0) {
-    throw new Error(
-      `UniFFI binding exports conflict with package exports in ${srcDir}: ${conflicts.join(", ")}`,
-    );
-  }
-}
-
 /** Read the authoritative npm package name and version emitted by the package project. */
 function packageMetadata(pkgDir: string): { identifier: string; version: string } {
   const manifestPath = join(pkgDir, "package.json");
@@ -441,10 +378,7 @@ function generateForPackage(pkgDir: string): number {
     if (!existing || (!isSourceExt(existing) && isSourceExt(f))) byModulePath.set(stem, f);
   }
   const modulePaths = [...byModulePath.keys()].sort((a, b) => a.localeCompare(b));
-  const uniffiBindings = hasUniFFIBindings(srcDir);
-  const namespacedModulePaths = uniffiBindings
-    ? modulePaths.filter((modulePath) => modulePath !== "bindings")
-    : modulePaths;
+  const namespacedModulePaths = modulePaths;
 
   // No eligible modules -> no barrel: drop any stale root barrel and bail.
   if (modulePaths.length === 0) {
@@ -479,13 +413,6 @@ function generateForPackage(pkgDir: string): number {
   content = hoistUniqueExports(content, pkgDir, suppress);
   // A sibling `exports.ts` overrides/extends the generated barrel and wins on conflict.
   content = mergeCustomExports(content, pkgDir);
-  if (uniffiBindings) {
-    assertNoBindingExportConflicts(srcDir, content, customPath);
-    content = content.replace(
-      PACKAGE_VERSION_LINE,
-      `${PACKAGE_VERSION_LINE}\nexport * from "./src/bindings.ts";`,
-    );
-  }
 
   // Package metadata is blanked for the structural comparison, then restored
   // from package.json so a version-only change still rewrites the barrel.