@ts-ioc-container/bundler 2.1.0 → 3.1.0

package/AGENTS.md

@@ -1,7 +1,7 @@
 # AGENTS.md — @ts-ioc-container/bundler
 
 Bundles an application's dependencies into a single container module for
-`ts-ioc-container`: the `tic` CLI scans folders and generates a typed bundle
+`ts-ioc-container`: the `tic` CLI scans what a tsconfig compiles and generates a typed bundle
 (`useModule(new AppBundle())`). Discovery happens at build time (ADR 0022);
 nothing here runs inside the container, and the core package is not changed by
 it.
@@ -9,8 +9,10 @@ it.
 - The CLI is `ts-ioc-container`, with `tic` as a shortcut (both `bin` entries,
   same program). One config file describes one bundle: `<name>.bundle.json`, or the same in
   YAML as `<name>.bundle.yaml` / `.yml` (an empty YAML file = all defaults)
-  (schema: `tic.schema.json`), flat — `output`, `name`, `tags`, `extends`,
-  `importExtension`, `files`, `classes`, all optional. `tic build` works on
+  (schema: `tic.schema.json`), shaped like a tsconfig — `extends`, `include`,
+  `exclude`, `compilerOptions` — plus the bundler's `baseUrl`, `output` and `name`
+  at the top level and `compilerOptions.importExtension` / `compilerOptions.classes`;
+  all optional. `tic build` works on
   the package it is invoked in (nearest `package.json` up from the working
   directory; never a workspace root): it builds every `*.bundle.{json,yaml,yml}` there
   (or the ones named with repeatable `-c`), else — zero config — one bundle
@@ -18,24 +20,31 @@ it.
   applied with `container.useModule(new AppBundle())`. Several bundles (e.g.
   `production.bundle.json`, `development.bundle.json`) mean several configs.
   `--check` writes nothing and exits 1 when an output is stale — run it in CI.
-- A config `extends` a tsconfig (default `./tsconfig.json`, may be absent; one
-  named explicitly must exist), like a child tsconfig: what it compiles is the
-  bundle's file set, and its `paths` aliases and module resolution shape the
-  generated imports (most specific alias, else a relative path). `output`
-  defaults to `<root>/<name>.bundle.ts`: root = tsconfig `rootDir`, else the
-  common folder of its files. `name` defaults to the config's stem
-  (`production.bundle.json` → `production`), else `base`; the class is
+- A config is a tsconfig that `extends` another (default `./tsconfig.json`, may
+  be absent; one named explicitly must exist): TypeScript parses it with the
+  bundler's own fields removed, so the files it compiles (its `include` /
+  `exclude` replacing the parent's) are the bundle's file set, and the merged
+  `paths` aliases, `baseUrl` and module resolution shape the generated imports
+  (most specific alias, else a path relative to `baseUrl` when the file is under
+  it, else a relative path). Every compiler option but `classes`
+  and `importExtension` goes to TypeScript, which reports unknown ones.
+  The top-level `baseUrl` (default the config's directory) is the base the
+  config's own `include`, `exclude` and `output` resolve against — so they need
+  not repeat a shared prefix — and is passed to TypeScript as
+  `compilerOptions.baseUrl` unless that is set too; `extends` stays relative to
+  the config file. With `baseUrl` set, an omitted `include` defaults to the whole
+  `baseUrl` folder (`.`); without it, an omitted `include` still inherits the
+  extended tsconfig's.
+  `output` defaults to `<root>/<name>.bundle.ts`: root = compiled `rootDir`,
+  else the common folder of the files compiled. `name` defaults to the config's
+  stem (`production.bundle.json` → `production`), else `base`; the class is
   `toClassName(name)` — `ProductionBundle`, `BaseBundle`.
-- Selection has two stages. `files: { paths, include, exclude }` decides by path
-  which files are read and parsed at all. `paths` override the tsconfig's file
-  set with folders (relative to the config, or tsconfig aliases); required when
-  there is no tsconfig. A candidate must match one of `include` (default: all)
-  and none of `exclude` (default: test files, `__tests__/`, `node_modules/`; a
-  non-empty list replaces it, and the build warns if it drops a default). Globs
-  are relative to the config. With file naming conventions, `include` is the
-  speed lever — nothing else is read. Files `tic build` generated are never input.
-- `classes: { export, decorators, name, excludeClasses, excludeName }`
-  then picks classes of the parsed files; default is every exported,
+- Test files, `__tests__/` and `node_modules/` (`DEFAULT_EXCLUDE`) are never
+  scanned, whatever is compiled; neither are files `tic build` generated. With
+  file naming conventions, a narrow `include` is the speed lever — nothing else
+  is read.
+- `compilerOptions.classes: { export, decorators, name, excludeClasses, excludeName }`
+  picks classes of the scanned files; default is every exported,
   non-abstract class decorated with `@register` (`decorators` defaults to
   `["register"]`; `[]` requires none); positive criteria must all hold and then `excludeClasses` (exact
   names) and `excludeName` (glob) drop classes.
@@ -45,11 +54,12 @@ it.
   (scope-gated, e.g. `@perPage('a')` vs `@perPage('b')`).
 - Never edit a `*.bundle.ts` by hand — change the classes or the config and
   rerun `tic build`.
-- Unknown config fields are errors, at every level.
+- Unknown config fields are errors, except inside `compilerOptions`, where
+  TypeScript reports unknown compiler options.
 - Programmatic API: `build({ config, cwd, check })` (one config, one output),
   `findConfigFiles(dir)`, `run(argv, io)`, `loadConfig(file)`; every error the
   bundler raises on purpose is a `TicError` with a stable `code`
-  (`TicConfigError` = `INVALID_CONFIG`, `NamespaceNotFoundError`, `UsageError`,
+  (`TicConfigError` = `INVALID_CONFIG`, `UsageError`,
   `StaleBundlesError`, …).
 - Internals follow `release-monorepo-semantically` (ADR 0023): `createContainer(io)`
   in `lib/app.ts` is the composition root; `Application` resolves the controller

package/README.md

@@ -1,8 +1,8 @@
 # @ts-ioc-container/bundler
 
 **Bundles your dependencies into a single container module.** `tic build` scans
-what your tsconfig compiles — or the folders you name, by path or tsconfig alias —
-and generates one typed bundle that registers every class in them, ready for
+what your tsconfig compiles and generates one typed bundle that registers every
+class in it, ready for
 [`ts-ioc-container`](https://www.npmjs.com/package/ts-ioc-container):
 
 ```ts
@@ -14,8 +14,9 @@ Adding a service means writing the class — no hand-maintained list of
 TypeScript, generated at build time, so it type-checks, bundles and tree-shakes
 like code you wrote yourself.
 
-A bundle is configured like a tsconfig that `extends` yours: by default it
-takes the files your tsconfig compiles, and narrows or overrides them.
+A bundle config **is** a tsconfig that `extends` yours — `include`, `exclude`
+and `compilerOptions` mean what they mean to `tsc` — plus a few fields of the
+bundler's own.
 
 ## Install
 
@@ -73,28 +74,62 @@ or, in YAML, `<name>.bundle.yaml` / `<name>.bundle.yml` — same fields, same sc
 
 ```yaml
 # yaml-language-server: $schema=./node_modules/@ts-ioc-container/bundler/tic.schema.json
+extends: ./tsconfig.json
 output: src/di/app.bundle.ts
-files:
-  include: ['**/*.service.ts']
+include: [src/**/*.service.ts]
+compilerOptions:
+  classes:
+    decorators: [register, service]
 ```
 
 An empty YAML file is a bundle with every setting at its default. Describing
 one bundle in two formats (`app.bundle.json` and `app.bundle.yaml`) is an error.
 
-Every field is optional; `{}` is the zero-config bundle.
+Every field is optional; `{}` is the zero-config bundle. The tsconfig fields:
 
-| Field             | Default                                | Meaning                                                                                       |
-| ----------------- | -------------------------------------- | --------------------------------------------------------------------------------------------- |
-| `output`          | `<root>/<name>.bundle.ts`              | The bundle file; `<root>` as in [Zero config](#zero-config). Required without a tsconfig     |
-| `name`            | the config's stem, else `base`         | The bundle's name (`production.bundle.json` → `production`): names the default output and the class, `ProductionBundle` |
-| `tags`            | `[]`                                   | Tags associated with the bundle                                                               |
-| `extends`         | `./tsconfig.json` (may be absent)      | The tsconfig to build on: its file set, `paths` aliases and import extension; one named here must exist |
-| `importExtension` | `.js` under node16/nodenext, else none | Extension of generated imports                                                                |
-| `files`           | what the tsconfig compiles, no tests   | Which files are parsed — see [Selecting files](#selecting-files)                              |
-| `classes`         | exported classes with `@register`      | Which classes of a parsed file are registered — see [Selecting classes](#selecting-classes)   |
+| Field             | Default                           | Meaning                                                                                       |
+| ----------------- | --------------------------------- | --------------------------------------------------------------------------------------------- |
+| `extends`         | `./tsconfig.json` (may be absent) | The tsconfig this config extends; one named here must exist                                   |
+| `include`         | the extended tsconfig's           | Which files are scanned — see [Selecting files](#selecting-files)                              |
+| `exclude`         | the extended tsconfig's           | Which of them are left out — see [Selecting files](#selecting-files)                           |
+| `compilerOptions` | the extended tsconfig's           | tsconfig compiler options (`paths`, `rootDir`, `moduleResolution`, …) plus the bundler's below |
 
-An unknown field is an error, so a misspelled or removed option never goes
-unnoticed.
+The bundler's own fields, at the top level:
+
+| Field     | Default                        | Meaning                                                                                                                 |
+| --------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `baseUrl` | the config file's directory    | The base `include`, `exclude` and `output` resolve against, so they need not repeat a shared prefix such as `src`; also passed to TypeScript as `compilerOptions.baseUrl` |
+| `output`  | `<root>/<name>.bundle.ts`      | The bundle file; `<root>` as in [Zero config](#zero-config)                                                             |
+| `name`    | the config's stem, else `base` | The bundle's name (`production.bundle.json` → `production`): names the default output and the class, `ProductionBundle` |
+
+and under `compilerOptions`:
+
+| Option            | Default                                | Meaning                                                                                     |
+| ----------------- | -------------------------------------- | ------------------------------------------------------------------------------------------- |
+| `classes`         | exported classes with `@register`      | Which classes of a scanned file are registered — see [Selecting classes](#selecting-classes) |
+| `importExtension` | `.js` under node16/nodenext, else none | Extension of generated imports                                                              |
+
+An unknown top-level field is an error, so a misspelled or removed option never
+goes unnoticed. Every other compiler option is handed to TypeScript, which
+reports an unknown one (`Unknown compiler option 'pathz'. Did you mean 'paths'?`).
+
+`baseUrl` lets a config read in source terms instead of from the package root:
+
+```json
+{
+  "baseUrl": "src",
+  "output": ".generated/container.bundle.ts",
+  "exclude": [".generated/**", "db/testing/**"]
+}
+```
+
+writes `src/.generated/container.bundle.ts` from everything under `src/` except
+those two folders — with `baseUrl` set, an omitted `include` scans the whole
+`baseUrl` folder. `extends` still resolves against the config file.
+
+Generated imports read like the tsconfig you compile with: a file covered by a
+`paths` alias is imported in that alias form, a file under `baseUrl` in
+`baseUrl` form (`services/Logger`), and anything else relative to the bundle.
 
 ## Several bundles
 
@@ -114,7 +149,7 @@ Each one can extend its own tsconfig and select its own files:
 // production.bundle.json
 {
   "extends": "./tsconfig.production.json",
-  "files": { "exclude": ["**/*.development.ts", "**/*.test.ts", "**/*.spec.ts", "**/__tests__/**", "**/node_modules/**"] }
+  "exclude": ["src/**/*.development.ts"]
 }
 ```
 
@@ -123,80 +158,44 @@ It writes `src/production.bundle.ts`, exporting `ProductionBundle`.
 A bundle generated by one config is never registered by another, even when it
 sits in a folder the other scans.
 
-## Selection in two stages
+## Selecting files
 
-A bundle picks its registrations in two stages:
+The files a bundle scans are the files its config compiles, as `tsc` would see
+them: the extended tsconfig's `files` / `include` / `exclude` (following its own
+`extends`), with this config's `include` and `exclude` replacing the parent's —
+exactly as in a child tsconfig. Globs are relative to `baseUrl`, defaulting to
+the config file's directory.
 
-1. **`files`** — decided by path alone, before anything is read. Only files that
-   pass are parsed.
-2. **`classes`** — decided per class, on the files stage 1 let through.
+Test files (`*.spec.ts`, `*.test.ts`, their `.tsx` twins and `__tests__/`) and
+`node_modules/` are never scanned, whatever the tsconfig compiles, since test
+classes usually carry the same `@register` decorators as production ones. Files
+`tic build` generated are never input either.
 
 Parsing is where the time goes, so when your project names files by convention
-(`user.service.ts`, `user.repository.ts`), say so in `files.include` and the
-bundler never reads anything else:
+(`user.service.ts`, `user.repository.ts`), say so in `include` and the bundler
+never reads anything else:
 
 ```json
 {
   "output": "src/di/app.bundle.ts",
-  "files": {
-    "paths": ["@app/services"],
-    "include": ["**/*.service.ts", "**/*.repository.ts"]
-  },
-  "classes": { "decorators": ["register"] }
+  "include": ["src/**/*.service.ts", "src/**/*.repository.ts"],
+  "exclude": ["src/legacy/**"]
 }
 ```
 
-## Selecting files
-
-The candidates are the files the extended tsconfig compiles (its `files` /
-`include` / `exclude`, following its own `extends`). `paths` overrides that set
-the way a child tsconfig's `include` overrides its parent's: the bundle then scans
-those folders instead — relative to the config file (`./src/services`) or tsconfig
-`paths` aliases (`@app/services`), recursively unless an entry says
-`{ "path": "...", "recursive": false }`. Without a tsconfig, `paths` is required.
-
-A candidate is parsed when it matches **one of** `include` and **none of**
-`exclude`. Globs are relative to the config file and `/`-separated; `**` spans
-folders.
-
-| Rule      | Default                                   | Meaning                                                    |
-| --------- | ----------------------------------------- | ---------------------------------------------------------- |
-| `paths`   | what the tsconfig compiles                | Folders to scan instead                                    |
-| `include` | every source file                         | Globs a file must match one of, e.g. `"**/*.service.ts"`   |
-| `exclude` | test files, `__tests__/`, `node_modules/` | Globs of files never read; replaces the default when given |
-
-A non-empty `exclude` replaces the defaults, so restate the ones you still want:
-
-```json
-"files": {
-  "exclude": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/__tests__/**",
-    "**/node_modules/**",
-    "frontend/api/generated/**"
-  ]
-}
-```
-
-If it omits a default glob the build warns, since test classes usually carry
-the same `@register` decorators as production ones. `"exclude": []` deliberately
-parses everything, including tests. Giving only `include` keeps the default
-`exclude`, so `**/*.service.ts` still skips `user.service.spec.ts`.
-
 ## Selecting classes
 
-By default every exported, non-abstract class of a parsed file that carries
-`@register` is registered. `classes` changes that; a class must meet every
-criterion that is set:
+By default every exported, non-abstract class of a scanned file that carries
+`@register` is registered. `compilerOptions.classes` changes that; a class must
+meet every criterion that is set:
 
 ```json
-"classes": {
-  "export": "named",
-  "decorators": ["register", "repository"],
-  "name": "*Service"
+"compilerOptions": {
+  "classes": {
+    "export": "named",
+    "decorators": ["register", "repository"],
+    "name": "*Service"
+  }
 }
 ```
 
@@ -217,10 +216,12 @@ bind the same token, registration is last-wins and the stand-in silently wins.
 `excludeClasses` and `excludeName` drop a class right in the config:
 
 ```json
-"classes": {
-  "decorators": ["repository", "service"],
-  "excludeClasses": ["MockDashboardRepository"],
-  "excludeName": "*Fake"
+"compilerOptions": {
+  "classes": {
+    "decorators": ["repository", "service"],
+    "excludeClasses": ["MockDashboardRepository"],
+    "excludeName": "*Fake"
+  }
 }
 ```
 
@@ -235,7 +236,7 @@ are not resolved), so it can only be a heuristic:
 ```text
 tic: warning: app.bundle.json: decorator token "IDashboardRepositoryToken" is passed by
 HttpDashboardRepository, MockDashboardRepository; registration is last-wins,
-exclude one with classes.excludeClasses
+exclude one with compilerOptions.classes.excludeClasses
 ```
 
 Classes that are scope-gated are not last-wins, so they do not warn: when the
@@ -256,7 +257,6 @@ The output is plain TypeScript over the public `ts-ioc-container` API:
 ```ts
 // src/di/app.bundle.ts
 // Generated by `tic build` from ../../app.bundle.json. Do not edit by hand.
-// Paths: @app/services, @app/infra
 import { type IContainer, type IContainerModule, type IRegistration, Registration } from 'ts-ioc-container';
 import { MemoryLogger } from '@app/infra/logging/MemoryLogger';
 import { Greeter } from '@app/services/Greeter';

package/cjm/exceptions/DomainException.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaleBundlesError = exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.NamespaceNotFoundError = exports.TicConfigError = exports.TicError = void 0;
+exports.StaleBundlesError = exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.TicConfigError = exports.TicError = void 0;
 class TicError extends Error {
     code;
     constructor(code, message) {
@@ -16,12 +16,6 @@ class TicConfigError extends TicError {
     }
 }
 exports.TicConfigError = TicConfigError;
-class NamespaceNotFoundError extends TicError {
-    constructor(message) {
-        super('NAMESPACE_NOT_FOUND', message);
-    }
-}
-exports.NamespaceNotFoundError = NamespaceNotFoundError;
 class MissingCommandError extends TicError {
     constructor(usage) {
         super('MISSING_COMMAND', `missing command\n${usage}`);

package/cjm/features/build/BuildConfig.js

@@ -30,28 +30,6 @@ const strings = (what, minItems) => zod_1.z
     .meta({ type: 'array', items: { type: 'string', minLength: 1 }, ...(minItems > 0 && { minItems }) });
 const stringList = () => strings('an array of strings', 0);
 const nonEmptyStringList = () => strings('a non-empty array of strings', 1);
-const PATH_SCHEMA = zod_1.z.union([
-    nonEmptyString(),
-    zod_1.z.object({
-        path: nonEmptyString(),
-        recursive: zod_1.z.boolean(expected('a boolean')).default(true),
-    }, expected('a string or an object with "path"')),
-], expected('a string or an object with "path"'));
-const FILES_SCHEMA = zod_1.z
-    .strictObject({
-    paths: zod_1.z
-        .array(PATH_SCHEMA, expected('a non-empty array'))
-        .min(1, expected('a non-empty array'))
-        .optional()
-        .describe("Folders to scan instead of the extended tsconfig's file set: paths relative to this file (./src/services) or tsconfig paths aliases (@app/services). Required when there is no tsconfig to extend."),
-    include: nonEmptyStringList()
-        .optional()
-        .describe('Globs a file must match one of, e.g. ["**/*.service.ts", "**/*.repository.ts"]. Default: every source file.'),
-    exclude: stringList()
-        .default(exports.DEFAULT_EXCLUDE)
-        .describe('Globs of files never read. Replaces the default when given. A non-empty list that omits a default glob makes `tic build` warn.'),
-}, expected('an object'))
-    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. The candidates are what the extended tsconfig compiles, or the folders in `paths` when given. A candidate is parsed when it matches one of `include` and none of `exclude`. Globs are relative to this file. With a file naming convention, `include` keeps every other file unread.');
 const CLASSES_SCHEMA = zod_1.z
     .strictObject({
     export: zod_1.z
@@ -71,28 +49,47 @@ const CLASSES_SCHEMA = zod_1.z
         .optional()
         .describe('Glob the class name must NOT match, e.g. "*Mock". An anonymous default export is named after its file.'),
 }, expected('an object'))
-    .describe('Which classes of a parsed file are registered. A class is selected when it is exported, not abstract, and meets every criterion set here; by default that is every exported class decorated with @register.');
+    .describe('Which classes of a scanned file are registered. A class is selected when it is exported, not abstract, and meets every criterion set here; by default that is every exported class decorated with @register.');
+const COMPILER_OPTIONS_SCHEMA = zod_1.z
+    .looseObject({
+    importExtension: zod_1.z
+        .string(expected('a string'))
+        .optional()
+        .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
+    classes: CLASSES_SCHEMA.optional(),
+    paths: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.array(zod_1.z.string()))
+        .optional()
+        .describe('tsconfig `paths`: aliases the generated imports are written in.'),
+    rootDir: zod_1.z
+        .string()
+        .optional()
+        .describe('tsconfig `rootDir`: where the default output (<rootDir>/<name>.bundle.ts) goes.'),
+}, expected('an object'))
+    .describe("tsconfig `compilerOptions`, plus the bundler's own `importExtension` and `classes`. Every other option is handed to TypeScript on top of the extended tsconfig's, which validates it.");
+const tsconfigGlobs = (field, note = '') => stringList()
+    .optional()
+    .describe(`tsconfig \`${field}\`: replaces the extended tsconfig's. Relative to \`baseUrl\`.${note}`);
 exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
     $schema: zod_1.z.string().optional(),
+    extends: nonEmptyString()
+        .optional()
+        .meta({ default: exports.DEFAULT_EXTENDS })
+        .describe("The tsconfig this bundle extends, as a tsconfig's own `extends`: its file set, `paths` aliases and module resolution apply unless this file overrides them. Relative to this file. The default may be absent; a tsconfig named here must exist."),
+    baseUrl: nonEmptyString()
+        .optional()
+        .describe("The base folder this config's relative `include`, `exclude` and `output` resolve against, so they need not repeat a shared prefix such as `src`. Relative to this file; default this file's directory. Also handed to TypeScript as `compilerOptions.baseUrl` (unless that is set too), so generated imports use it."),
     output: nonEmptyString()
         .optional()
-        .describe("The bundle file (convention: *.bundle.ts). Default `<root>/<name>.bundle.ts`: <root> is the tsconfig's rootDir, else the common folder of the files it compiles. Required when there is no tsconfig to extend."),
+        .describe('The bundle file (convention: *.bundle.ts). Default `<root>/<name>.bundle.ts`: <root> is the compiled rootDir, else the common folder of the files compiled.'),
     name: zod_1.z
         .string(expected('letters, digits, "-" or "_", starting with a letter'))
         .regex(BUNDLE_NAME, expected('letters, digits, "-" or "_", starting with a letter'))
         .optional()
         .describe('The bundle\'s name: letters, digits, "-" and "_", starting with a letter. Default: this file\'s stem (production.bundle.json → production), else "base". It names the default output (production.bundle.ts) and the generated IContainerModule class (ProductionBundle).'),
-    tags: stringList().default([]).describe('Tags associated with the bundle.'),
-    extends: nonEmptyString()
-        .optional()
-        .meta({ default: exports.DEFAULT_EXTENDS })
-        .describe("The tsconfig this bundle builds on, like a tsconfig's own `extends`: what it compiles (`files` / `include` / `exclude`) is the bundle's file set unless `files.paths` overrides it, and its `paths` aliases and module resolution shape the generated imports. Relative to this file. The default may be absent; a tsconfig named here must exist."),
-    importExtension: zod_1.z
-        .string(expected('a string'))
-        .optional()
-        .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
-    files: FILES_SCHEMA.optional(),
-    classes: CLASSES_SCHEMA.optional(),
+    include: tsconfigGlobs('include', ' When `baseUrl` is set and this is omitted, the whole `baseUrl` folder (`.`) is scanned.'),
+    exclude: tsconfigGlobs('exclude'),
+    compilerOptions: COMPILER_OPTIONS_SCHEMA.optional(),
 }, expected('an object'));
 function formatPath(segments) {
     const formatted = segments
@@ -101,29 +98,13 @@ function formatPath(segments) {
         .replace(/^\./, '');
     return formatted || 'config';
 }
-function matchedBranch(issue) {
-    const typeMatched = issue.errors.filter((branch) => branch.every((inner) => inner.code !== 'invalid_type' || inner.path.length > 0));
-    return typeMatched.length === 1 ? typeMatched[0] : undefined;
-}
-function formatIssue(issue, prefix = []) {
-    const at = [...prefix, ...issue.path];
-    if (issue.code === 'unrecognized_keys')
-        return issue.keys.map((key) => `${formatPath([...at, key])}: unknown field`);
-    const branch = issue.code === 'invalid_union' ? matchedBranch(issue) : undefined;
-    if (branch)
-        return branch.flatMap((inner) => formatIssue(inner, at));
-    return [`${formatPath(at)}: ${issue.message}`];
+function formatIssue(issue) {
+    if (issue.code === 'unrecognized_keys') {
+        return issue.keys.map((key) => `${formatPath([...issue.path, key])}: unknown field`);
+    }
+    return [`${formatPath(issue.path)}: ${issue.message}`];
 }
 const formatIssues = (error) => error.issues.flatMap((issue) => formatIssue(issue)).join('; ');
-function toFileSelector(files) {
-    if (files === undefined)
-        return { exclude: exports.DEFAULT_EXCLUDE.map(glob_1.globToRegExp) };
-    return {
-        paths: files.paths?.map((entry) => (typeof entry === 'string' ? { path: entry, recursive: true } : entry)),
-        include: files.include?.map(glob_1.globToRegExp),
-        exclude: files.exclude.map(glob_1.globToRegExp),
-    };
-}
 function toClassSelector(classes) {
     if (classes === undefined)
         return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
@@ -135,18 +116,6 @@ function toClassSelector(classes) {
         excludeName: excludeName === undefined ? undefined : (0, glob_1.globToRegExp)(excludeName),
     };
 }
-function excludeWarnings(files) {
-    const exclude = files?.exclude ?? [];
-    if (exclude.length === 0)
-        return [];
-    const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
-    if (missing.length === 0)
-        return [];
-    return [
-        `files.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
-            `add them back`,
-    ];
-}
 exports.CONFIG_FILE_SUFFIXES = ['.bundle.json', '.bundle.yaml', '.bundle.yml'];
 const configSuffix = (file) => exports.CONFIG_FILE_SUFFIXES.find((suffix) => file.endsWith(suffix));
 exports.configSuffix = configSuffix;
@@ -164,20 +133,26 @@ function resolveConfig(content, file) {
     const result = exports.BUNDLE_CONFIG_SCHEMA.safeParse(content);
     if (!result.success)
         throw new DomainException_1.TicConfigError(formatIssues(result.error));
-    const { output, name, tags, extends: tsconfig, importExtension, files, classes } = result.data;
+    const { output, name, baseUrl, extends: tsconfig, include, exclude, compilerOptions = {} } = result.data;
+    const { importExtension, classes, ...tsCompilerOptions } = compilerOptions;
     const dir = node_path_1.default.dirname(file);
+    const base = baseUrl === undefined ? dir : node_path_1.default.resolve(dir, baseUrl);
+    const includeGlobs = include ?? (baseUrl === undefined ? undefined : ['.']);
+    const rebase = (globs) => globs?.map((glob) => (node_path_1.default.isAbsolute(glob) ? glob : (0, glob_1.toPosix)(node_path_1.default.relative(dir, node_path_1.default.resolve(base, glob))) || '.'));
     const bundleName = name ?? configStem(file) ?? exports.DEFAULT_BUNDLE_NAME;
     return {
         file,
         dir,
-        output: output === undefined ? undefined : node_path_1.default.resolve(dir, output),
+        output: output === undefined ? undefined : node_path_1.default.resolve(base, output),
         name: bundleName,
         className: toClassName(bundleName),
-        tags,
         tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
+        overrides: {
+            include: rebase(includeGlobs),
+            exclude: rebase(exclude),
+            compilerOptions: baseUrl === undefined ? tsCompilerOptions : { baseUrl, ...tsCompilerOptions },
+        },
         importExtension,
-        files: toFileSelector(files),
         classes: toClassSelector(classes),
-        warnings: excludeWarnings(files),
     };
 }

package/cjm/features/build/domain/ImportPaths.js

@@ -37,14 +37,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportPaths = void 0;
-const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const ts = __importStar(require("typescript"));
-const DomainException_1 = require("../../../exceptions/DomainException");
 const glob_1 = require("./glob");
 const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
-const isDirectory = (dir) => (0, node_fs_1.existsSync)(dir) && (0, node_fs_1.statSync)(dir).isDirectory();
-const isRelative = (spec) => spec.startsWith('.') || node_path_1.default.isAbsolute(spec);
 function splitWildcard(pattern) {
     const star = pattern.indexOf('*');
     return star === -1 ? undefined : [pattern.slice(0, star), pattern.slice(star + 1)];
@@ -52,6 +48,7 @@ function splitWildcard(pattern) {
 class ImportPaths {
     aliases;
     extension;
+    baseUrl;
     static fromOptions(options, tsconfigFile, importExtension) {
         const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = options;
         const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : node_path_1.default.dirname(tsconfigFile));
@@ -60,22 +57,12 @@ class ImportPaths {
             targets: targets.map((target) => (0, glob_1.toPosix)(node_path_1.default.resolve(base, target))),
         }));
         const nodeEsm = moduleResolution === ts.ModuleResolutionKind.Node16 || moduleResolution === ts.ModuleResolutionKind.NodeNext;
-        return new ImportPaths(aliases, importExtension ?? (nodeEsm ? '.js' : ''));
+        return new ImportPaths(aliases, importExtension ?? (nodeEsm ? '.js' : ''), baseUrl === undefined ? undefined : (0, glob_1.toPosix)(baseUrl));
     }
-    constructor(aliases, extension) {
+    constructor(aliases, extension, baseUrl) {
         this.aliases = aliases;
         this.extension = extension;
-    }
-    resolveNamespace(namespace, baseDir) {
-        const folder = node_path_1.default.resolve(baseDir, namespace);
-        if (isDirectory(folder))
-            return folder;
-        if (!isRelative(namespace)) {
-            const found = [namespace, `${namespace}/`].flatMap((spec) => this.aliasTargets(spec)).find(isDirectory);
-            if (found)
-                return node_path_1.default.normalize(found);
-        }
-        throw new DomainException_1.NamespaceNotFoundError(`namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`);
+        this.baseUrl = baseUrl;
     }
     specifier(fromFile, toFile) {
         const target = (0, glob_1.toPosix)(toFile);
@@ -83,9 +70,18 @@ class ImportPaths {
         const best = this.bestAlias(target, bare);
         if (best)
             return best.spec;
+        const fromBaseUrl = this.baseUrlSpecifier(bare);
+        if (fromBaseUrl)
+            return `${fromBaseUrl}${this.extension}`;
         const relative = (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(fromFile), bare));
         return `${relative.startsWith('.') ? relative : `./${relative}`}${this.extension}`;
     }
+    baseUrlSpecifier(bare) {
+        if (!this.baseUrl)
+            return undefined;
+        const prefix = this.baseUrl.endsWith('/') ? this.baseUrl : `${this.baseUrl}/`;
+        return bare.startsWith(prefix) ? bare.slice(prefix.length) : undefined;
+    }
     bestAlias(target, bare) {
         let best;
         for (const { pattern, targets } of this.aliases) {
@@ -97,18 +93,6 @@ class ImportPaths {
         }
         return best;
     }
-    aliasTargets(spec) {
-        return this.aliases.flatMap(({ pattern, targets }) => {
-            const wildcard = splitWildcard(pattern);
-            if (!wildcard)
-                return pattern === spec ? targets : [];
-            const [prefix, suffix] = wildcard;
-            if (!spec.startsWith(prefix) || !spec.endsWith(suffix) || spec.length < prefix.length + suffix.length)
-                return [];
-            const captured = spec.slice(prefix.length, spec.length - suffix.length);
-            return targets.map((target) => target.replace('*', captured));
-        });
-    }
     matchAlias(pattern, aliasTarget, file, bare) {
         const wildcard = splitWildcard(aliasTarget);
         if (!wildcard) {

package/cjm/features/build/domain/emit.js

@@ -7,7 +7,7 @@ const HandlebarsRenderService_1 = require("../../../services/HandlebarsRenderSer
 exports.GENERATED_HEADER = '// Generated by `tic build`';
 exports.BUNDLE_PROTOCOL = 'Bundle.ts.hbs';
 const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
-function bundleView({ name, configPath, paths, tsconfigPath, classes }) {
+function bundleView({ name, configPath, classes }) {
     const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
     const uniqueName = (wanted) => {
         let candidate = wanted;
@@ -27,7 +27,7 @@ function bundleView({ name, configPath, paths, tsconfigPath, classes }) {
             entry.named.push(binding === cls.exportName ? binding : `${cls.exportName} as ${binding}`);
         return binding;
     });
-    return { configPath, paths, tsconfigPath, name, imports: [...byFile.values()], registrations: bindings };
+    return { configPath, name, imports: [...byFile.values()], registrations: bindings };
 }
 function emitBundle(input) {
     return (0, HandlebarsRenderService_1.renderProtocol)(exports.BUNDLE_PROTOCOL, bundleView(input));