ddd-ts-kit 0.0.0-stage → 0.1.1

package/dist/check/explain/context-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/context-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0C1D,CAAC"}

package/dist/check/explain/context-docs.js

@@ -0,0 +1,44 @@
+export const CONTEXT_DOCS = {
+    'context/published-language-only': {
+        why: 'A bounded context owns its model and must be free to change it. The published language is the only part designed for others; importing anything else couples two models and turns every refactoring into a cross-team negotiation.',
+        bad: `// contexts/shipping/application/...
+import { Invoice } from '@/contexts/billing/domain/aggregates/invoice.aggregate.js';`,
+        good: `// contexts/shipping/application/...
+import type { InvoiceIssuedV1 } from '@/contexts/billing/published-language/index.js';`,
+    },
+    'context/declared-relationship': {
+        why: 'The context map is a strategic decision, not a side effect of an import. Declaring the upstream and the pattern keeps the map reviewable and lets the cycle check work.',
+        bad: `// shipping imports billing/published-language, config has "shipping": { "upstreams": [] }`,
+        good: `"shipping": { "classification": "supporting",
+  "upstreams": [{ "context": "billing", "relationship": "published-language" }] }`,
+    },
+    'context/published-language-is-a-contract': {
+        why: 'A contract that re-exports a domain class is no contract: consumers get the internal model and its behaviour through the back door. The published language holds serializable types that are versioned on purpose.',
+        bad: `// published-language/index.ts
+export { Invoice } from '@/contexts/billing/domain/aggregates/invoice.aggregate.js';`,
+        good: `// published-language/invoice-issued.v1.integration-event.ts
+export interface InvoiceIssuedV1Payload { readonly invoiceId: string }`,
+    },
+    'context/no-cycle': {
+        why: 'Two contexts that are upstream of each other are one context with a line drawn through it: neither can be changed, deployed or understood alone. One of them has to be the supplier.',
+        bad: `"billing": { "upstreams": [{ "context": "shipping" }] },
+"shipping": { "upstreams": [{ "context": "billing" }] }`,
+        good: `"billing": { "upstreams": [] },
+"shipping": { "upstreams": [{ "context": "billing" }] }`,
+    },
+    'context/extractable': {
+        why: 'A bounded context is a deployable unit in waiting. Moving one to its own service must change a composition root and adapters, never domain or application code. A module that wires another context, a repository that reads its tables, a handler that loads its aggregates or a map shared through an export all hold only while both live in one process and one database. In the declared style the wiring is written on the classes: a role file that imports a port of another context (anything of its domain/repositories/*.repository.ts or application/ports/*.port.ts) ties the composition of the two, so ports come from the context itself, the kernel, @ddd-ts-kit/auth and the platform.',
+        bad: `// contexts/shipping/infrastructure/persistence/drizzle-parcel.repository.ts
+import { invoices } from '@/contexts/billing/infrastructure/persistence/invoice.schema.js';
+export const cache = new Map<string, Parcel>();
+// contexts/shipping/application/commands/ship-parcel/ship-parcel.handler.ts, declared style
+import { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';`,
+        good: `// contexts/shipping/application/ports/invoice-status.gateway.port.ts
+export abstract class InvoiceStatusGateway { abstract isPaid(invoiceId: string): Promise<boolean>; }
+// contexts/shipping/infrastructure/external/in-process-invoice-status.gateway.ts
+import type { InvoiceStatus } from '@/contexts/billing/published-language/index.js';
+// contexts/shipping/application/commands/ship-parcel/ship-parcel.handler.ts, declared style
+import { InvoiceStatusGateway } from '@/contexts/shipping/application/ports/invoice-status.gateway.port.js';`,
+    },
+};
+//# sourceMappingURL=context-docs.js.map

package/dist/check/explain/context-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-docs.js","sourceRoot":"","sources":["../../../src/check/explain/context-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAsC;IAC7D,iCAAiC,EAAE;QACjC,GAAG,EAAE,oOAAoO;QACzO,GAAG,EAAE;qFAC4E;QACjF,IAAI,EAAE;uFAC6E;KACpF;IACD,+BAA+B,EAAE;QAC/B,GAAG,EAAE,yKAAyK;QAC9K,GAAG,EAAE,4FAA4F;QACjG,IAAI,EAAE;kFACwE;KAC/E;IACD,0CAA0C,EAAE;QAC1C,GAAG,EAAE,oNAAoN;QACzN,GAAG,EAAE;qFAC4E;QACjF,IAAI,EAAE;uEAC6D;KACpE;IACD,kBAAkB,EAAE;QAClB,GAAG,EAAE,sLAAsL;QAC3L,GAAG,EAAE;wDAC+C;QACpD,IAAI,EAAE;wDAC8C;KACrD;IACD,qBAAqB,EAAE;QACrB,GAAG,EAAE,0qBAA0qB;QAC/qB,GAAG,EAAE;;;;kGAIyF;QAC9F,IAAI,EAAE;;;;;6GAKmG;KAC1G;CACF,CAAC"}

package/dist/check/explain/events-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const EVENTS_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=events-docs.d.ts.map

package/dist/check/explain/events-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/events-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyEzD,CAAC"}

package/dist/check/explain/events-docs.js

@@ -0,0 +1,75 @@
+export const EVENTS_DOCS = {
+    'events/name-format': {
+        why: 'Event names are routing keys and part of the public contract. A uniform <context>.<aggregate>.<fact> name tells who owns the event and what happened, and never collides across contexts.',
+        bad: `readonly name = 'InvoiceIssued';`,
+        good: `readonly name = 'billing.invoice.issued';`,
+    },
+    'events/defined-in-published-language': {
+        why: 'Integration events are the only way two contexts communicate, so their shape is a public contract. One declaration with a payload schema gives the type, validates what is published and consumed, and feeds the generated catalog and AsyncAPI document. An event described by hand, or declared twice, drifts from what is really sent.',
+        bad: `// application/integration/publishers/invoice-issued.publisher.ts
+const event = { type: 'billing.invoice.issued', version: 1, payload };`,
+        good: `// published-language/invoice-issued.v1.integration-event.ts
+export const invoiceIssuedV1 = defineIntegrationEvent({
+  type: 'billing.invoice.issued', version: 1, payload: zodSchema(z.object({ invoiceId: z.string() })),
+});`,
+    },
+    'events/outbox-required': {
+        why: 'Publishing an event and committing the state change it describes must succeed or fail together. A handler that talks to a broker or a bus publishes events of transactions that roll back, and loses events when the broker is down. Written to the outbox in the transaction of the command, the event is relayed afterwards, whatever the transport.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+import { connect } from 'amqplib';
+// ddd-ts-kit.config.json
+"stack": { "orm": "drizzle", "events": "in-memory" }`,
+        good: `// application/commands/issue-invoice/issue-invoice.handler.ts
+constructor(private readonly publisher: IntegrationEventPublisher) {}
+// platform/platform.module.ts
+eventPublisher: new OutboxPublisher(persistence.outbox),`,
+    },
+    'events/consumer-idempotent': {
+        why: 'Delivery is at least once: a consumer sees the same event again after a retry, a restart or a replay. The processed-event store recognises a redelivery by the pair consumer name and event id, in the transaction of the handler. A consumer without a name, or sharing the name of another, either handles events twice or skips events it never handled. An integration event handler class that carries @IntegrationEventHandler(definition, { consumer }) is named by its declaration and needs no registration; the name is a string literal, and it is unique across declarations and registrations alike.',
+        bad: `// billing.module.ts
+subscriber.subscribe('catalog.product.listed', (event) => productListedHandler.handle(event));
+// application/integration/handlers/product-listed.integration-handler.ts
+@IntegrationEventHandler(productListedV1, { consumer: CONSUMER_NAME }, [CommandBus])`,
+        good: `// billing.module.ts
+builder.on(productListedV1, { consumer: 'billing.product-listed' }).handledBy(ProductListedHandler, [CommandBus]);
+// or, wired by hand
+consume(productListedV1, { consumer: 'billing.product-listed', processed, unitOfWork }, (event) => productListedHandler.handle(event));
+// or declared on the class
+@IntegrationEventHandler(productListedV1, { consumer: 'billing.product-listed' }, [CommandBus])
+export class ProductListedHandler {}`,
+    },
+    'domain-events/dispatched-on-save': {
+        why: 'Domain events leave with the save. Once a repository method that was handed an aggregate resolves, the events the aggregate recorded are dispatched in order, inside the unit of work of the command, so their handlers and the outbox commit or roll back with the state. A handler that pulls the events and dispatches them itself announces them twice or outside the transaction, and a repository adapter that dispatches mixes persistence with wiring. Reported: a call to pullEvents() in application/ or infrastructure/ of a context, and DomainEventDispatcher imported, listed as a dependency or received by a constructor in application/commands, application/queries and a repository adapter. The module file, the tests, the platform and main.ts are left alone.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, DomainEventDispatcher])
+await this.invoices.save(invoice);
+await this.dispatcher.dispatch(invoice.pullEvents());`,
+        good: `// application/commands/issue-invoice/issue-invoice.handler.ts
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository])
+await this.invoices.save(invoice);
+// a removal that announces an event takes the aggregate
+await this.invoices.remove(invoice);`,
+    },
+    'domain-events/transactional-before-commit': {
+        why: "An effect of a domain event exists only if the state change that recorded the event is committed. A handler that runs before the commit runs inside the transaction, and the commit can still fail after it ran (a deferred constraint, a serialization failure, a lost connection): that is safe only when the rollback undoes everything the handler did, so a before-commit handler has transactional effects only. Judged: every production class of application/event-handlers/*.event-handler.ts and application/integration/publishers/*.publisher.ts, and any class carrying @DomainEventHandler. Its phase is after-commit when its decorator says phase: 'after-commit', or, without a decorator, when every .on(..) of <context>.module.ts whose callback mentions it has a third argument holding phase: 'after-commit'; otherwise it is before-commit. Its dependencies are the names of its dependency list, of .toClass(Handler, [..]) and the types of its constructor parameters, resolved through the imports. Before the commit it may depend on the domain/ of its context, on the kernel ports except Cache, Lock, RateLimiter, JobScheduler and EventBus, on @ddd-ts-kit/auth, on application helpers of its context, and on a port of application/ports/ only when it is a persistence port: at least one production class implements it under infrastructure/persistence/ and none anywhere else under infrastructure/. Refused: those five kernel ports, any other port of application/ports/, anything of infrastructure/, of another context, of the platform or of another package. An after-commit handler is refused IntegrationEventPublisher alone: after the commit nothing makes the outbox row atomic with a state change, so it sends a command instead.",
+        bad: `// application/event-handlers/invoice-issued.event-handler.ts
+// Mailer is implemented under infrastructure/external/: the mail leaves even when the commit fails
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued' }, [InvoiceRepository, Mailer, Cache])
+// after the commit the outbox row would be written in no transaction
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued', phase: 'after-commit' }, [IntegrationEventPublisher])`,
+        good: `// application/event-handlers/invoice-issued.event-handler.ts: repositories, persistence ports, buses
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued' }, [InvoiceRepository, CommandBus])
+// an effect that may be lost on a crash runs after the commit, at most once
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued', phase: 'after-commit' }, [Cache])
+// explicit style, in billing.module.ts
+platform.domainEvents.on('billing.invoice.issued', async (event) => {
+  if (event instanceof InvoiceIssued) {
+    await invoiceIssuedEventHandler.handle(event);
+  }
+}, { phase: 'after-commit' });
+// an effect that must not be lost: a publisher writes to the outbox, the handler of that event does the work
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued' }, [IntegrationEventPublisher, IdGenerator])
+export class InvoiceIssuedPublisher {}`,
+    },
+};
+//# sourceMappingURL=events-docs.js.map

package/dist/check/explain/events-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-docs.js","sourceRoot":"","sources":["../../../src/check/explain/events-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAsC;IAC5D,oBAAoB,EAAE;QACpB,GAAG,EAAE,2LAA2L;QAChM,GAAG,EAAE,kCAAkC;QACvC,IAAI,EAAE,2CAA2C;KAClD;IACD,sCAAsC,EAAE;QACtC,GAAG,EAAE,2UAA2U;QAChV,GAAG,EAAE;uEAC8D;QACnE,IAAI,EAAE;;;IAGN;KACD;IACD,wBAAwB,EAAE;QACxB,GAAG,EAAE,wVAAwV;QAC7V,GAAG,EAAE;;;qDAG4C;QACjD,IAAI,EAAE;;;yDAG+C;KACtD;IACD,4BAA4B,EAAE;QAC5B,GAAG,EAAE,mlBAAmlB;QACxlB,GAAG,EAAE;;;qFAG4E;QACjF,IAAI,EAAE;;;;;;qCAM2B;KAClC;IACD,kCAAkC,EAAE;QAClC,GAAG,EAAE,svBAAsvB;QAC3vB,GAAG,EAAE;;;sDAG6C;QAClD,IAAI,EAAE;;;;qCAI2B;KAClC;IACD,2CAA2C,EAAE;QAC3C,GAAG,EAAE,8rDAA8rD;QACnsD,GAAG,EAAE;;;;2HAIkH;QACvH,IAAI,EAAE;;;;;;;;;;;;uCAY6B;KACpC;CACF,CAAC"}

package/dist/check/explain/imports-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const IMPORTS_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=imports-docs.d.ts.map

package/dist/check/explain/imports-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/imports-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA6B1D,CAAC"}

package/dist/check/explain/imports-docs.js

@@ -0,0 +1,31 @@
+export const IMPORTS_DOCS = {
+    'imports/alias-only': {
+        why: 'An alias names a file from the root of the project: the import reads the same from every file, says which context and which layer it reaches without counting "../", and does not change when the importing file moves. One way of writing an import also means one thing to review and one thing for the boundary rules to read: the checker, ESLint and dependency-cruiser resolve an alias exactly as they resolve a relative path, so no boundary is crossed by choosing the other spelling. The rule holds under the source root, test/ and scripts/, the same directory included, for import, export ... from and import(). The alias is declared once, under "paths" in tsconfig.json, and the build rewrites it into a relative path in the compiled output, which runs with plain `node`. An alias path with a "." or ".." segment is refused too, since it could name a file outside its directory. The compiler reports an alias that names no file; a JavaScript file at the project root (a config, a migration) is not judged. ESLint fixes the import (`eslint --fix`).',
+        bad: `// src/contexts/billing/application/commands/issue-invoice/issue-invoice.handler.ts
+import { Invoice } from '../../../domain/aggregates/invoice.aggregate.js';
+import { IssueInvoiceCommand } from './issue-invoice.command.js';`,
+        good: `// src/contexts/billing/application/commands/issue-invoice/issue-invoice.handler.ts
+import { IssueInvoiceCommand } from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.command.js';
+import { Invoice } from '@/contexts/billing/domain/aggregates/invoice.aggregate.js';
+// test/e2e/issue-invoice.e2e.spec.ts
+import { startApplication } from '$test/e2e/support/start-application.js';`,
+    },
+    'imports/alias-declared': {
+        why: 'An alias is declared in one place and resolved by many tools: the compiler, the dev runner, the test runner, ESLint, the checker, dependency-cruiser, knip, and the build that makes the output runnable. If two of them disagree, the type check passes on one file while production loads another, or a boundary rule stops seeing an import. So there is one source a person edits, "importAlias" in ddd-ts-kit.config.json, and one declaration derived from it that the tools read, "paths" in tsconfig.json. Node reads neither: the compiler emits an alias as it was written, so `ddd-ts-kit build-aliases` rewrites each one into a relative path after the compiler, and the output runs with plain `node`. The rule compares "paths" (tsconfig.json and tsconfig.build.json) with "importAlias", refuses a second entry under an alias, a "baseUrl" and a knip "paths"; checks that vitest and dependency-cruiser read tsconfig and that jest, which does not, repeats the same mapping; reports a script that compiles without the rewrite step and a tsx script under another tsconfig. An alias is "@/" or "$<name>/": neither can be the name of a package, so no installed dependency can ever take the place of a file of the project; "#<name>/" (a Node subpath import) and "@<name>/" (the name of a scope) are refused.',
+        bad: `// ddd-ts-kit.config.json
+"importAlias": "@/"
+// tsconfig.json
+"paths": { "@/*": ["./dist/src/*"] }
+// package.json
+"build": "tsc -p tsconfig.build.json"`,
+        good: `// ddd-ts-kit.config.json
+"importAlias": "@/"
+// tsconfig.json
+"paths": { "@/*": ["./src/*"], "$test/*": ["./test/*"], "$scripts/*": ["./scripts/*"] }
+// package.json
+"build": "tsc -p tsconfig.build.json && ddd-ts-kit build-aliases"
+// vitest.config.ts
+resolve: { tsconfigPaths: true }`,
+    },
+};
+//# sourceMappingURL=imports-docs.js.map

package/dist/check/explain/imports-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports-docs.js","sourceRoot":"","sources":["../../../src/check/explain/imports-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAsC;IAC7D,oBAAoB,EAAE;QACpB,GAAG,EAAE,whCAAwhC;QAC7hC,GAAG,EAAE;;kEAEyD;QAC9D,IAAI,EAAE;;;;2EAIiE;KACxE;IACD,wBAAwB,EAAE;QACxB,GAAG,EAAE,8wCAA8wC;QACnxC,GAAG,EAAE;;;;;sCAK6B;QAClC,IAAI,EAAE;;;;;;;iCAOuB;KAC9B;CACF,CAAC"}

package/dist/check/explain/language-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const LANGUAGE_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=language-docs.d.ts.map

package/dist/check/explain/language-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/language-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4B3D,CAAC"}

package/dist/check/explain/language-docs.js

@@ -0,0 +1,30 @@
+export const LANGUAGE_DOCS = {
+    'language/glossary-term': {
+        why: 'The ubiquitous language is the contract between the domain experts and the code. A class named with a word nobody defined is either a concept the experts do not know, or a synonym that will split the vocabulary in two. Writing the term and its meaning first forces the conversation that the name needs.',
+        bad: `// CONTEXT.md glossary: Invoice, Issue
+export class BillDispatcher {}`,
+        good: `// CONTEXT.md glossary: Invoice, Issue
+export class IssueInvoiceCommand {}`,
+    },
+    'language/no-technical-name': {
+        why: 'Manager, Helper, Data or Impl say how a class is built, not what it means. In the domain such a name marks a concept that was not discussed: the behaviour ends up in a bag that keeps growing. A domain expert never says "invoice manager".',
+        bad: `export class InvoiceManager {}`,
+        good: `export class InvoiceNumbering {}`,
+    },
+    'purity/no-system-clock': {
+        why: 'Code that reads the clock gives a different answer every time it runs, so its tests are either flaky or need a mocked module. Passing the instant in, from the Clock port, makes every rule about time testable with a fixed date and replayable in production.',
+        bad: `isOverdue(): boolean { return this.dueDate < new Date(); }`,
+        good: `isOverdue(now: Date): boolean { return this.dueDate < now; }`,
+    },
+    'purity/no-ambient-randomness': {
+        why: 'An identifier drawn inside the domain cannot be predicted by a test nor chosen by the caller (idempotent retries, imports of existing data). The IdGenerator port keeps the choice of the scheme in the composition root and gives tests readable, sequential identifiers.',
+        bad: `static create(): Invoice { return new Invoice(crypto.randomUUID()); }`,
+        good: `static create(id: string): Invoice { return new Invoice(id); }`,
+    },
+    'purity/no-environment': {
+        why: 'Reading the environment, logging to the console or touching the network from the domain or a handler hides a dependency that no constructor declares. The class then needs the real world, or a mocked module, to be tested. Every such access is a port with an adapter.',
+        bad: `if (process.env.FEATURE_X) console.log('issuing', invoice);`,
+        good: `constructor(private readonly features: FeatureFlags) {}`,
+    },
+};
+//# sourceMappingURL=language-docs.js.map

package/dist/check/explain/language-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-docs.js","sourceRoot":"","sources":["../../../src/check/explain/language-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAsC;IAC9D,wBAAwB,EAAE;QACxB,GAAG,EAAE,gTAAgT;QACrT,GAAG,EAAE;+BACsB;QAC3B,IAAI,EAAE;oCAC0B;KACjC;IACD,4BAA4B,EAAE;QAC5B,GAAG,EAAE,+OAA+O;QACpP,GAAG,EAAE,gCAAgC;QACrC,IAAI,EAAE,kCAAkC;KACzC;IACD,wBAAwB,EAAE;QACxB,GAAG,EAAE,iQAAiQ;QACtQ,GAAG,EAAE,4DAA4D;QACjE,IAAI,EAAE,8DAA8D;KACrE;IACD,8BAA8B,EAAE;QAC9B,GAAG,EAAE,4QAA4Q;QACjR,GAAG,EAAE,uEAAuE;QAC5E,IAAI,EAAE,gEAAgE;KACvE;IACD,uBAAuB,EAAE;QACvB,GAAG,EAAE,2QAA2Q;QAChR,GAAG,EAAE,6DAA6D;QAClE,IAAI,EAAE,yDAAyD;KAChE;CACF,CAAC"}

package/dist/check/explain/layer-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const LAYER_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=layer-docs.d.ts.map

package/dist/check/explain/layer-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/layer-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCxD,CAAC"}

package/dist/check/explain/layer-docs.js

@@ -0,0 +1,39 @@
+export const LAYER_DOCS = {
+    'layer/domain-purity': {
+        why: 'The domain is the part of the system that has to survive a change of framework, database or transport. Every outside import ties a business rule to a technical choice and makes it impossible to test without that choice. Values that come from the outside world (ids, time, randomness) enter as parameters. The packages that apply a concern from outside (@ddd-ts-kit/aspects, audit, redis, scheduling, sentry, tracing) are refused whatever `domainAllowedPackages` says. The kernel itself is allowed, its entry @ddd-ts-kit/kernel/declarations is not: a declaration is wiring, and the domain declares nothing, neither a decorator on a class nor a dependency list. A repository port is a plain abstract class.',
+        bad: `// domain/aggregates/invoice.aggregate.ts
+import { randomUUID } from 'node:crypto';
+import { IsEmail } from 'class-validator';
+import { Logged } from '@ddd-ts-kit/aspects/decorators';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';`,
+        good: `// domain/aggregates/invoice.aggregate.ts
+import { AggregateRoot } from '@ddd-ts-kit/kernel';
+import { Money } from '@/contexts/billing/domain/value-objects/money.vo.js';`,
+    },
+    'layer/application-inward': {
+        why: 'A use case orchestrates the domain and talks to the outside through ports. If it imports an adapter, a framework or a driver, the technical choice can no longer be replaced or faked, and the handler cannot be unit tested with plain fakes. Cross-cutting behaviour reaches a use case from outside: @ddd-ts-kit/aspects, audit, redis, scheduling, sentry and tracing are refused whatever `applicationAllowedPackages` says, their place is the composition root, a bus middleware or an adapter. The declarations of the kernel (@ddd-ts-kit/kernel/declarations) are part of the kernel and belong here: a handler, a job or a policy says what it is and names the ports it depends on, which are abstract classes, without knowing a container.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+import { PgInvoiceRepository } from '@/contexts/billing/infrastructure/persistence/pg-invoice.repository.js';
+import { RedisCache } from '@ddd-ts-kit/redis';
+import { retry } from '@ddd-ts-kit/aspects';`,
+        good: `// application/commands/issue-invoice/issue-invoice.handler.ts
+import { Cache, Clock } from '@ddd-ts-kit/kernel';
+import { CommandHandler } from '@ddd-ts-kit/kernel/declarations';
+import { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';`,
+    },
+    'layer/presentation-no-infrastructure': {
+        why: 'A route translates a transport request into a command or a query and maps the answer back. Reaching an adapter directly skips the use case, so the business rule that guards the operation is skipped too.',
+        bad: `// presentation/http/issue-invoice.route.ts
+import { PgInvoiceRepository } from '@/contexts/billing/infrastructure/persistence/pg-invoice.repository.js';`,
+        good: `// presentation/http/issue-invoice.route.ts
+import type { IssueInvoiceHandler } from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.handler.js';`,
+    },
+    'layer/infrastructure-no-presentation': {
+        why: 'Adapters implement ports declared inward. An adapter that knows a DTO or a route depends on one transport, and both outer layers start changing together.',
+        bad: `// infrastructure/persistence/pg-invoice.repository.ts
+import type { InvoiceDto } from '@/contexts/billing/presentation/http/invoice.dto.js';`,
+        good: `// infrastructure/persistence/pg-invoice.repository.ts
+import { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';`,
+    },
+};
+//# sourceMappingURL=layer-docs.js.map

package/dist/check/explain/layer-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-docs.js","sourceRoot":"","sources":["../../../src/check/explain/layer-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAsC;IAC3D,qBAAqB,EAAE;QACrB,GAAG,EAAE,ksBAAksB;QACvsB,GAAG,EAAE;;;;8DAIqD;QAC1D,IAAI,EAAE;;6EAEmE;KAC1E;IACD,0BAA0B,EAAE;QAC1B,GAAG,EAAE,0tBAA0tB;QAC/tB,GAAG,EAAE;;;6CAGoC;QACzC,IAAI,EAAE;;;kGAGwF;KAC/F;IACD,sCAAsC,EAAE;QACtC,GAAG,EAAE,4MAA4M;QACjN,GAAG,EAAE;8GACqG;QAC1G,IAAI,EAAE;2HACiH;KACxH;IACD,sCAAsC,EAAE;QACtC,GAAG,EAAE,2JAA2J;QAChK,GAAG,EAAE;uFAC8E;QACnF,IAAI,EAAE;kGACwF;KAC/F;CACF,CAAC"}

package/dist/check/explain/layout-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const LAYOUT_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=layout-docs.d.ts.map

package/dist/check/explain/layout-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/layout-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuEzD,CAAC"}

package/dist/check/explain/layout-docs.js

@@ -0,0 +1,73 @@
+export const LAYOUT_DOCS = {
+    'clean/no-hash-private': {
+        why: 'A code base has one way to hide a member. `private` is checked by the compiler, reads the same on a field, a method and a constructor parameter, and leaves the member reachable by the tooling of a test. `#name` is a second spelling of the same intention, with its own rules, that cannot be mixed with constructor parameters. ESLint can rewrite it when the change is safe.',
+        bad: `export class InMemoryInvoiceRepository {
+  readonly #rows = new Map<string, Invoice>();
+
+  #find(id: string): Invoice | undefined {
+    return this.#rows.get(id);
+  }
+}`,
+        good: `export class InMemoryInvoiceRepository {
+  private readonly rows = new Map<string, Invoice>();
+
+  private find(id: string): Invoice | undefined {
+    return this.rows.get(id);
+  }
+}`,
+    },
+    'clean/blank-lines': {
+        why: 'A function reads in steps: what it gathers, what it decides, what it answers. A blank line before `return` sets the outcome apart, and a block that starts and ends on its braces wastes no line. This checker holds the cheap part only: the `return` and the padded block. ESLint holds the blank lines between statements (after a group of declarations, around `if`, `for`, `try` and a multiline statement, between class members) and is authoritative, with an automatic fix; the formatter removes the padding of a block.',
+        bad: `function total(lines: readonly Line[]): Money {
+
+  const amounts = lines.map((line) => line.amount);
+  return sum(amounts);
+}`,
+        good: `function total(lines: readonly Line[]): Money {
+  const amounts = lines.map((line) => line.amount);
+
+  return sum(amounts);
+}`,
+    },
+    'clean/braces': {
+        why: 'A branch or a loop written between braces, its body on its own lines, is visible at a glance, and a statement added to it later cannot silently fall outside it. Every `if`, `else`, `for`, `while` and `do` is written that way, `else` on the line of the closing brace. A ternary, an arrow function returning an expression and a one-line object literal are not judged. ESLint holds the braces on the syntax tree (`curly`) and adds them; the formatter puts the body on its own lines.',
+        bad: `if (wrapped.has(repository)) return repository;
+
+for (const step of steps) await step();
+
+if (invoice.isPaid()) { return receipt; }`,
+        good: `if (wrapped.has(repository)) {
+  return repository;
+}
+
+for (const step of steps) {
+  await step();
+}
+
+if (invoice.isPaid()) {
+  return receipt;
+}`,
+    },
+    'clean/one-export-per-file': {
+        why: 'A file that exports one thing is named after it, found by its name and changed for one reason. A second exported class or function is a second responsibility hiding behind the first name. The companions that stay are the ones that are not a second thing: the types of its signature, its contract constants, a type sharing its name, and a small closed family (a type with its constructors, the accessors of one private state). An index file only re-exports: it says what a folder offers. Tests are not judged. This checker reads declarations as text, so the allowances are an approximation; ESLint is authoritative, and what neither can express is listed with its reason under "onePerFile.allow".',
+        bad: `// application/ports/gateways.port.ts
+export abstract class PaymentGateway {}
+export abstract class TaxGateway {}
+// domain/services/helpers.service.ts
+export class InvoiceNumbering {}`,
+        good: `// application/ports/payment-gateway.port.ts
+export abstract class PaymentGateway {}
+// application/ports/tax-gateway.port.ts
+export abstract class TaxGateway {}
+// application/commands/issue-invoice/issue-invoice.result.ts
+export interface IssueInvoiceResult { readonly invoiceId: string }`,
+    },
+    'clean/file-size': {
+        why: 'Past a few hundred lines a file holds more than one responsibility: nobody reads it whole, and every change touches something unrelated. The limit is 350 physical lines, for sources and tests alike, and is not configurable. A long test file is split by behaviour, a long source by concept. Generated files (a path segment named generated) and declaration files are not judged.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts, 600 lines:
+// the handler, its validation, its mapping and three helpers`,
+        good: `// issue-invoice.handler.ts orchestrates, in 40 lines;
+// the rules it applies live in the aggregate and in a domain service, each in its file`,
+    },
+};
+//# sourceMappingURL=layout-docs.js.map

package/dist/check/explain/layout-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-docs.js","sourceRoot":"","sources":["../../../src/check/explain/layout-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAsC;IAC5D,uBAAuB,EAAE;QACvB,GAAG,EAAE,qXAAqX;QAC1X,GAAG,EAAE;;;;;;EAMP;QACE,IAAI,EAAE;;;;;;EAMR;KACC;IACD,mBAAmB,EAAE;QACnB,GAAG,EAAE,qgBAAqgB;QAC1gB,GAAG,EAAE;;;;EAIP;QACE,IAAI,EAAE;;;;EAIR;KACC;IACD,cAAc,EAAE;QACd,GAAG,EAAE,ieAAie;QACte,GAAG,EAAE;;;;0CAIiC;QACtC,IAAI,EAAE;;;;;;;;;;EAUR;KACC;IACD,2BAA2B,EAAE;QAC3B,GAAG,EAAE,yrBAAyrB;QAC9rB,GAAG,EAAE;;;;iCAIwB;QAC7B,IAAI,EAAE;;;;;mEAKyD;KAChE;IACD,iBAAiB,EAAE;QACjB,GAAG,EAAE,0XAA0X;QAC/X,GAAG,EAAE;8DACqD;QAC1D,IAAI,EAAE;wFAC8E;KACrF;CACF,CAAC"}

package/dist/check/explain/ports-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const PORTS_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=ports-docs.d.ts.map

package/dist/check/explain/ports-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/ports-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkExD,CAAC"}

package/dist/check/explain/ports-docs.js

@@ -0,0 +1,68 @@
+export const PORTS_DOCS = {
+    'ports/abstract-class': {
+        why: 'A port is a contract and, at once, the injection token under which its adapter is bound: the abstract class names the dependency and carries its type. A port that holds a body, a constructor, an initializer or a hidden member is no longer a contract: a fake or a plain object cannot stand for it, and the container refuses to bind it. An interface vanishes at run time and cannot be a token, so a port file declares none. One exception is a member: `static readonly tokenKey`, the identity of a port a published package exposes. Checked in domain/repositories/*.repository.ts and application/ports/*.port.ts.',
+        bad: `// application/ports/payment-gateway.port.ts
+export interface PaymentGateway { charge(invoiceId: string): Promise<void> }
+export abstract class Mailer {
+  private readonly sent = 0;
+  send(to: string): void {}
+}`,
+        good: `// application/ports/payment-gateway.port.ts
+export abstract class PaymentGateway {
+  abstract charge(invoiceId: string): Promise<void>;
+}
+// domain/repositories/invoice.repository.ts
+export abstract class InvoiceRepository extends Repository<Invoice> {}`,
+    },
+    'ports/implements-never-extends': {
+        why: 'An adapter says which contract it honours with `implements`, and the compiler holds it to that contract. Extending the port instead would inherit from a class that holds nothing, make the adapter a second port for the container, and is refused when the binding is registered. The rule reads the class behind @Repository, @Gateway and @Adapter, the class given to bind(P).toClass(C) or rebind(P).toClass(C), and every class of infrastructure/ that extends a class of a port file. A class bound to itself is no port and is left alone.',
+        bad: `// infrastructure/persistence/knex-invoice.repository.ts
+@Repository(InvoiceRepository, [Database, ExecutionScope, Clock])
+export class KnexInvoiceRepository extends InvoiceRepository {}
+// billing.module.ts
+builder.bind(PaymentGateway).toClass(StripePaymentGateway, [PaymentSettings]);   // class StripePaymentGateway {}`,
+        good: `// infrastructure/persistence/knex-invoice.repository.ts
+@Repository(InvoiceRepository, [Database, ExecutionScope, Clock])
+export class KnexInvoiceRepository implements InvoiceRepository {}
+// infrastructure/external/stripe-payment.gateway.ts
+export class StripePaymentGateway implements PaymentGateway {}`,
+    },
+    'ports/no-token-constant': {
+        why: 'The abstract class of a port is its injection token: it names the dependency, carries its type and lets the compiler check a dependency list against a constructor. A constant beside it (a token() call, a Symbol, a string, an UPPER_SNAKE_CASE name in a list) is a second name for the same thing that nothing ties to the type, and a file of tokens is one more place to keep in step with the ports. There is one way to name a dependency: the class.',
+        bad: `// application/ports/billing.ports.ts
+export const INVOICE_REPOSITORY = token<InvoiceRepository>('billing.InvoiceRepository');
+// application/commands/issue-invoice/issue-invoice.handler.ts
+@CommandHandler(IssueInvoiceCommand, [INVOICE_REPOSITORY, CLOCK])
+// billing.module.ts
+builder.bind(Symbol.for('billing.PaymentGateway')).toClass(StripePaymentGateway, []);`,
+        good: `// domain/repositories/invoice.repository.ts
+export abstract class InvoiceRepository extends Repository<Invoice> {}
+// application/commands/issue-invoice/issue-invoice.handler.ts
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, Clock])
+// billing.module.ts
+builder.bind(PaymentGateway).toClass(StripePaymentGateway, [PaymentSettings]);`,
+    },
+    'ports/no-concrete-dependency': {
+        why: 'A dependency list says what a class needs, not who provides it. A list that names an adapter of infrastructure/ or a fake of test/fakes/ ties the use case to one implementation: the adapter can no longer be replaced at the composition root, and a test can no longer give its fake. The list names the port, the constructor parameter is typed by it, and the choice of the implementation stays in one place.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+import { KnexInvoiceRepository } from '@/contexts/billing/infrastructure/persistence/knex-invoice.repository.js';
+
+@CommandHandler(IssueInvoiceCommand, [KnexInvoiceRepository, Clock])`,
+        good: `// application/commands/issue-invoice/issue-invoice.handler.ts
+import { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';
+
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, Clock])`,
+    },
+    'ports/value-import': {
+        why: 'A port named in a dependency list or given to bind is used as a value: the class itself is looked up in the container. `import type` erases the import when the file is compiled, so the list would hold undefined at run time, or the file would not compile. The import of a token is a plain import; `import type` stays right for a class that only types a parameter.',
+        bad: `import type { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';
+import { type Clock } from '@ddd-ts-kit/kernel';
+
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, Clock])`,
+        good: `import { Clock } from '@ddd-ts-kit/kernel';
+import { InvoiceRepository } from '@/contexts/billing/domain/repositories/invoice.repository.js';
+
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, Clock])`,
+    },
+};
+//# sourceMappingURL=ports-docs.js.map

package/dist/check/explain/ports-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports-docs.js","sourceRoot":"","sources":["../../../src/check/explain/ports-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAsC;IAC3D,sBAAsB,EAAE;QACtB,GAAG,EAAE,kmBAAkmB;QACvmB,GAAG,EAAE;;;;;EAKP;QACE,IAAI,EAAE;;;;;uEAK6D;KACpE;IACD,gCAAgC,EAAE;QAChC,GAAG,EAAE,shBAAshB;QAC3hB,GAAG,EAAE;;;;kHAIyG;QAC9G,IAAI,EAAE;;;;+DAIqD;KAC5D;IACD,yBAAyB,EAAE;QACzB,GAAG,EAAE,+bAA+b;QACpc,GAAG,EAAE;;;;;sFAK6E;QAClF,IAAI,EAAE;;;;;+EAKqE;KAC5E;IACD,8BAA8B,EAAE;QAC9B,GAAG,EAAE,sZAAsZ;QAC3Z,GAAG,EAAE;;;qEAG4D;QACjE,IAAI,EAAE;;;iEAGuD;KAC9D;IACD,oBAAoB,EAAE;QACpB,GAAG,EAAE,4WAA4W;QACjX,GAAG,EAAE;;;iEAGwD;QAC7D,IAAI,EAAE;;;iEAGuD;KAC9D;CACF,CAAC"}

package/dist/check/explain/rule-docs.d.ts

@@ -0,0 +1,4 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+/** Shown by `ddd-ts-kit explain <rule-id>`: the reason behind the rule and one example each way. */
+export declare const RULE_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=rule-docs.d.ts.map

package/dist/check/explain/rule-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/rule-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAepD,oGAAoG;AACpG,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAcvD,CAAC"}

package/dist/check/explain/rule-docs.js

@@ -0,0 +1,30 @@
+import { AUTHZ_DOCS } from './authz-docs.js';
+import { CLEAN_DOCS } from './clean-docs.js';
+import { CONTEXT_DOCS } from './context-docs.js';
+import { EVENTS_DOCS } from './events-docs.js';
+import { IMPORTS_DOCS } from './imports-docs.js';
+import { LANGUAGE_DOCS } from './language-docs.js';
+import { LAYER_DOCS } from './layer-docs.js';
+import { LAYOUT_DOCS } from './layout-docs.js';
+import { PORTS_DOCS } from './ports-docs.js';
+import { SCHEDULING_DOCS } from './scheduling-docs.js';
+import { STANDARD_DOCS } from './standard-docs.js';
+import { TREE_DOCS } from './tree-docs.js';
+import { WIRING_DOCS } from './wiring-docs.js';
+/** Shown by `ddd-ts-kit explain <rule-id>`: the reason behind the rule and one example each way. */
+export const RULE_DOCS = {
+    ...AUTHZ_DOCS,
+    ...CLEAN_DOCS,
+    ...CONTEXT_DOCS,
+    ...EVENTS_DOCS,
+    ...IMPORTS_DOCS,
+    ...LANGUAGE_DOCS,
+    ...LAYER_DOCS,
+    ...LAYOUT_DOCS,
+    ...PORTS_DOCS,
+    ...SCHEDULING_DOCS,
+    ...STANDARD_DOCS,
+    ...TREE_DOCS,
+    ...WIRING_DOCS,
+};
+//# sourceMappingURL=rule-docs.js.map

package/dist/check/explain/rule-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-docs.js","sourceRoot":"","sources":["../../../src/check/explain/rule-docs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,oGAAoG;AACpG,MAAM,CAAC,MAAM,SAAS,GAAsC;IAC1D,GAAG,UAAU;IACb,GAAG,UAAU;IACb,GAAG,YAAY;IACf,GAAG,WAAW;IACd,GAAG,YAAY;IACf,GAAG,aAAa;IAChB,GAAG,UAAU;IACb,GAAG,WAAW;IACd,GAAG,UAAU;IACb,GAAG,eAAe;IAClB,GAAG,aAAa;IAChB,GAAG,SAAS;IACZ,GAAG,WAAW;CACf,CAAC"}

package/dist/check/explain/scheduling-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const SCHEDULING_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=scheduling-docs.d.ts.map

package/dist/check/explain/scheduling-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/scheduling-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmC7D,CAAC"}

package/dist/check/explain/scheduling-docs.js

@@ -0,0 +1,37 @@
+export const SCHEDULING_DOCS = {
+    'scheduling/job-triggers-use-case': {
+        why: 'A job says when something happens, a use case says what. A job that loads an aggregate, calls a repository or an adapter is a use case nobody can send by another way: no permission, no unit of work, no audit entry, no test through the bus. Kept to one command sent through the CommandBus port, the job is a line of schedule, and the work is a handler like any other. It lives in application/scheduling/*.job.ts, implements ScheduledJob, and depends on buses and ports only.',
+        bad: `// application/scheduling/send-reminders.job.ts
+import { Invoice } from '@/contexts/billing/domain/aggregates/invoice.aggregate.js';
+
+@Scheduled('billing.send-reminders', { every: '15m' }, [InvoiceRepository, Mailer])
+export class SendRemindersJob {
+  async run(): Promise<void> {
+    for (const invoice of await this.invoices.findOverdue()) {
+      await this.mailer.remind(invoice);
+    }
+  }
+}`,
+        good: `// application/scheduling/send-reminders.job.ts
+@Scheduled('billing.send-reminders', { every: '15m' }, [CommandBus])
+export class SendRemindersJob implements ScheduledJob {
+  constructor(private readonly commands: CommandBus) {}
+
+  async run(execution: JobExecution): Promise<void> {
+    await this.commands.execute(new SendRemindersCommand(systemActor('billing.send-reminders'), execution.scheduledAt));
+  }
+}`,
+    },
+    'scheduling/job-name': {
+        why: 'The name of a job is its identity everywhere a run leaves a trace: the scheduler and its lock, the settings that enable or reschedule it, the logs, the metrics and the audit trail, where the job is the system actor of the command it sends. It is written once as a string literal, `<context>.<job-name>` in lower-case kebab-case, so that it survives the renaming of a class and tells which context owns the job. Two jobs under one name share a lock and overwrite each other, so a name is unique in the project.',
+        bad: `@Scheduled(JOB_NAME, { every: '15m' }, [CommandBus])
+@Scheduled('SendReminders', { every: '15m' }, [CommandBus])
+// in contexts/billing
+builder.job('shipping.send-reminders', { every: '15m' }).handledBy(SendRemindersJob, [CommandBus]);
+new SendRemindersCommand(systemActor('billing.reminders'), execution.scheduledAt);`,
+        good: `@Scheduled('billing.send-reminders', { every: '15m' }, [CommandBus])
+builder.job('billing.send-reminders', { every: '15m' }).handledBy(SendRemindersJob, [CommandBus]);
+new SendRemindersCommand(systemActor('billing.send-reminders'), execution.scheduledAt);`,
+    },
+};
+//# sourceMappingURL=scheduling-docs.js.map

package/dist/check/explain/scheduling-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling-docs.js","sourceRoot":"","sources":["../../../src/check/explain/scheduling-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAsC;IAChE,kCAAkC,EAAE;QAClC,GAAG,EAAE,2dAA2d;QAChe,GAAG,EAAE;;;;;;;;;;EAUP;QACE,IAAI,EAAE;;;;;;;;EAQR;KACC;IACD,qBAAqB,EAAE;QACrB,GAAG,EAAE,+fAA+f;QACpgB,GAAG,EAAE;;;;mFAI0E;QAC/E,IAAI,EAAE;;wFAE8E;KACrF;CACF,CAAC"}

package/dist/check/explain/standard-docs.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDoc } from '../model/rule-doc.js';
+export declare const STANDARD_DOCS: Readonly<Record<string, RuleDoc>>;
+//# sourceMappingURL=standard-docs.d.ts.map

package/dist/check/explain/standard-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/standard-docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2C3D,CAAC"}