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

package/dist/gates/gate-rule-globs.js

@@ -1,7 +1,11 @@
 import { resolveSourceGlobs, } from '@shrkcrft/core';
-import { matchesAny } from '@shrkcrft/boundaries';
+import { globListSelects, wiringLabeledSources } from '@shrkcrft/boundaries';
 /**
- * The FOOTPRINT of a gate rule: every project-relative glob it reads.
+ * The FOOTPRINT of a gate rule, as the glob LISTS it reads — one per source's
+ * `files`, per `import-edges` `to.files`, per watched input, per generated
+ * writer. Kept as separate lists because a `!` entry subtracts from ITS OWN
+ * list only: flattened, one source's `!x` would hide a file another source
+ * reads (and a changeset touching x would skip a rule it does touch).
  *
  * `--changed-only` is only trustworthy if the footprint is complete. A rule
  * scoped by its declared side alone would go unevaluated when the change edits
@@ -9,39 +13,53 @@ import { matchesAny } from '@shrkcrft/boundaries';
  * rule declared over file A is the precise bug this plane exists to catch, so
  * every side, every hop, and every watched input counts.
  */
-export function gateRuleGlobs(view) {
-    if (view.plane === 'policy')
-        return view.raw.files ?? [];
+export function gateRuleGlobLists(view) {
+    if (view.plane === 'policy') {
+        const files = view.raw.files ?? [];
+        return files.length > 0 ? [files] : [];
+    }
     if (view.plane === 'baseline') {
         const rule = view.raw;
         // `watchFiles` is the ONLY footprint a command compute has — without it a
         // command baseline can never be scoped, so it always runs (see below).
         return [
-            ...gateRuleSources(view).flatMap(sourceGlobs),
-            ...(rule.watchFiles ?? []),
-            rule.baseline,
+            ...gateRuleSources(view).flatMap(sourceGlobLists),
+            ...(rule.watchFiles && rule.watchFiles.length > 0 ? [rule.watchFiles] : []),
+            // A ceiling rule has no committed artifact — its pinned value is the
+            // number in the config, so its footprint is its compute alone.
+            ...(rule.baseline ? [[rule.baseline]] : []),
         ];
     }
     if (view.plane === 'generated') {
         const rule = view.raw;
         return [
-            ...rule.generatedGlob,
-            ...(rule.sources ?? []).flatMap((s) => s.glob),
-            ...(rule.handMaintained ?? []),
+            rule.generatedGlob,
+            ...(rule.sources ?? []).map((s) => s.glob),
+            ...(rule.handMaintained && rule.handMaintained.length > 0 ? [rule.handMaintained] : []),
         ];
     }
-    return gateRuleSources(view).flatMap(sourceGlobs);
+    return gateRuleSources(view).flatMap(sourceGlobLists);
 }
 /**
- * Every glob one source reads: the files it scans, plus an `import-edges`
+ * Every glob a gate rule reads, flattened — for DISPLAY only. A scope question
+ * ("does this change touch the rule?") goes through {@link gateRuleGlobLists}
+ * per list ({@link ruleTouchedBy}), never through this union.
+ */
+export function gateRuleGlobs(view) {
+    return gateRuleGlobLists(view).flat();
+}
+/**
+ * The glob lists one source reads: the files it scans, plus an `import-edges`
  * source's TARGET globs.
  *
  * A fence whose footprint covered only the consumer side would go unevaluated
  * when the target subtree moved — and "cannot be proven out of scope" must
  * always resolve to staying IN scope, never to a quiet skip.
  */
-function sourceGlobs(src) {
-    return [...resolveSourceGlobs(src), ...(src.to?.files ?? [])];
+function sourceGlobLists(src) {
+    const files = resolveSourceGlobs(src);
+    const to = src.to?.files ?? [];
+    return [...(files.length > 0 ? [files] : []), ...(to.length > 0 ? [to] : [])];
 }
 /**
  * EVERY extraction source a rule reads — both wiring sides, every union sink,
@@ -54,30 +72,44 @@ function sourceGlobs(src) {
  * the guarantee the shared extractor exists to provide.
  */
 export function gateRuleSources(view) {
+    return gateRuleLabeledSources(view).map((s) => s.source);
+}
+/** A registry's sources, named `source` / `consumer` — THE labels its markers and dead units are qualified by. */
+export function registryLabeledSources(decl) {
+    return decl.consumer
+        ? [
+            { label: 'source', source: decl.source },
+            { label: 'consumer', source: decl.consumer },
+        ]
+        : [{ label: 'source', source: decl.source }];
+}
+/** A registration idiom's roles, named `declared` / `provided` / `consumed` — the labels `measureRegistrationRoles` settles them under. */
+export function registrationLabeledSources(idiom) {
+    return [
+        { label: 'declared', source: idiom.declared },
+        { label: 'provided', source: idiom.provided },
+        { label: 'consumed', source: idiom.consumed },
+    ];
+}
+/**
+ * {@link gateRuleSources}, each named by the side it plays (`declared`,
+ * `registered[1]`, `chain[0]`, `consumer`, …) — the ONE enumeration of a
+ * rule's sources, so a report naming a dead glob by its side cannot list a
+ * different set of sides than the extractor-consumer report does.
+ */
+export function gateRuleLabeledSources(view) {
     switch (view.plane) {
-        case 'wiring': {
-            const rule = view.raw;
-            return [
-                rule.declared,
-                ...(Array.isArray(rule.registered)
-                    ? rule.registered
-                    : rule.registered
-                        ? [rule.registered]
-                        : []),
-                ...(rule.chain ?? []),
-            ].filter((s) => s !== undefined);
-        }
-        case 'registry': {
-            const decl = view.raw;
-            return decl.consumer ? [decl.source, decl.consumer] : [decl.source];
-        }
-        case 'registration': {
-            const idiom = view.raw;
-            return [idiom.declared, idiom.provided, idiom.consumed];
-        }
+        case 'wiring':
+            // THE wiring side labels (round 13) — the engine's own enumeration, so a
+            // unit is named by one side label here and in `check wiring`.
+            return wiringLabeledSources(view.raw);
+        case 'registry':
+            return registryLabeledSources(view.raw);
+        case 'registration':
+            return registrationLabeledSources(view.raw);
         case 'baseline': {
             const source = view.raw.compute.source;
-            return source ? [source] : [];
+            return source ? [{ label: 'compute.source', source }] : [];
         }
         default:
             // `policy` and `generated` select files by glob, not by an extraction
@@ -86,7 +118,11 @@ export function gateRuleSources(view) {
     }
 }
 /**
- * Whether a rule's footprint intersects the changed set.
+ * Whether a rule's footprint intersects the changed set: some changed file is
+ * SELECTED by one of the rule's glob lists (`globListSelects` — an inclusion
+ * glob matches, none of that list's negations does). Exact per list, so a
+ * changeset touching only files the rule excludes does not select it, and one
+ * source's `!` can never hide another source's file.
  *
  * A rule with NO resolvable footprint (a command baseline with no
  * `watchFiles`) cannot be proven out of scope, so it stays IN scope. Guessing
@@ -94,8 +130,10 @@ export function gateRuleSources(view) {
  * the one thing that broke.
  */
 export function ruleTouchedBy(view, changed) {
-    const globs = gateRuleGlobs(view).filter((g) => g.length > 0);
-    if (globs.length === 0)
+    const lists = gateRuleGlobLists(view)
+        .map((l) => l.filter((g) => g.length > 0))
+        .filter((l) => l.length > 0);
+    if (lists.length === 0)
         return true;
-    return changed.some((file) => matchesAny(file, globs));
+    return lists.some((l) => changed.some((file) => globListSelects(file, l)));
 }

package/dist/gates/gate-rule-view.d.ts

@@ -1,7 +1,11 @@
 import { type IBaselineRule, type IDocReferenceRule, type IGeneratedArtifactRule, type IPolicyRule, type IRegistrationIdiom, type IRegistryDeclaration, type IRuleSelfTest, type IWiringRule } from '@shrkcrft/core';
-/** Which data-defined plane a rule belongs to. */
-export type GatePlane = 'wiring' | 'policy' | 'registry' | 'registration' | 'baseline' | 'generated' | 'doc-reference';
-/** Every plane, in the order `shrk gates list` prints them. */
+import { type GatePlane } from '@shrkcrft/config';
+/** Which data-defined plane a rule belongs to — THE config-schema type (`@shrkcrft/config`). */
+export type { GatePlane } from '@shrkcrft/config';
+/**
+ * Every plane, in the order `shrk gates list` prints them — THE list beside
+ * the config schema (`GATE_PLANE_ORDER`), never a CLI copy of it.
+ */
 export declare const GATE_PLANES: readonly GatePlane[];
 /**
  * One data-defined rule, normalized across planes.
@@ -36,6 +40,15 @@ export interface IGatePlanes {
     readonly generatedArtifacts?: readonly IGeneratedArtifactRule[];
     readonly docReferences?: readonly IDocReferenceRule[];
 }
-/** Flatten every declared rule across every plane into one iterable list. */
+/** Flatten every declared rule across every plane into one iterable list, in {@link GATE_PLANES} order. */
 export declare function collectGateRules(planes: IGatePlanes): IGateRuleView[];
+/**
+ * The "` · scan: code (N chars blanked)`" suffix for an explain line.
+ *
+ * A zone is the one setting that legitimately makes a rule match LESS while
+ * still reading green, so every surface that reports what a rule extracted also
+ * reports what the zone removed to get there. Empty string when the rule scans
+ * raw text, so an unzoned rule's output is byte-identical to before.
+ */
+export declare function scanNote(zone?: string, blankedChars?: number): string;
 //# sourceMappingURL=gate-rule-view.d.ts.map

package/dist/gates/gate-rule-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-rule-view.d.ts","sourceRoot":"","sources":["../../src/gates/gate-rule-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AAExB,kDAAkD;AAClD,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,cAAc,GACd,UAAU,GACV,WAAW,GACX,eAAe,CAAC;AAEpB,+DAA+D;AAC/D,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAQ3C,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,EACR,WAAW,GACX,WAAW,GACX,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,GACb,sBAAsB,GACtB,iBAAiB,CAAC;CACvB;AAED,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC3D,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvD;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,EAAE,CAiFrE"}
+{"version":3,"file":"gate-rule-view.d.ts","sourceRoot":"","sources":["../../src/gates/gate-rule-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA2C,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE3F,gGAAgG;AAChG,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAAqB,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,EACR,WAAW,GACX,WAAW,GACX,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,GACb,sBAAsB,GACtB,iBAAiB,CAAC;CACvB;AAED,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC3D,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvD;AA4GD,2GAA2G;AAC3G,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,EAAE,CAErE;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAIrE"}

package/dist/gates/gate-rule-view.js

@@ -1,94 +1,109 @@
 import { failsWhenEmpty, } from '@shrkcrft/core';
-/** Every plane, in the order `shrk gates list` prints them. */
-export const GATE_PLANES = [
-    'wiring',
-    'policy',
-    'registry',
-    'registration',
-    'baseline',
-    'generated',
-    'doc-reference',
-];
-/** Flatten every declared rule across every plane into one iterable list. */
-export function collectGateRules(planes) {
-    const out = [];
-    for (const r of planes.wiringRules ?? []) {
-        out.push({
-            id: r.id,
-            plane: 'wiring',
-            ...(r.description ? { description: r.description } : {}),
-            severity: r.severity ?? 'error',
-            failOnEmpty: failsWhenEmpty(r),
-            ...(r.selfTest ? { selfTest: r.selfTest } : {}),
-            raw: r,
-        });
-    }
-    for (const r of planes.policyRules ?? []) {
-        out.push({
-            id: r.id,
-            plane: 'policy',
-            ...(r.description ? { description: r.description } : {}),
-            severity: r.severity ?? 'error',
-            failOnEmpty: failsWhenEmpty(r),
-            ...(r.selfTest ? { selfTest: r.selfTest } : {}),
-            raw: r,
-        });
-    }
-    for (const r of planes.registries ?? []) {
-        out.push({
-            id: r.name,
-            plane: 'registry',
-            ...(r.description ? { description: r.description } : {}),
-            // A registry is an inventory, not a gate — it never fails a build on its
-            // own, so it carries no severity of its own.
+import { GATE_PLANE_CONFIG_KEY, GATE_PLANE_ORDER } from '@shrkcrft/config';
+/**
+ * Every plane, in the order `shrk gates list` prints them — THE list beside
+ * the config schema (`GATE_PLANE_ORDER`), never a CLI copy of it.
+ */
+export const GATE_PLANES = GATE_PLANE_ORDER;
+/**
+ * One view builder per plane, keyed by {@link GatePlane} so the record is
+ * exhaustive: a plane added to the config list fails the build here until it
+ * has a builder. Each reads its rules under THE config key
+ * (`GATE_PLANE_CONFIG_KEY`) — no plane → key name is spelled in the CLI.
+ */
+const PLANE_VIEWS = {
+    wiring: (planes) => (planes[GATE_PLANE_CONFIG_KEY.wiring] ?? []).map((r) => ({
+        id: r.id,
+        plane: 'wiring',
+        ...(r.description ? { description: r.description } : {}),
+        severity: r.severity ?? 'error',
+        failOnEmpty: failsWhenEmpty(r),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    policy: (planes) => (planes[GATE_PLANE_CONFIG_KEY.policy] ?? []).map((r) => ({
+        id: r.id,
+        plane: 'policy',
+        ...(r.description ? { description: r.description } : {}),
+        severity: r.severity ?? 'error',
+        failOnEmpty: failsWhenEmpty(r),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    registry: (planes) => (planes[GATE_PLANE_CONFIG_KEY.registry] ?? []).map((r) => ({
+        id: r.name,
+        plane: 'registry',
+        ...(r.description ? { description: r.description } : {}),
+        // A registry is an inventory, not a gate — it never fails a build on its
+        // own, so it carries no severity of its own. A `selfTest` still applies:
+        // an inventory whose selector went stale reports an empty registry as
+        // fact, which is worse than a failing gate because nothing looks wrong.
+        // `failOnEmpty` goes through the one shared helper; with no severity the
+        // default stays `false` (a loud skip), and an explicit `true` promotes it.
+        severity: 'warning',
+        failOnEmpty: failsWhenEmpty({
+            ...(r.failOnEmpty !== undefined ? { failOnEmpty: r.failOnEmpty } : {}),
             severity: 'warning',
-            failOnEmpty: false,
-            raw: r,
-        });
-    }
-    for (const r of planes.registrationGraph ?? []) {
-        out.push({
-            id: r.name,
-            plane: 'registration',
-            ...(r.description ? { description: r.description } : {}),
+        }),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    registration: (planes) => (planes[GATE_PLANE_CONFIG_KEY.registration] ?? []).map((r) => ({
+        id: r.name,
+        plane: 'registration',
+        ...(r.description ? { description: r.description } : {}),
+        severity: 'warning',
+        failOnEmpty: failsWhenEmpty({
+            ...(r.failOnEmpty !== undefined ? { failOnEmpty: r.failOnEmpty } : {}),
             severity: 'warning',
-            failOnEmpty: false,
-            raw: r,
-        });
-    }
-    for (const r of planes.baselines ?? []) {
-        out.push({
-            id: r.id,
-            plane: 'baseline',
-            ...(r.description ? { description: r.description } : {}),
-            severity: r.severity ?? 'error',
-            failOnEmpty: failsWhenEmpty(r),
-            ...(r.expectEmpty === true ? { expectEmpty: true } : {}),
-            ...(r.selfTest ? { selfTest: r.selfTest } : {}),
-            raw: r,
-        });
-    }
-    for (const r of planes.docReferences ?? []) {
-        out.push({
-            id: r.id,
-            plane: 'doc-reference',
-            ...(r.description ? { description: r.description } : {}),
-            severity: r.severity ?? 'error',
-            failOnEmpty: failsWhenEmpty(r),
-            ...(r.selfTest ? { selfTest: r.selfTest } : {}),
-            raw: r,
-        });
-    }
-    for (const r of planes.generatedArtifacts ?? []) {
-        out.push({
-            id: r.id,
-            plane: 'generated',
-            ...(r.description ? { description: r.description } : {}),
-            severity: r.severity ?? 'error',
-            failOnEmpty: failsWhenEmpty(r),
-            ...(r.selfTest ? { selfTest: r.selfTest } : {}),
-            raw: r,
-        });
-    }
-    return out;
+        }),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    baseline: (planes) => (planes[GATE_PLANE_CONFIG_KEY.baseline] ?? []).map((r) => ({
+        id: r.id,
+        plane: 'baseline',
+        ...(r.description ? { description: r.description } : {}),
+        severity: r.severity ?? 'error',
+        failOnEmpty: failsWhenEmpty(r),
+        ...(r.expectEmpty === true ? { expectEmpty: true } : {}),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    generated: (planes) => (planes[GATE_PLANE_CONFIG_KEY.generated] ?? []).map((r) => ({
+        id: r.id,
+        plane: 'generated',
+        ...(r.description ? { description: r.description } : {}),
+        severity: r.severity ?? 'error',
+        failOnEmpty: failsWhenEmpty(r),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+    'doc-reference': (planes) => (planes[GATE_PLANE_CONFIG_KEY['doc-reference']] ?? []).map((r) => ({
+        id: r.id,
+        plane: 'doc-reference',
+        ...(r.description ? { description: r.description } : {}),
+        severity: r.severity ?? 'error',
+        failOnEmpty: failsWhenEmpty(r),
+        ...(r.selfTest ? { selfTest: r.selfTest } : {}),
+        raw: r,
+    })),
+};
+/** Flatten every declared rule across every plane into one iterable list, in {@link GATE_PLANES} order. */
+export function collectGateRules(planes) {
+    return GATE_PLANES.flatMap((plane) => PLANE_VIEWS[plane](planes));
+}
+/**
+ * The "` · scan: code (N chars blanked)`" suffix for an explain line.
+ *
+ * A zone is the one setting that legitimately makes a rule match LESS while
+ * still reading green, so every surface that reports what a rule extracted also
+ * reports what the zone removed to get there. Empty string when the rule scans
+ * raw text, so an unzoned rule's output is byte-identical to before.
+ */
+export function scanNote(zone, blankedChars) {
+    if (!zone || zone === 'all')
+        return '';
+    const n = blankedChars ?? 0;
+    return `  · scan: ${zone} (${n} char${n === 1 ? '' : 's'} blanked)`;
 }

package/dist/gates/i-coverage-dead-glob.d.ts

@@ -0,0 +1,19 @@
+/**
+ * One dead glob inside a gate rule, as `gates coverage` reports it (the
+ * `deadGlobUnits` of `sharkcraft.gate-coverage/v1`): an inclusion glob that
+ * selects nothing, or a negation that excludes nothing.
+ */
+export interface ICoverageDeadGlob {
+    /** The side-qualified label — identical to the rule's `deadGlobs` entry (`declared: src/moved/*.ts`). */
+    readonly selector: string;
+    /** The glob as written (a negation keeps its `!`). */
+    readonly glob: string;
+    readonly negation: boolean;
+    /**
+     * Why it is dead: `matched 0 files`, `matches only files the list's
+     * negations exclude (N)`, or `excludes nothing — none of the N file(s) the
+     * other globs select match it`.
+     */
+    readonly reason: string;
+}
+//# sourceMappingURL=i-coverage-dead-glob.d.ts.map

package/dist/gates/i-coverage-dead-glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-coverage-dead-glob.d.ts","sourceRoot":"","sources":["../../src/gates/i-coverage-dead-glob.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,yGAAyG;IACzG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB"}

package/dist/gates/i-coverage-dead-glob.js

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

package/dist/gates/i-coverage-negation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A LIVE negation inside a gate rule and what it excludes, as `gates coverage`
+ * reports it (the `negations` of `sharkcraft.gate-coverage/v1`). The narrowing
+ * a `!` performs is printed (`excludes: !src/**\/*.spec.ts (512 files)`), so a
+ * reader sees what the rule does NOT measure.
+ */
+export interface ICoverageNegation {
+    /** The side-qualified negation (`declared: !src/**\/*.spec.ts`). */
+    readonly selector: string;
+    /** Files it excludes from its own list's positive set (at least 1). */
+    readonly excludes: number;
+}
+//# sourceMappingURL=i-coverage-negation.d.ts.map

package/dist/gates/i-coverage-negation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-coverage-negation.d.ts","sourceRoot":"","sources":["../../src/gates/i-coverage-negation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B"}

package/dist/gates/i-coverage-negation.js

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

package/dist/gates/i-registration-query-settle-input.d.ts

@@ -0,0 +1,18 @@
+import type { IRegistrationQueryVerdict } from '@shrkcrft/boundaries';
+/** What `settleRegistrationGraph` needs to settle one registration-graph absence query. */
+export interface IRegistrationQuerySettleInput<T extends {
+    readonly token: string;
+}> {
+    /** The verdict verb (`wiring unprovided` / `wiring orphans`). */
+    readonly verb: string;
+    readonly verdict: IRegistrationQueryVerdict<T>;
+    /** The exit the findings propose (1 over an unprovided token; orphans never fail). */
+    readonly proposed: number;
+    /** The clean sentence — printed only when the settled exit is 0. */
+    readonly clean: string;
+    /** The query's own coverage subject (`unprovided` / `orphans`) — its row carries the findings. */
+    readonly subject: string;
+    /** How many idioms the graph was built from — the run's coverage. */
+    readonly idioms: number;
+}
+//# sourceMappingURL=i-registration-query-settle-input.d.ts.map

package/dist/gates/i-registration-query-settle-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-registration-query-settle-input.d.ts","sourceRoot":"","sources":["../../src/gates/i-registration-query-settle-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEtE,2FAA2F;AAC3F,MAAM,WAAW,6BAA6B,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;IACjF,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,yBAAyB,CAAC,CAAC,CAAC,CAAC;IAC/C,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB"}

package/dist/gates/i-registration-query-settle-input.js

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

package/dist/gates/i-unit-state-note-row.d.ts

@@ -0,0 +1,16 @@
+import type { IUnitLiveness } from '@shrkcrft/core';
+/**
+ * One rule's settled selector units, as a plane verb hands them to THE shared
+ * unit-state renderer (`unitStateNotes`): the rule id it prints them under and
+ * the rule's non-live units (`unitLiveness` on every plane engine's result).
+ */
+export interface IUnitStateNoteRow {
+    readonly id: string;
+    readonly unitLiveness?: readonly IUnitLiveness[];
+    /**
+     * The rule is already reported as matching nothing (skipped / failed empty):
+     * its dead units are that verdict, never a second advisory line.
+     */
+    readonly reportedEmpty?: boolean;
+}
+//# sourceMappingURL=i-unit-state-note-row.d.ts.map

package/dist/gates/i-unit-state-note-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-unit-state-note-row.d.ts","sourceRoot":"","sources":["../../src/gates/i-unit-state-note-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACjD;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC"}

package/dist/gates/i-unit-state-note-row.js

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

package/dist/gates/i-unit-state-notes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What THE shared unit-state renderer (`unitStateNotes`) found across a plane
+ * verb's rules — the printed block, the per-unit lines and the counts the
+ * verb's clean line reads.
+ */
+export interface IUnitStateNotes {
+    /** Unmarked dead units of rules NOT already reported as matching nothing (advisory). */
+    readonly dead: number;
+    /** LOCAL `expectEmpty` markers whose target appeared — ✓ withheld, fails under `--fail-on-dead-units`. */
+    readonly localWentLive: number;
+    /** PACK markers whose target appeared — INFO, never a failure, never the consumer's to remove. */
+    readonly packWentLive: number;
+    /** The block to print (empty when there is nothing to say), each line `\n`-terminated. */
+    readonly text: string;
+    /**
+     * The same units as bare lines (`<rule id>: <formatUnitLiveness(u)>`, causes
+     * left to the caller's footer) — what a surface that prints NOTES instead of
+     * a block (finish, quality) decorates with its own `[advisory]` / `[info]`.
+     */
+    readonly deadLines: readonly string[];
+    readonly localWentLiveLines: readonly string[];
+    readonly packWentLiveLines: readonly string[];
+    /**
+     * The clauses a clean line must carry instead of its ✓ (`2 dead selector
+     * unit(s)`, `1 expectEmpty unit(s) went live — remove the markers`). Pack
+     * went-live units never withhold the ✓ (INFO).
+     */
+    readonly stale: readonly string[];
+    /** Rule ids with a dead or LOCAL went-live unit — their per-rule row reads `⚠`, never `✓`. */
+    readonly staleIds: ReadonlySet<string>;
+}
+//# sourceMappingURL=i-unit-state-notes.d.ts.map

package/dist/gates/i-unit-state-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-unit-state-notes.d.ts","sourceRoot":"","sources":["../../src/gates/i-unit-state-notes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0GAA0G;IAC1G,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,kGAAkG;IAClG,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0FAA0F;IAC1F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC"}

package/dist/gates/i-unit-state-notes.js

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

package/dist/gates/incomplete-registry-inventory.d.ts

@@ -0,0 +1,19 @@
+import type { IRegistryDeclaration } from '@shrkcrft/core';
+import { type IRegistryInventory } from '@shrkcrft/boundaries';
+/**
+ * Answer a `registry <name> list | exists | where | duplicates` query over an
+ * INCOMPLETE inventory: one whose source globs matched a file the reader did
+ * not read (over the read cap). Returns `undefined` when the answer is
+ * verified anyway, so the caller answers normally.
+ *
+ * Only a POSITIVE finding survives an incomplete read. An id found among the
+ * files read is declared, and a duplicate found there is a duplicate. Absence
+ * ("no", "not declared", "no duplicates") and the listing itself may be wrong,
+ * because the unread file can hold the id. So those are NOT VERIFIED (2),
+ * whatever guard flag was passed, and are settled through the one coverage
+ * guard (`readScopeCoverage` → `settleVerdict`) so the exit and the printed
+ * verdict agree. `exists X --fail-if-taken` over an unread file is never the
+ * "free" 0 a duplicate guard would march on.
+ */
+export declare function answerIncompleteInventory(inventory: IRegistryInventory, decl: IRegistryDeclaration, action: string | undefined, id: string | undefined, json: boolean): number | undefined;
+//# sourceMappingURL=incomplete-registry-inventory.d.ts.map

package/dist/gates/incomplete-registry-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incomplete-registry-inventory.d.ts","sourceRoot":"","sources":["../../src/gates/incomplete-registry-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAML,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAM9B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,kBAAkB,EAC7B,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,IAAI,EAAE,OAAO,GACZ,MAAM,GAAG,SAAS,CA6CpB"}