ddd-ts-kit 0.1.1 → 0.3.0

package/README.md

@@ -47,8 +47,10 @@ 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]
+                [--dependencies signature|listed] [--refusals factories|classes]
                 [--package-manager npm|pnpm]
                 [--allow-no-outbox "<reason>"] [--import-alias '$<name>/']
+                [--import-extension none|js]
                 [--context <name>:<core|supporting|generic>]...
                 [--dry-run] [--force]
 ```
@@ -62,6 +64,22 @@ left alone, `--force` included. An existing `package.json` is merged: missing sc
 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
@@ -101,11 +119,32 @@ 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 errors are built by factories.** `init` writes `"stack.refusals": "factories"`: a
+context has one error class per concept, extending `ConceptError` of the kernel, and
+`generate error <context> <Concept> <refusal>` adds a static factory to it. The `errors/*`
+rules hold that form. `--refusals classes`, or a config without the key, keeps one class per
+error built with `new`, as 0.1 and 0.2 wrote them; `error-factories` moves a project from one
+to the other.
+
 **Domain events leave with the save.** A generated command handler builds or loads its aggregate,
 calls one intention method, `await repository.save(aggregate)` and returns: no `pullEvents()`, and
 no `DomainEventDispatcher` in a handler or in a repository adapter, which only persists. The events
@@ -164,7 +203,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`,
@@ -200,7 +239,8 @@ ddd-ts-kit generate --help --json
 | `entity` | `<context> <Name>` | entity, spec |
 | `value-object` (`vo`) | `<context> <Name>` | value object, spec |
 | `domain-event` | `<context> <Aggregate> <Fact>` | event named `<context>.<aggregate>.<fact>`, spec |
-| `domain-error` | `<context> <Name> [--code CODE]` | error with a stable code, spec |
+| `error` (`refusal`) | `<context> <Concept> <refusal> [--code CODE] [--term ...]...` | a static factory `<refusal>` on `domain/errors/<concept>.error.ts`, the class of the errors of that concept (created when absent, extending `ConceptError`), and its case in `test/unit/<concept>.error.spec.ts`. The factory is added after the last one; run again, the command changes nothing. `<Concept>` is a term of the glossary (`--term` adds it). The code is the name of the refusal in constant case, with the concept before it when the name is one word or a code of the kit (`Appointment notFound` sets `APPOINTMENT_NOT_FOUND`); `--code` takes one of the forms `errors/factory-name` accepts. Refused: a name such as `create` or `error1`, and a code already set in the context |
+| `domain-error` | `<context> <Name> [--code CODE]` | one class per error with a stable code, spec: the form of a project whose config says `"stack.refusals": "classes"` or nothing. Refused under `factories`, with the `generate error` command to run instead |
 | `domain-service` | `<context> <Name>` | service, spec |
 | `repository` | `<context> <Aggregate> [--tenant-scoped]` | the port `domain/repositories/<name>.repository.ts` (`abstract class <Name>Repository extends Repository<<Name>>`), the adapter of the project's ORM (`implements` the port) with its mapper and table (or model), a fake, one `repositoryContract` spec run on both, registration |
 | `command` | `<context> <UseCaseName> (--permission <aggregate>.<action> \| --public) [--aggregate <Name>]` | `<use-case>.command.ts` on `AuthorizedCommand` (plain `Command` when public), `<use-case>.handler.ts` (it builds the aggregate, saves it and answers: the events leave with the save), spec through the bus with the refusal of an actor who lacks the permission, registration with `.requires(...)` or `.public()` (and the repository when missing). A generated command answers `void` or the identifier of its aggregate, so no `<use-case>.result.ts` is written |
@@ -210,6 +250,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 |
@@ -222,17 +263,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
@@ -271,8 +312,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
@@ -349,7 +398,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;
@@ -371,6 +422,48 @@ published languages, declared upstreams, allowed packages, cycles and orphans. `
 it as `.dependency-cruiser.cjs`; `--check` exits 1 when the file is missing or stale, which is
 what `npm run depcruise` runs first. Edit the config, not the file.
 
+## error-factories
+
+```
+ddd-ts-kit error-factories --plan
+ddd-ts-kit error-factories --apply [--dry-run]
+```
+
+Moves a project from one class per error (`new SlotTakenError(..)`) to static factories on one
+error class per concept (`AppointmentError.slotTaken(..)`), in two steps, because which concept
+a refusal is about is a decision of the model.
+
+`--plan` writes `error-factories.plan.json`: per context, one entry per class of
+`domain/errors/` that extends `DomainError`, with its code, the concept proposed for it (the
+aggregate its name starts or ends with, empty when none does) and the factory name that says
+its code (`APPOINTMENT_NOT_FOUND` on `Appointment` gives `notFound`). Edit it: every entry
+needs a `concept`, a term of the glossary.
+
+`--apply` follows the plan and refuses an entry without a concept, a vague factory name or one
+that does not say the code. It:
+
+- writes `domain/errors/<concept>.error.ts`, a class extending `ConceptError` with one factory
+  per class moved there: the parameters of the constructor, the message it gave to `super`, and
+  as facts the parameters that are plain data (text, numbers, booleans, dates);
+- removes each class and its spec, whose cases go under `describe('<factory>')` in
+  `test/unit/<concept>.error.spec.ts`;
+- rewrites every file under the source root and `test/`: `new X(..)` becomes
+  `<Concept>Error.<factory>(..)`, `thenError(X)` and `thenError(X, code)` become
+  `thenError('<CODE>')`, `toThrow(X)` and `expect.any(X)` become an assertion on the code,
+  `toBeInstanceOf(X)` becomes `toMatchObject({ code })`, `e instanceof X` becomes
+  `<Concept>Error.is(e, '<CODE>')`, an import of the class becomes the import of its concept
+  class, and a type names the concept class. A class of the same name in two contexts goes to
+  the concept of its own. Comments and strings are left alone;
+- sets `"stack.refusals": "factories"` in the config.
+
+It leaves, and says: a class that has members of its own, reads `this` in its constructor or
+gives options to `super` (written by hand); a place where a class stood as a value it cannot
+translate; a property of the error that became a fact (`error.personId` is now
+`error.facts.personId`); a factory with more than three parameters. And always: which facts a
+client may read (none is exposed), the factories that still take a sentence as only parameter,
+and the facts to assert in the specs. Run the formatter afterwards. Run again, it finds nothing
+left to move. `--json` answers `{ dryRun, moved, written, removed, manual }`.
+
 ## build-aliases
 
 ```
@@ -378,10 +471,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
@@ -390,9 +487,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:
@@ -541,7 +642,7 @@ saying what to do instead. Exit code 1 when there is at least one error.
 | `test/builder-required` | an aggregate without `test/builders/<name>.builder.ts` |
 | `events/name-format` | an event name that is not `<context>.<aggregate>.<fact>` in kebab-case with the right context |
 | `events/defined-in-published-language` | `defineIntegrationEvent` outside a published language, without a payload, twice for one version; an event described by hand |
-| `language/glossary-term` | a class of the model named with a word the glossary of its context does not define; an empty glossary |
+| `language/glossary-term` | a class of the model named with a word the glossary of its context does not define; an empty glossary; under `"stack.refusals": "factories"`, an error class of `domain/errors/` too |
 | `language/no-technical-name` | `Manager`, `Helper`, `Util`, `Utils`, `Data`, `Info`, `Processor`, `Wrapper`, `Impl`, `Base`, `Abstract`, `Dto`, `Entity`, `Model` in a type declared under `domain/` or in a use case folder |
 | `purity/no-system-clock` | `new Date()` without argument, `Date.now()`, `performance.now()` in `domain/` or `application/` |
 | `purity/no-ambient-randomness` | `Math.random`, the random source of `crypto`, an id library |
@@ -559,8 +660,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/` |
@@ -575,14 +677,17 @@ 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 |
+| `errors/code-unique` | under `"stack.refusals": "factories"`, in the `domain/errors/` of a context: a code set a second time, by a factory (`refusal('CODE', ..)`) or by a class (`readonly code = 'CODE'`), with the file and line of the first. The same code in two contexts is not reported |
+| `errors/known-code` | under `"stack.refusals": "factories"`, in a `*.route.ts`: a code of the `errors` list that no refusal of the context of the route sets, that no class outside the contexts sets, and that is not a code of the kit |
 
 Five more ids belong to `@ddd-ts-kit/eslint-plugin`, which reads the syntax tree where this
 checker reads text: `domain/aggregate-encapsulation`, `domain/value-object-immutability`,
@@ -692,6 +797,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

package/dist/alias/compiler-resolution-of.d.ts

@@ -0,0 +1,10 @@
+import type { CompilerResolution } from './compiler-resolution.js';
+/**
+ * What `init` writes in tsconfig.json for "importExtension". `Bundler` resolves a specifier
+ * without its extension and still reports one that names no file; it reads the `exports` of a
+ * package without the `node` condition, which is given back to it so that the compiler and Node
+ * take the same entry. `NodeNext` resolves as Node does and requires the extension. Both emit
+ * ECMAScript modules, which `build-aliases` completes.
+ */
+export declare function compilerResolutionOf(importExtension: string): CompilerResolution;
+//# sourceMappingURL=compiler-resolution-of.d.ts.map

package/dist/alias/compiler-resolution-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-resolution-of.d.ts","sourceRoot":"","sources":["../../src/alias/compiler-resolution-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,kBAAkB,CAIhF"}

package/dist/alias/compiler-resolution-of.js

@@ -0,0 +1,13 @@
+/**
+ * What `init` writes in tsconfig.json for "importExtension". `Bundler` resolves a specifier
+ * without its extension and still reports one that names no file; it reads the `exports` of a
+ * package without the `node` condition, which is given back to it so that the compiler and Node
+ * take the same entry. `NodeNext` resolves as Node does and requires the extension. Both emit
+ * ECMAScript modules, which `build-aliases` completes.
+ */
+export function compilerResolutionOf(importExtension) {
+    return importExtension === 'none'
+        ? { module: 'ESNext', moduleResolution: 'Bundler', customConditions: ['node'] }
+        : { module: 'NodeNext', moduleResolution: 'NodeNext' };
+}
+//# sourceMappingURL=compiler-resolution-of.js.map

package/dist/alias/compiler-resolution-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-resolution-of.js","sourceRoot":"","sources":["../../src/alias/compiler-resolution-of.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,eAAuB;IAC1D,OAAO,eAAe,KAAK,MAAM;QAC/B,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,MAAM,CAAC,EAAE;QAC/E,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;AAC3D,CAAC"}

package/dist/alias/compiler-resolution.d.ts

@@ -0,0 +1,8 @@
+/** The compiler options that decide how a specifier is resolved and what the compiler emits for it. */
+export interface CompilerResolution {
+    readonly module: string;
+    readonly moduleResolution: string;
+    /** The conditions added to the ones the resolution reads in the `exports` of a package. */
+    readonly customConditions?: readonly string[];
+}
+//# sourceMappingURL=compiler-resolution.d.ts.map

package/dist/alias/compiler-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-resolution.d.ts","sourceRoot":"","sources":["../../src/alias/compiler-resolution.ts"],"names":[],"mappings":"AAAA,uGAAuG;AACvG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,2FAA2F;IAC3F,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C"}

package/dist/alias/compiler-resolution.js

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

package/dist/alias/compiler-resolution.js.map

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

package/dist/alias/index.d.ts

@@ -2,12 +2,14 @@ export { aliasProblem } from './alias-problem.js';
 export type { AliasRoot } from './alias-root.js';
 export { aliasRoots } from './alias-roots.js';
 export { compilerPaths } from './compiler-paths.js';
+export { compilerResolutionOf } from './compiler-resolution-of.js';
 export { contextAlias } from './context-alias.js';
 export type { BuildLayout } from './build-layout.js';
 export { DEFAULT_BUILD_LAYOUT } from './default-build-layout.js';
 export { directoryAlias } from './directory-alias.js';
 export { FIXED_ALIAS_ROOTS } from './fixed-alias-roots.js';
 export { moduleNameMapper } from './module-name-mapper.js';
-export { platformAlias } from './platform-alias.js';
+export { specifierOf } from './specifier-of.js';
+export { specifierSuffix } from './specifier-suffix.js';
 export { toAlias } from './to-alias.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/alias/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/alias/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/alias/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}

package/dist/alias/index.js

@@ -1,11 +1,13 @@
 export { aliasProblem } from './alias-problem.js';
 export { aliasRoots } from './alias-roots.js';
 export { compilerPaths } from './compiler-paths.js';
+export { compilerResolutionOf } from './compiler-resolution-of.js';
 export { contextAlias } from './context-alias.js';
 export { DEFAULT_BUILD_LAYOUT } from './default-build-layout.js';
 export { directoryAlias } from './directory-alias.js';
 export { FIXED_ALIAS_ROOTS } from './fixed-alias-roots.js';
 export { moduleNameMapper } from './module-name-mapper.js';
-export { platformAlias } from './platform-alias.js';
+export { specifierOf } from './specifier-of.js';
+export { specifierSuffix } from './specifier-suffix.js';
 export { toAlias } from './to-alias.js';
 //# sourceMappingURL=index.js.map

package/dist/alias/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/alias/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/alias/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}

package/dist/alias/module-name-mapper.d.ts

@@ -1,7 +1,8 @@
 import type { AliasRoot } from './alias-root.js';
 /**
- * The `moduleNameMapper` of jest for these roots, which does not read tsconfig: an alias specifier,
- * written with the `.js` extension of the compiled file, answers the TypeScript source.
+ * The `moduleNameMapper` of jest for these roots, which does not read tsconfig: an alias
+ * specifier, written with `suffix` (the `.js` of the compiled file, or nothing), answers the
+ * TypeScript source and nothing else.
  */
-export declare function moduleNameMapper(roots: readonly AliasRoot[]): Record<string, string>;
+export declare function moduleNameMapper(roots: readonly AliasRoot[], suffix: string): Record<string, string>;
 //# sourceMappingURL=module-name-mapper.d.ts.map

package/dist/alias/module-name-mapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-name-mapper.d.ts","sourceRoot":"","sources":["../../src/alias/module-name-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOpF"}
+{"version":3,"file":"module-name-mapper.d.ts","sourceRoot":"","sources":["../../src/alias/module-name-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASpG"}

package/dist/alias/module-name-mapper.js

@@ -1,11 +1,13 @@
 const SPECIAL = /[.*+?^${}()|[\]\\]/g;
 /**
- * The `moduleNameMapper` of jest for these roots, which does not read tsconfig: an alias specifier,
- * written with the `.js` extension of the compiled file, answers the TypeScript source.
+ * The `moduleNameMapper` of jest for these roots, which does not read tsconfig: an alias
+ * specifier, written with `suffix` (the `.js` of the compiled file, or nothing), answers the
+ * TypeScript source and nothing else.
  */
-export function moduleNameMapper(roots) {
+export function moduleNameMapper(roots, suffix) {
+    const ending = suffix.replace(SPECIAL, String.raw `\$&`);
     return Object.fromEntries(roots.map(({ prefix, directory }) => [
-        String.raw `^${prefix.replace(SPECIAL, String.raw `\$&`)}(.*)\.js$`,
+        `^${prefix.replace(SPECIAL, String.raw `\$&`)}(.*)${ending}$`,
         `<rootDir>/${directory}/$1.ts`,
     ]));
 }

package/dist/alias/module-name-mapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"module-name-mapper.js","sourceRoot":"","sources":["../../src/alias/module-name-mapper.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,GAAG,qBAAqB,CAAC;AAEtC;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA2B;IAC1D,OAAO,MAAM,CAAC,WAAW,CACvB,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;QACnC,MAAM,CAAC,GAAG,CAAA,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,CAAA,KAAK,CAAC,WAAW;QACjE,aAAa,SAAS,QAAQ;KAC/B,CAAC,CACH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"module-name-mapper.js","sourceRoot":"","sources":["../../src/alias/module-name-mapper.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,GAAG,qBAAqB,CAAC;AAEtC;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA2B,EAAE,MAAc;IAC1E,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,CAAA,KAAK,CAAC,CAAC;IAExD,OAAO,MAAM,CAAC,WAAW,CACvB,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;QACnC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,CAAA,KAAK,CAAC,OAAO,MAAM,GAAG;QAC5D,aAAa,SAAS,QAAQ;KAC/B,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/alias/specifier-of.d.ts

@@ -0,0 +1,7 @@
+import { type Config } from '../config/index.js';
+/**
+ * How a generated import names a file of the project, given from the project root with or
+ * without its extension: by its alias, ending as "importExtension" says.
+ */
+export declare function specifierOf(config: Config, file: string): string;
+//# sourceMappingURL=specifier-of.d.ts.map

package/dist/alias/specifier-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifier-of.d.ts","sourceRoot":"","sources":["../../src/alias/specifier-of.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAK9D;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAWhE"}

package/dist/alias/specifier-of.js

@@ -0,0 +1,17 @@
+import { CliError } from '../cli-error.js';
+import { CONFIG_FILE } from '../config/index.js';
+import { aliasRoots } from './alias-roots.js';
+import { specifierSuffix } from './specifier-suffix.js';
+import { toAlias } from './to-alias.js';
+/**
+ * How a generated import names a file of the project, given from the project root with or
+ * without its extension: by its alias, ending as "importExtension" says.
+ */
+export function specifierOf(config, file) {
+    const specifier = toAlias(aliasRoots(config), file, specifierSuffix(config.importExtension));
+    if (specifier === undefined) {
+        throw new CliError(`${file} is under no directory an import alias names.`, `Keep it under the source root in ${CONFIG_FILE}: a file is imported by an alias, never by a relative path.`);
+    }
+    return specifier;
+}
+//# sourceMappingURL=specifier-of.js.map

package/dist/alias/specifier-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifier-of.js","sourceRoot":"","sources":["../../src/alias/specifier-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAe,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,IAAY;IACtD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC;IAE7F,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,IAAI,QAAQ,CAChB,GAAG,IAAI,+CAA+C,EACtD,oCAAoC,WAAW,6DAA6D,CAC7G,CAAC;IACJ,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/alias/specifier-suffix.d.ts

@@ -0,0 +1,6 @@
+/**
+ * What an alias specifier ends with under "importExtension": nothing for `none`, `.js` otherwise.
+ * A value `check` reports as wrong is read as `js`, which is what a config without the key means.
+ */
+export declare function specifierSuffix(importExtension: string): '' | '.js';
+//# sourceMappingURL=specifier-suffix.d.ts.map

package/dist/alias/specifier-suffix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifier-suffix.d.ts","sourceRoot":"","sources":["../../src/alias/specifier-suffix.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,EAAE,GAAG,KAAK,CAEnE"}

package/dist/alias/specifier-suffix.js

@@ -0,0 +1,8 @@
+/**
+ * What an alias specifier ends with under "importExtension": nothing for `none`, `.js` otherwise.
+ * A value `check` reports as wrong is read as `js`, which is what a config without the key means.
+ */
+export function specifierSuffix(importExtension) {
+    return importExtension === 'none' ? '' : '.js';
+}
+//# sourceMappingURL=specifier-suffix.js.map

package/dist/alias/specifier-suffix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifier-suffix.js","sourceRoot":"","sources":["../../src/alias/specifier-suffix.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,eAAuB;IACrD,OAAO,eAAe,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AACjD,CAAC"}

package/dist/alias/to-alias.d.ts

@@ -1,7 +1,8 @@
 import type { AliasRoot } from './alias-root.js';
 /**
  * The specifier that names a file of the project, given by its path from the project root with
- * or without its extension; nothing when the file is under no aliased tree.
+ * or without its extension, ending with `suffix` (`.js`, or nothing); nothing when the file is
+ * under no aliased tree.
  */
-export declare function toAlias(roots: readonly AliasRoot[], file: string): string | undefined;
+export declare function toAlias(roots: readonly AliasRoot[], file: string, suffix: string): string | undefined;
 //# sourceMappingURL=to-alias.d.ts.map

package/dist/alias/to-alias.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-alias.d.ts","sourceRoot":"","sources":["../../src/alias/to-alias.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQrF"}
+{"version":3,"file":"to-alias.d.ts","sourceRoot":"","sources":["../../src/alias/to-alias.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQrG"}

package/dist/alias/to-alias.js

@@ -1,13 +1,14 @@
 const EXTENSION = /\.(?:ts|js)$/;
 /**
  * The specifier that names a file of the project, given by its path from the project root with
- * or without its extension; nothing when the file is under no aliased tree.
+ * or without its extension, ending with `suffix` (`.js`, or nothing); nothing when the file is
+ * under no aliased tree.
  */
-export function toAlias(roots, file) {
+export function toAlias(roots, file, suffix) {
     const root = roots.find(({ directory }) => file.startsWith(`${directory}/`));
     if (root === undefined) {
         return undefined;
     }
-    return `${root.prefix}${file.slice(root.directory.length + 1).replace(EXTENSION, '')}.js`;
+    return `${root.prefix}${file.slice(root.directory.length + 1).replace(EXTENSION, '')}${suffix}`;
 }
 //# sourceMappingURL=to-alias.js.map

package/dist/alias/to-alias.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-alias.js","sourceRoot":"","sources":["../../src/alias/to-alias.ts"],"names":[],"mappings":"AAEA,MAAM,SAAS,GAAG,cAAc,CAAC;AAEjC;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,KAA2B,EAAE,IAAY;IAC/D,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IAE7E,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC;AAC5F,CAAC"}
+{"version":3,"file":"to-alias.js","sourceRoot":"","sources":["../../src/alias/to-alias.ts"],"names":[],"mappings":"AAEA,MAAM,SAAS,GAAG,cAAc,CAAC;AAEjC;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,KAA2B,EAAE,IAAY,EAAE,MAAc;IAC/E,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IAE7E,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC;AAClG,CAAC"}

package/dist/build/emitted-place.d.ts

@@ -3,6 +3,8 @@ import type { AliasRoot, BuildLayout } from '../alias/index.js';
 export interface EmittedPlace {
     readonly roots: readonly AliasRoot[];
     readonly layout: BuildLayout;
+    /** What an alias specifier ends with in the sources: `.js`, or nothing. */
+    readonly suffix: string;
     /** Whether a path, given from the project root, is a file. */
     readonly isFile: (file: string) => boolean;
 }

package/dist/build/emitted-place.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emitted-place.d.ts","sourceRoot":"","sources":["../../src/build/emitted-place.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhE,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C"}
+{"version":3,"file":"emitted-place.d.ts","sourceRoot":"","sources":["../../src/build/emitted-place.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhE,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C"}

package/dist/build/emitted-specifier.d.ts

@@ -1,8 +1,9 @@
 import type { EmittedPlace } from './emitted-place.js';
 /**
  * The relative specifier that names, from an emitted file, the emitted file an alias specifier
- * stands for, with its `.js` extension; nothing when the build emitted no such file. Both files
- * are given from the project root.
+ * stands for, always with its `.js` extension: Node resolves no other spelling. Nothing when the
+ * build emitted no such file, or when the specifier is not written as the project writes its
+ * imports. Both files are given from the project root.
  */
 export declare function emittedSpecifier(place: EmittedPlace, file: string, specifier: string): string | undefined;
 //# sourceMappingURL=emitted-specifier.d.ts.map