@intentius/chant 0.19.1 → 0.20.0

package/src/cli/commands/check-lexicon-examples.ts

@@ -0,0 +1,103 @@
+/**
+ * "Every shipped example builds" (chant #1067).
+ *
+ * `check-lexicon.ts`'s existing example checks only count directories
+ * ("At least 1 example", "At least 3 examples", "At least 5 examples with
+ * tests") — nothing ever tries to build one. `lexicons/aws/examples/core-concepts`
+ * shipped with a discovery-time error (two files independently exporting a
+ * top-level `dataBucket`) and `chant dev check-lexicon lexicons/aws` still
+ * reported "All tier-1 checks passed," because none of its 29 checks touch
+ * build output. This module closes that gap directly: for every non-empty
+ * `examples/<name>/src/` directory, run the same discover-and-serialize
+ * pipeline `chant build` runs and report whether it produced output with no
+ * structural error.
+ *
+ * Scope, deliberately: "builds" here means discovery + serialization
+ * succeed (no `DiscoveryError`/`BuildError`, real output produced) — the
+ * same thing a `Duplicate export name` failure blocks. It does not
+ * additionally require the output to pass every post-synth/lint check
+ * (WAW0xx and friends). Those are a separate, already-gated contract
+ * (`chant lint`, the post-synth pipeline) with their own severity model and
+ * their own CI step; several existing AWS examples (docs-snippets,
+ * lambda-api, lambda-s3, shared-alb) currently fail one or more post-synth
+ * checks for reasons unrelated to this issue (e.g. WAW042, a TLS-only
+ * bucket policy check added after those examples were written). Folding
+ * that axis into "does it build" would fail this new check for all of them
+ * on its very first run, for defects this issue never set out to fix.
+ * Tracked separately; not silently absorbed here.
+ */
+
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { build } from "../../build";
+import { findInfraFiles } from "../../discovery/files";
+import { detectLexicons } from "../../detectLexicon";
+import { loadPlugins } from "../plugins";
+
+export interface ExampleBuildResult {
+  example: string;
+  ok: boolean;
+  detail?: string;
+}
+
+/**
+ * Build every non-empty example under `<lexiconDir>/examples/*\/src` and
+ * report per-example pass/fail. Returns `[]` when the lexicon has no
+ * `examples/` directory at all (a separate tier-1 check already covers
+ * that).
+ */
+export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBuildResult[]> {
+  const examplesDir = join(lexiconDir, "examples");
+  if (!existsSync(examplesDir)) return [];
+
+  const results: ExampleBuildResult[] = [];
+  const entries = readdirSync(examplesDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+
+  for (const entry of entries) {
+    const srcDir = join(examplesDir, entry.name, "src");
+    if (!existsSync(srcDir)) continue;
+
+    const contents = readdirSync(srcDir);
+    if (contents.length === 0 || (contents.length === 1 && contents[0] === ".gitkeep")) continue;
+
+    try {
+      const files = await findInfraFiles(srcDir);
+      if (files.length === 0) continue;
+
+      const lexiconNames = await detectLexicons(files);
+      if (lexiconNames.length === 0) {
+        results.push({
+          example: entry.name,
+          ok: false,
+          detail: "no lexicon imports detected in src/ — cannot determine which plugin(s) to build with",
+        });
+        continue;
+      }
+
+      const plugins = await loadPlugins(lexiconNames);
+      const result = await build(srcDir, plugins.map((p) => p.serializer));
+
+      const structuralErrors = result.errors.map((e) => e.message);
+      const producedOutput = result.outputs.size > 0;
+      const ok = structuralErrors.length === 0 && producedOutput;
+
+      results.push({
+        example: entry.name,
+        ok,
+        detail: ok
+          ? undefined
+          : structuralErrors.length > 0
+            ? structuralErrors.join("; ")
+            : "discovered source but produced no output",
+      });
+    } catch (err) {
+      results.push({
+        example: entry.name,
+        ok: false,
+        detail: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  return results;
+}

package/src/cli/commands/check-lexicon-intrinsics.test.ts

@@ -0,0 +1,145 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { auditIntrinsics } from "./check-lexicon-intrinsics";
+
+/**
+ * chant #1067 — proof that the intrinsic-foldability audit actually
+ * validates, rather than just counting. Each case here is a small,
+ * synthetic lexicon (plugin.ts + index.ts + intrinsics.ts) so the
+ * fixtures encode the exact failure shapes #1039 shipped: a genuine
+ * tagged template registered with the wrong `isTag`, and a plain call
+ * registered with the wrong `isTag`, in both directions — plus a
+ * registration naming something the package never exports.
+ */
+
+function writeFixture(dir: string): void {
+  mkdirSync(join(dir, "src"), { recursive: true });
+
+  writeFileSync(
+    join(dir, "src/plugin.ts"),
+    `export const testPlugin = {
+  name: "test",
+  intrinsics() {
+    return [
+      { name: "Tag1", description: "a genuine tagged template", isTag: true },
+      { name: "Plain1", description: "a genuine plain call", isTag: false },
+      { name: "Mismatch1", description: "claims tag but is a plain call", isTag: true },
+      { name: "Mismatch2", description: "claims plain but is a tagged template", isTag: false },
+      { name: "Missing1", description: "registered but never exported", isTag: false },
+    ];
+  },
+};
+`,
+  );
+
+  writeFileSync(
+    join(dir, "src/index.ts"),
+    `export { Tag1, Plain1, Mismatch1, Mismatch2 } from "./intrinsics";
+`,
+  );
+
+  writeFileSync(
+    join(dir, "src/intrinsics.ts"),
+    `export function Tag1(strings: TemplateStringsArray, ...values: unknown[]): string {
+  return strings.join("");
+}
+
+export function Plain1(x: string): string {
+  return x;
+}
+
+// Registered as isTag: true above — this is the #1039 "aws Sub" shape,
+// inverted: a plain call wrongly claimed as a tag.
+export function Mismatch1(x: string): string {
+  return x;
+}
+
+// Registered as isTag: false above — this is the #1039 "gitlab reference()"
+// shape: a genuine tagged template wrongly claimed as a plain call.
+export function Mismatch2(strings: TemplateStringsArray, ...values: unknown[]): string {
+  return strings.join("");
+}
+`,
+  );
+}
+
+describe("auditIntrinsics", () => {
+  let dir: string;
+
+  beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "chant-check-lexicon-intrinsics-"));
+    writeFixture(dir);
+  });
+  afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+  test("a genuine tagged template registered as isTag: true passes", () => {
+    const items = auditIntrinsics(dir);
+    const item = items.find((i) => i.name === "Tag1");
+    expect(item).toMatchObject({ exported: true, actualIsTag: true, ok: true });
+  });
+
+  test("a genuine plain call registered as isTag: false passes", () => {
+    const items = auditIntrinsics(dir);
+    const item = items.find((i) => i.name === "Plain1");
+    expect(item).toMatchObject({ exported: true, actualIsTag: false, ok: true });
+  });
+
+  test("a plain call wrongly registered as isTag: true fails (aws Sub shape, inverted)", () => {
+    const items = auditIntrinsics(dir);
+    const item = items.find((i) => i.name === "Mismatch1");
+    expect(item?.ok).toBe(false);
+    expect(item?.exported).toBe(true);
+    expect(item?.actualIsTag).toBe(false);
+    expect(item?.detail).toMatch(/plain call.*but registered with isTag: true/);
+  });
+
+  test("a tagged template wrongly registered as isTag: false fails (gitlab reference() shape)", () => {
+    const items = auditIntrinsics(dir);
+    const item = items.find((i) => i.name === "Mismatch2");
+    expect(item?.ok).toBe(false);
+    expect(item?.exported).toBe(true);
+    expect(item?.actualIsTag).toBe(true);
+    expect(item?.detail).toMatch(/authored as a tagged template.*isTag: false/);
+  });
+
+  test("a registered intrinsic that isn't exported fails, distinctly from a signature mismatch", () => {
+    const items = auditIntrinsics(dir);
+    const item = items.find((i) => i.name === "Missing1");
+    expect(item?.exported).toBe(false);
+    expect(item?.ok).toBe(false);
+    expect(item?.detail).toMatch(/not exported from src\/index\.ts/);
+  });
+
+  test("returns [] for a lexicon with no intrinsics() method", () => {
+    const emptyDir = mkdtempSync(join(tmpdir(), "chant-check-lexicon-intrinsics-empty-"));
+    try {
+      mkdirSync(join(emptyDir, "src"), { recursive: true });
+      writeFileSync(join(emptyDir, "src/plugin.ts"), `export const testPlugin = { name: "test" };\n`);
+      expect(auditIntrinsics(emptyDir)).toEqual([]);
+    } finally {
+      rmSync(emptyDir, { recursive: true, force: true });
+    }
+  });
+
+  test("returns [] for a lexicon whose intrinsics() legitimately registers none (gcp/k8s shape)", () => {
+    const emptyArrayDir = mkdtempSync(join(tmpdir(), "chant-check-lexicon-intrinsics-emptyarray-"));
+    try {
+      mkdirSync(join(emptyArrayDir, "src"), { recursive: true });
+      writeFileSync(
+        join(emptyArrayDir, "src/plugin.ts"),
+        `export const testPlugin = {
+  name: "test",
+  intrinsics() {
+    return [];
+  },
+};
+`,
+      );
+      expect(auditIntrinsics(emptyArrayDir)).toEqual([]);
+    } finally {
+      rmSync(emptyArrayDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/commands/check-lexicon-intrinsics.ts

@@ -0,0 +1,312 @@
+/**
+ * Static audit of a lexicon's intrinsic registrations (chant #1067).
+ *
+ * `check-lexicon.ts`'s original 29 checks are all existence/count assertions
+ * — they never look at whether a registration is actually *correct*.
+ * Foldability (`IntrinsicDef.isTag`, ../../lexicon.ts) is the sharpest case:
+ * it drives both `chant build --fold` (which registered tags it recognizes)
+ * and the generated per-lexicon intrinsics doc page (its "Folds?" column,
+ * via `intrinsicFolds()`), so a wrong value doesn't just mislead a reader —
+ * it silently changes what `--fold` does. #1039 shipped with the flag wrong
+ * in both directions at once (aws's `Sub` missing `isTag` entirely; gitlab's
+ * `reference()` claiming `isTag: true` for a plain call) and neither was
+ * caught by anything until someone measured fold coverage by hand.
+ *
+ * This module answers two questions per registered intrinsic, purely by
+ * parsing source (no execution, no `chant generate` required first):
+ *
+ * 1. Is `name` actually exported from the package's public entry
+ *    (`src/index.ts`)? A registration that names something the package
+ *    doesn't export is documenting a function that doesn't exist.
+ * 2. Does the exported declaration's own shape agree with `isTag`? A tagged
+ *    template is a function whose first parameter is typed
+ *    `TemplateStringsArray` — the only shape `fold()` ever recognizes as a
+ *    tag (see ../../fold/fold.ts). Anything else (a plain function, a class,
+ *    a const object/proxy) cannot be invoked as `` Name`...` `` and must be
+ *    `isTag: false`.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import * as ts from "typescript";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface IntrinsicAuditItem {
+  name: string;
+  /** The `isTag` value as registered in `src/plugin.ts`'s `intrinsics()`. */
+  declaredIsTag: boolean | undefined;
+  /** Whether `name` resolves to a real export of `src/index.ts`. */
+  exported: boolean;
+  /**
+   * Whether the resolved declaration is genuinely authored as a tagged
+   * template (first parameter typed `TemplateStringsArray`). `undefined`
+   * when the declaration couldn't be located or its shape can't be
+   * determined statically — treated as a failure, not a pass, since a
+   * foldability claim that can't be verified is exactly the unvalidated
+   * state #1067 is closing.
+   */
+  actualIsTag: boolean | undefined;
+  /** True only when exported AND the authored shape matches `declaredIsTag`. */
+  ok: boolean;
+  detail?: string;
+}
+
+interface DeclaredIntrinsic {
+  name: string;
+  isTag: boolean | undefined;
+}
+
+interface ExportTarget {
+  /** Relative module specifier as written, e.g. "./intrinsics". */
+  modulePath: string;
+  /** The name as declared in the target module (post `as` rename resolution). */
+  localName: string;
+}
+
+// ── Parsing helpers ──────────────────────────────────────────────────
+
+function parseFile(path: string): ts.SourceFile | undefined {
+  if (!existsSync(path)) return undefined;
+  let text: string;
+  try {
+    text = readFileSync(path, "utf-8");
+  } catch {
+    return undefined;
+  }
+  return ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+
+/**
+ * Find `intrinsics(): IntrinsicDef[] { return [ ... ]; }` (or the arrow-
+ * function-property equivalent) in a plugin.ts source file and extract each
+ * registered `{ name, isTag }` pair from the array literal. Returns
+ * `undefined` when no `intrinsics` method exists at all (lexicons with no
+ * intrinsics, e.g. gcp/k8s, still return `[]` — that's a real empty array,
+ * not `undefined`).
+ */
+function extractDeclaredIntrinsics(pluginPath: string): DeclaredIntrinsic[] | undefined {
+  const sf = parseFile(pluginPath);
+  if (!sf) return undefined;
+
+  let arrayLiteral: ts.ArrayLiteralExpression | undefined;
+
+  const findReturnedArray = (body: ts.Block): ts.ArrayLiteralExpression | undefined => {
+    for (const stmt of body.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression && ts.isArrayLiteralExpression(stmt.expression)) {
+        return stmt.expression;
+      }
+    }
+    return undefined;
+  };
+
+  const visit = (node: ts.Node): void => {
+    if (arrayLiteral) return;
+
+    if (ts.isMethodDeclaration(node) && node.name && ts.isIdentifier(node.name) && node.name.text === "intrinsics" && node.body) {
+      arrayLiteral = findReturnedArray(node.body);
+    } else if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && node.name.text === "intrinsics") {
+      const init = node.initializer;
+      if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+        if (init.body && ts.isBlock(init.body)) {
+          arrayLiteral = findReturnedArray(init.body);
+        } else if (init.body && ts.isArrayLiteralExpression(init.body)) {
+          arrayLiteral = init.body;
+        }
+      }
+    }
+
+    if (!arrayLiteral) ts.forEachChild(node, visit);
+  };
+  visit(sf);
+
+  if (!arrayLiteral) return undefined;
+
+  const result: DeclaredIntrinsic[] = [];
+  for (const el of arrayLiteral.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    let name: string | undefined;
+    let isTag: boolean | undefined;
+
+    for (const prop of el.properties) {
+      if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+      const key = prop.name.text;
+      if (key === "name" && ts.isStringLiteralLike(prop.initializer)) {
+        name = prop.initializer.text;
+      } else if (key === "isTag") {
+        if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) isTag = true;
+        else if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) isTag = false;
+      }
+    }
+
+    if (name !== undefined) result.push({ name, isTag });
+  }
+
+  return result;
+}
+
+/**
+ * Build a map of publicly-exported name -> where it's really declared, by
+ * parsing `src/index.ts`'s top-level `export { a, b as c } from "./file"`
+ * statements (every lexicon's intrinsics are re-exported this way) plus
+ * direct top-level exported declarations in index.ts itself (`modulePath:
+ * "."`). Wildcard re-exports (`export * from "./generated"`) are not
+ * expanded — none of the 8 lexicons that register intrinsics export them
+ * that way, so this is a deliberate, documented gap rather than a silent one.
+ */
+function extractExportMap(indexPath: string): Map<string, ExportTarget> {
+  const map = new Map<string, ExportTarget>();
+  const sf = parseFile(indexPath);
+  if (!sf) return map;
+
+  const hasExportModifier = (node: ts.Node): boolean =>
+    !!ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+
+  for (const stmt of sf.statements) {
+    if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier && ts.isStringLiteralLike(stmt.moduleSpecifier)) {
+      const modulePath = stmt.moduleSpecifier.text;
+      if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        for (const spec of stmt.exportClause.elements) {
+          const exportedName = spec.name.text;
+          const localName = spec.propertyName ? spec.propertyName.text : exportedName;
+          map.set(exportedName, { modulePath, localName });
+        }
+      }
+      continue;
+    }
+
+    if (ts.isFunctionDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+      map.set(stmt.name.text, { modulePath: ".", localName: stmt.name.text });
+    } else if (ts.isClassDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+      map.set(stmt.name.text, { modulePath: ".", localName: stmt.name.text });
+    } else if (ts.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name)) {
+          map.set(decl.name.text, { modulePath: ".", localName: decl.name.text });
+        }
+      }
+    }
+  }
+
+  return map;
+}
+
+/** True when a parameter list's first entry is typed `TemplateStringsArray`. */
+function firstParamIsTemplateStringsArray(params: ts.NodeArray<ts.ParameterDeclaration>): boolean {
+  const first = params[0];
+  if (!first?.type || !ts.isTypeReferenceNode(first.type)) return false;
+  const typeName = first.type.typeName;
+  const text = ts.isIdentifier(typeName) ? typeName.text : typeName.right.text;
+  return text === "TemplateStringsArray";
+}
+
+/**
+ * Resolve whether the declaration named `target.localName` in the module
+ * `target.modulePath` (relative to `indexPath`) is authored as a tagged
+ * template. Returns `{ found: false }` when the declaration can't be
+ * located — a function declared but never found is treated as unverifiable,
+ * not as a pass.
+ */
+function resolveActualIsTag(
+  indexPath: string,
+  target: ExportTarget,
+): { found: boolean; isTag?: boolean } {
+  const filePath =
+    target.modulePath === "."
+      ? indexPath
+      : join(dirname(indexPath), `${target.modulePath.replace(/^\.\//, "")}.ts`);
+
+  const sf = parseFile(filePath);
+  if (!sf) return { found: false };
+
+  let result: { found: boolean; isTag?: boolean } | undefined;
+
+  for (const stmt of sf.statements) {
+    if (result) break;
+
+    if (ts.isFunctionDeclaration(stmt) && stmt.name?.text === target.localName) {
+      result = { found: true, isTag: firstParamIsTemplateStringsArray(stmt.parameters) };
+    } else if (ts.isClassDeclaration(stmt) && stmt.name?.text === target.localName) {
+      // A class is invoked with `new X(...)`, never as a tagged template.
+      result = { found: true, isTag: false };
+    } else if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name) || decl.name.text !== target.localName) continue;
+        const init = decl.initializer;
+        if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+          result = { found: true, isTag: firstParamIsTemplateStringsArray(init.parameters) };
+        } else {
+          // A const object, proxy, `new X()`, etc. — not callable as a tag.
+          result = { found: true, isTag: false };
+        }
+      }
+    }
+  }
+
+  return result ?? { found: false };
+}
+
+// ── Public entry point ───────────────────────────────────────────────
+
+/**
+ * Audit every intrinsic a lexicon registers in `src/plugin.ts` against
+ * `src/index.ts`'s real export surface and each export's authored shape.
+ * Returns `[]` for a lexicon with no `intrinsics()` method, or one that
+ * registers none — nothing to audit either way.
+ */
+export function auditIntrinsics(lexiconDir: string): IntrinsicAuditItem[] {
+  const pluginPath = join(lexiconDir, "src/plugin.ts");
+  const indexPath = join(lexiconDir, "src/index.ts");
+
+  const declared = extractDeclaredIntrinsics(pluginPath);
+  if (!declared || declared.length === 0) return [];
+
+  const exportMap = extractExportMap(indexPath);
+  const items: IntrinsicAuditItem[] = [];
+
+  for (const d of declared) {
+    const target = exportMap.get(d.name);
+
+    if (!target) {
+      items.push({
+        name: d.name,
+        declaredIsTag: d.isTag,
+        exported: false,
+        actualIsTag: undefined,
+        ok: false,
+        detail: `"${d.name}" is registered in plugin.ts intrinsics() but is not exported from src/index.ts`,
+      });
+      continue;
+    }
+
+    const resolved = resolveActualIsTag(indexPath, target);
+    if (!resolved.found) {
+      items.push({
+        name: d.name,
+        declaredIsTag: d.isTag,
+        exported: true,
+        actualIsTag: undefined,
+        ok: false,
+        detail: `could not locate the declaration of "${d.name}" (exported from ${target.modulePath}) to verify it against isTag`,
+      });
+      continue;
+    }
+
+    const declaredTag = d.isTag === true;
+    const ok = resolved.isTag === declaredTag;
+    items.push({
+      name: d.name,
+      declaredIsTag: d.isTag,
+      exported: true,
+      actualIsTag: resolved.isTag,
+      ok,
+      detail: ok
+        ? undefined
+        : resolved.isTag
+          ? `"${d.name}" is authored as a tagged template (first param: TemplateStringsArray) but registered with isTag: ${d.isTag ?? "undefined"}`
+          : `"${d.name}" is a plain call/declaration (not a tagged template) but registered with isTag: true`,
+    });
+  }
+
+  return items;
+}

package/src/cli/commands/check-lexicon.test.ts

@@ -0,0 +1,34 @@
+import { describe, test, expect } from "vitest";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkLexicon } from "./check-lexicon";
+
+// chant #1067 — check-lexicon.ts had zero tests before this issue, despite
+// being the tool meant to gate every lexicon's completeness. This locks in
+// that checkLexicon() actually wires the new semantic checks (intrinsic
+// foldability audit, example-build audit) into its tier-1 results — not
+// just the pre-existing existence/count checks — against a real,
+// already-built lexicon in this repo.
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..", "..");
+const gitlabDir = join(repoRoot, "lexicons", "gitlab");
+
+describe("checkLexicon", () => {
+  test("includes the new #1067 tier-1 checks by name", async () => {
+    const result = await checkLexicon(gitlabDir);
+    const names = result.items.map((i) => i.name);
+    expect(names).toContain("Every shipped example builds");
+    expect(names).toContain("Registered intrinsics are exported by the package");
+    expect(names).toContain("Registered intrinsics' isTag matches how they're authored");
+    expect(names).toContain("dist/manifest.json declares a chantVersion");
+    expect(names).toContain('package.json routes exports["."].default at ./src/index.ts and deletes emitted JS in build');
+  });
+
+  test("gitlab's own reference() intrinsic passes both the export and isTag audits", async () => {
+    const result = await checkLexicon(gitlabDir);
+    const exported = result.items.find((i) => i.name === "Registered intrinsics are exported by the package");
+    const matches = result.items.find((i) => i.name === "Registered intrinsics' isTag matches how they're authored");
+    expect(exported?.pass).toBe(true);
+    expect(matches?.pass).toBe(true);
+  });
+});