@ts-ioc-container/bundler 0.0.0

package/AGENTS.md

@@ -0,0 +1,40 @@
+# 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
+(`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.
+
+- The CLI is `ts-ioc-container`, with `tic` as a shortcut (both `bin` entries,
+  same program). `tic build` reads `tic.config.json` (schema: `tic.schema.json`) and writes one
+  bundle per `bundles[]` entry — a generated class, `export class AppBundle implements IContainerModule`, applied with `container.useModule(new AppBundle())`. `--check` writes nothing and exits 1
+  when an output is stale — run it in CI.
+- A namespace is a folder: relative to the config file, or a tsconfig `paths`
+  alias. Generated imports use the most specific alias, else a relative path.
+- Default selection is every exported, non-abstract class. A module's
+  `select: { export, decorators, nameGlob }` narrows it; a class must meet every
+  criterion set. Decorators match by name, so composed ones must be listed.
+- Never edit a `*.bundle.ts` by hand — change the classes or the config and
+  rerun `tic build`.
+- Files take part when they match no `exclude` glob **and** an
+  `InclusionPredicate` (`({ filename }) => boolean`, filename relative to the
+  config) returns true. The predicate comes from `build({ include })`, else the
+  bundle's `include` file, else a conventional `tic.include.*` next to the
+  config. Predicate files are `require`d once per process — read env vars
+  inside the predicate. README "Recipe: generate per environment" shows the
+  per-environment setup.
+- Right after parsing, an `ExportPredicate` (`FilterPredicate<ExportContext>`:
+  filename, exportName, className, isDefault, decorators, tags) filters class by
+  class, after `select`; found via `build({ filterExports })`, a bundle's
+  `filterExports` file, or `tic.exports.*` next to the config.
+- Prefer `byTags((tags, context) => ...)` (a `TagInclusionPredicate`) over parsing
+  file names: tags are the dot-parts between base name and extension
+  (`Report.production.eu.ts` → `['production', 'eu']`). Usage examples:
+  `__tests__/examples/inclusion-predicates.spec.ts`.
+- For a lean production build, the production entry must import only the
+  production bundle (README "One bundle per environment"); statically importing
+  both bundles ships both.
+- Programmatic API: `build({ config, cwd, check })`, `run(argv, io)`,
+  `loadConfig(file)`; errors are `TicConfigError` / `NamespaceNotFoundError`
+  (both `TicError`).

package/README.md

@@ -0,0 +1,335 @@
+# @ts-ioc-container/bundler
+
+**Bundles your dependencies into a single container module.** `tic build` scans
+your folders — by path or tsconfig alias — and generates one typed bundle that
+registers every class in them, ready for
+[`ts-ioc-container`](../ts-ioc-container):
+
+```ts
+const container = new Container().useModule(new AppBundle());
+```
+
+Adding a service means writing the class — no hand-maintained list of
+`addRegistration(...)` calls to keep in sync. The bundle is ordinary
+TypeScript, generated at build time, so it type-checks, bundles and tree-shakes
+like code you wrote yourself.
+
+In TypeScript a namespace is an import path, so folders are named the way
+imports are: relative to the config file (`./src/services`) or through a
+`tsconfig.json` `paths` alias (`@app/services`).
+
+## Install
+
+```bash
+pnpm add -D @ts-ioc-container/bundler
+```
+
+It installs the CLI as `ts-ioc-container`, with **`tic`** as a shortcut —
+`ts-ioc-container build` and `tic build` are the same command; the examples
+below use the shortcut.
+
+`typescript` (>= 5) is a peer dependency.
+
+## Configure
+
+`tic.config.json`, next to your `tsconfig.json`:
+
+```json
+{
+  "$schema": "./node_modules/@ts-ioc-container/bundler/tic.schema.json",
+  "bundles": [
+    {
+      "output": "src/di/app.bundle.ts",
+      "name": "AppBundle",
+      "namespaces": ["@app/services", { "path": "./src/infra", "recursive": false }]
+    }
+  ]
+}
+```
+
+| Field                        | Default                                   | Meaning                                                                                      |
+| ---------------------------- | ----------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `tsconfig`                   | `tsconfig.json` (may be absent)           | Source of `paths` aliases and of the import extension                                        |
+| `importExtension`            | `.js` under node16/nodenext, else none    | Extension of generated imports                                                               |
+| `bundles[].output`           | —                                         | The bundle file (convention: `*.bundle.ts`)                                                  |
+| `bundles[].name`             | `Bundle`                                  | Name of the generated class, an `IContainerModule`                                           |
+| `bundles[].namespaces`       | —                                         | Folders to scan; `{ path, recursive }` to stop at the folder itself                          |
+| `bundles[].select`           | every exported class                      | Which classes of a file are registered — see [Selecting classes](#selecting-classes)          |
+| `bundles[].exclude`          | test files, `__tests__/`, `node_modules/` | Globs (relative to the config) never scanned; replaces the default                           |
+| `bundles[].filterExports`    | `tic.exports.*` next to the config        | File exporting an `ExportPredicate` — see [Filtering classes](#filtering-classes-after-parsing) |
+| `bundles[].include`          | `tic.include.*` next to the config        | File exporting an `InclusionPredicate` — see [Including files](#including-files-with-a-predicate) |
+
+## Selecting classes
+
+By default every exported, non-abstract class of a scanned file is registered.
+`select` narrows that; a class must meet every criterion that is set:
+
+```json
+"select": {
+  "export": "named",
+  "decorators": ["register", "repository"],
+  "nameGlob": "*Service"
+}
+```
+
+| Criterion    | Default | Meaning                                                                                                     |
+| ------------ | ------- | ----------------------------------------------------------------------------------------------------------- |
+| `export`     | `any`   | `any`, `named` or `default` — which exports count                                                           |
+| `decorators` | —       | The class must carry one of these, by name — also renamed imports and `@ioc.register()`; list composed ones |
+| `nameGlob`   | —       | Glob on the class name; an anonymous default export is named after its file (`user-service.ts` → `UserService`) |
+
+Abstract and non-exported classes are never registered.
+
+## Including files with a predicate
+
+When globs aren't enough, decide in code which files take part:
+
+```ts
+type InclusionPredicate = (context: { filename: string }) => boolean;
+```
+
+`filename` is the path relative to the config file, `/`-separated
+(`src/services/Logger.ts`). A file takes part only when it matches no `exclude`
+glob **and** the predicate returns `true`.
+
+By convention there is nothing to configure: put a `tic.include.ts` (or `.cjs`,
+`.js`, `.mjs`, `.cts`, `.mts`) next to `tic.config.json` and its default export
+applies to every bundle.
+
+```ts
+// tic.include.ts
+import type { InclusionPredicate } from '@ts-ioc-container/bundler';
+
+const include: InclusionPredicate = ({ filename }) => !filename.includes('/legacy/');
+export default include;
+```
+
+| Where the predicate comes from       | Applies to    | Wins over                      |
+| ------------------------------------ | ------------- | ------------------------------ |
+| `build({ include })` (programmatic)  | every bundle  | everything                     |
+| `bundles[].include: "./path/file"`   | that bundle   | the conventional file          |
+| `tic.include.*` next to the config   | every bundle  | — (used when nothing is named) |
+
+Predicate files are loaded synchronously with `require`: `.cjs` / `.js`
+everywhere, `.mjs` on Node 22.12+, `.ts` on Node versions that strip types
+(22.18+, 23.6+). Like any `require`d module a file is loaded **once per
+process**, so read environment variables inside the predicate, not at the top
+of the file.
+
+### Tags: `TagInclusionPredicate`
+
+A file's **tags** are the dot-separated parts of its name between the base name
+and the extension — `StripeGateway.production.ts` → `['production']`,
+`Report.production.eu.ts` → `['production', 'eu']`, `Shared.ts` → `[]`. Write
+a predicate over them and wrap it with `byTags`:
+
+```ts
+type TagInclusionPredicate = (tags: string[], context: { filename: string }) => boolean;
+```
+
+```ts
+// tic.include.ts
+import { byTags } from '@ts-ioc-container/bundler';
+
+export default byTags((tags) => !tags.includes('manual')); // Scheduler.manual.ts is never generated
+```
+
+`byTags` returns an ordinary `InclusionPredicate`, so it goes anywhere one
+does. `fileTags(filename)` is exported too. More examples — folders, name
+conventions, environments, environment × region — run as tests in
+[`__tests__/examples/inclusion-predicates.spec.ts`](__tests__/examples/inclusion-predicates.spec.ts).
+
+## Filtering classes after parsing
+
+`include` decides on whole files before they are read. To decide class by
+class, right after a file is parsed, use an `ExportPredicate`. It runs on every
+exported, non-abstract class that passes `select`:
+
+```ts
+type FilterPredicate<Target> = (value: Target) => boolean;
+type ExportPredicate = FilterPredicate<ExportContext>;
+
+interface ExportContext {
+  filename: string;     // relative to the config: 'src/Mailer.ts'
+  exportName: string;   // 'default' for a default export
+  className: string;    // an anonymous default export is named after its file
+  isDefault: boolean;
+  decorators: string[]; // renamed imports resolved: `register as reg` -> 'register'
+  tags: string[];       // file-name tags, as byTags reads them
+}
+```
+
+```ts
+// tic.exports.ts, next to tic.config.json: picked up by convention
+import type { ExportPredicate } from '@ts-ioc-container/bundler';
+
+const filterExports: ExportPredicate = ({ exportName }) => !/(Stub|Mock|Fake)$/.test(exportName);
+export default filterExports;
+```
+
+It is found and loaded like an inclusion predicate: `build({ filterExports })`,
+else the bundle's `filterExports` file, else a `tic.exports.*` next to the
+config. Examples (test doubles sharing a file, decorator combinations, tags
+with class names) run as tests in
+[`__tests__/examples/inclusion-predicates.spec.ts`](__tests__/examples/inclusion-predicates.spec.ts).
+
+## Recipe: generate per environment
+
+Keep environment-specific implementations side by side, named by convention:
+`*.production.ts` joins only production, `*.development.ts` only development,
+and every other file is shared.
+
+```text
+src/services/
+├── Shared.ts                        → every environment
+├── StripeGateway.production.ts      → production only
+└── FakeGateway.development.ts       → development only
+```
+
+One helper turns the convention into a predicate — the environment tags a file
+carries must all be the wanted one, and a file without any is shared:
+
+```js
+// tic/for-env.cjs
+const { byTags } = require('@ts-ioc-container/bundler');
+const ENVS = ['development', 'production', 'test'];
+
+module.exports = (env) => byTags((tags) => tags.filter((tag) => ENVS.includes(tag)).every((tag) => tag === env));
+```
+
+### A. One bundle per environment (recommended)
+
+Every environment gets its own bundle, and both are committed. The files don't
+depend on who ran `tic build`, so `tic build --check` stays stable in CI.
+
+```json
+{
+  "bundles": [
+    {
+      "output": "src/di/app.production.bundle.ts",
+      "name": "AppBundle",
+      "namespaces": ["@app/services"],
+      "include": "./tic/production.cjs"
+    },
+    {
+      "output": "src/di/app.development.bundle.ts",
+      "name": "AppBundle",
+      "namespaces": ["@app/services"],
+      "include": "./tic/development.cjs"
+    }
+  ]
+}
+```
+
+```js
+// tic/production.cjs
+module.exports = require('./for-env.cjs')('production');
+// tic/development.cjs
+module.exports = require('./for-env.cjs')('development');
+```
+
+To keep development code out of the production build, the production entry
+point must import **only** the production bundle — a bundler includes what is
+imported, and a registration keeps its class alive, so nothing can be dropped
+after the fact. Give each environment its own entry:
+
+```ts
+// src/main.production.ts — production build entry
+import { Container } from 'ts-ioc-container';
+import { AppBundle } from './di/app.production.bundle';
+
+export const container = new Container().useModule(new AppBundle());
+```
+
+```ts
+// src/main.development.ts — development entry
+import { Container } from 'ts-ioc-container';
+import { AppBundle } from './di/app.development.bundle';
+
+export const container = new Container().useModule(new AppBundle());
+```
+
+With a single entry, pick the bundle with a dynamic `import()`: the bundler
+splits each into its own chunk and only the chosen one is loaded — the other
+chunk is still emitted, just never fetched.
+
+```ts
+const { AppBundle } =
+  process.env.NODE_ENV === 'production'
+    ? await import('./di/app.production.bundle')
+    : await import('./di/app.development.bundle');
+```
+
+| How the app picks the bundle                                     | Development classes in the production build |
+| ---------------------------------------------------------------- | ------------------------------------------- |
+| One entry per environment, importing its own bundle              | ✅ none                                     |
+| Recipe B below — only the production bundle exists at build time | ✅ none                                     |
+| Dynamic `import()` of the bundle                                 | ⚠️ emitted as a separate chunk, never loaded |
+| Static imports of both bundles plus a runtime condition          | ❌ both bundles, in full                    |
+
+Don't rely on the bundler dropping a statically imported bundle behind
+`process.env.NODE_ENV === 'production'`: the classes it imports run decorators
+at load time, which bundlers treat as side effects and keep.
+
+### B. One output, environment chosen when `tic build` runs
+
+The smallest production build: only the production bundle ever exists while it
+is built. For pipelines that generate at deploy time instead of committing the
+output:
+
+```js
+// tic.include.cjs — picked up by convention
+const forEnv = require('./tic/for-env.cjs');
+
+// Read TIC_ENV per call: the file is loaded once per process.
+module.exports = (context) => forEnv(process.env.TIC_ENV ?? 'development')(context);
+```
+
+```bash
+TIC_ENV=production tic build
+```
+
+The output now depends on `TIC_ENV`. Either don't commit it (generate it in
+every pipeline), or run `tic build --check` with the same `TIC_ENV` it was
+generated with.
+
+## Build
+
+```bash
+tic build                 # tic.config.json in the working directory
+tic build -c path/to/tic.config.json
+tic build --check         # CI: write nothing, exit 1 if a bundle is out of date
+```
+
+The output is plain TypeScript over the public `ts-ioc-container` API:
+
+```ts
+// src/di/app.bundle.ts
+// Generated by `tic build` from ../../tic.config.json. Do not edit by hand.
+// Namespaces: @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';
+
+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);
+  }
+}
+```
+
+```ts
+const container = new Container().useModule(new AppBundle());
+```
+
+Treat `*.bundle.ts` as build output: add it to `.prettierignore` (and any
+other formatter's ignore list), since `--check` compares files byte for byte.
+
+Each class keeps its own `@register(...)` config (key, scope, singleton, …);
+an undecorated class is bound by its class name. Discovery is syntactic — no
+type checker runs.

package/cjm/ImportPaths.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 errors_1 = require("./errors");
+const glob_1 = require("./glob");
+const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
+const NO_INPUTS = 18003;
+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)];
+}
+class ImportPaths {
+    aliases;
+    extension;
+    static load(tsconfig, importExtension) {
+        if (!(0, node_fs_1.existsSync)(tsconfig.file)) {
+            if (tsconfig.required)
+                throw new errors_1.TicConfigError(`tsconfig not found: ${tsconfig.file}`);
+            return new ImportPaths([], importExtension ?? '');
+        }
+        const { config, error } = ts.readConfigFile(tsconfig.file, ts.sys.readFile);
+        const parsed = ts.parseJsonConfigFileContent(config, ts.sys, node_path_1.default.dirname(tsconfig.file), undefined, tsconfig.file);
+        const [fatal] = [error, ...parsed.errors].filter((d) => !!d && d.code !== NO_INPUTS);
+        if (fatal) {
+            throw new errors_1.TicConfigError(`${tsconfig.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
+        }
+        const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = parsed.options;
+        const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : node_path_1.default.dirname(tsconfig.file));
+        const aliases = Object.entries(paths).map(([pattern, targets]) => ({
+            pattern,
+            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' : ''));
+    }
+    constructor(aliases, extension) {
+        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 errors_1.NamespaceNotFoundError(`namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`);
+    }
+    specifier(fromFile, toFile) {
+        const target = (0, glob_1.toPosix)(toFile);
+        const bare = target.replace(SOURCE_EXTENSION, '');
+        let best;
+        for (const { pattern, targets } of this.aliases) {
+            for (const aliasTarget of targets) {
+                const match = this.matchAlias(pattern, aliasTarget, target, bare);
+                if (match && (!best || match.score > best.score))
+                    best = match;
+            }
+        }
+        if (best)
+            return best.spec;
+        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}`;
+    }
+    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) {
+            const exact = aliasTarget === file || aliasTarget.replace(SOURCE_EXTENSION, '') === bare;
+            return exact && !splitWildcard(pattern) ? { spec: pattern, score: Infinity } : undefined;
+        }
+        const [prefix, suffix] = wildcard;
+        if (!bare.startsWith(prefix) || !bare.endsWith(suffix) || bare.length < prefix.length + suffix.length) {
+            return undefined;
+        }
+        const captured = bare.slice(prefix.length, bare.length - suffix.length);
+        return { spec: `${pattern.replace('*', captured)}${this.extension}`, score: prefix.length };
+    }
+}
+exports.ImportPaths = ImportPaths;

package/cjm/bin.js

@@ -0,0 +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));

package/cjm/build.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+const emit_1 = require("./emit");
+const glob_1 = require("./glob");
+const ImportPaths_1 = require("./ImportPaths");
+const exportPredicate_1 = require("./exportPredicate");
+const inclusion_1 = require("./inclusion");
+const scan_1 = require("./scan");
+function build({ config = config_1.DEFAULT_CONFIG_FILE, cwd = process.cwd(), check = false, include, filterExports, } = {}) {
+    const resolved = (0, config_1.loadConfig)(node_path_1.default.resolve(cwd, config));
+    const paths = ImportPaths_1.ImportPaths.load(resolved.tsconfig, resolved.importExtension);
+    const includeFor = predicateResolver({
+        override: include,
+        conventional: (0, inclusion_1.findConventionalPredicate)(resolved.dir),
+        fileOf: (bundle) => bundle.include,
+        load: inclusion_1.loadInclusionPredicate,
+    });
+    const filterExportsFor = predicateResolver({
+        override: filterExports,
+        conventional: (0, exportPredicate_1.findConventionalExportPredicate)(resolved.dir),
+        fileOf: (bundle) => bundle.filterExports,
+        load: exportPredicate_1.loadExportPredicate,
+    });
+    const generated = resolved.bundles.map((bundle) => generate(resolved, bundle, paths, { include: includeFor(bundle), filterExports: filterExportsFor(bundle) }));
+    const outputs = generated.map(({ bundle, content, registrations }) => {
+        const current = (0, node_fs_1.existsSync)(bundle.output) ? (0, node_fs_1.readFileSync)(bundle.output, 'utf8') : undefined;
+        const status = current === content ? 'unchanged' : check ? 'stale' : 'written';
+        if (status === 'written') {
+            (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(bundle.output), { recursive: true });
+            (0, node_fs_1.writeFileSync)(bundle.output, content);
+        }
+        return { file: bundle.output, bundle: bundle.name, status, registrations, content };
+    });
+    return { config: resolved.file, outputs };
+}
+function predicateResolver({ override, conventional, fileOf, load, }) {
+    const loaded = new Map();
+    return (bundle) => {
+        if (override)
+            return override;
+        const file = fileOf(bundle) ?? conventional;
+        if (file === undefined)
+            return undefined;
+        if (!loaded.has(file))
+            loaded.set(file, load(file));
+        return loaded.get(file);
+    };
+}
+function generate(config, bundle, paths, { include, filterExports }) {
+    const relative = (file) => (0, glob_1.toPosix)(node_path_1.default.relative(config.dir, file));
+    const outputs = new Set(config.bundles.map((m) => m.output));
+    const excludes = bundle.exclude.map(glob_1.globToRegExp);
+    const isExcluded = (file) => {
+        if (outputs.has(file))
+            return true;
+        const filename = relative(file);
+        return excludes.some((glob) => glob.test(filename)) || (include !== undefined && !include({ filename }));
+    };
+    const files = new Set();
+    for (const namespace of bundle.namespaces) {
+        const dir = paths.resolveNamespace(namespace.path, config.dir);
+        for (const file of (0, scan_1.listSourceFiles)(dir, namespace.recursive, isExcluded))
+            files.add(file);
+    }
+    const classes = [...files]
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+        .flatMap((file) => (0, scan_1.findClasses)(file, bundle.select))
+        .filter((cls) => {
+        if (!filterExports)
+            return true;
+        const filename = relative(cls.file);
+        const { exportName, className, isDefault, decorators } = cls;
+        return filterExports({ filename, exportName, className, isDefault, decorators, tags: (0, inclusion_1.fileTags)(filename) });
+    })
+        .map((cls) => ({ ...cls, specifier: paths.specifier(bundle.output, cls.file) }));
+    const content = (0, emit_1.emitBundle)({
+        name: bundle.name,
+        configPath: (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(bundle.output), config.file)),
+        namespaces: bundle.namespaces.map((ns) => ns.path),
+        classes,
+    });
+    return { bundle, content, registrations: classes.length };
+}