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

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

@@ -1,7 +1,11 @@
-import { type IBaselineRule, 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';
-/** Every plane, in the order `shrk gates list` prints them. */
+import { type IBaselineRule, type IDocReferenceRule, type IGeneratedArtifactRule, type IPolicyRule, type IRegistrationIdiom, type IRegistryDeclaration, type IRuleSelfTest, type IWiringRule } from '@shrkcrft/core';
+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.
@@ -17,9 +21,14 @@ export interface IGateRuleView {
     readonly severity: 'error' | 'warning';
     /** True when a zero-match is a hard failure rather than a loud skip. */
     readonly failOnEmpty: boolean;
+    /**
+     * True when an EMPTY result is the rule's passing state (a fence). The
+     * loud-skip contract is inverted for these, and only for these.
+     */
+    readonly expectEmpty?: boolean;
     readonly selfTest?: IRuleSelfTest;
     /** The underlying rule, for the plane-specific explainer. */
-    readonly raw: IWiringRule | IPolicyRule | IRegistryDeclaration | IRegistrationIdiom | IBaselineRule | IGeneratedArtifactRule;
+    readonly raw: IWiringRule | IPolicyRule | IRegistryDeclaration | IRegistrationIdiom | IBaselineRule | IGeneratedArtifactRule | IDocReferenceRule;
 }
 /** The config planes this view is built from. */
 export interface IGatePlanes {
@@ -29,7 +38,17 @@ export interface IGatePlanes {
     readonly registrationGraph?: readonly IRegistrationIdiom[];
     readonly baselines?: readonly IBaselineRule[];
     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,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,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,CAAC;AAErG,+DAA+D;AAC/D,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAO3C,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,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,CAAC;CAC5B;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;CACjE;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,EAAE,CAqErE"}
+{"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,81 +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',
-];
-/** 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.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"}

package/dist/gates/incomplete-registry-inventory.js

@@ -0,0 +1,63 @@
+import { describeUnread, readScopeCoverage, readScopeHasUnread, registryDuplicates, registryExists, } from '@shrkcrft/boundaries';
+import { ExitCode } from "../exit-codes.js";
+import { asJson } from "../output/format-output.js";
+import { settleVerdict } from "./settle-verdict.js";
+import { verdictLine } from "./verdict-line.js";
+/**
+ * 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 function answerIncompleteInventory(inventory, decl, action, id, json) {
+    if (!readScopeHasUnread(inventory.readScope))
+        return undefined;
+    if ((action === 'exists' || action === 'where') && id !== undefined && registryExists(inventory, id)) {
+        return undefined;
+    }
+    if (action === 'duplicates' && registryDuplicates(inventory).length > 0)
+        return undefined;
+    const coverage = {
+        ...readScopeCoverage({ unit: 'ids', expected: inventory.entries.length, examined: inventory.entries.length }, inventory.readScope),
+        subject: `registry "${inventory.name}"`,
+    };
+    const settled = settleVerdict(ExitCode.VerifiedPass, [coverage]);
+    const what = describeUnread(inventory.readScope.unread);
+    if (json) {
+        process.stdout.write(asJson({
+            name: inventory.name,
+            ...(action ? { action } : {}),
+            ...(id !== undefined ? { id } : {}),
+            ids: inventory.entries.map((e) => e.id),
+            verified: false,
+            unread: inventory.readScope.unread,
+            exitCode: settled.exit,
+            verdict: settled.verdict,
+            shortfalls: settled.shortfalls,
+        }) + '\n');
+        return settled.exit;
+    }
+    process.stdout.write(`Registry "${inventory.name}"${decl.description ? ` — ${decl.description}` : ''}: its source globs matched ${what},\n` +
+        '  so the inventory is incomplete and this answer is NOT verified.\n');
+    if (action === 'list' || action === undefined) {
+        process.stdout.write(`  ${inventory.entries.length} id(s) among the files read:\n`);
+        for (const e of inventory.entries)
+            process.stdout.write(`  • ${e.id}\n`);
+    }
+    else if (id !== undefined) {
+        process.stdout.write(`  "${id}" is not among the ids read; the unread file may declare it.\n`);
+    }
+    const line = verdictLine(settled, '');
+    if (line)
+        process.stdout.write(`${line}\n`);
+    return settled.exit;
+}

package/dist/gates/measure-registration-roles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * THE role measurement of a registration idiom — re-exported. Round 13 (P4):
+ * the implementation moved to `@shrkcrft/boundaries`
+ * (`packages/boundaries/src/wiring/measure-registration-roles.ts`) so the
+ * registration-graph queries read the SAME authority `gates check` / `gates
+ * coverage` read — MCP `get_wiring_graph` cannot import the CLI. Edit it
+ * there; this path stays so every gates import is unchanged.
+ */
+export { measureRegistrationRoles } from '@shrkcrft/boundaries';
+//# sourceMappingURL=measure-registration-roles.d.ts.map

package/dist/gates/measure-registration-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-registration-roles.d.ts","sourceRoot":"","sources":["../../src/gates/measure-registration-roles.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/gates/measure-registration-roles.js

@@ -0,0 +1,9 @@
+/**
+ * THE role measurement of a registration idiom — re-exported. Round 13 (P4):
+ * the implementation moved to `@shrkcrft/boundaries`
+ * (`packages/boundaries/src/wiring/measure-registration-roles.ts`) so the
+ * registration-graph queries read the SAME authority `gates check` / `gates
+ * coverage` read — MCP `get_wiring_graph` cannot import the CLI. Edit it
+ * there; this path stays so every gates import is unchanged.
+ */
+export { measureRegistrationRoles } from '@shrkcrft/boundaries';

package/dist/gates/plane-verdict.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A plane payload's top-level `verdict`, derived from the SETTLED exit — so a
+ * `--json` payload can never say `pass` (or `warnings`) next to `exitCode: 2`.
+ *
+ *   0 → `warnings` when the engine reported non-blocking findings, else `pass`
+ *   1 → `errors`
+ *   2 → `not-verified`
+ *   3 → `usage-error`
+ *
+ * Spread the engine's report first and set `verdict: planeVerdictForExit(exit,
+ * report.verdict)` after it, so the settled word overrides the engine's.
+ */
+export declare function planeVerdictForExit(exit: number, engineVerdict?: string): 'pass' | 'warnings' | 'errors' | 'not-verified' | 'usage-error';
+//# sourceMappingURL=plane-verdict.d.ts.map

package/dist/gates/plane-verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane-verdict.d.ts","sourceRoot":"","sources":["../../src/gates/plane-verdict.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,cAAc,GAAG,aAAa,CAKjE"}

package/dist/gates/plane-verdict.js

@@ -0,0 +1,22 @@
+import { ExitCode } from "../exit-codes.js";
+/**
+ * A plane payload's top-level `verdict`, derived from the SETTLED exit — so a
+ * `--json` payload can never say `pass` (or `warnings`) next to `exitCode: 2`.
+ *
+ *   0 → `warnings` when the engine reported non-blocking findings, else `pass`
+ *   1 → `errors`
+ *   2 → `not-verified`
+ *   3 → `usage-error`
+ *
+ * Spread the engine's report first and set `verdict: planeVerdictForExit(exit,
+ * report.verdict)` after it, so the settled word overrides the engine's.
+ */
+export function planeVerdictForExit(exit, engineVerdict) {
+    if (exit === ExitCode.VerifiedPass)
+        return engineVerdict === 'warnings' ? 'warnings' : 'pass';
+    if (exit === ExitCode.Failure)
+        return 'errors';
+    if (exit === ExitCode.NotVerified)
+        return 'not-verified';
+    return 'usage-error';
+}

package/dist/gates/qualify-clean-for-units.d.ts

@@ -0,0 +1,12 @@
+import type { IUnitStateNotes } from './i-unit-state-notes.js';
+/**
+ * A verb's clean sentence, qualified by THE shared unit-state renderer's
+ * findings (round 13, K2): with a dead unit or a LOCAL went-live marker listed
+ * above, EVERY ✓ is withheld and the sentence says why — `No policy
+ * violations on the scanned surfaces, but 1 expectEmpty unit(s) went live —
+ * remove the markers (listed above).` The exit is unchanged (advisory);
+ * `verdictLine` still prints the sentence only at exit 0, followed by any
+ * acceptance. An empty `clean` stays empty.
+ */
+export declare function qualifyCleanForUnits(clean: string, notes: IUnitStateNotes): string;
+//# sourceMappingURL=qualify-clean-for-units.d.ts.map

package/dist/gates/qualify-clean-for-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualify-clean-for-units.d.ts","sourceRoot":"","sources":["../../src/gates/qualify-clean-for-units.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM,CAOlF"}

package/dist/gates/qualify-clean-for-units.js

@@ -0,0 +1,18 @@
+/**
+ * A verb's clean sentence, qualified by THE shared unit-state renderer's
+ * findings (round 13, K2): with a dead unit or a LOCAL went-live marker listed
+ * above, EVERY ✓ is withheld and the sentence says why — `No policy
+ * violations on the scanned surfaces, but 1 expectEmpty unit(s) went live —
+ * remove the markers (listed above).` The exit is unchanged (advisory);
+ * `verdictLine` still prints the sentence only at exit 0, followed by any
+ * acceptance. An empty `clean` stays empty.
+ */
+export function qualifyCleanForUnits(clean, notes) {
+    if (clean.length === 0 || notes.stale.length === 0)
+        return clean;
+    const lead = clean
+        .replace(/\s*✓/gu, '')
+        .replace(/ {2,}/gu, ' ')
+        .replace(/[.\s]+$/u, '');
+    return `${lead}, but ${notes.stale.join(', and ')} (listed above).`;
+}

package/dist/gates/registration-graph-verdict.d.ts

@@ -0,0 +1,34 @@
+import { type IGateEnvelope } from './gate-envelope.js';
+import type { IRegistrationQuerySettleInput } from './i-registration-query-settle-input.js';
+/**
+ * Settle a registration-graph absence query (`wiring unprovided` / `wiring
+ * orphans`) against what the graph read AND what every idiom's roles examined.
+ *
+ * The coverage comes from ONE place, @shrkcrft/boundaries
+ * `registrationUnprovidedVerdict` / `registrationOrphansVerdict`: the idiom
+ * files the reader could not read (over the read cap), named; every absence
+ * such a file could refute, demoted from a finding to `unproven`; and — round
+ * 13 (P4) — every idiom's ROLE record from THE role authority
+ * (`measureRegistrationRoles`), so a declared role that matched no file is a
+ * shortfall here exactly as on `gates check`. finish's unprovided sub-gate and
+ * MCP `get_wiring_graph` read the same records, so the verb and its siblings
+ * cannot disagree.
+ *
+ * The settle runs through the shared gate envelope (one row per record, the
+ * query's own row carrying its findings): a proposed 0 over a shortfall is NOT
+ * VERIFIED (2), a 1 keeps its exit and gains the `(also not verified: …)`
+ * line, an expectEmpty acceptance is printed at 0, and a fully-examined graph
+ * settles exactly as proposed, with the clean line. `--json` ALWAYS carries
+ * `gate`, `coverage`, `exitCode`, `verdict`, `shortfalls` and `accepted` — it
+ * carried them only when a file was unread, so a dead declared role printed
+ * `{"total":0,"unprovided":[]}` at exit 0 with nothing to say it proved nothing.
+ */
+export declare function settleRegistrationGraph<T extends {
+    readonly token: string;
+}>(input: IRegistrationQuerySettleInput<T>): {
+    readonly exit: number;
+    readonly line: string;
+    readonly json: Readonly<Record<string, unknown>>;
+    readonly gate: IGateEnvelope;
+};
+//# sourceMappingURL=registration-graph-verdict.d.ts.map