@spikedpunch/align-core 0.1.0

package/dist/rules/evaluators.js

@@ -0,0 +1,236 @@
+import { toRuleId } from '../types/branded.js';
+import { computeFingerprint } from '../baseline/fingerprint.js';
+import { extractCycleChainNodes, tarjanScc } from './tarjan.js';
+import { evaluateCustomHost } from './host-rules.js';
+/** No predicates registered — the default for callers that don't pass a registry (most tests, and
+ * any evaluation path that only exercises portable `arch.*` kinds). A `custom.host` rule
+ * evaluated against this empty registry throws `UnknownHostRuleError`, same as an unregistered
+ * name against a real registry — there is no silent-zero-violations path (ADR 008 amendment). */
+const NO_HOST_PREDICATES = new Map();
+// `exactOptionalPropertyTypes` (CODING_BEST_PRACTICES.md §9) forbids assigning `undefined` to an
+// optional field explicitly — spread this in rather than writing `because: rule.provenance.because`.
+// Exported: `rules/manifest-evaluators.ts`'s manifest-domain evaluators share this exact helper
+// rather than duplicating it (CODING_BEST_PRACTICES.md's rule-of-three) — both evaluator families
+// build the same `ViolationBase` shape from the same `RuleProvenance`.
+export function becauseField(because) {
+    return because === undefined ? {} : { because };
+}
+export const evaluateNoDependency = (rule, graph) => {
+    const nodeByFile = new Map(graph.nodes.map((n) => [n.file, n]));
+    const violations = [];
+    for (const edge of graph.edges) {
+        const fromNode = nodeByFile.get(edge.from);
+        const toNode = nodeByFile.get(edge.to);
+        if (fromNode === undefined || toNode === undefined)
+            continue;
+        if (fromNode.component !== rule.from || toNode.component !== rule.to)
+            continue;
+        const id = computeFingerprint(['no-dependency', rule.id, edge.from, edge.to, edge.specifier]);
+        violations.push({
+            id,
+            ruleId: toRuleId(rule.id),
+            category: 'architecture',
+            severity: 'error',
+            file: edge.from,
+            range: { startLine: edge.line, endLine: edge.line },
+            snippet: edge.snippet,
+            fixHint: { code: 'remove-import', file: edge.from, line: edge.line },
+            ...becauseField(rule.provenance.because),
+            kind: 'no-dependency',
+            fromFile: edge.from,
+            toFile: edge.to,
+            fromComponent: fromNode.component,
+            toComponent: toNode.component,
+            specifier: edge.specifier,
+            line: edge.line,
+        });
+    }
+    return violations;
+};
+const RUNTIME_KINDS = ['import', 'reexport', 'dynamic'];
+const ALL_KINDS = ['import', 'reexport', 'dynamic', 'type-only'];
+export const evaluateNoCycles = (rule, graph) => {
+    const nodeByFile = new Map(graph.nodes.map((n) => [n.file, n]));
+    const inScope = (file) => rule.scope === 'repo' ? true : nodeByFile.get(file)?.component === rule.scope;
+    const allowedKinds = new Set(rule.includeTypeOnly ? ALL_KINDS : RUNTIME_KINDS);
+    const adjacency = new Map();
+    for (const node of graph.nodes)
+        if (inScope(node.file))
+            adjacency.set(node.file, []);
+    const edgeByPair = new Map();
+    for (const edge of graph.edges) {
+        if (!allowedKinds.has(edge.kind))
+            continue;
+        if (!adjacency.has(edge.from) || !adjacency.has(edge.to))
+            continue;
+        adjacency.get(edge.from)?.push(edge.to);
+        // First edge wins for a given (from, to) pair when the chain is rendered — enough to name a
+        // concrete importable specifier/line without enumerating every parallel edge.
+        const key = `${edge.from} ${edge.to}`;
+        if (!edgeByPair.has(key))
+            edgeByPair.set(key, edge);
+    }
+    const sccs = tarjanScc(adjacency);
+    const violations = [];
+    for (const scc of sccs) {
+        const isSelfLoop = scc.length === 1 && (scc[0] === undefined ? false : (adjacency.get(scc[0]) ?? []).includes(scc[0]));
+        if (scc.length <= 1 && !isSelfLoop)
+            continue;
+        const chainNodes = extractCycleChainNodes(scc, adjacency);
+        const chain = [];
+        for (let i = 0; i < chainNodes.length - 1; i += 1) {
+            const from = chainNodes[i];
+            const to = chainNodes[i + 1];
+            if (from === undefined || to === undefined)
+                continue;
+            const edge = edgeByPair.get(`${from} ${to}`);
+            if (edge === undefined)
+                continue;
+            chain.push({ from, to, specifier: edge.specifier, line: edge.line });
+        }
+        if (chain.length === 0)
+            continue;
+        const breakHop = chain[chain.length - 1];
+        if (breakHop === undefined)
+            continue;
+        const breakEdgeRaw = edgeByPair.get(`${breakHop.from} ${breakHop.to}`);
+        if (breakEdgeRaw === undefined)
+            continue;
+        const id = computeFingerprint(['no-cycles', rule.id, ...chain.map((e) => `${e.from}>${e.to}:${e.specifier}`)]);
+        const firstFile = chainNodes[0];
+        if (firstFile === undefined)
+            continue;
+        violations.push({
+            id,
+            ruleId: toRuleId(rule.id),
+            category: 'architecture',
+            severity: 'error',
+            file: firstFile,
+            range: { startLine: breakHop.line, endLine: breakHop.line },
+            snippet: breakEdgeRaw.snippet,
+            fixHint: { code: 'break-cycle-edge', suggestedEdge: breakHop },
+            ...becauseField(rule.provenance.because),
+            kind: 'no-cycles',
+            chain,
+            suggestedBreakEdge: breakHop,
+        });
+    }
+    return violations;
+};
+export const evaluateLayers = (rule, graph) => {
+    const nodeByFile = new Map(graph.nodes.map((n) => [n.file, n]));
+    const violations = [];
+    for (const layerDef of rule.layers) {
+        const allowed = new Set(layerDef.canDependOn);
+        for (const edge of graph.edges) {
+            const fromNode = nodeByFile.get(edge.from);
+            const toNode = nodeByFile.get(edge.to);
+            if (fromNode === undefined || toNode === undefined)
+                continue;
+            if (fromNode.component !== layerDef.layer)
+                continue;
+            if (toNode.component === fromNode.component)
+                continue; // intra-layer is always fine
+            if (allowed.has(toNode.component))
+                continue;
+            const id = computeFingerprint(['layers', rule.id, edge.from, edge.to, edge.specifier]);
+            violations.push({
+                id,
+                ruleId: toRuleId(rule.id),
+                category: 'architecture',
+                severity: 'error',
+                file: edge.from,
+                range: { startLine: edge.line, endLine: edge.line },
+                snippet: edge.snippet,
+                fixHint: { code: 'remove-import', file: edge.from, line: edge.line },
+                ...becauseField(rule.provenance.because),
+                kind: 'layers',
+                fromLayer: fromNode.component,
+                toLayer: toNode.component,
+                fromFile: edge.from,
+                toFile: edge.to,
+                specifier: edge.specifier,
+                line: edge.line,
+            });
+        }
+    }
+    return violations;
+};
+/**
+ * `arch.metric` (max-LOC only, promoted 2026-07-12 on kluster ruleset evidence —
+ * IMPLEMENTATION_PLAN.md's Promotion log: two 2,100+-line files were structurally invisible to
+ * every dependency/cycle rule). One violation per file classified to `rule.target` whose `loc`
+ * exceeds `rule.max` — `loc` is already on every `DependencyGraphNode` (no new scanning).
+ */
+export const evaluateMetric = (rule, graph) => {
+    const violations = [];
+    for (const node of graph.nodes) {
+        if (node.component !== rule.target)
+            continue;
+        if (node.loc <= rule.max)
+            continue;
+        const id = computeFingerprint(['metric', rule.id, node.file]);
+        violations.push({
+            id,
+            ruleId: toRuleId(rule.id),
+            category: 'architecture',
+            severity: 'error',
+            file: node.file,
+            range: { startLine: 1, endLine: 1 },
+            snippet: node.snippet,
+            fixHint: { code: 'split-file', file: node.file },
+            ...becauseField(rule.provenance.because),
+            kind: 'metric',
+            metric: rule.metric,
+            component: node.component,
+            value: node.loc,
+            threshold: rule.max,
+        });
+    }
+    return violations;
+};
+/**
+ * Exhaustive dispatcher: a new `RuleIR` discriminant without a case here is a compile error
+ * (never-check, CODING_BEST_PRACTICES.md §17.2), not a silent no-op.
+ *
+ * `hostPredicates` defaults to the empty registry — every `arch.*` evaluator ignores it entirely
+ * (they never took it before registration existed); only `custom.host` reads it. A predicate that
+ * throws propagates out of this function uncaught (`HostPredicateExecutionError`) exactly like a
+ * malformed rule would — the orchestrator's evaluation-loop guard is what turns that into gate
+ * `error` (`orchestrator.ts`), not this function, which stays a pure dispatcher.
+ *
+ * `security.manifest.*` kinds (ADR 013) return `[]` here, deliberately: this dispatcher only ever
+ * receives a `DependencyGraph` (TS-source scan output), and manifest rules evaluate against a
+ * disjoint scan domain (`ManifestInventory`) that this function never has access to. They are real
+ * `RuleIR` members (needed so the DSL/tier-2/build pipeline can author and round-trip them), but
+ * their actual evaluation always goes through `evaluateManifestRule`
+ * (`rules/manifest-evaluators.ts`) against real manifest data — `GateOrchestrator`'s `security` gate
+ * calls it directly and never routes these kinds through this function (`ruleCategoryOf` partitions
+ * `RulesetIR.rules` before either dispatcher runs, `rules/rule-category.ts`). Returning `[]` here
+ * (rather than throwing) keeps `align build`/`align explain`'s generic graph-based preview paths
+ * working without a manifest scan available to them — see ADR 013's follow-up ladder for the known
+ * gap this leaves (their impact-delta preview under-reports manifest-rule violations; `align check`
+ * remains authoritative).
+ */
+export function evaluateRule(rule, graph, components, hostPredicates = NO_HOST_PREDICATES) {
+    switch (rule.kind) {
+        case 'arch.no-dependency':
+            return evaluateNoDependency(rule, graph, components);
+        case 'arch.no-cycles':
+            return evaluateNoCycles(rule, graph, components);
+        case 'arch.layers':
+            return evaluateLayers(rule, graph, components);
+        case 'arch.metric':
+            return evaluateMetric(rule, graph, components);
+        case 'custom.host':
+            return evaluateCustomHost(rule, graph, hostPredicates);
+        case 'security.manifest.source-hygiene':
+        case 'security.manifest.new-dependency':
+            return [];
+        default: {
+            const exhaustive = rule;
+            throw new Error(`unhandled rule kind: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+//# sourceMappingURL=evaluators.js.map

package/dist/rules/evaluators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluators.js","sourceRoot":"","sources":["../../src/rules/evaluators.ts"],"names":[],"mappings":"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"}

package/dist/rules/host-rules.d.ts

@@ -0,0 +1,109 @@
+import type { ComponentName, RepoRelativePath } from '../types/branded.js';
+import type { CustomHostRule, RuleIR } from '../types/ir.js';
+import type { DependencyGraph } from '../types/graph.js';
+import type { SourceRange, Violation } from '../types/violation.js';
+/** Thrown when a `custom.host` rule names a host predicate that is not registered — the third
+ * member of the vacuous-green family (`rules/component-refs.ts`, `components/registry.ts`'s
+ * `validateClassifiedComponents`): pre-registration, `evaluateRule` returned zero violations for
+ * every `custom.host` rule unconditionally, so an unevaluatable rule would otherwise sit in the
+ * ruleset reporting green — and even count toward `passCount` — while enforcing nothing. Now that
+ * predicates are registrable (`align.config.ts`'s `hostRules` export, `docs/adr/002`), this only
+ * fires for a genuinely unregistered name — a typo, a removed predicate a rule still references,
+ * or (rare) a rule reaching `evaluateCustomHost` without having gone through the orchestrator's
+ * guard step first (defense in depth, see `evaluateCustomHost` below). */
+export declare class UnknownHostRuleError extends Error {
+    readonly ruleId: string;
+    readonly hostRuleName: string;
+    constructor(ruleId: string, hostRuleName: string);
+}
+/**
+ * Load-time validation, run in `GateOrchestrator.check`'s vacuous-green guard step: every
+ * `custom.host` rule's `hostRuleName` must name a registered host predicate. The CLI composition
+ * root derives `registeredHostPredicates` from the loaded config's `hostRules` export (core stays
+ * framework-free — it only ever sees the name set, never the config-loading mechanism) and passes
+ * the real set to `GateOrchestrator`'s constructor; a repo with no `hostRules` export passes an
+ * empty set here, same as before registration existed. Fail-fast on the first offender, same
+ * convention as the sibling validators.
+ */
+export declare function validateHostRules(rules: readonly RuleIR[], registeredHostPredicates: ReadonlySet<string>): void;
+/**
+ * Narrow, typed input a host predicate receives — pure data, no I/O (CODING_BEST_PRACTICES.md
+ * §14/15's "functional core" discipline applies to predicates too): the freshly re-scanned graph
+ * (ADR 005 — always fresh, never cached), a convenience component lookup, and the flat file list.
+ * Predicates read this and return `HostViolation[]`; they never touch the filesystem, network, or
+ * clock themselves, and `evaluateCustomHost` (below) is itself I/O-free, matching every other
+ * `RuleEvaluator` in this package.
+ */
+export interface HostRuleContext {
+    readonly graph: DependencyGraph;
+    readonly componentOf: (file: RepoRelativePath) => ComponentName | undefined;
+    readonly files: readonly RepoRelativePath[];
+}
+/**
+ * What a predicate returns — deliberately minimal so authoring one stays a few lines
+ * (docs/proposals/rule-expansion-evaluation.md §B.0's "cost to ship: low"). `range`/`snippet`
+ * default to the violating file's line 1 / scanned first-line snippet when omitted — core (never
+ * the predicate) fingerprints the violation, defaults `fixHint` to `'manual-review'`, and hoists
+ * the rule's `.because()` text, mirroring exactly what every other `RuleEvaluator` does for its
+ * own violations.
+ */
+export interface HostViolation {
+    readonly file: RepoRelativePath;
+    readonly range?: SourceRange;
+    readonly snippet?: string;
+    readonly message: string;
+}
+/** A registered host predicate: pure `(ctx) -> violations`, no I/O — same doctrine as
+ * `RuleEvaluator` (`rules/evaluators.ts`), scoped to one rule kind's worth of host-defined logic.
+ * Authored in `align.config.ts`'s `hostRules` export, keyed by the name a `custom.host` rule's
+ * `hostRuleName` references (`c.custom.host('name')`, `dsl/index.ts`). */
+export type HostPredicate = (ctx: HostRuleContext) => readonly HostViolation[];
+/** The registered-predicate map, keyed by `hostRuleName`. `ReadonlyMap` (not a plain object) —
+ * the CLI composition root builds this once from `align.config.ts`'s `hostRules` export and
+ * injects it into `GateOrchestrator`; core never constructs one itself. */
+export type HostPredicateRegistry = ReadonlyMap<string, HostPredicate>;
+/** Thrown when a registered predicate itself throws while evaluating — the reference-validity
+ * invariant's sibling (ADR 008 amendment): a buggy predicate must surface as gate `error`, never a
+ * silent pass (an uncaught exception mid-evaluation would otherwise abort the whole check with an
+ * unattributed stack trace) and never a silently-dropped violation set. Caught here, re-thrown
+ * with rule/predicate attribution so the orchestrator's evaluation-loop guard (`orchestrator.ts`)
+ * can turn it into a `GateResult` the same way it already does for scan/reference-validity
+ * failures. */
+export declare class HostPredicateExecutionError extends Error {
+    readonly ruleId: string;
+    readonly hostRuleName: string;
+    readonly predicateError: unknown;
+    constructor(ruleId: string, hostRuleName: string, predicateError: unknown);
+}
+/**
+ * Untrusted-mode's custom.host refusal (ADR 014). `--untrusted`/`--ir-only` never registers any
+ * host predicates (there is nothing to register them FROM — align.config.ts is never imported in
+ * that mode), so every `custom.host` rule is structurally unevaluatable there, permanently, not
+ * just until someone fixes a registration typo. Distinct from `UnknownHostRuleError` (a fixable
+ * config bug: register the predicate, fix the name, or remove the rule) — this error tells the
+ * truth about *why* it can't be fixed by editing `align.config.ts`: that file is never read under
+ * `--untrusted` at all. Refusing outright (never silently skipping the rule) follows the same
+ * false-green doctrine as `UnknownHostRuleError` and the reference-validity invariant (ADR 008
+ * amendment) — a silently-dropped rule would report green while enforcing nothing.
+ */
+export declare class UntrustedCustomHostRuleError extends Error {
+    readonly ruleIds: readonly string[];
+    constructor(ruleIds: readonly string[]);
+}
+/**
+ * `--untrusted`'s pre-flight guard (ADR 014), called by the CLI before constructing the
+ * orchestrator — mirrors `validateHostRules`'s fail-fast-on-first-offender convention but collects
+ * every offending rule id in one error instead of stopping at the first, since there is no
+ * "register the missing one and re-run" loop to support here (registration is categorically
+ * unavailable, not just incomplete).
+ */
+export declare function assertNoCustomHostRules(rules: readonly RuleIR[]): void;
+/**
+ * `custom.host`'s `RuleEvaluator` (dispatched from `rules/evaluators.ts`'s exhaustive switch,
+ * ADR 002). Looks up the rule's predicate in the injected registry, builds its `HostRuleContext`
+ * from the already-scanned graph (zero extra I/O), runs it, and normalizes every `HostViolation`
+ * into a full `Violation` — the same fingerprint/baseline/fix-hint machinery every other rule kind
+ * gets, so a custom.host violation is baseline-able and dedupes exactly like any other.
+ */
+export declare function evaluateCustomHost(rule: CustomHostRule, graph: DependencyGraph, predicates: HostPredicateRegistry): readonly Violation[];
+//# sourceMappingURL=host-rules.d.ts.map

package/dist/rules/host-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-rules.d.ts","sourceRoot":"","sources":["../../src/rules/host-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGpE;;;;;;;;0EAQ0E;AAC1E,qBAAa,oBAAqB,SAAQ,KAAK;aAE3B,MAAM,EAAE,MAAM;aACd,YAAY,EAAE,MAAM;gBADpB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM;CAUvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAO/G;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,aAAa,GAAG,SAAS,CAAC;IAC5E,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;0EAG0E;AAC1E,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,SAAS,aAAa,EAAE,CAAC;AAE/E;;2EAE2E;AAC3E,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEvE;;;;;;eAMe;AACf,qBAAa,2BAA4B,SAAQ,KAAK;aAElC,MAAM,EAAE,MAAM;aACd,YAAY,EAAE,MAAM;aACpB,cAAc,EAAE,OAAO;gBAFvB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,OAAO;CAU1C;AAED;;;;;;;;;;GAUG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;aACzB,OAAO,EAAE,SAAS,MAAM,EAAE;gBAA1B,OAAO,EAAE,SAAS,MAAM,EAAE;CAWvD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAGtE;AA8BD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,qBAAqB,GAChC,SAAS,SAAS,EAAE,CAsBtB"}

package/dist/rules/host-rules.js

@@ -0,0 +1,152 @@
+import { toRuleId } from '../types/branded.js';
+import { computeFingerprint } from '../baseline/fingerprint.js';
+/** Thrown when a `custom.host` rule names a host predicate that is not registered — the third
+ * member of the vacuous-green family (`rules/component-refs.ts`, `components/registry.ts`'s
+ * `validateClassifiedComponents`): pre-registration, `evaluateRule` returned zero violations for
+ * every `custom.host` rule unconditionally, so an unevaluatable rule would otherwise sit in the
+ * ruleset reporting green — and even count toward `passCount` — while enforcing nothing. Now that
+ * predicates are registrable (`align.config.ts`'s `hostRules` export, `docs/adr/002`), this only
+ * fires for a genuinely unregistered name — a typo, a removed predicate a rule still references,
+ * or (rare) a rule reaching `evaluateCustomHost` without having gone through the orchestrator's
+ * guard step first (defense in depth, see `evaluateCustomHost` below). */
+export class UnknownHostRuleError extends Error {
+    ruleId;
+    hostRuleName;
+    constructor(ruleId, hostRuleName) {
+        super(`Rule '${ruleId}' (custom.host) references host predicate '${hostRuleName}', which is not ` +
+            `registered in align.config.ts's 'hostRules' export. This rule cannot be evaluated and ` +
+            `would silently report green. Register a predicate named '${hostRuleName}' in 'hostRules', ` +
+            `fix the typo, or remove the rule (and re-run \`align build\` if it came from a doc).`);
+        this.ruleId = ruleId;
+        this.hostRuleName = hostRuleName;
+        this.name = 'UnknownHostRuleError';
+    }
+}
+/**
+ * Load-time validation, run in `GateOrchestrator.check`'s vacuous-green guard step: every
+ * `custom.host` rule's `hostRuleName` must name a registered host predicate. The CLI composition
+ * root derives `registeredHostPredicates` from the loaded config's `hostRules` export (core stays
+ * framework-free — it only ever sees the name set, never the config-loading mechanism) and passes
+ * the real set to `GateOrchestrator`'s constructor; a repo with no `hostRules` export passes an
+ * empty set here, same as before registration existed. Fail-fast on the first offender, same
+ * convention as the sibling validators.
+ */
+export function validateHostRules(rules, registeredHostPredicates) {
+    for (const rule of rules) {
+        if (rule.kind !== 'custom.host')
+            continue;
+        if (!registeredHostPredicates.has(rule.hostRuleName)) {
+            throw new UnknownHostRuleError(rule.id, rule.hostRuleName);
+        }
+    }
+}
+/** Thrown when a registered predicate itself throws while evaluating — the reference-validity
+ * invariant's sibling (ADR 008 amendment): a buggy predicate must surface as gate `error`, never a
+ * silent pass (an uncaught exception mid-evaluation would otherwise abort the whole check with an
+ * unattributed stack trace) and never a silently-dropped violation set. Caught here, re-thrown
+ * with rule/predicate attribution so the orchestrator's evaluation-loop guard (`orchestrator.ts`)
+ * can turn it into a `GateResult` the same way it already does for scan/reference-validity
+ * failures. */
+export class HostPredicateExecutionError extends Error {
+    ruleId;
+    hostRuleName;
+    predicateError;
+    constructor(ruleId, hostRuleName, predicateError) {
+        super(`Rule '${ruleId}' (custom.host) predicate '${hostRuleName}' threw while evaluating: ` +
+            `${predicateError instanceof Error ? predicateError.message : String(predicateError)} — ` +
+            `a host predicate must be a pure function over its HostRuleContext (no I/O); fix it in ` +
+            `align.config.ts's 'hostRules' export.`);
+        this.ruleId = ruleId;
+        this.hostRuleName = hostRuleName;
+        this.predicateError = predicateError;
+        this.name = 'HostPredicateExecutionError';
+    }
+}
+/**
+ * Untrusted-mode's custom.host refusal (ADR 014). `--untrusted`/`--ir-only` never registers any
+ * host predicates (there is nothing to register them FROM — align.config.ts is never imported in
+ * that mode), so every `custom.host` rule is structurally unevaluatable there, permanently, not
+ * just until someone fixes a registration typo. Distinct from `UnknownHostRuleError` (a fixable
+ * config bug: register the predicate, fix the name, or remove the rule) — this error tells the
+ * truth about *why* it can't be fixed by editing `align.config.ts`: that file is never read under
+ * `--untrusted` at all. Refusing outright (never silently skipping the rule) follows the same
+ * false-green doctrine as `UnknownHostRuleError` and the reference-validity invariant (ADR 008
+ * amendment) — a silently-dropped rule would report green while enforcing nothing.
+ */
+export class UntrustedCustomHostRuleError extends Error {
+    ruleIds;
+    constructor(ruleIds) {
+        super(`--untrusted refuses to evaluate ${ruleIds.length} custom.host rule(s): ${ruleIds.join(', ')}. ` +
+            `A custom.host predicate is host-side code by definition, and --untrusted's entire guarantee ` +
+            `is that no repo-controlled code executes — there is no predicate registry to consult because ` +
+            `align.config.ts is never imported in this mode. Options: run \`align check\` without ` +
+            `--untrusted on a repo you trust to execute code, or remove/replace these rules with a ` +
+            `portable arch.*/security.manifest.* kind before running \`align export-ir\` again.`);
+        this.ruleIds = ruleIds;
+        this.name = 'UntrustedCustomHostRuleError';
+    }
+}
+/**
+ * `--untrusted`'s pre-flight guard (ADR 014), called by the CLI before constructing the
+ * orchestrator — mirrors `validateHostRules`'s fail-fast-on-first-offender convention but collects
+ * every offending rule id in one error instead of stopping at the first, since there is no
+ * "register the missing one and re-run" loop to support here (registration is categorically
+ * unavailable, not just incomplete).
+ */
+export function assertNoCustomHostRules(rules) {
+    const ids = rules.filter((r) => r.kind === 'custom.host').map((r) => r.id);
+    if (ids.length > 0)
+        throw new UntrustedCustomHostRuleError(ids);
+}
+function normalizeHostViolation(rule, hv, nodeByFile) {
+    const range = hv.range ?? { startLine: 1, endLine: 1 };
+    // No I/O here either (evaluateCustomHost stays as pure as every other RuleEvaluator) — the
+    // fallback reuses the node's already-scanned first-line snippet (DependencyGraphNode.snippet,
+    // captured once at scan time, same field `arch.metric` reuses for its own file-level
+    // violations) rather than re-reading the file.
+    const snippet = hv.snippet ?? nodeByFile.get(hv.file)?.snippet ?? hv.message;
+    const id = computeFingerprint(['custom', rule.id, hv.file, String(range.startLine), hv.message]);
+    return {
+        id,
+        ruleId: toRuleId(rule.id),
+        category: 'architecture',
+        severity: 'error',
+        file: hv.file,
+        range,
+        snippet,
+        fixHint: { code: 'manual-review' },
+        ...(rule.provenance.because === undefined ? {} : { because: rule.provenance.because }),
+        kind: 'custom',
+        hostRuleName: rule.hostRuleName,
+        detail: hv.message,
+    };
+}
+/**
+ * `custom.host`'s `RuleEvaluator` (dispatched from `rules/evaluators.ts`'s exhaustive switch,
+ * ADR 002). Looks up the rule's predicate in the injected registry, builds its `HostRuleContext`
+ * from the already-scanned graph (zero extra I/O), runs it, and normalizes every `HostViolation`
+ * into a full `Violation` — the same fingerprint/baseline/fix-hint machinery every other rule kind
+ * gets, so a custom.host violation is baseline-able and dedupes exactly like any other.
+ */
+export function evaluateCustomHost(rule, graph, predicates) {
+    const predicate = predicates.get(rule.hostRuleName);
+    if (predicate === undefined) {
+        // Defense in depth: `validateHostRules` (the orchestrator's pre-evaluation guard step) should
+        // already have caught this — reachable only if a caller evaluates a rule without running the
+        // guard first (e.g. `align explain`/`align build`'s dry-run passes call `evaluateRule`
+        // directly). Same error type either way, so the message is identical.
+        throw new UnknownHostRuleError(rule.id, rule.hostRuleName);
+    }
+    const nodeByFile = new Map(graph.nodes.map((n) => [n.file, n]));
+    const componentOf = (file) => nodeByFile.get(file)?.component;
+    const ctx = { graph, componentOf, files: graph.nodes.map((n) => n.file) };
+    let results;
+    try {
+        results = predicate(ctx);
+    }
+    catch (err) {
+        throw new HostPredicateExecutionError(rule.id, rule.hostRuleName, err);
+    }
+    return results.map((hv) => normalizeHostViolation(rule, hv, nodeByFile));
+}
+//# sourceMappingURL=host-rules.js.map

package/dist/rules/host-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-rules.js","sourceRoot":"","sources":["../../src/rules/host-rules.ts"],"names":[],"mappings":"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"}

package/dist/rules/index.d.ts

@@ -0,0 +1,7 @@
+export * from './evaluators.js';
+export * from './manifest-evaluators.js';
+export * from './rule-category.js';
+export * from './component-refs.js';
+export * from './host-rules.js';
+export * from './tarjan.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/rules/index.js

@@ -0,0 +1,7 @@
+export * from './evaluators.js';
+export * from './manifest-evaluators.js';
+export * from './rule-category.js';
+export * from './component-refs.js';
+export * from './host-rules.js';
+export * from './tarjan.js';
+//# sourceMappingURL=index.js.map

package/dist/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/rules/manifest-evaluators.d.ts

@@ -0,0 +1,32 @@
+import type { SecurityManifestNewDependencyRule, SecurityManifestSourceHygieneRule } from '../types/ir.js';
+import type { ManifestInventory } from '../types/manifest.js';
+import type { Violation } from '../types/violation.js';
+export type SecurityManifestRule = SecurityManifestSourceHygieneRule | SecurityManifestNewDependencyRule;
+/**
+ * `security.manifest.source-hygiene` (ADR 013, probe Rule 1): any dependency specifier resolving
+ * to git/http(s)/file/link, not registry/workspace protocol. Fingerprint keyed on
+ * (manifest file, dep name) only — never the specifier value or a line number — so a git-ref bump
+ * or manifest reformatting doesn't reset baseline consent (ADR 013's name-level doctrine, mirrored
+ * from `security.manifest.new-dependency`); the current specifier is still reported as a
+ * structured field so a reviewer sees exactly what changed.
+ */
+export declare const evaluateSourceHygiene: (rule: SecurityManifestSourceHygieneRule, inventory: ManifestInventory) => Violation[];
+/**
+ * `security.manifest.new-dependency` (ADR 013, probe Rule 7): a stateless, fingerprint-driven
+ * re-expression of the probe's git-diff mechanism through align's existing baseline-consent
+ * machinery (ADR 006), not a git-history diff itself — this evaluator flags EVERY current
+ * runtime/dev dependency as a fingerprinted candidate on every run; baseline consent (`align
+ * init`/`baseline accept`) is what turns "all of today's deps" into "nothing," so only a
+ * genuinely new dependency (new name, not previously baselined) ever shows red. Name-level only
+ * (`optionalDependencies`/`peerDependencies` excluded) — version-level gating is a documented
+ * follow-up (ADR 013), not built here: it would fire on every routine version bump / renovate PR.
+ */
+export declare const evaluateNewDependency: (rule: SecurityManifestNewDependencyRule, inventory: ManifestInventory) => Violation[];
+/**
+ * Exhaustive dispatcher for the manifest scan domain — the sibling of `evaluators.ts`'s
+ * `evaluateRule`, over the disjoint `SecurityManifestRule` union instead of the full `RuleIR`
+ * union. `GateOrchestrator`'s `security` gate is the only real caller (`ruleCategoryOf` partitions
+ * `RulesetIR.rules` before this ever runs, `rules/rule-category.ts`).
+ */
+export declare function evaluateManifestRule(rule: SecurityManifestRule, inventory: ManifestInventory): readonly Violation[];
+//# sourceMappingURL=manifest-evaluators.d.ts.map

package/dist/rules/manifest-evaluators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-evaluators.d.ts","sourceRoot":"","sources":["../../src/rules/manifest-evaluators.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iCAAiC,EAAE,iCAAiC,EAAE,MAAM,gBAAgB,CAAC;AAC3G,OAAO,KAAK,EAAsB,iBAAiB,EAAkB,MAAM,sBAAsB,CAAC;AAClG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAIvD,MAAM,MAAM,oBAAoB,GAAG,iCAAiC,GAAG,iCAAiC,CAAC;AAwBzG;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,iCAAiC,EAAE,WAAW,iBAAiB,KAAG,SAAS,EA2BtH,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,iCAAiC,EAAE,WAAW,iBAAiB,KAAG,SAAS,EA0BtH,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,oBAAoB,EAAE,SAAS,EAAE,iBAAiB,GAAG,SAAS,SAAS,EAAE,CAWnH"}