ddd-ts-kit 0.0.0-stage → 0.1.0

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"}

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

@@ -0,0 +1,45 @@
+export const STANDARD_DOCS = {
+    'aspects/outside-in': {
+        why: 'Logging, metrics, retry, timeout, circuit breaking and caching are applied from outside the code they wrap, so the policy of an application is read in one place and changes without touching a class. The decorator form is the exception: it is kept for an adapter whose policy is part of what the adapter is, in infrastructure/ or in the platform. On a route, a module file, a published language or the shared kernel it hides a policy where nobody looks for one.',
+        bad: `// presentation/http/issue-invoice.route.ts
+import { Retry } from '@ddd-ts-kit/aspects/decorators';`,
+        good: `// billing.module.ts
+builder.bind(PaymentGateway).toClass(StripePaymentGateway, [PaymentSettings]).with(retry({ attempts: 3 }), timeout(2000));
+// infrastructure/external/stripe-payment.gateway.ts
+import { Retry } from '@ddd-ts-kit/aspects/decorators';`,
+    },
+    'tracing/platform-only': {
+        why: 'Tracing is non-invasive and wired once. One action is one trace because every span is opened by the same few places: the request boundary, the bus middleware, the instrumentation around adapters and handlers, the outbox relay. A context that imports @ddd-ts-kit/tracing or an @opentelemetry package opens spans of its own, with names and attributes nobody reviews, and can no longer be traced differently by changing the composition root alone. Judged: every source under the source root, tests included, but the platform directory, main.ts and apps/.',
+        bad: `// infrastructure/external/stripe-payment.gateway.ts
+import { trace } from '@opentelemetry/api';`,
+        good: `// src/platform/tracing.ts
+import { traceApplication, tracedPublisher } from '@ddd-ts-kit/tracing';
+import { initTracing } from '@ddd-ts-kit/tracing/node';`,
+    },
+    'standard/no-parallel-interface': {
+        why: 'The kernel defines the shapes every project shares (Actor, Session, ExecutionContext, Logger, Metrics, Cache, Page and PageRequest, AuditStamp, Clock, IdGenerator, UnitOfWork, JobScheduler, ScheduledJob, ErrorReporter) so that adapters, middlewares and tooling written once fit them all. A home-made ILogger or UserContext next to them forks the shape: every adapter then needs a translation, and the fields of the project never reach the standard logs, spans and audit entries. A project adds its fields by declaration merging of the extension interfaces the kernel leaves open.',
+        bad: `// application/ports/logger.port.ts
+export abstract class ILogger { abstract info(message: string): void; }
+// platform/cron-scheduler.ts
+export class CronScheduler {}
+// shared-kernel/user-context.ts
+export interface UserContext { userId: string; tenantId: string; plan: string }`,
+        good: `import type { Logger, ExecutionContext } from '@ddd-ts-kit/kernel';
+// platform/kernel-extensions.ts
+declare module '@ddd-ts-kit/kernel' {
+  interface ExecutionContextExtensions { plan: string }
+}
+// infrastructure/external/pino.logger.ts
+export class PinoLogger implements Logger {}`,
+    },
+    'governance/recorded-deviation': {
+        why: 'The architecture can be changed deliberately, not case by case. A suppression, a lowered severity or a widened list that points to no decision is indistinguishable from a shortcut, and gets copied. The decision record says why, for what scope and until when, so the exception can be reviewed today and removed later.',
+        bad: `// eslint-disable-next-line no-console -- needed for the demo
+"rules": { "test/spec-required": "off" }`,
+        good: `// eslint-disable-next-line no-console -- ADR-0004: startup banner read by operations
+"rules": { "test/spec-required": "off" },
+"deviations": [{ "what": "rules.test/spec-required", "adr": "0009", "reason": "Generated adapters are covered by the contract suite." }]
+// docs/adr/0004-startup-banner.md, docs/adr/0009-no-spec-for-generated-adapters.md`,
+    },
+};
+//# sourceMappingURL=standard-docs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard-docs.js","sourceRoot":"","sources":["../../../src/check/explain/standard-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAsC;IAC9D,oBAAoB,EAAE;QACpB,GAAG,EAAE,8cAA8c;QACnd,GAAG,EAAE;wDAC+C;QACpD,IAAI,EAAE;;;wDAG8C;KACrD;IACD,uBAAuB,EAAE;QACvB,GAAG,EAAE,yiBAAyiB;QAC9iB,GAAG,EAAE;4CACmC;QACxC,IAAI,EAAE;;wDAE8C;KACrD;IACD,gCAAgC,EAAE;QAChC,GAAG,EAAE,qkBAAqkB;QAC1kB,GAAG,EAAE;;;;;gFAKuE;QAC5E,IAAI,EAAE;;;;;;6CAMmC;KAC1C;IACD,+BAA+B,EAAE;QAC/B,GAAG,EAAE,8TAA8T;QACnU,GAAG,EAAE;yCACgC;QACrC,IAAI,EAAE;;;oFAG0E;KACjF;CACF,CAAC"}

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

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

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

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

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

@@ -0,0 +1,83 @@
+export const TREE_DOCS = {
+    'tree/closed': {
+        why: 'A fixed tree means every concept has one obvious place, so people and tools find it without reading the code. An ad hoc folder (utils, helpers, common) is where unnamed concepts go to hide; a real new need is declared in extraDirectories with its reason. In the declared style the generated barrel <context>.declarations.ts lives at the root of the context, next to CONTEXT.md; a module file may stay there when the wiring of a context is unusual.',
+        bad: `contexts/billing/domain/utils/rounding.ts`,
+        good: `contexts/billing/domain/value-objects/money.vo.ts
+contexts/billing/billing.declarations.ts   // declared style only`,
+    },
+    'tree/context-doc': {
+        why: 'CONTEXT.md is where the vocabulary and the boundaries are agreed with the domain experts. Without it, names drift and nobody can tell whether a concept belongs here. The classification says how much design effort the context deserves.',
+        bad: `contexts/billing/ without CONTEXT.md, or with "## Classification" saying generic while the config says core`,
+        good: `## Purpose, ## Classification, ## Ubiquitous language, ## Aggregates, ## Published events, ## Relationships`,
+    },
+    'naming/suffix': {
+        why: 'The suffix states the role of a file before it is opened and lets the other rules know what they are looking at. Kebab-case avoids case-only renames that break on some file systems. A use case folder holds its message, its handler and, when it answers something, its result (*.result.ts); a job is application/scheduling/*.job.ts. One file is named after its context instead of a role: presentation/http/<context>.routes.ts, the list of its routes (a context wired by hand lists them in its module file).',
+        bad: `domain/aggregates/Invoice.ts`,
+        good: `domain/aggregates/invoice.aggregate.ts
+application/commands/issue-invoice/issue-invoice.result.ts
+application/scheduling/send-reminders.job.ts
+presentation/http/billing.routes.ts`,
+    },
+    'naming/search-not-list': {
+        why: 'A read that takes criteria, a scope or a page is a search, and the whole project says so with one word: a port, its adapters, its fakes, the query and its folder. Two words for one thing make a reader wonder what the difference is, and a generated name then disagrees with a written one. Judged: a method named list, or list followed by an upper-case letter, in domain/repositories/*.repository.ts, application/ports/*.port.ts, infrastructure/ and test/fakes/ of a context (properties are not judged, nor listAccessible, which the Authorizer port of the kit requires); and under application/queries/, a folder or a file named list or starting with list- or list., and a class named List or starting with List followed by an upper-case letter. A read of one element or none stays findById or findBy...',
+        bad: `// application/ports/invoice-reader.port.ts
+abstract list(scope: AccessScope, page: PageRequest<InvoiceSort>): Promise<Page<InvoiceLine>>;
+abstract listByCustomer(customerId: string): Promise<readonly InvoiceLine[]>;
+// application/queries/list-invoices/list-invoices.query.ts
+export class ListInvoicesQuery {}`,
+        good: `// application/ports/invoice-reader.port.ts
+abstract search(scope: AccessScope, page: PageRequest<InvoiceSort>): Promise<Page<InvoiceLine>>;
+abstract searchByCustomer(customerId: string): Promise<readonly InvoiceLine[]>;
+abstract findById(id: string): Promise<InvoiceLine | undefined>;
+// application/queries/search-invoices/search-invoices.query.ts
+export class SearchInvoicesQuery {}`,
+    },
+    'naming/one-concept-per-file': {
+        why: 'One concept per file keeps the file name truthful and the diff of a change small. A second class in an aggregate file is usually an entity or a value object that deserves its own name and its own tests. In the declared style a role file is found by its name and holds one declared class: a second class carrying a declaration decorator in the same file is reported, whatever the role.',
+        bad: `// invoice.aggregate.ts
+export class Invoice {}
+export class InvoiceLine {}
+// application/authorization/invoice.policy.ts, declared style
+@Policy(billingPermissions['invoice.void'], { name: 'billing.only-issuer-voids' })
+export class OnlyIssuerVoidsPolicy {}
+@Policy(billingPermissions['invoice.issue'], { name: 'billing.only-accountant-issues' })
+export class OnlyAccountantIssuesPolicy {}`,
+        good: `// invoice.aggregate.ts
+export class Invoice {}
+// ../entities/invoice-line.entity.ts
+export class InvoiceLine {}`,
+    },
+    'test/spec-required': {
+        why: 'Aggregates, value objects, domain services, handlers and jobs hold the business behaviour and what triggers it; an untested one is an unverified rule. Requiring the spec file makes the missing test visible at the moment the code is written.',
+        bad: `domain/aggregates/invoice.aggregate.ts with no test/**/invoice.aggregate.spec.ts`,
+        good: `test/unit/invoice.aggregate.spec.ts`,
+    },
+    'test/coverage-governed': {
+        why: 'A coverage threshold is a floor that says how much of a layer no test has ever run, and it only says so while the measure is honest. One source holds it: the "coverage" key of ddd-ts-kit.config.json gives, per layer, the four rates every context must reach (the reference when the key is absent), and the test runner config reads them through governedCoverage of @ddd-ts-kit/testing/coverage, which also measures the four layers of every context, the files no test loads included. Raising a threshold is free; lowering one is a deviation with its decision record (governance/recorded-deviation). What this rule refuses is the quiet way around: an include, an exclude or thresholds written by hand in the runner config, the same set by a flag in a script, and a coverage ignore comment (v8 ignore, istanbul ignore, c8 ignore) in a production source that names no decision record. A rate proves that code ran under a test, never that the test asserts anything: the floor is not a goal.',
+        bad: `// vitest.config.ts
+coverage: { ...governedCoverage(mode), exclude: ['src/contexts/billing/infrastructure/**'] }
+// domain/aggregates/invoice.aggregate.ts
+/* v8 ignore next 3 */`,
+        good: `// vitest.config.ts
+coverage: { provider: 'v8', reporter: ['text', 'cobertura', 'lcov'], ...governedCoverage(mode) }
+// ddd-ts-kit.config.json
+"coverage": { "infrastructure": { "branches": 50 } },
+"deviations": [{ "what": "coverage.infrastructure.branches", "adr": "0011", "reason": "The driver's failure branches are held by its contract suite." }]
+// domain/aggregates/invoice.aggregate.ts
+/* v8 ignore next 3 -- ADR-0012: reached only by the legacy import, removed with it */`,
+    },
+    'test/no-mocks': {
+        why: 'A mock asserts that a call was made, not that the outcome is right, so it breaks on every refactoring and passes on wrong behaviour. A fake is a working in-memory implementation held to the same contract suite as the real adapter. Tests assert its state, the published events or the returned value.',
+        bad: `const repository = { save: vi.fn() };
+expect(repository.save).toHaveBeenCalledOnce();`,
+        good: `const repository = new FakeInvoiceRepository();
+expect(await repository.findById(id)).toBeDefined();`,
+    },
+    'test/builder-required': {
+        why: 'Tests that build aggregates by hand repeat every mandatory field and break together when one is added. A builder has valid defaults and methods in the ubiquitous language, and goes through the public API of the aggregate, so a test states only what matters to the rule it checks and never starts from an invalid state.',
+        bad: `domain/aggregates/invoice.aggregate.ts with no test/builders/invoice.builder.ts`,
+        good: `// test/builders/invoice.builder.ts
+anInvoice().issued().build();`,
+    },
+};
+//# sourceMappingURL=tree-docs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree-docs.js","sourceRoot":"","sources":["../../../src/check/explain/tree-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAsC;IAC1D,aAAa,EAAE;QACb,GAAG,EAAE,icAAic;QACtc,GAAG,EAAE,2CAA2C;QAChD,IAAI,EAAE;kEACwD;KAC/D;IACD,kBAAkB,EAAE;QAClB,GAAG,EAAE,4OAA4O;QACjP,GAAG,EAAE,6GAA6G;QAClH,IAAI,EAAE,6GAA6G;KACpH;IACD,eAAe,EAAE;QACf,GAAG,EAAE,0fAA0f;QAC/f,GAAG,EAAE,8BAA8B;QACnC,IAAI,EAAE;;;oCAG0B;KACjC;IACD,wBAAwB,EAAE;QACxB,GAAG,EAAE,kyBAAkyB;QACvyB,GAAG,EAAE;;;;kCAIyB;QAC9B,IAAI,EAAE;;;;;oCAK0B;KACjC;IACD,6BAA6B,EAAE;QAC7B,GAAG,EAAE,kYAAkY;QACvY,GAAG,EAAE;;;;;;;2CAOkC;QACvC,IAAI,EAAE;;;4BAGkB;KACzB;IACD,oBAAoB,EAAE;QACpB,GAAG,EAAE,kPAAkP;QACvP,GAAG,EAAE,kFAAkF;QACvF,IAAI,EAAE,qCAAqC;KAC5C;IACD,wBAAwB,EAAE;QACxB,GAAG,EAAE,y9BAAy9B;QAC99B,GAAG,EAAE;;;uBAGc;QACnB,IAAI,EAAE;;;;;;uFAM6E;KACpF;IACD,eAAe,EAAE;QACf,GAAG,EAAE,4SAA4S;QACjT,GAAG,EAAE;gDACuC;QAC5C,IAAI,EAAE;qDAC2C;KAClD;IACD,uBAAuB,EAAE;QACvB,GAAG,EAAE,gUAAgU;QACrU,GAAG,EAAE,iFAAiF;QACtF,IAAI,EAAE;8BACoB;KAC3B;CACF,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"wiring-docs.d.ts","sourceRoot":"","sources":["../../../src/check/explain/wiring-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,CAuDzD,CAAC"}

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

@@ -0,0 +1,57 @@
+export const WIRING_DOCS = {
+    'composition/only-in-module': {
+        why: 'When adapters are created in one place, replacing one (a fake in a test, another provider in production) is a one-line change and tracing can wrap them all. A `new PgRepository()` buried in a handler, or a `bind(Port).toClass(PgRepository)` written outside the composition root, hides a dependency and defeats both. A class carrying @Repository, @Gateway or @Adapter is bound by its declaration, so nothing instantiates it at all. What turns declarations into bindings (contextModule, discoverContext, include on a module builder) is composition too and stays in main.ts, apps/<context>/main.ts, the platform and a module file.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+const repository = new PgInvoiceRepository();
+// infrastructure/external/extend-billing.ts
+builder.include(billingDeclarations);`,
+        good: `// billing.module.ts
+const invoiceRepository = new PgInvoiceRepository();
+const issueInvoiceHandler = new IssueInvoiceHandler(invoiceRepository);
+// declared style: infrastructure/persistence/pg-invoice.repository.ts and src/main.ts
+@Repository(InvoiceRepository, [Database, ExecutionScope, Clock])
+export class PgInvoiceRepository implements InvoiceRepository {}
+contextModule('billing', billingDeclarations);`,
+    },
+    'declarations/role-declared': {
+        why: 'In the declared style nothing lists the classes of a context: a class is registered because its file has the name of a role and its decorator says which one. A role file whose class declares nothing, or declares another role, is wired nowhere and nobody is told. The names a declaration writes (a consumer, a policy, a domain event; the name of a job is held by scheduling/job-name) are identities kept in stores and logs, so they are literals, and the name of a domain event handler is the one its event carries. The domain declares nothing: a decorator there would make the model depend on its own wiring. Checked in declared-style projects only.',
+        bad: `// application/commands/issue-invoice/issue-invoice.handler.ts
+export class IssueInvoiceHandler {}
+// application/event-handlers/invoice-issued.event-handler.ts
+@DomainEventHandler(InvoiceIssued, { name: EVENT_NAME })
+// domain/aggregates/invoice.aggregate.ts
+@Repository(InvoiceRepository)
+export class Invoice {}`,
+        good: `// application/commands/issue-invoice/issue-invoice.handler.ts
+@CommandHandler(IssueInvoiceCommand, [InvoiceRepository, Clock])
+export class IssueInvoiceHandler {}
+// application/event-handlers/invoice-issued.event-handler.ts
+@DomainEventHandler(InvoiceIssued, { name: 'billing.invoice.issued' })
+export class InvoiceIssuedEventHandler {}`,
+    },
+    'declarations/barrel-current': {
+        why: 'With stack.assembly set to barrel, the composition root assembles a context from <context>.declarations.ts and from nothing else. A role file added by hand and missing from the barrel compiles, passes its unit tests and is never registered. The barrel is derived from the tree, one export per role file sorted by path, so it is compared with what the tree says; with stack.assembly set to discovery the role files are found at startup and a barrel left behind is reported instead.',
+        bad: `// billing.declarations.ts, while application/authorization/only-issuer-voids.policy.ts exists
+export * from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.command.js';
+export * from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.handler.js';`,
+        good: `// billing.declarations.ts, rewritten by \`ddd-ts-kit generate\` and \`ddd-ts-kit docs\`
+export * from '@/contexts/billing/application/authorization/only-issuer-voids.policy.js';
+export * from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.command.js';
+export * from '@/contexts/billing/application/commands/issue-invoice/issue-invoice.handler.js';`,
+    },
+    'config/valid': {
+        why: 'Every other rule reads the config: a misspelled upstream or rule id silently disables a check. The contexts on disk and in the config have to be the same set, or part of the code is not checked at all. A function limit above the ceiling of 100 lines and an allowance without a file or a reason are read as something else than what is written, so they are reported too.',
+        bad: `"rules": { "naming/sufix": "warn" }, "guard": "strict",
+"limits": { "maxFunctionLines": 250 },
+"onePerFile": { "allow": [{ "file": "src/platform/http-server.ts" }] }`,
+        good: `"rules": { "naming/suffix": "warn" }, "guard": "advise",   // enforce (default), advise or off: how the editor hook reacts
+"limits": { "maxFunctionLines": 40 },                       // at most 100
+"onePerFile": { "allow": [{ "file": "src/platform/http-server.ts", "reason": "The server and its two error mappers are one boundary." }] }`,
+    },
+    'config/suppression-needs-reason': {
+        why: 'An exception to an architecture rule is a decision someone will question later. The reason written next to it is what makes it reviewable; a bare suppression is indistinguishable from a shortcut.',
+        bad: `// ddd-ts-kit-disable-next-line layer/domain-purity`,
+        good: `// ddd-ts-kit-disable-next-line layer/domain-purity -- ADR-0012: decimal.js is our money arithmetic`,
+    },
+};
+//# sourceMappingURL=wiring-docs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wiring-docs.js","sourceRoot":"","sources":["../../../src/check/explain/wiring-docs.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAsC;IAC5D,4BAA4B,EAAE;QAC5B,GAAG,EAAE,qnBAAqnB;QAC1nB,GAAG,EAAE;;;sCAG6B;QAClC,IAAI,EAAE;;;;;;+CAMqC;KAC5C;IACD,4BAA4B,EAAE;QAC5B,GAAG,EAAE,0oBAA0oB;QAC/oB,GAAG,EAAE;;;;;;wBAMe;QACpB,IAAI,EAAE;;;;;0CAKgC;KACvC;IACD,6BAA6B,EAAE;QAC7B,GAAG,EAAE,keAAke;QACve,GAAG,EAAE;;gGAEuF;QAC5F,IAAI,EAAE;;;gGAGsF;KAC7F;IACD,cAAc,EAAE;QACd,GAAG,EAAE,kXAAkX;QACvX,GAAG,EAAE;;uEAE8D;QACnE,IAAI,EAAE;;2IAEiI;KACxI;IACD,iCAAiC,EAAE;QACjC,GAAG,EAAE,qMAAqM;QAC1M,GAAG,EAAE,qDAAqD;QAC1D,IAAI,EAAE,qGAAqG;KAC5G;CACF,CAAC"}

package/dist/check/exports/explained-mains.d.ts

@@ -0,0 +1,8 @@
+import type { Exported } from './exported.js';
+import type { LocalType } from './local-types.js';
+/**
+ * The exports M such that every other counted export is an interface of M's signature (allowance
+ * 1), a function derived from M taken with it (`retryAdvice` called by `retry`), or shares M's name.
+ */
+export declare function explainedMains(exported: readonly Exported[], counted: readonly Exported[], types: readonly LocalType[]): Exported[];
+//# sourceMappingURL=explained-mains.d.ts.map

package/dist/check/exports/explained-mains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explained-mains.d.ts","sourceRoot":"","sources":["../../../src/check/exports/explained-mains.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,OAAO,EAAE,SAAS,QAAQ,EAAE,EAC5B,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B,QAAQ,EAAE,CAsBZ"}

package/dist/check/exports/explained-mains.js

@@ -0,0 +1,26 @@
+import { escapeRegExp } from '../text/escape-reg-exp.js';
+import { typeClosure } from './type-closure.js';
+/**
+ * The exports M such that every other counted export is an interface of M's signature (allowance
+ * 1), a function derived from M taken with it (`retryAdvice` called by `retry`), or shares M's name.
+ */
+export function explainedMains(exported, counted, types) {
+    const firstOfName = exported.filter((candidate, index) => exported.findIndex((other) => other.name === candidate.name) === index);
+    return firstOfName.filter((main) => {
+        const own = exported.filter((candidate) => candidate.name === main.name);
+        const implemented = counted.find((candidate) => candidate.name === main.name) ?? main;
+        const derived = main.kind === 'function' ? counted.filter((candidate) => isDerivedFrom(candidate, implemented)) : [];
+        const closure = typeClosure([...own, ...derived].map((candidate) => candidate.signature), types);
+        return counted.every((other) => other.name === main.name || derived.includes(other) || (other.kind === 'interface' && closure.has(other.name)));
+    });
+}
+/** `retryAdvice` for `retry`: the name of the main followed by an upper-case letter, and called in its body. */
+function isDerivedFrom(candidate, main) {
+    if (candidate.kind !== 'function' ||
+        !candidate.name.startsWith(main.name) ||
+        !/^[A-Z]/.test(candidate.name.slice(main.name.length))) {
+        return false;
+    }
+    return new RegExp(`(?<![\\w$.])${escapeRegExp(candidate.name)}\\s*\\(`).test(main.text.slice(main.signature.length));
+}
+//# sourceMappingURL=explained-mains.js.map

package/dist/check/exports/explained-mains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explained-mains.js","sourceRoot":"","sources":["../../../src/check/exports/explained-mains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,QAA6B,EAC7B,OAA4B,EAC5B,KAA2B;IAE3B,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CACjC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI,CAAC,KAAK,KAAK,CAC7F,CAAC;IAEF,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;QACzE,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;QAEtF,MAAM,OAAO,GACX,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEvG,MAAM,OAAO,GAAG,WAAW,CACzB,CAAC,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,EAC5D,KAAK,CACN,CAAC;QAEF,OAAO,OAAO,CAAC,KAAK,CAClB,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CACjH,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,gHAAgH;AAChH,SAAS,aAAa,CAAC,SAAmB,EAAE,IAAc;IACxD,IACE,SAAS,CAAC,IAAI,KAAK,UAAU;QAC7B,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;QACrC,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EACtD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,IAAI,MAAM,CAAC,eAAe,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AACvH,CAAC"}

package/dist/check/exports/export-verdict.d.ts

@@ -0,0 +1,11 @@
+import type { Exported } from './exported.js';
+/** What the exports of a file come to, once the general allowances are applied. */
+export interface ExportVerdict {
+    /** The exported classes, interfaces and functions, once per name. */
+    readonly counted: readonly Exported[];
+    /** False when the file counts several and no allowance explains them. */
+    readonly explained: boolean;
+    /** The exports the file may be named after; empty when no name is expected. */
+    readonly mains: readonly Exported[];
+}
+//# sourceMappingURL=export-verdict.d.ts.map

package/dist/check/exports/export-verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-verdict.d.ts","sourceRoot":"","sources":["../../../src/check/exports/export-verdict.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC"}

package/dist/check/exports/export-verdict.js

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

package/dist/check/exports/export-verdict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-verdict.js","sourceRoot":"","sources":["../../../src/check/exports/export-verdict.ts"],"names":[],"mappings":""}

package/dist/check/exports/exported.d.ts

@@ -0,0 +1,12 @@
+/** One thing a file exports, as its declaration reads at text level. */
+export interface Exported {
+    /** `default` for an anonymous default export. */
+    readonly name: string;
+    readonly kind: 'class' | 'function' | 'interface' | 'const' | 'type' | 'enum';
+    readonly line: number;
+    /** The blanked code of the whole declaration. */
+    readonly text: string;
+    /** What others see of it: a function without its body; the whole declaration for anything else. */
+    readonly signature: string;
+}
+//# sourceMappingURL=exported.d.ts.map

package/dist/check/exports/exported.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exported.d.ts","sourceRoot":"","sources":["../../../src/check/exports/exported.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,MAAM,WAAW,QAAQ;IACvB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mGAAmG;IACnG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B"}

package/dist/check/exports/exported.js

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

package/dist/check/exports/exported.js.map

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

package/dist/check/exports/file-exports.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from '../model/source-file.js';
+import type { Exported } from './exported.js';
+/** What a source exports from its own declarations, in source order; re-exports (`export .. from`) are not in it. */
+export declare function fileExports(file: SourceFile): Exported[];
+//# sourceMappingURL=file-exports.d.ts.map