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

package/dist/evaluate/i-boundary-unit-finding.d.ts

@@ -0,0 +1,22 @@
+import type { UnitLivenessState } from '@shrkcrft/core';
+import type { IBoundaryDeadUnit } from './evaluate-boundaries.js';
+/**
+ * One settled selector unit of a boundary rule, as every boundary surface
+ * reports it (round 13): `check boundaries` text and `--json` (`intendedEmpty`,
+ * `wentLive`, `failingUnits`), MCP `check_boundaries`, the quality and finish
+ * notes. Built by `boundaryUnitFinding` from the one settle.
+ */
+export interface IBoundaryUnitFinding {
+    readonly ruleId: string;
+    /** The boundary JSON's unit word: `from`, `forbidden`, `allowed` or `exemptFiles`. */
+    readonly unit: IBoundaryDeadUnit['unit'];
+    readonly selector: string;
+    readonly state: UnitLivenessState;
+    /** THE sentence for the unit (`formatUnitLiveness`), without the selector the row already names. */
+    readonly reason: string;
+    /** The marker's own reason, when the unit is marked `expectEmpty`. */
+    readonly markReason?: string;
+    /** The pack that stamped the marker: a pack marker that went live is INFO and never fails the run. */
+    readonly packageName?: string;
+}
+//# sourceMappingURL=i-boundary-unit-finding.d.ts.map

package/dist/evaluate/i-boundary-unit-finding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-boundary-unit-finding.d.ts","sourceRoot":"","sources":["../../src/evaluate/i-boundary-unit-finding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,sGAAsG;IACtG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B"}

package/dist/evaluate/i-boundary-unit-finding.js

@@ -0,0 +1 @@
+export {};

package/dist/evaluate/settle-boundary-rule.d.ts

@@ -0,0 +1,23 @@
+import type { IBoundaryRuleSettleInput } from './i-boundary-rule-settle-input.js';
+import type { IBoundaryRuleSettlement } from './i-boundary-rule-settlement.js';
+/**
+ * THE settle of one boundary rule (round 13). The evaluator calls it with what
+ * it observed; the orchestrator's unread re-settle (`boundaryUnitLiveness` —
+ * `check boundaries` AND `--diff-against`) calls it with the claims an unread
+ * file could refute withdrawn. One function, so the two paths can never settle
+ * one rule differently:
+ *
+ *   - units through core's `settleUnitLiveness`: a `from` inclusion is
+ *     Coverage weight (dead → a shortfall, exit 2), every other list is
+ *     Advisory (listed, ✓ withheld); a marked unit whose target does not
+ *     exist is intended-empty (record B, printed `accepted by expectEmpty`),
+ *     one whose target exists went live;
+ *   - the rule's emptiness through `settleRuleEmptiness`: a rule whose every
+ *     `from` inclusion is intended-empty and that matched no file is
+ *     IntendedEmpty — accepted, never failOnEmpty; an unread governed file
+ *     makes it partial, never "matched nothing";
+ *   - the dead list is the settled `.dead` (unmarked units only), each worded
+ *     by the one per-unit line.
+ */
+export declare function settleBoundaryRule(input: IBoundaryRuleSettleInput): IBoundaryRuleSettlement;
+//# sourceMappingURL=settle-boundary-rule.d.ts.map

package/dist/evaluate/settle-boundary-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-boundary-rule.d.ts","sourceRoot":"","sources":["../../src/evaluate/settle-boundary-rule.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,GAAG,uBAAuB,CAiD3F"}

package/dist/evaluate/settle-boundary-rule.js

@@ -0,0 +1,73 @@
+import { settleRuleEmptiness, settleUnitLiveness, UnitDeadWeight, unitStateLists, } from '@shrkcrft/core';
+import { BoundaryMarkableList } from "../model/boundary-markable-list.js";
+import { boundaryRuleFailsOnEmpty } from "../model/boundary-rule-scope.js";
+import { boundaryUnitFinding } from "./boundary-unit-finding.js";
+/**
+ * THE settle of one boundary rule (round 13). The evaluator calls it with what
+ * it observed; the orchestrator's unread re-settle (`boundaryUnitLiveness` —
+ * `check boundaries` AND `--diff-against`) calls it with the claims an unread
+ * file could refute withdrawn. One function, so the two paths can never settle
+ * one rule differently:
+ *
+ *   - units through core's `settleUnitLiveness`: a `from` inclusion is
+ *     Coverage weight (dead → a shortfall, exit 2), every other list is
+ *     Advisory (listed, ✓ withheld); a marked unit whose target does not
+ *     exist is intended-empty (record B, printed `accepted by expectEmpty`),
+ *     one whose target exists went live;
+ *   - the rule's emptiness through `settleRuleEmptiness`: a rule whose every
+ *     `from` inclusion is intended-empty and that matched no file is
+ *     IntendedEmpty — accepted, never failOnEmpty; an unread governed file
+ *     makes it partial, never "matched nothing";
+ *   - the dead list is the settled `.dead` (unmarked units only), each worded
+ *     by the one per-unit line.
+ */
+export function settleBoundaryRule(input) {
+    const universeNote = input.fileUniverse === 'edges' ? ' (file list derived from import edges)' : '';
+    const settled = settleUnitLiveness({
+        unitLabel: 'scope globs',
+        acceptanceUnitLabel: 'selector units',
+        weight: UnitDeadWeight.Advisory,
+        observations: input.observations,
+        marks: input.rule.expectEmptyUnits ?? [],
+        deadSummary: `reached no governed file among ${input.filesScanned} scanned${universeNote}`,
+    });
+    const noFiles = `from globs matched 0 of ${input.filesScanned} scanned files: ${input.includeGlobs.join(', ')}`;
+    const emptiness = settleRuleEmptiness({
+        unitLabel: 'governed files',
+        filesMatched: input.filesInScope + input.exemptFilesInScope,
+        unitsMatched: input.filesInScope,
+        unread: input.unread,
+        emptiedByNegations: input.filesInScope === 0 && input.exemptFilesInScope > 0,
+        emptiedReason: `every file its from globs match is exempt (${input.exemptFilesInScope} file(s))`,
+        liveness: settled,
+        primaryLists: [BoundaryMarkableList.From],
+        failOnEmpty: boundaryRuleFailsOnEmpty(input.rule),
+        noFilesReason: noFiles,
+        noUnitsReason: noFiles,
+    });
+    const status = emptiness.skipped ? 'skipped' : input.violations > 0 ? 'failed' : 'passed';
+    const coverage = emptiness.coverage ??
+        settled.shortfall ?? { unit: 'scope globs', expected: 0, examined: 0 };
+    const deadUnits = settled.dead.map((u) => {
+        const f = boundaryUnitFinding(input.rule.id, u);
+        return {
+            ruleId: f.ruleId,
+            unit: f.unit,
+            selector: f.selector,
+            reason: f.reason,
+            ...(u.cause !== undefined ? { cause: u.cause } : {}),
+        };
+    });
+    const hasUnits = settled.dead.length + settled.intendedEmpty.length + settled.wentLive.length > 0;
+    return {
+        settled,
+        emptiness,
+        status,
+        ...(emptiness.skipReason !== undefined ? { skipReason: emptiness.skipReason } : {}),
+        failedOnEmpty: emptiness.fails,
+        coverage,
+        ...(settled.acceptance !== undefined ? { unitAcceptance: settled.acceptance } : {}),
+        ...(hasUnits ? { units: unitStateLists(settled) } : {}),
+        deadUnits,
+    };
+}

package/dist/evaluate/with-boundary-rule-settlement.d.ts

@@ -0,0 +1,11 @@
+import type { IBoundaryRuleCoverage } from './evaluate-boundaries.js';
+import type { IBoundaryRuleSettlement } from './i-boundary-rule-settlement.js';
+/**
+ * A rule's coverage record with a settlement applied (round 13): its status,
+ * skip, verdict coverage, acceptance, dead list, settled units and every row's
+ * `state`. The evaluator and the orchestrator's unread re-settle both build the
+ * record here, so neither can carry a field the other drops: a skip reason or
+ * an acceptance the new settlement does not carry is gone, never inherited.
+ */
+export declare function withBoundaryRuleSettlement(counts: Pick<IBoundaryRuleCoverage, 'ruleId' | 'severity' | 'filesInScope' | 'exemptFilesInScope' | 'edgesInScope' | 'violations' | 'suppressed' | 'fromGlobs' | 'forbidden' | 'allowed' | 'exemptions' | 'exceptions'>, s: IBoundaryRuleSettlement): IBoundaryRuleCoverage;
+//# sourceMappingURL=with-boundary-rule-settlement.d.ts.map

package/dist/evaluate/with-boundary-rule-settlement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-boundary-rule-settlement.d.ts","sourceRoot":"","sources":["../../src/evaluate/with-boundary-rule-settlement.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,IAAI,CACV,qBAAqB,EACnB,QAAQ,GACR,UAAU,GACV,cAAc,GACd,oBAAoB,GACpB,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,WAAW,GACX,WAAW,GACX,SAAS,GACT,YAAY,GACZ,YAAY,CACf,EACD,CAAC,EAAE,uBAAuB,GACzB,qBAAqB,CAoCvB"}

package/dist/evaluate/with-boundary-rule-settlement.js

@@ -0,0 +1,44 @@
+import { RuleEmptiness } from '@shrkcrft/core';
+import { BoundaryMarkableList } from "../model/boundary-markable-list.js";
+/**
+ * A rule's coverage record with a settlement applied (round 13): its status,
+ * skip, verdict coverage, acceptance, dead list, settled units and every row's
+ * `state`. The evaluator and the orchestrator's unread re-settle both build the
+ * record here, so neither can carry a field the other drops: a skip reason or
+ * an acceptance the new settlement does not carry is gone, never inherited.
+ */
+export function withBoundaryRuleSettlement(counts, s) {
+    const stateOf = new Map(s.settled.units.map((u) => [`${u.list} ${u.unit}`, u.state]));
+    const withState = (row, list, unit) => {
+        const { state: _previous, ...bare } = row;
+        const state = stateOf.get(`${list} ${unit}`);
+        return (state !== undefined ? { ...bare, state } : bare);
+    };
+    return {
+        ruleId: counts.ruleId,
+        severity: counts.severity,
+        status: s.status,
+        ...(s.skipReason !== undefined ? { skipReason: s.skipReason } : {}),
+        ...(s.failedOnEmpty ? { failedOnEmpty: true } : {}),
+        ...(s.emptiness.state === RuleEmptiness.IntendedEmpty ? { acceptedAsIntendedEmpty: true } : {}),
+        filesInScope: counts.filesInScope,
+        exemptFilesInScope: counts.exemptFilesInScope,
+        edgesInScope: counts.edgesInScope,
+        violations: counts.violations,
+        suppressed: counts.suppressed,
+        fromGlobs: counts.fromGlobs.map((g) => withState(g, BoundaryMarkableList.From, g.glob)),
+        forbidden: counts.forbidden.map((f) => withState(f, BoundaryMarkableList.ForbiddenImports, f.pattern)),
+        allowed: counts.allowed.map((a) => withState(a, BoundaryMarkableList.AllowedImports, a.pattern)),
+        exemptions: counts.exemptions.map((e) => e.origin === 'from-negation'
+            ? withState(e, BoundaryMarkableList.From, `!${e.glob}`)
+            : e.origin === 'exemptFiles'
+                ? withState(e, BoundaryMarkableList.ExemptFiles, e.glob)
+                : e),
+        exceptions: counts.exceptions,
+        deadUnits: s.deadUnits,
+        unitLiveness: s.settled.units,
+        coverage: s.coverage,
+        ...(s.unitAcceptance !== undefined ? { unitAcceptance: s.unitAcceptance } : {}),
+        ...(s.units !== undefined ? { units: s.units } : {}),
+    };
+}

package/dist/extract/code-zones.d.ts

@@ -1,3 +1,4 @@
+import type { ScanZone } from '@shrkcrft/core';
 /**
  * Which lexical zone of a file a character belongs to.
  *
@@ -14,14 +15,49 @@ export interface ICodeZone {
     readonly kind: CodeZoneKind;
     readonly start: number;
     readonly end: number;
+    /**
+     * Set on a `string` zone delimited by BACKTICKS.
+     *
+     * A template literal is the one string form that routinely carries real
+     * content a rule must see — an inline `template:`, a SQL/GraphQL tagged
+     * query. Tagging it lets `code-and-templates` keep those bodies while still
+     * blanking comments and plain quoted strings, without a second lexer.
+     */
+    readonly template?: boolean;
+    /**
+     * Set on a `code` zone that is one REGEX LITERAL (`/…/flags`).
+     *
+     * A regex literal is code, but its body is opaque: the backtick in
+     * `` /`/g `` must not open a template literal and the `/*` in `/\/*$/` must
+     * not open a block comment. Either mis-lex used to swallow every real
+     * construct up to the next backtick / `*\/` in the file — a real `import()`
+     * after it vanished from the code zone, and every boundary surface passed
+     * over a forbidden import (round 11 review).
+     */
+    readonly regex?: boolean;
 }
+/** Run `fn` with the `lexCodeZones` memo enabled (nestable), then clear it. */
+export declare function withLexCache<T>(fn: () => T): T;
+/** How many contents were actually lexed, and how many lexes the memo served (tests / perf locks). */
+export declare function lexCodeZonesStats(): {
+    readonly lexed: number;
+    readonly memoHits: number;
+};
+/** Reset {@link lexCodeZonesStats}. */
+export declare function resetLexCodeZonesStats(): void;
 /**
  * Split `content` into contiguous code / string / comment zones.
  *
  * A lexer, not a parser: it recognises the C/JS-family string quotes
- * (`'`, `"`, `` ` ``) and comment forms (`//`, `/* … *\/`). Documented limits —
- * a regex literal containing `//` reads as a comment, and `#`-comment languages
- * are reported as code.
+ * (`'`, `"`, `` ` ``), comment forms (`//`, `/* … *\/`) and regex literals.
+ * A `/` in expression position opens a regex literal (a `code` zone tagged
+ * `regex`, see {@link ICodeZone.regex}) whose quotes, backticks and `/*` open
+ * nothing. Documented limits — `#`-comment languages are reported as code, and
+ * a regex right after `)` (`if (x) /re/`) is read as a division, i.e. with the
+ * pre-round-11 lexing of its body.
+ *
+ * Inside {@link withLexCache} the result is memoised by content and shared
+ * (frozen) between callers.
  */
 export declare function lexCodeZones(content: string): readonly ICodeZone[];
 /**
@@ -29,4 +65,60 @@ export declare function lexCodeZones(content: string): readonly ICodeZone[];
  * recorded zone (e.g. past end-of-content).
  */
 export declare function zoneAt(zones: readonly ICodeZone[], index: number): CodeZoneKind;
+/**
+ * The lexed zone containing `index` (`undefined` past the end) — for a caller
+ * that needs a zone's BOUNDS, not just its kind: the import parser requires a
+ * specifier's quote to OPEN a string, which "is inside a string" cannot tell
+ * apart from a quote sitting inside a template literal.
+ */
+export declare function zoneContaining(zones: readonly ICodeZone[], index: number): ICodeZone | undefined;
+/**
+ * Does `zone` keep a match starting at `index`?
+ *
+ * The ONE place that maps a {@link ScanZone} onto a lexed offset. Both raw-text
+ * engines call it — the policy plane per finding, the extraction DSL through
+ * {@link blankOutsideZone} — so "what does `code` mean" cannot drift between
+ * the two planes an author moves a rule between.
+ *
+ * Narrower zones require the match to START in the named zone: a pattern
+ * spanning out of a comment is judged by where it began, which is the only
+ * offset a regex engine reports.
+ */
+export declare function zoneKeepsAt(zone: ScanZone, zones: readonly ICodeZone[], index: number): boolean;
+/** A run of characters {@link blankOutsideZone} replaced with whitespace. */
+export interface IBlankedSpan {
+    readonly kind: CodeZoneKind;
+    readonly start: number;
+    readonly end: number;
+}
+/** What {@link blankOutsideZone} produced, plus what it had to remove to get there. */
+export interface IBlankedContent {
+    /** Same LENGTH as the input — every dropped character became a space or newline. */
+    readonly content: string;
+    readonly blankedSpans: readonly IBlankedSpan[];
+    readonly blankedChars: number;
+}
+/**
+ * Return `content` with every span OUTSIDE `zone` replaced by equal-length
+ * whitespace.
+ *
+ * Blanking rather than deleting is the load-bearing detail: the result has the
+ * same length and the same newlines as the input, so every offset and every
+ * line number a downstream extractor reports is still the real one in the real
+ * file. That is what lets a zone apply to EVERY extractor kind — `array-members`,
+ * `call-args`, `object-keys` — instead of only the regex form, for free and with
+ * no per-extractor zone logic to keep in sync.
+ */
+export declare function blankOutsideZone(content: string, zone: ScanZone): IBlankedContent;
+/**
+ * Blank every lexed zone whose KIND is in `kinds`, keeping everything else.
+ *
+ * The import extractor needs the one shape no {@link ScanZone} expresses:
+ * comments gone (so a commented-out import is not an edge, and an apostrophe
+ * in a comment cannot cut a real import clause short) while string literals
+ * stay (the specifier IS a string). `zones` is passed in so a caller that also
+ * judges offsets against the lex does not lex twice. Same blanking loop as
+ * {@link blankOutsideZone} — one implementation of "blank a zone".
+ */
+export declare function blankZoneKinds(content: string, zones: readonly ICodeZone[], kinds: ReadonlySet<CodeZoneKind>): IBlankedContent;
 //# sourceMappingURL=code-zones.d.ts.map

package/dist/extract/code-zones.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-zones.d.ts","sourceRoot":"","sources":["../../src/extract/code-zones.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzD,wDAAwD;AACxD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CA4BlE;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAY/E"}
+{"version":3,"file":"code-zones.d.ts","sourceRoot":"","sources":["../../src/extract/code-zones.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzD,wDAAwD;AACxD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AA6HD,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ9C;AAED,sGAAsG;AACtG,wBAAgB,iBAAiB,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAEzF;AAED,uCAAuC;AACvC,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAiBlE;AAgDD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAY/E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAWhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,KAAK,EAAE,MAAM,GACZ,OAAO,CAsBT;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC9B,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,eAAe,CAIjF;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,KAAK,EAAE,WAAW,CAAC,YAAY,CAAC,GAC/B,eAAe,CAEjB"}

package/dist/extract/code-zones.js

@@ -1,13 +1,187 @@
 import { skipComment, skipString } from "./scan-literals.js";
+/** Characters after which a `/` starts an EXPRESSION (a regex literal), never a division. */
+const REGEX_AFTER_PUNCTUATION = new Set([
+    '(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';',
+    '+', '-', '*', '%', '<', '>', '~', '^', '/',
+]);
+/** Keywords after which a `/` starts a regex literal (`return /x/.test(s)`). */
+const REGEX_AFTER_KEYWORD = new Set([
+    'return', 'typeof', 'case', 'in', 'of', 'new', 'delete', 'void', 'throw',
+    'yield', 'await', 'instanceof', 'else', 'do',
+]);
+const isIdentifierChar = (c) => c !== undefined && /[A-Za-z0-9_$]/.test(c);
+const isBlank = (c) => c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '\f' || c === '\v';
+/**
+ * Is a `/` whose previous significant code character sits at `prev` in
+ * EXPRESSION position — i.e. does it open a regex literal rather than divide?
+ * `prev < 0` is the start of the file. After an operand (an identifier, a
+ * number, `)` or `]`) it is a division; after an operator, an opening bracket
+ * or one of {@link REGEX_AFTER_KEYWORD} it is a regex. `)` is judged a division
+ * on purpose: `(a + b) / 2` is far more common than `if (x) /re/.test(y)`, and
+ * a missed regex only falls back to the pre-round-11 reading.
+ */
+function regexMayStartAfter(content, prev) {
+    if (prev < 0)
+        return true;
+    const ch = content[prev];
+    if (REGEX_AFTER_PUNCTUATION.has(ch))
+        return true;
+    if (!isIdentifierChar(ch))
+        return false;
+    let start = prev;
+    while (start > 0 && isIdentifierChar(content[start - 1]))
+        start -= 1;
+    // `obj.return / 2` — a property named like a keyword is an operand.
+    if (start > 0 && content[start - 1] === '.')
+        return false;
+    return REGEX_AFTER_KEYWORD.has(content.slice(start, prev + 1));
+}
+/**
+ * If a regex literal starts at `start` (a `/` already judged to be in
+ * expression position, not followed by `/` or `*`), the index of its LAST
+ * character (the closing `/`, or its last flag); otherwise `-1`.
+ *
+ * Bounded to the line — a regex literal cannot contain a line terminator — so
+ * a `/` misjudged as a regex start costs at most the rest of one line, and a
+ * lone division with no closing `/` on its line is not a regex at all. A `/`
+ * inside a `[...]` class does not close the literal; `\` escapes one character.
+ */
+function skipRegexLiteral(content, start) {
+    let inClass = false;
+    for (let i = start + 1; i < content.length; i += 1) {
+        const c = content[i];
+        if (c === '\n' || c === '\r')
+            return -1;
+        if (c === '\\') {
+            const next = content[i + 1];
+            if (next === undefined || next === '\n' || next === '\r')
+                return -1;
+            i += 1;
+            continue;
+        }
+        if (inClass) {
+            if (c === ']')
+                inClass = false;
+            continue;
+        }
+        if (c === '[') {
+            inClass = true;
+            continue;
+        }
+        if (c === '/') {
+            let end = i;
+            while (end + 1 < content.length && /[A-Za-z]/.test(content[end + 1]))
+                end += 1;
+            return end;
+        }
+    }
+    return -1;
+}
+/**
+ * Does the `/` at `i` open a regex literal? Judged LAZILY, only for the rare
+ * `/` that is not a comment: scan back over blanks to the previous significant
+ * code character. The pending code region is `[codeStart, i)`; before it, the
+ * recorded zones partition `[0, codeStart)` — a comment is trivia (keep
+ * scanning before it), a string or regex literal is an operand (so the `/`
+ * divides), a code zone is scanned like the pending region, and running out of
+ * zones is the start of the file.
+ *
+ * This is exactly the previous-significant-character judgement the lexer used
+ * to track EAGERLY on every character (round 11 review: that bookkeeping made
+ * `lexCodeZones` ~1.8x slower under every zoned plane and the import parser).
+ */
+function slashOpensRegex(content, zones, codeStart, i) {
+    let lo = codeStart;
+    let j = i - 1;
+    let z = zones.length - 1;
+    for (;;) {
+        while (j >= lo && isBlank(content[j]))
+            j -= 1;
+        if (j >= lo)
+            return regexMayStartAfter(content, j);
+        if (z < 0)
+            return true;
+        const zone = zones[z];
+        z -= 1;
+        if (zone.kind === 'comment') {
+            lo = zone.start;
+            j = zone.start - 1;
+            continue;
+        }
+        if (zone.kind === 'string' || zone.regex === true)
+            return false;
+        lo = zone.start;
+        j = zone.end - 1;
+    }
+}
+/**
+ * Memo of `lexCodeZones`, keyed by the CONTENT itself — so an entry can never
+ * be stale (the key IS the bytes), even across a spawn or a write. Enabled only
+ * inside {@link withLexCache}: one `shrk quality` run lexes the same file under
+ * the plane check, the coverage pass and every zoned rule of both; within a
+ * window each distinct content is lexed once. Bounded, and cleared when the
+ * outermost window closes.
+ */
+const LEX_MEMO = new Map();
+const LEX_MEMO_LIMIT = 50_000;
+let lexWindowDepth = 0;
+let lexCount = 0;
+let lexMemoHits = 0;
+/** Run `fn` with the `lexCodeZones` memo enabled (nestable), then clear it. */
+export function withLexCache(fn) {
+    lexWindowDepth += 1;
+    try {
+        return fn();
+    }
+    finally {
+        lexWindowDepth -= 1;
+        if (lexWindowDepth === 0)
+            LEX_MEMO.clear();
+    }
+}
+/** How many contents were actually lexed, and how many lexes the memo served (tests / perf locks). */
+export function lexCodeZonesStats() {
+    return { lexed: lexCount, memoHits: lexMemoHits };
+}
+/** Reset {@link lexCodeZonesStats}. */
+export function resetLexCodeZonesStats() {
+    lexCount = 0;
+    lexMemoHits = 0;
+}
 /**
  * Split `content` into contiguous code / string / comment zones.
  *
  * A lexer, not a parser: it recognises the C/JS-family string quotes
- * (`'`, `"`, `` ` ``) and comment forms (`//`, `/* … *\/`). Documented limits —
- * a regex literal containing `//` reads as a comment, and `#`-comment languages
- * are reported as code.
+ * (`'`, `"`, `` ` ``), comment forms (`//`, `/* … *\/`) and regex literals.
+ * A `/` in expression position opens a regex literal (a `code` zone tagged
+ * `regex`, see {@link ICodeZone.regex}) whose quotes, backticks and `/*` open
+ * nothing. Documented limits — `#`-comment languages are reported as code, and
+ * a regex right after `)` (`if (x) /re/`) is read as a division, i.e. with the
+ * pre-round-11 lexing of its body.
+ *
+ * Inside {@link withLexCache} the result is memoised by content and shared
+ * (frozen) between callers.
  */
 export function lexCodeZones(content) {
+    if (lexWindowDepth > 0) {
+        const hit = LEX_MEMO.get(content);
+        if (hit !== undefined) {
+            lexMemoHits += 1;
+            return hit;
+        }
+    }
+    const zones = lexUncached(content);
+    lexCount += 1;
+    if (lexWindowDepth > 0) {
+        if (LEX_MEMO.size >= LEX_MEMO_LIMIT)
+            LEX_MEMO.clear();
+        const frozen = Object.freeze(zones);
+        LEX_MEMO.set(content, frozen);
+        return frozen;
+    }
+    return zones;
+}
+function lexUncached(content) {
     const zones = [];
     let codeStart = 0;
     const flushCode = (upTo) => {
@@ -19,7 +193,12 @@ export function lexCodeZones(content) {
         if (c === '"' || c === "'" || c === '`') {
             flushCode(i);
             const end = skipString(content, i);
-            zones.push({ kind: 'string', start: i, end: end + 1 });
+            zones.push({
+                kind: 'string',
+                start: i,
+                end: end + 1,
+                ...(c === '`' ? { template: true } : {}),
+            });
             i = end;
             codeStart = i + 1;
             continue;
@@ -31,6 +210,17 @@ export function lexCodeZones(content) {
                 zones.push({ kind: 'comment', start: i, end: end + 1 });
                 i = end;
                 codeStart = i + 1;
+                continue;
+            }
+            if (slashOpensRegex(content, zones, codeStart, i)) {
+                const reEnd = skipRegexLiteral(content, i);
+                if (reEnd >= 0) {
+                    flushCode(i);
+                    zones.push({ kind: 'code', start: i, end: reEnd + 1, regex: true });
+                    i = reEnd;
+                    codeStart = i + 1;
+                    continue;
+                }
             }
         }
     }
@@ -57,3 +247,122 @@ export function zoneAt(zones, index) {
     }
     return 'code';
 }
+/**
+ * The lexed zone containing `index` (`undefined` past the end) — for a caller
+ * that needs a zone's BOUNDS, not just its kind: the import parser requires a
+ * specifier's quote to OPEN a string, which "is inside a string" cannot tell
+ * apart from a quote sitting inside a template literal.
+ */
+export function zoneContaining(zones, index) {
+    let lo = 0;
+    let hi = zones.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const z = zones[mid];
+        if (index < z.start)
+            hi = mid - 1;
+        else if (index >= z.end)
+            lo = mid + 1;
+        else
+            return z;
+    }
+    return undefined;
+}
+/**
+ * Does `zone` keep a match starting at `index`?
+ *
+ * The ONE place that maps a {@link ScanZone} onto a lexed offset. Both raw-text
+ * engines call it — the policy plane per finding, the extraction DSL through
+ * {@link blankOutsideZone} — so "what does `code` mean" cannot drift between
+ * the two planes an author moves a rule between.
+ *
+ * Narrower zones require the match to START in the named zone: a pattern
+ * spanning out of a comment is judged by where it began, which is the only
+ * offset a regex engine reports.
+ */
+export function zoneKeepsAt(zone, zones, index) {
+    if (zone === 'all')
+        return true;
+    let lo = 0;
+    let hi = zones.length - 1;
+    let hit;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const z = zones[mid];
+        if (index < z.start)
+            hi = mid - 1;
+        else if (index >= z.end)
+            lo = mid + 1;
+        else {
+            hit = z;
+            break;
+        }
+    }
+    // Outside every recorded zone (e.g. past end-of-content) reads as code.
+    const kind = hit?.kind ?? 'code';
+    if (zone === 'code')
+        return kind === 'code';
+    if (zone === 'strings')
+        return kind === 'string';
+    if (zone === 'comments')
+        return kind === 'comment';
+    // code-and-templates
+    return kind === 'code' || (kind === 'string' && hit?.template === true);
+}
+/**
+ * Return `content` with every span OUTSIDE `zone` replaced by equal-length
+ * whitespace.
+ *
+ * Blanking rather than deleting is the load-bearing detail: the result has the
+ * same length and the same newlines as the input, so every offset and every
+ * line number a downstream extractor reports is still the real one in the real
+ * file. That is what lets a zone apply to EVERY extractor kind — `array-members`,
+ * `call-args`, `object-keys` — instead of only the regex form, for free and with
+ * no per-extractor zone logic to keep in sync.
+ */
+export function blankOutsideZone(content, zone) {
+    if (zone === 'all')
+        return { content, blankedSpans: [], blankedChars: 0 };
+    const zones = lexCodeZones(content);
+    return blankZonesWhere(content, zones, (z) => !zoneKeepsAt(zone, zones, z.start));
+}
+/**
+ * Blank every lexed zone whose KIND is in `kinds`, keeping everything else.
+ *
+ * The import extractor needs the one shape no {@link ScanZone} expresses:
+ * comments gone (so a commented-out import is not an edge, and an apostrophe
+ * in a comment cannot cut a real import clause short) while string literals
+ * stay (the specifier IS a string). `zones` is passed in so a caller that also
+ * judges offsets against the lex does not lex twice. Same blanking loop as
+ * {@link blankOutsideZone} — one implementation of "blank a zone".
+ */
+export function blankZoneKinds(content, zones, kinds) {
+    return blankZonesWhere(content, zones, (z) => kinds.has(z.kind));
+}
+/**
+ * The ONE blanking loop: replace each selected zone with equal-length
+ * whitespace. Newlines survive so line numbers — and any `m`-flag anchor —
+ * hold. Built from slices (not a per-character array) so a large file costs
+ * one pass.
+ */
+function blankZonesWhere(content, zones, blank) {
+    const parts = [];
+    const blankedSpans = [];
+    let blankedChars = 0;
+    let cursor = 0;
+    for (const z of zones) {
+        if (!blank(z))
+            continue;
+        const start = Math.min(z.start, content.length);
+        const end = Math.min(z.end, content.length);
+        if (start > cursor)
+            parts.push(content.slice(cursor, start));
+        parts.push(content.slice(start, end).replace(/[^\n]/g, ' '));
+        cursor = end;
+        blankedSpans.push({ kind: z.kind, start: z.start, end: z.end });
+        blankedChars += z.end - z.start;
+    }
+    if (cursor < content.length)
+        parts.push(content.slice(cursor));
+    return { content: parts.join(''), blankedSpans, blankedChars };
+}