@gotgenes/pi-permission-system 18.1.0 → 18.1.2

package/src/access-intent/bash/msys-bash-tokens.ts

@@ -0,0 +1,64 @@
+/**
+ * Pure shape classifier for a bash-command token on a win32 host, where Pi core
+ * executes commands through Git Bash and POSIX-shaped absolute tokens carry
+ * MSYS mount semantics rather than `node:path.win32` semantics.
+ *
+ * Consumed only by {@link PathNormalizer.forBashToken}; kept as a standalone
+ * module so the shape knowledge is unit-testable in isolation (no filesystem,
+ * no platform read).
+ */
+import { isSafeSystemPath } from "#src/safe-system-paths";
+
+/**
+ * The MSYS interpretation of a win32 bash token:
+ *
+ * - `device` — a safe MSYS runtime device (`/dev/null`, `/dev/std{in,out,err}`);
+ *   never a filesystem path.
+ * - `drive-mount` — an MSYS drive mount (`/c/…`, `/d/…`); `windowsPath` is its
+ *   deterministic Windows equivalent (`C:\…`).
+ * - `posix-absolute` — any other absolute POSIX path (`/tmp/foo`, `/usr/bin`);
+ *   its Windows target is install-dependent and not deterministically knowable,
+ *   so it is treated literally.
+ * - `plain` — everything else (relative tokens, `~/…`, native Windows drive
+ *   paths); handled by ordinary win32 resolution.
+ */
+export type Win32BashTokenKind =
+  | { kind: "device" }
+  | { kind: "drive-mount"; windowsPath: string }
+  | { kind: "posix-absolute" }
+  | { kind: "plain" };
+
+/**
+ * A single-letter first path segment identifies an MSYS drive mount: `/c`,
+ * `/c/`, or `/c/rest`. A multi-letter first segment (`/dev`, `/tmp`) is not a
+ * mount. The device set is checked before this pattern, so `/dev/*` never
+ * reaches it.
+ */
+const MSYS_DRIVE_MOUNT_PATTERN = /^\/([a-zA-Z])(\/.*)?$/;
+
+export function classifyWin32BashToken(token: string): Win32BashTokenKind {
+  if (isSafeSystemPath(token)) return { kind: "device" };
+
+  const driveMatch = MSYS_DRIVE_MOUNT_PATTERN.exec(token);
+  if (driveMatch) {
+    return {
+      kind: "drive-mount",
+      windowsPath: toWindowsDrivePath(driveMatch[1], driveMatch[2]),
+    };
+  }
+
+  if (token.startsWith("/")) return { kind: "posix-absolute" };
+
+  return { kind: "plain" };
+}
+
+/**
+ * Build the Windows equivalent of an MSYS drive mount: uppercase drive letter,
+ * `:\`, and the remainder with `/` separators rewritten to `\`. A bare or
+ * trailing-slash mount (`/c`, `/c/`) maps to the drive root (`C:\`).
+ */
+function toWindowsDrivePath(letter: string, rest: string | undefined): string {
+  const drive = `${letter.toUpperCase()}:`;
+  const tail = (rest ?? "").replace(/^\//, "").replaceAll("/", "\\");
+  return tail ? `${drive}\\${tail}` : `${drive}\\`;
+}

package/src/path-normalizer.ts

@@ -1,9 +1,11 @@
 import { posix as posixPath, win32 as winPath } from "node:path";
 
 import { AccessPath } from "./access-intent/access-path";
+import { classifyWin32BashToken } from "./access-intent/bash/msys-bash-tokens";
 import {
   canonicalNormalizePathForComparison,
   normalizePathForComparison,
+  normalizePathPolicyLiteral,
 } from "./access-intent/path-normalization";
 import {
   isPathOutsideWorkingDirectory,
@@ -11,6 +13,22 @@ import {
 } from "./path-containment";
 import { isPiInfrastructureRead } from "./pi-infrastructure-read";
 
+/**
+ * The interpreted effect of a literal `cd` target on the effective base, under
+ * the host platform's (and, on win32, Git Bash's) semantics.
+ *
+ * - `absolute` — the target names a resolvable absolute base (`value`); an
+ *   earlier unknown base is recovered.
+ * - `relative` — the target folds into the current base.
+ * - `unknown` — the target is not deterministically resolvable (a win32
+ *   non-mount POSIX absolute like `cd /tmp`, or a device), so the base becomes
+ *   conservatively unknown.
+ */
+export type BashCdTarget =
+  | { readonly kind: "absolute"; readonly value: string }
+  | { readonly kind: "relative" }
+  | { readonly kind: "unknown" };
+
 /**
  * Path-interpretation collaborator, constructed once at the session edge with
  * the two ambient inputs — the host `platform` and the session `cwd` — baked
@@ -47,8 +65,46 @@ export class PathNormalizer {
   }
 
   /** Build a literal-only AccessPath (unknown base after a non-literal `cd`). */
-  forLiteral(literal: string): AccessPath {
-    return AccessPath.forLiteral(literal);
+  forLiteral(literal: string, matchAliases?: readonly string[]): AccessPath {
+    return AccessPath.forLiteral(literal, matchAliases);
+  }
+
+  /**
+   * Build an AccessPath for a bash-command token, applying Git Bash/MSYS
+   * semantics on a win32 host.
+   *
+   * Pi core always executes bash through Git Bash on Windows, so a POSIX-shaped
+   * absolute token carries MSYS semantics, not `node:path.win32` semantics. On
+   * win32 the recognized safe device paths (`/dev/null`, `/dev/std{in,out,err}`)
+   * are preserved verbatim as devices instead of being resolved into
+   * `c:\dev\null`, and MSYS drive mounts (`/c/…`) are translated to their
+   * Windows equivalent (`C:\…`) before resolution; every other token delegates
+   * to {@link forPath}. On POSIX this is a straight delegation to
+   * {@link forPath}.
+   */
+  forBashToken(token: string, options?: { resolveBase?: string }): AccessPath {
+    if (this.platform !== "win32") return this.forPath(token, options);
+
+    const shape = classifyWin32BashToken(token);
+    switch (shape.kind) {
+      case "device":
+        return AccessPath.forDevice(token);
+      case "drive-mount":
+        return this.forPath(shape.windowsPath, options);
+      case "posix-absolute": {
+        // A non-mount POSIX absolute (`/tmp`, `/usr`) has an install-dependent
+        // Windows target this package cannot know, so it is kept literal: always
+        // external, matched and displayed as typed, never fabricated into
+        // `c:\tmp` (#533). The win32 path matcher folds a rule's separators
+        // (`/` -> `\`), so a forward-slash value is unmatchable; carry a
+        // backslash match alias so a natural `/tmp/*` external_directory rule
+        // still resolves, while `value()` stays as typed for display.
+        const literal = normalizePathPolicyLiteral(token);
+        return this.forLiteral(literal, [literal.replaceAll("/", "\\")]);
+      }
+      case "plain":
+        return this.forPath(token, options);
+    }
   }
 
   /** Platform-aware absoluteness (`win32` vs `posix` rules). */
@@ -56,6 +112,36 @@ export class PathNormalizer {
     return this.impl.isAbsolute(pathValue);
   }
 
+  /**
+   * Interpret a literal `cd` target's effect on the effective base.
+   *
+   * On win32 the target carries Git Bash/MSYS semantics: a drive mount
+   * (`cd /c/x`) resolves to a translated Windows base (`C:\x`), a non-mount
+   * POSIX absolute (`cd /tmp`) is not deterministically resolvable and yields an
+   * `unknown` base, and a native/relative target is handled as usual. On POSIX
+   * an absolute target is absolute and everything else is relative.
+   */
+  interpretBashCdTarget(target: string): BashCdTarget {
+    if (this.platform !== "win32") {
+      return this.impl.isAbsolute(target)
+        ? { kind: "absolute", value: target }
+        : { kind: "relative" };
+    }
+
+    const shape = classifyWin32BashToken(target);
+    switch (shape.kind) {
+      case "drive-mount":
+        return { kind: "absolute", value: shape.windowsPath };
+      case "device":
+      case "posix-absolute":
+        return { kind: "unknown" };
+      case "plain":
+        return this.impl.isAbsolute(target)
+          ? { kind: "absolute", value: target }
+          : { kind: "relative" };
+    }
+  }
+
   /** Resolve a `cd`-folded offset against the baked cwd (platform-aware). */
   resolveBase(offset: string): string {
     return this.impl.resolve(this.cwd, offset);
@@ -85,6 +171,23 @@ export class PathNormalizer {
     );
   }
 
+  /**
+   * Outside-cwd test for an already-canonical boundary value (from
+   * {@link AccessPath.boundaryValue}), against the baked cwd.
+   *
+   * Unlike {@link isOutsideWorkingDirectory}, it does not re-derive the
+   * canonical form — the caller passes a value the {@link AccessPath} already
+   * canonicalized, so a device's preserved `/dev/null` reaches the pure check's
+   * `isSafeSystemPath` exclusion intact.
+   */
+  isBoundaryOutsideWorkingDirectory(canonicalPath: string): boolean {
+    return isPathOutsideWorkingDirectory(
+      canonicalPath,
+      this.canonicalCwd,
+      this.platform,
+    );
+  }
+
   /**
    * Lexical (not symlink-resolved) comparison value, resolved against the baked
    * cwd. Mirrors the as-typed absolute form used for skill-prompt matching;

package/test/access-intent/access-path.test.ts

@@ -1,277 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-
-// Mock node:os so tilde-expansion is deterministic across platforms.
-vi.mock("node:os", () => {
-  const homedir = vi.fn(() => "/mock/home");
-  return {
-    homedir,
-    default: { homedir },
-  };
-});
-
-// Mock node:fs so realpathSync (used by canonicalizePath) is controllable.
-// Default implementation is identity — lexical tests are unaffected.
-const realpathSync = vi.hoisted(() =>
-  vi.fn<(path: string) => string>((p) => p),
-);
-vi.mock("node:fs", () => ({
-  realpathSync,
-  default: { realpathSync },
-}));
-
-import { AccessPath } from "#src/access-intent/access-path";
-
-describe("AccessPath.forPath", () => {
-  const cwd = "/projects/my-app";
-
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  describe("matchValues()", () => {
-    test("adds the symlink-resolved alias alongside the typed path", () => {
-      // /tmp -> /private/tmp (the macOS symlink from the bug report, #418).
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      expect(
-        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).matchValues(),
-      ).toEqual(["/tmp/x", "/private/tmp/x"]);
-    });
-
-    test("deduplicates when the canonical form equals the lexical form", () => {
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/etc/hosts"]);
-    });
-
-    test("keeps the relative aliases for an in-cwd token without duplicating", () => {
-      expect(
-        AccessPath.forPath("src/foo.ts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/projects/my-app/src/foo.ts", "src/foo.ts"]);
-    });
-
-    test("includes only the lexical aliases when canonical is empty", () => {
-      // Force canonicalizePath to return the original (no-op symlink resolution
-      // effectively means canonical === lexical, handled by dedup).
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).not.toHaveLength(0);
-    });
-
-    test("resolves a relative token against an explicit resolveBase", () => {
-      // The cd-folded effective base differs from cwd (the bash-path case).
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/projects/my-app/sub/foo.ts", "sub/foo.ts", "foo.ts"]);
-    });
-
-    test("adds the canonical alias resolved against resolveBase", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p === "/projects/my-app/sub/foo.ts" ? "/real/foo.ts" : p,
-      );
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual([
-        "/projects/my-app/sub/foo.ts",
-        "sub/foo.ts",
-        "foo.ts",
-        "/real/foo.ts",
-      ]);
-    });
-  });
-
-  describe("platform option", () => {
-    test("win32: builds lexical/match/boundary values with win32 rules", () => {
-      const ap = AccessPath.forPath("src\\foo.ts", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      });
-      expect(ap.value()).toBe("c:\\projects\\app\\src\\foo.ts");
-      expect(ap.boundaryValue()).toBe("c:\\projects\\app\\src\\foo.ts");
-      expect(ap.matchValues()).toEqual([
-        "c:\\projects\\app\\src\\foo.ts",
-        "src\\foo.ts",
-      ]);
-    });
-
-    test("win32: lowercases the symlink-resolved boundary value", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p === "c:\\projects\\app\\link" ? "C:\\Real\\App" : p,
-      );
-      expect(
-        AccessPath.forPath("link", {
-          cwd: "C:\\Projects\\App",
-          platform: "win32",
-        }).boundaryValue(),
-      ).toBe("c:\\real\\app");
-    });
-  });
-
-  describe("boundaryValue()", () => {
-    test("returns the canonical (symlink-resolved) form", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      expect(
-        AccessPath.forPath("/tmp/x", {
-          cwd,
-          platform: "linux",
-        }).boundaryValue(),
-      ).toBe("/private/tmp/x");
-    });
-
-    test("returns the lexical form when path has no symlinks", () => {
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).boundaryValue(),
-      ).toBe("/etc/hosts");
-    });
-
-    test("returns empty string for empty input", () => {
-      expect(
-        AccessPath.forPath("", { cwd, platform: "linux" }).boundaryValue(),
-      ).toBe("");
-    });
-  });
-
-  describe("value()", () => {
-    test("returns the lexical (as-typed, normalized) form", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      // Even when the path resolves to a different canonical, value() stays lexical.
-      expect(
-        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).value(),
-      ).toBe("/tmp/x");
-    });
-
-    test("normalizes the path against cwd", () => {
-      // A relative path becomes an absolute lexical value.
-      expect(
-        AccessPath.forPath("src/foo.ts", { cwd, platform: "linux" }).value(),
-      ).toBe("/projects/my-app/src/foo.ts");
-    });
-
-    test("normalizes a relative path against an explicit resolveBase", () => {
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).value(),
-      ).toBe("/projects/my-app/sub/foo.ts");
-    });
-
-    test("returns empty string for empty input", () => {
-      expect(AccessPath.forPath("", { cwd, platform: "linux" }).value()).toBe(
-        "",
-      );
-    });
-  });
-});
-
-describe("resolvedAlias()", () => {
-  const cwd = "/projects/my-app";
-
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  test("returns the canonical form when a symlink resolves elsewhere", () => {
-    realpathSync.mockImplementation((p: string) =>
-      p === "/projects/my-app/demo-symlink-passwd" ? "/etc/passwd" : p,
-    );
-    expect(
-      AccessPath.forPath("demo-symlink-passwd", {
-        cwd,
-        platform: "linux",
-      }).resolvedAlias(),
-    ).toBe("/etc/passwd");
-  });
-
-  test("returns undefined when the path has no symlinks (canonical equals lexical)", () => {
-    expect(
-      AccessPath.forPath("/etc/hosts", {
-        cwd,
-        platform: "linux",
-      }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-
-  test("returns undefined for a literal-only path (no canonical)", () => {
-    expect(AccessPath.forLiteral("foo.ts").resolvedAlias()).toBeUndefined();
-  });
-
-  test("returns undefined for empty input", () => {
-    expect(
-      AccessPath.forPath("", { cwd, platform: "linux" }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-
-  test("win32: returns the lowercased canonical form for a real symlink target", () => {
-    realpathSync.mockImplementation((p: string) =>
-      p === "c:\\projects\\app\\link" ? "C:\\Real\\App" : p,
-    );
-    expect(
-      AccessPath.forPath("link", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      }).resolvedAlias(),
-    ).toBe("c:\\real\\app");
-  });
-
-  test("win32: returns undefined for a case-only difference (both forms lowercased)", () => {
-    expect(
-      AccessPath.forPath("src\\foo.ts", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-});
-
-describe("AccessPath.forLiteral", () => {
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  test("matchValues() carries only the literal — no canonical, no absolute", () => {
-    expect(AccessPath.forLiteral("foo.ts").matchValues()).toEqual(["foo.ts"]);
-  });
-
-  test("boundaryValue() is empty (no outside-cwd notion for an unknown base)", () => {
-    expect(AccessPath.forLiteral("foo.ts").boundaryValue()).toBe("");
-  });
-
-  test("value() returns the literal", () => {
-    expect(AccessPath.forLiteral("foo.ts").value()).toBe("foo.ts");
-  });
-
-  test("an empty literal yields no match values", () => {
-    expect(AccessPath.forLiteral("").matchValues()).toEqual([]);
-    expect(AccessPath.forLiteral("").value()).toBe("");
-  });
-});

package/test/access-intent/bash/node-text.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  resolveNodeText,
-  SKIP_SUBTREE_TYPES,
-} from "#src/access-intent/bash/node-text";
-import type { TSNode } from "#src/access-intent/bash/parser";
-
-// Minimal fake TSNode builder — only fills the fields resolveNodeText reads.
-function makeNode(type: string, text: string, children: TSNode[] = []): TSNode {
-  return {
-    type,
-    text,
-    startIndex: 0,
-    childCount: children.length,
-    isNamed: true,
-    child: (i) => children[i] ?? null,
-  };
-}
-
-describe("SKIP_SUBTREE_TYPES", () => {
-  it("contains the three node types that must not be descended", () => {
-    expect(SKIP_SUBTREE_TYPES.has("heredoc_body")).toBe(true);
-    expect(SKIP_SUBTREE_TYPES.has("heredoc_end")).toBe(true);
-    expect(SKIP_SUBTREE_TYPES.has("comment")).toBe(true);
-  });
-
-  it("does not contain common argument node types", () => {
-    expect(SKIP_SUBTREE_TYPES.has("word")).toBe(false);
-    expect(SKIP_SUBTREE_TYPES.has("string")).toBe(false);
-    expect(SKIP_SUBTREE_TYPES.has("raw_string")).toBe(false);
-  });
-});
-
-describe("resolveNodeText", () => {
-  describe("word nodes", () => {
-    it("returns the node text unchanged", () => {
-      expect(resolveNodeText(makeNode("word", "hello"))).toBe("hello");
-    });
-  });
-
-  describe("raw_string nodes (single-quoted)", () => {
-    it("strips surrounding single quotes", () => {
-      expect(resolveNodeText(makeNode("raw_string", "'content'"))).toBe(
-        "content",
-      );
-    });
-
-    it("strips single quotes around a path", () => {
-      expect(resolveNodeText(makeNode("raw_string", "'/etc/hosts'"))).toBe(
-        "/etc/hosts",
-      );
-    });
-
-    it("returns text as-is when not fully single-quoted", () => {
-      // A raw_string node without enclosing quotes (defensive fallback)
-      expect(resolveNodeText(makeNode("raw_string", "noquotes"))).toBe(
-        "noquotes",
-      );
-    });
-  });
-
-  describe("string nodes (double-quoted)", () => {
-    it("concatenates inner word children, skipping quote delimiters", () => {
-      const quoteOpen = makeNode('"', '"');
-      const content = makeNode("string_content", "hello world");
-      const quoteClose = makeNode('"', '"');
-      const node = makeNode("string", '"hello world"', [
-        quoteOpen,
-        content,
-        quoteClose,
-      ]);
-      expect(resolveNodeText(node)).toBe("hello world");
-    });
-
-    it("concatenates multiple inner children", () => {
-      const quoteOpen = makeNode('"', '"');
-      const part1 = makeNode("string_content", "foo");
-      const part2 = makeNode("simple_expansion", "$BAR");
-      const quoteClose = makeNode('"', '"');
-      const node = makeNode("string", '"foo$BAR"', [
-        quoteOpen,
-        part1,
-        part2,
-        quoteClose,
-      ]);
-      expect(resolveNodeText(node)).toBe("foo$BAR");
-    });
-
-    it("returns empty string for an empty double-quoted string", () => {
-      const quoteOpen = makeNode('"', '"');
-      const quoteClose = makeNode('"', '"');
-      const node = makeNode("string", '""', [quoteOpen, quoteClose]);
-      expect(resolveNodeText(node)).toBe("");
-    });
-  });
-
-  describe("string_content, simple_expansion, and expansion nodes", () => {
-    it("returns text as-is for string_content", () => {
-      expect(resolveNodeText(makeNode("string_content", "plain text"))).toBe(
-        "plain text",
-      );
-    });
-
-    it("returns text as-is for simple_expansion (e.g. $HOME)", () => {
-      // retro 0350: $HOME returns the literal text of a simple_expansion node
-      expect(resolveNodeText(makeNode("simple_expansion", "$HOME"))).toBe(
-        "$HOME",
-      );
-    });
-
-    it("returns text as-is for expansion", () => {
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional literal — testing that expansion node text is returned verbatim
-      expect(resolveNodeText(makeNode("expansion", "${VAR}"))).toBe("${VAR}");
-    });
-  });
-
-  describe("concatenation nodes", () => {
-    it("concatenates resolved children", () => {
-      const word = makeNode("word", "/etc/");
-      const expansion = makeNode("simple_expansion", "$FILE");
-      const node = makeNode("concatenation", "/etc/$FILE", [word, expansion]);
-      expect(resolveNodeText(node)).toBe("/etc/$FILE");
-    });
-
-    it("handles nested concatenation-of-string", () => {
-      // A concatenation whose child is a double-quoted string
-      const quoteOpen = makeNode('"', '"');
-      const content = makeNode("string_content", "bar");
-      const quoteClose = makeNode('"', '"');
-      const inner = makeNode("string", '"bar"', [
-        quoteOpen,
-        content,
-        quoteClose,
-      ]);
-      const prefix = makeNode("word", "foo");
-      const node = makeNode("concatenation", 'foo"bar"', [prefix, inner]);
-      expect(resolveNodeText(node)).toBe("foobar");
-    });
-  });
-
-  describe("default fallback", () => {
-    it("returns the raw text for unknown node types", () => {
-      expect(resolveNodeText(makeNode("unknown_type", "rawtext"))).toBe(
-        "rawtext",
-      );
-    });
-  });
-});

package/test/access-intent/bash/parser.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getParser } from "#src/access-intent/bash/parser";
-
-describe("getParser", () => {
-  it("parses a simple bash command and returns a non-null root node", async () => {
-    const parser = await getParser();
-    const tree = parser.parse("echo hi");
-    expect(tree).not.toBeNull();
-    expect(tree?.rootNode).toBeDefined();
-    expect(tree?.rootNode.type).toBe("program");
-    tree?.delete();
-  });
-
-  it("returns the same memoized parser instance on repeated calls", async () => {
-    const first = await getParser();
-    const second = await getParser();
-    expect(first).toBe(second);
-  });
-});