@archwall/core 0.1.0

package/dist/prepare-C1FfL8Qd.cjs

@@ -0,0 +1,921 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch, 1);
+//#region src/paths.ts
+/** Forward slashes everywhere, so one string form crosses platforms. */
+function normalize(p) {
+	return p.replaceAll("\\", "/");
+}
+/**
+* A file's path relative to `root`, forward-slashed, or `null` when it does not lie
+* strictly inside `root`.
+*
+* The one answer to "where is this file, in the terms my patterns are written in".
+* `include`/`exclude`, classifier patterns, `RuleScope.include`, and `require-tag`'s
+* `within` all describe positions in a tree, and they must all agree on what a position
+* is — including on the edge cases: the root itself is not *inside* the root, and a file
+* above it has no position at all.
+*
+* A path that is already relative is taken as relative *to the root* rather than resolved
+* against `process.cwd()`. Real producers emit absolute paths, but in-memory graphs (tests,
+* `@archwall/test-utils`) use bare ids, and resolving those against the working directory
+* would silently place every module outside the project.
+*/
+function sourceRelative(root, file) {
+	const normalized = normalize(file);
+	if (!node_path.isAbsolute(normalized)) return normalized === "" ? null : normalized;
+	const rel = normalize(node_path.relative(root, normalized));
+	if (rel === "" || rel.startsWith("../") || rel === ".." || node_path.isAbsolute(rel)) return null;
+	return rel;
+}
+/**
+* Repository-relative, for anything that leaves the process: violation fingerprints,
+* reporter output, SARIF `artifactLocation.uri`.
+*
+* Absolute paths are the right module identity *inside* a run and wrong in every output,
+* because they make results machine-specific. SARIF in particular is silently useless with
+* absolute URIs: GitHub code scanning cannot associate the result with a repository file.
+*
+* Distinct from {@link sourceRelative} in its failure mode, deliberately: an id outside the
+* root is returned as-is rather than as `null`, because output must always print something,
+* whereas matching must be able to say "not here".
+*/
+function toRelative(root, id) {
+	const normalized = normalize(id);
+	if (!node_path.isAbsolute(normalized)) return normalized;
+	return sourceRelative(root, normalized) ?? normalized;
+}
+/**
+* FNV-1a, 64-bit, as 16 lowercase hex chars.
+*
+* Not `node:crypto`: core stays runnable wherever a graph can be built (browser playground,
+* worker, edge runtime), and this hash is used for identity, never for security.
+*/
+function stableHash(input) {
+	let h1 = 2166136261;
+	let h2 = 16777619;
+	for (let i = 0; i < input.length; i++) {
+		const c = input.charCodeAt(i);
+		h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
+		h2 = Math.imul(h2 ^ (c << 5 | c >>> 3), 16777619) >>> 0;
+	}
+	return h1.toString(16).padStart(8, "0") + h2.toString(16).padStart(8, "0");
+}
+/**
+* Joins parts into one hashable string.
+*
+* `\0` rather than a space: parts are paths and specifiers, which may contain spaces, and
+* a delimiter that can occur inside a part makes two different tuples hash identically.
+*/
+function hashParts(parts) {
+	return stableHash(parts.join("\0"));
+}
+//#endregion
+//#region src/errors.ts
+var ArchWallError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = new.target.name;
+	}
+};
+var IrVersionMismatchError = class extends ArchWallError {
+	graphVersion;
+	coreVersion;
+	constructor(graphVersion, coreVersion) {
+		super(`Incompatible graph IR: adapter produced irVersion ${graphVersion}, but @archwall/core supports ${coreVersion} (majors must match). Upgrade the adapter or core so their IR majors align.`);
+		this.graphVersion = graphVersion;
+		this.coreVersion = coreVersion;
+	}
+};
+//#endregion
+//#region src/graph/ir.ts
+/** Semver of the Project Graph IR schema itself, independent of package versions. */
+const IR_VERSION = "1.0.0";
+/** The schemes {@link ModuleId} recognises. */
+const MODULE_ID_SCHEMES = [
+	"file",
+	"pkg",
+	"builtin",
+	"virtual",
+	"unresolved"
+];
+const SCHEME_OF = /^(file|pkg|builtin|virtual|unresolved):/;
+/**
+* Splits a canonical id into its scheme and body, or null when it carries no known scheme.
+*
+* Null is a legitimate answer, not an error: in-memory graphs (`@archwall/test-utils`, a
+* playground) use bare ids, and every consumer here degrades to treating the id as opaque.
+*/
+function parseModuleId(id) {
+	const m = SCHEME_OF.exec(id);
+	if (!m) return null;
+	const scheme = m[1];
+	return {
+		scheme,
+		body: id.slice(scheme.length + 1)
+	};
+}
+/**
+* The id as a human should read it: the path, the package name, the builtin specifier.
+*
+* Used by every reporter and offered to rules as `RuleContext.display`, so that a message names
+* `src/domain/rules.ts` and `react` rather than a scheme-prefixed id — or, as before canonical
+* ids existed, an absolute path from whichever machine produced the graph.
+*
+* `virtual:` keeps its prefix: it is not a path, and the prefix is the only thing that says so.
+*/
+function displayModuleId(id) {
+	const parsed = parseModuleId(id);
+	if (parsed === null || parsed.scheme === "virtual") return id;
+	return parsed.body;
+}
+/** Code the project owns and can change — including sibling packages in the monorepo. */
+const FIRST_PARTY_KINDS = ["source", "workspace"];
+/** A dependency the project does not own: third-party code or a runtime builtin. */
+const THIRD_PARTY_KINDS = ["package", "builtin"];
+function isFirstParty(kind) {
+	return kind === "source" || kind === "workspace";
+}
+function isThirdParty(kind) {
+	return kind === "package" || kind === "builtin";
+}
+/**
+* The module graph, as an OPAQUE handle.
+*
+* The backing stores are private and no accessor hands them out. Everything a consumer
+* legitimately needs is a method here or on `GraphQuery`; if something is missing, the fix
+* is to add a method, never to expose the store.
+*
+* That is what keeps the *representation* out of the IR contract: a `ReadonlyMap` plus an
+* `Edge[]` is the current implementation, not the promise.
+*/
+var ProjectGraph = class ProjectGraph {
+	irVersion;
+	host;
+	delivery;
+	#modules;
+	#edges;
+	constructor(irVersion, host, delivery, modules, edges) {
+		this.irVersion = irVersion;
+		this.host = host;
+		this.delivery = delivery;
+		this.#modules = modules;
+		this.#edges = edges;
+	}
+	static create(init) {
+		const modules = init.modules instanceof Map ? init.modules : new Map(init.modules);
+		return new ProjectGraph(init.irVersion ?? "1.0.0", init.host, init.delivery ?? "complete", modules, init.edges);
+	}
+	get moduleCount() {
+		return this.#modules.size;
+	}
+	get edgeCount() {
+		return this.#edges.length;
+	}
+	module(id) {
+		return this.#modules.get(id);
+	}
+	hasModule(id) {
+		return this.#modules.has(id);
+	}
+	/** Every module, in graph order. */
+	modules() {
+		return this.#modules.values();
+	}
+	/** Every module id, in graph order. */
+	moduleIds() {
+		return this.#modules.keys();
+	}
+	/** Every edge, in graph order. Never copy this — it is already immutable. */
+	edges() {
+		return this.#edges;
+	}
+	/**
+	* A new graph with replaced stores, same identity fields.
+	*
+	* @internal Engine and {@link GraphDraft} only. Not part of the IR contract.
+	*/
+	replaceStores(modules, edges) {
+		return new ProjectGraph(this.irVersion, this.host, this.delivery, modules, edges ?? this.#edges);
+	}
+};
+/**
+* Copy-on-write {@link GraphMutation} over a {@link ProjectGraph}.
+*
+* A transform that touches nothing costs nothing: the stores are only cloned on the first
+* write, and `commit()` returns the original graph when there were none.
+*
+* @internal
+*/
+var GraphDraft = class {
+	#base;
+	#modules;
+	#edges;
+	constructor(base) {
+		this.#base = base;
+	}
+	#mutableModules() {
+		if (this.#modules === void 0) {
+			this.#modules = /* @__PURE__ */ new Map();
+			for (const m of this.#base.modules()) this.#modules.set(m.id, m);
+		}
+		return this.#modules;
+	}
+	#mutableEdges() {
+		this.#edges ??= [...this.#base.edges()];
+		return this.#edges;
+	}
+	module(id) {
+		return this.#modules ? this.#modules.get(id) : this.#base.module(id);
+	}
+	hasModule(id) {
+		return this.#modules ? this.#modules.has(id) : this.#base.hasModule(id);
+	}
+	modules() {
+		return this.#modules ? this.#modules.values() : this.#base.modules();
+	}
+	edges() {
+		return this.#edges ?? this.#base.edges();
+	}
+	addModule(node) {
+		this.#mutableModules().set(node.id, node);
+	}
+	patchModule(id, patch) {
+		const current = this.module(id);
+		if (current === void 0) return;
+		const { tags: tagPatch, ...rest } = patch;
+		const next = {
+			...current,
+			...rest
+		};
+		if (tagPatch !== void 0) {
+			const tags = new Map(current.tags);
+			for (const [k, v] of Object.entries(tagPatch)) tags.set(k, v);
+			next.tags = tags;
+		}
+		this.#mutableModules().set(id, next);
+	}
+	addEdge(edge) {
+		this.#mutableEdges().push(edge);
+	}
+	removeEdges(predicate) {
+		const kept = this.edges().filter((e) => !predicate(e));
+		if (kept.length !== this.edges().length) this.#edges = kept;
+	}
+	/** The resulting graph, or the untouched original when nothing was written. */
+	commit() {
+		if (this.#modules === void 0 && this.#edges === void 0) return this.#base;
+		const modules = this.#modules ?? new Map([...this.#base.modules()].map((m) => [m.id, m]));
+		return this.#base.replaceStores(modules, this.#edges);
+	}
+};
+function irMajor(version) {
+	const m = /^(\d+)\./.exec(version);
+	if (!m) throw new ArchWallError(`Malformed IR version: "${version}"`);
+	return Number(m[1]);
+}
+function assertIrCompatible(graphVersion) {
+	if (irMajor(graphVersion) !== irMajor("1.0.0")) throw new IrVersionMismatchError(graphVersion, IR_VERSION);
+}
+//#endregion
+//#region src/analysis/cache.ts
+/**
+* Memoizes graph computations per (computation, view): ten unscoped rules requesting SCCs cost
+* one traversal.
+*
+* The view is part of the key because a computation is an ENUMERATION of the graph, and
+* enumeration is scoped. A cache bound to the root query
+* would hand a rule scoped to `apps/web` the cycles of the whole repository — the rule's
+* `ctx.graph` narrowed and its `ctx.compute` silently not.
+*
+* Rules sharing a scope share the base query object, so they share the entry; the common case
+* (no scope at all) is still one evaluation for everyone.
+*/
+var GraphComputationCache = class {
+	#memo = /* @__PURE__ */ new Map();
+	get(computation, graph) {
+		let perView = this.#memo.get(graph);
+		if (perView === void 0) {
+			perView = /* @__PURE__ */ new Map();
+			this.#memo.set(graph, perView);
+		}
+		const key = computation;
+		if (perView.has(key)) return perView.get(key);
+		const value = computation.compute(graph);
+		perView.set(key, value);
+		return value;
+	}
+};
+//#endregion
+//#region src/graph/query.ts
+function matchesKind(m, want) {
+	return typeof want === "string" ? m.kind === want : want.includes(m.kind);
+}
+function matchesTags(m, want) {
+	for (const k of Object.keys(want)) if (m.tags.get(k) !== want[k]) return false;
+	return true;
+}
+const NO_EDGES = [];
+/**
+* Stable key for a filter, so the engine can bucket rules that want the same slice of the
+* graph and evaluate that slice once for all of them.
+*/
+function filterKey(filter) {
+	if (filter === void 0) return "*";
+	return JSON.stringify(filter, Object.keys(filter).sort());
+}
+/**
+* The adjacency and attribute indexes over one graph, built LAZILY per axis.
+*
+* One index serves every query over a graph, scoped or not: a scope narrows *which results
+* are returned*, and does not change what the graph contains, so it must never rebuild the
+* index of it.
+*
+* Each axis is built on first use. A run whose rules only walk edges never pays for the
+* tag, kind, and package indexes.
+*/
+var GraphIndex = class {
+	#graph;
+	#out;
+	#in;
+	#byTag;
+	#byKind;
+	#byPackage;
+	constructor(graph) {
+		this.#graph = graph;
+	}
+	#buildAdjacency() {
+		const out = /* @__PURE__ */ new Map();
+		const inn = /* @__PURE__ */ new Map();
+		for (const e of this.#graph.edges()) {
+			const o = out.get(e.from);
+			if (o) o.push(e);
+			else out.set(e.from, [e]);
+			const i = inn.get(e.to);
+			if (i) i.push(e);
+			else inn.set(e.to, [e]);
+		}
+		this.#out = out;
+		this.#in = inn;
+	}
+	outOf(id) {
+		if (this.#out === void 0) this.#buildAdjacency();
+		return this.#out?.get(id) ?? NO_EDGES;
+	}
+	into(id) {
+		if (this.#in === void 0) this.#buildAdjacency();
+		return this.#in?.get(id) ?? NO_EDGES;
+	}
+	byTag(key, value) {
+		if (this.#byTag === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const m of this.#graph.modules()) for (const [k, v] of m.tags) {
+				const bucket = `${k}\0${v}`;
+				const ids = index.get(bucket);
+				if (ids) ids.push(m.id);
+				else index.set(bucket, [m.id]);
+			}
+			this.#byTag = index;
+		}
+		return this.#byTag.get(`${key}\0${value}`) ?? [];
+	}
+	byKind(kind) {
+		if (this.#byKind === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const m of this.#graph.modules()) {
+				const bucket = index.get(m.kind);
+				if (bucket) bucket.push(m);
+				else index.set(m.kind, [m]);
+			}
+			this.#byKind = index;
+		}
+		return this.#byKind.get(kind) ?? [];
+	}
+	byPackage(name) {
+		if (this.#byPackage === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const m of this.#graph.modules()) {
+				if (m.packageName === void 0) continue;
+				const bucket = index.get(m.packageName);
+				if (bucket) bucket.push(m);
+				else index.set(m.packageName, [m]);
+			}
+			this.#byPackage = index;
+		}
+		return this.#byPackage.get(name) ?? [];
+	}
+};
+/**
+* The only sanctioned way to read a graph.
+*
+* A scoped query is a VIEW: it shares the underlying {@link GraphIndex} with the query it
+* came from and differs only in which modules it is *about*.
+*
+* ## What scope does, exactly
+*
+* One rule: **an operation is scoped if and only if it ENUMERATES. An operation that answers a
+* question about a module you named is never scoped.**
+*
+* | Operation | Scoped |
+* |---|---|
+* | `modules`, `moduleIds`, `moduleCount`, `edges` | yes — they enumerate |
+* | `module`, `has`, `tagOf` | no — you named the module |
+* | `edgesOutOf`, `edgesInto` | no — you named the module |
+* | `reachableFrom`, `reaching`, `pathBetween` | no — traversal from a named module |
+* | `ModuleSelection.edgesOut` / `edgesIn` | anchored: endpoints in-selection, edges unfiltered |
+* | `RuleContext.compute` | yes — a computation enumerates |
+*
+* The asymmetry is deliberate rather than incidental. A scoped rule must be able to ask what an
+* out-of-scope import target *is*, because an edge leaving the scope is the most interesting
+* thing it can find; hiding the target would turn `layer-dependencies` under a scope from a
+* finding into silence.
+*/
+var GraphQuery = class GraphQuery {
+	#graph;
+	#index;
+	/** When present, the ANCHOR set: which modules this view is about. See the class doc. */
+	#scope;
+	/** Scoped `edges()` is one filter over the whole edge list; do it once, not per call. */
+	#scopedEdges;
+	constructor(graph, index, scope) {
+		this.#graph = graph;
+		this.#index = index ?? new GraphIndex(graph);
+		this.#scope = scope;
+	}
+	/** A view of the same graph restricted to `scope`, sharing this query's index. */
+	scoped(scope) {
+		return new GraphQuery(this.#graph, this.#index, scope);
+	}
+	module(id) {
+		return this.#graph.module(id);
+	}
+	/** Modules in scope, or all of them when unscoped. */
+	moduleCount() {
+		return this.#scope ? this.#scope.size : this.#graph.moduleCount;
+	}
+	/** Every in-scope module id, in graph order. The traversal primitive. */
+	moduleIds() {
+		if (!this.#scope) return this.#graph.moduleIds();
+		const scope = this.#scope;
+		return (function* (ids) {
+			for (const id of ids) if (scope.has(id)) yield id;
+		})(this.#graph.moduleIds());
+	}
+	/** Whether the graph contains this module at all — distinct from "is it a source file". */
+	has(id) {
+		return this.#graph.hasModule(id);
+	}
+	tagOf(id, key) {
+		return this.#graph.module(id)?.tags.get(key);
+	}
+	modules(filter) {
+		let candidates;
+		const tagEntries = filter?.tag ? Object.entries(filter.tag) : [];
+		if (tagEntries.length > 0) {
+			const sets = tagEntries.map(([k, v]) => this.#index.byTag(k, v)).sort((a, b) => a.length - b.length);
+			const rest = sets.slice(1).map((ids) => new Set(ids));
+			const narrowed = [];
+			for (const id of sets[0] ?? []) {
+				if (!rest.every((s) => s.has(id))) continue;
+				const m = this.#graph.module(id);
+				if (m !== void 0) narrowed.push(m);
+			}
+			candidates = narrowed;
+		} else if (filter?.packageName !== void 0) candidates = this.#index.byPackage(filter.packageName);
+		else if (filter?.moduleKind !== void 0) {
+			const kinds = typeof filter.moduleKind === "string" ? [filter.moduleKind] : filter.moduleKind;
+			candidates = kinds.length === 1 ? this.#index.byKind(kinds[0]) : kinds.flatMap((k) => this.#index.byKind(k));
+		} else candidates = this.#graph.modules();
+		const nodes = [];
+		for (const m of candidates) {
+			if (this.#scope !== void 0 && !this.#scope.has(m.id)) continue;
+			if (filter?.moduleKind !== void 0 && !matchesKind(m, filter.moduleKind)) continue;
+			if (filter?.packageName !== void 0 && m.packageName !== filter.packageName) continue;
+			nodes.push(m);
+		}
+		return new Selection(this, nodes);
+	}
+	/**
+	* In-scope edges matching `filter`.
+	*
+	* Returns the graph's own array when nothing narrows it — it is already immutable, so a
+	* defensive copy per call would protect nobody and cost a full edge list per rule.
+	*/
+	edges(filter) {
+		let all;
+		if (this.#scope === void 0) all = this.#graph.edges();
+		else {
+			const scope = this.#scope;
+			this.#scopedEdges ??= this.#graph.edges().filter((e) => scope.has(e.from));
+			all = this.#scopedEdges;
+		}
+		return this.filterEdges(all, filter);
+	}
+	edgesOutOf(id) {
+		return this.#index.outOf(id);
+	}
+	edgesInto(id) {
+		return this.#index.into(id);
+	}
+	/**
+	* Every module reachable from `id` by following edges, excluding `id` itself unless a
+	* cycle leads back to it. Iterative: a 10k-module chain would overflow the stack.
+	*/
+	reachableFrom(id, filter) {
+		const seen = /* @__PURE__ */ new Set();
+		const stack = [id];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			for (const e of this.filterEdges(this.edgesOutOf(current), filter)) {
+				if (seen.has(e.to)) continue;
+				seen.add(e.to);
+				stack.push(e.to);
+			}
+		}
+		return seen;
+	}
+	/** The mirror of {@link reachableFrom}: everything that can reach `id`. */
+	reaching(id, filter) {
+		const seen = /* @__PURE__ */ new Set();
+		const stack = [id];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			for (const e of this.filterEdges(this.edgesInto(current), filter)) {
+				if (seen.has(e.from)) continue;
+				seen.add(e.from);
+				stack.push(e.from);
+			}
+		}
+		return seen;
+	}
+	/**
+	* Shortest dependency path from `from` to `to`, inclusive of both, or null. BFS, because
+	* the useful evidence for "domain reaches infrastructure" is the shortest chain, not
+	* whichever one a traversal happened to find first.
+	*/
+	pathBetween(from, to, filter) {
+		if (from === to) return [from];
+		const previous = /* @__PURE__ */ new Map();
+		const queue = [from];
+		const seen = /* @__PURE__ */ new Set([from]);
+		for (let i = 0; i < queue.length; i++) {
+			const current = queue[i];
+			for (const e of this.filterEdges(this.edgesOutOf(current), filter)) {
+				if (seen.has(e.to)) continue;
+				seen.add(e.to);
+				previous.set(e.to, current);
+				if (e.to === to) {
+					const path = [to];
+					for (let at = to; previous.has(at);) {
+						at = previous.get(at);
+						path.push(at);
+					}
+					return path.reverse();
+				}
+				queue.push(e.to);
+			}
+		}
+		return null;
+	}
+	/** Applies an {@link EdgeFilter} to an edge list. Returns the input when there is none. */
+	filterEdges(edges, filter) {
+		if (!filter) return edges;
+		return edges.filter((e) => this.matchesEdge(e, filter));
+	}
+	/** Whether one edge satisfies a filter. The unit the engine's visitor dispatch uses. */
+	matchesEdge(e, filter) {
+		if (filter.kind !== void 0 && e.kind !== filter.kind) return false;
+		const from = this.#graph.module(e.from);
+		const to = this.#graph.module(e.to);
+		if (filter.toModuleKind !== void 0 && (!to || !matchesKind(to, filter.toModuleKind))) return false;
+		if (filter.fromTag && (!from || !matchesTags(from, filter.fromTag))) return false;
+		if (filter.toTag && (!to || !matchesTags(to, filter.toTag))) return false;
+		if (filter.crossing !== void 0) {
+			const a = from?.tags.get(filter.crossing);
+			const b = to?.tags.get(filter.crossing);
+			if (a === void 0 || b === void 0 || a === b) return false;
+		}
+		return true;
+	}
+	/** Whether one module satisfies a filter. Paired with {@link matchesEdge}. */
+	matchesModule(m, filter) {
+		if (filter.tag && !matchesTags(m, filter.tag)) return false;
+		if (filter.moduleKind !== void 0 && !matchesKind(m, filter.moduleKind)) return false;
+		if (filter.packageName !== void 0 && m.packageName !== filter.packageName) return false;
+		return true;
+	}
+};
+var Selection = class Selection {
+	query;
+	nodes;
+	constructor(query, nodes) {
+		this.query = query;
+		this.nodes = nodes;
+	}
+	[Symbol.iterator]() {
+		return this.nodes[Symbol.iterator]();
+	}
+	get size() {
+		return this.nodes.length;
+	}
+	isEmpty() {
+		return this.nodes.length === 0;
+	}
+	toArray() {
+		return this.nodes;
+	}
+	ids() {
+		return this.nodes.map((m) => m.id);
+	}
+	forEach(fn) {
+		this.nodes.forEach(fn);
+	}
+	filter(predicate) {
+		return new Selection(this.query, this.nodes.filter(predicate));
+	}
+	edgesOut(filter) {
+		const all = this.nodes.flatMap((m) => this.query.edgesOutOf(m.id));
+		return this.query.filterEdges(all, filter);
+	}
+	edgesIn(filter) {
+		const all = this.nodes.flatMap((m) => this.query.edgesInto(m.id));
+		return this.query.filterEdges(all, filter);
+	}
+};
+//#endregion
+//#region src/engine/prepare.ts
+/**
+* The one pipeline: project boundary → transforms → boundary again → classification.
+*
+* The boundary belongs to the ENGINE, not to producers: producers are the component that
+* varies, so anything that must be identical across hosts cannot live in them. Producers
+* over-collect; the engine trims.
+*
+* It runs twice because a transform may ADD modules, and those must be bounded exactly as
+* if a producer had supplied them. Running it again is safe because it is idempotent — it
+* only ever re-kinds `source` → `excluded`. With no transforms configured, boundary and
+* classification are one fused pass over the modules.
+*
+* Excluded modules are re-kinded, never deleted. An edge *into* an excluded file still says
+* something true about the architecture, and deleting the node would silently rewrite the
+* graph's shape (a cycle through a test helper would vanish).
+*/
+function prepareGraph(graph, config, transforms, classifiers) {
+	const diagnostics = [];
+	const provided = [];
+	let current = graph;
+	if (transforms.length > 0) {
+		current = boundaryAndClassify(current, config, []);
+		const ctx = {
+			sourceRoot: config.sourceRoot,
+			repoRoot: config.repoRoot,
+			relative: (file) => sourceRelative(config.sourceRoot, file)
+		};
+		for (const t of transforms) {
+			const draft = new GraphDraft(current);
+			try {
+				t.transform(draft, ctx);
+				current = draft.commit();
+				for (const c of t.provides ?? []) provided.push(c);
+			} catch (err) {
+				diagnostics.push({
+					code: "transform-failed",
+					severity: "error",
+					message: `Graph transform "${t.name}" threw and was skipped: ${err instanceof Error ? err.message : String(err)}`,
+					...err instanceof Error && err.stack !== void 0 ? { details: { stack: err.stack } } : {}
+				});
+			}
+		}
+	}
+	return {
+		graph: boundaryAndClassify(current, config, classifiers),
+		diagnostics,
+		provided
+	};
+}
+/**
+* One pass over the modules applying both the boundary and classification.
+*
+* They do not interact — the boundary decides `kind` from the file path alone, and
+* classification decides `tags` from the node — so one pass serves both, halving the
+* per-run allocation. At 50k modules a second pass would mean another 50k node copies and
+* 50k tag Maps on every watch rebuild.
+*
+* Two further allocations are avoided: a module whose kind is unchanged AND that no
+* classifier tagged is passed through by reference, and the tag map is cloned only when a
+* classifier actually contributes something.
+*/
+function boundaryAndClassify(graph, config, classifiers) {
+	const isIncluded = (0, picomatch.default)(config.include, { dot: true });
+	const isExcluded = (0, picomatch.default)(config.exclude, { dot: true });
+	const ctx = {
+		sourceRoot: config.sourceRoot,
+		relative: (file) => sourceRelative(config.sourceRoot, file)
+	};
+	const modules = /* @__PURE__ */ new Map();
+	for (const m of graph.modules()) {
+		let node = m;
+		if (m.kind === "source" && m.file !== null) {
+			const rel = sourceRelative(config.sourceRoot, m.file);
+			if (rel === null || !isIncluded(rel) || isExcluded(rel)) node = {
+				...m,
+				kind: "excluded"
+			};
+		}
+		let tags;
+		for (const classifier of classifiers) {
+			const patch = classifier.classify(node, ctx);
+			if (!patch) continue;
+			tags ??= new Map(node.tags);
+			for (const [k, v] of Object.entries(patch)) tags.set(k, v);
+		}
+		modules.set(m.id, tags === void 0 ? node : {
+			...node,
+			tags
+		});
+	}
+	return graph.replaceStores(modules);
+}
+/**
+* The project boundary on its own, for callers that want kinds settled without tagging.
+* One implementation, shared with {@link prepareGraph}.
+*/
+function applyProjectBoundary(graph, config) {
+	return boundaryAndClassify(graph, config, []);
+}
+//#endregion
+Object.defineProperty(exports, "ArchWallError", {
+	enumerable: true,
+	get: function() {
+		return ArchWallError;
+	}
+});
+Object.defineProperty(exports, "FIRST_PARTY_KINDS", {
+	enumerable: true,
+	get: function() {
+		return FIRST_PARTY_KINDS;
+	}
+});
+Object.defineProperty(exports, "GraphComputationCache", {
+	enumerable: true,
+	get: function() {
+		return GraphComputationCache;
+	}
+});
+Object.defineProperty(exports, "GraphDraft", {
+	enumerable: true,
+	get: function() {
+		return GraphDraft;
+	}
+});
+Object.defineProperty(exports, "GraphIndex", {
+	enumerable: true,
+	get: function() {
+		return GraphIndex;
+	}
+});
+Object.defineProperty(exports, "GraphQuery", {
+	enumerable: true,
+	get: function() {
+		return GraphQuery;
+	}
+});
+Object.defineProperty(exports, "IR_VERSION", {
+	enumerable: true,
+	get: function() {
+		return IR_VERSION;
+	}
+});
+Object.defineProperty(exports, "IrVersionMismatchError", {
+	enumerable: true,
+	get: function() {
+		return IrVersionMismatchError;
+	}
+});
+Object.defineProperty(exports, "MODULE_ID_SCHEMES", {
+	enumerable: true,
+	get: function() {
+		return MODULE_ID_SCHEMES;
+	}
+});
+Object.defineProperty(exports, "ProjectGraph", {
+	enumerable: true,
+	get: function() {
+		return ProjectGraph;
+	}
+});
+Object.defineProperty(exports, "THIRD_PARTY_KINDS", {
+	enumerable: true,
+	get: function() {
+		return THIRD_PARTY_KINDS;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "applyProjectBoundary", {
+	enumerable: true,
+	get: function() {
+		return applyProjectBoundary;
+	}
+});
+Object.defineProperty(exports, "assertIrCompatible", {
+	enumerable: true,
+	get: function() {
+		return assertIrCompatible;
+	}
+});
+Object.defineProperty(exports, "displayModuleId", {
+	enumerable: true,
+	get: function() {
+		return displayModuleId;
+	}
+});
+Object.defineProperty(exports, "filterKey", {
+	enumerable: true,
+	get: function() {
+		return filterKey;
+	}
+});
+Object.defineProperty(exports, "hashParts", {
+	enumerable: true,
+	get: function() {
+		return hashParts;
+	}
+});
+Object.defineProperty(exports, "irMajor", {
+	enumerable: true,
+	get: function() {
+		return irMajor;
+	}
+});
+Object.defineProperty(exports, "isFirstParty", {
+	enumerable: true,
+	get: function() {
+		return isFirstParty;
+	}
+});
+Object.defineProperty(exports, "isThirdParty", {
+	enumerable: true,
+	get: function() {
+		return isThirdParty;
+	}
+});
+Object.defineProperty(exports, "parseModuleId", {
+	enumerable: true,
+	get: function() {
+		return parseModuleId;
+	}
+});
+Object.defineProperty(exports, "prepareGraph", {
+	enumerable: true,
+	get: function() {
+		return prepareGraph;
+	}
+});
+Object.defineProperty(exports, "sourceRelative", {
+	enumerable: true,
+	get: function() {
+		return sourceRelative;
+	}
+});
+Object.defineProperty(exports, "stableHash", {
+	enumerable: true,
+	get: function() {
+		return stableHash;
+	}
+});
+Object.defineProperty(exports, "toRelative", {
+	enumerable: true,
+	get: function() {
+		return toRelative;
+	}
+});
+
+//# sourceMappingURL=prepare-C1FfL8Qd.cjs.map