@shrkcrft/boundaries 0.1.0-alpha.29 → 0.1.0-alpha.31

package/dist/extract/scan-literals.d.ts

@@ -11,7 +11,18 @@
  * comment syntax differs from the C/JS family (e.g. `#` comments) is scanned as
  * plain code.
  */
-/** Index of the closing quote of the string starting at `start` (handles escapes). */
+/**
+ * Index of the closing quote of the string starting at `start` (handles escapes).
+ *
+ * A `'…'` or `"…"` literal ends at an unescaped NEWLINE (JS semantics — only a
+ * template literal spans lines): the returned index is then the last character
+ * before the newline. Without this a quote the lexer could not recognise as
+ * code — the `'` inside a regex literal such as `/[&<>"']/g`, an apostrophe in
+ * prose — swallowed the rest of the FILE as one phantom string, hiding every
+ * real construct after it (round 11, 6.1a: a real `import()` 60 lines later
+ * vanished). Bounding the mis-lex to one line is strictly more accurate for
+ * every caller: zone lexing, the policy plane and array extraction alike.
+ */
 export declare function skipString(content: string, start: number): number;
 /**
  * If a comment starts at `start`, the index of its LAST character; otherwise

package/dist/extract/scan-literals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-literals.d.ts","sourceRoot":"","sources":["../../src/extract/scan-literals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAUjE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYlE;AAED,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AA0CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAgC7E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsB7D"}
+{"version":3,"file":"scan-literals.d.ts","sourceRoot":"","sources":["../../src/extract/scan-literals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYjE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYlE;AAED,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AA0CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAgC7E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsB7D"}

package/dist/extract/scan-literals.js

@@ -11,9 +11,21 @@
  * comment syntax differs from the C/JS family (e.g. `#` comments) is scanned as
  * plain code.
  */
-/** Index of the closing quote of the string starting at `start` (handles escapes). */
+/**
+ * Index of the closing quote of the string starting at `start` (handles escapes).
+ *
+ * A `'…'` or `"…"` literal ends at an unescaped NEWLINE (JS semantics — only a
+ * template literal spans lines): the returned index is then the last character
+ * before the newline. Without this a quote the lexer could not recognise as
+ * code — the `'` inside a regex literal such as `/[&<>"']/g`, an apostrophe in
+ * prose — swallowed the rest of the FILE as one phantom string, hiding every
+ * real construct after it (round 11, 6.1a: a real `import()` 60 lines later
+ * vanished). Bounding the mis-lex to one line is strictly more accurate for
+ * every caller: zone lexing, the policy plane and array extraction alike.
+ */
 export function skipString(content, start) {
     const quote = content[start];
+    const singleLine = quote === "'" || quote === '"';
     for (let i = start + 1; i < content.length; i += 1) {
         if (content[i] === '\\') {
             i += 1;
@@ -21,6 +33,8 @@ export function skipString(content, start) {
         }
         if (content[i] === quote)
             return i;
+        if (singleLine && content[i] === '\n')
+            return i - 1;
     }
     return content.length - 1;
 }

package/dist/extract/source-liveness-request.d.ts

@@ -0,0 +1,24 @@
+import type { IGlobListUnits } from '../util/i-glob-list-units.js';
+import type { IGlobLivenessRequest } from '../util/i-glob-liveness-request.js';
+import type { ILabeledSource } from './i-labeled-source.js';
+/**
+ * THE glob lists of a rule's extraction sources as the gate-plane liveness
+ * settle reads them (round 13) — every source's `files` and, NEW this round,
+ * an `import-edges` source's `to.files` (judged for liveness, so a typo'd fence
+ * target is no longer a silent pass, and markable, so a fence to a planned
+ * subtree is sayable).
+ *
+ * Each list is qualified by its side (`declared.files`, `compute.source.to.files`
+ * — `qualifyListPath`), and each source's markers the same way
+ * (`qualifyUnitMarks`), so one settle spans a rule's every source without two
+ * sides' `files` colliding. In a multi-source rule a unit prints `<side>: <glob>`
+ * (today's dead-glob selector); `to.files` units print `[<side> ]to.files: <glob>`.
+ *
+ * `gates coverage` (`buildGateCoverage`), the wiring engine (`runWiring`) and
+ * the registration role measurement all build their request here, so the one
+ * rule's units read identically on every surface. `unitsOf` lets a caller
+ * judge a `files` list off a walk it already did; `to.files` matches resolved
+ * import targets, so it is judged off the one reader's own walk of its globs.
+ */
+export declare function sourceLivenessRequest(projectRoot: string, sources: readonly ILabeledSource[], excludeDirs?: readonly string[], subject?: string, unitsOf?: (globs: readonly string[]) => IGlobListUnits): IGlobLivenessRequest;
+//# sourceMappingURL=source-liveness-request.d.ts.map

package/dist/extract/source-liveness-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-liveness-request.d.ts","sourceRoot":"","sources":["../../src/extract/source-liveness-request.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,WAAW,GAAE,SAAS,MAAM,EAAO,EACnC,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,cAAc,GACrD,oBAAoB,CAuBtB"}

package/dist/extract/source-liveness-request.js

@@ -0,0 +1,45 @@
+import { qualifyListPath, qualifyUnitMarks } from '@shrkcrft/core';
+import { readGlobListUnits } from "../util/dead-glob-units.js";
+/**
+ * THE glob lists of a rule's extraction sources as the gate-plane liveness
+ * settle reads them (round 13) — every source's `files` and, NEW this round,
+ * an `import-edges` source's `to.files` (judged for liveness, so a typo'd fence
+ * target is no longer a silent pass, and markable, so a fence to a planned
+ * subtree is sayable).
+ *
+ * Each list is qualified by its side (`declared.files`, `compute.source.to.files`
+ * — `qualifyListPath`), and each source's markers the same way
+ * (`qualifyUnitMarks`), so one settle spans a rule's every source without two
+ * sides' `files` colliding. In a multi-source rule a unit prints `<side>: <glob>`
+ * (today's dead-glob selector); `to.files` units print `[<side> ]to.files: <glob>`.
+ *
+ * `gates coverage` (`buildGateCoverage`), the wiring engine (`runWiring`) and
+ * the registration role measurement all build their request here, so the one
+ * rule's units read identically on every surface. `unitsOf` lets a caller
+ * judge a `files` list off a walk it already did; `to.files` matches resolved
+ * import targets, so it is judged off the one reader's own walk of its globs.
+ */
+export function sourceLivenessRequest(projectRoot, sources, excludeDirs = [], subject, unitsOf) {
+    const multi = sources.length > 1;
+    const exclude = new Set(excludeDirs);
+    const judge = unitsOf ?? ((globs) => readGlobListUnits(projectRoot, globs, exclude));
+    const lists = [];
+    const marks = [];
+    for (const { label, source } of sources) {
+        const files = source.files ?? [];
+        if (files.length > 0) {
+            lists.push({ list: qualifyListPath(label, 'files'), ...(multi ? { label } : {}), globs: files, units: judge(files) });
+        }
+        const to = source.to?.files ?? [];
+        if (to.length > 0) {
+            lists.push({
+                list: qualifyListPath(label, 'to.files'),
+                label: multi ? `${label} to.files` : 'to.files',
+                globs: to,
+                units: readGlobListUnits(projectRoot, to, exclude),
+            });
+        }
+        marks.push(...qualifyUnitMarks(source.expectEmptyUnits ?? [], label));
+    }
+    return { ...(subject !== undefined ? { subject } : {}), lists, marks };
+}

package/dist/generated/check-provenance.d.ts

@@ -6,7 +6,11 @@ export type ProvenanceFindingKind =
 /** A file OUTSIDE the glob carries the header — a hand-written file mislabeled. */
  | 'mislabeled'
 /** Advisory: the header does not name how to regenerate the file. */
- | 'no-regen-pointer';
+ | 'no-regen-pointer'
+/** In the tree, owned by no writer and not blessed as hand-maintained. */
+ | 'unclassified'
+/** A `handMaintained` bless whose file no longer exists. */
+ | 'stale-hand-maintained';
 export interface IProvenanceFinding {
     readonly ruleId: string;
     readonly file: string;
@@ -20,6 +24,20 @@ export interface IProvenanceFinding {
  * deterministic — never a whole-tree read of every file type.
  */
 export declare function deriveOutsideGlobs(generatedGlob: readonly string[]): string[];
+/**
+ * Tree-classification results a mixed-tree rule produces alongside its files.
+ *
+ * Passed in rather than recomputed so the classification a caller already did
+ * (see `scanGeneratedFiles`) is the same one reported — two implementations of
+ * "which files does this rule own?" is precisely the drift this plane exists
+ * to catch.
+ */
+export interface IClassificationFindings {
+    /** Files under the tree owned by no writer and not blessed. */
+    readonly unclassified?: readonly string[];
+    /** `handMaintained` patterns currently matching no file. */
+    readonly staleHandMaintained?: readonly string[];
+}
 /**
  * Check the "this file is generated" header contract.
  *
@@ -30,7 +48,7 @@ export declare function deriveOutsideGlobs(generatedGlob: readonly string[]): st
  * `outside` should contain candidate files NOT in `generatedGlob`; pass an empty
  * map when `forbidOutside` is off.
  */
-export declare function checkProvenanceHeaders(rule: IGeneratedArtifactRule, generated: ReadonlyMap<string, string>, outside: ReadonlyMap<string, string>): {
+export declare function checkProvenanceHeaders(rule: IGeneratedArtifactRule, generated: ReadonlyMap<string, string>, outside: ReadonlyMap<string, string>, classification?: IClassificationFindings): {
     findings: readonly IProvenanceFinding[];
     error?: string;
 };

package/dist/generated/check-provenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-provenance.d.ts","sourceRoot":"","sources":["../../src/generated/check-provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAG7D,0CAA0C;AAC1C,MAAM,MAAM,qBAAqB;AAC/B,qEAAqE;AACnE,gBAAgB;AAClB,mFAAmF;GACjF,YAAY;AACd,qEAAqE;GACnE,kBAAkB,CAAC;AAEvB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAQD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAO7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,sBAAsB,EAC5B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC;IAAE,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA2D7D"}
+{"version":3,"file":"check-provenance.d.ts","sourceRoot":"","sources":["../../src/generated/check-provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAI7D,0CAA0C;AAC1C,MAAM,MAAM,qBAAqB;AAC/B,qEAAqE;AACnE,gBAAgB;AAClB,mFAAmF;GACjF,YAAY;AACd,qEAAqE;GACnE,kBAAkB;AACpB,0EAA0E;GACxE,cAAc;AAChB,4DAA4D;GAC1D,uBAAuB,CAAC;AAE5B,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAQD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ7E;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,4DAA4D;IAC5D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClD;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,sBAAsB,EAC5B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,cAAc,GAAE,uBAA4B,GAC3C;IAAE,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAgF7D"}

package/dist/generated/check-provenance.js

@@ -1,3 +1,4 @@
+import { globListWalkGlobs } from "../scan/glob.js";
 import { safeCompile } from "../util/safe-regex.js";
 /** The head of a file, as the header contract sees it. */
 function headOf(content, withinLines) {
@@ -11,7 +12,8 @@ function headOf(content, withinLines) {
  */
 export function deriveOutsideGlobs(generatedGlob) {
     const exts = new Set();
-    for (const g of generatedGlob) {
+    // Inclusion globs only: a `!gen/**/*.hand.ts` names no extension to search.
+    for (const g of globListWalkGlobs(generatedGlob)) {
         const m = /\.([A-Za-z0-9]+)$/.exec(g);
         if (m)
             exts.add(m[1]);
@@ -28,16 +30,35 @@ export function deriveOutsideGlobs(generatedGlob) {
  * `outside` should contain candidate files NOT in `generatedGlob`; pass an empty
  * map when `forbidOutside` is off.
  */
-export function checkProvenanceHeaders(rule, generated, outside) {
+export function checkProvenanceHeaders(rule, generated, outside, classification = {}) {
+    const severity = rule.severity ?? 'error';
+    // Classification findings do not depend on the header contract — a mixed tree
+    // must be fully accounted for whether or not the rule asserts headers, so
+    // these are produced before the early return below.
+    const classFindings = [
+        ...(classification.unclassified ?? []).map((file) => ({
+            ruleId: rule.id,
+            file,
+            kind: 'unclassified',
+            severity,
+            message: 'in the generated tree but owned by no `sources[]` glob and not listed in `handMaintained` — classify it',
+        })),
+        ...(classification.staleHandMaintained ?? []).map((pattern) => ({
+            ruleId: rule.id,
+            file: pattern,
+            kind: 'stale-hand-maintained',
+            severity: 'warning',
+            message: '`handMaintained` entry matches no file — the blessed file was renamed or deleted',
+        })),
+    ];
     const header = rule.provenanceHeader;
     if (!header)
-        return { findings: [] };
+        return { findings: classFindings };
     const { re, error } = safeCompile(header.mustMatch, header.flags);
     if (error || !re)
-        return { findings: [], error: `provenanceHeader ${error}` };
-    const severity = rule.severity ?? 'error';
+        return { findings: classFindings, error: `provenanceHeader ${error}` };
     const within = header.withinLines ?? 10;
-    const findings = [];
+    const findings = [...classFindings];
     const test = (content) => {
         re.lastIndex = 0;
         return re.test(headOf(content, within));

package/dist/generated/read-regen-tree.d.ts

@@ -0,0 +1,16 @@
+import type { IMatchedFiles } from '../util/matched-files.js';
+/**
+ * Read a REGENERATED temp tree (what a `generatedArtifacts[].regen` wrote into
+ * `{TMP}`): every file under `root`, keyed by POSIX path relative to it.
+ *
+ * Same contract as the one reader (`readMatchingFiles`): a file it did not read
+ * (over {@link MAX_REGEN_FILE_BYTES}, or unreadable) is returned in `unread`
+ * with its reason, never dropped. It used to be dropped, so a regen that wrote
+ * a NEW 2.1MB file read "byte-identical to a fresh regen ✓" while the same
+ * file at 100 bytes failed as "regen produces it but it is not committed".
+ * The caller decides what an unread output means: one keyed onto a committed
+ * file cannot be byte-compared (a coverage gap), one keyed onto nothing
+ * committed is drift its path alone proves.
+ */
+export declare function readRegenTree(root: string): IMatchedFiles;
+//# sourceMappingURL=read-regen-tree.d.ts.map

package/dist/generated/read-regen-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-regen-tree.d.ts","sourceRoot":"","sources":["../../src/generated/read-regen-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAK9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAuCzD"}

package/dist/generated/read-regen-tree.js

@@ -0,0 +1,61 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { UnreadFileReason } from "../util/unread-file-reason.js";
+import { MAX_REGEN_FILE_BYTES } from "../util/walk-files.js";
+/**
+ * Read a REGENERATED temp tree (what a `generatedArtifacts[].regen` wrote into
+ * `{TMP}`): every file under `root`, keyed by POSIX path relative to it.
+ *
+ * Same contract as the one reader (`readMatchingFiles`): a file it did not read
+ * (over {@link MAX_REGEN_FILE_BYTES}, or unreadable) is returned in `unread`
+ * with its reason, never dropped. It used to be dropped, so a regen that wrote
+ * a NEW 2.1MB file read "byte-identical to a fresh regen ✓" while the same
+ * file at 100 bytes failed as "regen produces it but it is not committed".
+ * The caller decides what an unread output means: one keyed onto a committed
+ * file cannot be byte-compared (a coverage gap), one keyed onto nothing
+ * committed is drift its path alone proves.
+ */
+export function readRegenTree(root) {
+    const files = new Map();
+    const unread = [];
+    const visit = (abs) => {
+        let entries;
+        try {
+            entries = readdirSync(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const child = nodePath.join(abs, e.name);
+            if (e.isDirectory()) {
+                visit(child);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            const rel = nodePath.relative(root, child).split(nodePath.sep).join('/');
+            let size;
+            try {
+                size = statSync(child).size;
+            }
+            catch {
+                unread.push({ path: rel, reason: UnreadFileReason.Unreadable });
+                continue;
+            }
+            if (size > MAX_REGEN_FILE_BYTES) {
+                unread.push({ path: rel, reason: UnreadFileReason.OverRegenCap, bytes: size });
+                continue;
+            }
+            try {
+                files.set(rel, readFileSync(child, 'utf8'));
+            }
+            catch {
+                unread.push({ path: rel, reason: UnreadFileReason.Unreadable, bytes: size });
+            }
+        }
+    };
+    visit(root);
+    unread.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, unread: Object.freeze(unread) };
+}

package/dist/generated/scan-generated.d.ts

@@ -1,17 +1,71 @@
 import type { IGeneratedArtifactRule } from '@shrkcrft/core';
+import type { IReadScope } from '../util/read-scope.js';
+/** One writer's slice of a mixed generated tree. */
+export interface IGeneratedSourceSlice {
+    /** Label for output — the writer's `id`, or `source[<index>]`. */
+    readonly label: string;
+    /** The regen command that owns this slice. */
+    readonly regen: string;
+    /** Globs selecting the committed files this writer owns. */
+    readonly glob: readonly string[];
+    /** Committed files matching this writer's glob (path → content). */
+    readonly files: ReadonlyMap<string, string>;
+    readonly timeoutMs?: number;
+}
 /** The committed generated files plus the mislabel-candidate set. */
 export interface IGeneratedScan {
     /** Files matching `generatedGlob` (project-relative path → content). */
     readonly generated: ReadonlyMap<string, string>;
+    /**
+     * The subset of {@link generated} that is checkable — i.e. everything except
+     * the hand-maintained blesses. Header and byte checks run over this.
+     */
+    readonly checkable: ReadonlyMap<string, string>;
+    /** Files excluded by `handMaintained` or by the in-file marker, sorted. */
+    readonly handMaintained: readonly string[];
+    /** The subset of {@link handMaintained} that declared itself via the marker. */
+    readonly markedHandMaintained: readonly string[];
+    /**
+     * `handMaintained` patterns that currently match NO file. A bless whose file
+     * was renamed or deleted is a stale exemption: it silently widens nothing
+     * today, but it also documents a file that no longer exists, and the next
+     * file to take that name inherits an exemption nobody reviewed.
+     */
+    readonly staleHandMaintained: readonly string[];
+    /**
+     * Files under `generatedGlob` owned by NO writer and not blessed. Only
+     * populated for multi-writer rules, where the writers partition the tree —
+     * a single-writer rule owns everything its glob matches by definition.
+     */
+    readonly unclassified: readonly string[];
+    /** Per-writer slices for a multi-writer rule; empty for a single-writer one. */
+    readonly slices: readonly IGeneratedSourceSlice[];
     /** Candidates for the `forbidOutside` mislabel check (empty when it is off). */
     readonly outside: ReadonlyMap<string, string>;
     /** Globs actually used for the outside scan (derived or configured). */
     readonly outsideGlobs: readonly string[];
+    /**
+     * The rule's read scope: every file read (committed generated files, plus
+     * the outside candidates when `forbidOutside` is on), and every matched file
+     * the reader did NOT read (over the read cap, or unreadable). An unread
+     * committed file was never header-checked or byte-compared.
+     */
+    readonly readScope: IReadScope;
 }
 /**
- * Read the committed side of a generated-artifact rule. Pure filesystem reads —
- * the regen command (if any) is orchestrated by the caller, which is also where
- * the local-config-only trust decision is enforced.
+ * Read + CLASSIFY the committed side of a generated-artifact rule.
+ *
+ * Classification is the part that makes this usable on a real tree. A blanket
+ * "everything under this glob is generated by that one command" holds only in a
+ * demo; a real `generated/` dir mixes several writers' output with files that
+ * are still hand-maintained. Partitioning the tree first means each writer is
+ * compared against its OWN slice (no cross-writer `only-committed` noise), the
+ * hand-written files are exempted from the header contract instead of failing
+ * it, and anything belonging to neither is surfaced as `unclassified` rather
+ * than silently assumed.
+ *
+ * Pure filesystem reads — the regen commands (if any) are orchestrated by the
+ * caller, which is also where the local-config-only trust decision is enforced.
  */
 export declare function scanGeneratedFiles(projectRoot: string, rule: IGeneratedArtifactRule, excludeDirs?: readonly string[]): IGeneratedScan;
 //# sourceMappingURL=scan-generated.d.ts.map

package/dist/generated/scan-generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-generated.d.ts","sourceRoot":"","sources":["../../src/generated/scan-generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAK7D,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,sBAAsB,EAC5B,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,cAAc,CAmBhB"}
+{"version":3,"file":"scan-generated.d.ts","sourceRoot":"","sources":["../../src/generated/scan-generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAI7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAIxD,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,2EAA2E;IAC3E,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAClD,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;CAChC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,sBAAsB,EAC5B,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,cAAc,CAkHhB"}

package/dist/generated/scan-generated.js

@@ -1,27 +1,127 @@
-import { matchesAny } from "../scan/glob.js";
-import { readMatchingFiles } from "../util/walk-files.js";
+import { globListSelects } from "../scan/glob.js";
+import { safeCompile } from "../util/safe-regex.js";
+import { readSelectedFiles } from "../util/read-selected-files.js";
+import { mergeReadScopes, unreadEntryMatches, unreadEntryWhollyMatches } from "../util/read-scope-coverage.js";
 import { deriveOutsideGlobs } from "./check-provenance.js";
 /**
- * Read the committed side of a generated-artifact rule. Pure filesystem reads —
- * the regen command (if any) is orchestrated by the caller, which is also where
- * the local-config-only trust decision is enforced.
+ * Read + CLASSIFY the committed side of a generated-artifact rule.
+ *
+ * Classification is the part that makes this usable on a real tree. A blanket
+ * "everything under this glob is generated by that one command" holds only in a
+ * demo; a real `generated/` dir mixes several writers' output with files that
+ * are still hand-maintained. Partitioning the tree first means each writer is
+ * compared against its OWN slice (no cross-writer `only-committed` noise), the
+ * hand-written files are exempted from the header contract instead of failing
+ * it, and anything belonging to neither is surfaced as `unclassified` rather
+ * than silently assumed.
+ *
+ * Pure filesystem reads — the regen commands (if any) are orchestrated by the
+ * caller, which is also where the local-config-only trust decision is enforced.
  */
 export function scanGeneratedFiles(projectRoot, rule, excludeDirs = []) {
     const exclude = new Set(excludeDirs);
-    const generated = readMatchingFiles(projectRoot, rule.generatedGlob, exclude);
+    // The files `generatedGlob` SELECTS: a `!` entry (`!gen/**/*.hand.ts`)
+    // excludes, so a hand file carved out of the tree is never header-checked.
+    const generatedRead = readSelectedFiles(projectRoot, rule.generatedGlob, exclude);
+    const generated = generatedRead.files;
+    const blessPatterns = rule.handMaintained ?? [];
+    // The in-file marker is read from the same head window the header contract
+    // uses, so "the top of the file" means one thing for both classifications.
+    const markerWindow = rule.provenanceHeader?.withinLines ?? 10;
+    const marker = rule.handMaintainedMarker
+        ? safeCompile(rule.handMaintainedMarker, rule.handMaintainedMarkerFlags).re
+        : undefined;
+    const carriesMarker = (content) => {
+        if (!marker)
+            return false;
+        marker.lastIndex = 0;
+        return marker.test(content.split('\n').slice(0, Math.max(1, markerWindow)).join('\n'));
+    };
+    const handMaintained = [];
+    const markedHandMaintained = [];
+    const checkable = new Map();
+    for (const [path, content] of generated) {
+        if (blessPatterns.length > 0 && globListSelects(path, blessPatterns)) {
+            handMaintained.push(path);
+            continue;
+        }
+        if (carriesMarker(content)) {
+            handMaintained.push(path);
+            markedHandMaintained.push(path);
+            continue;
+        }
+        checkable.set(path, content);
+    }
+    handMaintained.sort();
+    markedHandMaintained.sort();
+    // A bless is pinned to a NAMED file (the schema forbids a wildcard basename),
+    // so one that matches nothing points at a file that has been renamed away.
+    // A file over the read cap was still MATCHED, so a bless naming it is live.
+    // So is one that could match beneath a directory the walk could not list.
+    const matchedPaths = [...generated.keys()];
+    const staleHandMaintained = blessPatterns
+        .filter((pattern) => !matchedPaths.some((p) => globListSelects(p, [pattern])) &&
+        !generatedRead.unread.some((u) => unreadEntryMatches(u, [pattern])))
+        .sort();
+    const slices = (rule.sources ?? []).map((src, i) => {
+        const files = new Map();
+        for (const [path, content] of checkable) {
+            if (globListSelects(path, src.glob))
+                files.set(path, content);
+        }
+        return {
+            label: src.id ?? `source[${i}]`,
+            regen: src.regen,
+            glob: src.glob,
+            files,
+            ...(src.timeoutMs !== undefined ? { timeoutMs: src.timeoutMs } : {}),
+        };
+    });
+    // Only a multi-writer rule PARTITIONS the tree; a single-writer rule owns
+    // everything its glob matched, so nothing there can be unclassified.
+    const unclassified = slices.length === 0
+        ? []
+        : [...checkable.keys()].filter((p) => !slices.some((s) => globListSelects(p, s.glob))).sort();
     const wantOutside = rule.provenanceHeader?.forbidOutside === true;
     if (!wantOutside) {
-        return { generated, outside: new Map(), outsideGlobs: [] };
+        return {
+            generated,
+            checkable,
+            handMaintained,
+            markedHandMaintained,
+            staleHandMaintained,
+            unclassified,
+            slices,
+            outside: new Map(),
+            outsideGlobs: [],
+            readScope: { read: generated.size, unread: generatedRead.unread },
+        };
     }
     const outsideGlobs = rule.provenanceHeader?.outsideGlob && rule.provenanceHeader.outsideGlob.length > 0
         ? [...rule.provenanceHeader.outsideGlob]
         : deriveOutsideGlobs(rule.generatedGlob);
-    const all = readMatchingFiles(projectRoot, outsideGlobs, exclude);
+    const all = readSelectedFiles(projectRoot, outsideGlobs, exclude);
     const outside = new Map();
-    for (const [path, content] of all) {
-        if (matchesAny(path, rule.generatedGlob))
+    for (const [path, content] of all.files) {
+        // A file `generatedGlob` excludes is OUTSIDE the generated tree: carrying
+        // the "do not edit" header there is exactly a mislabel.
+        if (globListSelects(path, rule.generatedGlob))
             continue;
         outside.set(path, content);
     }
-    return { generated, outside, outsideGlobs };
+    // An unlistable directory is "outside" unless the generated glob covers ALL
+    // of it (it may hold both); `mergeReadScopes` counts a shared path once.
+    const outsideUnread = all.unread.filter((u) => !unreadEntryWhollyMatches(u, rule.generatedGlob));
+    return {
+        generated,
+        checkable,
+        handMaintained,
+        markedHandMaintained,
+        staleHandMaintained,
+        unclassified,
+        slices,
+        outside,
+        outsideGlobs,
+        readScope: mergeReadScopes(generated.size + outside.size, [generatedRead.unread, outsideUnread]),
+    };
 }

package/dist/index.d.ts

@@ -1,24 +1,57 @@
 export * from './model/boundary-rule.js';
+export * from './model/boundary-rule-scope.js';
+export * from './scan/import-pattern.js';
+export * from './scan/node-builtin-package-names.js';
 export * from './registry/boundary-registry.js';
 export * from './registry/load-boundary-rules.js';
 export * from './scan/glob.js';
+export * from './scan/i-glob-unit-measure.js';
 export * from './scan/scan-imports.js';
 export * from './evaluate/evaluate-boundaries.js';
+export * from './model/boundary-markable-list.js';
+export * from './model/boundary-rule-input.js';
+export * from './model/boundary-rule-input-keys.js';
+export * from './model/boundary-rule-key-problems.js';
+export * from './model/boundary-rule-marker-problems.js';
+export * from './model/boundary-unit-problem-issue.js';
+export * from './model/normalize-boundary-rule.js';
+export * from './model/boundary-intended-empty-line.js';
+export * from './evaluate/i-boundary-rule-settle-input.js';
+export * from './evaluate/i-boundary-rule-settlement.js';
+export * from './evaluate/boundary-unit-kind.js';
+export * from './evaluate/i-boundary-unit-finding.js';
+export * from './evaluate/boundary-unit-finding.js';
+export * from './evaluate/settle-boundary-rule.js';
+export * from './evaluate/with-boundary-rule-settlement.js';
 export * from './scan/tsconfig-aliases.js';
 export * from './wiring/evaluate-wiring.js';
 export * from './wiring/scan-wiring-files.js';
 export * from './wiring/explain-wiring.js';
 export * from './wiring/registry-query.js';
 export * from './wiring/registration-graph.js';
+export * from './wiring/i-registration-query-verdict.js';
+export * from './wiring/registration-query-verdict.js';
+export * from './wiring/i-registration-roles.js';
+export * from './wiring/measure-registration-roles.js';
+export * from './wiring/i-idiom-role-coverage.js';
+export * from './wiring/measure-idiom-role-coverage.js';
+export * from './generated/read-regen-tree.js';
 export * from './wiring/trace-literal.js';
 export * from './wiring/plan-wiring-fix.js';
+export * from './wiring/sink-imports.js';
 export * from './policy/extract-templates.js';
 export * from './policy/evaluate-policy.js';
 export * from './policy/run-policy.js';
 export * from './extract/scan-literals.js';
 export * from './extract/extract-tokens.js';
+export * from './extract/parse-imports.js';
+export * from './extract/import-edges.js';
 export * from './extract/code-zones.js';
 export * from './extract/inspect-source.js';
+export * from './extract/i-labeled-source.js';
+export * from './extract/source-liveness-request.js';
+export * from './wiring/wiring-labeled-sources.js';
+export * from './policy/i-policy-rule-liveness.js';
 export * from './baseline/canonicalize.js';
 export * from './baseline/json-path-keys.js';
 export * from './baseline/diff-baseline.js';
@@ -27,5 +60,23 @@ export * from './generated/check-provenance.js';
 export * from './generated/compare-trees.js';
 export * from './generated/scan-generated.js';
 export * from './util/safe-regex.js';
+export * from './util/blank-run-hazard.js';
+export * from './util/blank-run-hazard-finding.js';
 export * from './util/walk-files.js';
+export * from './util/unread-file-reason.js';
+export * from './util/unread-file.js';
+export * from './util/matched-files.js';
+export * from './util/read-scope.js';
+export * from './util/read-scope-coverage.js';
+export * from './util/read-selected-files.js';
+export * from './util/i-dead-glob-unit.js';
+export * from './util/i-glob-negation.js';
+export * from './util/i-glob-list-units.js';
+export * from './util/dead-glob-units.js';
+export * from './util/i-glob-liveness-list.js';
+export * from './util/i-glob-liveness-request.js';
+export * from './util/glob-list-liveness-input.js';
+export * from './util/settle-glob-lists.js';
+export * from './util/read-glob-list-liveness.js';
+export * from './util/plane-scan-exclude-dirs.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sCAAsC,CAAC;AACrD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAElD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,uCAAuC,CAAC;AACtD,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC;AACzD,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAE5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC;AACnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAE1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC"}