@goodbones/core 0.1.0-beta.1 → 0.1.0-beta.11

package/src/manifest/json-schema.ts

@@ -0,0 +1,210 @@
+import * as Schema from "effect/Schema";
+
+import { Manifest } from "./manifest.js";
+
+// The manifest's shape as a JSON Schema, generated from the same codec that
+// decodes it, so the two cannot disagree. A YAML file names it in a header
+// comment and a JSON file in a `$schema` key; either way the editor completes
+// keys and flags a misspelled one before the loader ever runs.
+//
+// Three things the codec does not know are added here: the `defs` map, the
+// `{ use }` reference form that may stand in for any object, and the
+// `{ include }` form that may stand in for any object or list — all belong to
+// the passes that run before decoding.
+
+export const MANIFEST_SCHEMA_ID =
+  "https://dataquail.github.io/goodbones/schema/architecture.schema.json";
+
+// The schema an included file names: one node of the tree, with the two keys
+// a file of its own may carry at the top.
+export const MANIFEST_NODE_SCHEMA_ID =
+  "https://dataquail.github.io/goodbones/schema/architecture-node.schema.json";
+
+type JsonValue = string | number | boolean | null | JsonObject | ReadonlyArray<JsonValue>;
+type JsonObject = { readonly [key: string]: JsonValue };
+
+const entriesOf = (value: JsonObject): ReadonlyArray<readonly [string, JsonValue]> =>
+  Object.entries(value);
+
+const isObject = (value: JsonValue): value is JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isList = (value: JsonValue): value is ReadonlyArray<JsonValue> => Array.isArray(value);
+
+// The generator names the recursive schemas after its own internal wrappers,
+// numbered in the order it meets them. A stable name is what a `$ref` in an
+// error message or a docs page can point at: the tree's node, and an
+// objective's detector — told apart by what each declares, since the order
+// moves with the manifest's shape.
+const definitionNameOf = (name: string, definition: JsonValue): string => {
+  if (!/^(Suspend|Union)_\d*$/.test(name)) return name;
+  const text = JSON.stringify(definition);
+  if (text.includes('"children"')) return "ManifestNode";
+  if (text.includes('"all"')) return "Detector";
+  return name;
+};
+
+const DEFINITION_NAMES: Record<string, string> = {};
+
+const USE_REFERENCE = "#/$defs/Use";
+const INCLUDE_REFERENCE = "#/$defs/Include";
+
+const Use: JsonObject = {
+  type: "object",
+  description:
+    "A reference to a fragment under the top-level `defs`. Replaced by a copy of the fragment before the manifest is decoded; any other key written beside `use` overrides the fragment's key of the same name.",
+  properties: { use: { type: "string" } },
+  required: ["use"],
+};
+
+const Include: JsonObject = {
+  type: "object",
+  description:
+    "A reference to another YAML or JSON file, relative to this one. Replaced by that file's whole value before the manifest is decoded; a list item naming a file that holds a list is spliced in. Nothing may be written beside `include`.",
+  properties: { include: { type: "string" } },
+  required: ["include"],
+  additionalProperties: false,
+};
+
+// Every object schema below the root becomes "this object, or a `use` of a
+// fragment shaped like it, or an `include` of a file holding one", and every
+// list schema "this list, or an `include` of a file holding one". The
+// expansion passes replace a reference wherever it stands, so the schema
+// admits one wherever the value may stand.
+const admitReferences = (value: JsonValue): JsonValue => {
+  if (Array.isArray(value)) return value.map(admitReferences);
+  if (!isObject(value)) return value;
+
+  const rebuilt: Record<string, JsonValue> = {};
+  for (const [key, entry] of entriesOf(value)) {
+    if (key === "$ref" && typeof entry === "string") {
+      const name = entry.replace(/^#\/\$defs\//, "");
+      rebuilt[key] = `#/$defs/${DEFINITION_NAMES[name] ?? name}`;
+    } else {
+      rebuilt[key] = admitReferences(entry);
+    }
+  }
+  if (rebuilt.type === "object" && "properties" in rebuilt) {
+    return { anyOf: [{ $ref: USE_REFERENCE }, { $ref: INCLUDE_REFERENCE }, rebuilt] };
+  }
+  if (rebuilt.type === "array") {
+    return { anyOf: [{ $ref: INCLUDE_REFERENCE }, rebuilt] };
+  }
+  return rebuilt;
+};
+
+const DEFS_PROPERTY: JsonObject = {
+  type: "object",
+  description:
+    'Named fragments, referenced elsewhere in the manifest as `{ use: "<name>" }`. A fragment may itself contain `use`. Every file\'s `defs` share one namespace.',
+  additionalProperties: true,
+};
+
+const SCHEMA_PROPERTY: JsonObject = {
+  type: "string",
+  description: "For editors. Ignored by the loader.",
+};
+
+// A `Record` whose keys are checked — the campaign and objective ids —
+// generates as `patternProperties`, which alone admits any other key beside
+// the matching ones. Closed here, so an editor flags an id in the wrong
+// shape as the loader would.
+const withKeyPatterns = (value: JsonValue): JsonValue => {
+  if (Array.isArray(value)) return value.map(withKeyPatterns);
+  if (!isObject(value)) return value;
+  const rebuilt: Record<string, JsonValue> = {};
+  for (const [childKey, entry] of entriesOf(value)) rebuilt[childKey] = withKeyPatterns(entry);
+  if (
+    rebuilt.type === "object" &&
+    "patternProperties" in rebuilt &&
+    !("additionalProperties" in rebuilt)
+  ) {
+    rebuilt.additionalProperties = false;
+  }
+  return rebuilt;
+};
+
+export type ManifestJsonSchemaOptions = {
+  // The manifest keys of families the core does not own, as the fields of
+  // their own codecs — `CampaignsManifest.fields` from @goodbones/campaigns.
+  // Generated together with the core's, so the published schema describes the
+  // manifest a host with those families loaded will actually decode, and a
+  // host without them publishes a schema without those keys.
+  readonly extensions?: ReadonlyArray<Schema.Struct.Fields> | undefined;
+};
+
+export const manifestJsonSchema = (options: ManifestJsonSchemaOptions = {}): JsonObject => {
+  const whole =
+    options.extensions === undefined || options.extensions.length === 0
+      ? Manifest
+      : Schema.Struct(Object.assign({}, Manifest.fields, ...options.extensions));
+  const generated = Schema.toJsonSchemaDocument(whole) as unknown as {
+    readonly schema: JsonObject;
+    readonly definitions: JsonObject;
+  };
+  const { properties, ...root } = generated.schema;
+  if (properties === undefined || !isObject(properties)) {
+    throw new Error("the manifest schema generated with no properties");
+  }
+
+  for (const [name, definition] of entriesOf(generated.definitions)) {
+    DEFINITION_NAMES[name] = definitionNameOf(name, definition);
+  }
+  const definitions: Record<string, JsonValue> = {};
+  for (const [name, definition] of entriesOf(generated.definitions)) {
+    definitions[DEFINITION_NAMES[name] ?? name] = admitReferences(definition);
+  }
+
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: MANIFEST_SCHEMA_ID,
+    title: "Architecture manifest",
+    description:
+      "One manifest of a repository's architecture, read by @goodbones/cli and @goodbones/oxlint. See https://dataquail.github.io/goodbones/architecture-rules/manifest/.",
+    ...root,
+    properties: {
+      $schema: SCHEMA_PROPERTY,
+      defs: DEFS_PROPERTY,
+      ...Object.fromEntries(
+        entriesOf(properties).map(([key, value]) => [key, withKeyPatterns(admitReferences(value))]),
+      ),
+    },
+    $defs: { ...definitions, Use, Include },
+  };
+};
+
+// One node of the tree as a file of its own — what a per-package
+// `architecture.yaml` that the root manifest `include`s is shaped like. The
+// node's object form, with the `$schema` and `defs` keys such a file may carry
+// at the top, over the same definitions as the whole manifest.
+export const manifestNodeJsonSchema = (options: ManifestJsonSchemaOptions = {}): JsonObject => {
+  const whole = manifestJsonSchema(options);
+  const definitions = whole.$defs;
+  if (definitions === undefined || !isObject(definitions)) {
+    throw new Error("the manifest schema generated with no definitions");
+  }
+  const node = definitions.ManifestNode;
+  const variants = node !== undefined && isObject(node) ? node.anyOf : undefined;
+  const object =
+    variants !== undefined && isList(variants)
+      ? variants.find((variant) => isObject(variant) && variant.type === "object")
+      : undefined;
+  if (object === undefined || !isObject(object)) {
+    throw new Error("the manifest schema generated with no object form of a node");
+  }
+  const { $id: _id, $schema: _schema, ...rest } = object;
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: MANIFEST_NODE_SCHEMA_ID,
+    title: "Architecture manifest node",
+    description:
+      "One node of an architecture manifest's tree, as a file the manifest includes. See https://dataquail.github.io/goodbones/architecture-rules/manifest/#splitting-the-manifest-include.",
+    ...rest,
+    properties: {
+      $schema: SCHEMA_PROPERTY,
+      defs: DEFS_PROPERTY,
+      ...(rest.properties !== undefined && isObject(rest.properties) ? rest.properties : {}),
+    },
+    $defs: definitions,
+  };
+};

package/src/manifest/manifest.ts

@@ -1,8 +1,16 @@
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
 
 import { DeclarationKind, ResolveConfig } from "../domain/architecture-config.js";
 import { ConfigInvalid } from "../domain/architecture-error.js";
+import {
+  type ManifestLocator,
+  type ManifestPath,
+  renderManifestPath,
+} from "../domain/manifest-location.js";
+import { expandManifest, originOf, type Substitution } from "./expand.js";
+import type { ManifestExtension } from "./extension.js";
 
 // A manifest is a tree of nodes keyed by path pattern, where everything the
 // architecture says about a part of the tree is written at that part of the tree.
@@ -98,7 +106,7 @@ const Members = Schema.Struct({
 // is about; exactly one demand says what is required of them, and none means
 // `forbid` — a selected site is the violation. Stated on a folder it covers
 // the subtree, like `members`.
-const SurfaceConvention = Schema.Union([
+export const SurfaceConvention = Schema.Union([
   Schema.Literals(["kebab-case", "camelCase", "PascalCase", "snake_case"]),
   Schema.Struct({ regex: Schema.String }),
 ]);
@@ -247,12 +255,48 @@ const CoverageFloors = Schema.Struct({
   graph: Schema.optionalKey(Schema.Finite),
 });
 
+// Ceilings on the conformance measures — what `architecture conformance`
+// counts and `check` does not otherwise gate: the files no family reaches,
+// the nodes no file is under, the allowances nothing imports through, and
+// the fragment entries used at fewer than half the nodes granted them. Each
+// is a count that only goes down: lowered when the number falls, never
+// raised to make a red run green.
+const ConformanceCeilings = Schema.Struct({
+  residue: Schema.optionalKey(Schema.Finite),
+  vacant: Schema.optionalKey(Schema.Finite),
+  slack: Schema.optionalKey(Schema.Finite),
+  concentration: Schema.optionalKey(Schema.Finite),
+});
+
 const Limits = Schema.Struct({
   unrestricted: Schema.optionalKey(Schema.Finite),
   partial: Schema.optionalKey(Schema.Finite),
   coverage: Schema.optionalKey(CoverageFloors),
+  conformance: Schema.optionalKey(ConformanceCeilings),
+});
+
+
+const decodeTree = Schema.decodeUnknownResult(Schema.Record(Schema.String, ManifestNodeSchema), {
+  errors: "all",
+  onExcessProperty: "error",
 });
 
+// A tree of nodes, as an `endState` is once rebased: decoded like the
+// manifest's own, every issue listed.
+export const decodeManifestTree = (
+  raw: unknown,
+): Result.Result<Readonly<Record<string, ManifestNode>>, string> => {
+  const decoded = decodeTree(raw);
+  return Result.isFailure(decoded)
+    ? Result.fail(
+        flatten(decoded.failure.issue)
+          .issues.map((issue) => `${renderManifestPath(pathOf(issue))}: ${issue.message}`)
+          .join("\n"),
+      )
+    : Result.succeed(decoded.success);
+};
+
+
 export const Manifest = Schema.Struct({
   // How an import specifier becomes a file. Every pattern below is matched
   // against a resolved path, so this is what makes the rest of the file mean
@@ -283,16 +327,30 @@ export type LimitsSpec = typeof Limits.Type;
 export type NamingSpec = typeof Naming.Type;
 export type ExportRestriction = typeof ExportRestriction.Type;
 
+
+
 export const globsOf = (globs: string | ReadonlyArray<string>): ReadonlyArray<string> =>
   typeof globs === "string" ? [globs] : globs;
 
-const decode = Schema.decodeUnknownResult(Manifest);
+// Every issue, not the first: a manifest is edited by hand, and the reader
+// fixing one line wants to know about the other three. A key the schema does
+// not declare is refused rather than dropped — a misspelled `matchNot` that
+// decoded to nothing would be a rule quietly enforcing less than it says.
+const decode = Schema.decodeUnknownResult(Manifest, { errors: "all", onExcessProperty: "error" });
+const flatten = SchemaIssue.makeFormatterStandardSchemaV1();
 
 export type DecodedManifest = {
   readonly manifest: Manifest;
+  // What each family the core does not own decoded out of the keys it claims,
+  // keyed by the extension's id. The core carries these and never looks
+  // inside them.
+  readonly extensions: ReadonlyMap<string, unknown>;
   // Things the manifest said in a form that still loads but is on its way out.
   // The host prints them; nothing else acts on them.
   readonly notices: ReadonlyArray<string>;
+  // Every `use` the expansion replaced. Lowering reads them to say which
+  // fragment an allowance came through; nothing else needs them.
+  readonly substitutions: ReadonlyArray<Substitution>;
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -392,17 +450,155 @@ const normalizeLegacyMembers = (
   return { input: { ...input, tree }, notices };
 };
 
+
+export type DecodeManifestOptions = {
+  // Turns a path in the file into a line and column. The YAML reader supplies
+  // one; a JavaScript module has no positions to give and passes nothing.
+  readonly locate?: ManifestLocator | undefined;
+  // Families the core does not own. Each claims top-level keys, which are
+  // split off before the core decodes what is left and handed to that
+  // family's own codec.
+  readonly extensions?: ReadonlyArray<ManifestExtension> | undefined;
+};
+
+const fileLabelOf = (configPath: string): string => configPath.split(/[\\/]/).at(-1) ?? configPath;
+
+// A position carries its own file when the value was written in a file the
+// manifest `include`d; otherwise it is in the manifest file itself.
+const positionOf = (
+  file: string,
+  locate: ManifestLocator | undefined,
+  path: ManifestPath,
+): string | null => {
+  const found = locate?.(path) ?? null;
+  return found === null
+    ? null
+    : `${found.file ?? file}:${String(found.line)}:${String(found.column)}`;
+};
+
+// One line per issue: where in the file, which path, what was wrong — and,
+// when the value came in through a `use`, the reference that pulled it in,
+// since the fragment's own line may sit far from where the reader is looking.
+const describeIssue = (
+  configPath: string,
+  locate: ManifestLocator | undefined,
+  substitutions: ReadonlyArray<Substitution>,
+  path: ManifestPath,
+  detail: string,
+): string => {
+  const file = fileLabelOf(configPath);
+  const origin = originOf(substitutions, path);
+  const at = positionOf(file, locate, origin.path);
+  const via = origin.via.map(({ at: ref, name }) => {
+    const position = positionOf(file, locate, ref);
+    return `via \`use: ${JSON.stringify(name)}\`${position === null ? "" : ` at ${position}`}`;
+  });
+  return (
+    `  ${at === null ? "" : `${at}  `}${renderManifestPath(origin.path)}: ${detail}` +
+    (via.length === 0 ? "" : ` (${via.join(", ")})`)
+  );
+};
+
+// The standard-schema formatter flattens the issue tree to `{ path, message }`
+// pairs; a path segment may arrive wrapped as `{ key }`.
+const pathOf = (issue: {
+  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined;
+}): ManifestPath =>
+  (issue.path ?? []).map((segment) => (typeof segment === "object" ? segment.key : segment));
+
 export const decodeManifest = (
   configPath: string,
   input: unknown,
+  options: DecodeManifestOptions = {},
 ): Result.Result<DecodedManifest, ConfigInvalid> => {
-  const resolve = normalizeLegacyResolve(input);
+  const expanded = expandManifest(input);
+  if (Result.isFailure(expanded)) {
+    return Result.fail(
+      new ConfigInvalid({
+        configPath,
+        detail:
+          "the manifest does not expand:\n" +
+          describeIssue(
+            configPath,
+            options.locate,
+            [],
+            expanded.failure.path,
+            expanded.failure.detail,
+          ),
+      }),
+    );
+  }
+  const { substitutions, value } = expanded.success;
+
+  const extensions = options.extensions ?? [];
+  const describe = (path: ManifestPath, detail: string): string =>
+    describeIssue(configPath, options.locate, substitutions, path, detail);
+
+  // The keys a family the core does not own claims are split off here. What
+  // is left is decoded by the core's codec with excess properties refused, so
+  // a key nobody claims is still the misspelling it always was.
+  const claimed = new Map<string, string>();
+  for (const extension of extensions) {
+    for (const key of extension.manifestKeys) {
+      const already = claimed.get(key);
+      if (already !== undefined) {
+        return Result.fail(
+          new ConfigInvalid({
+            configPath,
+            detail:
+              `two loaded families both claim the manifest key \`${key}\` ` +
+              `("${already}" and "${extension.id}"). Load one of them.`,
+          }),
+        );
+      }
+      claimed.set(key, extension.id);
+    }
+  }
+  const core = isRecord(value)
+    ? Object.fromEntries(Object.entries(value).filter(([key]) => !claimed.has(key)))
+    : value;
+
+  const resolve = normalizeLegacyResolve(core);
   const members = normalizeLegacyMembers(resolve.input);
-  return Result.map(
-    Result.mapError(
-      decode(members.input),
-      (issue) => new ConfigInvalid({ configPath, detail: String(issue) }),
-    ),
-    (manifest) => ({ manifest, notices: [...resolve.notices, ...members.notices] }),
-  );
+  const decoded = decode(members.input);
+  if (Result.isFailure(decoded)) {
+    const lines = flatten(decoded.failure.issue).issues.map((issue) =>
+      describeIssue(configPath, options.locate, substitutions, pathOf(issue), issue.message),
+    );
+    return Result.fail(
+      new ConfigInvalid({
+        configPath,
+        detail: `the manifest does not decode:\n${lines.join("\n")}`,
+      }),
+    );
+  }
+
+  // Each family decodes its own slice, and renders its issues the way the
+  // core renders its own. One family's failure is reported on its own: the
+  // core's decode already succeeded, so there is nothing to collect it with.
+  const decodedExtensions = new Map<string, unknown>();
+  for (const extension of extensions) {
+    const slice = isRecord(value)
+      ? Object.fromEntries(
+          extension.manifestKeys.flatMap((key) => (key in value ? [[key, value[key]]] : [])),
+        )
+      : {};
+    const result = extension.decode(slice, describe);
+    if (Result.isFailure(result)) {
+      return Result.fail(
+        new ConfigInvalid({
+          configPath,
+          detail: `the manifest does not decode:\n${result.failure.join("\n")}`,
+        }),
+      );
+    }
+    decodedExtensions.set(extension.id, result.success);
+  }
+
+  return Result.succeed({
+    manifest: decoded.success,
+    extensions: decodedExtensions,
+    notices: [...resolve.notices, ...members.notices],
+    substitutions,
+  });
 };

package/src/ports/file-system.ts

@@ -5,4 +5,7 @@ export type FileSystem = {
   readonly exists: (repoRelativePath: string) => boolean;
   // The file's text, or `null` when it is absent or unreadable.
   readonly readText: (repoRelativePath: string) => string | null;
+  // The names in a folder — the per-sector records under a campaign's
+  // ledger directory are found this way. Empty when the folder is absent.
+  readonly list: (repoRelativeDir: string) => ReadonlyArray<string>;
 };

package/src/ports/language.ts

@@ -4,6 +4,7 @@ import type { ExportFix, ResolveScope } from "../domain/architecture-config.js";
 import type { ScopeInvalid } from "../domain/architecture-error.js";
 import type { FactExtractor } from "./fact-extractor.js";
 import type { ModuleResolver } from "./module-resolver.js";
+import type { SyntaxMatcher } from "./syntax-matcher.js";
 
 // Everything the policy needs from one programming language, behind one port.
 //
@@ -21,6 +22,17 @@ export type Language = {
   // Files carrying one of those extensions that are not source — for
   // TypeScript, a declaration file states types and no linter visits one.
   readonly ignoredFiles: ReadonlyArray<RegExp>;
+  // The files whose presence makes a folder a package of this language —
+  // `package.json`, `go.mod`, `Cargo.toml`. `infer` counts its depth from a
+  // package rather than from the repository root, so a monorepo of twenty
+  // packages is described one package at a time. Empty if the ecosystem has no
+  // such marker.
+  readonly packageMarkers: ReadonlyArray<string>;
+  // The folder names a package of this language keeps its source under, in
+  // order of preference — `src` for TypeScript, nothing for Go, where source
+  // sits at the package root. The first one that exists is where `infer`
+  // starts counting.
+  readonly sourceRoots: ReadonlyArray<string>;
   // Reads the facts out of one source text. The CLI reads every file through
   // it, and a probe carrying a `source` snippet is parsed by it at load.
   readonly extractor: FactExtractor;
@@ -28,6 +40,11 @@ export type Language = {
   // carry out. A rewrite is written in one module syntax; a rule naming one no
   // loaded language implements is refused at load.
   readonly fixes: ReadonlyArray<ExportFix>;
+  // Finds expressions of a given shape in one file, for a campaign's `syntax`
+  // term. Optional: a pack without one still answers every other family, and
+  // a campaign that needs one in its scope is refused at load with a
+  // sentence naming the language.
+  readonly syntax?: SyntaxMatcher;
   // A resolver for the files one scope covers. Built once per scope per run;
   // resolution is the expensive half of linting an architecture. The scope's
   // `options` are this language's to read, and anything it does not

package/src/ports/syntax-matcher.ts

@@ -0,0 +1,42 @@
+// A campaign's `syntax` term asks a question the facts cannot answer: does
+// this file contain an expression of this shape? A syntax matcher parses one
+// file and finds every node matching a rule, returning the matched text, what
+// each metavariable captured, where it sits, and the named declaration it
+// sits in. The rule object is the engine's own — ast-grep's, for the one
+// matcher that exists — and is carried opaquely; the matcher validates it.
+//
+// The matcher knows nothing about imports. Narrowing a capture by what its
+// identifier is bound to is done in the core, against the file's facts and
+// the resolver, so a second engine has only this port to implement.
+
+export type Position = {
+  // Zero-based line and column.
+  readonly line: number;
+  readonly column: number;
+};
+
+export type SyntaxMatch = {
+  readonly text: string;
+  // Each metavariable of the rule to the text it captured.
+  readonly captures: ReadonlyMap<string, string>;
+  readonly range: { readonly start: Position; readonly end: Position };
+  // The name of the nearest enclosing named declaration — the match itself
+  // when it is one — or `null` for a match at the top level of the file.
+  readonly anchor: string | null;
+};
+
+export type SyntaxTree = {
+  // Every node the rule matches, in source order. A rule the engine cannot
+  // read throws, with the engine's own sentence.
+  readonly findAll: (rule: unknown) => ReadonlyArray<SyntaxMatch>;
+  // The name of the innermost named declaration enclosing a position, or
+  // `null` at the top level — how a diagnostic another tool reported at a
+  // line is anchored on a declaration rather than on the line.
+  readonly anchorAt: (position: Position) => string | null;
+};
+
+export type SyntaxMatcher = {
+  // Parses one file's text. `null` when the matcher has no grammar for the
+  // file's extension, which a campaign treats as a file with no matches.
+  readonly parse: (file: string, text: string) => SyntaxTree | null;
+};

package/src/testing.ts

@@ -4,3 +4,4 @@
 export { makeFactExtractorFake } from "./infrastructure/fact-extractor-fake.js";
 export { makeFileSystemFake } from "./infrastructure/file-system-fake.js";
 export { makeModuleResolverFake } from "./infrastructure/module-resolver-fake.js";
+export { makeSyntaxMatcherFake, type StagedMatch } from "./infrastructure/syntax-matcher-fake.js";