Collect the free canonical ids read in the subtree rooted at `node`, in ascending (canonical) order — the cids the fragment reads from its enclosing s

Like [`lower_corpus`] but discovers across several roots into one corpus (sharing a single interner — required for cross-root/cross-language matching)

Write `files` into a fresh per-process temp dir named after `tag` and lower them together as one corpus. Callers remove the returned dir when done.

Like [`detect`] but also returns the unit/candidate [`Dump`] for diagnostics. Normalize one file and extract its detection units. The resulting [`Unit

Public entry: the value-graph fingerprint of the unit rooted at `root` (sorted multiset of `u64` value hashes). Equivalent computations → equal multis

`(receiver, value)` of a single-item append-like builder call admitted by first-party language/library contracts. Raw method selectors such as `push`

Anti-unify two units' value DAGs into a graded witness. `a_lossy`/`b_lossy` mark whether each unit passed lossy lowering (so the claim is scoped to th

A strict semantic proof fact for a static import binding: local name → `(module coordinate, exported symbol)`. Frontends only call this for import fo

Side-effect-free for normalization rewrites that move or drop expressions.

Like [`lower_corpus_many`] but applies gitignore-syntax `exclude` globs during discovery (e.g. `tests`, `vendor/**`, `**/*.generated.ts`).

One FNV-1a step: xor `x` into the accumulator `h`, then multiply by [`PRIME`].

Parse `src` with a thread-local parser cached under `key` (which must uniquely identify the grammar — JS/TS/TSX share a crate but need distinct slots)

Build the value graph for a `Func`/`Method`/class unit. The unit root may be a `Func` (params + body) or a `Block` (class body of methods); for a `Blo

Binary-operator tokens shared by ~every C-family language. Per-language frontends delegate here and then handle their own extras (JS `===`/`**`/`??`,

Flatten an associative-commutative chain of value nodes into `out`.

Lower a float literal, retaining a hash of its source text so float constants are behavior-DISTINCT in the value graph (`3.14` ≠ `2.71`). The structur

Lower an import / `#include` / `use` statement to a `Seq` of its identifier and string leaves. Imports carry no behavior, but a *duplicated import blo

Borrow a slice of owned `PathBuf`s as `&Path` references — the form the detection entry points take. Used by every analysis/refactor subcommand that h

Stable hash of a runtime value (deterministic: `FxHasher` carries no random state), used to compose symbolic identities.

Lower a `left`/`operator`/`right` binary-expression node into a `BinOp`. Every supported grammar names those fields identically; each frontend supplie

A `Return` over a chain of `len` non-commutative `Un` ops wrapping `Const(key)`, so two such DAGs differ only in the const while staying above the low

Does the value contain a `Sym` anywhere (including inside lists)? Concrete operations must never run over a hidden symbolic operand — `sum([f(x)])` co

`(receiver, key, value)` of a first-party exact-safe index assignment. This is intentionally evidence-gated: languages with overloadable/user-dispatc