@gotgenes/pi-permission-system 18.1.1 → 18.2.0

package/src/permission-prompter.ts

@@ -1,5 +1,4 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ConfigReader } from "./config-store";
 import type { ApprovalRequester } from "./forwarded-permissions/permission-forwarder";
 import type { PermissionPromptDecision } from "./permission-dialog";
 import {
@@ -8,7 +7,6 @@ import {
 } from "./permission-events";
 import { buildDirectUiPrompt } from "./permission-ui-prompt";
 import type { ReviewLogger } from "./session-logger";
-import { shouldAutoApprovePermissionState } from "./yolo-mode";
 
 export type PermissionReviewSource = "tool_call" | "skill_input" | "skill_read";
 
@@ -40,13 +38,11 @@ export interface PermissionPrompterApi {
 /**
  * Dependencies required by PermissionPrompter.
  *
- * Keeps the prompter's external surface narrow: callers provide config
- * access, a review logger, the UI-prompt event bus, and the forwarder
- * that owns the UI/subagent-forwarding branching logic.
+ * Keeps the prompter's external surface narrow: callers provide a review
+ * logger, the UI-prompt event bus, and the forwarder that owns the
+ * UI/subagent-forwarding branching logic.
  */
 export interface PermissionPrompterDeps {
-  /** Read current config for yolo-mode check (called at prompt time). */
-  config: ConfigReader;
   /** Write structured entries to the permission review log. */
   logger: ReviewLogger;
   /** Event bus used for UI prompt broadcasts. */
@@ -57,10 +53,13 @@ export interface PermissionPrompterDeps {
 
 /**
  * Encapsulates the full permission-prompt flow:
- *   1. Yolo-mode auto-approval check.
- *   2. Review-log "waiting" entry.
- *   3. UI-present vs. subagent-forwarding branching (via confirmPermission).
- *   4. Review-log "approved" / "denied" entry.
+ *   1. Review-log "waiting" entry.
+ *   2. UI-present vs. subagent-forwarding branching (via confirmPermission).
+ *   3. Review-log "approved" / "denied" entry.
+ *
+ * Yolo-mode auto-approval happens upstream, at the composition stage
+ * (`PermissionManager.check`'s `rewriteAsksToYolo`) — an `ask` never reaches
+ * this class under yolo, so this class has no yolo-mode knowledge.
  *
  * Injecting a single PermissionPrompter instance means adding a new prompt
  * parameter (e.g. a future sessionLabel variant) only requires changing
@@ -73,11 +72,6 @@ export class PermissionPrompter implements PermissionPrompterApi {
     ctx: ExtensionContext,
     details: PromptPermissionDetails,
   ): Promise<PermissionPromptDecision> {
-    if (shouldAutoApprovePermissionState("ask", this.deps.config.current())) {
-      this.writeReviewEntry("permission_request.auto_approved", details);
-      return { approved: true, state: "approved", autoApproved: true };
-    }
-
     this.writeReviewEntry("permission_request.waiting", details);
 
     // Build the event once. When this session has UI it broadcasts directly;

package/src/prompting-gateway.ts

@@ -1,6 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
-import type { ConfigReader } from "./config-store";
 import type { GatePrompter } from "./gate-prompter";
 import type { PermissionPromptDecision } from "./permission-dialog";
 import type {
@@ -9,18 +8,15 @@ import type {
 } from "./permission-prompter";
 import { isSubagentExecutionContext } from "./subagent-context";
 import type { SubagentSessionRegistry } from "./subagent-registry";
-import { canResolveAskPermissionRequest } from "./yolo-mode";
 
 /**
  * Dependencies required by PromptingGateway.
  *
- * All four fields are actively consumed:
- * - `config` + `subagentSessionsDir` + `registry` drive `canConfirm()`.
+ * All fields are actively consumed:
+ * - `subagentSessionsDir` + `registry` drive `canConfirm()`.
  * - `prompter` is called by `prompt()`.
  */
 export interface PromptingGatewayDeps {
-  /** Read current config for the yolo-mode branch of the can-prompt policy. */
-  config: ConfigReader;
   /** Static path used to detect a forwarding subagent context. */
   subagentSessionsDir: string;
   /** Host platform, injected from the composition root, for subagent-context path detection. */
@@ -46,8 +42,8 @@ export interface PromptingGatewayLifecycle {
  * Context-owning implementation of the GatePrompter role.
  *
  * Owns the stored ExtensionContext and the "can we prompt?" policy
- * (UI / subagent / yolo-mode), replacing the four twin methods
- * that previously lived on PermissionSession.
+ * (UI / subagent), replacing the four twin methods that previously
+ * lived on PermissionSession.
  *
  * Lifecycle: PermissionSession drives activate/deactivate so the stored
  * context mirrors the session context without independent call-site changes.
@@ -72,22 +68,22 @@ export class PromptingGateway
   /**
    * Whether an interactive permission prompt can be shown.
    *
-   * Returns false when no context is active. Otherwise delegates to
-   * canResolveAskPermissionRequest, which checks hasUI, subagent status,
-   * and yolo-mode — relocating the policy from the index.ts closure.
+   * Returns false when no context is active. Otherwise true when the
+   * context has UI or is a forwarding subagent — the two Authorizer-
+   * selection predicates the Phase 9 spine will consume. Yolo-mode never
+   * reaches this policy: it is resolved upstream at the composition stage.
    */
   canConfirm(): boolean {
     if (this.context === null) return false;
-    return canResolveAskPermissionRequest({
-      config: this.deps.config.current(),
-      hasUI: this.context.hasUI,
-      isSubagent: isSubagentExecutionContext(
+    return (
+      this.context.hasUI ||
+      isSubagentExecutionContext(
         this.context,
         this.deps.subagentSessionsDir,
         this.deps.platform,
         this.deps.registry,
-      ),
-    });
+      )
+    );
   }
 
   /**

package/src/rule.ts

@@ -9,6 +9,7 @@ import { wildcardMatch } from "./wildcard-matcher";
  * Synthesized:   "builtin" (universal default / evaluate() fallback),
  *                "baseline" (conditional MCP metadata auto-allow).
  * Runtime:       "session" (session approvals).
+ * Rewrite:       "yolo" (composition-stage ask→allow rewrite under yolo mode).
  */
 export type RuleOrigin =
   | "global"
@@ -17,7 +18,8 @@ export type RuleOrigin =
   | "project-agent"
   | "builtin"
   | "baseline"
-  | "session";
+  | "session"
+  | "yolo";
 
 /** A single permission rule — the atomic unit of policy. */
 export interface Rule {
@@ -41,6 +43,24 @@ export interface Rule {
 /** An ordered list of rules. Later rules take priority (last-match-wins). */
 export type Ruleset = Rule[];
 
+/**
+ * Rewrite every `ask` rule to `allow`, tagged `origin: "yolo"`.
+ *
+ * The composition-stage expression of yolo mode as recorded authority: when
+ * enabled, an `ask` becomes a standing `allow` grant in the ruleset rather than
+ * a live prompt-path concern. `deny` and existing `allow` rules pass through
+ * untouched, so yolo suppresses prompts but preserves hard denies.
+ *
+ * Pure and non-mutating — `surface`, `pattern`, and `layer` are preserved so
+ * downstream `matchedPattern` / source derivation is unaffected; only `action`
+ * and `origin` change.
+ */
+export function rewriteAsksToYolo(rules: Ruleset): Ruleset {
+  return rules.map((rule) =>
+    rule.action === "ask" ? { ...rule, action: "allow", origin: "yolo" } : rule,
+  );
+}
+
 /**
  * Pure permission evaluation.
  *

package/src/status.ts

@@ -5,9 +5,9 @@ import type {
 
 import {
   EXTENSION_ID,
+  isYoloModeEnabled,
   type PermissionSystemExtensionConfig,
 } from "./extension-config";
-import { isYoloModeEnabled } from "./yolo-mode";
 
 export const PERMISSION_SYSTEM_STATUS_KEY = EXTENSION_ID;
 export const PERMISSION_SYSTEM_YOLO_STATUS_VALUE = "yolo";

package/src/yolo-mode.ts

@@ -1,30 +0,0 @@
-import type { PermissionSystemExtensionConfig } from "./extension-config";
-import type { PermissionState } from "./types";
-
-export interface AskPermissionResolutionOptions {
-  config: PermissionSystemExtensionConfig;
-  hasUI: boolean;
-  isSubagent: boolean;
-}
-
-export function isYoloModeEnabled(
-  config: PermissionSystemExtensionConfig,
-): boolean {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion -- typed as boolean but may be undefined at runtime (untyped callers); Boolean() guards against that
-  return Boolean(config.yoloMode);
-}
-
-export function shouldAutoApprovePermissionState(
-  state: PermissionState,
-  config: PermissionSystemExtensionConfig,
-): boolean {
-  return state === "ask" && isYoloModeEnabled(config);
-}
-
-export function canResolveAskPermissionRequest(
-  options: AskPermissionResolutionOptions,
-): boolean {
-  return (
-    options.hasUI || options.isSubagent || isYoloModeEnabled(options.config)
-  );
-}

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);
-  });
-});