@dbx-tools/projen 0.4.1 → 0.5.1

package/index.ts

@@ -2,55 +2,95 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 
-export * as barrels from "./src/barrels";
-export * as clean from "./src/clean";
-export * as cliBin from "./src/cli-bin";
-export * as codegen from "./src/codegen";
-export * as dbxToolsConfig from "./src/dbx-tools-config";
-export * as engineRoot from "./src/engine-root";
-export * as generated from "./src/generated";
-export * as mixin from "./src/mixin";
-export * as moduleExports from "./src/module-exports";
-export * as openapi from "./src/openapi";
-export * as packages from "./src/packages";
-export * as pnpmWorkspace from "./src/pnpm-workspace";
-export * as project from "./src/project";
-export * as projectPredicate from "./src/project-predicate";
-export * as release from "./src/release";
-export * as scaffold from "./src/scaffold";
-export * as tags from "./src/tags";
-export * as tsconfig from "./src/tsconfig";
-export * as vite from "./src/vite";
-export * as vscode from "./src/vscode";
-export * as watch from "./src/watch";
-export { generateBarrels } from "./src/barrels";
-export { listGeneratedFiles, listNodeModulesDirs, removePaths } from "./src/clean";
-export { CliBinLauncher, addCliBinLaunchers } from "./src/cli-bin";
-export { generateCodegen } from "./src/codegen";
-export { DBXToolsConfig } from "./src/dbx-tools-config";
-export type { DBXToolsConfigOptions } from "./src/dbx-tools-config";
-export { resolvePkgRoot } from "./src/engine-root";
-export { makeWritable, makeReadonly, isReadonly, header, stampGenerated } from "./src/generated";
-export type { HeaderOpts } from "./src/generated";
-export { create } from "./src/mixin";
-export type { ConstructsMixin } from "./src/mixin";
-export { moduleStatements } from "./src/module-exports";
-export type { ModuleStatement, ModuleExport } from "./src/module-exports";
-export { isTsoaController, generateOpenapi } from "./src/openapi";
-export { repoRoot, DEFAULT_PACKAGE_ROOTS, projectName, toPosix, isGeneratedFile, isModuleFile, DiscoveredPackage, scanPackages, readPackageManifest, syncResynthPaths, recordedPackages, recordedRoots } from "./src/packages";
-export type { RecordedPackage } from "./src/packages";
-export { PnpmWorkspaceState } from "./src/pnpm-workspace";
-export type { Catalog, AllowBuilds, DBXToolsPNPMWorkspaceOptions } from "./src/pnpm-workspace";
-export { PackageIdentifier, identifier, applyCompilerOptions, applyIncludes, applyTasks, applyExports, addExports, addPackageFiles, srcModuleExports, PROJEN_VERSION, DBXToolsNodeProject, DBXToolsTypeScriptProject, taskScript, applyToProjects } from "./src/project";
-export type { DBXToolsProject, DBXToolsProjectOptions, DBXToolsTypeScriptProjectOptions, ApplyToProjectsOptions } from "./src/project";
-export { isProject, isDBXToolsProject, hasName, hasIdentifierPackageName, hasIdentifierName, hasIdentifierScope, hasTag, hasPath } from "./src/project-predicate";
-export { DBXToolsRelease } from "./src/release";
-export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release";
-export { runSynth } from "./src/scaffold";
-export { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS } from "./src/tags";
-export type { PackageTag } from "./src/tags";
-export { DBXToolsRootTsconfig } from "./src/tsconfig";
-export { ViteConfigFile } from "./src/vite";
-export { DBXToolsVsCode } from "./src/vscode";
-export { watchRoots, watchLoop } from "./src/watch";
-export type { IgnoreGroupOptions } from "./src/watch";
+export * as barrels from "./src/barrels.ts";
+export * as clean from "./src/clean.ts";
+export * as codegen from "./src/codegen.ts";
+export * as dbxToolsConfig from "./src/dbx-tools-config.ts";
+export * as engineRoot from "./src/engine-root.ts";
+export * as generated from "./src/generated.ts";
+export * as mixin from "./src/mixin.ts";
+export * as moduleExports from "./src/module-exports.ts";
+export * as openapi from "./src/openapi.ts";
+export * as packages from "./src/packages.ts";
+export * as pnpmWorkspace from "./src/pnpm-workspace.ts";
+export * as project from "./src/project.ts";
+export * as projectPredicate from "./src/project-predicate.ts";
+export * as release from "./src/release.ts";
+export * as scaffold from "./src/scaffold.ts";
+export * as tags from "./src/tags.ts";
+export * as tsconfig from "./src/tsconfig.ts";
+export * as vite from "./src/vite.ts";
+export * as vscode from "./src/vscode.ts";
+export * as watch from "./src/watch.ts";
+export { generateBarrels } from "./src/barrels.ts";
+export { listGeneratedFiles, listNodeModulesDirs, removePaths } from "./src/clean.ts";
+export { generateCodegen } from "./src/codegen.ts";
+export { DBXToolsConfig } from "./src/dbx-tools-config.ts";
+export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
+export { resolvePkgRoot } from "./src/engine-root.ts";
+export { makeWritable, makeReadonly, isReadonly, header, stampGenerated } from "./src/generated.ts";
+export type { HeaderOpts } from "./src/generated.ts";
+export { create } from "./src/mixin.ts";
+export type { ConstructsMixin } from "./src/mixin.ts";
+export { moduleStatements } from "./src/module-exports.ts";
+export type { ModuleStatement, ModuleExport } from "./src/module-exports.ts";
+export { isTsoaController, generateOpenapi } from "./src/openapi.ts";
+export {
+  repoRoot,
+  DEFAULT_PACKAGE_ROOTS,
+  projectName,
+  toPosix,
+  isGeneratedFile,
+  isModuleFile,
+  DiscoveredPackage,
+  scanPackages,
+  readPackageManifest,
+  syncResynthPaths,
+  recordedPackages,
+  recordedRoots,
+} from "./src/packages.ts";
+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 {
+  PackageIdentifier,
+  identifier,
+  applyCompilerOptions,
+  applyIncludes,
+  applyTasks,
+  applyExports,
+  addExports,
+  addPackageFiles,
+  srcModuleExports,
+  PROJEN_VERSION,
+  DBXToolsNodeProject,
+  DBXToolsTypeScriptProject,
+  taskScript,
+  applyToProjects,
+} from "./src/project.ts";
+export type {
+  DBXToolsProject,
+  DBXToolsProjectOptions,
+  DBXToolsTypeScriptProjectOptions,
+  ApplyToProjectsOptions,
+} from "./src/project.ts";
+export {
+  isProject,
+  isDBXToolsProject,
+  hasName,
+  hasIdentifierPackageName,
+  hasIdentifierName,
+  hasIdentifierScope,
+  hasTag,
+  hasPath,
+} from "./src/project-predicate.ts";
+export { DBXToolsRelease } from "./src/release.ts";
+export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.ts";
+export { runSynth } from "./src/scaffold.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 { ViteConfigFile } from "./src/vite.ts";
+export { DBXToolsVsCode } from "./src/vscode.ts";
+export { watchRoots, watchLoop } from "./src/watch.ts";
+export type { IgnoreGroupOptions } from "./src/watch.ts";

package/package.json

@@ -32,7 +32,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/barrels.ts

@@ -15,7 +15,7 @@
  * takes priority. This keeps the barrel auto-generated while letting you add or
  * override individual exports.
  *
- * Each eligible module becomes `export * as <name> from "./src/x"` (camelCase
+ * Each eligible module becomes `export * as <name> from "./src/x.ts"` (camelCase
  * namespace from its path segments; invalid identifiers suffixed with `Module`),
  * sorted by module path.
  *
@@ -40,9 +40,15 @@ import { join } from "node:path";
 import { find } from "@dbx-tools/path";
 import { string } from "@dbx-tools/shared-core";
 import isIdentifier from "is-identifier";
-import { header, makeReadonly, makeWritable, stampGenerated, type HeaderOpts } from "./generated";
-import { moduleExports, moduleStatements, type ModuleExport } from "./module-exports";
-import { isModuleFile, toPosix, recordedPackages } from "./packages";
+import {
+  header,
+  makeReadonly,
+  makeWritable,
+  stampGenerated,
+  type HeaderOpts,
+} from "./generated.ts";
+import { moduleExports, moduleStatements, type ModuleExport } from "./module-exports.ts";
+import { isModuleFile, toPosix, recordedPackages } from "./packages.ts";
 
 /**
  * A `src`-relative posix path excluded from the root barrel:
@@ -149,8 +155,7 @@ function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<strin
   const seen = new Map<string, { count: number; modulePath: string }>();
   const perModule = new Map<string, ModuleExport[]>();
   for (const { modulePath } of namespaces) {
-    const abs = join(pkgDir, modulePath.replace(/^\.\//, ""));
-    const exports = moduleExports(withTsExt(abs));
+    const exports = moduleExports(join(pkgDir, modulePath.replace(/^\.\//, "")));
     perModule.set(modulePath, exports);
     for (const { name } of exports) {
       const prior = seen.get(name);
@@ -177,14 +182,6 @@ function hoistUniqueExports(content: string, pkgDir: string, suppress: Set<strin
   return `${content.replace(/\n+$/, "")}\n${lines.join("\n")}\n`;
 }
 
-/** Resolve a barrel module path (`./src/x`, extensionless) to its on-disk `.ts(x)` file. */
-function withTsExt(absNoExt: string): string {
-  for (const ext of [".ts", ".tsx", ".mts", ".cts"]) {
-    if (existsSync(absNoExt + ext)) return absNoExt + ext;
-  }
-  return `${absNoExt}.ts`;
-}
-
 /** Hand-authored override barrel: a sibling of the generated `index.ts`. */
 const CUSTOM_EXPORTS_FILE = "exports.ts";
 
@@ -229,7 +226,7 @@ function mergeCustomExports(content: string, pkgDir: string): string {
     const ns = /^export \* as (\w+) from /.exec(line)?.[1];
     return !(ns && overridden.has(ns));
   });
-  return `${kept.join("\n").replace(/\n+$/, "")}\nexport * from "./exports";\n`;
+  return `${kept.join("\n").replace(/\n+$/, "")}\nexport * from "./exports.ts";\n`;
 }
 
 /**
@@ -285,11 +282,14 @@ function generateForPackage(pkgDir: string): number {
   // Unlock the read-only barrel so the rewrite below can replace it.
   makeWritable(rootBarrel);
 
-  // `./src/<path-without-ext>` namespaced by its path segments (camelCase; invalid
-  // identifiers suffixed with `Module`).
+  // `./src/<path>` with the module's REAL extension, namespaced by its path
+  // segments (camelCase; invalid identifiers suffixed with `Module`). The
+  // extension is written because `tsc` rewrites it on emit
+  // (`rewriteRelativeImportExtensions`) - an extensionless specifier would be
+  // copied through verbatim and Node's ESM resolver cannot probe for it.
   let content = modulePaths
     .map((stem) => {
-      const modulePath = `./src/${stem}`;
+      const modulePath = `./src/${byModulePath.get(stem)!}`;
       return `export * as ${modulePathToNamespace(modulePath)} from "${modulePath}";`;
     })
     .join("\n");

package/src/clean.ts

@@ -24,8 +24,8 @@
 import { existsSync, rmSync, statSync } from "node:fs";
 import { basename, join, relative } from "node:path";
 import { find } from "@dbx-tools/path";
-import { isReadonly, makeWritable } from "./generated";
-import { repoRoot, toPosix } from "./packages";
+import { isReadonly, makeWritable } from "./generated.ts";
+import { repoRoot, toPosix } from "./packages.ts";
 
 /**
  * Basenames `clean` never removes even when they are generated/read-only. `.gitignore`

package/src/codegen.ts

@@ -47,10 +47,10 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import type * as ts from "typescript";
-import { lazyRequire } from "./_lazy-require";
-import { header, isReadonly, makeReadonly, makeWritable } from "./generated";
+import { lazyRequire } from "./_lazy-require.ts";
+import { header, isReadonly, makeReadonly, makeWritable } from "./generated.ts";
 import { log, object } from "@dbx-tools/shared-core";
-import { readPackageManifest, repoRoot, recordedPackages } from "./packages";
+import { readPackageManifest, repoRoot, recordedPackages } from "./packages.ts";
 
 const logger = log.logger("projen:codegen");
 
@@ -322,8 +322,12 @@ export function generateCodegen(): string[] {
     .map((p) => ({ dir: p.dir, inputs: codegenInputs(p.dir) }))
     .filter((t): t is { dir: string; inputs: string[] } => t.inputs !== undefined);
 
+  // Nothing to generate is the NORMAL case for a workspace that declares no
+  // `codegen` inputs, and this runs on every synth - so it stays silent rather
+  // than printing a line about work that was never asked for. `debug` keeps it
+  // reachable when someone is actually chasing why codegen produced nothing.
   if (targets.length === 0) {
-    logger.info("no packages declare a `codegen` field");
+    logger.debug("no packages declare a `codegen` field");
     return [];
   }
 

package/src/openapi.ts

@@ -25,8 +25,8 @@ import { createRequire } from "node:module";
 import { join } from "node:path";
 import type * as ts from "typescript";
 import { find } from "@dbx-tools/path";
-import { lazyRequire } from "./_lazy-require";
-import { makeReadonly, makeWritable, stampGenerated } from "./generated";
+import { lazyRequire } from "./_lazy-require.ts";
+import { makeReadonly, makeWritable, stampGenerated } from "./generated.ts";
 import { log } from "@dbx-tools/shared-core";
 import {
   type RecordedPackage,
@@ -34,7 +34,7 @@ import {
   repoRoot,
   toPosix,
   recordedPackages,
-} from "./packages";
+} from "./packages.ts";
 
 const logger = log.logger("projen:openapi");
 
@@ -86,15 +86,21 @@ export function isTsoaController(path: string): boolean {
  */
 export async function generateOpenapi(): Promise<string[]> {
   const pkgs = controllerPackages();
+  // Same reasoning as codegen's empty case: a workspace with no tsoa controllers
+  // is not a condition worth a line on every synth.
   if (pkgs.length === 0) {
-    logger.info("no tsoa controllers found in any server/node package");
+    logger.debug("no tsoa controllers found in any server/node package");
     return [];
   }
 
   // Lazy, resilient loads: tsoa + typescript are CJS (require), openapi-typescript
   // is ESM (dynamic import).
   const require = createRequire(import.meta.url);
-  const { generateSpec } = lazyRequire<typeof import("tsoa")>(require, "tsoa", "openapi generation");
+  const { generateSpec } = lazyRequire<typeof import("tsoa")>(
+    require,
+    "tsoa",
+    "openapi generation",
+  );
   const tsRuntime = lazyRequire<typeof ts>(require, "typescript", "openapi generation");
   const { default: openapiTS, astToString } = await import("openapi-typescript");
 

package/src/pnpm-workspace.ts

@@ -40,7 +40,7 @@
  */
 import { relative } from "node:path";
 import { javascript, type Project } from "projen";
-import { toPosix } from "./packages";
+import { toPosix } from "./packages.ts";
 
 /**
  * The pnpm `catalog:` version registry: dependency name -> version range. A

package/src/project-predicate.ts

@@ -7,8 +7,8 @@ import {
 } from "@dbx-tools/shared-core";
 import { IConstruct } from "constructs";
 import { Project } from "projen";
-import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project";
-import { toPosix } from "./packages";
+import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project.ts";
+import { toPosix } from "./packages.ts";
 import { relative } from "node:path";
 import { match, PathMatchInput, PathMatchPredicate } from "@dbx-tools/path";
 import { project } from "..";

package/src/project.ts

@@ -13,17 +13,17 @@ import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { ReleaseTrigger } from "projen/lib/release";
-import { generateBarrels } from "./barrels";
-import { generateCodegen } from "./codegen";
-import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config";
-import { resolvePkgRoot } from "./engine-root";
-import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace";
-import { applyCompiledPublish } from "./publish";
-import { DBXToolsRelease, type StandaloneRelease } from "./release";
-import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags";
-import { DBXToolsRootTsconfig } from "./tsconfig";
-import { ViteConfigFile } from "./vite";
-import { DBXToolsVsCode } from "./vscode";
+import { generateBarrels } from "./barrels.ts";
+import { generateCodegen } from "./codegen.ts";
+import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
+import { resolvePkgRoot } from "./engine-root.ts";
+import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
+import { applyCompiledPublish } from "./publish.ts";
+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 { DEFAULT_VITE_OVERRIDES, ViteConfigFile } from "./vite.ts";
+import { DBXToolsVsCode } from "./vscode.ts";
 import {
   DEFAULT_PACKAGE_ROOTS,
   type DiscoveredPackage,
@@ -32,7 +32,7 @@ import {
   repoRoot,
   scanPackages,
   toPosix,
-} from "./packages";
+} from "./packages.ts";
 import { mixin, projectPredicate } from "..";
 import { IConstruct } from "constructs";
 
@@ -271,11 +271,25 @@ export function srcModuleExports(pkg: javascript.NodeProject): Record<string, st
   return exports;
 }
 
-/** ESM compiler options every Node package shares regardless of tag. */
-const SHARED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
+/**
+ * ESM compiler options every package shares regardless of tag.
+ *
+ * Relative imports in this repo carry their REAL extension (`./http.ts`), which
+ * is what lets `tsc` rewrite them to `./http.js` on emit
+ * (`rewriteRelativeImportExtensions`) instead of a post-processing pass fixing up
+ * the emitted tree. Both flags belong here rather than on the publishing packages
+ * only: the specifier style is a property of the SOURCE, so a `ui` package (which
+ * publishes source and is excluded from the compiled surface) still has to accept
+ * and rewrite it.
+ */
+const SHARED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions & {
+  rewriteRelativeImportExtensions: boolean;
+} = {
   module: "ESNext",
   moduleResolution: javascript.TypeScriptModuleResolution.BUNDLER,
   skipLibCheck: true,
+  allowImportingTsExtensions: true,
+  rewriteRelativeImportExtensions: true,
 };
 
 /** Shared formatting rules, applied by projen's Prettier on whichever project is root. */
@@ -827,7 +841,6 @@ function initProject(
   for (const root of roots) {
     project.annotateGenerated(`/${root}/**/index.ts`);
     project.annotateGenerated(`/${root}/openapi/**`);
-    project.annotateGenerated(`/${root}/**/bin/*.mjs`);
   }
 
   // ESLint lives ONLY on the root and lints every package. `projectService` resolves
@@ -851,6 +864,12 @@ function initProject(
     eslint.addIgnorePattern(`${root}/**/index.ts`);
   }
   eslint.addIgnorePattern("**/vite.config.ts");
+  // The unmanaged vite overrides live at the package root, outside any `src/**`
+  // tsconfig include, so the type-aware parser cannot resolve them to a project.
+  // They are hand-authored (not generated), but ESLint still cannot parse them.
+  for (const override of DEFAULT_VITE_OVERRIDES) {
+    eslint.addIgnorePattern(`**/${override}`);
+  }
   // Codegen packages declare `codegen.inputs` via mixins after construction; ignore
   // their `src/` once manifests are known (preSynthesize), same reason as openapi.
   new EslintIgnoreCodegen(project);

package/src/publish.ts

@@ -4,44 +4,52 @@
  *
  * Packages resolve each other from SOURCE - every `exports` entry points at a
  * `.ts` file, so a cross-package import type-checks with no build step and no
- * `dist` to keep in sync. That property is worth keeping, but it cannot be what
+ * `lib` to keep in sync. That property is worth keeping, but it cannot be what
  * ships: Node refuses to strip types under `node_modules`
  * (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), so a published package whose
  * entry point is `index.ts` is unloadable by anything that is not a bundler.
- * Consumers papered over that by special-casing `@dbx-tools/*` into their own
- * bundle, which is a tax this repo has no business charging.
  *
  * pnpm resolves both at once. It substitutes `publishConfig`'s `main`/`types`/
- * `exports` into the manifest at pack time and drops `publishConfig` itself, so
- * the workspace keeps its source entry points while the tarball advertises the
- * compiled ones. Nothing here changes how the repo builds or type-checks; it
- * only changes what `pnpm pack` writes.
+ * `bin`/`exports` into the manifest at pack time and drops `publishConfig`
+ * itself, so the workspace keeps its source entry points while the tarball
+ * advertises the compiled ones. Nothing here changes how the repo builds or
+ * type-checks; it only changes what `pnpm pack` writes.
  *
- * Two pieces make the emitted tree actually loadable:
+ * Two compiler options make the emitted tree loadable, both native `tsc`:
  *
  * - `rootDir: "."` so the package-ROOT `index.ts` barrel is compiled at all.
  *   projen's default `rootDir: "src"` puts the barrel outside the compilation,
- *   which is why `lib/` has never had an `index.js`.
- * - a specifier pass after `tsc`, because `tsc` never rewrites import paths.
- *   Sources are written for `moduleResolution: bundler` and so import `"./http"`,
- *   which Node cannot resolve; `tasks/emit.ts` appends the extension that the
- *   emitted file actually has. Doing it after the fact keeps 800-odd import
- *   sites free of the `.js` suffix that would otherwise have to be written - and
- *   maintained - by hand.
+ *   which is why `lib/` would otherwise have no `index.js`.
+ * - `rewriteRelativeImportExtensions`, which turns the `./x.ts` specifiers this
+ *   repo writes into the `./x.js` Node's ESM resolver needs. Sources carry the
+ *   real extension (`allowImportingTsExtensions`) and `tsc` rewrites it on emit,
+ *   so no post-processing pass is involved.
  *
  * UI packages are deliberately excluded (see {@link publishesCompiled}).
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
-import { addPackageFiles, applyCompilerOptions, applyIncludes, taskScript } from "./project";
-import { isDBXToolsProject } from "./project-predicate";
+import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
+import { isDBXToolsProject } from "./project-predicate.ts";
 
 /** Directory `tsc` emits into, and the root of every published entry point. */
 export const COMPILED_DIR = "lib";
 
-/** An `exports` target written as TypeScript source, i.e. one with a compiled twin. */
+/** An `exports`/`bin` target written as TypeScript source, i.e. with a compiled twin. */
 const TS_SOURCE = /\.tsx?$/;
 
+/**
+ * Compiler options that make a package's emitted `lib/` tree loadable by Node.
+ *
+ * Only `rootDir` here: the specifier rewriting
+ * (`allowImportingTsExtensions` + `rewriteRelativeImportExtensions`) is part of
+ * the tsconfig floor EVERY package gets, since the `.ts`-suffixed specifier style
+ * is a property of the source rather than of publishing.
+ */
+export const COMPILED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
+  rootDir: ".",
+};
+
 /**
  * Whether a package publishes compiled output rather than source.
  *
@@ -52,15 +60,16 @@ const TS_SOURCE = /\.tsx?$/;
  * `./styles.css` plus raw SVG assets that `tsc` does not copy and could not
  * rewrite. Compiling them would mean a real asset pipeline (Vite library mode)
  * to solve a problem they do not have.
- *
- * This is the same split the downstream app build already makes on its own: its
- * client bundle resolves `@dbx-tools/ui-*` from source without complaint, while
- * its SERVER bundle is the one that had to inline `@dbx-tools/*` to avoid
- * handing Node a `.ts` entry point.
  */
 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 isDBXToolsProject()(pkg) && !pkg.dbxToolsConfig.tags.includes("ui");
+}
+
+/** The `./lib/...` stem of a source path, or `undefined` if it is not TypeScript. */
+function compiledStem(target: string): string | undefined {
+  if (!TS_SOURCE.test(target)) return undefined;
+  return `./${COMPILED_DIR}/${target.replace(/^\.\//, "").replace(TS_SOURCE, "")}`;
 }
 
 /**
@@ -71,13 +80,12 @@ export function publishesCompiled(pkg: javascript.NodeProject): boolean {
  * mapping is positional: `./src/react/index.ts` -> `./lib/src/react/index.js`.
  */
 function compiledTarget(target: string): { types: string; default: string } | undefined {
-  if (!TS_SOURCE.test(target)) return undefined;
-  const stem = `./${COMPILED_DIR}/${target.replace(/^\.\//, "").replace(TS_SOURCE, "")}`;
-  return { types: `${stem}.d.ts`, default: `${stem}.js` };
+  const stem = compiledStem(target);
+  return stem ? { types: `${stem}.d.ts`, default: `${stem}.js` } : undefined;
 }
 
 /**
- * Derive `publishConfig` from the package's FINAL `exports` map.
+ * Derive `publishConfig` from the package's FINAL `exports` + `bin` maps.
  *
  * Runs at preSynthesize precisely so the tags have already installed their
  * export layouts - deriving it any earlier would mirror the constructor's bare
@@ -88,9 +96,26 @@ function publishConfig(pkg: javascript.NodeProject): Record<string, unknown> | u
   const compiled = Object.entries(exports).map(
     ([subpath, target]) => [subpath, compiledTarget(target) ?? target] as const,
   );
+
+  // A CLI's `bin` points at its `.ts` entry in-repo (Node strips types outside
+  // `node_modules`, so a workspace checkout runs it directly); the tarball has to
+  // point at the emitted `.js`, which is what lets the published CLI run with no
+  // loader installed.
+  // `bin` is rendered LAZILY (projen assigns `bin: () => this.renderBin()` and
+  // keeps the map itself private), so unlike `exports` this has to be called -
+  // reading the field directly yields the function and finds no entries.
+  const binField = pkg.package.manifest.bin as
+    Record<string, string> | (() => Record<string, string>) | undefined;
+  const bin = (typeof binField === "function" ? binField() : binField) ?? {};
+  const compiledBin = Object.entries(bin).flatMap(([name, target]) => {
+    const stem = compiledStem(target);
+    return stem ? [[name, `${stem}.js`] as const] : [];
+  });
+
   // Nothing to swap means the package ships no TypeScript entry point at all;
   // leave its manifest alone rather than writing an inert `publishConfig`.
-  if (!compiled.some(([, target]) => typeof target !== "string")) return undefined;
+  const swaps = compiled.some(([, target]) => typeof target !== "string");
+  if (!swaps && compiledBin.length === 0) return undefined;
 
   // Setting this field REPLACES whatever projen renders into it, and what projen
   // renders is `access` - dropped, every scoped package here would publish as
@@ -100,13 +125,14 @@ function publishConfig(pkg: javascript.NodeProject): Record<string, unknown> | u
   return {
     access: pkg.package.npmAccess,
     ...(typeof root === "object" ? { main: root.default, types: root.types } : {}),
+    ...(compiledBin.length ? { bin: Object.fromEntries(compiledBin) } : {}),
     exports: Object.fromEntries(compiled),
   };
 }
 
 /**
- * Give a package a compiled publish surface: emit the barrel, fix the emitted
- * specifiers, ship `lib/`, and advertise it through `publishConfig`.
+ * Give a package a compiled publish surface: emit the barrel, ship `lib/`, and
+ * advertise it through `publishConfig`.
  *
  * Idempotent - `preSynthesizeProject` reaches every package twice (once from the
  * root's walk, once from the package's own preSynthesize) and both passes must
@@ -115,22 +141,13 @@ function publishConfig(pkg: javascript.NodeProject): Record<string, unknown> | u
 export function applyCompiledPublish(pkg: javascript.NodeProject): void {
   if (!publishesCompiled(pkg)) return;
 
-  // The barrel lives at the package root, so the compilation has to start there.
-  // The `cli` tag already does this for its `bin/` tree; for everything else it
-  // is what puts an `index.js` in the emitted output for the first time.
-  applyCompilerOptions(pkg, { rootDir: "." });
+  applyCompilerOptions(pkg, COMPILED_COMPILER_OPTIONS);
   applyIncludes(pkg, "index.ts");
   addPackageFiles(pkg, COMPILED_DIR);
 
   const config = publishConfig(pkg);
   if (config) pkg.package.addField("publishConfig", config);
 
-  // `tsc` emits extensionless relative specifiers; Node ESM cannot resolve them.
-  const fixSpecifiers = taskScript(pkg, "emit.ts", COMPILED_DIR);
-  if (!pkg.compileTask.steps.some((step) => step.exec === fixSpecifiers)) {
-    pkg.compileTask.exec(fixSpecifiers);
-  }
-
   // The release workflow publishes straight after `pnpm install`, with no build
   // in between, so the compiled output has to be produced by the pack itself
   // rather than assumed present. This also covers a bare `pnpm pack` and the

package/src/release.ts

@@ -7,7 +7,7 @@
 import { Component } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission } from "projen/lib/github/workflows-model";
-import { applyTasks, taskScript, type DBXToolsNodeProject } from "./project";
+import { applyTasks, taskScript, type DBXToolsNodeProject } from "./project.ts";
 
 /**
  * A standalone project that lives in a repo SUBDIRECTORY but is NOT a member of

package/src/scaffold.ts

@@ -3,7 +3,7 @@
  */
 import { join } from "node:path";
 import { exec } from "@dbx-tools/core";
-import { repoRoot } from "./packages";
+import { repoRoot } from "./packages.ts";
 
 /**
  * Re-run projen synth by executing `.projenrc.ts` with `node --import tsx` (no

package/src/tags.ts

@@ -14,9 +14,8 @@
  * callers add their own afterward.
  */
 import type { IMixin as ConstructsMixin } from "constructs";
-import { DependencyType, javascript } from "projen";
-import { addCliBinLaunchers } from "./cli-bin";
-import { create } from "./mixin";
+import { javascript } from "projen";
+import { create } from "./mixin.ts";
 import {
   addPackageFiles,
   applyCompilerOptions,
@@ -24,9 +23,9 @@ import {
   applyIncludes,
   applyTasks,
   srcModuleExports,
-} from "./project";
-import * as projectPredicate from "./project-predicate";
-import { ViteConfigFile } from "./vite";
+} from "./project.ts";
+import * as projectPredicate from "./project-predicate.ts";
+import { ViteConfigFile } from "./vite.ts";
 
 /** Node compiler options: ES2022 lib + node types, deliberately no DOM. */
 const NODE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
@@ -114,19 +113,17 @@ export const PACKAGE_TAG_MIXINS = {
     });
   }),
   cli: create(projectPredicate.hasTag("cli"), (p) => {
-    // tsx is a RUNTIME dep, not a dev one: a CLI's bin is a `.ts` entry that needs
-    // the tsx loader registered before it can run, and an installed consumer
-    // (`npm i -g`) has no other source for it. Drop the baseline devDep so it isn't
-    // declared in both blocks. The generated `.mjs` launchers are what actually
-    // reach it - see {@link addCliBinLaunchers}.
-    p.deps.removeDependency("tsx", DependencyType.BUILD);
-    p.addDeps("commander@catalog:", "@clack/prompts@catalog:", "tsx@catalog:");
+    // No tsx: a CLI's `bin` resolves to its emitted `lib/bin/<name>.js` in the
+    // published tarball (see `publishConfig` in {@link applyCompiledPublish}), so
+    // the installed CLI is plain JavaScript Node runs directly - no loader to
+    // register and no launcher shim to generate. In a WORKSPACE checkout the
+    // manifest still points at the `.ts` entry, which Node type-strips on its own
+    // because the package is not under `node_modules`.
+    p.addDeps("commander@catalog:", "@clack/prompts@catalog:");
     p.addDevDeps("@types/node@catalog:");
-    addCliBinLaunchers(p);
     // A CLI compiles code OUTSIDE `src/` - its root `index.ts` barrel and the
-    // `bin/` entries - which the src-only tag default doesn't reach, so the
-    // tsconfig is rooted at the package instead.
-    applyCompilerOptions(p, { ...NODE_COMPILER_OPTIONS, rootDir: "." });
+    // `bin/` entries - which the src-only tag default doesn't reach.
+    applyCompilerOptions(p, NODE_COMPILER_OPTIONS);
     applyIncludes(p, "index.ts", "bin/**/*.ts");
     // A CLI's standard surface: the `.` root entry, a `./<module>` subpath per
     // top-level `src` module, and `./package.json`. Derived rather than declared
@@ -137,7 +134,7 @@ export const PACKAGE_TAG_MIXINS = {
       "./package.json": "./package.json",
     });
     // A CLI is the one shape whose entry point lives outside `src`, so its
-    // launchers have to be added to the tarball allowlist explicitly.
+    // `bin/` tree has to be added to the tarball allowlist explicitly.
     addPackageFiles(p, "bin");
   }),
   server: create(projectPredicate.hasTag("server"), (p) => {

package/src/vite.ts

@@ -24,8 +24,12 @@ import { type Project, TextFile } from "projen";
  * (later wins, absent files skipped). Both extensions are accepted so an existing
  * JavaScript override keeps working; the TypeScript one is listed last so it wins
  * where a package is mid-migration and still has both.
+ *
+ * Exported because ESLint has to ignore them: an override is a package-ROOT file
+ * outside any `src/**` tsconfig include, so the type-aware parser cannot resolve
+ * it to a project - the same reason the generated `vite.config.ts` is ignored.
  */
-const DEFAULT_VITE_OVERRIDES = ["vite.config.override.js", "vite.config.override.ts"];
+export const DEFAULT_VITE_OVERRIDES = ["vite.config.override.js", "vite.config.override.ts"];
 
 /** Render the generated `vite.config.ts` source with the override chain inlined. */
 function renderViteConfig(overridePaths: string[]): string {

package/src/watch.ts

@@ -17,7 +17,7 @@
 import { isAbsolute, resolve } from "node:path";
 import { watch as fileScan } from "@dbx-tools/path";
 import { log } from "@dbx-tools/shared-core";
-import { isGeneratedFile, recordedRoots, repoRoot } from "./packages";
+import { isGeneratedFile, recordedRoots, repoRoot } from "./packages.ts";
 
 const logger = log.logger("projen:watch");
 const DEBOUNCE_MS = 250;

package/tasks/barrels.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
 import { sep } from "node:path";
-import { generateBarrels } from "../src/barrels";
+import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
-import { watchLoop, watchRoots } from "../src/watch";
-import { recordedPackages } from "../src/packages";
+import { watchLoop, watchRoots } from "../src/watch.ts";
+import { recordedPackages } from "../src/packages.ts";
 
 const logger = log.logger("projen:barrels");
 

package/tasks/clean.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env -S npx tsx
 import { relative } from "node:path";
-import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean";
+import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { log, string } from "@dbx-tools/shared-core";
-import { repoRoot, toPosix } from "../src/packages";
+import { repoRoot, toPosix } from "../src/packages.ts";
 
 const logger = log.logger("projen:clean");
 const yes = process.argv.includes("-y") || process.argv.includes("--yes");

package/tasks/openapi.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
-import { generateBarrels } from "../src/barrels";
+import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
-import { generateOpenapi, isTsoaController } from "../src/openapi";
-import { runSynth } from "../src/scaffold";
-import { watchLoop, watchRoots } from "../src/watch";
+import { generateOpenapi, isTsoaController } from "../src/openapi.ts";
+import { runSynth } from "../src/scaffold.ts";
+import { watchLoop, watchRoots } from "../src/watch.ts";
 
 const logger = log.logger("projen:openapi");
 

package/tasks/projenrc.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
 import { resolve } from "node:path";
 import { log } from "@dbx-tools/shared-core";
-import { runSynth } from "../src/scaffold";
-import { watchLoop } from "../src/watch";
-import { repoRoot, syncResynthPaths } from "../src/packages";
+import { runSynth } from "../src/scaffold.ts";
+import { watchLoop } from "../src/watch.ts";
+import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 
 const logger = log.logger("projen:projenrc");
 

package/tasks/sync.ts

@@ -2,7 +2,7 @@
 import { fileURLToPath } from "node:url";
 import concurrently from "concurrently";
 import { log } from "@dbx-tools/shared-core";
-import { runSynth } from "../src/scaffold";
+import { runSynth } from "../src/scaffold.ts";
 
 const logger = log.logger("projen:sync");
 

package/src/cli-bin.ts

@@ -1,72 +0,0 @@
-/**
- * Generated `bin/<name>.mjs` launchers for a CLI package's TypeScript entries.
- *
- * A CLI's real entry is a `.ts` file, which Node cannot run on its own, so something
- * has to register tsx first. A `#!/usr/bin/env -S npx tsx` shebang does that only for
- * a WORKSPACE checkout: `npx` resolves tsx from the current working directory, and a
- * globally installed CLI (`npm i -g @dbx-tools/cli`) has no relationship to whatever
- * directory the user happens to be in - so every first invocation stalls to fetch tsx
- * from the network, or fails outright when offline.
- *
- * {@link CliBinLauncher} emits a tiny `.mjs` sibling that npm points its bin symlink
- * at. Because the launcher reaches tsx through a bare `import` specifier, NODE
- * resolves it relative to the launcher's own location - i.e. the CLI package's own
- * `node_modules` - which is exactly where the `cli` tag's runtime tsx dependency
- * installs it. The `.ts` entry stays the source of truth; the launcher only registers
- * the loader and hands off.
- *
- * {@link addCliBinLaunchers} discovers the entries by scanning the package's `bin/`
- * directory at synth, so a new CLI just needs its `.ts` file plus a `package.json`
- * bin pointing at the matching `.mjs`.
- */
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { type Project, TextFile } from "projen";
-import { header } from "./generated";
-
-/** Directory (package-relative) holding a CLI's executable entries. */
-const BIN_DIR = "bin";
-
-/** Render the launcher source for a `.ts` entry sitting beside it. */
-function renderLauncher(entryFileName: string): string {
-  return `#!/usr/bin/env node
-${header({
-  tool: "projen synth (cli tag)",
-  source: `./${entryFileName}`,
-})}
-// Resolved as a bare specifier so Node looks in THIS file's package rather than the
-// caller's cwd - the only way a globally installed CLI finds its own tsx.
-import { register } from "tsx/esm/api";
-
-register();
-await import(new URL(${JSON.stringify(`./${entryFileName}`)}, import.meta.url).href);
-`;
-}
-
-/**
- * A projen-owned, read-only `.mjs` launcher that registers tsx and defers to the
- * `.ts` entry beside it.
- */
-export class CliBinLauncher extends TextFile {
-  constructor(project: Project, entryFileName: string) {
-    super(project, join(BIN_DIR, entryFileName.replace(/\.ts$/, ".mjs")), {
-      readonly: true,
-      executable: true,
-      lines: renderLauncher(entryFileName).split("\n"),
-    });
-  }
-}
-
-/**
- * Emit a {@link CliBinLauncher} for every `.ts` entry in the package's `bin/`
- * directory. A package with no `bin/` directory is left alone.
- */
-export function addCliBinLaunchers(project: Project): void {
-  const binDir = join(project.outdir, BIN_DIR);
-  if (!existsSync(binDir)) return;
-
-  for (const entry of readdirSync(binDir).sort()) {
-    if (!entry.endsWith(".ts") || entry.endsWith(".d.ts")) continue;
-    new CliBinLauncher(project, entry);
-  }
-}

package/tasks/emit.ts

@@ -1,82 +0,0 @@
-/**
- * Append the explicit file extension Node ESM requires to every relative
- * specifier in a compiled tree.
- *
- * Sources are written for `moduleResolution: bundler`, so they import `"./http"`
- * with no extension, and `tsc` copies specifiers through untouched. Node's ESM
- * resolver does no extension probing, so that emitted output is unloadable -
- * which is the whole reason these packages used to publish source instead. The
- * alternative fix is to write `"./http.js"` at all 800-odd import sites and keep
- * writing it forever; this pass makes it a build detail instead.
- *
- * Deliberately filesystem-driven rather than clever: each specifier is resolved
- * against what `tsc` actually emitted, so a module that became a file and a
- * module that became a directory are told apart by looking, not by guessing.
- * Anything that does not resolve is left exactly as it was - a bare package
- * specifier, an asset, or a genuine mistake that should surface as itself.
- *
- * Usage: `tsx emit.ts <compiled-dir>` (relative to the package root).
- */
-import { log } from "@dbx-tools/shared-core";
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-
-const logger = log.logger("projen:emit");
-
-/**
- * The specifier of a static import/export or a dynamic `import()`.
- *
- * Anchored on the keyword that precedes it so a relative path appearing inside a
- * string literal or a comment is never touched.
- */
-const SPECIFIER = /(\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*)(["'])(\.\.?\/[^"']*)\2/g;
-
-/** Extensions that are already explicit, whether JavaScript or an asset. */
-const EXPLICIT = /\.(js|mjs|cjs|json|css|svg|png|jpg|jpeg|gif|webp)$/;
-
-/** Files whose specifiers matter: the emitted JavaScript and its declarations. */
-const EMITTED = /\.(js|mjs|cjs|d\.ts)$/;
-
-/**
- * What a relative specifier must become, or `undefined` to leave it alone.
- *
- * Declarations resolve against the emitted `.js` too: inside a `.d.ts`,
- * TypeScript maps a `"./foo.js"` specifier onto the neighbouring `foo.d.ts`, so
- * both file kinds want the same suffix.
- */
-function retarget(fileDir: string, specifier: string): string | undefined {
-  if (EXPLICIT.test(specifier)) return undefined;
-  const base = resolve(fileDir, specifier);
-  if (existsSync(`${base}.js`)) return `${specifier}.js`;
-  if (existsSync(join(base, "index.js"))) return `${specifier}/index.js`;
-  return undefined;
-}
-
-/** Every file under `dir`, recursively. */
-function walk(dir: string): string[] {
-  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) =>
-    entry.isDirectory() ? walk(join(dir, entry.name)) : [join(dir, entry.name)],
-  );
-}
-
-/** Rewrite one file in place; returns whether anything changed. */
-function rewrite(file: string): boolean {
-  const before = readFileSync(file, "utf8");
-  const after = before.replace(SPECIFIER, (match, keyword, quote, specifier) => {
-    const next = retarget(dirname(file), specifier as string);
-    return next ? `${keyword}${quote}${next}${quote}` : match;
-  });
-  if (after === before) return false;
-  writeFileSync(file, after);
-  return true;
-}
-
-const target = resolve(process.argv[2] ?? "lib");
-// A package whose compile produced nothing (no emit, or a tag that replaced the
-// compile task) is not an error - there is simply nothing to fix up.
-if (existsSync(target)) {
-  const changed = walk(target)
-    .filter((file) => EMITTED.test(file))
-    .filter(rewrite).length;
-  if (changed > 0) logger.debug(`emit: resolved specifiers in ${changed} files`);
-}