@codefast/cli 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @codefast/cli
 
+## 0.14.0
+
+### Minor Changes
+
+- [#1007](https://github.com/codefastlabs/codefast/pull/1007) Add `codefast audit layers`, which holds a package's `src/` to the layering its architecture states.
+  `audit.layers.packages` lists each package's layers bottom to top, every entry a family directly under the root — a
+  directory, or a lone module sitting flat — and the audit reports every value import or re-export that points up the
+  list, plus every module no layer places. Type-only imports pass whichever way they point; a dynamic `import()` counts as
+  a value import. A configured name the workspace does not hold, an entry nested below the root, and a family placed twice
+  are refused before anything is scanned. `audit.layers.allowlist` takes the offending import as written, or
+  `path:<import>`.
+
+- [#990](https://github.com/codefastlabs/codefast/pull/990) Remove `codefast audit constants`, the audit that required every upper-case numeric `const` to name its kind in the
+  comment above it.
+
+  Breaking: the `audit constants` subcommand is gone, and `audit.constants` is no longer a config key, so a
+  `codefast.config` that still sets it fails validation as an unknown key; delete that section.
+
+- [#992](https://github.com/codefastlabs/codefast/pull/992) `codefast tag` stamps every overload signature again, each in its own doc block. Since the move to `oxc-parser` it
+  stamped only an overloaded function's implementation, the one signature a `.d.ts` drops, so a released overload reached
+  consumers with no `@since` on any signature they can see.
+
+  A declaration with no doc block and a `//` comment on the line above it now fails the run instead of getting a fresh
+  block there, where the block would stack under a note (which `audit comments` rejects) or split a directive from the
+  code it governs. The run names each such declaration by file and line, lists it under `blockedDeclarations` in `--json`,
+  leaves its file untouched, and exits `1`: once a release ships the declaration unstamped, a later run can only stamp a
+  version that did not introduce it. The `--json` `ok` field now follows the exit code, so a failed target also reports
+  `ok: false`.
+
 ## 0.13.0
 
 ### Minor Changes

package/README.md

@@ -111,9 +111,9 @@ codefast                              # Codefast monorepo developer CLI
 │  ├─ links [target]                  # markdown links pointing at a missing path/anchor
 │  ├─ imports [target]                # banned import forms (React by-name, Zod namespace in front-end, …)
 │  ├─ assertions [target]             # double type assertions through unknown/any (x as unknown as T)
-│  ├─ constants [target]              # numeric constants whose comment names none of the three kinds
 │  ├─ display-names [target]          # token()/tag()/module names breaking the <namespace>:<Name> convention
 │  ├─ publish [target]                # what breaks a consumer's install: #/ imports, unshipped targets, @source paths
+│  ├─ layers [target]                 # value imports pointing up a package's configured layers
 │  └─ comments [target]               # section dividers not in the one allowed form
 │      └─ --fix                       # rewrite every fixable divider in place (the only audit that writes)
 │      (each audit also takes [target] + --json)
@@ -145,16 +145,16 @@ Every command also responds to `--help`; each command's section below explains w
 | `audit links`         | Report markdown cross-references that resolve to nothing                   | no                |
 | `audit imports`       | Enforce the import policy (React by-name, Zod namespace in front-end)      | no (report only)  |
 | `audit assertions`    | Report double type assertions through `unknown` / `any`, tests included    | no                |
-| `audit constants`     | Require every tuned numeric constant to name the kind of number it is      | no                |
 | `audit display-names` | Enforce the `namespace:Name` display-name convention                       | no                |
 | `audit publish`       | Report what would break a consumer's install of a published package        | no                |
+| `audit layers`        | Report value imports that point up a package's configured layers           | no                |
 | `audit comments`      | Check doc-comment conventions; repair section dividers                     | `--fix` only      |
 
-**Which of these are for you?** `arrange`, `mirror`, `pack-slim`, `tag`, `audit links`, `audit assertions`, and
-`audit publish` are general-purpose — they work for any pnpm workspace or single package that builds with `tsc`. The
-other five audits encode codefast's own house style (logical Tailwind directions, named React imports, a specific
-comment/divider grammar, a `namespace:Name` scheme for `@codefast/di` tokens, a named kind for every tuned numeric
-constant). Adopt them if they fit your project; otherwise skip them, or use an allowlist to narrow their scope.
+**Which of these are for you?** `arrange`, `mirror`, `pack-slim`, `tag`, `audit links`, `audit assertions`,
+`audit layers`, and `audit publish` are general-purpose — they work for any pnpm workspace or single package that builds
+with `tsc`. The other four audits encode codefast's own house style (logical Tailwind directions, named React imports, a
+specific comment/divider grammar, a `namespace:Name` scheme for `@codefast/di` tokens). Adopt them if they fit your
+project; otherwise skip them, or use an allowlist to narrow their scope.
 
 ## `arrange`
 
@@ -276,9 +276,15 @@ Exits `1` when any package fails, `0` otherwise.
 ## `tag`
 
 Adds `@since <version>` tags to the doc comments of exported declarations that lack one, creating the doc block when
-there is none. The version comes from the nearest `package.json` above each target file, and declarations that already
-carry `@since` are left alone. Run it at release time so published APIs carry accurate version metadata — never
-hand-write `@since`.
+there is none. Overload signatures are declarations too, each stamped on its own, because the `.d.ts` keeps every
+overload's doc block and drops the implementation's. The version comes from the nearest `package.json` above each target
+file, and declarations that already carry `@since` are left alone. Run it at release time so published APIs carry
+accurate version metadata — never hand-write `@since`.
+
+A declaration with no doc block and a `//` comment on the line above it is reported instead: a block written there would
+stack under a note, which `audit comments` rejects, or split a directive from the code it governs. Its file is left as
+it is, so every reported line stays accurate. Write the doc block by hand before the release that ships the declaration,
+since a later run can only stamp a version that did not introduce it.
 
 ```bash
 codefast tag                   # auto-discover packages from cwd (or the single package)
@@ -286,7 +292,8 @@ codefast tag packages/ui/src   # tag one directory or file
 codefast tag --dry-run         # summary only, no writes
 ```
 
-Exits `1` when no target is selected, when any target fails, or when the `tag.onAfterWrite` hook fails.
+Exits `1` when no target is selected, when any target fails, when a declaration is left unstamped, or when the
+`tag.onAfterWrite` hook fails.
 
 ## `audit`
 
@@ -385,6 +392,41 @@ codefast audit publish                     # every published package in the work
 codefast audit publish --json              # machine-readable summary
 ```
 
+### `audit layers`
+
+_General-purpose._ Holds a package's `src/` to the layering its architecture states. You list the layers in
+configuration, bottom to top, each naming the families directly under the root — a directory, or a lone module sitting
+flat (`errors.ts`) — and the audit reports every value import or re-export that points up the list, plus every module no
+layer places. Type-only imports erase at build time and couple nothing, so they may point anywhere; a dynamic `import()`
+counts as a value import wherever it sits.
+
+```js
+// codefast.config.js
+export default {
+  audit: {
+    layers: {
+      packages: {
+        "@acme/di": {
+          root: "src", // where the layers sit, relative to the package (default)
+          layers: [["core", "errors.ts"], ["engine"], ["container"], ["index.ts"]],
+        },
+      },
+      allowlist: [],
+    },
+  },
+};
+```
+
+```bash
+codefast audit layers                        # every package audit.layers.packages names
+codefast audit layers packages/di            # one package, or a directory beneath its root
+codefast audit layers --json                 # machine-readable summary
+```
+
+A configured package name the workspace does not hold, a layer entry nested below the root, and a family placed twice
+are refused before anything is scanned. Configure exceptions via `audit.layers.allowlist` — each entry is the offending
+import as written or `repo/relative/path.ts:<import>`.
+
 ### `audit comments`
 
 _House style._ Checks doc-comment conventions. Section dividers not in the one allowed form are mechanical, so `--fix`
@@ -420,30 +462,6 @@ codefast audit display-names --json                # machine-readable summary
 Configure exceptions via `audit.displayNames.allowlist` — each entry is the call as written, through its closing quote
 (or parenthesis when the name is the only argument), or `repo/relative/path.ts:<call>`.
 
-### `audit constants`
-
-_House style._ Holds library sources to one rule for tuned numbers: a numeric constant says which kind of number it is.
-It flags an upper-case `const NAME = <number>` in a `.ts`/`.tsx` file under a `src` directory — tests, benchmarks, apps,
-and examples are out of scope — unless the comment directly above it, a `/* … */` block or a run of `//` lines, names
-one of three kinds:
-
-- `a constant of the machine` — a width of the platform the code runs on;
-- `a value the contract fixes` — a number the documented contract promises;
-- `derived from bind-time data` — a figure computed from what a caller hands in.
-
-A count that merely looks reasonable is none of them, so it is reported. `0`, `1`, and `-1` are skipped: they stand for
-absence or identity, not for a tuned size.
-
-```bash
-codefast audit constants                   # uses audit.constants.target from config
-codefast audit constants packages/di/src   # explicit target
-codefast audit constants --json            # machine-readable summary
-```
-
-With no `[target]`, the scan root is `audit.constants.target` from the config; when neither is set the command fails.
-Configure exceptions via `audit.constants.allowlist` — each entry is the constant's name or `repo/relative/path.ts:NAME`
-— for a measured policy that has to stay a tuned number.
-
 ## Configuration
 
 **You do not need a config file.** Every command has sensible defaults and works with none. Add a `codefast.config.*`
@@ -579,9 +597,10 @@ export default {
     imports: { allowlist: [] }, // offending import text as written, or `repo/relative/path.tsx:<text>`
     assertions: { allowlist: [] }, // assertion as written, or `repo/relative/path.ts:<assertion>`
     displayNames: { allowlist: [] }, // call as written, or `repo/relative/path.ts:<call>`
-    constants: {
-      target: "packages/core/src", // default scan root when no CLI arg is passed
-      allowlist: [], // constant name, or `repo/relative/path.ts:NAME`
+    layers: {
+      // per package: its layers bottom to top, each entry a directory or module file under `root` (default `src`)
+      packages: { "@acme/di": { layers: [["core", "errors.ts"], ["engine"], ["index.ts"]] } },
+      allowlist: [], // import as written, or `repo/relative/path.ts:<import>`
     },
   },
 };
@@ -635,7 +654,7 @@ pnpm run cli:audit:comments         # codefast audit comments
 pnpm run cli:audit:imports          # codefast audit imports
 pnpm run cli:audit:assertions       # codefast audit assertions
 pnpm run cli:audit:display-names    # codefast audit display-names
-pnpm run cli:audit:constants        # codefast audit constants
+pnpm run cli:audit:layers           # codefast audit layers
 pnpm run cli:audit:publish          # codefast audit publish
 ```
 

package/dist/audit/command.js

@@ -9,11 +9,6 @@ import { commentAuditRunRequestSchema } from "#audit/comments/cli-schema";
 import { presentCommentAuditResult } from "#audit/comments/output";
 import { prepareCommentAudit } from "#audit/comments/prepare";
 import { runCommentAudit } from "#audit/comments/run";
-import { exitCodeForConstantAuditResult, formatConstantAuditJsonOutput } from "#audit/constants/cli-result";
-import { constantAuditRunRequestSchema } from "#audit/constants/cli-schema";
-import { presentConstantAuditResult } from "#audit/constants/output";
-import { prepareConstantAudit } from "#audit/constants/prepare";
-import { runConstantAudit } from "#audit/constants/run";
 import { exitCodeForDisplayNameAuditResult, formatDisplayNameAuditJsonOutput } from "#audit/display-names/cli-result";
 import { displayNameAuditRunRequestSchema } from "#audit/display-names/cli-schema";
 import { presentDisplayNameAuditResult } from "#audit/display-names/output";
@@ -24,6 +19,11 @@ import { importsAuditRunRequestSchema } from "#audit/imports/cli-schema";
 import { presentImportsAuditResult } from "#audit/imports/output";
 import { prepareImportsAudit } from "#audit/imports/prepare";
 import { runImportsAudit } from "#audit/imports/run";
+import { exitCodeForLayersAuditResult, formatLayersAuditJsonOutput } from "#audit/layers/cli-result";
+import { layersAuditRunRequestSchema } from "#audit/layers/cli-schema";
+import { presentLayersAuditResult } from "#audit/layers/output";
+import { prepareLayersAudit } from "#audit/layers/prepare";
+import { runLayersAudit } from "#audit/layers/run";
 import { exitCodeForLinkAuditResult, formatLinkAuditJsonOutput } from "#audit/links/cli-result";
 import { linkAuditRunRequestSchema } from "#audit/links/cli-schema";
 import { presentLinkAuditResult } from "#audit/links/output";
@@ -121,22 +121,6 @@ const displayNamesCheck = {
     formatJson: formatDisplayNameAuditJsonOutput,
     exitCode: exitCodeForDisplayNameAuditResult,
 };
-const constantsCheck = {
-    name: "constants",
-    description: "Report numeric constants whose comment names none of the three kinds a number may be",
-    targetHelp: "Directory or file to scan (default: audit.constants.target from config)",
-    schema: constantAuditRunRequestSchema,
-    prepare: prepareConstantAudit,
-    buildRequest: baseAuditRequest,
-    run: (fs, request) => runConstantAudit(fs, {
-        rootDir: request.rootDir,
-        targetPath: request.targetPath,
-        allowlist: request.allowlist ?? [],
-    }),
-    present: presentConstantAuditResult,
-    formatJson: formatConstantAuditJsonOutput,
-    exitCode: exitCodeForConstantAuditResult,
-};
 const commentsCheck = {
     name: "comments",
     description: "Report section dividers that are not in the repo's one allowed form",
@@ -157,6 +141,23 @@ const commentsCheck = {
         command.option("--fix", "Rewrite every mechanically fixable divider in place", false);
     },
 };
+const layersCheck = {
+    name: "layers",
+    description: "Report value imports that point up a package's configured layers, and modules sitting in no layer",
+    targetHelp: "Directory or file to scan (default: the repo root, reaching every package audit.layers names)",
+    schema: layersAuditRunRequestSchema,
+    prepare: prepareLayersAudit,
+    buildRequest: (prelude, opts) => ({ ...baseAuditRequest(prelude, opts), packages: prelude.packages }),
+    run: (fs, request) => runLayersAudit(fs, {
+        rootDir: request.rootDir,
+        targetPath: request.targetPath,
+        allowlist: request.allowlist ?? [],
+        packages: request.packages,
+    }),
+    present: presentLayersAuditResult,
+    formatJson: formatLayersAuditJsonOutput,
+    exitCode: exitCodeForLayersAuditResult,
+};
 const publishCheck = {
     name: "publish",
     description: "Report what breaks a consumer's install: #/ imports, unshipped exports/imports targets, and stylesheet @source paths reaching nothing shipped",
@@ -200,8 +201,8 @@ export function createAuditCommand() {
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(importsCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(assertionsCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(displayNamesCheck));
-    registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(constantsCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(commentsCheck));
+    registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(layersCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(publishCheck));
     return cmd;
 }

package/dist/audit/comments/domain/comment-content.d.ts

@@ -18,6 +18,18 @@ export interface CommentContentFinding {
     readonly raw: string;
     readonly defect: CommentContentDefectKind;
 }
+/**
+ * Returns whether a line is a `//` note: a line comment that is neither a divider nor a tooling directive.
+ *
+ * @since 0.14.0
+ */
+export declare function isNoteLine(line: string): boolean;
+/**
+ * Returns whether a line is a `//` tooling directive, which governs the code below it.
+ *
+ * @since 0.14.0
+ */
+export declare function isDirectiveLine(line: string): boolean;
 /**
  * Scans a source file's comments for banned content, in source order.
  *

package/dist/audit/comments/domain/comment-content.js

@@ -18,6 +18,22 @@ const declarationPattern = /^[ \t]*(?:export|const|let|var|function|class|interf
 // A divider or a tooling directive above a doc block is not a stacked note.
 const dividerLinePattern = /^[ \t]*\/\/[ \t]*[-=─_*~#]{2,}/;
 const directiveLinePattern = /^[ \t]*\/\/[ \t]*(?:oxlint-|eslint-|@ts-|prettier-)/;
+/**
+ * Returns whether a line is a `//` note: a line comment that is neither a divider nor a tooling directive.
+ *
+ * @since 0.14.0
+ */
+export function isNoteLine(line) {
+    return lineCommentPattern.test(line) && !dividerLinePattern.test(line) && !isDirectiveLine(line);
+}
+/**
+ * Returns whether a line is a `//` tooling directive, which governs the code below it.
+ *
+ * @since 0.14.0
+ */
+export function isDirectiveLine(line) {
+    return directiveLinePattern.test(line);
+}
 /**
  * Scans a source file's comments for banned content, in source order.
  *
@@ -37,10 +53,7 @@ export function scanCommentContent(content, language) {
         // A `//` run stacked directly above a doc block reads as a second doc — it belongs inside.
         if (language === "js" && !insideBlock && trimmed.startsWith("/**")) {
             let runStart = index;
-            while (runStart > 0 &&
-                lineCommentPattern.test(lines[runStart - 1]) &&
-                !dividerLinePattern.test(lines[runStart - 1]) &&
-                !directiveLinePattern.test(lines[runStart - 1])) {
+            while (runStart > 0 && isNoteLine(lines[runStart - 1])) {
                 runStart--;
             }
             if (runStart < index) {

package/dist/audit/domain/types.d.ts

@@ -135,37 +135,6 @@ export type DisplayNameAuditResult = {
     readonly allowlistedCount: number;
     readonly scannedFileCount: number;
 };
-/**
- * A numeric constant whose comment names none of the three kinds.
- *
- * @since 0.11.0
- */
-export type ConstantViolation = {
-    readonly line: number;
-    /** The declaration's name and value, as `NAME = 32`. */
-    readonly raw: string;
-    readonly reason: string;
-};
-/**
- * The numeric-constant violations found in one file.
- *
- * @since 0.11.0
- */
-export type ConstantFileViolations = {
-    readonly relativePath: string;
-    readonly violations: Array<ConstantViolation>;
-};
-/**
- * Outcome of one `audit constants` run.
- *
- * @since 0.11.0
- */
-export type ConstantAuditResult = {
-    readonly files: Array<ConstantFileViolations>;
-    readonly violationCount: number;
-    readonly allowlistedCount: number;
-    readonly scannedFileCount: number;
-};
 /**
  * A broken link or anchor found by the link audit.
  *
@@ -296,4 +265,36 @@ export type PublishAuditResult = {
     readonly legacyImportCount: number;
     readonly scannedFileCount: number;
     readonly packageCount: number;
+};
+/**
+ * A module outside every configured layer, or a value import that points up the layers.
+ *
+ * @since 0.14.0
+ */
+export type LayerViolation = {
+    readonly line: number;
+    /** The import or re-export as written, or the module path when the module itself is unplaced. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The layering violations found in one file.
+ *
+ * @since 0.14.0
+ */
+export type LayerFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<LayerViolation>;
+};
+/**
+ * Outcome of one `audit layers` run.
+ *
+ * @since 0.14.0
+ */
+export type LayersAuditResult = {
+    readonly files: Array<LayerFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+    readonly packageCount: number;
 };

package/dist/audit/layers/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { LayersAuditResult } from "#audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted layering violation remains.
+ *
+ * @since 0.14.0
+ */
+export declare function exitCodeForLayersAuditResult(result: LayersAuditResult): number;
+/**
+ * Machine-readable layering summary for `--json`.
+ *
+ * @since 0.14.0
+ */
+export declare function formatLayersAuditJsonOutput(result: LayersAuditResult, rootDir: string): string;

package/dist/audit/{constants → layers}/cli-result.js

@@ -1,18 +1,18 @@
 import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#core/exit-codes";
 /**
- * Exit `1` when any non-allowlisted numeric constant is unlabelled.
+ * Exit `1` when any non-allowlisted layering violation remains.
  *
- * @since 0.11.0
+ * @since 0.14.0
  */
-export function exitCodeForConstantAuditResult(result) {
+export function exitCodeForLayersAuditResult(result) {
     return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
 }
 /**
- * Machine-readable numeric-constant summary for `--json`.
+ * Machine-readable layering summary for `--json`.
  *
- * @since 0.11.0
+ * @since 0.14.0
  */
-export function formatConstantAuditJsonOutput(result, rootDir) {
+export function formatLayersAuditJsonOutput(result, rootDir) {
     return JSON.stringify({
         schemaVersion: 1,
         ok: result.violationCount === 0,

package/dist/audit/layers/cli-schema.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod";
+/**
+ * One layered package as the run reads it: its name, the absolute root the layers sit under, and the layers.
+ *
+ * @since 0.14.0
+ */
+export type LayersAuditPackage = {
+    readonly name: string;
+    readonly rootPath: string;
+    readonly layers: ReadonlyArray<ReadonlyArray<string>>;
+};
+/**
+ * Resolved request for a single layering audit run.
+ *
+ * @since 0.14.0
+ */
+export type LayersAuditRunRequest = {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist?: ReadonlyArray<string> | undefined;
+    readonly json: boolean;
+    readonly packages: ReadonlyArray<LayersAuditPackage>;
+};
+/**
+ * Zod schema for {@link LayersAuditRunRequest}.
+ *
+ * @since 0.14.0
+ */
+export declare const layersAuditRunRequestSchema: z.ZodType<LayersAuditRunRequest>;

package/dist/audit/layers/cli-schema.js

@@ -0,0 +1,17 @@
+import * as z from "zod";
+/**
+ * Zod schema for {@link LayersAuditRunRequest}.
+ *
+ * @since 0.14.0
+ */
+export const layersAuditRunRequestSchema = z.object({
+    rootDir: z.string().min(1),
+    targetPath: z.string().min(1),
+    allowlist: z.array(z.string()).optional(),
+    json: z.boolean(),
+    packages: z.array(z.object({
+        name: z.string().min(1),
+        rootPath: z.string().min(1),
+        layers: z.array(z.array(z.string().min(1))),
+    })),
+});

package/dist/audit/layers/domain/layering.d.ts

@@ -0,0 +1,46 @@
+import type { LayerViolation } from "#audit/domain/types";
+/**
+ * The key a layer entry and a module path share: the first path segment, without a module extension.
+ *
+ * @remarks `errors.ts`, `errors/` and `errors/taxonomy.ts` all key as `errors`, so a layer entry names
+ * a family directly under the root — a directory, or a lone module sitting flat.
+ *
+ * @since 0.14.0
+ */
+export declare function layerKeyOf(modulePath: string): string;
+/**
+ * Returns why a layer list breaks its contract, or `undefined` when every entry is a family under the root, placed once.
+ *
+ * @since 0.14.0
+ */
+export declare function invalidLayerEntry(layers: ReadonlyArray<ReadonlyArray<string>>): string | undefined;
+/**
+ * Where a module sits: its layer's position from the bottom, and the entry that placed it there.
+ *
+ * @since 0.14.0
+ */
+export interface LayerPlacement {
+    readonly index: number;
+    readonly entry: string;
+}
+/**
+ * A package's layers, bottom to top, answering the placement of any module path under the root.
+ *
+ * @since 0.14.0
+ */
+export declare class LayerMap {
+    #private;
+    constructor(layers: ReadonlyArray<ReadonlyArray<string>>);
+    /** The placement of a root-relative module path, or `undefined` when no layer names its family. */
+    placementOf(modulePath: string): LayerPlacement | undefined;
+}
+/**
+ * Scans one module against its package's layers and returns the violations: the module sitting in no
+ * layer, or a value import or re-export whose target sits in a higher layer, or in none.
+ *
+ * @remarks Type-only imports and re-exports erase at build time and couple nothing, so they pass
+ * whichever way they point. Dynamic `import()` counts as a value import wherever it sits.
+ *
+ * @since 0.14.0
+ */
+export declare function auditLayeringSource(filePath: string, modulePath: string, sourceText: string, layers: LayerMap): Array<LayerViolation>;