@mrciphersmith/keryx 0.2.83 → 0.2.84

package/src/gdgraph/treesitter/extract.test.ts

@@ -1,278 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expect, test } from "bun:test";
-import { extractSymbolLayer, type TsNode } from "./extract";
-import type { CallEdge, SymbolNode } from "../types";
-
-const FIXTURE_DIR = fileURLToPath(new URL("../../../fixtures/symbol-graph/", import.meta.url));
-
-// --- Minimal mock syntax-tree builder (a structural stand-in for a parsed
-// `web-tree-sitter` tree; the extractor is dependency-free). ---
-interface MockOptions {
-  type: string;
-  line?: number;
-  endLine?: number;
-  text?: string;
-  fields?: Record<string, TsNode | null>;
-  namedChildren?: TsNode[];
-}
-
-function mk(o: MockOptions): TsNode {
-  const line = o.line ?? 1;
-  const endLine = o.endLine ?? line;
-  const named = o.namedChildren ?? [];
-  return {
-    type: o.type,
-    text: o.text ?? "",
-    startPosition: { row: line - 1, column: 0 },
-    endPosition: { row: endLine - 1, column: 0 },
-    childForFieldName: (field: string) => o.fields?.[field] ?? null,
-    namedChildren: named,
-    children: named,
-  };
-}
-
-const idNode = (text: string): TsNode => mk({ type: "identifier", text });
-const paramsNode = (): TsNode => mk({ type: "formal_parameters", text: "()" });
-const callTo = (name: string, line: number): TsNode =>
-  mk({ type: "call_expression", line, fields: { function: idNode(name) }, text: `${name}()` });
-
-// Build the tree modeling `fixtures/symbol-graph/source.ts`.
-export function buildWidgetTree(): TsNode {
-  const alphaBody = mk({ type: "statement_block", line: 1, namedChildren: [callTo("helper", 1)] });
-  const funcAlpha = mk({
-    type: "function_declaration",
-    line: 1,
-    endLine: 1,
-    fields: { name: idNode("alpha"), parameters: paramsNode() },
-    namedChildren: [alphaBody],
-  });
-  const funcHelper = mk({
-    type: "function_declaration",
-    line: 2,
-    endLine: 2,
-    fields: { name: idNode("helper"), parameters: paramsNode() },
-  });
-  const renderBody = mk({ type: "statement_block", line: 4, namedChildren: [callTo("alpha", 4)] });
-  const methodRender = mk({
-    type: "method_definition",
-    line: 4,
-    endLine: 4,
-    fields: { name: idNode("render"), parameters: paramsNode() },
-    namedChildren: [renderBody],
-  });
-  const classBody = mk({ type: "class_body", line: 3, endLine: 5, namedChildren: [methodRender] });
-  const classWidget = mk({
-    type: "class_declaration",
-    line: 3,
-    endLine: 5,
-    fields: { name: idNode("Widget") },
-    namedChildren: [classBody],
-  });
-  const interfaceShape = mk({
-    type: "interface_declaration",
-    line: 6,
-    endLine: 6,
-    fields: { name: idNode("Shape") },
-  });
-  return mk({
-    type: "program",
-    line: 1,
-    endLine: 6,
-    namedChildren: [funcAlpha, funcHelper, classWidget, interfaceShape],
-  });
-}
-
-async function loadJsonl<T>(file: string): Promise<T[]> {
-  const content = await readFile(file, "utf8");
-  return content
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => JSON.parse(line) as T);
-}
-
-function prf(produced: Set<string>, expected: Set<string>): { precision: number; recall: number } {
-  let truePos = 0;
-  for (const item of produced) {
-    if (expected.has(item)) {
-      truePos += 1;
-    }
-  }
-  return {
-    precision: produced.size === 0 ? 0 : truePos / produced.size,
-    recall: expected.size === 0 ? 0 : truePos / expected.size,
-  };
-}
-
-test("AC1.2/AC1.3 — extracted symbols/calls hit precision ≥ 0.90 and recall ≥ 0.85", async () => {
-  const layer = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
-  const expectedSymbols = await loadJsonl<SymbolNode>(path.join(FIXTURE_DIR, "expected", "symbols.jsonl"));
-  const expectedCalls = await loadJsonl<CallEdge>(path.join(FIXTURE_DIR, "expected", "calls.jsonl"));
-
-  const symbolKey = (s: SymbolNode) => `${s.id}|${s.kind}|${s.startLine}`;
-  const callKey = (c: CallEdge) => `${c.kind}|${c.from}|${c.to}`;
-
-  const symbolPrf = prf(new Set(layer.symbols.map(symbolKey)), new Set(expectedSymbols.map(symbolKey)));
-  const callPrf = prf(new Set(layer.calls.map(callKey)), new Set(expectedCalls.map(callKey)));
-
-  expect(symbolPrf.precision).toBeGreaterThanOrEqual(0.9);
-  expect(symbolPrf.recall).toBeGreaterThanOrEqual(0.85);
-  expect(callPrf.precision).toBeGreaterThanOrEqual(0.9);
-  expect(callPrf.recall).toBeGreaterThanOrEqual(0.85);
-});
-
-test("AC1.1 — emits function/class/method/interface nodes + calls/defines/unresolved edges", () => {
-  const layer = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
-  const kinds = new Set(layer.symbols.map((symbol) => symbol.kind));
-  expect(kinds).toEqual(new Set(["function", "class", "method", "interface"]));
-  const callKinds = new Set(layer.calls.map((call) => call.kind));
-  expect(callKinds.has("defines")).toBe(true);
-  expect(callKinds.has("calls")).toBe(true);
-});
-
-test("AC1.4 — symbol ids are stable + content-independent; re-run is byte-identical", () => {
-  const a = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
-  const b = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
-  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
-  expect(a.symbols.map((symbol) => symbol.id)).toEqual([
-    "src/widget.ts#alpha",
-    "src/widget.ts#helper",
-    "src/widget.ts#Widget",
-    "src/widget.ts#Widget.render",
-    "src/widget.ts#Shape",
-  ]);
-});
-
-test("AC1.4 — colliding names get a positional @startLine disambiguator only", () => {
-  const idNodeLocal = (text: string): TsNode => mk({ type: "identifier", text });
-  const dup1 = mk({
-    type: "function_declaration",
-    line: 1,
-    endLine: 1,
-    fields: { name: idNodeLocal("dup"), parameters: paramsNode() },
-  });
-  const dup2 = mk({
-    type: "function_declaration",
-    line: 5,
-    endLine: 5,
-    fields: { name: idNodeLocal("dup"), parameters: paramsNode() },
-  });
-  const unique = mk({
-    type: "function_declaration",
-    line: 9,
-    endLine: 9,
-    fields: { name: idNodeLocal("only"), parameters: paramsNode() },
-  });
-  const root = mk({ type: "program", line: 1, endLine: 9, namedChildren: [dup1, dup2, unique] });
-  const layer = extractSymbolLayer(root, "src/dup.ts", "typescript");
-  const ids = layer.symbols.map((symbol) => symbol.id);
-  expect(ids).toEqual(["src/dup.ts#dup@1", "src/dup.ts#dup@5", "src/dup.ts#only"]);
-});
-
-test("unresolved calls to unknown callees are kept as unresolved-call edges", () => {
-  const idNodeLocal = (text: string): TsNode => mk({ type: "identifier", text });
-  const body = mk({
-    type: "statement_block",
-    line: 1,
-    namedChildren: [
-      mk({ type: "call_expression", line: 1, fields: { function: idNodeLocal("externalThing") }, text: "externalThing()" }),
-    ],
-  });
-  const fn = mk({
-    type: "function_declaration",
-    line: 1,
-    endLine: 2,
-    fields: { name: idNodeLocal("main"), parameters: paramsNode() },
-    namedChildren: [body],
-  });
-  const root = mk({ type: "program", line: 1, endLine: 2, namedChildren: [fn] });
-  const layer = extractSymbolLayer(root, "src/main.ts", "typescript");
-  const unresolved = layer.calls.filter((call) => call.kind === "unresolved-call");
-  expect(unresolved).toHaveLength(1);
-  expect(unresolved[0]?.to).toBe("externalThing");
-  expect(unresolved[0]?.resolved).toBe(false);
-});
-
-test("Java class and method extraction", () => {
-  const idNode = (text: string): TsNode => mk({ type: "identifier", text });
-  const methodBody = mk({ type: "block", line: 4, namedChildren: [
-    mk({ type: "method_invocation", line: 4, fields: { method: idNode("helper") }, text: "helper()" }),
-  ]});
-  const methodHelper = mk({
-    type: "method_declaration",
-    line: 3,
-    endLine: 3,
-    fields: { name: idNode("helper"), parameters: mk({ type: "formal_parameters", text: "()" }) },
-  });
-  const methodMain = mk({
-    type: "method_declaration",
-    line: 4,
-    endLine: 5,
-    fields: { name: idNode("main"), parameters: mk({ type: "formal_parameters", text: "()" }) },
-    namedChildren: [methodBody],
-  });
-  const classBody = mk({ type: "class_body", line: 2, endLine: 6, namedChildren: [methodHelper, methodMain] });
-  const classApp = mk({
-    type: "class_declaration",
-    line: 1,
-    endLine: 6,
-    fields: { name: idNode("App") },
-    namedChildren: [classBody],
-  });
-  const root = mk({ type: "program", line: 1, endLine: 6, namedChildren: [classApp] });
-  const layer = extractSymbolLayer(root, "src/App.java", "java");
-
-  expect(layer.symbols).toHaveLength(3); // App class + 2 methods
-  const classSymbol = layer.symbols.find((s) => s.name === "App");
-  expect(classSymbol).toBeDefined();
-  expect(classSymbol?.kind).toBe("class");
-
-  const methods = layer.symbols.filter((s) => s.kind === "method");
-  expect(methods).toHaveLength(2);
-});
-
-test("Python function and class extraction", () => {
-  const idNode = (text: string): TsNode => mk({ type: "identifier", text });
-  const funcBody = mk({ type: "block", line: 4, namedChildren: [
-    mk({ type: "call", line: 4, fields: { function: idNode("helper") }, text: "helper()" }),
-  ]});
-  const funcHelper = mk({
-    type: "function_definition",
-    line: 2,
-    endLine: 2,
-    fields: { name: idNode("helper"), parameters: mk({ type: "parameters", text: "()" }) },
-  });
-  const funcMain = mk({
-    type: "function_definition",
-    line: 4,
-    endLine: 5,
-    fields: { name: idNode("main"), parameters: mk({ type: "parameters", text: "()" }) },
-    namedChildren: [funcBody],
-  });
-  const methodProcess = mk({
-    type: "function_definition",
-    line: 8,
-    endLine: 8,
-    fields: { name: idNode("process"), parameters: mk({ type: "parameters", text: "(self)" }) },
-  });
-  const classBody = mk({ type: "block", line: 7, endLine: 9, namedChildren: [methodProcess] });
-  const classApp = mk({
-    type: "class_definition",
-    line: 6,
-    endLine: 9,
-    fields: { name: idNode("App") },
-    namedChildren: [classBody],
-  });
-  const root = mk({ type: "program", line: 1, endLine: 9, namedChildren: [funcHelper, funcMain, classApp] });
-  const layer = extractSymbolLayer(root, "src/main.py", "python");
-
-  expect(layer.symbols).toHaveLength(4); // 2 functions + 1 class + 1 nested function (process)
-  const classSymbol = layer.symbols.find((s) => s.name === "App");
-  expect(classSymbol).toBeDefined();
-  expect(classSymbol?.kind).toBe("class");
-
-  const functions = layer.symbols.filter((s) => s.kind === "function");
-  expect(functions.length).toBeGreaterThan(0); // Should have at least the top-level functions
-});

package/src/gdgraph/treesitter/no-treesitter-import.test.ts

@@ -1,51 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expect, test } from "bun:test";
-
-// AC1.5 (C0-2): `web-tree-sitter` is imported ONLY via `await import()` inside
-// `src/gdgraph/treesitter/adapter.ts`. This is an ADDITIVE, gdgraph-specific
-// assertion layered on the generic `src/capability/no-optional-imports.test.ts`
-// (which already scans every optionalDependencies package across `src/`).
-
-const SRC_ROOT = fileURLToPath(new URL("../../", import.meta.url));
-const ADAPTER = path.join(SRC_ROOT, "gdgraph", "treesitter", "adapter.ts");
-
-async function tsFiles(dir: string): Promise<string[]> {
-  const entries = await readdir(dir, { withFileTypes: true });
-  const files: string[] = [];
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...(await tsFiles(full)));
-    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-
-test("no static import of web-tree-sitter anywhere in src/", async () => {
-  const files = await tsFiles(SRC_ROOT);
-  const staticImport = /\b(?:import|export)\b[^()]*?\bfrom\s*['"]web-tree-sitter['"]|\bimport\s*['"]web-tree-sitter['"]|\brequire\s*\(\s*['"]web-tree-sitter['"]\s*\)/;
-  const violations: string[] = [];
-  for (const file of files) {
-    const content = await readFile(file, "utf8");
-    if (staticImport.test(content)) {
-      violations.push(path.relative(SRC_ROOT, file));
-    }
-  }
-  expect(violations).toEqual([]);
-});
-
-test("adapter declares web-tree-sitter as a lazy optionalDependency, never a static import", async () => {
-  const content = await readFile(ADAPTER, "utf8");
-  // The dep is loaded lazily by the seam (`await import(spec.optionalDependency)`
-  // in capability/seam.ts) using the id the adapter declares here.
-  expect(content).toContain('optionalDependency: "web-tree-sitter"');
-  // The adapter never statically imports the dep (types are structural).
-  expect(/from\s*['"]web-tree-sitter['"]/.test(content)).toBe(false);
-
-  const seam = await readFile(path.join(SRC_ROOT, "capability", "seam.ts"), "utf8");
-  expect(seam).toContain("await import(spec.optionalDependency)");
-});

package/src/gdgraph/treesitter/real-grammar-fixture.test.ts

@@ -1,71 +0,0 @@
-// AFC-13 / AC5 requirement 4: "fixture даёт реальные symbols после явной
-// установки" — a fixture that genuinely yields real symbols after an
-// explicit runtime/grammar installation. This task is forbidden from
-// performing that installation (no dependency installs of any kind).
-//
-// So this file does NOT install anything. It probes whether a working
-// `web-tree-sitter` runtime + a real, verified grammar are ALREADY present in
-// this environment (exactly the state an explicit install would produce) and:
-//   - genuinely present  ⇒ the test RUNS FOR REAL against the real adapter
-//     (`resolveTreesitterCapability`, the actual production entry point —
-//     not a mock) and asserts real, non-empty symbols extracted from a real
-//     TypeScript fixture by the real grammar.
-//   - genuinely absent   ⇒ `test.skipIf` marks the test SKIPPED (visible as
-//     "skip" in `bun test`'s own summary, not a silent pass), with the reason
-//     embedded in the test name.
-//
-// A vacuous pass (the "absent" branch quietly returning without asserting
-// anything) would NOT be evidence for requirement 4 — `test.skipIf` is used
-// specifically so an absent environment shows up as a skip, never as a pass.
-
-import { expect, test } from "bun:test";
-import { resolveTreesitterCapability } from "./adapter";
-
-const FIXTURE_SOURCE = ["export function boot(): void {", "  tick();", "}", "", "function tick(): void {}", ""].join(
-  "\n",
-);
-
-// Probed once at module load (top-level await — this file's only test needs
-// the answer before `test.skipIf` decides whether to run). This calls the
-// REAL `resolveTreesitterCapability` against the real project root, so it
-// reflects whatever runtime + grammar state is genuinely on this machine —
-// no mocking, no injected `dep`.
-const projectRoot = process.cwd();
-const probedAdapter = await resolveTreesitterCapability(projectRoot, {
-  languages: ["typescript"],
-  grammarsPath: null,
-});
-const skipReason = probedAdapter
-  ? ""
-  : "no working web-tree-sitter runtime + verified typescript grammar resolved in this environment " +
-    "(gdgraph.treesitter must be enabled in metaproject.json AND a matching grammar installed via " +
-    '"keryx gdgraph assets pull tree-sitter-typescript" — an install this task must not perform)';
-
-test.skipIf(!probedAdapter)(
-  skipReason ? `AC5.req4 — real fixture yields real symbols [SKIPPED: ${skipReason}]` : "AC5.req4 — real fixture yields real symbols after explicit installation",
-  async () => {
-    const adapter = probedAdapter;
-    if (!adapter) {
-      // Unreachable when the test actually runs (skipIf gates it), kept only
-      // so TypeScript sees the non-null adapter below without a cast.
-      throw new Error("AC5.req4 ran without a resolved adapter — skipIf condition was wrong");
-    }
-
-    const layer = await adapter.run({
-      files: [{ path: "fixtures/treesitter/ac5-req4-fixture.ts", content: FIXTURE_SOURCE }],
-    });
-
-    // Real symbols, not a mock's canned output: names, kinds, and a resolved
-    // call edge all come from the actually-installed tree-sitter grammar
-    // parsing actual TypeScript source.
-    expect(layer.symbols.length).toBeGreaterThan(0);
-    const byName = Object.fromEntries(layer.symbols.map((s) => [s.name, s]));
-    expect(byName.boot).toMatchObject({ kind: "function", language: "typescript" });
-    expect(byName.tick).toMatchObject({ kind: "function", language: "typescript" });
-
-    const callSummaries = layer.calls.map((c) => `${c.kind}:${c.from}=>${c.to}`);
-    expect(callSummaries).toContain(
-      "calls:fixtures/treesitter/ac5-req4-fixture.ts#boot=>fixtures/treesitter/ac5-req4-fixture.ts#tick",
-    );
-  },
-);

package/src/gdgraph/treesitter/resolve-calls.test.ts

@@ -1,38 +0,0 @@
-import { expect, test } from "bun:test";
-import { resolveCrossFileCalls } from "./extract";
-import type { CallEdge, SymbolNode } from "../types";
-
-function sym(id: string, name: string, path: string): SymbolNode {
-  return { id, kind: "function", path, name, container: null, startLine: 1, endLine: 2, language: "typescript" };
-}
-function unresolved(from: string, to: string): CallEdge {
-  return { id: `u:${from}=>${to}`, from, to, kind: "unresolved-call", resolved: false };
-}
-
-test("resolves a cross-file member call to a globally-unique symbol", () => {
-  const symbols = [sym("src/a.ts#runPipeline", "runPipeline", "src/a.ts"), sym("src/b.ts#caller", "caller", "src/b.ts")];
-  // caller (in b.ts) calls `TasksApi.runPipeline` — cross-file, unresolved by per-file extraction
-  const calls = [unresolved("src/b.ts#caller", "TasksApi.runPipeline")];
-  const out = resolveCrossFileCalls(symbols, calls);
-  expect(out).toHaveLength(1);
-  expect(out[0]).toMatchObject({ from: "src/b.ts#caller", to: "src/a.ts#runPipeline", kind: "calls", resolved: true });
-});
-
-test("leaves an ambiguous name (multiple defs) unresolved — never guesses", () => {
-  const symbols = [
-    sym("src/a.ts#clonePipeline", "clonePipeline", "src/a.ts"),
-    sym("src/b.ts#clonePipeline", "clonePipeline", "src/b.ts"),
-    sym("src/c.ts#caller", "caller", "src/c.ts"),
-  ];
-  const out = resolveCrossFileCalls(symbols, [unresolved("src/c.ts#caller", "x.clonePipeline")]);
-  expect(out[0]?.kind).toBe("unresolved-call");
-});
-
-test("drops self-edges and passes resolved calls through unchanged", () => {
-  const symbols = [sym("src/a.ts#f", "f", "src/a.ts")];
-  const resolved: CallEdge = { id: "c", from: "src/a.ts#g", to: "src/a.ts#f", kind: "calls", resolved: true };
-  const out = resolveCrossFileCalls(symbols, [unresolved("src/a.ts#f", "f"), resolved]);
-  // the self-call f->f is not added as a resolved edge; the pre-resolved call stays
-  expect(out.some((c) => c.kind === "calls" && c.from === "src/a.ts#f" && c.to === "src/a.ts#f")).toBe(false);
-  expect(out).toContainEqual(resolved);
-});

package/src/gdgraph/wiki-layer-no-git.test.ts

@@ -1,73 +0,0 @@
-// Flow 223 AC11: nothing phase 0 adds may depend on git.
-//
-// Different projects treat `.metaproject/` differently, and
-// `src/commands/init.no-git.test.ts` already pins "no git at all" as a
-// supported state. The describe edge, the wiki layer, the build manifest and
-// page provenance must therefore all work on a bare directory — this suite is
-// the guard that keeps a future `git` call from creeping into that path.
-
-import { expect, test } from "bun:test";
-import { mkdtemp, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { computeVerifiedScope, parseProvenance, writeProvenance } from "../wiki/provenance";
-import { buildGraph } from "./build";
-import { getFilesDescribedBy, loadGraph } from "./query";
-
-async function bareProject(): Promise<string> {
-  const root = await mkdtemp(path.join(tmpdir(), "lwg-nogit-"));
-  await mkdir(path.join(root, "src", "ctx"), { recursive: true });
-  await writeFile(path.join(root, "src", "ctx", "index.ts"), 'export * from "./run";\n');
-  await writeFile(path.join(root, "src", "ctx", "run.ts"), "export const run = () => 1;\n");
-  await mkdir(path.join(root, ".metaproject", "wiki", "components"), { recursive: true });
-  await writeFile(
-    path.join(root, ".metaproject", "wiki", "components", "src-ctx.md"),
-    "# src/ctx\nVersion: 1.0.0\nType: component\nStatus: accepted\nDescribes:\n  - src/ctx/**\n",
-  );
-  return root;
-}
-
-test("the whole phase-0 path works with no .git directory anywhere", async () => {
-  const root = await bareProject();
-
-  // Two builds: the first writes nodes.jsonl, the second sees a module set.
-  await buildGraph(root);
-  await buildGraph(root);
-
-  const graph = await loadGraph(root);
-  expect(graph.wikiPages?.[0]?.id).toBe("wiki:components/src-ctx.md");
-  expect(getFilesDescribedBy(graph, "wiki:components/src-ctx.md")).toEqual([
-    "src/ctx/index.ts",
-    "src/ctx/run.ts",
-  ]);
-
-  // VerifiedScope is the git-free freshness path; it must compute here.
-  const scope = await computeVerifiedScope(root, ["src/ctx/index.ts", "src/ctx/run.ts"], graph);
-  expect(scope).toMatch(/^sha256:[0-9a-f]{64}$/);
-
-  const pagePath = path.join(root, ".metaproject", "wiki", "components", "src-ctx.md");
-  const stamped = writeProvenance(await readFile(pagePath, "utf8"), { verifiedScope: scope });
-  await writeFile(pagePath, stamped);
-  expect(parseProvenance(await readFile(pagePath, "utf8")).verifiedScope).toBe(scope);
-
-  // And no `.git` was created along the way.
-  expect(await readdir(root)).not.toContain(".git");
-});
-
-test("a page carrying VerifiedAt but no reachable git history still resolves", async () => {
-  const root = await bareProject();
-  const pagePath = path.join(root, ".metaproject", "wiki", "components", "src-ctx.md");
-  await writeFile(
-    pagePath,
-    writeProvenance(await readFile(pagePath, "utf8"), { verifiedAt: "a".repeat(40) }),
-  );
-
-  await buildGraph(root);
-  await buildGraph(root);
-
-  // The sha is parsed and kept; deciding it is unreachable is phase 1's job,
-  // and must not become a build-time failure here (specification §4.1 path 2).
-  expect(parseProvenance(await readFile(pagePath, "utf8")).verifiedAt).toBe("a".repeat(40));
-  const graph = await loadGraph(root);
-  expect(graph.wikiPages?.[0]?.undecidable).toBe(false);
-});