ddd-ts-kit 0.1.0 → 0.2.0

package/README.md

@@ -22,6 +22,12 @@ npx ddd-ts-kit generate route billing IssueInvoice --method POST --path /invoice
 npx ddd-ts-kit check
 ```
 
+`init` ends by saying what to run next: `pnpm install`, then `pnpm run verify` (`npm install`,
+then `npm run verify` with `--package-manager npm`). A new project passes that whole gate before
+anything is generated, with no context, with one and with several: the end-to-end suite installs
+it for real and runs it, on both package managers and on every proven stack. After the install the
+CLI is the one the project pins: `pnpm exec ddd-ts-kit <command>`, or `npx ddd-ts-kit <command>`.
+
 Every command accepts `--json` (machine-readable output, errors included) and `--cwd <dir>`.
 Commands other than `init` look for `ddd-ts-kit.config.json` in the directory and its parents.
 Exit codes: `0` success, `1` violations, stale documentation or, under `--strict`, a commit over
@@ -41,22 +47,56 @@ ddd-ts-kit init [--http express|fastify|nest|none]
                 [--broker none|rabbitmq|kafka|nats|redis|custom] [--cache none|redis] [--audit on|off]
                 [--errors none|sentry] [--logger stdout|pino|winston]
                 [--style declared|explicit] [--assembly barrel|discovery]
+                [--package-manager npm|pnpm]
                 [--allow-no-outbox "<reason>"] [--import-alias '$<name>/']
+                [--import-extension none|js]
                 [--context <name>:<core|supporting|generic>]...
                 [--dry-run] [--force]
 ```
 
 Works in an empty directory or an existing project. An existing file is never replaced without
-`--force`; it is reported as skipped. An existing `package.json` is merged: missing scripts and
+`--force`; it is reported as skipped. `init` also writes the generated contracts as the scripts
+of the project write them for a project without a route or an integration event of its own
+(`openapi/openapi.json`, `docs/integration/asyncapi.json` and `event-catalog.md`), so that the
+first commit holds them and `docs:check` passes at once; a contract that is already there is
+left alone, `--force` included. An existing `package.json` is merged: missing scripts and
 dependencies are added, yours are kept and mentioned in the notes. Run again later, `init` keeps
 the stack recorded in the config.
 
+`init --force` on a project that is already initialised rewrites the files `init` owns and keeps
+the config: the contexts and their upstreams, the rules, the limits, the deviations and every
+other key stay as written, and the stack changes only where a flag names a choice
+(`init --force --logger pino` changes the logger; a combination the recorded stack cannot take
+is refused as for a new project). The composition root, the proof that each context wires alone
+and the registry of permissions are rewritten from their templates, then the declared contexts
+are wired into them again; what another generator had added to a file of the platform (the
+value of a gateway, the settings of a job) is not, and a note says so. A config that cannot be
+read is replaced.
+
+An import of a file of the project is written without an extension
+(`@/contexts/billing/domain/aggregates/invoice.aggregate`): `init` records
+`"importExtension": "none"`, and `--import-extension js` asks for the `.js` of the emitted file
+instead. A config without the key is read as `js`, so a project generated before the key
+existed keeps its spelling. See [docs/CONFIG.md](../../docs/CONFIG.md).
+
 Defaults: `express`, `zod`, `tsyringe` (`nest` with `--http nest`, and only then), `vitest`,
 `drizzle` on `postgres`, `outbox` when there is an ORM, `swagger`, `github`, `jwt`, `rbac`, no broker,
 the cache in the process, the audit trail `on` when there is an ORM, unexpected failures reported
 nowhere (`--errors none`), JSON lines on the standard output (`--logger stdout`), and the
 `declared` style with a `barrel` wherever the declarations are read: with `--di tsyringe`.
 
+**Package manager.** `pnpm` unless `--package-manager npm`: every script, pipeline, hook, the
+Dockerfile, the guidance and the agent permissions are written in the dialect of the one chosen,
+recorded under `stack.packageManager`. pnpm is pinned in `package.json` and provided by corepack;
+`pnpm-workspace.yaml` says that no dependency runs a build script unless allowed by name. Both are
+proven by a real install of a generated project, its build and its `verify`. The kit is installed
+from the registry either way.
+
+**Pipelines.** A pull or merge request runs the unit specs, the integration specs and the lint of
+the contexts its change reaches through the context map (`ddd-ts-kit affected`); types,
+architecture, import graph, dead code, end to end, build and documents always run on the whole
+project, and the default branch and the nightly schedule run everything.
+
 **Two styles.** In the `declared` style each class says what it is with a decorator of
 `@ddd-ts-kit/kernel/declarations` (`@Requires` or `@Public` on a command or a query,
 `@CommandHandler`, `@QueryHandler`, `@IntegrationEventHandler`, `@DomainEventHandler`, `@Scheduled`,
@@ -78,9 +118,23 @@ A config written before `stack.style` existed is explicit.
 **A port is an abstract class and its own injection token.** `application/ports/<name>.port.ts`
 and `domain/repositories/<name>.repository.ts` hold one abstract class each. Generated code holds
 no `token()`, no UPPER_SNAKE injection constant, no `<context>.ports.ts` and no
-`platform/tokens.ts`: a dependency list names port classes (`[InvoiceRepository, IdGenerator, Clock]`),
-kernel ports are value imports wherever they are named in a list or a binding, an adapter
-`implements` its port. Every generated file exports one class, interface or function and is named
+`platform/tokens.ts`: a constructor parameter typed by a port class names what is injected
+(`private readonly clock: Clock`), kernel ports are value imports wherever they are named in a
+list or a binding and type imports where they only type a parameter, an adapter `implements`
+its port.
+
+**The constructor states the dependencies.** In the declared style a generated class lists
+nothing in its decorator (`@CommandHandler(IssueInvoiceCommand)`): each constructor parameter
+is typed by one class, its token (`declarations/constructor-injection`). `generate`, `docs` and
+the `dev` script read the signatures, with the zero-dependency scanner of the checker and no
+compiler, and write `injected(Class, [Tokens])` statements in the generated file of each
+context: the barrel `<context>.declarations.ts`, or `<context>.dependencies.ts` under
+discovery. `@ddd-ts-kit/di` injects from there. `emitDecoratorMetadata` is never relied on: it
+is absent with standard decorators and under `tsx`. `init` writes
+`"stack.dependencies": "signature"`; a config without the key is `listed`, the 0.1 form
+(`@CommandHandler(M, [Ports])`), which keeps working untouched, and
+`--dependencies listed` asks for it. The explicit style stays explicit: its module file lists
+what each class is given. Every generated file exports one class, interface or function and is named
 after it.
 
 **Domain events leave with the save.** A generated command handler builds or loads its aggregate,
@@ -141,7 +195,7 @@ to its lists, everything else is kept, and the notes of the command list what wa
 denied and `Read(!./.env.example)`, a negation placed after it in the same list, takes the
 example file back out.
 
-Every `.ts` file `init` and `generate` write imports by the alias (`@/platform/errors.js`),
+Every `.ts` file `init` and `generate` write imports by the alias (`@/platform/errors`),
 never by a relative path; the barrel and a published-language index re-export by it too.
 
 Scripts: `dev` (`tsx watch`, which resolves an alias from the `paths` of `tsconfig.json`,
@@ -187,6 +241,7 @@ ddd-ts-kit generate --help --json
 | `integration-event` | `<context> <Aggregate> <Fact> [--version n]` | `defineIntegrationEvent` declaration in the published language (its payload in `<event>.v<n>.payload.ts` with class-validator or a schema of your own), index export, the publisher `application/integration/publishers/<event>.publisher.ts`, spec, registration, a line of `platform/audit/audited-events.ts` |
 | `integration-handler` (`consumer`) | `<context> <upstreamContext> <eventType>` | `application/integration/handlers/<name>.integration-handler.ts`, a class `<Name>IntegrationHandler` depending on `CommandBus`, its spec, its idempotent subscription under the consumer name `<context>.<name>`; refused unless the upstream is declared |
 | `event-handler` | `<context> <Aggregate> <Fact> [--phase after-commit]` | reaction to a domain event of the context, spec, subscription; before the commit of the unit of work by default, after it with `--phase after-commit` (an effect no transaction covers, at most once), and the spec runs the reaction in that phase |
+| `projection` (`projector`) | `<context> <Name> <event-type>` | a projector in `application/projections/<name>.projection.ts`, declared with `@Projection('<context>.<name>')` and one `@On(definition)` method for the integration event, which the context itself or a declared upstream publishes, and its spec; declared style only. It keeps one read model: its port is received in the constructor |
 | `job` | `<context> <Name> (--every <duration> \| --cron "<expression>" [--time-zone <zone>]) --command <UseCaseName>` | `application/scheduling/<name>.job.ts`, a class `<Name>Job implements ScheduledJob` that sends the command, as `systemActor('<context>.<name>')` when it is protected, with `execution.scheduledAt` when the command takes it; `test/unit/<name>.job.spec.ts`, which runs the job (by name on tsyringe, `application.jobs.runNow`; `job.run(occurrence)` with hand wiring) and asserts the command it sent; its registration; its switch in `platform/job-settings.ts`; the grant of its system actor (below) |
 | `acl` | `<context> <upstreamOrSystemName>` | translator in `infrastructure/anti-corruption/`, spec |
 | `e2e` | `<context> <UseCaseName>` | `test/e2e/<use-case>.e2e.spec.ts` driving the route of the use case: 401 without a credential, 403 without the permission, the documented status with it; for a command, one more test asserts the trace of the request, exact on names and structure, with `installTestTracing()` and `expectSpanTree(storyOf(trace), [...])` of `@ddd-ts-kit/tracing/testing` (`POST /invoices`, then `command IssueInvoiceCommand`, then `repository InvoiceRepository.save`); needs the route |
@@ -199,17 +254,17 @@ ddd-ts-kit generate --help --json
 
 - **The declared style, kind by kind.** No token anywhere: a list names port classes. `command`
   and `query` put `@Requires(<permissions>[...])` or `@Public()` on the message and
-  `@CommandHandler(Message, [InvoiceRepository, IdGenerator, Clock])` or
+  `@CommandHandler(Message)` or
   `@QueryHandler(Message, [<UseCase>Reader])` on the handler; `repository` writes
   `@Repository(InvoiceRepository, [<storage>, ExecutionScope, Clock])`, the storage being
   `Database` of the platform (drizzle, prisma), `KnexContext` or `TypeOrmContext`; the in-memory
   adapter of a read port is `in-memory-<name>-reader.repository.ts`, a role file with
   `@Repository(<UseCase>Reader)`; `integration-handler` writes
-  `@IntegrationEventHandler(definition, { consumer }, [CommandBus])` and is refused when the
+  `@IntegrationEventHandler(definition, { consumer })` and is refused when the
   upstream does not declare the event; `event-handler` and the publisher of `integration-event`
   write `@DomainEventHandler(Event, { name })` (the publisher with
   `[IntegrationEventPublisher, IdGenerator]`), and both are found like any role file: the
-  composition root lists no publisher; `job` writes `@Scheduled('<context>.<name>', schedule, [CommandBus])`;
+  composition root lists no publisher; `job` writes `@Scheduled('<context>.<name>', schedule)`;
   `policy` writes a class with `@Policy(permission, { name })` and registers nothing; `gateway`
   writes `@Gateway(<Name>Gateway, [<Name>Contract])` and binds the upstream value in the marker
   regions of `platform/platform.module.ts` and `platform/platform-test.module.ts`: a value or a
@@ -248,8 +303,16 @@ ddd-ts-kit generate --help --json
   relationship schema or a permission the generator cannot read, nothing is written and the job
   file carries the `TODO(domain)` naming the actor and the permission.
 - **The barrel is derived.** `<context>.declarations.ts` holds one `export *` per role file, sorted
-  by path. Every `generate`, and `docs`, rewrite it; `docs --check` and `check`
-  (`declarations/barrel-current`) report one that a role file written by hand left behind.
+  by path, then one `injected(Class, [Tokens])` per class whose constructor takes something,
+  read from its signature, with the imports they need. Every `generate`, and `docs`, rewrite it;
+  `docs --check` and `check` (`declarations/barrel-current`) report one that a role file written
+  by hand left behind or whose constructor changed since, naming the class
+  (`stale  src/contexts/billing/billing.declarations.ts: the dependency list of IssueInvoiceHandler is stale: ...`).
+  The `dev` script loads `ddd-ts-kit/dist/refresh-declarations.js` before the application, on
+  every start and reload of `tsx watch`: a port added to a constructor is injected on the
+  reload that follows the save. The same module is the binary `ddd-ts-kit-refresh-declarations`.
+  It is laid out as Biome lays it out at a line width of 120; a project that formats at another
+  width leaves `**/*.declarations.ts` and `**/*.dependencies.ts` out of its formatter.
 - **Deny by default.** `command` and `query` are refused without `--permission` or `--public`. A new
   permission joins `<context>.permissions.ts`; its words are checked against the glossary like any
   other name. With `--authz rebac` the requirement names the context as its resource, a starting
@@ -326,7 +389,9 @@ Regenerates what is derived from the config and the code, and nothing else:
   kept; on first creation the four written sections are laid out with hints.
 - the generated lists of every `CONTEXT.md` (aggregates, published events, permissions, scheduled
   jobs as a table of name, schedule and command, relationships);
-- the barrel of every declared context, `<context>.declarations.ts`;
+- the generated file of every declared context: the barrel `<context>.declarations.ts`, with
+  what each constructor is injected, read from its signature, or under discovery
+  `<context>.dependencies.ts`, which holds that alone;
 - the reference of every `CONTEXT.md`: the facts of `describe`, as tables under `## Reference`,
   between `ddd-ts-kit:reference` markers; a `CONTEXT.md` that has no such section gets it after its
   last generated list;
@@ -355,10 +420,14 @@ ddd-ts-kit build-aliases [--project <tsconfig>]
 ```
 
 The second step of `npm run build`, after the compiler. The compiler emits an import alias as
-it was written (`@/platform/errors.js`), and Node resolves no alias: this command rewrites, in
-every `.js`, `.mjs`, `.cjs`, `.d.ts`, `.d.mts` and `.d.cts` under the output directory of the
-tsconfig (`tsconfig.build.json` by default), each alias specifier into the relative path of the
-emitted file it names, so that `node dist/src/main.js` runs with no loader and no flag.
+it was written (`@/platform/errors`), and Node resolves no alias and completes no extension:
+this command rewrites, in every `.js`, `.mjs`, `.cjs`, `.d.ts`, `.d.mts` and `.d.cts` under the
+output directory of the tsconfig (`tsconfig.build.json` by default), each alias specifier into
+the relative path of the emitted file it names, with its `.js` extension
+(`../../platform/errors.js`), so that `node dist/src/main.js` runs with no loader and no flag.
+It reads `importAlias` and `importExtension` of the config: `@/platform/errors` names
+`platform/errors.js` under `none`, `@/platform/errors.js` names it under `js`, and no other
+spelling is guessed.
 
 - Rewritten: the specifier of `import ... from`, `export ... from`, a bare `import`,
   `import('...')` and `require('...')` with a string literal, `import.meta.resolve('...')`, and
@@ -367,9 +436,13 @@ emitted file it names, so that `node dist/src/main.js` runs with no loader and n
   code, a comment, a template or a regular expression, is left alone. Lines never move and the
   source maps are not touched.
 - Idempotent: a second run rewrites nothing.
-- It exits 2 and writes nothing when an alias names no emitted file, when `import()` is given
-  an alias completed at run time (a template with an interpolation, a concatenation), or when
-  the output directory does not exist.
+- It exits 2 and writes nothing when an alias names no emitted file, when it names a directory
+  (an alias names one file: `.../published-language/index`), when it is written in the spelling
+  the config does not ask for, when `import()` is given an alias completed at run time (a
+  template with an interpolation, a concatenation), or when the output directory does not
+  exist. Each refusal says the file, the line and what to write instead.
+- A package is never touched, whatever its subpath ends with (`zod/v4/core.js`,
+  `@scope/package/file.js`, `node:fs`).
 
 `--json` answers `{ outDir, files, changed, specifiers }`. `ddd-ts-kit check` reports a script
 that compiles without this step (`imports/alias-declared`). The whole mechanism:
@@ -536,8 +609,9 @@ saying what to do instead. Exit code 1 when there is at least one error.
 | `clean/file-size` | a file of more than 350 lines, sources and tests; a path with a segment `generated` and declaration files are exempt |
 | `composition/only-in-module` | `new X`, or `bind(..).toClass(X, ..)` and `rebind(..).toClass(X, ..)`, of a class imported from `infrastructure/`, outside the module file, `main.ts`, the platform and tests; in a file importing `@ddd-ts-kit/di`, a call of `contextModule`, `discoverContext` or `.include(` outside those places and `apps/<context>/main.ts` |
 | `imports/alias-only` | under the source root, `test/` and `scripts/`: an `import`, `export ... from` or `import()` with a relative specifier, the same directory included (the fix names the alias to write; `eslint --fix` writes it); an alias specifier with a `.` or `..` segment |
-| `imports/alias-declared` | an `importAlias` that is not `@/` or `$<name>/`, or that is `$test/`, `$scripts/`, `$generated/`; a `paths` entry of `tsconfig.json` missing or different from what `importAlias` gives (the fix gives the entry); another `paths` entry under an alias; a `baseUrl`; a `tsconfig.build.json` whose `paths` differ; `paths` of `knip.json` mapping an alias; a script that compiles (`tsc` without `--noEmit`) and does not run `ddd-ts-kit build-aliases` afterwards; a script running `tsx --tsconfig` on another file; a `vitest` config at the root without `tsconfigPaths: true`, a `jest` config without the derived `moduleNameMapper` entries, or `.dependency-cruiser.cjs` without `tsConfig`. A project without `package.json` is not judged |
-| `config/valid` | unknown upstream, classification, relationship, rule id or `guard` mode; a context missing on disk or in the config; a `commit` limit that is not a positive integer |
+| `imports/extension` | under the source root, `test/` and `scripts/`: with `importExtension` `none`, an alias specifier that ends with `.js`, `.mjs`, `.cjs`, `.ts`, `.mts` or `.cts`, or that names a directory holding an `index.ts`; with `js` (or no key), an alias specifier that does not end with `.js` (the fix names the specifier to write; `eslint --fix` writes it). A package subpath is never judged |
+| `imports/alias-declared` | an `importAlias` that is not `@/` or `$<name>/`, or that is `$test/`, `$scripts/`, `$generated/`; a `paths` entry of `tsconfig.json` missing or different from what `importAlias` gives (the fix gives the entry); another `paths` entry under an alias; a `baseUrl`; a `tsconfig.build.json` whose `paths` differ; `paths` of `knip.json` mapping an alias; a script that compiles (`tsc` without `--noEmit`) and does not run `ddd-ts-kit build-aliases` afterwards; a script running `tsx --tsconfig` on another file; a `vitest` config at the root without `tsconfigPaths: true`, a `jest` config without the derived `moduleNameMapper` entries, or `.dependency-cruiser.cjs` without `tsConfig`; `module` and `moduleResolution` of `tsconfig.json` (or of a `tsconfig.build.json` that sets its own) that are not what `importExtension` gives: `ESNext`, `Bundler` and `customConditions` holding `node` under `none`, and under `js` a written value that is not a Node resolution; a jest mapping whose pattern does not end as the imports do. A project without `package.json` is not judged |
+| `config/valid` | unknown upstream, classification, relationship, rule id, `guard` mode or `importExtension`; a context missing on disk or in the config; a `commit` limit that is not a positive integer |
 | `config/suppression-needs-reason` | a suppression without a rule id or a reason (kept as an alias next to `governance/recorded-deviation`, which judges the reason) |
 | `authz/declared` | in a module file, `builder.command(X)` or `builder.query(X)` without `.requires(` or `.public(` in its chain, unless the message class carries `@Requires` or `@Public` of `@ddd-ts-kit/kernel/declarations`; with manual or nest wiring, a command or query class absent from every `requires(X, ...)` and `publicUseCase(X)` of the module file and of `application/authorization/`; a `defineRoute` without `security` (the route type refuses it already, and an empty list too: this is the text-level net for a definition built loosely); in the declared style, the exported class of a `*.command.ts` or `*.query.ts` file carrying neither `@Requires` nor `@Public` |
 | `authz/in-application` | `presentation/`: a test on roles, `isAdmin`, the import of an authorizer or of `Access`; `infrastructure/`: `authorize(` or `check(` on an authorizer or access, `ForbiddenError`; `domain/`: any import of `@ddd-ts-kit/auth`, of the actor types of the kernel (`Actor`, `ActorContext`, `Session`, `ExecutionContext`, the authorized messages), a read of `.roles` or `.permissions` on an actor. The request glue of `@ddd-ts-kit/auth` (`actorOf`, `sessionOf`, `resolveSession`, `SessionAuthenticator`) is free in `presentation/`. `presentation/` and `infrastructure/`: the import of `Requires`, `Public` or `Policy` from `@ddd-ts-kit/kernel/declarations`, or of the ports `Access` and `PolicyAccess` from `@ddd-ts-kit/auth`; they are free in `application/` |
@@ -552,11 +626,12 @@ saying what to do instead. Exit code 1 when there is at least one error.
 | `context/extractable` | a module file importing another context outside its published language; persistence importing another context's infrastructure or naming its schema; a handler importing another context's repository; `export let` or an exported `new Map`, `Set`, `WeakMap` at module level; `deployable: true` without `apps/<context>/main.ts`; in the declared style, a role file importing anything of a port file of another context |
 | `governance/recorded-deviation` | a `ddd-ts-kit-disable` or `eslint-disable` comment whose reason names no `ADR-<number>` with a file `docs/adr/<number>-*.md`; a rule set to `off` (or to `warn` below its default), an extra directory, an extra allowed package, a `guard` other than `enforce` or `stack.events` off the outbox, without a `deviations` entry `{ what, adr, reason }` pointing to an existing record |
 | `declarations/role-declared` | declared style only: a role file (other than `*.command.ts` and `*.query.ts`, held by `authz/declared`; `*.job.ts` under `application/scheduling/` with `@Scheduled` and `*.publisher.ts` with `@DomainEventHandler` are roles) exporting no class with the decorator of its suffix and folder, or one carrying another declaration; a declared class in a file that is not a role file; a `consumer` or `name` option that is missing, empty, a variable, a concatenation or a template with a substitution; a `@DomainEventHandler` name that differs from the `name` literal of the imported event class; any declaration decorator on a class under `domain/` |
-| `declarations/barrel-current` | declared style only: with `stack.assembly: barrel`, a missing `<context>.declarations.ts` or one that differs from one `export *` per role file sorted by path; with `discovery`, a barrel that still exists. It needs the tree, so `check-file` does not run it |
+| `declarations/barrel-current` | declared style only: with `stack.assembly: barrel`, a missing `<context>.declarations.ts` or one that differs from one `export *` per role file sorted by path followed by one `injected(Class, [Tokens])` per class whose constructor takes something (read from the signatures, with their imports); with `discovery`, a barrel that still exists, and a `<context>.dependencies.ts` that differs from those `injected` statements (absent is accepted while it would hold none). The message names the missing role file or the class whose list is stale. It needs the tree, so `check-file` does not run it |
+| `declarations/constructor-injection` | declared style only, in a role file: on a class whose decorator lists nothing, a constructor parameter that is optional, has a default value, is a rest parameter or is destructured, has no type, or is typed by anything but one class name (type arguments aside): a union, an intersection, an array, a qualified name, a type of the language, an interface, a type alias, an enum or an unexported class of the file or of the file of the project it is imported from; a class that inherits its constructor from a class the project cannot read. Under `stack.dependencies: signature`, a decorator that carries a list although the constructor can be read: one that repeats it, one that differs |
 | `ports/abstract-class` | in a port file (`domain/repositories/*.repository.ts`, `application/ports/*.port.ts`): a class that is not `abstract`; a member that is not an abstract method or property (`static readonly tokenKey = '<text>'` apart): a constructor, a body, an initializer, a `private`, `protected` or `#` member; an exported `interface` (a `type` alias, a data shape, is not reported) |
 | `ports/implements-never-extends` | a class carrying `@Repository(P)`, `@Gateway(P)` or `@Adapter(P)`, or given to `bind(P).toClass(C)` or `rebind(P).toClass(C)`, without `implements P` or with `extends P`; under `infrastructure/`, a class extending a class imported from a port file |
 | `ports/no-token-constant` | a call of `token` imported from a `@ddd-ts-kit/*` package; `Symbol(..)`, `Symbol.for(..)` or a string literal as the first argument of `bind`, `rebind`, `resolve`, `fake` or `override` in a file importing `@ddd-ts-kit/di`; an UPPER_SNAKE_CASE name in a dependency list; a file named `*.ports.ts` or `tokens.ts` |
-| `ports/no-concrete-dependency` | a dependency list naming a class imported from `infrastructure/` or from `test/fakes/` of a context |
+| `ports/no-concrete-dependency` | a dependency list naming a class imported from `infrastructure/` or from `test/fakes/` of a context; in the declared style, a constructor parameter of a declared class that lists nothing, typed by such a class |
 | `ports/value-import` | a class named in a dependency list, or given to `bind` or `rebind`, imported with `import type` or `import { type X }` |
 | `scheduling/job-triggers-use-case` | in `application/scheduling/*.job.ts`: an exported class that does not implement `ScheduledJob`; a `run` that sends no command (no `.execute(` call); a repository in the dependency list or the constructor; an import from `domain/aggregates/`, `domain/entities/`, `domain/services/` or `infrastructure/`. A `builder.job(..)` registration of a class that lives elsewhere |
 | `scheduling/job-name` | the first argument of `@Scheduled(..)` or `.job(..)` that is not a string literal `<context>.<job-name>` in lower-case kebab-case with the context of its file; a `systemActor(..)` of a job file passing another name; one job name used twice in the project |
@@ -669,6 +744,14 @@ import is judged by every boundary rule exactly as the relative path to the same
   `override` are binding calls only in a file that imports `@ddd-ts-kit/di`.
   `ports/implements-never-extends` reads the bound class through one direct relative or alias
   import; a class of a package or behind a barrel is not judged.
+- The constructor of a declared class is read as text, by the scanner of the checker: the
+  constructor of the exported class that carries the decorator of its role file, its own or
+  the nearest one it inherits through imports of the project. A type imported from a package
+  is trusted to be a class (the compiler judges the generated file, which imports it as a
+  value); a type reached through a barrel is trusted too. A constructor overloaded by
+  signatures without a body, or built by a mixin, is not read: write one plain constructor.
+  `declarations/barrel-current` compares text exactly, so the generated file is never
+  reformatted by hand.
 - `scheduling/job-triggers-use-case` takes any `.execute(` call in `run` for a command sent; a job
   that executes something else, or sends its command from a helper, is misjudged.
   `scheduling/job-name` compares literal names: a job registered under a computed name is reported
@@ -713,8 +796,8 @@ npm run clean:self --workspace ddd-ts-kit       # the clean/* rules on this pack
 npm run clean:packages --workspace ddd-ts-kit   # the same rules on the sources of every other package
 ```
 
-The slow suite lives in `test/e2e/`, in seven spec files and their support files; it
-generates every project with every kind, a job on an interval and one on a cron expression with a
+The slow suite lives in `test/e2e/`, in its spec files and their support files; but for the
+`first-minute` specs it generates every project with every kind, a job on an interval and one on a cron expression with a
 time zone, `adapter --decorators`, `generate service` and `generate worker` included. It runs in
 the process, without a container:
 
@@ -738,6 +821,23 @@ the process, without a container:
   `--authz rebac --broker rabbitmq --ci gitlab`; and hand wiring (`--di manual`) on
   `--authz abac --orm knex` and on
   `--http fastify --orm knex --broker rabbitmq --cache redis --errors sentry --logger winston`.
+- `first-minute.spec.ts`, `first-minute-proven.spec.ts`, `first-minute-no-context.spec.ts` and
+  `first-minute-two-contexts.spec.ts`: a
+  project is green from its first minute, before anything is generated. The first runs the quick
+  start of the root README line by line as it is written, on pnpm and, in the words the README
+  gives for it, on npm: `init` alone, the install and the `verify` the note of `init` names (also
+  held to the README and the `CLAUDE.md` of the project), then a context, a second one downstream
+  of it, a use case with its route, `docs:generate`, with a `verify` at each step; and the
+  sequence the defect of 0.1.0 was reported with, contexts asked of `init`. The second does the
+  same on the seven other proven stacks, one package manager each in turn: no context, one, two
+  with an upstream, a first use case. Both install for real from the packed kit and run in the
+  package manager jobs of the pipeline (`ci:test:managers`). The last two take every stack the
+  workspace can run, installed as a published kit would be, with no context and with two: no
+  finding of the four analyzers, specs that pass, a build, and the contracts `init` wrote equal to
+  what the scripts of the project generate.
+- `package-managers.spec.ts`: one project per package manager on the default stack and on NestJS
+  with Prisma, every kind generated, installed for real from the packed kit: the frozen install of
+  a pipeline, the build, `verify`, and `affected` from the installed CLI.
 - `first-class.spec.ts`: the first-class stack, `--validation class-validator --orm knex --authn
   keycloak --authz rebac --cache redis --audit on --errors sentry --logger pino --style declared`
   (legacy decorator mode), three times, with `--broker redis` (one server for the cache and the

package/dist/affected/changed-paths.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The paths that differ between `base` and `head`, relative to the project at `root`; a path of
+ * the repository outside the project keeps a leading `../`. A rename is its old path and its new
+ * one. Undefined when git cannot tell (not a repository, an unknown ref, a shallow clone without
+ * the base): the caller then selects everything.
+ */
+export declare function changedPaths(root: string, base: string, head: string): string[] | undefined;
+//# sourceMappingURL=changed-paths.d.ts.map

package/dist/affected/changed-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-paths.d.ts","sourceRoot":"","sources":["../../src/affected/changed-paths.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAc3F"}

package/dist/affected/changed-paths.js

@@ -0,0 +1,21 @@
+import { runGit } from '../commit/run-git.js';
+/**
+ * The paths that differ between `base` and `head`, relative to the project at `root`; a path of
+ * the repository outside the project keeps a leading `../`. A rename is its old path and its new
+ * one. Undefined when git cannot tell (not a repository, an unknown ref, a shallow clone without
+ * the base): the caller then selects everything.
+ */
+export function changedPaths(root, base, head) {
+    const prefix = runGit(root, ['rev-parse', '--show-prefix'])?.trim();
+    // Three dots would need the history between the two; the merge base is asked for and used when the clone has it.
+    const from = runGit(root, ['merge-base', base, head])?.trim() || base;
+    const diff = runGit(root, ['diff', '--name-only', '--no-renames', '-z', from, head]);
+    if (prefix === undefined || diff === undefined) {
+        return undefined;
+    }
+    return diff
+        .split('\0')
+        .filter((file) => file !== '')
+        .map((file) => (file.startsWith(prefix) ? file.slice(prefix.length) : `../${file}`));
+}
+//# sourceMappingURL=changed-paths.js.map

package/dist/affected/changed-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-paths.js","sourceRoot":"","sources":["../../src/affected/changed-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,IAAY,EAAE,IAAY;IACnE,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IACpE,iHAAiH;IACjH,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC;IACtE,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAErF,IAAI,MAAM,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,IAAI;SACR,KAAK,CAAC,IAAI,CAAC;SACX,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;SAC7B,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;AACzF,CAAC"}

package/dist/affected/downstreams-of.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../config/index.js';
+/** Every context that declares `context` as an upstream, directly or through another: the context map read as a dependency graph. */
+export declare function downstreamsOf(config: Config, context: string): string[];
+//# sourceMappingURL=downstreams-of.d.ts.map

package/dist/affected/downstreams-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downstreams-of.d.ts","sourceRoot":"","sources":["../../src/affected/downstreams-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,qIAAqI;AACrI,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBvE"}

package/dist/affected/downstreams-of.js

@@ -0,0 +1,16 @@
+/** Every context that declares `context` as an upstream, directly or through another: the context map read as a dependency graph. */
+export function downstreamsOf(config, context) {
+    const reached = new Set();
+    const pending = [context];
+    for (let current = pending.pop(); current !== undefined; current = pending.pop()) {
+        for (const [name, { upstreams }] of Object.entries(config.contexts)) {
+            if (!reached.has(name) && upstreams.some((upstream) => upstream.context === current)) {
+                reached.add(name);
+                pending.push(name);
+            }
+        }
+    }
+    reached.delete(context);
+    return [...reached];
+}
+//# sourceMappingURL=downstreams-of.js.map

package/dist/affected/downstreams-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downstreams-of.js","sourceRoot":"","sources":["../../src/affected/downstreams-of.ts"],"names":[],"mappings":"AAEA,qIAAqI;AACrI,MAAM,UAAU,aAAa,CAAC,MAAc,EAAE,OAAe;IAC3D,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,CAAC;IAE1B,KAAK,IAAI,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,KAAK,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC;QACjF,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;YACpE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,KAAK,OAAO,CAAC,EAAE,CAAC;gBACrF,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAExB,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AACtB,CAAC"}

package/dist/affected/everything.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from '../config/index.js';
+import type { Selection } from './selection.js';
+/** The whole project: no context left out, which is what the default branch and the nightly run always get. */
+export declare function everything(config: Config, reason: string): Selection;
+//# sourceMappingURL=everything.d.ts.map

package/dist/affected/everything.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"everything.d.ts","sourceRoot":"","sources":["../../src/affected/everything.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,+GAA+G;AAC/G,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAEpE"}

package/dist/affected/everything.js

@@ -0,0 +1,5 @@
+/** The whole project: no context left out, which is what the default branch and the nightly run always get. */
+export function everything(config, reason) {
+    return { scope: 'all', reason, contexts: Object.keys(config.contexts), specs: ['**/*.spec.ts'], leftOut: [] };
+}
+//# sourceMappingURL=everything.js.map

package/dist/affected/everything.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"everything.js","sourceRoot":"","sources":["../../src/affected/everything.ts"],"names":[],"mappings":"AAGA,+GAA+G;AAC/G,MAAM,UAAU,UAAU,CAAC,MAAc,EAAE,MAAc;IACvD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;AAChH,CAAC"}

package/dist/affected/format-selection.d.ts

@@ -0,0 +1,10 @@
+import type { Selection } from './selection.js';
+/**
+ * The selection for a reader (`text`), as data (`json`), or as `key=value` lines: `github` for
+ * `$GITHUB_OUTPUT`, `env` (keys in upper case behind `AFFECTED_`) for a GitLab `dotenv` report.
+ * The keys: `scope` (`all`, `contexts` or `none`); `contexts`, comma separated, which the test
+ * runner reads as `DDD_TS_KIT_AFFECTED` (empty for `all`: nothing is left out); `args`, the
+ * arguments a partial run adds to the test runner; `lint`, the ones it adds to the linter.
+ */
+export declare function formatSelection(selection: Selection, format: string): string;
+//# sourceMappingURL=format-selection.d.ts.map

package/dist/affected/format-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-selection.d.ts","sourceRoot":"","sources":["../../src/affected/format-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAc5E"}

package/dist/affected/format-selection.js

@@ -0,0 +1,45 @@
+/** Lets a partial run pass when a selected context has no spec of one kind. */
+const PARTIAL_RUN = '--passWithNoTests';
+const ENV_PREFIX = 'AFFECTED_';
+/**
+ * The selection for a reader (`text`), as data (`json`), or as `key=value` lines: `github` for
+ * `$GITHUB_OUTPUT`, `env` (keys in upper case behind `AFFECTED_`) for a GitLab `dotenv` report.
+ * The keys: `scope` (`all`, `contexts` or `none`); `contexts`, comma separated, which the test
+ * runner reads as `DDD_TS_KIT_AFFECTED` (empty for `all`: nothing is left out); `args`, the
+ * arguments a partial run adds to the test runner; `lint`, the ones it adds to the linter.
+ */
+export function formatSelection(selection, format) {
+    if (format === 'json') {
+        return JSON.stringify(selection, null, 2);
+    }
+    if (format === 'text') {
+        return text(selection);
+    }
+    const key = (name) => (format === 'env' ? `${ENV_PREFIX}${name.toUpperCase()}` : name);
+    return Object.entries(values(selection))
+        .map(([name, value]) => `${key(name)}=${value}`)
+        .join('\n');
+}
+function values(selection) {
+    const partial = selection.scope === 'contexts';
+    return {
+        scope: selection.scope,
+        contexts: partial ? selection.contexts.join(',') : '',
+        args: partial ? PARTIAL_RUN : '',
+        lint: selection.leftOut.map((directory) => `--ignore-pattern ${directory}`).join(' '),
+    };
+}
+function text(selection) {
+    if (selection.scope === 'all') {
+        return `Everything is affected: ${selection.reason}.`;
+    }
+    if (selection.scope === 'none') {
+        return `Nothing that runs is affected: ${selection.reason}.`;
+    }
+    return [
+        `Affected contexts: ${selection.contexts.join(', ')} (${selection.reason}).`,
+        `Specs: ${selection.specs.join(' ')}`,
+        `Left to the default branch: ${selection.leftOut.join(' ')}`,
+    ].join('\n');
+}
+//# sourceMappingURL=format-selection.js.map

package/dist/affected/format-selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-selection.js","sourceRoot":"","sources":["../../src/affected/format-selection.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,MAAM,WAAW,GAAG,mBAAmB,CAAC;AACxC,MAAM,UAAU,GAAG,WAAW,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,SAAoB,EAAE,MAAc;IAClE,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,GAAG,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAEvG,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;SACrC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC;SAC/C,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED,SAAS,MAAM,CAAC,SAAoB;IAClC,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,KAAK,UAAU,CAAC;IAE/C,OAAO;QACL,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;QACrD,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE;QAChC,IAAI,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,oBAAoB,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;KACtF,CAAC;AACJ,CAAC;AAED,SAAS,IAAI,CAAC,SAAoB;IAChC,IAAI,SAAS,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QAC9B,OAAO,2BAA2B,SAAS,CAAC,MAAM,GAAG,CAAC;IACxD,CAAC;IAED,IAAI,SAAS,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;QAC/B,OAAO,kCAAkC,SAAS,CAAC,MAAM,GAAG,CAAC;IAC/D,CAAC;IAED,OAAO;QACL,sBAAsB,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,MAAM,IAAI;QAC5E,UAAU,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACrC,+BAA+B,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;KAC7D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/affected/path-reach.d.ts

@@ -0,0 +1,12 @@
+/** What one changed path reaches: one context (its specs alone when only its tests changed), everything, or nothing that runs. */
+export type PathReach = {
+    readonly kind: 'context';
+    readonly context: string;
+    readonly testsOnly: boolean;
+} | {
+    readonly kind: 'everything';
+    readonly reason: string;
+} | {
+    readonly kind: 'nothing';
+};
+//# sourceMappingURL=path-reach.d.ts.map

package/dist/affected/path-reach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-reach.d.ts","sourceRoot":"","sources":["../../src/affected/path-reach.ts"],"names":[],"mappings":"AAAA,kIAAkI;AAClI,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GACnF;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC"}

package/dist/affected/path-reach.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path-reach.js.map

package/dist/affected/path-reach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-reach.js","sourceRoot":"","sources":["../../src/affected/path-reach.ts"],"names":[],"mappings":""}

package/dist/affected/reach-of.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../config/index.js';
+import type { PathReach } from './path-reach.js';
+/**
+ * What a changed path, relative to the project root, reaches. A path under a declared context
+ * reaches that context; a document reaches nothing; anything else (the shared kernel, the
+ * platform, the composition root, the configuration, the lockfile, the tooling, the pipeline, a
+ * context the config does not declare, a path nobody listed) reaches everything.
+ */
+export declare function reachOf(config: Config, file: string): PathReach;
+//# sourceMappingURL=reach-of.d.ts.map

package/dist/affected/reach-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach-of.d.ts","sourceRoot":"","sources":["../../src/affected/reach-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAY/D"}

package/dist/affected/reach-of.js

@@ -0,0 +1,30 @@
+/** Written for people and agents, never loaded by a spec, a build or a tool of the pipeline other than the documents gate, which always runs. */
+const DOCUMENT_DIRECTORIES = ['docs/', 'openapi/', '.claude/'];
+/**
+ * What a changed path, relative to the project root, reaches. A path under a declared context
+ * reaches that context; a document reaches nothing; anything else (the shared kernel, the
+ * platform, the composition root, the configuration, the lockfile, the tooling, the pipeline, a
+ * context the config does not declare, a path nobody listed) reaches everything.
+ */
+export function reachOf(config, file) {
+    const contexts = `${config.contextsDir}/`;
+    if (file.startsWith(contexts)) {
+        return contextReach(config, file.slice(contexts.length));
+    }
+    if (isDocument(file)) {
+        return { kind: 'nothing' };
+    }
+    return { kind: 'everything', reason: `${file} is shared by every context` };
+}
+function contextReach(config, inside) {
+    const [context = '', ...rest] = inside.split('/');
+    if (rest.length === 0 || config.contexts[context] === undefined) {
+        return { kind: 'everything', reason: `${config.contextsDir}/${inside} belongs to no declared context` };
+    }
+    return { kind: 'context', context, testsOnly: rest[0] === 'test' };
+}
+function isDocument(file) {
+    const atRoot = !file.includes('/');
+    return (atRoot && file.endsWith('.md')) || DOCUMENT_DIRECTORIES.some((directory) => file.startsWith(directory));
+}
+//# sourceMappingURL=reach-of.js.map

package/dist/affected/reach-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach-of.js","sourceRoot":"","sources":["../../src/affected/reach-of.ts"],"names":[],"mappings":"AAGA,iJAAiJ;AACjJ,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,MAAc,EAAE,IAAY;IAClD,MAAM,QAAQ,GAAG,GAAG,MAAM,CAAC,WAAW,GAAG,CAAC;IAE1C,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9B,OAAO,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAC7B,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI,6BAA6B,EAAE,CAAC;AAC9E,CAAC;AAED,SAAS,YAAY,CAAC,MAAc,EAAE,MAAc;IAClD,MAAM,CAAC,OAAO,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAElD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;QAChE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,WAAW,IAAI,MAAM,iCAAiC,EAAE,CAAC;IAC1G,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC;AACrE,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAEnC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;AAClH,CAAC"}

package/dist/affected/select-affected.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '../config/index.js';
+import type { Selection } from './selection.js';
+/**
+ * What a change set has to run. A context whose sources changed is selected with every context
+ * downstream of it; a context whose tests alone changed is selected alone (no other context may
+ * import them); one path that is shared, or that nobody listed, selects everything. The
+ * selection is never narrower than the declared dependencies: `context/declared-relationship`
+ * keeps the imports inside them, and that rule runs on the whole project in every pipeline.
+ */
+export declare function selectAffected(config: Config, changed: readonly string[]): Selection;
+//# sourceMappingURL=select-affected.d.ts.map

package/dist/affected/select-affected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-affected.d.ts","sourceRoot":"","sources":["../../src/affected/select-affected.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CA2BpF"}

package/dist/affected/select-affected.js

@@ -0,0 +1,39 @@
+import { downstreamsOf } from './downstreams-of.js';
+import { everything } from './everything.js';
+import { reachOf } from './reach-of.js';
+/**
+ * What a change set has to run. A context whose sources changed is selected with every context
+ * downstream of it; a context whose tests alone changed is selected alone (no other context may
+ * import them); one path that is shared, or that nobody listed, selects everything. The
+ * selection is never narrower than the declared dependencies: `context/declared-relationship`
+ * keeps the imports inside them, and that rule runs on the whole project in every pipeline.
+ */
+export function selectAffected(config, changed) {
+    const reaches = changed.map((file) => reachOf(config, file));
+    const shared = reaches.find((reach) => reach.kind === 'everything');
+    if (shared !== undefined) {
+        return everything(config, shared.reason);
+    }
+    const selected = new Set(reaches.flatMap((reach) => contextsOf(config, reach)));
+    const declared = Object.keys(config.contexts);
+    const contexts = declared.filter((context) => selected.has(context));
+    if (contexts.length === 0) {
+        const reason = changed.length === 0 ? 'no file changed' : 'only documents changed';
+        return { scope: 'none', reason, contexts: [], specs: [], leftOut: [] };
+    }
+    const directory = (context) => `${config.contextsDir}/${context}/`;
+    return {
+        scope: contexts.length === declared.length ? 'all' : 'contexts',
+        reason: 'the changed contexts and the contexts downstream of them in the context map',
+        contexts,
+        specs: [...contexts.map((context) => `${directory(context)}**/*.spec.ts`), `!${config.contextsDir}/**`],
+        leftOut: declared.filter((context) => !selected.has(context)).map(directory),
+    };
+}
+function contextsOf(config, reach) {
+    if (reach.kind !== 'context') {
+        return [];
+    }
+    return reach.testsOnly ? [reach.context] : [reach.context, ...downstreamsOf(config, reach.context)];
+}
+//# sourceMappingURL=select-affected.js.map

package/dist/affected/select-affected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-affected.js","sourceRoot":"","sources":["../../src/affected/select-affected.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,OAA0B;IACvE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC;IAEpE,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAChF,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9C,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;IAErE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,wBAAwB,CAAC;QAEnF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACzE,CAAC;IAED,MAAM,SAAS,GAAG,CAAC,OAAe,EAAU,EAAE,CAAC,GAAG,MAAM,CAAC,WAAW,IAAI,OAAO,GAAG,CAAC;IAEnF,OAAO;QACL,KAAK,EAAE,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU;QAC/D,MAAM,EAAE,6EAA6E;QACrF,QAAQ;QACR,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,IAAI,MAAM,CAAC,WAAW,KAAK,CAAC;QACvG,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC;KAC7E,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CAAC,MAAc,EAAE,KAAgB;IAClD,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;AACtG,CAAC"}