@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-non-null-assertion-test.yml

@@ -3,8 +3,224 @@ valid:
   - 'const x = foo'
   - 'const x = foo?.bar'
   - 'const x: number = foo()'
+  # #1777: get-after-has, same map, same key — suppressed.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (m.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777: pop-after-length, same array, in a while loop.
+  - |
+    function f(stack: number[]) {
+      while (stack.length > 0) {
+        const x = stack.pop()!;
+      }
+    }
+  # #1777: shift-after-length, same array, in an if branch.
+  - |
+    function f(queue: number[]) {
+      if (queue.length > 0) {
+        return queue.shift()!;
+      }
+    }
+  # #1818 round 2: ternary-narrow. The consequence branch is only reached
+  # when the condition's own property access is truthy; the nested closure
+  # loses TS's narrowing across the function boundary, hence the `!`.
+  - |
+    function f(index: { forward?: Map<string, number> }, files: string[]) {
+      return index.forward
+        ? files.map((file) => index.forward!.get(file))
+        : undefined;
+    }
+  # #1818 round 2: property re-asserted after a `.filter()` on the same
+  # property, immediately followed by `.map()` in the same chain.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string } }>) {
+      return reads
+        .filter((r) => r.enclosingSymbol)
+        .map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
 invalid:
   - 'const x = foo!'
   - 'foo!.bar()'
   - 'const x = (foo!)!.bar'
   - 'foo!!'
+  # #1777 mutation guard: a get()! with NO has() check anywhere in the
+  # function must still flag — deleting the exclusion's pattern match
+  # (not just its metavariable binding) reds this.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      return m.get(k)!;
+    }
+  # #1777 mutation guard: the has() check is for a DIFFERENT key —
+  # same-key binding discipline is the guard, not mere presence of
+  # any .has() call on the map.
+  - |
+    function f(m: Map<string, number>, k: string, other: string) {
+      if (m.has(other)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 mutation guard: the has() check is on a DIFFERENT map —
+  # same-receiver binding discipline is the guard.
+  - |
+    function f(m: Map<string, number>, other: Map<string, number>, k: string) {
+      if (other.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 mutation guard: pop()! with NO length check anywhere in the
+  # function must still flag.
+  - |
+    function f(arr: number[]) {
+      return arr.pop()!;
+    }
+  # #1777 mutation guard: the length check is on a DIFFERENT array —
+  # same-array binding discipline is the guard.
+  - |
+    function f(arr: number[], other: number[]) {
+      if (other.length > 0) {
+        return arr.pop()!;
+      }
+    }
+  # #1777: a length check elsewhere in the SAME function that does not
+  # dominate this particular pop() (documented approximation — the
+  # rule only requires presence in the enclosing function, not proven
+  # dominance) still suppresses; this fixture exists to make that
+  # scoping visible rather than silently assumed. Left as `invalid`
+  # because this specific shape (length check AFTER the pop, in an
+  # unrelated later branch) is outside the two named idiom shapes: the
+  # pop here is not itself inside the while/for/if that carries the
+  # length check.
+  - |
+    function f(arr: number[]) {
+      const x = arr.pop()!;
+      if (arr.length > 0) {
+        return x;
+      }
+    }
+  # #1777 F1 regression test: a `.has()` guard in an OUTER function must
+  # NOT suppress a `!` inside an INNER closure — the `stopBy` boundary
+  # has to stop the ancestor walk at the nearest enclosing function.
+  # Review round 1 proved the pre-fix rule got this wrong (a guard in
+  # the outer scope suppressed the closure's finding).
+  - |
+    function outer(m: Map<string, number>, k: string) {
+      if (m.has(k)) {
+        // guard lives here, in the OUTER function
+      }
+      return function inner() {
+        return m.get(k)!;
+      };
+    }
+  # #1777 F1 regression test, arrow-closure variant: same outer/inner
+  # split, `.length` guard in the outer function only.
+  - |
+    function outer(arr: number[]) {
+      if (arr.length > 0) {
+        // guard lives here, in the OUTER function
+      }
+      return () => arr.pop()!;
+    }
+  # #1777 F2 regression test: `if (!m.has(k))` guards the branch where
+  # the key is proven ABSENT, so `m.get(k)!` inside that branch is a
+  # real bug, not a narrowed-after-check idiom. ast-grep can't read
+  # branch polarity, so the fix is a blunt one — ANY negated `.has()`
+  # is refused as a guard — but it MUST catch this exact shape, the one
+  # review round 1 named as "the rule's most likely real bug shape."
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (!m.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 F2 accepted regression: this is a genuinely SAFE early-return
+  # guard clause — by the time `m.get(k)!` runs, `!m.has(k)` has already
+  # returned. It was correctly suppressed before the F2 fix. It is NOT
+  # anymore, and that is accepted, not a bug: ast-grep matches this
+  # `if (!m.has(k)) return;` identically to the real-bug shape directly
+  # above (same syntax, opposite control flow), and there is no cheaper
+  # structural signal available to tell them apart. This fixture exists
+  # so the known blind spot has a name and a test, and can't be
+  # mistaken for coverage this rule doesn't have.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (!m.has(k)) return;
+      return m.get(k)!;
+    }
+  # #1818 mutation guard: ternary-narrow, but the assertion sits in the
+  # ALTERNATIVE branch (the condition's property is falsy there) — a real
+  # bug, must still flag.
+  - |
+    function f(index: { forward?: Map<string, number> }, files: string[]) {
+      return index.forward
+        ? undefined
+        : files.map((file) => index.forward!.get(file));
+    }
+  # #1818 mutation guard: ternary-narrow, but the assertion targets a
+  # DIFFERENT object than the condition checked — same-binding discipline
+  # is the guard, not mere presence of a truthy-ternary anywhere outside.
+  - |
+    function f(
+      index: { forward?: Map<string, number> },
+      other: { forward?: Map<string, number> },
+      files: string[],
+    ) {
+      return index.forward
+        ? files.map((file) => other.forward!.get(file))
+        : undefined;
+    }
+  # #1818 mutation guard: filter+map, but the filter checks a DIFFERENT
+  # property than the one asserted in map — must still flag.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string }; other?: unknown }>) {
+      return reads
+        .filter((r) => r.other)
+        .map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
+  # #1818 mutation guard: no preceding filter at all — must still flag.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string } }>) {
+      return reads.map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
+  # #1818 review round 1, N1: the SAME assertion repeated in BOTH the
+  # consequence AND alternative branches. The consequence instance is
+  # genuinely safe and suppressed; the alternative instance is a real
+  # bug (the condition's property is falsy on that branch) and must
+  # still flag. An `has: field: consequence` EXISTENCE check on the
+  # ternary cannot tell these two instances apart (the consequence
+  # branch's matching text satisfies the check for both); `field:
+  # consequence` as an IDENTITY check on the matched node can.
+  - |
+    function f(o: { y?: { length: number } }) {
+      return o.y ? o.y!.length : o.y!.length;
+    }
+  # #1818 review round 1, N2a: nested ternary. The assertion's NEAREST
+  # ternary is the INNER one, whose own condition (`flag`) does not
+  # match the asserted object/property — so it must still flag, even
+  # though an OUTER ternary's condition happens to match. Proves
+  # `stopBy: kind: ternary_expression` is a real boundary: weakening it
+  # to `end` lets the search escalate past the inner ternary (which
+  # correctly fails) to the outer one (which wrongly succeeds).
+  - |
+    function f(o: { y?: { length: number } }, flag: boolean) {
+      return o.y
+        ? flag
+          ? 1
+          : o.y!.length
+        : 0;
+    }
+  # #1818 review round 1, N2b: filter+map, but the asserted receiver is
+  # an UNRELATED variable, not the map callback's own parameter — must
+  # still flag. Proves the `$M` metavariable binding is load-bearing:
+  # decoupling it (e.g. to an unconstrained parameter name) would make
+  # ANY assertion inside ANY filter-then-map chain's callback body
+  # suppress, regardless of what is actually being asserted.
+  - |
+    function f(
+      rs: Array<{ sym?: { name: string } }>,
+      stray: { sym?: { name: string } },
+    ) {
+      return rs.filter((r) => r.sym).map((m) => stray.sym!.name);
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-apply-js-test.yml

@@ -2,6 +2,8 @@ id: no-reflect-apply-js
 valid:
   - 'fn.apply(obj, args)'
   - 'fn(...args)'
+  - 'const proxy = new Proxy(target, { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } });'
 invalid:
   - 'Reflect.apply(fn, obj, args)'
   - 'const r = Reflect.apply(target[method], target, argumentsList);'
+  - 'const ordinary = { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-apply-test.yml

@@ -2,6 +2,8 @@ id: no-reflect-apply
 valid:
   - 'fn.apply(obj, args)'
   - 'fn(...args)'
+  - 'const proxy = new Proxy(target, { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } });'
 invalid:
   - 'Reflect.apply(fn, obj, args)'
   - 'const r = Reflect.apply(target[method], target, argumentsList);'
+  - 'const ordinary = { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-get-js-test.yml

@@ -2,7 +2,8 @@ id: no-reflect-get-js
 valid:
   - 'obj.prop'
   - 'obj[key]'
-  - 'Reflect.get(target, prop, receiver)'
+  - 'const proxy = new Proxy(api, { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } });'
 invalid:
   - 'Reflect.get(obj, "key")'
   - 'const v = Reflect.get(target, prop);'
+  - 'const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-get-test.yml

@@ -2,7 +2,8 @@ id: no-reflect-get
 valid:
   - 'obj.prop'
   - 'obj[key]'
-  - 'Reflect.get(target, prop, receiver)'
+  - 'const proxy = new Proxy(api, { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } });'
 invalid:
   - 'Reflect.get(obj, "key")'
   - 'const v = Reflect.get(target, prop);'
+  - 'const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-return-value-in-generator-test.yml

@@ -11,6 +11,12 @@ valid:
   - |
     def regular():
         return 42
+  - |
+    @asynccontextmanager
+    async def lifespan(app):
+        def handler():
+            return 42
+        yield
 invalid:
   - |
     def gen():
@@ -20,3 +26,9 @@ invalid:
     def gen():
         yield from iter([1, 2])
         return result
+  - |
+    def outer():
+        def inner_gen():
+            yield 1
+            return 99
+        return inner_gen

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-runtime-typeof-test.yml

@@ -0,0 +1,33 @@
+id: no-runtime-typeof
+valid:
+  - |
+    function isFoo(x: unknown): x is Foo {
+      return typeof x === "object";
+    }
+  - |
+    const isBar = (x: unknown): x is Bar => typeof x === "object";
+  - |
+    function parseThing(x: unknown) {
+      return typeof x === "string";
+    }
+  - |
+    const validateThing = (x: unknown) => typeof x === "string";
+  - |
+    class C {
+      isFoo(x: unknown): x is Foo {
+        return typeof x === "object";
+      }
+    }
+invalid:
+  - |
+    function plain(x: unknown) {
+      return typeof x === "string";
+    }
+  - |
+    const check = (x: unknown) => typeof x === "string";
+  - |
+    class C {
+      plain(x: unknown) {
+        return typeof x === "string";
+      }
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-server-bind-wildcard-test.yml

@@ -4,7 +4,16 @@ valid:
   - "app.run(host='localhost', port=8000)"
   - "uvicorn.run(app, host='127.0.0.1', port=8000)"
   - "uvicorn.run(app, host=HOST, port=PORT)"  # env var is OK
+  - |
+    return Settings.model_construct(
+        gh_proxy_bind_host='0.0.0.0',
+    )
 invalid:
   - "app.run(host='0.0.0.0', port=8000)"
   - "uvicorn.run(app, host='0.0.0.0', port=8000)"
   - 'app.run(host="0.0.0.0", port=8000)'
+  - "server.listen(host='0.0.0.0', port=8000)"
+  - "app.serve(host='0.0.0.0', port=8000)"
+  - "run(host='0.0.0.0', port=8000)"
+  - "config = uvicorn.Config(app, host='0.0.0.0', port=8000)"
+  - "app.run_server(host='0.0.0.0', port=8000)"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-shape-in-symbol-names-test.yml

@@ -0,0 +1,13 @@
+id: no-shape-in-symbol-names
+valid:
+  - "const manifest = 1;"
+  - "interface I { name: string; }"
+  - "type Manifest = 1;"
+invalid:
+  - "const shape = 1;"
+  - "const packageJsonShape = 1;"
+  - "class C { shapeField = 1; }"
+  - "class C { #shapeField = 1; }"
+  - "interface I { shapeProp: string; }"
+  - "type PackageJsonShape = 1;"
+  - "function reshape() {}"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-sql-in-code-js-test.yml

@@ -3,8 +3,12 @@ valid:
   - "db.find({ id })"
   - "db.findOne({ where: { id } })"
   - 'sql.unsafe("non-sql")'
-invalid:
   - 'db.query("SELECT * FROM users")'
   - 'db.query("INSERT INTO x VALUES (1)")'
   - 'db.query("UPDATE users SET x = 1")'
   - 'db.query("SELECT * FROM users WHERE id = ?", [id])'
+  - 'db.query("SELECT * FROM " + "users")'
+invalid:
+  - 'db.query("SELECT * FROM users WHERE id = " + id)'
+  - 'db.query("DELETE FROM sessions WHERE token = " + token, [])'
+  - 'db.query(`SELECT * FROM users WHERE id = ${id}`)'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-sql-in-code-test.yml

@@ -3,8 +3,12 @@ valid:
   - "db.find({ id })"
   - "db.findOne({ where: { id } })"
   - 'sql.unsafe("non-sql")'
-invalid:
   - 'db.query("SELECT * FROM users")'
   - 'db.query("INSERT INTO x VALUES (1)")'
   - 'db.query("UPDATE users SET x = 1")'
   - 'db.query("SELECT * FROM users WHERE id = ?", [id])'
+  - 'db.query("SELECT * FROM " + "users")'
+invalid:
+  - 'db.query("SELECT * FROM users WHERE id = " + id)'
+  - 'db.query("DELETE FROM sessions WHERE token = " + token, [])'
+  - 'db.query(`SELECT * FROM users WHERE id = ${id}`)'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unknown-parameters-test.yml

@@ -0,0 +1,12 @@
+id: no-unknown-parameters
+valid:
+  - "function f(x: string) {}"
+  - "function f(cause: unknown) {}"
+  - "const g = (cause?: unknown) => {};"
+  - "class C { m(cause: unknown) {} }"
+invalid:
+  - "function f(x: unknown) {}"
+  - "const g = (x: unknown) => {};"
+  - "class C { m(x: unknown) {} }"
+  - "interface I { m(x: unknown): void; }"
+  - "function f(x?: unknown) {}"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unknown-returns-test.yml

@@ -0,0 +1,16 @@
+id: no-unknown-returns
+valid:
+  - "function f(x: unknown): string { return String(x); }"
+  - "const g = (x: unknown): number => 1;"
+  - "class C { m(): void {} }"
+  # #1824: a function_type is a TYPE-POSITION annotation (a callback
+  # signature or type alias), not a value returning unknown — "the
+  # caller ignores my result" is a legitimate contract, so it must not
+  # flag. Covers both a standalone alias and a parameter position use.
+  - "type H = () => unknown;"
+  - "interface I { on(cb: () => unknown): void; }"
+invalid:
+  - "function f(): unknown { return 1; }"
+  - "const g = (): unknown => 1;"
+  - "class C { m(): unknown { return 1; } }"
+  - "interface I { m(): unknown; }"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unsafe-dictionary-any-test.yml

@@ -0,0 +1,10 @@
+id: no-unsafe-dictionary-any
+valid:
+  - "type T = Record<string, unknown>;"
+  - "function f(x: Record<string, string>) {}"
+  - "interface I { m: Record<string, number>; }"
+invalid:
+  - "type T = Record<string, any>;"
+  - "function f(x: Record<string, any>) {}"
+  - "interface I { m: Record<string, any>; }"
+  - "const m: Record<number, any> = {};"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unsafe-dictionary-unknown-test.yml

@@ -0,0 +1,8 @@
+id: no-unsafe-dictionary-unknown
+valid:
+  - "type T = Record<string, string>;"
+  - "function f(x: Record<string, any>) {}"
+invalid:
+  - "type T = Record<string, unknown>;"
+  - "function f(x: Record<string, unknown>) {}"
+  - "interface I { m: Record<string, unknown>; }"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/redundant-unsafe-function-test.yml

@@ -9,6 +9,16 @@ valid:
     }
   - |
     fn f() -> i32 { 42 }
+  - |
+    /// Dereferences a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure the pointer is valid and aligned.
+    unsafe fn ptr_deref(p: *const i32) -> i32 {
+        let x = 1;
+        x
+    }
 invalid:
   - |
     unsafe fn f() {
@@ -23,3 +33,28 @@ invalid:
         let ptr = 0x1234 as *const i32;
         ptr
     }
+  - |
+    /// Does something.
+    unsafe fn no_real_safety_doc() {
+        println!("nope");
+    }
+  - |
+    // # Safety
+    // This is a stray file-top comment, not attached to any function.
+
+    fn helper() {}
+
+    unsafe fn no_doc_at_all() {
+        println!("bad 1");
+    }
+  - |
+    /// # Safety
+    /// Caller must ensure the pointer is valid.
+    unsafe fn documented_fn(p: *const i32) -> i32 {
+        let x = 1;
+        x
+    }
+
+    unsafe fn undocumented_fn_b() {
+        println!("no doc for me");
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/require-safety-comment-for-as-unknown-as-test.yml

@@ -0,0 +1,177 @@
+id: require-safety-comment-for-as-unknown-as
+valid:
+  - |
+    // SAFETY: checked above
+    const a = x as unknown as Foo;
+  - |
+    const b = /* SAFETY: inline */ x as unknown as Foo;
+  - |
+    // SAFETY: arg is validated upstream
+    foo(x as unknown as Foo);
+  # 2026-08-20 (#1727/#1777): this rule now owns the `as unknown as` shape
+  # alone, so a single concrete `as` and a concrete CHAIN are both out of scope
+  # here (the chain belongs to no-chained-type-assertions.yml). Widening the
+  # pattern back to any assertion reds both.
+  - 'const c = x as Foo;'
+  - 'const d = x as A as B;'
+  # #1847: the `inside:` kind list omitted `export_statement`, so a
+  # SAFETY: comment above an EXPORTED cast could not satisfy the valve.
+  # Dropping `export_statement` from the rule's kind list reds this case.
+  - |
+    // SAFETY: node exposes this at runtime, absent from @types/node
+    export const b = (globalThis as unknown as { z: number }).z;
+  # #1847: same gap for a class-field cast — the kind list omitted
+  # `public_field_definition`. Dropping it from the rule's kind list
+  # reds this case.
+  - |
+    class Foo {
+      // SAFETY: server always sends this field at runtime
+      bar: unknown = (globalThis as unknown as { z: number }).z;
+    }
+  # #1852 review (F1): same gap for an enum member's initializer cast —
+  # the kind list omitted `enum_assignment`. Dropping it from the
+  # rule's kind list reds this case. Covers plain, `const`, and
+  # `export` enum alike — `enum_assignment` is the member node itself,
+  # unaffected by keywords on the enclosing `enum_declaration`.
+  # (`declare enum` members have no initializer expression to cast, so
+  # there is nothing to probe for that flavor.)
+  - |
+    enum Direction {
+      // SAFETY: node exposes this at runtime, absent from @types/node
+      Up = (globalThis as unknown as { z: number }).z,
+    }
+  - |
+    const enum Direction {
+      // SAFETY: node exposes this at runtime, absent from @types/node
+      Up = (globalThis as unknown as { z: number }).z,
+    }
+  - |
+    export enum Direction {
+      // SAFETY: node exposes this at runtime, absent from @types/number
+      Up = (globalThis as unknown as { z: number }).z,
+    }
+  # #1852 review over-suppression probe: two casts inside ONE exported
+  # declaration under a single SAFETY: comment. This is pre-existing
+  # behavior, not new — the same one-comment-covers-the-whole-statement
+  # trade already applied to `lexical_declaration`/`variable_declaration`
+  # before #1847 (verified: an unexported `const pair = {a: x as unknown
+  # as Foo, b: y as unknown as Foo}` under one SAFETY: comment was
+  # already 0 findings on master). The "Scope and known gap" note above
+  # states the valve is statement-scoped, not cast-scoped, by design:
+  # "a comment is accepted if it directly precedes... the assertion's
+  # containing... statement." `export_statement` inherits that same
+  # trade; it does not introduce a new one. Locked in here so a future
+  # narrowing of the scope is a deliberate choice, not an accident.
+  - |
+    // SAFETY: both fields document the same upstream payload shape
+    export const pair = { a: x as unknown as Foo, b: y as unknown as Foo };
+  # #1870: tree-sitter-typescript calls an object-literal member a `pair`.
+  # A comment directly above that pair is the natural local anchor.
+  - |
+    const config = {
+      // SAFETY: input is validated by the config loader
+      value: input as unknown as string,
+    };
+  - |
+    configure({
+      // SAFETY: input is validated by the config loader
+      value: input as unknown as string,
+    });
+  # Direct comments immediately above casts in array elements and call
+  # arguments are supported by the direct-cast arm.
+  - |
+    const values = [
+      // SAFETY: input is validated by the config loader
+      input as unknown as string,
+    ];
+  - |
+    configure(
+      // SAFETY: input is validated by the config loader
+      input as unknown as string,
+    );
+invalid:
+  - "const a = x as unknown as Foo;"
+  - |
+    const b = x as unknown as Foo; // no safety note
+  - |
+    // some other comment
+    const c = x as unknown as Foo;
+  # The comment must actually claim safety. A comment mentioning the word in
+  # prose without the `SAFETY:` marker does not clear it — deleting the
+  # `SAFETY\s*:` regex from the rule reds this case.
+  - |
+    // this cast is safe, trust me
+    const d = x as unknown as Foo;
+  # #1834: the `follows: {stopBy: end}` scan is unbounded — it must not walk
+  # past the contiguous comment block into an EARLIER statement's SAFETY:
+  # comment. A stray SAFETY: comment anywhere earlier in the same block must
+  # not exempt a later, undocumented cast.
+  - |
+    function f(x: unknown, y: unknown) {
+      // SAFETY: this comment documents a DIFFERENT assertion below.
+      const a = (y as unknown as string).length;
+
+      const b = (x as unknown as string).length;
+      return a + b;
+    }
+  # SAFETY: on cast A must not bleed to cast B directly below it, even with
+  # no other statement in between.
+  - |
+    // SAFETY: documents castA only
+    const castA = a as unknown as Foo;
+    const castB = b as unknown as Foo;
+  # #1847: an exported cast with no SAFETY: comment must still flag —
+  # adding `export_statement` to the valve must not turn it into a
+  # blanket exemption for every exported cast.
+  - "export const b = (globalThis as unknown as { z: number }).z;"
+  # #1847: an undocumented class-field cast must still flag — adding
+  # `public_field_definition` to the valve must not exempt every field
+  # cast regardless of a SAFETY: comment.
+  - |
+    class Foo {
+      bar: unknown = (globalThis as unknown as { z: number }).z;
+    }
+  # #1852 review (F1): an undocumented enum-member cast must still flag
+  # — adding `enum_assignment` to the valve must not exempt every enum
+  # member cast regardless of a SAFETY: comment.
+  - |
+    enum Direction {
+      Up = (globalThis as unknown as { z: number }).z,
+    }
+  # #1852 review over-suppression probe: a SAFETY: comment separated
+  # from the cast by an unrelated statement must NOT suppress. This is
+  # already enforced by #1834's `stopBy: {not: {kind: comment}}` bound
+  # (the comment is no longer the statement's immediate preceding
+  # sibling once another statement sits between them), but it had no
+  # dedicated minimal fixture — the existing #1834 cases both pair the
+  # comment with a DIFFERENT documented cast, not a bare intervening
+  # statement.
+  - |
+    // SAFETY: documents nothing below — an unrelated call sits between
+    doSomethingUnrelated();
+     const b = x as unknown as Foo;
+  # A comment on an unrelated sibling pair must not reach a later pair.
+  - |
+    const config = {
+      unrelated: 1,
+      // SAFETY: this documents a different property
+      other: 2,
+      target: input as unknown as string,
+    };
+  # An outer pair comment must not cross into a nested pair.
+  - |
+    const config = {
+      // SAFETY: only the parent property is validated
+      parent: {
+        nestedTarget: value as unknown as string,
+      },
+    };
+  # A nested pair comment must not travel outward to a parent cast.
+  - |
+    const config = {
+      parent: value as unknown as string,
+      // SAFETY: only the nested property is validated
+      nested: {
+        child: value as unknown as string,
+      },
+    };

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/ts-void-zero-test.yml

@@ -3,6 +3,7 @@ valid:
   - 'undefined'
   - 'void x'
   - 'void 1'
+  - 'function probe(undefined) { return undefined; }'
 invalid:
   - 'void 0'
   - 'const x = void 0'