@archwall/core 0.1.0 → 0.2.1

package/dist/{transform-CnUPOO0E.d.mts → transform-CzxyWbUC.d.cts}

@@ -54,7 +54,16 @@ type WellKnownCapability =
  * that matches on specifiers must require this, or it silently matches nothing on hosts
  * that cannot supply them and reports a clean run rather than an unavailable one.
  */
-"raw-specifiers";
+"raw-specifiers" |
+/**
+ * Type-only edges are PRESENT and carry `attributes.typeOnly`. See {@link EdgeAttributes}.
+ *
+ * A rule that treats type-only imports differently must require this. Without it, a host
+ * that erases type imports (every bundler does) is indistinguishable from one where the
+ * code genuinely has no type imports — and "no `attributes.typeOnly` anywhere" would be
+ * read as "nothing is type-only" rather than "nobody asked".
+ */
+"type-only-edges";
 /**
  * Open union: adapters may declare capabilities core does not know about, and rules may
  * require them, without an IR major. `WellKnownCapability` keeps autocomplete useful for
@@ -75,11 +84,44 @@ interface SourceLocation {
 }
 type WellKnownEdgeKind = "static" | "dynamic" | "reexport";
 /**
- * Open union so future graph facts (CSS imports, worker edges, type-only edges) arrive
- * additively. Consumers must treat an unrecognised kind as "some dependency exists" —
- * never assume exhaustiveness.
+ * Open union so future graph facts (CSS imports, worker edges) arrive additively. Consumers
+ * must treat an unrecognised kind as "some dependency exists" — never assume exhaustiveness.
+ *
+ * `kind` answers ONE question — roughly "what syntax produced this edge" — and deliberately
+ * keeps answering only that. Everything else an edge might be belongs in
+ * {@link EdgeAttributes}; see the note there for why.
  */
 type EdgeKind = WellKnownEdgeKind | (string & {});
+/**
+ * Orthogonal facts about an edge, as an OPEN bag.
+ *
+ * `kind` is one enum, but the domain is not one-dimensional. `export type * from "./x"` is
+ * *both* a re-export and type-only; a dynamic import of a barrel is both dynamic and a
+ * re-export. Modelling those as one enum forces every producer to pick a winner, and forces
+ * every consumer to guess which axis the winner came from.
+ *
+ * So the axes split: `kind` keeps the syntactic one, and everything else lands here, where it
+ * composes. A bag rather than named fields because the next axis is always unknown — import
+ * attributes (`with { type: "json" }`), worker edges, CSS edges, `require` vs `import`
+ * interop — and each one arriving as a new top-level `Edge` field would be a new IR major.
+ *
+ * **Absent means "the host did not say", never "false".** That distinction is the whole
+ * reason {@link WellKnownCapability} has `type-only-edges`: a bundler that erased type imports
+ * before ArchWall saw them reports nothing here, and a rule must be able to tell that apart
+ * from a codebase with no type imports in it.
+ */
+interface EdgeAttributes {
+  /**
+   * The import is erased at compile time (`import type`, `export type`, or an
+   * `import { type X }` specifier where every named binding is type-only).
+   *
+   * Requires the `type-only-edges` capability to be meaningful. `true` or absent — never
+   * `false`, so that a producer cannot accidentally assert the negative it does not know.
+   */
+  typeOnly?: true;
+  /** Third parties and future core versions extend here without an IR major. */
+  [key: string]: string | true | undefined;
+}
 /**
  * What a module *is*, relative to the project being analysed.
  *
@@ -129,6 +171,8 @@ interface Edge {
   kind: EdgeKind;
   /** Present only if host capability allows. */
   loc?: SourceLocation;
+  /** Orthogonal facts; see {@link EdgeAttributes}. Absent when the host reported none. */
+  attributes?: EdgeAttributes;
 }
 type GraphDelivery = "complete" | "progressive";
 interface ProjectGraphInit {
@@ -139,6 +183,14 @@ interface ProjectGraphInit {
   edges: readonly Edge[];
   /** Default {@link IR_VERSION}. Adapters should leave this alone. */
   irVersion?: string;
+  /**
+   * Opaque identity for this graph. Defaults to a fresh process-local number.
+   *
+   * The contract is one-directional and deliberately weak: **equal revisions mean the same
+   * graph; unequal revisions mean nothing.** Set it explicitly only if you can guarantee the
+   * first half — a producer that content-hashes its inputs, for instance.
+   */
+  revision?: number;
 }
 /**
  * The module graph, as an OPAQUE handle.
@@ -155,6 +207,12 @@ declare class ProjectGraph {
   readonly irVersion: string;
   readonly host: HostInfo;
   readonly delivery: GraphDelivery;
+  /**
+   * See {@link ProjectGraphInit.revision}. Preserved across {@link replaceStores}, because a
+   * derived graph is a deterministic function of this one and the config that derived it —
+   * so a cache keyed on `(revision, configKey)` stays sound through the prepare pipeline.
+   */
+  readonly revision: number;
   private constructor();
   static create(init: ProjectGraphInit): ProjectGraph;
   get moduleCount(): number;
@@ -261,8 +319,6 @@ type Severity = "error" | "warn" | "info";
  * offending location — it has N of them, and the old model could only name one and had to
  * serialise the rest into the message string. A finding about a package, a directory, or
  * the configuration has no module at all.
- *
- * See docs/adr/0004-violation-locations.md.
  */
 type ViolationLocation = {
   type: "edge";
@@ -355,8 +411,7 @@ declare function renderMessage(template: string, data: Readonly<Record<string, s
  * Fingerprint scheme version. Bump when the algorithm changes so that a stale baseline
  * ERRORS instead of silently mismatching every entry.
  *
- * `aw3` is the first scheme over canonical module ids
- * (docs/adr/0012-canonical-module-identity.md). Before it, a violation about `react` hashed the
+ * `aw3` is the first scheme over canonical module ids. Before it, a violation about `react` hashed the
  * host's own id — a resolved `node_modules` path under the CLI, the bare specifier under esbuild
  * — so the same finding fingerprinted differently under two bundlers.
  */
@@ -405,7 +460,24 @@ type WellKnownDiagnosticCode =
 /** A configured rule, or one of its options, is deprecated. */
 "rule-deprecated" |
 /** A graph transform threw. The pipeline continued without its contribution. */
-"transform-failed";
+"transform-failed" |
+/**
+ * Files are inside the project boundary that the producer cannot read, so they are absent
+ * from the graph entirely — not excluded, not unresolved, just invisible.
+ *
+ * Only a producer that ENUMERATES a directory tree can detect this, which in practice means
+ * the CLI: a bundler adapter is handed a graph whose membership its compiler already decided.
+ */
+"unscannable-files" |
+/**
+ * The baseline lists violations this run did not produce — they were fixed, or the code
+ * they were about is gone.
+ *
+ * Worth saying out loud rather than tolerating: a baseline that is never pruned stops being
+ * "debt we accepted" and becomes a permanent hole, and the stale entry will silently
+ * re-suppress the finding if it ever comes back.
+ */
+"baseline-stale";
 type DiagnosticCode = WellKnownDiagnosticCode | (string & {});
 /**
  * Everything the run wants to say that is *not* a violation of the user's architecture: a
@@ -428,6 +500,15 @@ interface RuleSkippedDetails {
   missingCapabilities: readonly Capability[];
   host: string;
 }
+/** Payload shape for `code: "unscannable-files"`. */
+interface UnscannableFilesDetails {
+  /** How many in-boundary files the producer could not read. */
+  count: number;
+  /** Distinct extensions, most common first — what to act on. */
+  extensions: readonly string[];
+  /** A bounded sample of repo-relative paths, for a message a human can follow. */
+  sample: readonly string[];
+}
 /** Payload shape for `code: "empty-scope"`. */
 interface EmptyScopeDetails {
   /** The scope as configured, so the message can be acted on without reopening the config. */
@@ -459,6 +540,16 @@ interface EdgeFilter {
   toTag?: Record<string, string>;
   /** Tag key; keep edge iff BOTH endpoints have the tag and values differ. */
   crossing?: string;
+  /**
+   * Selects on {@link EdgeAttributes}. `true` requires the attribute present; `false` requires
+   * it ABSENT; a string requires that exact value.
+   *
+   * `false` and "absent" are the same test on purpose — attributes are never stored as `false`
+   * (see {@link EdgeAttributes}), so "not type-only" and "nobody said" are indistinguishable
+   * *here* by construction. A rule that must tell them apart declares the corresponding
+   * capability and gets skipped loudly instead, which is the only honest answer.
+   */
+  attributes?: Readonly<Record<string, string | boolean>>;
 }
 /**
  * Stable key for a filter, so the engine can bucket rules that want the same slice of the
@@ -504,7 +595,41 @@ interface ModuleSelection extends Iterable<ModuleNode> {
   edgesIn(filter?: EdgeFilter): readonly Edge[];
 }
 /**
- * The only sanctioned way to read a graph.
+ * The read surface a rule gets — and the type it should name.
+ *
+ * An INTERFACE rather than the class, because the two are different promises. What ArchWall
+ * owes a rule author is a set of questions that can be asked about a graph; what it must stay
+ * free to change is how those questions are answered. Naming the class in `RuleContext` fused
+ * the two: the concrete implementation became observable via `instanceof`, a test double became
+ * impossible to supply, and an interned or columnar store became a breaking change rather than
+ * an optimisation.
+ *
+ * {@link GraphQuery} is the only implementation core ships, and it lives in
+ * `@archwall/core/internal`. Rules never construct one — they are handed one — so nothing is
+ * taken away by that; a rule author who needs one for a TEST gets it from
+ * `@archwall/test-utils`, which is the supported way to build a graph by hand.
+ *
+ * See {@link GraphQuery} for what scope does to each of these operations.
+ */
+interface GraphView {
+  module(id: ModuleId): ModuleNode | undefined;
+  moduleCount(): number;
+  moduleIds(): Iterable<ModuleId>;
+  has(id: ModuleId): boolean;
+  tagOf(id: ModuleId, key: string): string | undefined;
+  modules(filter?: ModuleFilter): ModuleSelection;
+  edges(filter?: EdgeFilter): readonly Edge[];
+  edgesOutOf(id: ModuleId): readonly Edge[];
+  edgesInto(id: ModuleId): readonly Edge[];
+  reachableFrom(id: ModuleId, filter?: EdgeFilter): ReadonlySet<ModuleId>;
+  reaching(id: ModuleId, filter?: EdgeFilter): ReadonlySet<ModuleId>;
+  pathBetween(from: ModuleId, to: ModuleId, filter?: EdgeFilter): readonly ModuleId[] | null;
+  filterEdges(edges: readonly Edge[], filter?: EdgeFilter): readonly Edge[];
+  matchesEdge(e: Edge, filter: EdgeFilter): boolean;
+  matchesModule(m: ModuleNode, filter: ModuleFilter): boolean;
+}
+/**
+ * The only sanctioned way to read a graph; the sole implementation of {@link GraphView}.
  *
  * 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*.
@@ -528,7 +653,7 @@ interface ModuleSelection extends Iterable<ModuleNode> {
  * thing it can find; hiding the target would turn `layer-dependencies` under a scope from a
  * finding into silence.
  */
-declare class GraphQuery {
+declare class GraphQuery implements GraphView {
   #private;
   constructor(graph: ProjectGraph, index?: GraphIndex, scope?: ReadonlySet<ModuleId>);
   /** A view of the same graph restricted to `scope`, sharing this query's index. */
@@ -585,7 +710,7 @@ declare class GraphQuery {
  */
 interface GraphComputation<T> {
   name: string;
-  compute(graph: GraphQuery): T;
+  compute(graph: GraphView): T;
 }
 declare function defineGraphComputation<T>(computation: GraphComputation<T>): GraphComputation<T>;
 //#endregion
@@ -634,5 +759,5 @@ interface GraphTransform {
 }
 declare function defineTransform(transform: GraphTransform): GraphTransform;
 //#endregion
-export { THIRD_PARTY_KINDS as $, primarySourceLocation as A, GraphDelivery as B, ViolationLocation as C, locationsOf as D, fingerprintOf as E, defineClassifier as F, MODULE_ID_SCHEMES as G, GraphMutation as H, Capability as I, ModuleKind as J, ModuleId as K, Edge as L, Classifier as M, ClassifierContext as N, primaryEdge as O, TagPatch as P, SourceLocation as Q, EdgeKind as R, ViolationInput as S, countBySeverity as T, HostInfo as U, GraphDraft as V, IR_VERSION as W, ProjectGraph as X, ModuleNode as Y, ProjectGraphInit as Z, WellKnownDiagnosticCode as _, defineGraphComputation as a, isFirstParty as at, SeverityCounts as b, GraphQuery as c, filterKey as d, WellKnownCapability as et, Diagnostic as f, RuleSkippedDetails as g, EmptyScopeDetails as h, GraphComputation as i, irMajor as it, renderMessage as j, primaryModule as k, ModuleFilter as l, DiagnosticSeverity as m, TransformContext as n, assertIrCompatible as nt, EdgeFilter as o, isThirdParty as ot, DiagnosticCode as p, ModuleIdScheme as q, defineTransform as r, displayModuleId as rt, GraphIndex as s, parseModuleId as st, GraphTransform as t, WellKnownEdgeKind as tt, ModuleSelection as u, FINGERPRINT_SCHEME as v, compareViolations as w, Violation as x, Severity as y, FIRST_PARTY_KINDS as z };
-//# sourceMappingURL=transform-CnUPOO0E.d.mts.map
+export { ProjectGraph as $, primaryEdge as A, EdgeAttributes as B, Violation as C, countBySeverity as D, compareViolations as E, ClassifierContext as F, GraphMutation as G, FIRST_PARTY_KINDS as H, TagPatch as I, MODULE_ID_SCHEMES as J, HostInfo as K, defineClassifier as L, primarySourceLocation as M, renderMessage as N, fingerprintOf as O, Classifier as P, ModuleNode as Q, Capability as R, SeverityCounts as S, ViolationLocation as T, GraphDelivery as U, EdgeKind as V, GraphDraft as W, ModuleIdScheme as X, ModuleId as Y, ModuleKind as Z, RuleSkippedDetails as _, defineGraphComputation as a, assertIrCompatible as at, FINGERPRINT_SCHEME as b, GraphQuery as c, isFirstParty as ct, ModuleSelection as d, ProjectGraphInit as et, filterKey as f, EmptyScopeDetails as g, DiagnosticSeverity as h, GraphComputation as i, WellKnownEdgeKind as it, primaryModule as j, locationsOf as k, GraphView as l, isThirdParty as lt, DiagnosticCode as m, TransformContext as n, THIRD_PARTY_KINDS as nt, EdgeFilter as o, displayModuleId as ot, Diagnostic as p, IR_VERSION as q, defineTransform as r, WellKnownCapability as rt, GraphIndex as s, irMajor as st, GraphTransform as t, SourceLocation as tt, ModuleFilter as u, parseModuleId as ut, UnscannableFilesDetails as v, ViolationInput as w, Severity as x, WellKnownDiagnosticCode as y, Edge as z };
+//# sourceMappingURL=transform-CzxyWbUC.d.cts.map

package/dist/{transform-CnUPOO0E.d.cts → transform-CzxyWbUC.d.mts}

@@ -54,7 +54,16 @@ type WellKnownCapability =
  * that matches on specifiers must require this, or it silently matches nothing on hosts
  * that cannot supply them and reports a clean run rather than an unavailable one.
  */
-"raw-specifiers";
+"raw-specifiers" |
+/**
+ * Type-only edges are PRESENT and carry `attributes.typeOnly`. See {@link EdgeAttributes}.
+ *
+ * A rule that treats type-only imports differently must require this. Without it, a host
+ * that erases type imports (every bundler does) is indistinguishable from one where the
+ * code genuinely has no type imports — and "no `attributes.typeOnly` anywhere" would be
+ * read as "nothing is type-only" rather than "nobody asked".
+ */
+"type-only-edges";
 /**
  * Open union: adapters may declare capabilities core does not know about, and rules may
  * require them, without an IR major. `WellKnownCapability` keeps autocomplete useful for
@@ -75,11 +84,44 @@ interface SourceLocation {
 }
 type WellKnownEdgeKind = "static" | "dynamic" | "reexport";
 /**
- * Open union so future graph facts (CSS imports, worker edges, type-only edges) arrive
- * additively. Consumers must treat an unrecognised kind as "some dependency exists" —
- * never assume exhaustiveness.
+ * Open union so future graph facts (CSS imports, worker edges) arrive additively. Consumers
+ * must treat an unrecognised kind as "some dependency exists" — never assume exhaustiveness.
+ *
+ * `kind` answers ONE question — roughly "what syntax produced this edge" — and deliberately
+ * keeps answering only that. Everything else an edge might be belongs in
+ * {@link EdgeAttributes}; see the note there for why.
  */
 type EdgeKind = WellKnownEdgeKind | (string & {});
+/**
+ * Orthogonal facts about an edge, as an OPEN bag.
+ *
+ * `kind` is one enum, but the domain is not one-dimensional. `export type * from "./x"` is
+ * *both* a re-export and type-only; a dynamic import of a barrel is both dynamic and a
+ * re-export. Modelling those as one enum forces every producer to pick a winner, and forces
+ * every consumer to guess which axis the winner came from.
+ *
+ * So the axes split: `kind` keeps the syntactic one, and everything else lands here, where it
+ * composes. A bag rather than named fields because the next axis is always unknown — import
+ * attributes (`with { type: "json" }`), worker edges, CSS edges, `require` vs `import`
+ * interop — and each one arriving as a new top-level `Edge` field would be a new IR major.
+ *
+ * **Absent means "the host did not say", never "false".** That distinction is the whole
+ * reason {@link WellKnownCapability} has `type-only-edges`: a bundler that erased type imports
+ * before ArchWall saw them reports nothing here, and a rule must be able to tell that apart
+ * from a codebase with no type imports in it.
+ */
+interface EdgeAttributes {
+  /**
+   * The import is erased at compile time (`import type`, `export type`, or an
+   * `import { type X }` specifier where every named binding is type-only).
+   *
+   * Requires the `type-only-edges` capability to be meaningful. `true` or absent — never
+   * `false`, so that a producer cannot accidentally assert the negative it does not know.
+   */
+  typeOnly?: true;
+  /** Third parties and future core versions extend here without an IR major. */
+  [key: string]: string | true | undefined;
+}
 /**
  * What a module *is*, relative to the project being analysed.
  *
@@ -129,6 +171,8 @@ interface Edge {
   kind: EdgeKind;
   /** Present only if host capability allows. */
   loc?: SourceLocation;
+  /** Orthogonal facts; see {@link EdgeAttributes}. Absent when the host reported none. */
+  attributes?: EdgeAttributes;
 }
 type GraphDelivery = "complete" | "progressive";
 interface ProjectGraphInit {
@@ -139,6 +183,14 @@ interface ProjectGraphInit {
   edges: readonly Edge[];
   /** Default {@link IR_VERSION}. Adapters should leave this alone. */
   irVersion?: string;
+  /**
+   * Opaque identity for this graph. Defaults to a fresh process-local number.
+   *
+   * The contract is one-directional and deliberately weak: **equal revisions mean the same
+   * graph; unequal revisions mean nothing.** Set it explicitly only if you can guarantee the
+   * first half — a producer that content-hashes its inputs, for instance.
+   */
+  revision?: number;
 }
 /**
  * The module graph, as an OPAQUE handle.
@@ -155,6 +207,12 @@ declare class ProjectGraph {
   readonly irVersion: string;
   readonly host: HostInfo;
   readonly delivery: GraphDelivery;
+  /**
+   * See {@link ProjectGraphInit.revision}. Preserved across {@link replaceStores}, because a
+   * derived graph is a deterministic function of this one and the config that derived it —
+   * so a cache keyed on `(revision, configKey)` stays sound through the prepare pipeline.
+   */
+  readonly revision: number;
   private constructor();
   static create(init: ProjectGraphInit): ProjectGraph;
   get moduleCount(): number;
@@ -261,8 +319,6 @@ type Severity = "error" | "warn" | "info";
  * offending location — it has N of them, and the old model could only name one and had to
  * serialise the rest into the message string. A finding about a package, a directory, or
  * the configuration has no module at all.
- *
- * See docs/adr/0004-violation-locations.md.
  */
 type ViolationLocation = {
   type: "edge";
@@ -355,8 +411,7 @@ declare function renderMessage(template: string, data: Readonly<Record<string, s
  * Fingerprint scheme version. Bump when the algorithm changes so that a stale baseline
  * ERRORS instead of silently mismatching every entry.
  *
- * `aw3` is the first scheme over canonical module ids
- * (docs/adr/0012-canonical-module-identity.md). Before it, a violation about `react` hashed the
+ * `aw3` is the first scheme over canonical module ids. Before it, a violation about `react` hashed the
  * host's own id — a resolved `node_modules` path under the CLI, the bare specifier under esbuild
  * — so the same finding fingerprinted differently under two bundlers.
  */
@@ -405,7 +460,24 @@ type WellKnownDiagnosticCode =
 /** A configured rule, or one of its options, is deprecated. */
 "rule-deprecated" |
 /** A graph transform threw. The pipeline continued without its contribution. */
-"transform-failed";
+"transform-failed" |
+/**
+ * Files are inside the project boundary that the producer cannot read, so they are absent
+ * from the graph entirely — not excluded, not unresolved, just invisible.
+ *
+ * Only a producer that ENUMERATES a directory tree can detect this, which in practice means
+ * the CLI: a bundler adapter is handed a graph whose membership its compiler already decided.
+ */
+"unscannable-files" |
+/**
+ * The baseline lists violations this run did not produce — they were fixed, or the code
+ * they were about is gone.
+ *
+ * Worth saying out loud rather than tolerating: a baseline that is never pruned stops being
+ * "debt we accepted" and becomes a permanent hole, and the stale entry will silently
+ * re-suppress the finding if it ever comes back.
+ */
+"baseline-stale";
 type DiagnosticCode = WellKnownDiagnosticCode | (string & {});
 /**
  * Everything the run wants to say that is *not* a violation of the user's architecture: a
@@ -428,6 +500,15 @@ interface RuleSkippedDetails {
   missingCapabilities: readonly Capability[];
   host: string;
 }
+/** Payload shape for `code: "unscannable-files"`. */
+interface UnscannableFilesDetails {
+  /** How many in-boundary files the producer could not read. */
+  count: number;
+  /** Distinct extensions, most common first — what to act on. */
+  extensions: readonly string[];
+  /** A bounded sample of repo-relative paths, for a message a human can follow. */
+  sample: readonly string[];
+}
 /** Payload shape for `code: "empty-scope"`. */
 interface EmptyScopeDetails {
   /** The scope as configured, so the message can be acted on without reopening the config. */
@@ -459,6 +540,16 @@ interface EdgeFilter {
   toTag?: Record<string, string>;
   /** Tag key; keep edge iff BOTH endpoints have the tag and values differ. */
   crossing?: string;
+  /**
+   * Selects on {@link EdgeAttributes}. `true` requires the attribute present; `false` requires
+   * it ABSENT; a string requires that exact value.
+   *
+   * `false` and "absent" are the same test on purpose — attributes are never stored as `false`
+   * (see {@link EdgeAttributes}), so "not type-only" and "nobody said" are indistinguishable
+   * *here* by construction. A rule that must tell them apart declares the corresponding
+   * capability and gets skipped loudly instead, which is the only honest answer.
+   */
+  attributes?: Readonly<Record<string, string | boolean>>;
 }
 /**
  * Stable key for a filter, so the engine can bucket rules that want the same slice of the
@@ -504,7 +595,41 @@ interface ModuleSelection extends Iterable<ModuleNode> {
   edgesIn(filter?: EdgeFilter): readonly Edge[];
 }
 /**
- * The only sanctioned way to read a graph.
+ * The read surface a rule gets — and the type it should name.
+ *
+ * An INTERFACE rather than the class, because the two are different promises. What ArchWall
+ * owes a rule author is a set of questions that can be asked about a graph; what it must stay
+ * free to change is how those questions are answered. Naming the class in `RuleContext` fused
+ * the two: the concrete implementation became observable via `instanceof`, a test double became
+ * impossible to supply, and an interned or columnar store became a breaking change rather than
+ * an optimisation.
+ *
+ * {@link GraphQuery} is the only implementation core ships, and it lives in
+ * `@archwall/core/internal`. Rules never construct one — they are handed one — so nothing is
+ * taken away by that; a rule author who needs one for a TEST gets it from
+ * `@archwall/test-utils`, which is the supported way to build a graph by hand.
+ *
+ * See {@link GraphQuery} for what scope does to each of these operations.
+ */
+interface GraphView {
+  module(id: ModuleId): ModuleNode | undefined;
+  moduleCount(): number;
+  moduleIds(): Iterable<ModuleId>;
+  has(id: ModuleId): boolean;
+  tagOf(id: ModuleId, key: string): string | undefined;
+  modules(filter?: ModuleFilter): ModuleSelection;
+  edges(filter?: EdgeFilter): readonly Edge[];
+  edgesOutOf(id: ModuleId): readonly Edge[];
+  edgesInto(id: ModuleId): readonly Edge[];
+  reachableFrom(id: ModuleId, filter?: EdgeFilter): ReadonlySet<ModuleId>;
+  reaching(id: ModuleId, filter?: EdgeFilter): ReadonlySet<ModuleId>;
+  pathBetween(from: ModuleId, to: ModuleId, filter?: EdgeFilter): readonly ModuleId[] | null;
+  filterEdges(edges: readonly Edge[], filter?: EdgeFilter): readonly Edge[];
+  matchesEdge(e: Edge, filter: EdgeFilter): boolean;
+  matchesModule(m: ModuleNode, filter: ModuleFilter): boolean;
+}
+/**
+ * The only sanctioned way to read a graph; the sole implementation of {@link GraphView}.
  *
  * 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*.
@@ -528,7 +653,7 @@ interface ModuleSelection extends Iterable<ModuleNode> {
  * thing it can find; hiding the target would turn `layer-dependencies` under a scope from a
  * finding into silence.
  */
-declare class GraphQuery {
+declare class GraphQuery implements GraphView {
   #private;
   constructor(graph: ProjectGraph, index?: GraphIndex, scope?: ReadonlySet<ModuleId>);
   /** A view of the same graph restricted to `scope`, sharing this query's index. */
@@ -585,7 +710,7 @@ declare class GraphQuery {
  */
 interface GraphComputation<T> {
   name: string;
-  compute(graph: GraphQuery): T;
+  compute(graph: GraphView): T;
 }
 declare function defineGraphComputation<T>(computation: GraphComputation<T>): GraphComputation<T>;
 //#endregion
@@ -634,5 +759,5 @@ interface GraphTransform {
 }
 declare function defineTransform(transform: GraphTransform): GraphTransform;
 //#endregion
-export { THIRD_PARTY_KINDS as $, primarySourceLocation as A, GraphDelivery as B, ViolationLocation as C, locationsOf as D, fingerprintOf as E, defineClassifier as F, MODULE_ID_SCHEMES as G, GraphMutation as H, Capability as I, ModuleKind as J, ModuleId as K, Edge as L, Classifier as M, ClassifierContext as N, primaryEdge as O, TagPatch as P, SourceLocation as Q, EdgeKind as R, ViolationInput as S, countBySeverity as T, HostInfo as U, GraphDraft as V, IR_VERSION as W, ProjectGraph as X, ModuleNode as Y, ProjectGraphInit as Z, WellKnownDiagnosticCode as _, defineGraphComputation as a, isFirstParty as at, SeverityCounts as b, GraphQuery as c, filterKey as d, WellKnownCapability as et, Diagnostic as f, RuleSkippedDetails as g, EmptyScopeDetails as h, GraphComputation as i, irMajor as it, renderMessage as j, primaryModule as k, ModuleFilter as l, DiagnosticSeverity as m, TransformContext as n, assertIrCompatible as nt, EdgeFilter as o, isThirdParty as ot, DiagnosticCode as p, ModuleIdScheme as q, defineTransform as r, displayModuleId as rt, GraphIndex as s, parseModuleId as st, GraphTransform as t, WellKnownEdgeKind as tt, ModuleSelection as u, FINGERPRINT_SCHEME as v, compareViolations as w, Violation as x, Severity as y, FIRST_PARTY_KINDS as z };
-//# sourceMappingURL=transform-CnUPOO0E.d.cts.map
+export { ProjectGraph as $, primaryEdge as A, EdgeAttributes as B, Violation as C, countBySeverity as D, compareViolations as E, ClassifierContext as F, GraphMutation as G, FIRST_PARTY_KINDS as H, TagPatch as I, MODULE_ID_SCHEMES as J, HostInfo as K, defineClassifier as L, primarySourceLocation as M, renderMessage as N, fingerprintOf as O, Classifier as P, ModuleNode as Q, Capability as R, SeverityCounts as S, ViolationLocation as T, GraphDelivery as U, EdgeKind as V, GraphDraft as W, ModuleIdScheme as X, ModuleId as Y, ModuleKind as Z, RuleSkippedDetails as _, defineGraphComputation as a, assertIrCompatible as at, FINGERPRINT_SCHEME as b, GraphQuery as c, isFirstParty as ct, ModuleSelection as d, ProjectGraphInit as et, filterKey as f, EmptyScopeDetails as g, DiagnosticSeverity as h, GraphComputation as i, WellKnownEdgeKind as it, primaryModule as j, locationsOf as k, GraphView as l, isThirdParty as lt, DiagnosticCode as m, TransformContext as n, THIRD_PARTY_KINDS as nt, EdgeFilter as o, displayModuleId as ot, Diagnostic as p, IR_VERSION as q, defineTransform as r, WellKnownCapability as rt, GraphIndex as s, irMajor as st, GraphTransform as t, SourceLocation as tt, ModuleFilter as u, parseModuleId as ut, UnscannableFilesDetails as v, ViolationInput as w, Severity as x, WellKnownDiagnosticCode as y, Edge as z };
+//# sourceMappingURL=transform-CzxyWbUC.d.mts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archwall/core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Graph IR, analysis engine, and rule/preset/reporter contracts for ArchWall.",
   "license": "MIT",
   "repository": {
@@ -27,8 +27,14 @@
     }
   },
   "exports": {
-    ".": "./src/index.ts",
-    "./internal": "./src/internal.ts",
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./internal": {
+      "import": "./dist/internal.mjs",
+      "require": "./dist/internal.cjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -51,4 +57,4 @@
   "devDependencies": {
     "@types/picomatch": "^4.0.3"
   }
-}
+}