@ts-ioc-container/bundler 5.1.0 → 7.0.0

package/AGENTS.md

@@ -7,10 +7,11 @@ nothing here runs inside the container, and the core package is not changed by
 it.
 
 - The CLI is `ts-ioc-container`, with `tic` as a shortcut (both `bin` entries,
-  same program): `tic build [<config>]` is a Unix filter. It reads the config
-  file `<config>` (JSON for `.json`, YAML for `.yaml` / `.yml`) — or, without
-  one or with `-`, config text from stdin (parsed as YAML, which covers JSON) —
-  and prints the bundle to **stdout**; it writes nothing. Saving is the shell's
+  same program): `tic build [<config>...]` is a Unix filter. It reads the config
+  file `<config>` (JSON for `.json`, YAML for `.yaml` / `.yml`) — several are
+  merged left to right into one bundle — or, without one or with `-`, config
+  text from stdin (parsed as YAML, which covers JSON; never merged) — and
+  prints the bundle to **stdout**; it writes nothing. Saving is the shell's
   job: `tic build app.bundle.json > src/di/app.bundle.ts`,
   `cat dev.bundle.json | tic build > src/di/dev.bundle.ts`; CI checks with
   `tic build app.bundle.json | diff - src/di/app.bundle.ts`. Warnings and errors
@@ -19,21 +20,22 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
 - Every import in a bundle is written through a tsconfig `paths` alias, so the
   bundle works wherever it is saved; a selected class no alias covers fails the
   build naming its file. There are no relative imports.
-- Config fields (schema: `tic.schema.json`), flat: `glob` with `glob.glob`
-  required; `className`, `name`, `tsconfig`, `importExtension` optional.
+- Config fields (schema: `tic.schema.json`), flat: `paths` with `paths.include`
+  required; `match`, `name`, `tsconfig`, `importExtension` optional.
   Relative paths resolve against the config file; for piped text, against the
   working directory. `name` defaults to the file's stem (`prod.bundle.json` →
   `prod`) and is required for piped text or a file named otherwise; the class
   is `toClassName(name)` — `ProdBundle`.
 - A config does **not** extend its tsconfig and never takes files from it. The
   `tsconfig` field (default `./tsconfig.json`, may be absent; one named
-  explicitly must exist) only supplies `paths` aliases — which `glob.glob` may
+  explicitly must exist) only supplies `paths` aliases — which `paths.include` may
   name and generated imports are written in (most specific alias, else a
   relative path) — and the module resolution that sets the import extension.
-- Selection has two stages, both shaped `{ glob, exclude }`, and both taking
-  a string or a list as a shortcut for their `glob`. `glob: { glob, exclude }`
-  decides by path which files are read and parsed at all (`glob: ./src` /
-  `glob: [./a, ./b]` = `glob.glob`). `glob.glob` (required: one folder or a
+- Selection has two stages, `paths: { include, exclude }` and
+  `match: { ..., glob, exclude }`. `paths` is always an object (a string
+  or a list in its place is an error); `match` also takes a string or a
+  list as a shortcut for `match.glob`. `paths` decides by path which files
+  are read and parsed at all. `paths.include` (required: one folder or a
   non-empty list) names the folders scanned, always with their sub-folders —
   relative to the config file (`./src/services`) or tsconfig aliases
   (`@app/services`); there is no `{ path, recursive }` form. A file in them is parsed unless it matches one
@@ -41,9 +43,9 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   with a tsconfig alias — `@generated/**`, or `@generated` for the whole folder;
   catch-all `"*"` aliases are skipped; default: test files, `__tests__/`,
   `node_modules/`; a non-empty value replaces it, and the build warns if it drops
-  a default). There is no `include`. Files `tic build` generated are never input.
-- `className: { export, decorators, glob, exclude }` (or `className: '*Service'`
-  / `['*Service', '*Repository']` = `className.glob`, default `export` and
+  a default). Files `tic build` generated are never input.
+- `match: { export, decorators, glob, exclude }` (or `match: '*Service'`
+  / `['*Service', '*Repository']` = `match.glob`, default `export` and
   `decorators`) then picks classes of the parsed files; default is every exported,
   non-abstract class decorated with `@register` (`decorators` defaults to
   `["register"]`; `[]` requires none); positive criteria must all hold — `glob` is one glob
@@ -53,12 +55,23 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   two selected classes pass the same plain-identifier first decorator argument (a
   same-token heuristic), unless a decorator they share has differing arguments
   (scope-gated, e.g. `@perPage('a')` vs `@perPage('b')`).
+- Several configs merge like webpack-merge (`mergeConfigs`):
+  `tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts`.
+  Objects merge field by field; the list fields `paths.include`,
+  `paths.exclude`, `match.glob`, `match.exclude` and `match.decorators`
+  concatenate without duplicates (a later config only adds); any other value
+  set later replaces an earlier one; the `match` shorthand merges as
+  `match.glob`. Each file is validated alone (`BUNDLE_CONFIG_FILE_SCHEMA`:
+  `paths` optional; errors name the file), the merged result as one config
+  (`BUNDLE_CONFIG_SCHEMA`). Defaults apply to the merged config only. The last
+  file names the bundle unless one sets `name`; all must sit in one folder.
 - 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.
-- Programmatic API: `build({ config, cwd })` or `build({ text, cwd })` returns
+- Programmatic API: `build({ config, cwd })` (`config`: a file or a list merged
+  left to right) or `build({ text, cwd })` returns
   `{ content, bundle, registrations, warnings }` and writes nothing;
-  `loadConfig(file)`, `run(argv, io)` (`io.stdin` backs piped configs); every error the
+  `loadConfig(file | files)`, `run(argv, io)` (`io.stdin` backs piped configs); every error the
   bundler raises on purpose is a `TicError` with a stable `code`
   (`TicConfigError` = `INVALID_CONFIG`, `NamespaceNotFoundError`, `UsageError`,
   …).
@@ -71,4 +84,5 @@ IContainerModule`, applied with `container.useModule(new AppBundle())`.
   services behind tokens (`IBundleBuilderKey`, `ITicConfigServiceKey`, …); pure
   logic in `lib/features/build/domain/`. A new command is a controller plus a module.
 - The config schema is `BUNDLE_CONFIG_SCHEMA` (zod); `tic.schema.json` is generated
-  from it with `pnpm run generate:schema` — never edit it by hand.
+  from its per-file variant `BUNDLE_CONFIG_FILE_SCHEMA` with `pnpm run generate:schema`
+  — never edit it by hand.

package/README.md

@@ -33,11 +33,12 @@ below use the shortcut.
 ## Build
 
 ```bash
-tic build [<config>]
+tic build [<config>...]
 ```
 
 `tic build` prints the bundle to **stdout** and writes nothing. `<config>` is a
-config file — JSON for `.json`, YAML for `.yaml` / `.yml`. Without it (or with
+config file — JSON for `.json`, YAML for `.yaml` / `.yml`. Several are
+[merged](#merging-configs) left to right into one bundle. Without one (or with
 `-`) the config is read from **stdin**. Warnings and errors go to stderr, so
 they never end up in the bundle.
 
@@ -46,6 +47,9 @@ they never end up in the bundle.
 tic build app.bundle.json > src/di/app.bundle.ts
 tic build prod.bundle.yml > src/di/prod.bundle.ts
 
+# several configs merged into one bundle, like webpack-merge
+tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts
+
 # the config piped in — it has no file name, so it sets `name` ("name": "dev")
 cat dev.bundle.json | tic build > src/di/dev.bundle.ts
 tic build < dev.bundle.yml > src/di/dev.bundle.ts
@@ -55,7 +59,7 @@ tic build app.bundle.json | npx prettier --stdin-filepath app.bundle.ts > src/di
 cat dev.bundle.json | tic build | tee src/di/dev.bundle.ts
 
 # a config built on the fly
-printf 'name: app\nglob: "@app/services"\n' | tic build > src/di/app.bundle.ts
+printf 'name: app\npaths:\n  include: "@app/services"\n' | tic build > src/di/app.bundle.ts
 jq '.name = "admin"' app.bundle.json | tic build > src/di/admin.bundle.ts
 
 # CI: is the saved bundle current?
@@ -69,8 +73,9 @@ covers is an error naming its file; add a `paths` entry for its folder.
 
 Relative paths in a config file resolve against the file; in a piped config,
 against the working directory. The bundle is named after the config file —
-`prod.bundle.json` exports `ProdBundle` — unless the config sets `name`, which a
-piped config, or a file not named `<name>.bundle.json`, must.
+`prod.bundle.json` exports `ProdBundle`; of several merged, after the last —
+unless the config sets `name`, which a piped config, or a file not named
+`<name>.bundle.json`, must.
 
 ## Configure
 
@@ -80,19 +85,22 @@ registers. Point your editor at the schema:
 ```json
 {
   "$schema": "./node_modules/@ts-ioc-container/bundler/tic.schema.json",
-  "glob": ["@app/services", "./src/infra"]
+  "paths": { "include": ["@app/services", "./src/infra"] }
 }
 ```
 
 ```yaml
 # yaml-language-server: $schema=./node_modules/@ts-ioc-container/bundler/tic.schema.json
-glob: ['@app/services', ./src/infra]
+paths:
+  include:
+    - '@app/services'
+    - ./src/infra
 ```
 
 | Field             | Default                                       | Meaning                                                                                                     |
 | ----------------- | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `glob`            | — (required)                                  | Which files are parsed — see [Selecting files](#selecting-files)                                            |
-| `className`       | exported classes with `@register`             | Which classes of a parsed file are registered — see [Selecting classes](#selecting-classes)                 |
+| `paths`           | — (required)                                  | Which files are parsed — see [Selecting files](#selecting-files). Merged configs need it in one of them     |
+| `match`           | exported classes with `@register`             | Which classes of a parsed file are registered — see [Selecting classes](#selecting-classes)                 |
 | `name`            | the config file's (`app.bundle.json` → `app`) | The bundle's name: names the class, `AppBundle`. Required for a piped config or a file named otherwise      |
 | `tsconfig`        | `./tsconfig.json`                             | Source of the `paths` aliases every import is written through, and of the import extension — never of files |
 | `importExtension` | `.js` under node16/nodenext, else none        | Extension of generated imports                                                                              |
@@ -102,30 +110,38 @@ unnoticed.
 
 ## Several bundles
 
-Need more than one bundle — per environment, per app? Keep a config per bundle
-and build each one:
+Need more than one bundle — per environment, per app? Keep what they share in
+one config, what each adds in another, and build each environment from both:
 
 ```bash
 for env in prod dev test; do
-  tic build "$env.bundle.yml" > "src/di/$env.bundle.ts"
+  tic build common.bundle.yml "$env.bundle.yml" > "src/di/$env.bundle.ts"
 done
 ```
 
 ```json
 {
   "scripts": {
-    "bundle": "tic build app.bundle.json > src/di/app.bundle.ts",
-    "bundle:check": "tic build app.bundle.json | diff - src/di/app.bundle.ts"
+    "bundle": "tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts",
+    "bundle:check": "tic build common.bundle.yml prod.bundle.yml | diff - src/di/prod.bundle.ts"
   }
 }
 ```
 
-Each config selects its own files and classes:
+```yaml
+# common.bundle.yml: what every environment registers
+paths:
+  include:
+    - '@app/services'
+```
+
+Each environment's config adds its own files and classes:
 
 ```yaml
-# prod.bundle.yml: services + adapters, minus dev-only *.dev.ts files
-glob:
-  glob: ['@app/services', ./src/infra]
+# prod.bundle.yml: + the adapters, minus dev-only *.dev.ts files
+paths:
+  include:
+    - ./src/infra
   exclude:
     - '**/*.dev.ts'
     - '**/*.spec.ts'
@@ -137,12 +153,39 @@ glob:
 ```
 
 ```yaml
-# dev.bundle.yml: the *.dev.ts logger replaces the production one, dropped by class name
-glob: ['@app/services', ./src/infra]
-className:
+# dev.bundle.yml: + the adapters; the *.dev.ts logger replaces the production one, dropped by class name
+paths:
+  include:
+    - ./src/infra
+match:
   exclude: JsonLogger
 ```
 
+`tic build common.bundle.yml prod.bundle.yml` then scans `@app/services` and
+`./src/infra`, and exports `ProdBundle`.
+
+### Merging configs
+
+`tic build a.bundle.yml b.bundle.yml c.bundle.yml` merges the configs left to
+right, the way webpack-merge merges webpack configs:
+
+- objects merge field by field;
+- list fields — `paths.include`, `paths.exclude`, `match.glob`, `match.exclude`,
+  `match.decorators` — concatenate in order, without duplicates (one folder or
+  glob counts as a list of one), so a later config can only add to them;
+- any other value (`name`, `tsconfig`, `importExtension`, `match.export`) set
+  by a later config replaces an earlier one;
+- the `match` shorthand merges as `match.glob`.
+
+Each config is validated on its own — an error names the file it is in — so a
+shared config may leave `paths` out; the merged config must have
+`paths.include`. Defaults apply to the merged config only: a `paths.exclude` in
+any of them replaces the default excludes, as it does in a single config, so
+list the defaults in the shared config to keep them. The bundle is named after
+the last config, unless one sets `name` — so leave `name` out of a shared
+config. Merged configs must sit in one folder, which their relative paths
+resolve against. A piped config (`-`) is never merged.
+
 A saved bundle is never registered by another build, even when it sits in a
 folder that build scans.
 
@@ -150,51 +193,47 @@ folder that build scans.
 
 A bundle picks its registrations in two stages:
 
-1. **`glob`** — decided by path alone, before anything is read. Only files that
+1. **`paths`** — decided by path alone, before anything is read. Only files that
    pass are parsed.
-2. **`className`** — decided per class, on the files stage 1 let through.
+2. **`match`** — decided per class, on the files stage 1 let through.
 
-Parsing is where the time goes, so point `glob` at the folders that hold your
+Parsing is where the time goes, so point `paths` at the folders that hold your
 registrations, and `exclude` what they should not contribute:
 
 ```json
 {
-  "glob": {
-    "glob": "@app/services",
+  "paths": {
+    "include": "@app/services",
     "exclude": ["**/*.spec.ts", "**/*.test.ts", "**/__tests__/**", "**/node_modules/**", "**/legacy/**"]
   },
-  "className": { "decorators": ["register"] }
+  "match": { "decorators": ["register"] }
 }
 ```
 
 ## Selecting files
 
-`glob` takes the same shape as [`className`](#selecting-classes):
-`{ glob, exclude }`. `glob.glob` names the folders a bundle's files come from,
+`paths` is `{ include, exclude }`. `paths.include` names the folders a bundle's files come from,
 and the only ones: what your tsconfig compiles plays no part. It is one folder
 or a list, each relative to the config file (`./src/services`) or a tsconfig
 `paths` alias (`@app/services`, for a `"@app/*": ["./src/*"]` alias), and
-always scanned with its sub-folders.
-
-When the default `exclude` is all you need, `glob` itself can be the folders —
-a string or a list is a shortcut for `glob.glob`:
+always scanned with its sub-folders. `paths` is always an object — a folder or a
+list in place of it is an error — and `exclude` may be left out to keep the default:
 
 ```yaml
-glob: ./src/services # = glob: { glob: ./src/services }
+paths:
+  include: ./src/services # one folder
 ```
 
 ```yaml
-glob: ['@app/services', ./src/infra] # = glob: { glob: ['@app/services', ./src/infra] }
-```
-
-```yaml
-glob: # the object form, for a custom exclude
-  glob: ['@app/services', ./src/infra]
-  exclude: '**/*.dev.ts'
+paths:
+  include: # or a list
+    - '@app/services'
+    - ./src/infra
+  exclude: '**/*.dev.ts' # a custom exclude
 ```
 
 Within them, a file is parsed unless it matches **one of** `exclude`. Globs are relative to the config file and `/`-separated; `**`
-spans folders. Like a folder in `glob.glob`, an exclude glob may start with a
+spans folders. Like a folder in `paths.include`, an exclude glob may start with a
 tsconfig `paths` alias: with `"@generated/*": ["./src/.generated/*"]`,
 `@generated/**` reads `src/.generated/**`, and `@generated` (or `@generated/`)
 drops the whole folder. A catch-all `"*"` alias is never applied, so plain globs
@@ -202,13 +241,13 @@ such as `**/*.spec.ts` keep their meaning.
 
 | Rule      | Default                                   | Meaning                                                                                                          |
 | --------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| `glob`    | — (required)                              | Folder, or folders, to scan                                                                                      |
+| `include` | — (required)                              | Folder, or folders, to scan                                                                                      |
 | `exclude` | test files, `__tests__/`, `node_modules/` | A glob, or a list of them, of files never read; may start with a tsconfig alias; replaces the default when given |
 
 A non-empty `exclude` replaces the defaults, so restate the ones you still want:
 
 ```json
-"glob": {
+"paths": {
   "exclude": [
     "**/*.spec.ts",
     "**/*.test.ts",
@@ -229,11 +268,11 @@ parses everything, including tests.
 ## Selecting classes
 
 By default every exported, non-abstract class of a parsed file that carries
-`@register` is registered. `className` changes that; a class must meet every
+`@register` is registered. `match` changes that; a class must meet every
 criterion that is set:
 
 ```json
-"className": {
+"match": {
   "export": "named",
   "decorators": ["register", "repository"],
   "glob": "*Service"
@@ -257,7 +296,7 @@ bind the same token, registration is last-wins and the stand-in silently wins.
 matches only itself, so one list drops a class by name and a family by pattern:
 
 ```json
-"className": {
+"match": {
   "decorators": ["repository", "service"],
   "exclude": ["MockDashboardRepository", "*Fake"]
 }
@@ -266,18 +305,18 @@ matches only itself, so one list drops a class by name and a family by pattern:
 `exclude` applies after every other criterion, so it combines with
 `decorators` and `glob` freely.
 
-### The `className` shortcut
+### The `match` shortcut
 
-When the default `export` and `decorators` are all you need, `className`
+When the default `export` and `decorators` are all you need, `match`
 itself can be the class-name globs — a string or a list is a shortcut for
-`className.glob`, just as on `glob`:
+`match.glob`:
 
 ```yaml
-className: '*Service' # = className: { glob: '*Service' }
+match: '*Service' # = match: { glob: '*Service' }
 ```
 
 ```yaml
-className: ['*Service', '*Repository'] # = className: { glob: ['*Service', '*Repository'] }
+match: ['*Service', '*Repository'] # = match: { glob: ['*Service', '*Repository'] }
 ```
 
 As a safety net, the build warns when two selected classes pass the same
@@ -288,7 +327,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 className.exclude
+exclude one with match.exclude
 ```
 
 Classes that are scope-gated are not last-wins, so they do not warn: when the
@@ -304,15 +343,14 @@ The output is plain TypeScript over the public `ts-ioc-container` API:
 // src/di/app.bundle.ts
 // Generated by `tic build`. Do not edit by hand.
 // Paths: @app/services, @app/infra
-import { type IContainer, type IContainerModule, type IRegistration, Registration } from 'ts-ioc-container';
+import { type IContainer, type IContainerModule, Registration } from 'ts-ioc-container';
 import { MemoryLogger } from '@app/infra/logging/MemoryLogger';
 import { Greeter } from '@app/services/Greeter';
 
-export const registrations: IRegistration[] = [Registration.fromClass(MemoryLogger), Registration.fromClass(Greeter)];
-
 export class AppBundle implements IContainerModule {
   applyTo(container: IContainer): void {
-    for (const registration of registrations) container.addRegistration(registration);
+    container.addRegistration(Registration.fromClass(MemoryLogger));
+    container.addRegistration(Registration.fromClass(Greeter));
   }
 }
 ```
@@ -341,5 +379,5 @@ const { content, warnings } = build({ config: 'app.bundle.json' });
 writeFileSync('src/di/app.bundle.ts', content);
 
 // or config text, as `tic build` reads from stdin
-build({ text: 'name: app\nglob:\n  glob: ["@app/services"]\n' });
+build({ text: 'name: app\npaths:\n  include: ["@app/services"]\n' });
 ```

package/cjm/app.js

@@ -34,6 +34,6 @@ function run(argv, io = (0, CliIo_1.processIo)()) {
 function build({ cwd = process.cwd(), ...request }) {
     return withContainer({ ...(0, CliIo_1.processIo)(), cwd }, (container) => BundleBuilder_1.IBundleBuilderKey.resolve(container).build(request));
 }
-function loadConfig(file) {
-    return withContainer((0, CliIo_1.processIo)(), (container) => TicConfigService_1.ITicConfigServiceKey.resolve(container).load(file));
+function loadConfig(files) {
+    return withContainer((0, CliIo_1.processIo)(), (container) => TicConfigService_1.ITicConfigServiceKey.resolve(container).load(files));
 }

package/cjm/cli/usage.js

@@ -6,10 +6,11 @@ exports.USAGE = [
     '       tic is a shortcut for ts-ioc-container',
     '',
     'Commands:',
-    '  ts-ioc-container build [<config>]   print the bundle a config file (.json, .yaml, .yml) describes;',
-    '                                     without one (or with -), read the config from stdin',
-    '  ts-ioc-container help               show this help',
-    '  ts-ioc-container version            show the version',
+    '  ts-ioc-container build [<config>...]   print the bundle a config file (.json, .yaml, .yml) describes;',
+    '                                        several are merged left to right into one bundle;',
+    '                                        without one (or with -), read the config from stdin',
+    '  ts-ioc-container help                  show this help',
+    '  ts-ioc-container version               show the version',
     '',
     'Options:',
     '  -h, --help      show this help',
@@ -17,6 +18,7 @@ exports.USAGE = [
     '',
     'The bundle goes to stdout and warnings to stderr; saving it is up to you:',
     '  tic build app.bundle.json > src/di/app.bundle.ts',
+    '  tic build common.bundle.yml prod.bundle.yml > src/di/prod.bundle.ts   # merged left to right',
     '  cat app.bundle.yml | tic build > src/di/app.bundle.ts     # config from stdin (must set name)',
     '  tic build app.bundle.json | diff - src/di/app.bundle.ts   # CI: is it current?',
 ].join('\n');

package/cjm/features/build/BuildConfig.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configFormat = exports.STDIN = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_TSCONFIG = void 0;
+exports.configFormat = exports.STDIN = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_FILE_SCHEMA = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_TSCONFIG = void 0;
 exports.parseConfig = parseConfig;
 exports.toClassName = toClassName;
+exports.mergeConfigs = mergeConfigs;
 exports.resolveConfig = resolveConfig;
 const node_path_1 = __importDefault(require("node:path"));
 const yaml_1 = require("yaml");
@@ -42,21 +43,17 @@ const globs = () => globList('a glob or a non-empty array of globs', 1);
 const toList = (value) => (Array.isArray(value) ? value : [value]);
 const toGlobs = (value) => value === undefined ? undefined : toList(value).map(glob_1.globToRegExp);
 const FOLDERS_SCHEMA = zod_1.z.array(nonEmptyString(), expected('a non-empty array')).min(1, expected('a non-empty array'));
-const GLOB_OBJECT_SCHEMA = zod_1.z.strictObject({
-    glob: zod_1.z
+const PATHS_DESCRIPTION = 'Which files this bundle reads and parses — decided by path alone, before parsing. `include` names the folders the files come from; within them a file is parsed unless it matches one of `exclude`. Globs are relative to the config file.';
+const PATHS_SCHEMA = zod_1.z
+    .strictObject({
+    include: zod_1.z
         .union([nonEmptyString(), FOLDERS_SCHEMA], expected('a folder or a non-empty array of folders'))
         .describe('Folder, or folders, to scan, sub-folders included: paths relative to the config file (./src/services) or tsconfig paths aliases (@app/services).'),
     exclude: globList('a glob or an array of globs', 0)
         .default(exports.DEFAULT_EXCLUDE)
         .describe('Glob, or globs, of files never read, relative to the config file or starting with a tsconfig paths alias (@generated/**, or @generated for the whole folder). Replaces the default when given. A non-empty value that omits a default glob makes `tic build` warn.'),
-}, expected('an object'));
-const GLOB_SCHEMA = zod_1.z
-    .union([
-    nonEmptyString().describe('One folder to scan, with the default exclude: shorthand for { "glob": [...] }.'),
-    FOLDERS_SCHEMA.describe('Folders to scan, with the default exclude: shorthand for { "glob": [...] }.'),
-    GLOB_OBJECT_SCHEMA,
-], expected('a folder, a non-empty array of folders or an object with "glob"'))
-    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. `glob` names the folders the files come from; within them a file is parsed unless it matches one of `exclude`. Globs are relative to the config file. A folder, or a list of folders, is shorthand for { "glob": [...] }.');
+}, expected('an object with "include"'))
+    .describe(PATHS_DESCRIPTION);
 const CLASS_OBJECT_SCHEMA = zod_1.z.strictObject({
     export: zod_1.z
         .enum(['any', 'named', 'default'], expected('"any", "named" or "default"'))
@@ -92,14 +89,17 @@ exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
     tsconfig: nonEmptyString()
         .optional()
         .meta({ default: exports.DEFAULT_TSCONFIG })
-        .describe('The tsconfig whose `paths` aliases glob.glob may name and generated imports are written in, and whose module resolution sets the import extension. It adds no files: the bundle scans glob.glob alone. Relative to the config file. The default may be absent; a tsconfig named here must exist.'),
+        .describe('The tsconfig whose `paths` aliases paths.include may name and generated imports are written in, and whose module resolution sets the import extension. It adds no files: the bundle scans paths.include alone. Relative to the config 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.'),
-    glob: GLOB_SCHEMA,
-    className: CLASSES_SCHEMA.optional(),
+    paths: PATHS_SCHEMA,
+    match: CLASSES_SCHEMA.optional(),
 }, expected('an object'));
+exports.BUNDLE_CONFIG_FILE_SCHEMA = exports.BUNDLE_CONFIG_SCHEMA.extend({
+    paths: PATHS_SCHEMA.partial().optional().describe(`${PATHS_DESCRIPTION} Required in the merged config.`),
+});
 function formatPath(segments) {
     const formatted = segments
         .map((segment) => (typeof segment === 'number' ? `[${segment}]` : `.${String(segment)}`))
@@ -121,24 +121,19 @@ function formatIssue(issue, prefix = []) {
     return [`${formatPath(at)}: ${issue.message}`];
 }
 const formatIssues = (error) => error.issues.flatMap((issue) => formatIssue(issue)).join('; ');
-function toGlobObject(glob) {
-    if (typeof glob === 'string' || Array.isArray(glob))
-        return { glob, exclude: exports.DEFAULT_EXCLUDE };
-    return glob;
-}
-function toGlobSelector(glob) {
+function toPathSelector(paths) {
     return {
-        glob: toList(glob.glob),
-        exclude: toList(glob.exclude),
+        include: toList(paths.include),
+        exclude: toList(paths.exclude),
     };
 }
-function toClassSelector(className) {
-    if (className === undefined)
+function toClassSelector(match) {
+    if (match === undefined)
         return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
-    if (typeof className === 'string' || Array.isArray(className)) {
-        return { export: 'any', decorators: exports.DEFAULT_DECORATORS, glob: toGlobs(className) };
+    if (typeof match === 'string' || Array.isArray(match)) {
+        return { export: 'any', decorators: exports.DEFAULT_DECORATORS, glob: toGlobs(match) };
     }
-    const { decorators, glob, exclude, ...rest } = className;
+    const { decorators, glob, exclude, ...rest } = match;
     return {
         ...rest,
         decorators: decorators.length > 0 ? decorators : undefined,
@@ -146,15 +141,15 @@ function toClassSelector(className) {
         exclude: toGlobs(exclude),
     };
 }
-function excludeWarnings(glob) {
-    const exclude = toList(glob.exclude);
+function excludeWarnings(paths) {
+    const exclude = toList(paths.exclude);
     if (exclude.length === 0)
         return [];
     const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
     if (missing.length === 0)
         return [];
     return [
-        `glob.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
+        `paths.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
             `add them back`,
     ];
 }
@@ -180,11 +175,38 @@ function toClassName(name) {
     const words = name.split(/[-_]+/).filter(Boolean);
     return `${words.map((word) => word[0].toUpperCase() + word.slice(1)).join('')}Bundle`;
 }
+const LIST_FIELDS = new Set(['paths.include', 'paths.exclude', 'match.decorators', 'match.glob', 'match.exclude']);
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function mergeInto(base, next, at = '') {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(next)) {
+        const field = `${at}${key}`;
+        const previous = merged[key];
+        if (LIST_FIELDS.has(field)) {
+            merged[key] = [
+                ...new Set([...toList((previous ?? [])), ...toList(value)]),
+            ];
+        }
+        else {
+            merged[key] = isObject(previous) && isObject(value) ? mergeInto(previous, value, `${field}.`) : value;
+        }
+    }
+    return merged;
+}
+const expandMatch = ({ match, ...rest }) => match === undefined ? rest : { ...rest, match: isObject(match) ? match : { glob: match } };
+function mergeConfigs(configs) {
+    return configs.reduce((merged, { file, content }) => {
+        const result = exports.BUNDLE_CONFIG_FILE_SCHEMA.safeParse(content);
+        if (!result.success)
+            throw new DomainException_1.TicConfigError(`${node_path_1.default.basename(file)}: ${formatIssues(result.error)}`);
+        return mergeInto(merged, expandMatch(content));
+    }, {});
+}
 function resolveConfig(content, file) {
     const result = exports.BUNDLE_CONFIG_SCHEMA.safeParse(content);
     if (!result.success)
         throw new DomainException_1.TicConfigError(formatIssues(result.error));
-    const { name, tsconfig, importExtension, glob, className } = result.data;
+    const { name, tsconfig, importExtension, paths, match } = result.data;
     const bundleName = name ?? configStem(file);
     if (bundleName === undefined) {
         throw new DomainException_1.TicConfigError(node_path_1.default.basename(file) === exports.STDIN
@@ -192,7 +214,6 @@ function resolveConfig(content, file) {
             : `name: required when the config file is not named <name>${exports.CONFIG_FILE_SUFFIXES.join(' / ')}`);
     }
     const dir = node_path_1.default.dirname(file);
-    const globObject = toGlobObject(glob);
     return {
         file,
         dir,
@@ -200,8 +221,8 @@ function resolveConfig(content, file) {
         bundleClassName: toClassName(bundleName),
         tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_TSCONFIG), required: tsconfig !== undefined },
         importExtension,
-        glob: toGlobSelector(globObject),
-        className: toClassSelector(className),
-        warnings: excludeWarnings(globObject),
+        paths: toPathSelector(paths),
+        match: toClassSelector(match),
+        warnings: excludeWarnings(paths),
     };
 }