@ts-ioc-container/bundler 2.0.0 → 3.0.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 `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,23 @@ 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 and module resolution shape the generated imports (most
+  specific alias, else a relative path). Every compiler option but `classes`
+  and `importExtension` goes to TypeScript, which reports unknown ones.
+  `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,7 +46,19 @@ 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)`; errors are `TicConfigError` / `NamespaceNotFoundError`
-  (both `TicError`).
+  `findConfigFiles(dir)`, `run(argv, io)`, `loadConfig(file)`; every error the
+  bundler raises on purpose is a `TicError` with a stable `code`
+  (`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
+  registered under the command name (`@register('build')`) and runs its
+  `@onDefault(invoke)` action, which parses its own options with
+  `@inject(pipe(commandArgs, parseOptions(spec), validate(SCHEMA)))`. Work lives in
+  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.

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,43 @@ 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                                                                                                                 |
+| -------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `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'?`).
 
 ## Several bundles
 
@@ -114,7 +130,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 +139,43 @@ 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 the config file.
 
-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"] }
-}
-```
-
-## 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/**"
-  ]
+  "include": ["src/**/*.service.ts", "src/**/*.repository.ts"],
+  "exclude": ["src/legacy/**"]
 }
 ```
 
-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 +196,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 +216,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 +237,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/app.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainer = createContainer;
+exports.run = run;
+exports.build = build;
+exports.loadConfig = loadConfig;
+require("reflect-metadata");
+const ts_ioc_container_1 = require("ts-ioc-container");
+const Application_1 = require("./cli/Application");
+const CliIo_1 = require("./domain/CliIo");
+const BuildModule_1 = require("./features/build/BuildModule");
+const BundleBuilder_1 = require("./features/build/services/BundleBuilder");
+const TicConfigService_1 = require("./features/build/services/TicConfigService");
+const HelpModule_1 = require("./features/help/HelpModule");
+const CommonModule_1 = require("./modules/CommonModule");
+function createContainer(io = (0, CliIo_1.processIo)()) {
+    return new ts_ioc_container_1.Container({ tags: ['root'] })
+        .useModule(new CommonModule_1.CommonModule(io))
+        .useModule(new BuildModule_1.BuildModule())
+        .useModule(new HelpModule_1.HelpModule());
+}
+function withContainer(io, fn) {
+    const container = createContainer(io);
+    try {
+        return fn(container);
+    }
+    finally {
+        container.dispose();
+    }
+}
+function run(argv, io = (0, CliIo_1.processIo)()) {
+    return Application_1.Application.bootstrap(createContainer(io)).run(...argv);
+}
+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));
+}

package/cjm/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const cli_1 = require("./cli");
-process.exitCode = (0, cli_1.run)(process.argv.slice(2));
+const app_1 = require("./app");
+process.exitCode = (0, app_1.run)(process.argv.slice(2));

package/cjm/cli/Application.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+const DomainException_1 = require("../exceptions/DomainException");
+const decorators_1 = require("./decorators");
+const IErrorHandler_1 = require("./IErrorHandler");
+const usage_1 = require("./usage");
+const COMMAND_ALIASES = {
+    '--help': 'help',
+    '-h': 'help',
+    '--version': 'version',
+    '-v': 'version',
+};
+function parseCommandAndAction(argv) {
+    const [first, maybeAction] = argv;
+    if (!first)
+        throw new DomainException_1.MissingCommandError(usage_1.USAGE);
+    const command = COMMAND_ALIASES[first] ?? first;
+    const action = maybeAction && !maybeAction.startsWith('-') ? maybeAction : decorators_1.DEFAULT_ACTION;
+    return { command, action };
+}
+class Application {
+    scope;
+    errorHandler;
+    static bootstrap(container) {
+        return new Application(container, IErrorHandler_1.IErrorHandlerKey.resolve(container));
+    }
+    constructor(scope, errorHandler) {
+        this.scope = scope;
+        this.errorHandler = errorHandler;
+    }
+    run(...argv) {
+        try {
+            const { command, action } = parseCommandAndAction(argv);
+            if (!this.scope.hasRegistration(command))
+                throw new DomainException_1.UnknownCommandError(command);
+            const controller = this.scope.resolve(command);
+            const collector = new ts_ioc_container_1.HookCollector({
+                key: action,
+                createExecutionContext: (0, ts_ioc_container_1.createHookContextFactory)({ args: argv }),
+            });
+            const actions = collector.getActions(controller, { scope: this.scope });
+            if (actions.length === 0)
+                throw new DomainException_1.UnknownActionError(command, action);
+            for (const item of actions)
+                (0, ts_ioc_container_1.toTask)(item)();
+            return 0;
+        }
+        catch (error) {
+            return this.errorHandler.handleError(error);
+        }
+        finally {
+            this.scope.dispose();
+        }
+    }
+}
+exports.Application = Application;

package/cjm/cli/IErrorHandler.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IErrorHandlerKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.IErrorHandlerKey = new ts_ioc_container_1.SingleToken('IErrorHandler');

package/cjm/cli/decorators.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onDefault = exports.action = exports.DEFAULT_ACTION = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.DEFAULT_ACTION = 'default';
+const action = (name, ...hooks) => (0, ts_ioc_container_1.hook)(name, (0, ts_ioc_container_1.sequential)(...hooks));
+exports.action = action;
+const onDefault = (...hooks) => (0, exports.action)(exports.DEFAULT_ACTION, ...hooks);
+exports.onDefault = onDefault;

package/cjm/cli/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE = exports.IErrorHandlerKey = exports.Application = exports.validate = exports.parseOptions = exports.commandArgs = exports.onDefault = exports.DEFAULT_ACTION = exports.action = void 0;
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "action", { enumerable: true, get: function () { return decorators_1.action; } });
+Object.defineProperty(exports, "DEFAULT_ACTION", { enumerable: true, get: function () { return decorators_1.DEFAULT_ACTION; } });
+Object.defineProperty(exports, "onDefault", { enumerable: true, get: function () { return decorators_1.onDefault; } });
+var options_1 = require("./options");
+Object.defineProperty(exports, "commandArgs", { enumerable: true, get: function () { return options_1.commandArgs; } });
+Object.defineProperty(exports, "parseOptions", { enumerable: true, get: function () { return options_1.parseOptions; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return options_1.validate; } });
+var Application_1 = require("./Application");
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return Application_1.Application; } });
+var IErrorHandler_1 = require("./IErrorHandler");
+Object.defineProperty(exports, "IErrorHandlerKey", { enumerable: true, get: function () { return IErrorHandler_1.IErrorHandlerKey; } });
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "USAGE", { enumerable: true, get: function () { return usage_1.USAGE; } });

package/cjm/cli/options.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.parseOptions = exports.commandArgs = void 0;
+const node_util_1 = require("node:util");
+const zod_1 = require("zod");
+const DomainException_1 = require("../exceptions/DomainException");
+const commandArgs = ({ args = [] }) => args.map(String);
+exports.commandArgs = commandArgs;
+const parseOptions = (options) => (argv) => {
+    const firstFlag = argv.findIndex((arg) => arg.startsWith('-'));
+    try {
+        return { ...(0, node_util_1.parseArgs)({ args: firstFlag >= 0 ? argv.slice(firstFlag) : [], options, strict: true }).values };
+    }
+    catch (e) {
+        throw new DomainException_1.UsageError(e.message);
+    }
+};
+exports.parseOptions = parseOptions;
+const validate = (schema) => (value) => {
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new DomainException_1.UsageError(zod_1.z.prettifyError(result.error));
+    return result.data;
+};
+exports.validate = validate;

package/cjm/cli/usage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE = void 0;
+exports.USAGE = [
+    'Usage: ts-ioc-container <command> [options]',
+    '       tic is a shortcut for ts-ioc-container',
+    '',
+    'Commands:',
+    '  ts-ioc-container build [--config <path>]... [--check]   generate one bundle per *.bundle.{json,yaml,yml} config',
+    '                                                          (none: one bundle from tsconfig.json, all defaults)',
+    '  ts-ioc-container help                                   show this help',
+    '  ts-ioc-container version                                show the version',
+    '',
+    'Options:',
+    '  -c, --config <path>   build only this config; repeatable (default: every *.bundle.{json,yaml,yml} of the package, else tsconfig.json)',
+    '  --check               write nothing; exit 1 when a generated bundle is out of date',
+    '  -h, --help            show this help',
+    '  -v, --version         show the version',
+].join('\n');

package/cjm/domain/CliIo.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIo = exports.CliIoKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.CliIoKey = new ts_ioc_container_1.SingleToken('CliIo');
+const processIo = () => ({ cwd: process.cwd(), stdout: console.log, stderr: console.error });
+exports.processIo = processIo;

package/cjm/domain/GlobalConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalConfig = exports.GlobalConfigKey = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+exports.GlobalConfigKey = new ts_ioc_container_1.SingleToken('GlobalConfig');
+const globalConfig = (key) => ({ scope }) => exports.GlobalConfigKey.resolve(scope)[key];
+exports.globalConfig = globalConfig;

package/cjm/exceptions/DomainException.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleBundlesError = exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.TicConfigError = exports.TicError = void 0;
+class TicError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = new.target.name;
+    }
+}
+exports.TicError = TicError;
+class TicConfigError extends TicError {
+    constructor(message) {
+        super('INVALID_CONFIG', message);
+    }
+}
+exports.TicConfigError = TicConfigError;
+class MissingCommandError extends TicError {
+    constructor(usage) {
+        super('MISSING_COMMAND', `missing command\n${usage}`);
+    }
+}
+exports.MissingCommandError = MissingCommandError;
+class UnknownCommandError extends TicError {
+    constructor(command) {
+        super('UNKNOWN_COMMAND', `unknown command "${command}"`);
+    }
+}
+exports.UnknownCommandError = UnknownCommandError;
+class UnknownActionError extends TicError {
+    constructor(command, action) {
+        super('UNKNOWN_ACTION', `unknown action "${action}" for command "${command}"`);
+    }
+}
+exports.UnknownActionError = UnknownActionError;
+class UsageError extends TicError {
+    constructor(message) {
+        super('USAGE', message);
+    }
+}
+exports.UsageError = UsageError;
+class StaleBundlesError extends TicError {
+    constructor(count) {
+        super('STALE_BUNDLES', `${count} generated bundle${count === 1 ? ' is' : 's are'} out of date — run \`tic build\``);
+    }
+}
+exports.StaleBundlesError = StaleBundlesError;

package/cjm/exceptions/ExceptionHandler.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandler = void 0;
+const ts_ioc_container_1 = require("ts-ioc-container");
+const IErrorHandler_1 = require("../cli/IErrorHandler");
+const ConsoleLogger_1 = require("../services/ConsoleLogger");
+const DomainException_1 = require("./DomainException");
+let ExceptionHandler = class ExceptionHandler {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    handleError(error) {
+        if (error instanceof DomainException_1.TicError)
+            this.logger.error(error.message);
+        else
+            this.logger.error(error instanceof Error ? (error.stack ?? error.message) : String(error));
+        return 1;
+    }
+};
+exports.ExceptionHandler = ExceptionHandler;
+exports.ExceptionHandler = ExceptionHandler = __decorate([
+    (0, ts_ioc_container_1.register)(IErrorHandler_1.IErrorHandlerKey, (0, ts_ioc_container_1.singleton)()),
+    __param(0, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
+    __metadata("design:paramtypes", [Object])
+], ExceptionHandler);