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

package/dist/boundary-configuration-status.js

@@ -0,0 +1,118 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+/** The conventional local rule file — loaded ONLY when listed in `boundaryFiles`. */
+export const DEFAULT_LOCAL_BOUNDARY_FILE = 'boundaries.ts';
+/**
+ * Classify the local `boundaryFiles` entries — THE code path both the
+ * inspector's load loop and {@link describeBoundaryConfiguration} use, so the
+ * loader and the diagnostics cannot disagree about which files exist.
+ *
+ * `unlistedDefault` is set when `sharkcraft/boundaries.ts` exists but no entry
+ * points at it: the file an author naturally creates loads nothing until it is
+ * listed. It is reported, never auto-loaded — auto-loading would start
+ * enforcing rules silently (new exit 1s).
+ */
+export function classifyLocalBoundaryFiles(sharkcraftDir, boundaryFiles) {
+    const listed = boundaryFiles.map((rel) => {
+        const abs = nodePath.join(sharkcraftDir, rel);
+        return { rel, abs, exists: existsSync(abs) };
+    });
+    const defaultAbs = nodePath.join(sharkcraftDir, DEFAULT_LOCAL_BOUNDARY_FILE);
+    const isListed = listed.some((l) => nodePath.resolve(l.abs) === nodePath.resolve(defaultAbs));
+    return { listed, ...(existsSync(defaultAbs) && !isListed ? { unlistedDefault: defaultAbs } : {}) };
+}
+/** A path relative to the project root (`/`-separated), or the absolute path when outside it. */
+export function boundaryFileLabel(projectRoot, abs) {
+    const rel = nodePath.relative(projectRoot, abs);
+    if (rel === '' || rel.startsWith('..') || nodePath.isAbsolute(rel))
+        return abs;
+    return rel.split(nodePath.sep).join('/');
+}
+/**
+ * The structured load issues one loaded rule file carries — used by the
+ * inspector (local + pack files) and `check boundaries --rule-file`, so every
+ * origin reports a dropped rule the same way.
+ */
+export function boundaryLoadIssuesFromFile(loaded, projectRoot, origin, packageName) {
+    const file = boundaryFileLabel(projectRoot, loaded.source);
+    const base = { file, origin, ...(packageName ? { packageName } : {}) };
+    const out = [];
+    if (loaded.missing) {
+        out.push({ ...base, kind: 'missing-file', issues: ['the rule file does not exist'] });
+    }
+    if (loaded.loadError !== undefined) {
+        out.push({ ...base, kind: 'load-error', issues: [loaded.loadError] });
+    }
+    for (const inv of loaded.invalid) {
+        out.push({
+            ...base,
+            kind: 'invalid-rule',
+            ...(inv.ruleId !== undefined ? { ruleId: inv.ruleId } : {}),
+            index: inv.index,
+            issues: inv.issues.map((i) => `${i.field}: ${i.message}`),
+        });
+    }
+    return out;
+}
+/**
+ * Are boundary rules configured, and if not, why? The one answer every
+ * boundary surface renders (round 11, L-1).
+ */
+export function describeBoundaryConfiguration(inspection) {
+    const ruleCount = inspection.boundaryRegistry.size();
+    const sharkcraftDir = inspection.sharkcraftDir;
+    const listedLocalFiles = inspection.config?.boundaryFiles ?? [];
+    const classified = sharkcraftDir
+        ? classifyLocalBoundaryFiles(sharkcraftDir, listedLocalFiles)
+        : { listed: [] };
+    const missingListed = classified.listed.filter((l) => !l.exists);
+    const packBoundaryFiles = [];
+    for (const pack of inspection.packs.validPacks) {
+        for (const rel of pack.manifest?.contributions?.boundaryFiles ?? []) {
+            packBoundaryFiles.push({ packageName: pack.packageName, file: nodePath.resolve(pack.packageRoot, rel) });
+        }
+    }
+    const loadIssues = inspection.boundaryLoadIssues ?? [];
+    const configInvalid = inspection.configLoadError !== undefined;
+    const label = (abs) => boundaryFileLabel(inspection.projectRoot, abs);
+    const diagnostics = [];
+    if (configInvalid) {
+        diagnostics.push(`sharkcraft.config.ts failed to load (${inspection.configLoadError?.message ?? 'unknown error'}) — boundaryFiles could not be read; run \`shrk doctor\` (config-invalid).`);
+    }
+    for (const m of missingListed) {
+        diagnostics.push(`boundaryFiles lists "${m.rel}" but ${label(m.abs)} does not exist — no rules load from it.`);
+    }
+    if (classified.unlistedDefault) {
+        diagnostics.push(`${label(classified.unlistedDefault)} exists but is not listed in boundaryFiles — its rules are NOT loaded. Add \`boundaryFiles: ['${DEFAULT_LOCAL_BOUNDARY_FILE}']\` to sharkcraft.config.ts.`);
+    }
+    if (loadIssues.length > 0) {
+        diagnostics.push(`${loadIssues.length} boundary rule(s) / rule file(s) failed to load — each is reported as an errored rule.`);
+    }
+    if (ruleCount === 0 && !configInvalid && missingListed.length === 0 && !classified.unlistedDefault) {
+        if (!sharkcraftDir) {
+            diagnostics.push(`No sharkcraft/ directory found under ${inspection.projectRoot} — no boundary rules can be loaded.`);
+        }
+        else if (listedLocalFiles.length === 0 && packBoundaryFiles.length === 0) {
+            diagnostics.push(`No boundary rules loaded: ${inspection.configFile ? 'sharkcraft.config.ts lists no boundaryFiles' : 'no sharkcraft.config.ts was found'} and no pack contributes any. Create ${label(nodePath.join(sharkcraftDir, DEFAULT_LOCAL_BOUNDARY_FILE))} and list it: \`boundaryFiles: ['${DEFAULT_LOCAL_BOUNDARY_FILE}']\`.`);
+        }
+        else if (loadIssues.length === 0) {
+            // Only when nothing failed: a listed file that THREW, or whose every rule
+            // failed validation, did not "load" — its load issues (above, and one
+            // errored rule each) are the honest account.
+            diagnostics.push('The listed boundary rule files loaded, but define no rules.');
+        }
+    }
+    return {
+        ruleCount,
+        configured: ruleCount > 0,
+        sharkcraftDir,
+        configFile: inspection.configFile,
+        configInvalid,
+        listedLocalFiles,
+        missingListedFiles: missingListed.map((m) => m.abs),
+        ...(classified.unlistedDefault ? { unlistedDefaultFile: classified.unlistedDefault } : {}),
+        packBoundaryFiles,
+        loadIssues: loadIssues.length,
+        diagnostics,
+    };
+}

package/dist/boundary-configuration-status.model.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The ONE answer to "are boundary rules configured, and if not, why?"
+ * (round 11, L-1).
+ *
+ * Five surfaces answered this differently — `check boundaries` said "no rules
+ * configured" and exited 0 while telling the author to create a file that
+ * already existed (it was simply not listed in `boundaryFiles`), quality said
+ * `passed`, finish said `skipped`, MCP returned a count and no verdict. Every
+ * surface now renders these diagnostics.
+ */
+export interface IBoundaryConfigurationStatus {
+    /** Rules in the registry (local + pack). */
+    readonly ruleCount: number;
+    /** `ruleCount > 0`. */
+    readonly configured: boolean;
+    /** Where the sharkcraft directory resolved — printed so a wrong root is visible. */
+    readonly sharkcraftDir: string | null;
+    readonly configFile: string | null;
+    /** The config exists but failed to load — no `boundaryFiles` could be read. */
+    readonly configInvalid: boolean;
+    /** `boundaryFiles` entries as written (relative to the sharkcraft dir). */
+    readonly listedLocalFiles: readonly string[];
+    /** Listed entries whose file does not exist (absolute paths). */
+    readonly missingListedFiles: readonly string[];
+    /** `sharkcraft/boundaries.ts` exists but is NOT listed, so it loads nothing (absolute path). */
+    readonly unlistedDefaultFile?: string;
+    /** Boundary files contributed by packs. */
+    readonly packBoundaryFiles: readonly {
+        readonly packageName: string;
+        readonly file: string;
+    }[];
+    /** Rules / files that failed to load (see `IBoundaryLoadIssue`). */
+    readonly loadIssues: number;
+    /** Human sentences explaining the state, most actionable first. */
+    readonly diagnostics: readonly string[];
+}
+//# sourceMappingURL=boundary-configuration-status.model.d.ts.map

package/dist/boundary-configuration-status.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-configuration-status.model.d.ts","sourceRoot":"","sources":["../src/boundary-configuration-status.model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uBAAuB;IACvB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,oFAAoF;IACpF,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,iEAAiE;IACjE,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,gGAAgG;IAChG,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,2CAA2C;IAC3C,QAAQ,CAAC,iBAAiB,EAAE,SAAS;QAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC/F,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC"}

package/dist/boundary-configuration-status.model.js

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

package/dist/boundary-load-issue.model.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A boundary rule (or a whole rule file) that was configured but could not be
+ * evaluated — round 11, 1.3#boundary-invalid-rule.
+ *
+ * The loader used to turn each of these into a warning string that no boundary
+ * surface rendered, so `check boundaries` reported green over a fence that had
+ * just vanished. As structured records they become ERRORED rules on every
+ * surface (`check boundaries`, finish, both MCP tools): never evaluated, never
+ * silent, exit 1.
+ */
+export interface IBoundaryLoadIssue {
+    /** The rule file — project-relative when inside the project, else absolute. */
+    readonly file: string;
+    /**
+     *   - `invalid-rule` — one rule failed validation and was dropped;
+     *   - `load-error`   — the file threw on import, timed out, or exported no rule array;
+     *   - `missing-file` — `boundaryFiles` lists a file that does not exist.
+     */
+    readonly kind: 'invalid-rule' | 'load-error' | 'missing-file';
+    readonly origin: 'local' | 'pack' | 'rule-file';
+    /** The contributing pack, for `origin: 'pack'`. */
+    readonly packageName?: string;
+    /** The rule's id, when an invalid rule had a string one. */
+    readonly ruleId?: string;
+    /** Position in the file's rule array, for `invalid-rule`. */
+    readonly index?: number;
+    /** One line per problem (`title: title required`, or the loader's message). */
+    readonly issues: readonly string[];
+}
+//# sourceMappingURL=boundary-load-issue.model.d.ts.map

package/dist/boundary-load-issue.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-load-issue.model.d.ts","sourceRoot":"","sources":["../src/boundary-load-issue.model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,GAAG,cAAc,CAAC;IAC9D,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,WAAW,CAAC;IAChD,mDAAmD;IACnD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC"}

package/dist/boundary-load-issue.model.js

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

package/dist/boundary-rule-check.model.d.ts

@@ -0,0 +1,44 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import type { BoundarySeverity, IBoundaryRuleCoverage, IBoundaryViolation, IUnreadFile } from '@shrkcrft/boundaries';
+import type { IBoundaryStaleExceptionFinding } from './boundary-stale-exception-finding.model.js';
+/** One SELECTED rule's result in a boundary check. */
+export interface IBoundaryRuleCheck {
+    readonly ruleId: string;
+    readonly title: string;
+    readonly severity: BoundarySeverity;
+    /**
+     * The verdict word, over the REPORTED scope: `failed` when it has reported
+     * violations or stale exceptions, OR when it governed nothing and fails on
+     * empty (`failedOnEmpty` — the wiring plane's mapping, so the gate envelope
+     * counts it in `failed`); `skipped` when it governed nothing otherwise.
+     * Whether the rule EXAMINED anything is `detail.status` (the engine's word) —
+     * "evaluated" / "checked nothing" counts read that, never this.
+     */
+    readonly status: 'passed' | 'failed' | 'skipped';
+    readonly skipReason?: string;
+    /** A skip that fails the run (`failOnEmpty`). */
+    readonly failedOnEmpty?: boolean;
+    /** The changeset touched this rule's definition: every violation it produces is reported. */
+    readonly escalated?: boolean;
+    /**
+     * The engine's verdict coverage (scope globs) — read, never recomputed —
+     * folded through `readScopeCoverage` when a governed file in the rule's
+     * reported scope could not be read ({@link unread}): then `examined R of
+     * R+U files`, naming each unread path, so the rule settles PARTIAL (2).
+     */
+    readonly coverage: IVerdictCoverage;
+    /**
+     * Governed files in this rule's REPORTED scope the scan could not read. A
+     * rule whose zero governed files is caused by one of these matched a file
+     * it could not examine: it is never `failedOnEmpty`, never "checked
+     * nothing", and never a pass (see `boundaryRuleCheckedNothing`).
+     */
+    readonly unread?: readonly IUnreadFile[];
+    /** What each unit of the rule matched. */
+    readonly detail: IBoundaryRuleCoverage;
+    /** This rule's REPORTED violations. */
+    readonly violations: readonly IBoundaryViolation[];
+    /** This rule's REPORTED stale exceptions — each fails the rule. */
+    readonly staleExceptions: readonly IBoundaryStaleExceptionFinding[];
+}
+//# sourceMappingURL=boundary-rule-check.model.d.ts.map

package/dist/boundary-rule-check.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-rule-check.model.d.ts","sourceRoot":"","sources":["../src/boundary-rule-check.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACrH,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAElG,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,6FAA6F;IAC7F,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,uCAAuC;IACvC,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,mEAAmE;IACnE,QAAQ,CAAC,eAAe,EAAE,SAAS,8BAA8B,EAAE,CAAC;CACrE"}

package/dist/boundary-rule-check.model.js

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

package/dist/boundary-rule-invalidation.model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Which boundary rules a changeset INVALIDATED — round 11, 6.3 / closing#d.
+ *
+ * A `--changed-only` run filters violations to the changed files, which by
+ * construction cannot see a change to the rules themselves: tightening a rule
+ * creates violations only in files nobody touched. When the changeset touches
+ * a rule's definition (or the config, or the alias map every rule is evaluated
+ * under), those rules are ESCALATED — every violation they produce is reported,
+ * whatever its file. Stateless on purpose: the diff itself is the signal, so it
+ * works on a fresh CI checkout where a persisted rule-set hash has no previous
+ * value.
+ */
+export interface IBoundaryRuleInvalidation {
+    /** Rules whose violations are all new to this changeset. */
+    readonly escalatedRuleIds: readonly string[];
+    /** Why, one entry per changed file that triggered escalation. */
+    readonly reasons: readonly {
+        /** Project-relative path of the changed file. */
+        readonly file: string;
+        /**
+         *   - `rule-source` — a file that defines boundary rules (escalates those rules);
+         *   - `config`      — sharkcraft.config.ts (escalates every rule);
+         *   - `tsconfig`    — tsconfig.json / tsconfig.base.json, the alias map (every rule);
+         *   - `manifest`    — a root package.json / lockfile, or a file inside a pack (that pack's rules);
+         *   - `rule-file`   — a `--rule-file` candidate (every candidate rule is new by definition).
+         */
+        readonly kind: 'rule-source' | 'config' | 'tsconfig' | 'manifest' | 'rule-file';
+        readonly ruleIds: readonly string[];
+    }[];
+}
+//# sourceMappingURL=boundary-rule-invalidation.model.d.ts.map

package/dist/boundary-rule-invalidation.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-rule-invalidation.model.d.ts","sourceRoot":"","sources":["../src/boundary-rule-invalidation.model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,yBAAyB;IACxC,4DAA4D;IAC5D,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,SAAS;QACzB,iDAAiD;QACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB;;;;;;WAMG;QACH,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;QAChF,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KACrC,EAAE,CAAC;CACL"}

package/dist/boundary-rule-invalidation.model.js

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

package/dist/boundary-rule-set-diff.model.d.ts

@@ -0,0 +1,75 @@
+import type { IBoundaryRuleCoverage, IBoundaryUnitFinding, IBoundaryViolation } from '@shrkcrft/boundaries';
+import type { IBoundaryLoadIssue } from './boundary-load-issue.model.js';
+/** One import edge, keyed without its rule — so a renamed rule is not churn. */
+interface IBoundaryFlaggedEdge {
+    readonly file: string;
+    readonly line: number;
+    readonly importSpecifier: string;
+}
+/**
+ * What a candidate rule set WOULD flag relative to the active one (round 11,
+ * 3.3#3, `check boundaries --diff-against <file>`). Both sides are evaluated by
+ * the gate's own engine against ONE scan, so the delta is purely a rule delta —
+ * a dry-run that is not the gate's engine would be a second engine.
+ */
+export interface IBoundaryRuleSetDiff {
+    readonly schema: 'sharkcraft.boundary-rule-diff/v1';
+    readonly candidateFile: string;
+    /** Candidate rule ids not in the active set. */
+    readonly rulesAdded: readonly string[];
+    /** Candidate rule ids that replace an active rule of the same id. */
+    readonly rulesReplaced: readonly string[];
+    readonly added: readonly IBoundaryViolation[];
+    readonly removed: readonly IBoundaryViolation[];
+    readonly unchanged: number;
+    readonly perRule: readonly {
+        readonly ruleId: string;
+        readonly added: number;
+        readonly removed: number;
+        readonly unchanged: number;
+    }[];
+    readonly edgeLevel: {
+        readonly newlyFlagged: readonly IBoundaryFlaggedEdge[];
+        readonly noLongerFlagged: readonly IBoundaryFlaggedEdge[];
+    };
+    readonly before: {
+        readonly rules: number;
+        readonly counts: {
+            readonly error: number;
+            readonly warning: number;
+            readonly info: number;
+        };
+    };
+    readonly after: {
+        readonly rules: number;
+        readonly counts: {
+            readonly error: number;
+            readonly warning: number;
+            readonly info: number;
+        };
+    };
+    /**
+     * The candidate rules' coverage in the proposed evaluation — a dead candidate
+     * scope is flagged here. Round 13 (P2): each record went through THE unread
+     * re-settle `check boundaries` uses (`boundaryUnitLiveness`) and its read
+     * scope (`readScopeCoverage`), so an unreadable governed file is never a pass
+     * here and a dead unit it could refute is Unproven, not reported.
+     */
+    readonly candidateCoverage: readonly IBoundaryRuleCoverage[];
+    /** The candidate rules' expectEmpty units whose target does not exist — accepted (round 13). */
+    readonly intendedEmpty: readonly IBoundaryUnitFinding[];
+    /** The candidate rules' expectEmpty units whose target now exists — stale markers (round 13). */
+    readonly wentLive: readonly IBoundaryUnitFinding[];
+    /** The candidate units `--fail-on-dead-units` fails (core `selectorUnitFails`); each makes the proposal 1. */
+    readonly failingUnits: readonly IBoundaryUnitFinding[];
+    readonly loadIssues: readonly IBoundaryLoadIssue[];
+    /**
+     * 1 when the proposal ADDS an error-severity violation, a candidate rule
+     * failed to load, a candidate fails on empty, or a candidate unit fails under
+     * `--fail-on-dead-units`; else 0; 3 for an unknown `--rule`.
+     */
+    readonly proposedExit: number;
+    readonly unknownRuleId?: string;
+}
+export {};
+//# sourceMappingURL=boundary-rule-set-diff.model.d.ts.map

package/dist/boundary-rule-set-diff.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-rule-set-diff.model.d.ts","sourceRoot":"","sources":["../src/boundary-rule-set-diff.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC5G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE,gFAAgF;AAChF,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,kCAAkC,CAAC;IACpD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,EAAE,CAAC;IACJ,QAAQ,CAAC,SAAS,EAAE;QAClB,QAAQ,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,CAAC;QACvD,QAAQ,CAAC,eAAe,EAAE,SAAS,oBAAoB,EAAE,CAAC;KAC3D,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAC1I,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACzI;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC7D,gGAAgG;IAChG,QAAQ,CAAC,aAAa,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACxD,iGAAiG;IACjG,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACnD,8GAA8G;IAC9G,QAAQ,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvD,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC"}

package/dist/boundary-rule-set-diff.model.js

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

package/dist/boundary-rule-sources.d.ts

@@ -0,0 +1,28 @@
+import type { IBoundaryRuleInvalidation } from './boundary-rule-invalidation.model.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+/**
+ * The files that DEFINE boundary rules (round 11, closing#d / 6.3) — one list,
+ * so the changed-scope filter, finish and the imports gate agree on what a
+ * "rule source" is:
+ *
+ *   - the sharkcraft config (it lists `boundaryFiles`);
+ *   - every local `boundaryFiles` entry, resolved under the sharkcraft dir
+ *     (listed, whether or not it exists — a deleted rule file is a rule edit);
+ *   - every pack-contributed boundary file.
+ *
+ * Project-relative, `/`-separated, sorted.
+ */
+export declare function boundaryRuleSourceFiles(inspection: ISharkcraftInspection): string[];
+/**
+ * Which rules a changeset invalidated — see {@link IBoundaryRuleInvalidation}.
+ *
+ *   - a changed rule-source file escalates the rules it defines;
+ *   - a changed sharkcraft config or root tsconfig (the alias map) escalates
+ *     EVERY rule;
+ *   - a changed root package.json / lockfile, or any file inside a pack's root,
+ *     escalates the pack-contributed rules it could have changed.
+ *
+ * `ruleIds` narrows the rule set considered (default: the whole registry).
+ */
+export declare function resolveBoundaryRuleInvalidation(changedFiles: readonly string[], inspection: ISharkcraftInspection, ruleIds?: readonly string[]): IBoundaryRuleInvalidation;
+//# sourceMappingURL=boundary-rule-sources.d.ts.map

package/dist/boundary-rule-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-rule-sources.d.ts","sourceRoot":"","sources":["../src/boundary-rule-sources.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AACvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,qBAAqB,GAAG,MAAM,EAAE,CAkBnF;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,UAAU,EAAE,qBAAqB,EACjC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,yBAAyB,CA2C3B"}

package/dist/boundary-rule-sources.js

@@ -0,0 +1,110 @@
+import * as nodePath from 'node:path';
+import { boundaryFileLabel, classifyLocalBoundaryFiles } from "./boundary-configuration-status.js";
+/**
+ * The files that DEFINE boundary rules (round 11, closing#d / 6.3) — one list,
+ * so the changed-scope filter, finish and the imports gate agree on what a
+ * "rule source" is:
+ *
+ *   - the sharkcraft config (it lists `boundaryFiles`);
+ *   - every local `boundaryFiles` entry, resolved under the sharkcraft dir
+ *     (listed, whether or not it exists — a deleted rule file is a rule edit);
+ *   - every pack-contributed boundary file.
+ *
+ * Project-relative, `/`-separated, sorted.
+ */
+export function boundaryRuleSourceFiles(inspection) {
+    const label = (abs) => boundaryFileLabel(inspection.projectRoot, abs);
+    const out = new Set();
+    if (inspection.configFile)
+        out.add(label(inspection.configFile));
+    if (inspection.sharkcraftDir) {
+        for (const l of classifyLocalBoundaryFiles(inspection.sharkcraftDir, inspection.config?.boundaryFiles ?? []).listed) {
+            out.add(label(l.abs));
+        }
+    }
+    for (const pack of inspection.packs.validPacks) {
+        for (const rel of pack.manifest?.contributions?.boundaryFiles ?? []) {
+            out.add(label(nodePath.resolve(pack.packageRoot, rel)));
+        }
+    }
+    for (const src of inspection.boundarySources.values()) {
+        if (src.file)
+            out.add(label(src.file));
+    }
+    return [...out].sort();
+}
+const TSCONFIG_FILES = new Set(['tsconfig.json', 'tsconfig.base.json']);
+const ROOT_MANIFEST_FILES = new Set([
+    'package.json',
+    'bun.lock',
+    'bun.lockb',
+    'package-lock.json',
+    'npm-shrinkwrap.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+]);
+function normalizeChanged(f) {
+    return f.split(/[\\/]/).join('/').replace(/^\.\//, '');
+}
+/**
+ * Which rules a changeset invalidated — see {@link IBoundaryRuleInvalidation}.
+ *
+ *   - a changed rule-source file escalates the rules it defines;
+ *   - a changed sharkcraft config or root tsconfig (the alias map) escalates
+ *     EVERY rule;
+ *   - a changed root package.json / lockfile, or any file inside a pack's root,
+ *     escalates the pack-contributed rules it could have changed.
+ *
+ * `ruleIds` narrows the rule set considered (default: the whole registry).
+ */
+export function resolveBoundaryRuleInvalidation(changedFiles, inspection, ruleIds) {
+    const all = ruleIds ?? inspection.boundaryRegistry.list().map((r) => r.id);
+    const label = (abs) => boundaryFileLabel(inspection.projectRoot, abs);
+    const changed = new Set(changedFiles.map(normalizeChanged));
+    const escalated = new Set();
+    const reasons = [];
+    const add = (file, kind, ids) => {
+        if (ids.length === 0)
+            return;
+        reasons.push({ file, kind, ruleIds: [...ids] });
+        for (const id of ids)
+            escalated.add(id);
+    };
+    const bySource = new Map();
+    for (const id of all) {
+        const src = inspection.boundarySources.get(id);
+        if (!src?.file)
+            continue;
+        const file = label(src.file);
+        const list = bySource.get(file);
+        if (list)
+            list.push(id);
+        else
+            bySource.set(file, [id]);
+    }
+    for (const [file, ids] of bySource)
+        if (changed.has(file))
+            add(file, 'rule-source', ids);
+    if (inspection.configFile) {
+        const cfg = label(inspection.configFile);
+        if (changed.has(cfg))
+            add(cfg, 'config', all);
+    }
+    for (const f of changed)
+        if (TSCONFIG_FILES.has(f))
+            add(f, 'tsconfig', all);
+    const packRuleIds = all.filter((id) => inspection.boundarySources.get(id)?.type === 'pack');
+    for (const f of changed)
+        if (ROOT_MANIFEST_FILES.has(f))
+            add(f, 'manifest', packRuleIds);
+    for (const pack of inspection.packs.validPacks) {
+        const root = label(pack.packageRoot);
+        if (nodePath.isAbsolute(root))
+            continue; // outside the project — never in a changeset
+        const touched = [...changed].find((f) => f.startsWith(`${root}/`) && !bySource.has(f));
+        if (!touched)
+            continue;
+        add(touched, 'manifest', all.filter((id) => inspection.boundarySources.get(id)?.packageName === pack.packageName));
+    }
+    return { escalatedRuleIds: all.filter((id) => escalated.has(id)), reasons };
+}

package/dist/boundary-stale-exception-finding.model.d.ts

@@ -0,0 +1,12 @@
+import type { IBoundaryStaleException } from '@shrkcrft/boundaries';
+/**
+ * A stale exception, located at the rule file that declares it — so it flows
+ * through the changed-scope filter like a violation keyed on the rule source:
+ * it fails a changeset that edits the rule file (or escalates it), and is
+ * legacy otherwise.
+ */
+export interface IBoundaryStaleExceptionFinding extends IBoundaryStaleException {
+    /** Project-relative path of the rule's source file. */
+    readonly file: string;
+}
+//# sourceMappingURL=boundary-stale-exception-finding.model.d.ts.map

package/dist/boundary-stale-exception-finding.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-stale-exception-finding.model.d.ts","sourceRoot":"","sources":["../src/boundary-stale-exception-finding.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,WAAW,8BAA+B,SAAQ,uBAAuB;IAC7E,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB"}

package/dist/boundary-stale-exception-finding.model.js

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

package/dist/boundary-unit-liveness.d.ts

@@ -0,0 +1,35 @@
+import { type IBoundaryRule, type IBoundaryRuleCoverage, type IUnreadFile } from '@shrkcrft/boundaries';
+/**
+ * THE unread re-settle of one boundary rule (round 13; V1-U1, prerequisite P2)
+ * — `check boundaries` AND `check boundaries --diff-against` both call it, so an
+ * unreadable governed file weighs the same on the gate and on the authoring
+ * path. It replaces `withProvableDeadUnits`, which silently DROPPED a claim;
+ * the diff path had no such step at all.
+ *
+ * A "matches nothing" / "does not exist yet" fact is a whole-tree claim made
+ * from what was READ. Every negative fact an unread entry could refute is
+ * withdrawn (made unknown), and the rule is re-settled through the one boundary
+ * settle (`settleBoundaryRule`, `@shrkcrft/boundaries`): such a unit reads
+ * Unproven — no dead line, no `accepted by expectEmpty`, a gap in its rule's
+ * coverage. What is refutable:
+ *
+ *   - a `forbiddenImports` / `allowedImports` claim ("matches no import
+ *     anywhere") — by any unread entry the rule's `from` globs match;
+ *   - a `from` / exemption glob claim ("matched 0 files") — by an unread entry
+ *     that glob matches;
+ *   - a unit dead by its SHAPE (`cause`) — never: it is proved from the rule alone.
+ *
+ * A positive fact (a match seen) is kept. The rule's emptiness is re-settled
+ * with `readGap`: a rule whose governed files went unread is partial, never
+ * "matched nothing" and never failOnEmpty's 1. Unchanged (same object) when
+ * nothing is withdrawn and no governed file is unread.
+ */
+export declare function boundaryUnitLiveness(detail: IBoundaryRuleCoverage, rule: IBoundaryRule, context: {
+    /** Every entry the scan could not read (files, and directories it could not list). */
+    readonly unread: readonly IUnreadFile[];
+    /** A governed file in the rule's REPORTED scope was not read (the orchestrator's `readGap`). */
+    readonly readGap: boolean;
+    readonly filesScanned: number;
+    readonly fileUniverse: 'scan' | 'edges';
+}): IBoundaryRuleCoverage;
+//# sourceMappingURL=boundary-unit-liveness.d.ts.map

package/dist/boundary-unit-liveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-unit-liveness.d.ts","sourceRoot":"","sources":["../src/boundary-unit-liveness.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAG9B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE;IACP,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;CACzC,GACA,qBAAqB,CAyCvB"}