@starci/eslint-canon-be 3.19.7 → 3.20.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,21 @@
1
1
  # Changelog
2
2
 
3
+ ## 3.20.2 - 2026-11-09
4
+
5
+ - Changed: peers `@starci/hfs ~6.4.0`; no lint rule changed.
6
+
7
+ ## 3.20.1 - 2026-11-09
8
+
9
+ - Fixed: the package's own build no longer logs TS2307 for `@starci/hfs/runtime/scripts/hfs/rule-catalog.mjs`: the path-mapped runtime types (`src/types/runtime`) gain `scripts/hfs/rule-catalog.d.mts` (`loadRuleCatalog`, the part of `RuleCatalog` the edition gate reads), and `checkTiers` there takes the TypeScript API as its second argument, as the machine does (the typecheck of the specs failed on it).
10
+ - Specs: `src/be-r89-source-form-coverage.spec.ts` (a method taking the named interface `ErrorParams` passes `BE_PUBLIC_CONTRACT_FORM`).
11
+
12
+ ## 3.20.0 - 2026-11-08
13
+
14
+ - Changed: `throw-domain-error`, `error-home` and `error-family-shape` recognise a coded error by the declaration of `DomainError` (and `ErrorKind`) in `@starci/common`, found through the type checker, so the family of an app (through the re-export of `platform/errors`), of a root workspace package and of every `@starci` package passes one test. A class named `DomainError` declared anywhere else is a bare `Error` subclass.
15
+ - Removed: the `starci.errorBase` declaration of a root package; its errors extend `DomainError` of `@starci/common` (`@starci/common` is a framework package for the third-party owner rule). The closed list of framework control-flow signals (BullMQ) stays.
16
+ - Changed: peers `@starci/hfs ~6.3.0`.
17
+ - Specs: `src/error-handling.spec.ts`, `src/packages-config.spec.ts` (an app family, a package error of `@starci/auth` and `@starci/test-world`, a `@starci/common` subclass and a root package family pass; a plain `Error`, a lookalike class, the `Promise.reject` forms and the wrapper dodge fail).
18
+
3
19
  ## 3.19.7 - 2026-11-08
4
20
 
5
21
  - Fixed: the test-scope Sonar way block selects the specs with a positive selector (`files: ['**/*.{spec,e2e-spec}.{ts,mts,cts,js,mjs,cjs}']`, exported as `SPEC_FILES`) instead of `ignores: ['**/*', '!**/*.spec...']`. The harness lint scope (`canonScope` of `@starci/hfs`) refuses a negated selector, so every app's `starci app check --gate lint` ended in `ESLint tool error: eslint source scope is unavailable ... unsupported canon ignores selectors` and linted nothing. The block selects the same files as before and carries the name `starci-be/sonar-way-tests`, by which the packages config narrows it to the specs of the package subpaths.
package/README.md CHANGED
@@ -37,7 +37,7 @@ A sample, not the list:
37
37
 
38
38
  | Area | What the rules hold |
39
39
  |---|---|
40
- | **Errors** | A `catch` rethrows, calls a method on a `Logger` receiver (typed, from `platform/logging`) or returns an outcome carrying its cause; a `DomainError` subclass lives only in `errors/<capability>.error.ts` of its owner, and that file is one code enum, one `Record<Code, ErrorKind>` table and one empty class; a `throw` throws a `DomainError`, never a bare `Error`, a framework exception or a platform error out of a domain; a root workspace package throws the error base its `package.json` declares (`starci.errorBase`) (`catch-must-account`, `error-home`, `throw-domain-error`, `error-family-shape`) |
40
+ | **Errors** | A `catch` rethrows, calls a method on a `Logger` receiver (typed, from `platform/logging`) or returns an outcome carrying its cause; a `DomainError` subclass lives only in `errors/<capability>.error.ts` of its owner, and that file is one code enum, one `Record<Code, ErrorKind>` table and one empty class; a `throw` throws a `DomainError`, never a bare `Error`, a framework exception or a platform error out of a domain; a `DomainError` is the class `@starci/common` declares, which the app re-exports in `platform/errors` and a root workspace package or a `@starci` package extends directly (`catch-must-account`, `error-home`, `throw-domain-error`, `error-family-shape`) |
41
41
  | **Schema authority** | Migrations only: every DataSource or TypeORM options object states the literal `synchronize: false` (found by the contextual type), no `migrationsRun`, no DDL string outside a migration (but the renderer files hfs.json `sides.be.ddlRenderers` declares, which only build and return DDL text and are not reachable from run-time code), no entity glob; no `@Entity` type reachable from a transport signature, a handler `execute`, a contract or a message, and no GraphQL or validator import in an entity file (`no-runtime-schema`, `no-entity-in-contract`) |
42
42
  | **Config and secrets** | `process.env` (any form) is allowed in the `platform/config` file declaring `EnvSource`, the test world (slot `be.tests.world`) and the app bootstrap roles `apps/<app>/src/main.ts` and its matching `<app>.env.ts`; only those two app roles may read `EnvSource` or capability parse helpers. Compose groups and `<app>.options.ts` never read `process.env` or `EnvSource`. `@nestjs/config` and `dotenv` are forbidden config paths. A function exported by a `<capability>.config.ts` keeps its existing name and is called only from these bootstrap roles, its own config file or spec, the test world and a provider contract spec (`config-parsed-in-main`). Secrets use `EnvSource.secret()`: `<NAME>_FILE` takes priority for `.starcistacks` custody, and plain `<NAME>` is read only when the file key is absent; a declared file supplies exact contents and an empty or unreadable path fails startup without fallback. No default of any kind for a value typed `Secret` or `Url`; secrets compare with `timingSafeEqual` (`no-direct-env-read`, `config-parsed-in-main`, `no-secret-default`, `secret-compare-timing-safe`) |
43
43
  | **Model calls** (R326, R327, R344) | Every model call goes through the `@starci/ai-router` gateway: an upstream provider key variable (`PROVIDER_KEY_VARIABLES` of `src/ai-gateway.ts`, with its `_FILE` twin) is named only in the gateway's custody owner `integrations/ai-gateway`, specs and the test world included; code builds only `ChatOpenAI` and `OpenAIEmbeddings` of `@langchain/openai`, each from an inline options object whose `configuration.baseURL` is read from a `<c>.options.ts` type and whose `apiKey` is a `platform/config` `Secret` revealed; `integrations/ai` reads exactly `STARCI_AI_KEY`, the one virtual key of every client, and the custody owner passes the gateway no `adminToken`. Which owner may import LangChain, `openai`, a provider SDK or an agent framework is the infrastructure table (`provider-key-custody`, `ai-client-through-gateway`, `ai-virtual-key-name`, `infra-import-owner`) |
@@ -25,7 +25,7 @@ import { lineCount } from "../runtime/scripts/lib/line-count.mjs";
25
25
  import ts from "typescript";
26
26
  import { APP_ENV_ROLE, APP_OPTIONS_ROLE, appRoleOf } from "./lib/app-roles.js";
27
27
  import { hfsOf } from "./lib/hfs.js";
28
- import { isOwnedBy } from "./lib/declared.js";
28
+ import { isCommonFile, isOwnedBy } from "./lib/declared.js";
29
29
  import { keyName, staticText } from "./lib/ast.js";
30
30
  import { isDeclarationFile, normalizePath } from "./lib/path.js";
31
31
  import { childNode, moduleOf, originsOfType, packageOfExport, resolvedSymbol as resolveAlias, typed } from "./lib/types.js";
@@ -229,13 +229,13 @@ const compositionTypes = (checker) => {
229
229
  };
230
230
  /** Whether a type is declared under the app's `platform/<area>` capability folder. */
231
231
  const declaredIn = (symbol, area) => symbol?.getDeclarations()?.some((declaration) => normalizePath(declaration.getSourceFile().fileName).includes(`/modules/platform/${area}/`)) ?? false;
232
- /** A message bundle of `platform/i18n`, or a table of error kinds: every value (property or index) is `platform/errors`' ErrorKind. */
232
+ /** A message bundle of `platform/i18n`, or a table of error kinds: every value (property or index) is the `ErrorKind` of `@starci/common`, which `platform/errors` re-exports. */
233
233
  const catalogEntry = (type) => {
234
234
  if (declaredIn(type.getSymbol(), "i18n") && type.getSymbol()?.name === "MessageBundle")
235
235
  return true;
236
236
  if (!(type.flags & ts.TypeFlags.Object))
237
237
  return false;
238
- const kind = (value) => value?.aliasSymbol?.name === "ErrorKind" && declaredIn(value.aliasSymbol, "errors");
238
+ const kind = (value) => value?.aliasSymbol?.name === "ErrorKind" && (value.aliasSymbol.getDeclarations()?.some((declaration) => isCommonFile(normalizePath(declaration.getSourceFile().fileName))) ?? false);
239
239
  const values = [...type.getProperties().map((property) => propertyType(type, property.name)), ...checker.getIndexInfosOfType(type).map((index) => index.type)];
240
240
  return values.length > 0 && values.every(kind);
241
241
  };
@@ -12,7 +12,7 @@
12
12
  * takes the exact caught value as `cause` (BE-ERROR-4). A value the rule cannot see through (a parameter, a call that
13
13
  * is handed the caught value) counts as carrying, so a kept cause is never reported.
14
14
  * - `error-home` keeps every error class where its owner is: a class that derives from `DomainError` is declared only in
15
- * `errors/<capability>.error.ts` of its own owner, and a class that derives from the built-in `Error` some other way
15
+ * `errors/<capability>.error.ts` of its own owner (a root workspace package places its errors freely), and a class that derives from the built-in `Error` some other way
16
16
  * (`AbstractException`, a framework `HttpException` subclass, a bare `extends Error`) is refused.
17
17
  * - `throw-domain-error` refuses a `throw` whose type does not derive from `DomainError` (`throw new Error`, the Nest
18
18
  * `HttpException` family, a thrown string or object), and a domain owner that throws a platform error outward. A rejection is
@@ -20,15 +20,15 @@
20
20
  * the same way, so the one form that also satisfies Sonar S7746 (`throw` in an async function) and S6671 (an Error rejects)
21
21
  * is `throw new <C>Error(...)`.
22
22
  *
23
- * The error base of a file is `DomainError` of `platform/errors`; a root workspace package, which cannot import an app owner, declares
24
- * its own base in its manifest (`starci.errorBase`: `{ name, file }`), and both rules read that class, in that file, as its `DomainError`:
25
- * the base itself is its host and a package has no owner layout to place its subclasses in.
23
+ * The error base of every file is `DomainError` as `@starci/common` declares it: both rules ask the type checker where the class is declared,
24
+ * so a family of an app (which imports it through the re-export of `platform/errors`), of a root workspace package and of a `@starci` package
25
+ * passes the same test. A root workspace package has no owner layout to place its subclasses in.
26
26
  * - `error-family-shape` holds the one shape of `errors/<c>.error.ts`: a `<C>ErrorCode` string enum, a
27
27
  * `<C>_ERROR_KINDS: Record<<C>ErrorCode, ErrorKind>` table, and an empty `<C>Error extends DomainError<<C>ErrorCode>`.
28
28
  * Code uniqueness across the repository is the architecture machine's job, not a single file's.
29
29
  */
30
30
  import { nameOrValue, some, walk } from "./lib/ast.js";
31
- import { derives, derivesFromBuiltinError, derivesFromErrorBase, errorHomeOf, isOwnedBy, isOwnedType, ownerName, packageErrorBaseOf, partsOf, typeOf, } from "./lib/declared.js";
31
+ import { derives, derivesFromBuiltinError, derivesFromErrorBase, errorHomeOf, isCommonType, isOwnedType, ownerName, partsOf, typeOf, } from "./lib/declared.js";
32
32
  import { hfsOf } from "./lib/hfs.js";
33
33
  import { normalizePath } from "./lib/path.js";
34
34
  import { typed } from "./lib/types.js";
@@ -248,7 +248,7 @@ export const errorHome = {
248
248
  schema: [],
249
249
  messages: {
250
250
  place: "`{{name}}` derives from `DomainError` but is not declared in `errors/{{owner}}.error.ts` of its owner. An owner has one error class, in that file; move it there.",
251
- mustExtendDomainError: "`{{name}}` derives from the built-in `Error` without deriving from `DomainError` (`AbstractException`, a framework exception or a bare `extends Error`). Extend `DomainError` from `platform/errors` in the owner's `errors/<capability>.error.ts`; in a root workspace package, extend the error base its `package.json` declares (`starci.errorBase`).",
251
+ mustExtendDomainError: "`{{name}}` derives from the built-in `Error` without deriving from `DomainError` (`AbstractException`, a framework exception or a bare `extends Error`). Extend `DomainError` from `platform/errors` in the owner's `errors/<capability>.error.ts`; in a root workspace package, extend `DomainError` from `@starci/common`.",
252
252
  },
253
253
  },
254
254
  create(context) {
@@ -260,13 +260,8 @@ export const errorHome = {
260
260
  const type = typeOf(context, node.id);
261
261
  if (!type)
262
262
  return;
263
- const packageBase = packageErrorBaseOf(hfs, filename);
264
- const isErrorBaseHost = (node.id.name === "DomainError" && isOwnedBy(hfs, filename, "platform", "errors")) ||
265
- (packageBase !== null && node.id.name === packageBase.name && hfs.relative(filename) === packageBase.file);
266
- if (isErrorBaseHost)
267
- return;
268
263
  if (derivesFromErrorBase(context, type)) {
269
- if (packageBase !== null || isWorldErrorHome(hfs, filename))
264
+ if (hfs.tierOf(filename) === "package" || isWorldErrorHome(hfs, filename))
270
265
  return;
271
266
  // A spec-local subclass of the abstract base is a test double for code that takes any DomainError, not an error family.
272
267
  if (isSpecLocalClass(filename, node))
@@ -366,7 +361,7 @@ export const throwDomainError = {
366
361
  messages: {
367
362
  bareError: "`throw new Error(...)` carries a sentence and no code, so nothing downstream can group or map it. Throw the `<C>Error` of the owning capability with one of its codes.",
368
363
  framework: "`throw new {{name}}(...)` carries an HTTP status and no identity. Throw the `<C>Error` of the owning capability; the one filter of `platform/errors` maps its code to a status.",
369
- notDomainError: "This `throw` does not throw a `DomainError`. Throw the `<C>Error` of the owning capability with one of its codes, or return an `Outcome` and let the transport unwrap it; a root workspace package throws the error base its `package.json` declares (`starci.errorBase`).",
364
+ notDomainError: "This `throw` does not throw a `DomainError`. Throw the `<C>Error` of the owning capability with one of its codes, or return an `Outcome` and let the transport unwrap it; a root workspace package throws an error that derives from `DomainError` of `@starci/common`.",
370
365
  platformThrown: "A domain owner throws `{{name}}`, an error of a platform owner. Translate it into the error of this capability so platform details do not cross the boundary.",
371
366
  rejectNotDomainError: "This rejection does not carry a `DomainError`. In an `async` function or a promise callback write `throw new <C>Error(...)` with one of the capability's codes (`return Promise.reject(value)` is Sonar S7746, and a value that is no `DomainError` breaks this rule); in a `new Promise` executor reject with the `<C>Error` of the owning capability.",
372
367
  },
@@ -464,9 +459,9 @@ export const errorFamilyShape = {
464
459
  extra: "`{{name}}` is an extra export. An error family file exports only `{{pascal}}ErrorCode`, `{{upper}}_ERROR_KINDS` and `{{pascal}}Error`.",
465
460
  memberValue: "`{{member}}` must be a string literal `{{upper}}_<WHAT>` in upper snake case with no `_EXCEPTION` or `_ERROR` suffix.",
466
461
  noKinds: "This file must export `const {{upper}}_ERROR_KINDS: Record<{{pascal}}ErrorCode, ErrorKind>` so the compiler proves every code has a kind.",
467
- kindsType: "`{{upper}}_ERROR_KINDS` must be annotated `Record<{{pascal}}ErrorCode, ErrorKind>` with `ErrorKind` from `platform/errors`; only that annotation makes the table exhaustive.",
462
+ kindsType: "`{{upper}}_ERROR_KINDS` must be annotated `Record<{{pascal}}ErrorCode, ErrorKind>` with `ErrorKind` from `platform/errors` (which re-exports `@starci/common`); only that annotation makes the table exhaustive.",
468
463
  noClass: "This file must export `class {{pascal}}Error extends DomainError<{{pascal}}ErrorCode> {}`, the one error class of the capability.",
469
- classShape: "`{{pascal}}Error` must extend `DomainError<{{pascal}}ErrorCode>` from `platform/errors` and declare nothing beyond its JSDoc: no body, no per-case subclass.",
464
+ classShape: "`{{pascal}}Error` must extend `DomainError<{{pascal}}ErrorCode>` from `platform/errors` (which re-exports `@starci/common`) and declare nothing beyond its JSDoc: no body, no per-case subclass.",
470
465
  },
471
466
  },
472
467
  create(context) {
@@ -507,7 +502,7 @@ export const errorFamilyShape = {
507
502
  const isRecord = annotation?.type === "TSTypeReference" && annotation.typeName.type === "Identifier" && annotation.typeName.name === "Record";
508
503
  const [keyArg, valueArg] = args;
509
504
  const keyOk = keyArg?.type === "TSTypeReference" && keyArg.typeName.type === "Identifier" && keyArg.typeName.name === codeName;
510
- const valueOk = args.length === 2 && valueArg?.type === "TSTypeReference" && isOwnedType(context, valueArg, "ErrorKind", "platform", "errors");
505
+ const valueOk = args.length === 2 && valueArg?.type === "TSTypeReference" && isCommonType(context, valueArg, "ErrorKind");
511
506
  if (!isRecord || args.length !== 2 || !keyOk || !valueOk)
512
507
  context.report({ node: declarator.id, messageId: "kindsType", data });
513
508
  }
@@ -517,7 +512,7 @@ export const errorFamilyShape = {
517
512
  else {
518
513
  const parent = cls.superClass;
519
514
  const args = typeParamsUnder(cls, "superTypeArguments") ?? typeParamsUnder(cls, "superTypeParameters") ?? [];
520
- const parentOk = parent && isOwnedType(context, parent, "DomainError", "platform", "errors");
515
+ const parentOk = parent && isCommonType(context, parent, "DomainError");
521
516
  const [codeArg] = args;
522
517
  const argOk = args.length === 1 && codeArg?.type === "TSTypeReference" && codeArg.typeName.type === "Identifier" && codeArg.typeName.name === codeName;
523
518
  if (!parentOk || !argOk || cls.body.body.length > 0)
@@ -6,7 +6,7 @@
6
6
  import ts from "typescript";
7
7
  import type { TSESTree } from "@typescript-eslint/utils";
8
8
  import type { Context, Node } from "./rule.js";
9
- import type { HfsPackageDeclaredType, HfsView } from "./hfs.js";
9
+ import type { HfsView } from "./hfs.js";
10
10
  import type { TypeOrigin } from "./types.js";
11
11
  /** The last segment of an owner root (`src/modules/platform/errors` gives `errors`), or null when there is no owner. */
12
12
  export declare const ownerName: (root: string | null | undefined) => string | null | undefined;
@@ -60,11 +60,13 @@ export declare const presentParts: (type: ts.Type | null | undefined) => ts.Type
60
60
  */
61
61
  export declare const derives: (checker: ts.TypeChecker, type: ts.Type | null | undefined, test: (name: string, file: string) => boolean, depth?: number) => boolean;
62
62
  export declare const derivesFromBuiltinError: (context: Context, type: ts.Type | null | undefined) => boolean;
63
- /** The error base a root package declares for the linted file (`starci.errorBase` of its manifest), or null outside a package or without one. */
64
- export declare const packageErrorBaseOf: (hfs: HfsView, filename: string) => HfsPackageDeclaredType | null;
63
+ /** True when `file` belongs to the installed `@starci/common`. */
64
+ export declare const isCommonFile: (file: string) => boolean;
65
+ /** True when the node's type is `name`, declared by `@starci/common` (an app's `platform/errors` re-exports it, and the type checker follows the re-export to the declaration). */
66
+ export declare const isCommonType: (context: Context, node: Node, name: string) => boolean;
65
67
  /**
66
- * True when the type is (or extends) the error base of the linted file: `DomainError` as declared by the repository's `platform/errors`
67
- * owner, or, in a root workspace package (which cannot import `platform/errors`), the error base its manifest declares, in its declared file.
68
+ * True when the type is (or extends) `DomainError` as `@starci/common` declares it, so the error family of an app, of a root workspace package
69
+ * and of every `@starci` package passes through one test: where the class is declared, never what it is called or where it is imported from.
68
70
  */
69
71
  export declare const derivesFromErrorBase: (context: Context, type: ts.Type | null | undefined) => boolean;
70
72
  /**
@@ -5,7 +5,6 @@
5
5
  */
6
6
  import ts from "typescript";
7
7
  import { hfsOf } from "./hfs.js";
8
- import { normalizePath } from "./path.js";
9
8
  import { typeOrigins, typed } from "./types.js";
10
9
  /** The last segment of an owner root (`src/modules/platform/errors` gives `errors`), or null when there is no owner. */
11
10
  export const ownerName = (root) => (root ? root.split("/").at(-1) : null);
@@ -120,17 +119,19 @@ export const derivesFromBuiltinError = (context, type) => {
120
119
  return source ? program.isSourceFileDefaultLibrary(source) : false;
121
120
  });
122
121
  };
123
- /** The error base a root package declares for the linted file (`starci.errorBase` of its manifest), or null outside a package or without one. */
124
- export const packageErrorBaseOf = (hfs, filename) => hfs.packageContract?.(filename)?.errorBase ?? null;
122
+ /** The package directory of `@starci/common` in an installed tree: where `DomainError` and `ErrorKind` are declared. */
123
+ const COMMON_PACKAGE_DIR = "/node_modules/@starci/common/";
124
+ /** True when `file` belongs to the installed `@starci/common`. */
125
+ export const isCommonFile = (file) => file.includes(COMMON_PACKAGE_DIR);
126
+ /** True when the node's type is `name`, declared by `@starci/common` (an app's `platform/errors` re-exports it, and the type checker follows the re-export to the declaration). */
127
+ export const isCommonType = (context, node, name) => originsOf(context, node).some((origin) => origin.name === name && isCommonFile(origin.file));
125
128
  /**
126
- * True when the type is (or extends) the error base of the linted file: `DomainError` as declared by the repository's `platform/errors`
127
- * owner, or, in a root workspace package (which cannot import `platform/errors`), the error base its manifest declares, in its declared file.
129
+ * True when the type is (or extends) `DomainError` as `@starci/common` declares it, so the error family of an app, of a root workspace package
130
+ * and of every `@starci` package passes through one test: where the class is declared, never what it is called or where it is imported from.
128
131
  */
129
132
  export const derivesFromErrorBase = (context, type) => {
130
- const hfs = hfsOf(context);
131
133
  const { checker } = typed(context);
132
- const own = packageErrorBaseOf(hfs, normalizePath(context.filename));
133
- return derives(checker, type, (name, file) => (name === "DomainError" && isOwnedBy(hfs, file, "platform", "errors")) || (own !== null && name === own.name && hfs.relative(file) === own.file));
134
+ return derives(checker, type, (name, file) => name === "DomainError" && isCommonFile(file));
134
135
  };
135
136
  /**
136
137
  * The owner-relative `errors/<capability>.error.ts` home of an error family, or null for a file that is not one.
@@ -153,8 +153,7 @@ export interface HfsPackageDeclaredType {
153
153
  readonly name: string;
154
154
  readonly file: string;
155
155
  }
156
- /** The error base and the outcome union a root package declares for itself, since it cannot import the app's `platform/errors` or `GraphQLResponse<T>`. */
156
+ /** The outcome union a root package declares for itself, since it cannot import the app's `GraphQLResponse<T>`. */
157
157
  export interface HfsPackageContract {
158
- readonly errorBase?: HfsPackageDeclaredType;
159
158
  readonly outcome?: HfsPackageDeclaredType;
160
159
  }
@@ -22,7 +22,7 @@ const PURE = new Set([
22
22
  const FRAMEWORK = new Set([
23
23
  "@nestjs/common", "@nestjs/core", "@nestjs/cqrs", "@nestjs/graphql", "@nestjs/apollo", "@nestjs/platform-express",
24
24
  "@nestjs/typeorm", "@nestjs/swagger", "@nestjs/mapped-types", "@nestjs/throttler", "@apollo/server",
25
- "@as-integrations/express5", "express", "nest-commander", "typeorm", "@starci/nest-kit",
25
+ "@as-integrations/express5", "express", "nest-commander", "typeorm", "@starci/nest-kit", "@starci/common",
26
26
  ]);
27
27
  const TEST_LIBRARIES = new Set(["@nestjs/testing", "@starci/jest-preset", "@starci/test-world", "@jest/globals", "jest", "jest-mock"]);
28
28
  const DEPENDENCIES = new WeakMap();
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@starci/eslint-canon-be",
3
- "version": "3.19.7",
3
+ "version": "3.20.2",
4
4
  "description": "The StarCi back-end lint canon: every rule its laws publish, gathered as one flat-config plugin.",
5
5
  "type": "module",
6
6
  "license": "MIT",
@@ -40,7 +40,7 @@
40
40
  "node": ">=22.13.0"
41
41
  },
42
42
  "peerDependencies": {
43
- "@starci/hfs": "~6.2.0",
43
+ "@starci/hfs": "~6.4.0",
44
44
  "eslint": ">=9",
45
45
  "typescript": ">=5.9"
46
46
  },
@@ -74,6 +74,6 @@
74
74
  "typescript": "^6.0.3"
75
75
  },
76
76
  "types": "./dist/index.d.ts",
77
- "gitHead": "1ac3e3ed36e167ca7dbed5cad593ca8033106f44",
78
- "starciSource": "1dcbc5e6c5a518233f880f381f5b2eafc909497891d9b60815cfd49b101cd608"
77
+ "gitHead": "247dce2b96806850cc135a4573c9b6069c908ef1",
78
+ "starciSource": "b163f1bb89f926f8769f4af42818dcd4ccf49815efd0b76df9a66efa95d08249"
79
79
  }