@goodbones/core 0.1.0-beta.1

package/src/core/patterns.ts

@@ -0,0 +1,116 @@
+import * as Result from "effect/Result";
+
+import { patternsOf } from "../domain/architecture-config.js";
+import { PatternInvalid } from "../domain/architecture-error.js";
+
+const BACKREFERENCE = /\$([1-9])/g;
+
+// Validation-only stand-in so `new RegExp` sees a syntactically complete pattern
+// where a backreference will later be spliced.
+const withPlaceholderCaptures = (pattern: string): string => pattern.replaceAll(BACKREFERENCE, "x");
+
+const compilePattern = (
+  ruleName: string,
+  field: string,
+  pattern: string,
+): Result.Result<RegExp, PatternInvalid> => {
+  try {
+    return Result.succeed(new RegExp(pattern));
+  } catch (cause) {
+    return Result.fail(new PatternInvalid({ ruleName, field, pattern, detail: String(cause) }));
+  }
+};
+
+export const compilePatterns = (
+  ruleName: string,
+  field: string,
+  patterns: string | ReadonlyArray<string> | undefined,
+): Result.Result<ReadonlyArray<RegExp>, PatternInvalid> => {
+  const sources = patterns === undefined ? [] : patternsOf(patterns);
+  const compiled: Array<RegExp> = [];
+  for (const source of sources) {
+    const one = compilePattern(ruleName, field, source);
+    if (Result.isFailure(one)) return Result.fail(one.failure);
+    compiled.push(one.success);
+  }
+  return Result.succeed(compiled);
+};
+
+// Target patterns are compiled per edge (a `$1` is only known once the `from`
+// side has matched), so they are validated separately at load. A typo in a
+// `toNot` must fail the config, not lie dormant until some file happens to
+// select the rule.
+export const validateTargetPatterns = (
+  ruleName: string,
+  fields: ReadonlyArray<readonly [string, string | ReadonlyArray<string> | undefined]>,
+): Result.Result<void, PatternInvalid> => {
+  for (const [field, patterns] of fields) {
+    const validated = compilePatterns(
+      ruleName,
+      field,
+      patterns === undefined ? undefined : patternsOf(patterns).map(withPlaceholderCaptures),
+    );
+    if (Result.isFailure(validated)) return Result.fail(validated.failure);
+  }
+  return Result.succeed(undefined);
+};
+
+export const sourcesOf = (
+  patterns: string | ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> => (patterns === undefined ? [] : [...patternsOf(patterns)]);
+
+// A capture is one path segment from the importer, spliced into a target
+// pattern as `$1`. It is data, not pattern syntax: a folder named `my.module`
+// must match itself, not "my" plus any character plus "module".
+const REGEX_METACHARACTER = /[.*+?^${}()|[\]\\]/g;
+
+const substitute = (pattern: string, captures: RegExpExecArray): string =>
+  pattern.replaceAll(BACKREFERENCE, (whole, index: string) => {
+    const capture = captures[Number(index)];
+    return capture === undefined ? whole : capture.replace(REGEX_METACHARACTER, "\\$&");
+  });
+
+const targetCache = new Map<string, RegExp>();
+
+const compiledTarget = (pattern: string): RegExp => {
+  const cached = targetCache.get(pattern);
+  if (cached !== undefined) return cached;
+  const compiled = new RegExp(pattern);
+  targetCache.set(pattern, compiled);
+  return compiled;
+};
+
+export const matchesAny = (
+  patterns: ReadonlyArray<string>,
+  captures: RegExpExecArray,
+  value: string,
+): boolean => patterns.some((pattern) => compiledTarget(substitute(pattern, captures)).test(value));
+
+export type Selectable = {
+  readonly from: ReadonlyArray<RegExp>;
+  readonly fromNot: ReadonlyArray<RegExp>;
+};
+
+export const firstFromMatch = (rule: Selectable, importer: string): RegExpExecArray | null => {
+  if (rule.fromNot.some((pattern) => pattern.test(importer))) return null;
+  for (const pattern of rule.from) {
+    const captures = pattern.exec(importer);
+    if (captures !== null) return captures;
+  }
+  return null;
+};
+
+export type Targeted = Selectable & {
+  readonly to: ReadonlyArray<string>;
+  readonly toNot: ReadonlyArray<string>;
+};
+
+export const targetAllowed = (
+  rule: Targeted,
+  captures: RegExpExecArray,
+  targetPath: string,
+): boolean => {
+  if (rule.to.length > 0 && !matchesAny(rule.to, captures, targetPath)) return false;
+  if (rule.toNot.length > 0 && matchesAny(rule.toNot, captures, targetPath)) return false;
+  return true;
+};

package/src/core/structure.ts

@@ -0,0 +1,349 @@
+import * as Result from "effect/Result";
+
+import type {
+  StructureConfig,
+  StructureFolder,
+  StructureNaming,
+  StructureParity,
+  StructureRoot,
+} from "../domain/architecture-config.js";
+import type { PatternInvalid } from "../domain/architecture-error.js";
+import type { Violation } from "../domain/violation.js";
+import type { FileSystem } from "../ports/file-system.js";
+import { compilePatterns } from "./patterns.js";
+
+export type CompiledStructureRoot = {
+  readonly name: string;
+  readonly message: string;
+  readonly path: ReadonlyArray<RegExp>;
+  readonly probe: string;
+};
+
+export type CompiledStructureFolder = {
+  readonly name: string;
+  readonly message: string;
+  readonly folder: ReadonlyArray<RegExp>;
+  readonly files: ReadonlyArray<RegExp>;
+  readonly probe: string;
+};
+
+export type CompiledStructureParity = {
+  readonly name: string;
+  readonly message: string;
+  readonly file: ReadonlyArray<RegExp>;
+  readonly fileNot: ReadonlyArray<RegExp>;
+  readonly requires: ReadonlyArray<string>;
+  readonly probe: string;
+};
+
+export type CompiledStructureNaming = {
+  readonly name: string;
+  readonly message: string;
+  readonly file: ReadonlyArray<RegExp>;
+  readonly fileNot: ReadonlyArray<RegExp>;
+  readonly subject: number;
+  readonly convention: RegExp | null;
+  readonly sameAs: number | null;
+  readonly probe: string;
+};
+
+export type CompiledStructure = {
+  readonly roots: ReadonlyArray<CompiledStructureRoot>;
+  readonly folders: ReadonlyArray<CompiledStructureFolder>;
+  readonly parity: ReadonlyArray<CompiledStructureParity>;
+  readonly naming: ReadonlyArray<CompiledStructureNaming>;
+};
+
+export const EMPTY_STRUCTURE: CompiledStructure = {
+  roots: [],
+  folders: [],
+  parity: [],
+  naming: [],
+};
+
+const compileRoot = (rule: StructureRoot): Result.Result<CompiledStructureRoot, PatternInvalid> => {
+  const path = compilePatterns(rule.name, "path", rule.path);
+  if (Result.isFailure(path)) return Result.fail(path.failure);
+  return Result.succeed({
+    name: rule.name,
+    message: rule.message,
+    path: path.success,
+    probe: rule.probe.path,
+  });
+};
+
+const compileFolder = (
+  rule: StructureFolder,
+): Result.Result<CompiledStructureFolder, PatternInvalid> => {
+  const folder = compilePatterns(rule.name, "folder", rule.folder);
+  if (Result.isFailure(folder)) return Result.fail(folder.failure);
+  const files = compilePatterns(rule.name, "files", rule.files);
+  if (Result.isFailure(files)) return Result.fail(files.failure);
+  return Result.succeed({
+    name: rule.name,
+    message: rule.message,
+    folder: folder.success,
+    files: files.success,
+    probe: rule.probe.path,
+  });
+};
+
+const compileParity = (
+  rule: StructureParity,
+): Result.Result<CompiledStructureParity, PatternInvalid> => {
+  const file = compilePatterns(rule.name, "file", rule.file);
+  if (Result.isFailure(file)) return Result.fail(file.failure);
+  const fileNot = compilePatterns(rule.name, "fileNot", rule.fileNot);
+  if (Result.isFailure(fileNot)) return Result.fail(fileNot.failure);
+  return Result.succeed({
+    name: rule.name,
+    message: rule.message,
+    file: file.success,
+    fileNot: fileNot.success,
+    requires: [...rule.requires],
+    probe: rule.probe.path,
+  });
+};
+
+const compileNaming = (
+  rule: StructureNaming,
+): Result.Result<CompiledStructureNaming, PatternInvalid> => {
+  const file = compilePatterns(rule.name, "file", rule.file);
+  if (Result.isFailure(file)) return Result.fail(file.failure);
+  const fileNot = compilePatterns(rule.name, "fileNot", rule.fileNot);
+  if (Result.isFailure(fileNot)) return Result.fail(fileNot.failure);
+  const convention = compilePatterns(rule.name, "convention", rule.convention);
+  if (Result.isFailure(convention)) return Result.fail(convention.failure);
+  return Result.succeed({
+    name: rule.name,
+    message: rule.message,
+    file: file.success,
+    fileNot: fileNot.success,
+    subject: rule.subject,
+    convention: convention.success[0] ?? null,
+    sameAs: rule.sameAs ?? null,
+    probe: rule.probe.path,
+  });
+};
+
+const compileAll = <A, B>(
+  items: ReadonlyArray<A>,
+  compile: (item: A) => Result.Result<B, PatternInvalid>,
+): Result.Result<ReadonlyArray<B>, PatternInvalid> => {
+  const compiled: Array<B> = [];
+  for (const item of items) {
+    const one = compile(item);
+    if (Result.isFailure(one)) return Result.fail(one.failure);
+    compiled.push(one.success);
+  }
+  return Result.succeed(compiled);
+};
+
+export const compileStructure = (
+  config: StructureConfig | undefined,
+): Result.Result<CompiledStructure, PatternInvalid> => {
+  if (config === undefined) return Result.succeed(EMPTY_STRUCTURE);
+
+  const roots = compileAll(config.roots ?? [], compileRoot);
+  if (Result.isFailure(roots)) return Result.fail(roots.failure);
+  const folders = compileAll(config.folders ?? [], compileFolder);
+  if (Result.isFailure(folders)) return Result.fail(folders.failure);
+  const parity = compileAll(config.parity ?? [], compileParity);
+  if (Result.isFailure(parity)) return Result.fail(parity.failure);
+  const naming = compileAll(config.naming ?? [], compileNaming);
+  if (Result.isFailure(naming)) return Result.fail(naming.failure);
+
+  return Result.succeed({
+    roots: roots.success,
+    folders: folders.success,
+    parity: parity.success,
+    naming: naming.success,
+  });
+};
+
+const anyMatches = (patterns: ReadonlyArray<RegExp>, value: string): boolean =>
+  patterns.some((pattern) => pattern.test(value));
+
+const dirnameOf = (file: string): string => {
+  const cut = file.lastIndexOf("/");
+  return cut === -1 ? "" : file.slice(0, cut);
+};
+
+const basenameOf = (file: string): string => file.slice(file.lastIndexOf("/") + 1);
+
+// `{base}` is the filename minus its FINAL extension — `create-todo.handler` for
+// `create-todo.handler.ts`, `handler` for `handler.go` — so `{base}.test.ts` or
+// `{base}_test.go` names the sibling test. The dot-delimited stereotype stays
+// part of the base on purpose.
+const baseOf = (basename: string): string => {
+  const cut = basename.lastIndexOf(".");
+  return cut <= 0 ? basename : basename.slice(0, cut);
+};
+
+// A `../` in a required path is resolved against the file's own folder, which is
+// how a port three folders from its adapters names them.
+const resolveSibling = (folder: string, relative: string): string => {
+  const segments = folder === "" ? [] : folder.split("/");
+  for (const segment of relative.split("/")) {
+    if (segment === "..") segments.pop();
+    else if (segment !== "." && segment !== "") segments.push(segment);
+  }
+  return segments.join("/");
+};
+
+export const requiredSiblingsOf = (
+  rule: CompiledStructureParity,
+  file: string,
+): ReadonlyArray<string> => {
+  const base = baseOf(basenameOf(file));
+  const folder = dirnameOf(file);
+  return rule.requires.map((template) =>
+    resolveSibling(folder, template.replaceAll("{base}", base)),
+  );
+};
+
+type NamingMatch = {
+  readonly subject: string;
+  readonly expected: string | null;
+  // Whether the rule asked for a comparison at all. Without this a `sameAs`
+  // naming a group the pattern never fills would fall back to "no convention"
+  // and admit every name — vacuous, in the one family added to stop that.
+  readonly comparing: boolean;
+};
+
+// The rule's pattern carries capture groups; `subject` says which one holds the
+// name being judged, and `sameAs` which one it has to equal.
+const firstNamingMatch = (rule: CompiledStructureNaming, file: string): NamingMatch | null => {
+  for (const pattern of rule.file) {
+    const found = pattern.exec(file);
+    if (found === null) continue;
+    const subject = found[rule.subject];
+    if (subject === undefined) continue;
+    return {
+      subject,
+      expected: rule.sameAs === null ? null : (found[rule.sameAs] ?? null),
+      comparing: rule.sameAs !== null,
+    };
+  }
+  return null;
+};
+
+const namingSatisfied = (rule: CompiledStructureNaming, named: NamingMatch): boolean =>
+  named.comparing
+    ? named.expected !== null && named.subject === named.expected
+    : rule.convention === null || rule.convention.test(named.subject);
+
+export const evaluateStructure = (
+  structure: CompiledStructure,
+  fileSystem: FileSystem,
+  file: string,
+): ReadonlyArray<Violation> => {
+  const violations: Array<Violation> = [];
+  const folder = dirnameOf(file);
+  const basename = basenameOf(file);
+
+  for (const rule of structure.parity) {
+    if (!anyMatches(rule.file, file) || anyMatches(rule.fileNot, file)) continue;
+    for (const sibling of requiredSiblingsOf(rule, file)) {
+      if (fileSystem.exists(sibling)) continue;
+      violations.push({
+        kind: "structure",
+        ruleName: rule.name,
+        message: rule.message,
+        file,
+        subject: sibling,
+      });
+    }
+  }
+
+  for (const rule of structure.naming) {
+    if (anyMatches(rule.fileNot, file)) continue;
+    const named = firstNamingMatch(rule, file);
+    if (named === null || namingSatisfied(rule, named)) continue;
+    violations.push({
+      kind: "structure",
+      ruleName: rule.name,
+      message: rule.message,
+      file,
+      subject: named.subject,
+    });
+  }
+
+  const governing = structure.folders.filter((rule) => anyMatches(rule.folder, folder));
+
+  if (governing.length > 0) {
+    if (!governing.some((rule) => anyMatches(rule.files, basename))) {
+      const rule = governing[0];
+      if (rule !== undefined) {
+        violations.push({
+          kind: "structure",
+          ruleName: rule.name,
+          message: rule.message,
+          file,
+          subject: basename,
+        });
+      }
+    }
+    return violations;
+  }
+
+  // No folder rule governs this folder at all. Inside a taxonomy root that means
+  // the folder itself is not part of the taxonomy — the stray-folder case a
+  // per-file check would otherwise miss entirely.
+  const root = structure.roots.find((candidate) => anyMatches(candidate.path, file));
+  if (root !== undefined) {
+    violations.push({
+      kind: "structure",
+      ruleName: root.name,
+      message: root.message,
+      file,
+      subject: folder,
+    });
+  }
+
+  return violations;
+};
+
+// A structure rule proves itself the same way the other families do: on a path
+// it must reject. Parity is checked structurally — that the rule still selects
+// its probe and still renders a sibling to demand — because asking the real
+// filesystem at config-load time would make the guard depend on a fixture.
+export const structureRulesFailingTheirProbe = (
+  structure: CompiledStructure,
+): ReadonlyArray<string> => {
+  const failing: Array<string> = [];
+
+  for (const rule of structure.naming) {
+    const named = firstNamingMatch(rule, rule.probe);
+    if (named === null || namingSatisfied(rule, named) || anyMatches(rule.fileNot, rule.probe)) {
+      failing.push(rule.name);
+    }
+  }
+
+  for (const rule of structure.parity) {
+    const selects = anyMatches(rule.file, rule.probe) && !anyMatches(rule.fileNot, rule.probe);
+    const demands = requiredSiblingsOf(rule, rule.probe).some((sibling) => sibling.length > 0);
+    if (!selects || !demands) failing.push(rule.name);
+  }
+
+  const layoutOnly = { ...structure, parity: [] };
+  const reported = (file: string): ReadonlyArray<string> =>
+    evaluateStructure(layoutOnly, { exists: () => true, readText: () => null }, file).map(
+      (violation) => violation.ruleName,
+    );
+
+  for (const rule of structure.folders) {
+    // A folder that admits any name claims its folder but states no policy, so
+    // there is nothing for a probe to demonstrate.
+    if (rule.files.some((pattern) => pattern.source === "^.*$")) continue;
+    // The rule must govern its probe's folder AND the folder's admitted set —
+    // the union of every governing rule — must still reject the basename.
+    const governs = anyMatches(rule.folder, dirnameOf(rule.probe));
+    if (!governs || reported(rule.probe).length === 0) failing.push(rule.name);
+  }
+  for (const rule of structure.roots) {
+    if (!reported(rule.probe).includes(rule.name)) failing.push(rule.name);
+  }
+
+  return failing;
+};

package/src/core/surface.ts

@@ -0,0 +1,181 @@
+import * as Result from "effect/Result";
+
+import type {
+  BindingKind,
+  DeclarationKind,
+  SurfaceProbe,
+  SurfaceRule,
+} from "../domain/architecture-config.js";
+import type { PatternInvalid } from "../domain/architecture-error.js";
+import type { ExportSite } from "../domain/facts.js";
+import type { Violation } from "../domain/violation.js";
+import type { FactExtractor } from "../ports/fact-extractor.js";
+import { compilePatterns, firstFromMatch } from "./patterns.js";
+
+export type { ExportSite } from "../domain/facts.js";
+
+// What a rule asks of the sites it speaks to. Exactly one per rule: the
+// manifest lowers a spec that names several demands into several rules.
+export type Demand =
+  | { readonly kind: "forbid" }
+  | { readonly kind: "allow"; readonly allow: ReadonlyArray<RegExp> }
+  | { readonly kind: "convention"; readonly convention: RegExp }
+  | { readonly kind: "count"; readonly min: number; readonly max: number };
+
+export type CompiledSurfaceRule = {
+  readonly name: string;
+  readonly message: string;
+  readonly from: ReadonlyArray<RegExp>;
+  readonly fromNot: ReadonlyArray<RegExp>;
+  readonly kinds: ReadonlyArray<BindingKind> | null;
+  readonly declares: ReadonlyArray<DeclarationKind> | null;
+  readonly reexport: boolean | null;
+  readonly match: ReadonlyArray<RegExp>;
+  readonly matchNot: ReadonlyArray<RegExp>;
+  readonly demand: Demand;
+  readonly probe: SurfaceProbe;
+};
+
+const demandOf = (rule: SurfaceRule): Result.Result<Demand, PatternInvalid> => {
+  if (rule.allow !== undefined) {
+    const allow = compilePatterns(rule.name, "allow", rule.allow);
+    if (Result.isFailure(allow)) return Result.fail(allow.failure);
+    return Result.succeed({ kind: "allow", allow: allow.success });
+  }
+  if (rule.convention !== undefined) {
+    const convention = compilePatterns(rule.name, "convention", rule.convention);
+    if (Result.isFailure(convention)) return Result.fail(convention.failure);
+    const [compiled] = convention.success;
+    return compiled === undefined
+      ? Result.succeed({ kind: "forbid" })
+      : Result.succeed({ kind: "convention", convention: compiled });
+  }
+  if (rule.count !== undefined) {
+    return Result.succeed({
+      kind: "count",
+      min: rule.count.min ?? 0,
+      max: rule.count.max ?? Number.POSITIVE_INFINITY,
+    });
+  }
+  return Result.succeed({ kind: "forbid" });
+};
+
+export const compileSurfaceRule = (
+  rule: SurfaceRule,
+): Result.Result<CompiledSurfaceRule, PatternInvalid> => {
+  const from = compilePatterns(rule.name, "from", rule.from);
+  if (Result.isFailure(from)) return Result.fail(from.failure);
+  const fromNot = compilePatterns(rule.name, "fromNot", rule.fromNot);
+  if (Result.isFailure(fromNot)) return Result.fail(fromNot.failure);
+  const match = compilePatterns(rule.name, "match", rule.match);
+  if (Result.isFailure(match)) return Result.fail(match.failure);
+  const matchNot = compilePatterns(rule.name, "matchNot", rule.matchNot);
+  if (Result.isFailure(matchNot)) return Result.fail(matchNot.failure);
+  const demand = demandOf(rule);
+  if (Result.isFailure(demand)) return Result.fail(demand.failure);
+
+  return Result.succeed({
+    name: rule.name,
+    message: rule.message,
+    probe: rule.probe,
+    from: from.success,
+    fromNot: fromNot.success,
+    kinds: rule.kinds === undefined ? null : [...rule.kinds],
+    declares: rule.declares === undefined ? null : [...rule.declares],
+    reexport: rule.reexport ?? null,
+    match: match.success,
+    matchNot: matchNot.success,
+    demand: demand.success,
+  });
+};
+
+export const compileSurfaceRules = (
+  rules: ReadonlyArray<SurfaceRule>,
+): Result.Result<ReadonlyArray<CompiledSurfaceRule>, PatternInvalid> => {
+  const compiled: Array<CompiledSurfaceRule> = [];
+  for (const rule of rules) {
+    const one = compileSurfaceRule(rule);
+    if (Result.isFailure(one)) return Result.fail(one.failure);
+    compiled.push(one.success);
+  }
+  return Result.succeed(compiled);
+};
+
+const anyMatches = (patterns: ReadonlyArray<RegExp>, value: string): boolean =>
+  patterns.some((pattern) => pattern.test(value));
+
+export const surfaceRulesSelecting = (
+  rules: ReadonlyArray<CompiledSurfaceRule>,
+  file: string,
+): ReadonlyArray<CompiledSurfaceRule> =>
+  rules.filter((rule) => firstFromMatch(rule, file) !== null);
+
+// Whether a site is one the rule speaks to at all.
+const governs = (rule: CompiledSurfaceRule, site: ExportSite): boolean => {
+  if (rule.kinds !== null && !rule.kinds.includes(site.kind)) return false;
+  if (rule.declares !== null && !rule.declares.includes(site.declares)) return false;
+  if (rule.reexport !== null && rule.reexport !== site.reexport) return false;
+  if (rule.match.length > 0 && !anyMatches(rule.match, site.name)) return false;
+  if (rule.matchNot.length > 0 && anyMatches(rule.matchNot, site.name)) return false;
+  return true;
+};
+
+// A file's whole surface at once, because `count` is a statement about the
+// file rather than about any one site. The other demands report per site, on
+// the name that is actually restricted.
+export const evaluateSurface = (
+  selected: ReadonlyArray<CompiledSurfaceRule>,
+  file: string,
+  sites: ReadonlyArray<ExportSite>,
+): ReadonlyArray<Violation> => {
+  const violations: Array<Violation> = [];
+  const report = (rule: CompiledSurfaceRule, subject: string | null): void => {
+    violations.push({ kind: "surface", ruleName: rule.name, message: rule.message, file, subject });
+  };
+
+  for (const rule of selected) {
+    const spoken = sites.filter((site) => governs(rule, site));
+    const demand = rule.demand;
+    switch (demand.kind) {
+      case "forbid":
+        for (const site of spoken) report(rule, site.name);
+        break;
+      case "allow":
+        for (const site of spoken) {
+          if (!anyMatches(demand.allow, site.name)) report(rule, site.name);
+        }
+        break;
+      case "convention":
+        for (const site of spoken) {
+          if (!demand.convention.test(site.name)) report(rule, site.name);
+        }
+        break;
+      case "count":
+        if (spoken.length < demand.min || spoken.length > demand.max) report(rule, null);
+        break;
+    }
+  }
+  return violations;
+};
+
+// The probe is a whole surface — a list of sites, or a source the parser reads
+// them out of — because that is what the rule is evaluated against. A rule that
+// reports nothing for its own probe enforces nothing.
+export const surfaceRulesFailingTheirProbe = (
+  rules: ReadonlyArray<CompiledSurfaceRule>,
+  extractor: FactExtractor,
+): ReadonlyArray<CompiledSurfaceRule> =>
+  rules.filter((rule) => {
+    if (firstFromMatch(rule, rule.probe.from) === null) return true;
+    const sites: ReadonlyArray<ExportSite> =
+      rule.probe.source === undefined
+        ? (rule.probe.sites ?? []).map((site) => ({
+            file: rule.probe.from,
+            name: site.name,
+            kind: site.kind,
+            declares: site.declares ?? "other",
+            reexport: site.reexport ?? false,
+          }))
+        : extractor.factsOf(rule.probe.from, rule.probe.source).exportSites;
+    return evaluateSurface([rule], rule.probe.from, sites).length === 0;
+  });