@intentset/architecture 0.1.0

package/src/extract.ts

@@ -0,0 +1,344 @@
+/**
+ * Every module reference in one TypeScript or JavaScript file (profile TS004:
+ * type-only imports, dynamic imports and re-exports all count).
+ *
+ * TypeScript 7 ships its parser inside the native compiler and exposes no
+ * in-process `createSourceFile`; what it does ship in JavaScript is the
+ * scanner. So this module tokenizes with TypeScript's own scanner, which is
+ * what gets strings, comments, template literals and regular expressions
+ * right, and recognizes the handful of declaration shapes that carry a module
+ * specifier over the token stream:
+ *
+ *   import d, { a, type B } from "x"     import type { A } from "x"
+ *   import "x"                           import X = require("x")
+ *   export { a } from "x"                export type { A } from "x"
+ *   export * from "x"                    export * as ns from "x"
+ *   import("x")                          require("x")
+ *
+ * The scanner leaves two decisions to its parser: whether `/` starts a
+ * regular expression, and whether `}` resumes a template literal. Both are
+ * made here from the preceding token and a stack of template brace depths.
+ * Anything this module cannot read is returned as a problem, never dropped:
+ * a dynamic import with a computed specifier, or a token the scanner could
+ * not terminate (invariant 6).
+ */
+import { LanguageVariant, SyntaxKind } from "typescript/unstable/ast";
+import { computeLineStarts, createScanner, tokenIsIdentifierOrKeyword } from "typescript/unstable/ast/scanner";
+
+export interface RawImport {
+  specifier: string;
+  /** 1-based line of the specifier. */
+  line: number;
+  /** `import type`, `export type`, every named specifier marked `type`, or `typeof import("x")`. */
+  typeOnly: boolean;
+  /** `import("x")` or `require("x")`. */
+  dynamic: boolean;
+  /** `export ... from "x"`. */
+  reexport: boolean;
+  /** `export * from "x"` or `export * as ns from "x"`. */
+  wildcard: boolean;
+}
+
+export interface ExtractProblem {
+  line: number;
+  message: string;
+}
+
+export interface Extraction {
+  imports: RawImport[];
+  problems: ExtractProblem[];
+}
+
+interface Token {
+  kind: SyntaxKind;
+  text: string;
+  value: string;
+  line: number;
+}
+
+/** Keywords after which `/` begins a regular expression rather than a division. */
+const REGEX_AFTER_WORD = new Set([
+  "return",
+  "typeof",
+  "case",
+  "in",
+  "of",
+  "delete",
+  "void",
+  "throw",
+  "new",
+  "else",
+  "do",
+  "instanceof",
+  "yield",
+  "await",
+]);
+
+const VALUE_ENDING = new Set<SyntaxKind>([
+  SyntaxKind.NumericLiteral,
+  SyntaxKind.BigIntLiteral,
+  SyntaxKind.StringLiteral,
+  SyntaxKind.RegularExpressionLiteral,
+  SyntaxKind.NoSubstitutionTemplateLiteral,
+  SyntaxKind.TemplateTail,
+  SyntaxKind.CloseParenToken,
+  SyntaxKind.CloseBracketToken,
+  SyntaxKind.CloseBraceToken,
+  SyntaxKind.PlusPlusToken,
+  SyntaxKind.MinusMinusToken,
+]);
+
+function regexAllowed(previous: Token | undefined): boolean {
+  if (previous === undefined) return true;
+  if (VALUE_ENDING.has(previous.kind)) return false;
+  if (tokenIsIdentifierOrKeyword(previous.kind)) return REGEX_AFTER_WORD.has(previous.text);
+  return true;
+}
+
+function isJsx(path: string): boolean {
+  return path.endsWith(".tsx") || path.endsWith(".jsx");
+}
+
+function tokenize(path: string, text: string): { tokens: Token[]; problems: ExtractProblem[] } {
+  const jsx = isJsx(path);
+  const scanner = createScanner(true, jsx ? LanguageVariant.JSX : LanguageVariant.Standard, text);
+  const starts = computeLineStarts(text);
+  const lineOf = (position: number): number => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = (low + high + 1) >> 1;
+      if (starts[mid] <= position) low = mid;
+      else high = mid - 1;
+    }
+    return low + 1;
+  };
+  const tokens: Token[] = [];
+  const problems: ExtractProblem[] = [];
+  /** Open brace depth inside each `${` of an unfinished template literal. */
+  const templates: number[] = [];
+  let previous: Token | undefined;
+  let lastEnd = -1;
+  for (;;) {
+    let kind = scanner.scan();
+    if (kind === SyntaxKind.EndOfFile) break;
+    // TypeScript 7's scanner can return a token without advancing: JSX text
+    // such as `#{n}` scans as an empty private identifier at the `#`, forever.
+    // A token that ends where the last one did makes no progress, so step over
+    // one character. In JSX that costs nothing, since no import is written in
+    // JSX text; anywhere else it is reported, because something was skipped.
+    if (scanner.getTokenEnd() <= lastEnd) {
+      if (!jsx) {
+        problems.push({
+          line: lineOf(lastEnd),
+          message: "the scanner could not advance here, so one character was skipped",
+        });
+      }
+      lastEnd++;
+      scanner.resetTokenState(lastEnd);
+      continue;
+    }
+    lastEnd = scanner.getTokenEnd();
+    if ((kind === SyntaxKind.SlashToken || kind === SyntaxKind.SlashEqualsToken) && regexAllowed(previous)) {
+      kind = scanner.reScanSlashToken();
+    } else if (kind === SyntaxKind.OpenBraceToken && templates.length > 0) {
+      templates[templates.length - 1]++;
+    } else if (kind === SyntaxKind.CloseBraceToken && templates.length > 0) {
+      if (templates[templates.length - 1] === 0) {
+        kind = scanner.reScanTemplateToken(false);
+        if (kind === SyntaxKind.TemplateTail) templates.pop();
+      } else templates[templates.length - 1]--;
+    }
+    if (kind === SyntaxKind.TemplateHead) templates.push(0);
+    const line = lineOf(scanner.getTokenStart());
+    if (scanner.isUnterminated()) {
+      // In JSX, text such as `Don't` scans as a string that runs to the end of its line and no further;
+      // it costs at most that line, and no import is written inside JSX text.
+      if (!(jsx && kind === SyntaxKind.StringLiteral)) {
+        problems.push({ line, message: `the scanner could not terminate a ${describe(kind)} that starts here` });
+      }
+    }
+    const token: Token = { kind, text: scanner.getTokenText(), value: scanner.getTokenValue(), line };
+    tokens.push(token);
+    previous = token;
+  }
+  if (templates.length > 0) {
+    problems.push({ line: previous?.line ?? 1, message: "a template literal is still open at the end of the file" });
+  }
+  return { tokens, problems };
+}
+
+function describe(kind: SyntaxKind): string {
+  switch (kind) {
+    case SyntaxKind.StringLiteral:
+      return "string literal";
+    case SyntaxKind.RegularExpressionLiteral:
+      return "regular expression";
+    case SyntaxKind.NoSubstitutionTemplateLiteral:
+    case SyntaxKind.TemplateHead:
+    case SyntaxKind.TemplateMiddle:
+    case SyntaxKind.TemplateTail:
+      return "template literal";
+    default:
+      return "token";
+  }
+}
+
+/** Extract every module reference from one file. */
+export function extractImports(path: string, text: string): Extraction {
+  const { tokens, problems } = tokenize(path, text);
+  const imports: RawImport[] = [];
+  const consumed = new Set<number>();
+
+  const word = (i: number, text?: string): boolean => {
+    const token = tokens[i];
+    return token !== undefined && tokenIsIdentifierOrKeyword(token.kind) && (text === undefined || token.text === text);
+  };
+  const is = (i: number, kind: SyntaxKind): boolean => tokens[i]?.kind === kind;
+  const isString = (i: number): boolean => is(i, SyntaxKind.StringLiteral);
+  const isLiteral = (i: number): boolean => isString(i) || is(i, SyntaxKind.NoSubstitutionTemplateLiteral);
+  const afterDot = (i: number): boolean => is(i - 1, SyntaxKind.DotToken) || is(i - 1, SyntaxKind.QuestionDotToken);
+  const add = (i: number, fields: Omit<RawImport, "specifier" | "line">) => {
+    imports.push({ specifier: tokens[i].value, line: tokens[i].line, ...fields });
+  };
+  /** Index of the token closing the bracket opened at i, or tokens.length. */
+  const closing = (i: number, open: SyntaxKind, close: SyntaxKind): number => {
+    let depth = 0;
+    for (let k = i; k < tokens.length; k++) {
+      if (tokens[k].kind === open) depth++;
+      else if (tokens[k].kind === close && --depth === 0) return k;
+    }
+    return tokens.length;
+  };
+  /** Named elements between braces: true when every one is written `type X`. */
+  const allTyped = (open: number, close: number): boolean => {
+    let count = 0;
+    let typed = 0;
+    let start = true;
+    for (let k = open + 1; k < close; k++) {
+      if (is(k, SyntaxKind.CommaToken)) {
+        start = true;
+        continue;
+      }
+      if (start) {
+        count++;
+        if (word(k, "type") && word(k + 1) && !word(k + 1, "as")) typed++;
+        start = false;
+      }
+    }
+    return count > 0 && typed === count;
+  };
+  /** A call such as `import(x)` or `require(x)` that is really a method declaration `import(x) { ... }`. */
+  const isMethod = (open: number): boolean =>
+    is(closing(open, SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken) + 1, SyntaxKind.OpenBraceToken);
+
+  for (let i = 0; i < tokens.length; i++) {
+    if (consumed.has(i) || afterDot(i)) continue;
+
+    if (word(i, "import") && tokens[i].kind === SyntaxKind.ImportKeyword) {
+      if (is(i + 1, SyntaxKind.OpenParenToken)) {
+        if (isLiteral(i + 2) && (is(i + 3, SyntaxKind.CloseParenToken) || is(i + 3, SyntaxKind.CommaToken))) {
+          add(i + 2, { typeOnly: word(i - 1, "typeof"), dynamic: true, reexport: false, wildcard: false });
+        } else if (!is(i + 2, SyntaxKind.CloseParenToken) && !isMethod(i + 1)) {
+          problems.push({
+            line: tokens[i].line,
+            message: "a dynamic import has a computed specifier, so its target cannot be known",
+          });
+        }
+        continue;
+      }
+      if (
+        is(i + 1, SyntaxKind.DotToken) ||
+        is(i + 1, SyntaxKind.ColonToken) ||
+        is(i + 1, SyntaxKind.CommaToken) ||
+        is(i + 1, SyntaxKind.CloseBraceToken) ||
+        is(i + 1, SyntaxKind.CloseParenToken)
+      ) {
+        continue;
+      }
+      let j = i + 1;
+      let typeOnly = false;
+      if (
+        word(j, "type") &&
+        !is(j + 1, SyntaxKind.CommaToken) &&
+        !is(j + 1, SyntaxKind.EqualsToken) &&
+        !(word(j + 1, "from") && isString(j + 2))
+      ) {
+        typeOnly = true;
+        j++;
+      }
+      if (isString(j)) {
+        add(j, { typeOnly, dynamic: false, reexport: false, wildcard: false });
+        continue;
+      }
+      if (word(j) && is(j + 1, SyntaxKind.EqualsToken)) {
+        if (word(j + 2, "require") && is(j + 3, SyntaxKind.OpenParenToken) && isString(j + 4)) {
+          add(j + 4, { typeOnly, dynamic: false, reexport: false, wildcard: false });
+          consumed.add(j + 2);
+        }
+        continue;
+      }
+      // Default, namespace and named bindings, then `from "x"`.
+      let hasPlainBinding = false;
+      let typedNamed = false;
+      for (let k = j; k < tokens.length && k < j + 4096; k++) {
+        if (is(k, SyntaxKind.OpenBraceToken)) {
+          const close = closing(k, SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken);
+          typedNamed = allTyped(k, close);
+          k = close;
+          continue;
+        }
+        if (word(k, "from") && isString(k + 1)) {
+          const typed = typeOnly || (typedNamed && !hasPlainBinding);
+          add(k + 1, { typeOnly: typed, dynamic: false, reexport: false, wildcard: false });
+          i = k + 1;
+          break;
+        }
+        if (is(k, SyntaxKind.SemicolonToken) || word(k, "import") || word(k, "export")) break;
+        if (is(k, SyntaxKind.AsteriskToken) || (word(k) && !word(k, "as") && !is(k - 1, SyntaxKind.AsKeyword))) {
+          hasPlainBinding = true;
+        }
+      }
+      continue;
+    }
+
+    if (word(i, "export") && tokens[i].kind === SyntaxKind.ExportKeyword) {
+      let j = i + 1;
+      let typeOnly = false;
+      if (word(j, "type") && (is(j + 1, SyntaxKind.OpenBraceToken) || is(j + 1, SyntaxKind.AsteriskToken))) {
+        typeOnly = true;
+        j++;
+      }
+      if (is(j, SyntaxKind.AsteriskToken)) {
+        let k = j + 1;
+        if (word(k, "as")) k += 2;
+        if (word(k, "from") && isString(k + 1)) {
+          add(k + 1, { typeOnly, dynamic: false, reexport: true, wildcard: true });
+          i = k + 1;
+        }
+        continue;
+      }
+      if (is(j, SyntaxKind.OpenBraceToken)) {
+        const close = closing(j, SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken);
+        if (word(close + 1, "from") && isString(close + 2)) {
+          add(close + 2, { typeOnly: typeOnly || allTyped(j, close), dynamic: false, reexport: true, wildcard: false });
+          i = close + 2;
+        }
+      }
+      continue;
+    }
+
+    if (word(i, "require") && is(i + 1, SyntaxKind.OpenParenToken) && !word(i - 1, "function")) {
+      if (isLiteral(i + 2) && is(i + 3, SyntaxKind.CloseParenToken)) {
+        add(i + 2, { typeOnly: false, dynamic: true, reexport: false, wildcard: false });
+      } else if (!is(i + 2, SyntaxKind.CloseParenToken) && !isMethod(i + 1)) {
+        problems.push({
+          line: tokens[i].line,
+          message: "a require call has a computed specifier, so its target cannot be known",
+        });
+      }
+    }
+  }
+
+  return { imports, problems };
+}

package/src/finding.ts

@@ -0,0 +1,64 @@
+/**
+ * A diagnostic plus what it is about. Exceptions (VSA §9) match on exact
+ * paths and edges, which a message cannot be trusted to carry, so every
+ * check reports a Finding: the diagnostic in core's shape (ADR 0004 key
+ * order, origin "architecture") and the subject an exception can name.
+ */
+import type { Diagnostic, Location, Severity } from "@intentset/core";
+
+export interface SubjectEdge {
+  /** A file path or a slice ID. */
+  from: string;
+  /** A file path, a slice ID, or a package specifier. */
+  to: string;
+}
+
+export interface Finding {
+  diagnostic: Diagnostic;
+  /** Every path the finding concerns; the diagnostic's own path is always included. */
+  paths: string[];
+  /** File-level and slice-level edges the finding concerns. */
+  edges: SubjectEdge[];
+}
+
+export interface FindingFields {
+  code: string;
+  severity?: Severity;
+  artifact: string | null;
+  path: string | null;
+  location?: Location;
+  field?: string;
+  message: string;
+  remediation: string;
+  paths?: string[];
+  edges?: SubjectEdge[];
+}
+
+/** One diagnostic, members in contract order, optional members present only when known. */
+export function finding(fields: FindingFields): Finding {
+  const diagnostic: Diagnostic = {
+    code: fields.code,
+    severity: fields.severity ?? "error",
+    origin: "architecture",
+    artifact: fields.artifact,
+    path: fields.path,
+    ...(fields.location !== undefined ? { location: fields.location } : {}),
+    ...(fields.field !== undefined ? { field: fields.field } : {}),
+    message: fields.message,
+    remediation: fields.remediation,
+  };
+  const paths = new Set(fields.paths ?? []);
+  if (fields.path !== null) paths.add(fields.path);
+  return { diagnostic, paths: [...paths].sort(), edges: fields.edges ?? [] };
+}
+
+/** "1 file" / "3 files". */
+export function plural(count: number, noun: string, many = `${noun}s`): string {
+  return `${count} ${count === 1 ? noun : many}`;
+}
+
+/** At most `limit` items joined with commas, then "and N more". */
+export function listSome(items: readonly string[], limit = 3): string {
+  if (items.length <= limit) return items.join(", ");
+  return `${items.slice(0, limit).join(", ")} and ${items.length - limit} more`;
+}

package/src/imports.ts

@@ -0,0 +1,77 @@
+/**
+ * The resolved import graph of a tree (VSA003–VSA006, profile TS004): one
+ * edge per module reference in every code file, with the target file or,
+ * for a package outside the repository, the specifier alone. What could not
+ * be read or resolved is returned beside the edges, never folded into them.
+ */
+import { extractImports } from "./extract.ts";
+import { isCode } from "./paths.ts";
+import { compareStrings } from "./patterns.ts";
+import type { Resolver, Via } from "./resolve.ts";
+
+export interface ImportEdge {
+  from: string;
+  /** Target file, or null for an external package. */
+  to: string | null;
+  specifier: string;
+  /** 1-based line of the specifier in `from`. */
+  line: number;
+  typeOnly: boolean;
+  dynamic: boolean;
+  reexport: boolean;
+  /** `export * from` or `export * as ns from`. */
+  wildcardExport: boolean;
+  via: Via;
+  /** Resolved through a `*` alias, an exports pattern or a package without exports (TS006). */
+  wildcardAlias: boolean;
+}
+
+export interface UnresolvedImport {
+  path: string;
+  line: number | null;
+  specifier: string | null;
+  message: string;
+}
+
+export interface ImportGraph {
+  edges: ImportEdge[];
+  unresolved: UnresolvedImport[];
+}
+
+/** Build the graph over every code file in `files` (already filtered of ignored paths). */
+export function buildImportGraph(files: ReadonlyMap<string, string>, resolver: Resolver): ImportGraph {
+  const edges: ImportEdge[] = [];
+  const unresolved: UnresolvedImport[] = [];
+  for (const path of [...files.keys()].sort(compareStrings)) {
+    if (!isCode(path)) continue;
+    const { imports, problems } = extractImports(path, files.get(path) as string);
+    for (const problem of problems) {
+      unresolved.push({ path, line: problem.line, specifier: null, message: problem.message });
+    }
+    for (const raw of imports) {
+      const resolution = resolver.resolve(path, raw.specifier);
+      if (resolution.problem !== undefined) {
+        unresolved.push({
+          path,
+          line: raw.line,
+          specifier: raw.specifier,
+          message: `the specifier "${raw.specifier}" ${resolution.problem}`,
+        });
+        continue;
+      }
+      edges.push({
+        from: path,
+        to: resolution.to,
+        specifier: raw.specifier,
+        line: raw.line,
+        typeOnly: raw.typeOnly,
+        dynamic: raw.dynamic,
+        reexport: raw.reexport,
+        wildcardExport: raw.wildcard,
+        via: resolution.via,
+        wildcardAlias: resolution.wildcard,
+      });
+    }
+  }
+  return { edges, unresolved };
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+/**
+ * @intentset/architecture: the Traceable VSA checker (spec/vsa-0.1.md) with
+ * the TypeScript + Amplify Gen 2 profile's boundaries
+ * (spec/profile-typescript-amplify-gen2-0.1.md). `checkArchitecture` is the
+ * whole check; the rest is exported for reports, tools and tests.
+ */
+export {
+  applyBaseline,
+  type BaselineEntry,
+  fingerprint,
+  type Mode,
+  parseBaseline,
+  plainMessage,
+  writeBaseline,
+} from "./baseline.ts";
+export { type BoundaryResult, checkBoundaries, checkUnclassified, type SliceEdge } from "./boundaries.ts";
+export {
+  type ArchitectureResult,
+  type ArchitectureSummary,
+  type CheckOptions,
+  checkArchitecture,
+  REVIEW_REQUIRED,
+} from "./check.ts";
+export { checkClaims } from "./claims.ts";
+export {
+  ARCHITECTURE_CONFIG_PATH,
+  type ArchitectureConfig,
+  DEFAULT_ARCHITECTURE_CONFIG,
+  readArchitectureConfig,
+  resolveConfig,
+} from "./config.ts";
+export { checkDependencies, shortestCycle, stronglyConnected } from "./dependencies.ts";
+export {
+  annotate,
+  applyExceptions,
+  covers,
+  EXCEPTIONS_PATTERNS,
+  type ExceptionRecord,
+  readExceptionRecord,
+  readExceptions,
+} from "./exceptions.ts";
+export { type Extraction, extractImports, type RawImport } from "./extract.ts";
+export type { Finding, SubjectEdge } from "./finding.ts";
+export { buildImportGraph, type ImportEdge, type ImportGraph, type UnresolvedImport } from "./imports.ts";
+export { inSeam, isPure, layerAllows, layerOf, purePatterns, seamPatterns } from "./layers.ts";
+export { checkOwnership } from "./ownership.ts";
+export { expandClaims, matchAny, matchPattern, validatePattern } from "./patterns.ts";
+export {
+  activeSlices,
+  buildModel,
+  type Model,
+  type Region,
+  type RegionKind,
+  regionLabel,
+  type SliceInfo,
+} from "./regions.ts";
+export { type Resolution, Resolver, type Via } from "./resolve.ts";
+export { matchAlias, stripJsonComments, type TsConfig, TsConfigs } from "./tsconfig.ts";

package/src/layers.ts

@@ -0,0 +1,67 @@
+/**
+ * A slice's internal layers (VSA006, profile §3). The slice declares its
+ * layers by pattern; the profile's matrix says which may import which:
+ *
+ *   presentation -> application, policy, model
+ *   application  -> policy, model, external
+ *   policy       -> model
+ *   model        -> model
+ *   external     -> model
+ *
+ * each layer also importing itself. The same declaration names the slice's
+ * external-access seam (the `external` layer, VSA010 and AMP002) and its pure
+ * layers (`policy` and `model`, AMP006). A slice that declares no layers
+ * falls back to the reference layout's folders under an entrypoint's
+ * directory: client/, domain/policies/, domain/models/. A slice has one
+ * entrypoint per package, so a file uses the folders under the entrypoint
+ * directory nearest above it.
+ */
+import type { ArchitectureConfig } from "./config.ts";
+import { matchAny } from "./patterns.ts";
+import { rootOf, type SliceInfo } from "./regions.ts";
+
+export type LayerOf = { layer: string } | { layer: null; reason: "none" | "ambiguous"; candidates: string[] };
+
+export function layerOf(slice: SliceInfo, path: string): LayerOf {
+  const matches = Object.keys(slice.meta.layers)
+    .sort()
+    .filter((layer) => matchAny(slice.meta.layers[layer], path));
+  if (matches.length === 1) return { layer: matches[0] };
+  return { layer: null, reason: matches.length === 0 ? "none" : "ambiguous", candidates: matches };
+}
+
+/** The fallback folders under the root a path belongs to, or under every root when no path is given. */
+function under(slice: SliceInfo, folders: string[], path?: string): string[] {
+  const roots = path === undefined ? slice.roots : [rootOf(slice, path)].filter((root) => root !== null);
+  return roots.flatMap((root) => folders.map((folder) => (root === "" ? `${folder}/**` : `${root}/${folder}/**`)));
+}
+
+/** The slice's declared external-access seam; for a slice that declares none, the client/ folder under each entrypoint (or the one above `path`). */
+export function seamPatterns(slice: SliceInfo, path?: string): string[] {
+  const declared = slice.meta.layers.external ?? [];
+  return declared.length > 0 ? declared : under(slice, ["client"], path);
+}
+
+/** The slice's pure layers: policies and models, which must stay free of clients and SDKs. */
+export function purePatterns(slice: SliceInfo, path?: string): string[] {
+  const declared = [...(slice.meta.layers.policy ?? []), ...(slice.meta.layers.model ?? [])];
+  return declared.length > 0 ? declared : under(slice, ["domain/policies", "domain/models"], path);
+}
+
+export function inSeam(slice: SliceInfo, path: string): boolean {
+  return matchAny(seamPatterns(slice, path), path);
+}
+
+export function isPure(slice: SliceInfo, path: string): boolean {
+  return matchAny(purePatterns(slice, path), path);
+}
+
+/** May a file in layer `from` import one in layer `to`? Unknown layers are never allowed anything. */
+export function layerAllows(config: ArchitectureConfig, from: string, to: string): boolean {
+  if (from === to) return true;
+  return (config.layerMatrix[from] ?? []).includes(to);
+}
+
+export function knownLayer(config: ArchitectureConfig, layer: string): boolean {
+  return Object.hasOwn(config.layerMatrix, layer);
+}