lockwire 0.1.33 → 0.1.35

package/README.md

@@ -173,6 +173,33 @@ sequenceDiagram
 
 ## Install
 
+**Have your AI do it.** Paste this into Claude Code, Codex, Cursor or any coding agent, in the repository you want to protect:
+
+```text
+Set up lockwire (https://github.com/Reality-Ventures/lockwire) in this repository. It binds
+claims in our docs to the code they describe and flags them when the code changes. It's an npm
+package with one runtime dependency and makes no network calls.
+
+1. Install it for the agent you are:
+   - Claude Code: add this to .claude/settings.json (merge with what's there), then tell me to
+     run /reload-plugins:
+     {"extraKnownMarketplaces": {"lockwire": {"source": {"source": "github",
+       "repo": "Reality-Ventures/lockwire"}, "autoUpdate": true}},
+      "enabledPlugins": {"lockwire@lockwire": true}}
+   - Anything else: run `npx skills add Reality-Ventures/lockwire`, and register
+     `npx -y lockwire mcp` as a stdio MCP server if you support MCP.
+2. Run `npx lockwire init` at the repository root.
+3. In CLAUDE.md, AGENTS.md or README.md, find 3 to 5 sentences that state something specific about
+   our code (a function's parameters, a default, a limit, where something lives). Above each, add a
+   marker naming the code and what the sentence depends on, e.g.
+   <!-- lockwire src/auth/session.ts#createSession sig -->
+   (sig: signature and types; body: behaviour; deps: what it calls; path: where it lives).
+4. Run `npx lockwire link <doc>` for each doc you changed, then `npx lockwire check`, and show me
+   the result.
+
+Don't commit, push or run `lockwire autofix`; I'll review the changes first.
+```
+
 **Claude Code** — hook, MCP server, and skill in one plugin:
 
 ```bash

package/dist/blake3.d.ts

@@ -0,0 +1,9 @@
+/**
+ * BLAKE3, the unkeyed hash, written out so lockwire needs no hashing dependency (Node's crypto has no
+ * BLAKE3). Lockfiles written by earlier versions hold BLAKE3 fingerprints, so the hash has to stay
+ * the same one; the tests check this against the reference implementation (`@noble/hashes`, a
+ * development dependency) over every input length around the chunk and tree boundaries.
+ */
+/** The first `length` bytes (at most 32) of the BLAKE3 hash of `input`, as lowercase hex. */
+export declare function blake3Hex(input: Uint8Array, length?: number): string;
+//# sourceMappingURL=blake3.d.ts.map

package/dist/blake3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake3.d.ts","sourceRoot":"","sources":["../src/blake3.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA8HH,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,SAAK,GAAG,MAAM,CAkBhE"}

package/dist/blake3.js

@@ -0,0 +1,128 @@
+/**
+ * BLAKE3, the unkeyed hash, written out so lockwire needs no hashing dependency (Node's crypto has no
+ * BLAKE3). Lockfiles written by earlier versions hold BLAKE3 fingerprints, so the hash has to stay
+ * the same one; the tests check this against the reference implementation (`@noble/hashes`, a
+ * development dependency) over every input length around the chunk and tree boundaries.
+ */
+const IV = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+];
+const PERMUTATION = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
+const CHUNK_START = 1;
+const CHUNK_END = 2;
+const PARENT = 4;
+const ROOT = 8;
+const BLOCK_LEN = 64;
+const CHUNK_LEN = 1024;
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+// Scratch space reused by every compression, so hashing allocates nothing per block.
+const state = new Uint32Array(16);
+const msg = new Uint32Array(16);
+const next = new Uint32Array(16);
+function g(a, b, c, d, mx, my) {
+    state[a] = state[a] + state[b] + mx;
+    state[d] = rotr(state[d] ^ state[a], 16);
+    state[c] = state[c] + state[d];
+    state[b] = rotr(state[b] ^ state[c], 12);
+    state[a] = state[a] + state[b] + my;
+    state[d] = rotr(state[d] ^ state[a], 8);
+    state[c] = state[c] + state[d];
+    state[b] = rotr(state[b] ^ state[c], 7);
+}
+/**
+ * The compression function: an 8-word chaining value and a 16-word block in, 16 words out. The result
+ * is `state`, which the next call overwrites: read what you need before compressing again.
+ */
+function compress(cv, block, counter, blockLen, flags) {
+    for (let i = 0; i < 8; i++)
+        state[i] = cv[i];
+    state[8] = IV[0];
+    state[9] = IV[1];
+    state[10] = IV[2];
+    state[11] = IV[3];
+    state[12] = counter >>> 0;
+    state[13] = Math.floor(counter / 0x100000000) >>> 0;
+    state[14] = blockLen;
+    state[15] = flags;
+    for (let i = 0; i < 16; i++)
+        msg[i] = block[i];
+    for (let round = 0; round < 7; round++) {
+        g(0, 4, 8, 12, msg[0], msg[1]);
+        g(1, 5, 9, 13, msg[2], msg[3]);
+        g(2, 6, 10, 14, msg[4], msg[5]);
+        g(3, 7, 11, 15, msg[6], msg[7]);
+        g(0, 5, 10, 15, msg[8], msg[9]);
+        g(1, 6, 11, 12, msg[10], msg[11]);
+        g(2, 7, 8, 13, msg[12], msg[13]);
+        g(3, 4, 9, 14, msg[14], msg[15]);
+        if (round < 6) {
+            for (let i = 0; i < 16; i++)
+                next[i] = msg[PERMUTATION[i]];
+            msg.set(next);
+        }
+    }
+    for (let i = 0; i < 8; i++) {
+        state[i] = state[i] ^ state[i + 8];
+        state[i + 8] = state[i + 8] ^ cv[i];
+    }
+    return state;
+}
+const chainingValue = (o) => Array.from(compress(o.cv, o.block, o.counter, o.blockLen, o.flags).subarray(0, 8));
+const words = (bytes, start, length) => {
+    const block = new Uint32Array(16);
+    const view = new DataView(bytes.buffer, bytes.byteOffset + start, length);
+    for (let i = 0; i < length >> 2; i++)
+        block[i] = view.getUint32(i * 4, true);
+    // A final partial word is zero-padded, little-endian.
+    for (let i = length & ~3; i < length; i++)
+        block[i >> 2] = block[i >> 2] | (view.getUint8(i) << (8 * (i & 3)));
+    return block;
+};
+/** The output of the chunk starting at `start`, whose last block is left for the caller to finish. */
+function chunkOutput(input, start, index) {
+    const length = Math.min(CHUNK_LEN, input.length - start);
+    const blocks = Math.max(1, Math.ceil(length / BLOCK_LEN));
+    let cv = IV;
+    for (let b = 0; b < blocks - 1; b++) {
+        const block = words(input, start + b * BLOCK_LEN, BLOCK_LEN);
+        cv = Array.from(compress(cv, block, index, BLOCK_LEN, b === 0 ? CHUNK_START : 0).subarray(0, 8));
+    }
+    const last = (blocks - 1) * BLOCK_LEN;
+    const blockLen = length - last;
+    return {
+        cv,
+        block: words(input, start + last, blockLen),
+        counter: index,
+        blockLen,
+        flags: (blocks === 1 ? CHUNK_START : 0) | CHUNK_END,
+    };
+}
+const parentOutput = (left, right) => ({
+    cv: IV,
+    block: Uint32Array.from([...left, ...right]),
+    counter: 0,
+    blockLen: BLOCK_LEN,
+    flags: PARENT,
+});
+/** The first `length` bytes (at most 32) of the BLAKE3 hash of `input`, as lowercase hex. */
+export function blake3Hex(input, length = 32) {
+    const chunks = Math.max(1, Math.ceil(input.length / CHUNK_LEN));
+    // Completed subtrees, merged as soon as two of equal size exist.
+    const stack = [];
+    for (let i = 0; i < chunks - 1; i++) {
+        let cv = chainingValue(chunkOutput(input, i * CHUNK_LEN, i));
+        for (let done = i + 1; (done & 1) === 0; done >>= 1)
+            cv = chainingValue(parentOutput(stack.pop(), cv));
+        stack.push(cv);
+    }
+    let out = chunkOutput(input, (chunks - 1) * CHUNK_LEN, chunks - 1);
+    while (stack.length > 0)
+        out = parentOutput(stack.pop(), chainingValue(out));
+    const digest = compress(out.cv, out.block, 0, out.blockLen, out.flags | ROOT);
+    let hex = "";
+    for (let i = 0; i < Math.ceil(length / 4); i++)
+        for (let b = 0; b < 4; b++)
+            hex += ((digest[i] >>> (8 * b)) & 0xff).toString(16).padStart(2, "0");
+    return hex.slice(0, length * 2);
+}
+//# sourceMappingURL=blake3.js.map

package/dist/blake3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake3.js","sourceRoot":"","sources":["../src/blake3.ts"],"names":[],"mappings":"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"}

package/dist/extract-v2.d.ts

@@ -19,15 +19,25 @@
  *   isn't part of the body.
  * - `deps` names each call by its structure (`client.get().json`), so reformatting a call chain or
  *   renaming a local passed as an argument doesn't move it.
+ *
+ * Version 3 is version 2 except that what code formatters (Black, Ruff, Prettier) rewrite without
+ * changing behaviour reads the same either way, in `sig` and `body` alike: a string's quotes, escaped
+ * quotes and prefix case (`'it\'s'`, `"it's"`, `U'a'`); a number's spelling (`0XAB`, `1E5`, and in
+ * TS/JS `1.50`, `.5`); Python's optional parentheses (`from m import (a)`, `with (a, b):`,
+ * `for (x, y) in`, `return (a, b)`, `-> (int)`); an arrow's single parameter with or without
+ * parentheses; and a quoted key that needn't be (`{ 'a': 1 }`). It also stops reading a class's or a
+ * whole file's own top-level names (a model's fields, a module's constants) as locals: renaming one
+ * is a change (see {@link collectLocals}). Version-2 anchors keep being read the version-2 way (see
+ * {@link withVersion}) until a check finds them unchanged and re-stamps them.
  */
 import type { Node } from "web-tree-sitter";
 import type { LangId } from "./grammar.js";
 import type { FileSymbols } from "./types.js";
 /** A node as its tokens: comments and layout dropped, a trailing comma before a closer dropped. */
-export declare function canon(node: Node): string;
-export declare function extractFileSymbolsV2(root: Node, lang: LangId, normalizeLocals: boolean): FileSymbols;
-/** Whole-file `body` and `deps` for a file-only anchor, read the version-2 way. */
-export declare function computeWholeFileTiersV2(root: Node, lang: LangId, normalizeLocals: boolean): {
+export declare function canon(node: Node, lang?: LangId): string;
+export declare function extractFileSymbolsV2(root: Node, lang: LangId, normalizeLocals: boolean, version?: number): FileSymbols;
+/** Whole-file `body` and `deps` for a file-only anchor, read the version-2 (or 3) way. */
+export declare function computeWholeFileTiersV2(root: Node, lang: LangId, normalizeLocals: boolean, version?: number): {
     bodyNormalized: string;
     deps: string[];
 };

package/dist/extract-v2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-v2.d.ts","sourceRoot":"","sources":["../src/extract-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AAE9D,mGAAmG;AACnG,wBAAgB,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAiBxC;AA2bD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,OAAO,GACvB,WAAW,CAqPb;AAED,mFAAmF;AACnF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,OAAO,GACvB;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAO5C"}
+{"version":3,"file":"extract-v2.d.ts","sourceRoot":"","sources":["../src/extract-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AA+G9D,mGAAmG;AACnG,wBAAgB,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAoCvD;AA2eD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,OAAO,EACxB,OAAO,SAAI,GACV,WAAW,CAEb;AAyPD,0FAA0F;AAC1F,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,OAAO,EACxB,OAAO,SAAI,GACV;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAS5C"}

package/dist/extract-v2.js

@@ -1,17 +1,149 @@
+/**
+ * Whether the extraction under way reads formatting the version-3 way. Set for the length of one
+ * (synchronous) extraction by {@link withVersion}, so the helpers below needn't all carry it.
+ */
+let formatProof = false;
+function withVersion(version, run) {
+    const saved = formatProof;
+    formatProof = version >= 3;
+    try {
+        return run();
+    }
+    finally {
+        formatProof = saved;
+    }
+}
+/** `\'` and `\"` as the quote alone; every other escape as written. */
+const unescapeQuotes = (s) => s.replace(/\\([\s\S])/g, (pair, c) => (c === "'" || c === '"' ? c : pair));
+/**
+ * A string literal whichever quotes delimit it: its prefix (lower case, sorted, without Python 3's
+ * no-op `u`) and its contents with escaped quotes unescaped. `inner` renders an f-string's
+ * interpolations. Null for anything but a plain or f-string literal (a template literal keeps its
+ * backticks: there's no other way to write one).
+ */
+function stringLiteral(node, lang, inner) {
+    // Named: TS's `string` keyword is an unnamed node of the same type.
+    if (node.type !== "string" || !node.isNamed)
+        return null;
+    if (lang !== "python")
+        return JSON.stringify(unescapeQuotes(node.text.slice(1, -1)));
+    let prefix = "";
+    let quote = 1;
+    let contents = "";
+    const text = (t) => {
+        contents += prefix.includes("r") ? t : unescapeQuotes(t);
+    };
+    for (const c of node.children) {
+        if (!c || c.isExtra)
+            continue;
+        if (c.type === "string_start") {
+            const delimiter = c.text.replace(/^[^'"]*/, "");
+            quote = delimiter.length;
+            prefix = [...c.text.slice(0, -quote).toLowerCase().replace("u", "")].sort().join("");
+        }
+        // An f-string's own braces are written doubled (`{{`), so an interpolation can't be mistaken for text.
+        else if (c.type === "interpolation")
+            contents += inner(c);
+        // The grammar ends `r'\''` with a `string_end` of `\''`: what precedes the closing quote is text.
+        else if (c.type === "string_end")
+            text(c.text.slice(0, -quote));
+        else
+            text(c.text);
+    }
+    return `${prefix}${JSON.stringify(contents)}`;
+}
+/** A number literal however it's spelled: case, `_` separators and, in TS/JS, the value it denotes. */
+function numberLiteral(text, lang) {
+    const t = text.toLowerCase().replace(/_/g, "");
+    // Python keeps the spelling (`1` and `1.0` are different types); so do BigInts and legacy octals.
+    if (lang === "python" || t.endsWith("n") || /^0\d/.test(t))
+        return t;
+    const value = Number(t);
+    return Number.isFinite(value) ? String(value) : t;
+}
+const NUMBER_TYPES = new Set(["number", "integer", "float"]);
+/** The node types version 3 reads differently from version 2 (bar optional parentheses). */
+const FORMATTED_TYPES = new Set(["string", ...NUMBER_TYPES, "formal_parameters"]);
+/** Members whose name may be quoted or not, as long as it's an identifier either way. */
+const NAMED_MEMBERS = new Set([
+    "pair",
+    "property_signature",
+    "method_signature",
+    "public_field_definition",
+    "field_definition",
+    "method_definition",
+    "abstract_method_signature",
+]);
+/** A quoted member name that needn't be (`{ 'a': 1 }`): the bare name. */
+function unquotedKey(node, lang) {
+    if (lang === "python" || node.type !== "string" || !node.isNamed)
+        return null;
+    const parent = node.parent;
+    if (!parent || !NAMED_MEMBERS.has(parent.type))
+        return null;
+    const field = ["key", "name", "property"]
+        .map((f) => parent.childForFieldName(f))
+        .find((c) => c?.id === node.id);
+    if (!field)
+        return null;
+    const name = unescapeQuotes(node.text.slice(1, -1));
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : null;
+}
+/** Python's optional parentheses: around an import list, a `with` clause, or a tuple. */
+const OPTIONAL_PARENS = new Set(["import_from_statement", "with_clause", "tuple", "tuple_pattern"]);
+/** A parenthesized tuple is the same tuple without the parentheses. */
+const TUPLE_AS = new Map([
+    ["tuple", "expression_list"],
+    ["tuple_pattern", "pattern_list"],
+]);
+/** An arrow function's one plain parameter, when it's written in parentheses (`(x) => x`). */
+function soleArrowParameter(node) {
+    if (node.type !== "formal_parameters" || node.parent?.type !== "arrow_function")
+        return null;
+    const params = node.namedChildren.filter((c) => c !== null && !c.isExtra);
+    if (params.length !== 1)
+        return null;
+    const p = params[0];
+    if (p.type === "identifier")
+        return p;
+    const named = p.namedChildren.filter((c) => c !== null && !c.isExtra);
+    return p.type === "required_parameter" && named.length === 1 && named[0]?.type === "identifier"
+        ? named[0]
+        : null;
+}
 /** A node as its tokens: comments and layout dropped, a trailing comma before a closer dropped. */
-export function canon(node) {
+export function canon(node, lang) {
     const tokens = [];
     const walk = (n) => {
         if (n.isExtra)
             return; // comments
+        if (formatProof && lang) {
+            const key = unquotedKey(n, lang);
+            const literal = key ?? stringLiteral(n, lang, (i) => canon(i, lang));
+            if (literal !== null) {
+                tokens.push(literal);
+                return;
+            }
+            if (n.isNamed && NUMBER_TYPES.has(n.type)) {
+                tokens.push(numberLiteral(n.text, lang));
+                return;
+            }
+            if (n.type === "parenthesized_expression" && n.namedChildCount === 1) {
+                const inner = n.namedChildren[0];
+                if (inner && !inner.isExtra)
+                    return walk(inner);
+            }
+            // (An arrow's parameters need nothing here: sigOf writes a bare one in parentheses.)
+        }
         if (n.childCount === 0) {
             const t = n.text.trim();
             if (t)
                 tokens.push(t);
             return;
         }
+        const dropParens = formatProof && lang === "python" && OPTIONAL_PARENS.has(n.type);
         for (const c of n.children)
-            if (c)
+            if (c && !(dropParens && (c.type === "(" || c.type === ")")))
                 walk(c);
     };
     walk(node);
@@ -101,20 +233,20 @@ function isExported(node) {
     return false;
 }
 /** Decorators written before a declaration: Python's `decorated_definition`, TS's on the class or export, or class-body siblings for a member. */
-function decoratorsOf(def, member) {
+function decoratorsOf(def, member, lang) {
     const out = [];
     const parent = member.parent;
     if (parent?.type === "decorated_definition" || parent?.type === "export_statement")
         for (const c of parent.namedChildren)
             if (c?.type === "decorator")
-                out.push(canon(c));
+                out.push(canon(c, lang));
     for (const c of def.namedChildren)
         if (c?.type === "decorator")
-            out.push(canon(c));
+            out.push(canon(c, lang));
     // A TS class member's decorators are the class body's children right before it.
     if (parent?.type === "class_body")
         for (let s = member.previousSibling; s?.type === "decorator"; s = s.previousSibling)
-            out.push(canon(s));
+            out.push(canon(s, lang));
     return out;
 }
 /** Keyword modifiers written before the name: `static`, `async`, `get`, `private`, `readonly`, `*`, `abstract`… */
@@ -165,23 +297,23 @@ function sigOf(def, name, lang) {
         const nameNode = n.childForFieldName("name");
         const body = [...n.children]
             .filter((c) => c !== null && c !== nameNode && !c.isExtra && c.type !== "decorator")
-            .map(canon)
+            .map((c) => canon(c, lang))
             .join(" ");
         return `${n.type} ${name} ${body}${tail}`;
     }
     const typeParams = n.childForFieldName("type_parameters");
-    const tp = typeParams ? canon(typeParams) : "";
+    const tp = typeParams ? canon(typeParams, lang) : "";
     if (def.kind === "class") {
         const heritage = lang === "python"
             ? n.childForFieldName("superclasses")
             : (n.namedChildren.find((c) => c?.type === "class_heritage") ?? null);
-        return `class ${name}${tp}${heritage ? ` ${canon(heritage)}` : ""}${tail}`;
+        return `class ${name}${tp}${heritage ? ` ${canon(heritage, lang)}` : ""}${tail}`;
     }
     const params = n.childForFieldName("parameters");
     const single = lang === "python" ? null : n.childForFieldName("parameter");
-    const ps = params ? canon(params) : single ? `(${canon(single)})` : "()";
+    const ps = params ? canon(params, lang) : single ? `(${canon(single, lang)})` : "()";
     const ret = n.childForFieldName("return_type");
-    const rs = ret ? canon(ret).replace(/^:\s*/, "") : "";
+    const rs = ret ? canon(ret, lang).replace(/^:\s*/, "") : "";
     return `fn ${name}${tp}${ps}${rs ? `->${rs}` : ""}${tail}`;
 }
 // -------------------------------------------------------------------------------------------------
@@ -237,25 +369,52 @@ function paramNames(params, lang, out) {
         }
     }
 }
-function collectLocals(subtree, outerParams, lang) {
+/**
+ * The names `subtree` binds that are local to it, aliased in `body`. For a class or a whole file
+ * (`ownNames`), from version 3 the names bound at its own top level, outside any function in it, aren't
+ * locals: they are its fields, attributes, constants and exports, and renaming one changes what other
+ * code can use (`montly_fee: float` → `monthly_fee: float` renames a model's field and its JSON key).
+ */
+function collectLocals(subtree, outerParams, lang, ownNames = false) {
     const locals = new Set();
+    const own = new Set();
+    const keepOwn = ownNames && formatProof;
+    /** Records the names `pattern` binds at `site`: the scope's own when no function lies between. */
+    const bind = (site, pattern) => {
+        if (!site)
+            return;
+        const names = new Set();
+        patternNames(pattern, names);
+        let inFunction = false;
+        if (keepOwn)
+            for (let p = site.parent; p && p.id !== subtree.id; p = p.parent)
+                if (FUNCTION_LIKE[lang].has(p.type)) {
+                    inFunction = true;
+                    break;
+                }
+        for (const name of names)
+            (keepOwn && !inFunction ? own : locals).add(name);
+    };
     paramNames(outerParams, lang, locals);
     if (lang === "python") {
         for (const fn of subtree.descendantsOfType(["function_definition", "lambda"]))
             paramNames(fn?.childForFieldName("parameters") ?? null, lang, locals);
         for (const n of subtree.descendantsOfType(["assignment", "augmented_assignment"]))
-            patternNames(n?.childForFieldName("left") ?? null, locals);
-        for (const n of subtree.descendantsOfType(["for_statement", "for_in_clause"]))
+            bind(n, n?.childForFieldName("left") ?? null);
+        for (const n of subtree.descendantsOfType(["for_statement"]))
+            bind(n, n?.childForFieldName("left") ?? null);
+        // A comprehension is a scope of its own, wherever it is.
+        for (const n of subtree.descendantsOfType(["for_in_clause"]))
             patternNames(n?.childForFieldName("left") ?? null, locals);
         for (const n of subtree.descendantsOfType(["as_pattern_target"]))
             for (const c of n?.namedChildren ?? [])
-                patternNames(c, locals);
+                bind(n, c);
         for (const n of subtree.descendantsOfType(["named_expression"]))
-            patternNames(n?.childForFieldName("name") ?? null, locals);
+            bind(n, n?.childForFieldName("name") ?? null);
     }
     else {
         for (const n of subtree.descendantsOfType(["variable_declarator"]))
-            patternNames(n?.childForFieldName("name") ?? null, locals);
+            bind(n, n?.childForFieldName("name") ?? null);
         for (const n of subtree.descendantsOfType([...FUNCTION_LIKE[lang]])) {
             paramNames(n?.childForFieldName("parameters") ?? null, lang, locals);
             const single = n?.childForFieldName("parameter");
@@ -263,10 +422,13 @@ function collectLocals(subtree, outerParams, lang) {
                 patternNames(single, locals);
         }
         for (const n of subtree.descendantsOfType(["for_in_statement"]))
-            patternNames(n?.childForFieldName("left") ?? null, locals);
+            bind(n, n?.childForFieldName("left") ?? null);
         for (const n of subtree.descendantsOfType(["catch_clause"]))
-            patternNames(n?.childForFieldName("parameter") ?? null, locals);
+            bind(n, n?.childForFieldName("parameter") ?? null);
     }
+    // A name that is also the scope's own is read as written everywhere, so the two never get confused.
+    for (const name of own)
+        locals.delete(name);
     return locals;
 }
 /** An identifier that names a value, not a property, attribute or keyword argument. */
@@ -287,13 +449,28 @@ function isValueIdentifier(node, lang) {
 function serializeBody(node, locals, normalizeLocals, lang, aliasOf) {
     if (node.isExtra)
         return "";
+    // Read once: each read of a node's type is a call into the parser.
+    const nodeType = node.type;
     // Grouping parentheses carry no meaning (the tree's shape already has the precedence), and
     // formatters add and remove them to wrap lines.
-    if (node.type === "parenthesized_expression" && node.namedChildCount === 1) {
+    if (nodeType === "parenthesized_expression" && node.namedChildCount === 1) {
         const inner = node.namedChildren[0];
         if (inner && !inner.isExtra)
             return serializeBody(inner, locals, normalizeLocals, lang, aliasOf);
     }
+    if (formatProof && FORMATTED_TYPES.has(nodeType)) {
+        const key = unquotedKey(node, lang);
+        if (key !== null)
+            return `property_identifier:${key}`;
+        const literal = stringLiteral(node, lang, (i) => serializeBody(i, locals, normalizeLocals, lang, aliasOf));
+        if (literal !== null)
+            return `string:${literal}`;
+        if (node.isNamed && NUMBER_TYPES.has(nodeType))
+            return `${nodeType}:${numberLiteral(node.text, lang)}`;
+        const sole = soleArrowParameter(node);
+        if (sole)
+            return serializeBody(sole, locals, normalizeLocals, lang, aliasOf);
+    }
     if (node.childCount === 0) {
         if (node.isNamed) {
             if (normalizeLocals && locals.has(node.text) && isValueIdentifier(node, lang)) {
@@ -304,21 +481,23 @@ function serializeBody(node, locals, normalizeLocals, lang, aliasOf) {
                 }
                 return `$${idx}`;
             }
-            return `${node.type}:${node.text}`;
+            return `${nodeType}:${node.text}`;
         }
-        if (node.type === "," || node.type === ";")
+        if (nodeType === "," || nodeType === ";")
             return "";
-        return node.type;
+        return nodeType;
     }
+    const dropParens = formatProof && lang === "python" && OPTIONAL_PARENS.has(nodeType);
     const parts = [];
     for (const child of node.children) {
-        if (!child)
+        if (!child || (dropParens && (child.type === "(" || child.type === ")")))
             continue;
         const s = serializeBody(child, locals, normalizeLocals, lang, aliasOf);
         if (s)
             parts.push(s);
     }
-    return `(${node.type} ${parts.join(" ")})`;
+    const type = (formatProof && lang === "python" && TUPLE_AS.get(nodeType)) || nodeType;
+    return `(${type} ${parts.join(" ")})`;
 }
 /** A Python function's docstring is documentation, not behaviour. */
 function withoutDocstring(body, lang) {
@@ -450,7 +629,10 @@ function commonJsPath(left) {
     const path = parts.filter((p) => p !== "prototype").join(".");
     return path ? { path, exported } : null;
 }
-export function extractFileSymbolsV2(root, lang, normalizeLocals) {
+export function extractFileSymbolsV2(root, lang, normalizeLocals, version = 2) {
+    return withVersion(version, () => extractSymbols(root, lang, normalizeLocals));
+}
+function extractSymbols(root, lang, normalizeLocals) {
     const importedNames = collectImportedNames(root, lang);
     const bySymbolPath = new Map();
     const fileExports = [];
@@ -467,7 +649,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
                 ? withoutDocstring(body, lang)
                 : [body];
         const locals = def.kind === "class"
-            ? collectLocals(body ?? n, null, lang)
+            ? collectLocals(body ?? n, null, lang, true)
             : collectLocals(body ?? n, n.childForFieldName("parameters") ?? n.childForFieldName("parameter"), lang);
         const aliasOf = new Map();
         const bodyNormalized = roots
@@ -565,7 +747,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
             outer: prefix ? cls : outerOf(cls),
             exported: prefix ? false : isExported(cls),
             extra: [],
-            decorators: decoratorsOf(cls, cls),
+            decorators: decoratorsOf(cls, cls, lang),
         });
         if (isType)
             return;
@@ -594,7 +776,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
                     outer: member.parent?.type === "decorated_definition" ? member.parent : member,
                     exported: false,
                     extra: [],
-                    decorators: decoratorsOf(member, member),
+                    decorators: decoratorsOf(member, member, lang),
                 });
             }
             else if (member.type === "public_field_definition" || member.type === "field_definition") {
@@ -610,7 +792,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
                     outer: member,
                     exported: false,
                     extra: [...leadingModifiers(member), ...fn.wrappers.map((w) => `wrap:${w}`)],
-                    decorators: decoratorsOf(member, member),
+                    decorators: decoratorsOf(member, member, lang),
                 });
             }
         }
@@ -629,7 +811,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
                 outer: outerOf(node),
                 exported: lang === "python" ? false : isExported(node),
                 extra: [],
-                decorators: decoratorsOf(node, node),
+                decorators: decoratorsOf(node, node, lang),
             });
         }
         else if (CLASS_LIKE.has(node.type)) {
@@ -664,7 +846,7 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
                 outer: outerOf(node),
                 exported: isExported(node),
                 extra: [
-                    ...(type ? [`:${canon(type).replace(/^:\s*/, "")}`] : []),
+                    ...(type ? [`:${canon(type, lang).replace(/^:\s*/, "")}`] : []),
                     ...fn.wrappers.map((w) => `wrap:${w}`),
                 ],
                 decorators: [],
@@ -693,13 +875,15 @@ export function extractFileSymbolsV2(root, lang, normalizeLocals) {
     }
     return { bySymbolPath, fileExports };
 }
-/** Whole-file `body` and `deps` for a file-only anchor, read the version-2 way. */
-export function computeWholeFileTiersV2(root, lang, normalizeLocals) {
-    const importedNames = collectImportedNames(root, lang);
-    const locals = collectLocals(root, null, lang);
-    return {
-        bodyNormalized: serializeBody(root, locals, normalizeLocals, lang, new Map()),
-        deps: collectDeps([root], lang, importedNames, locals),
-    };
+/** Whole-file `body` and `deps` for a file-only anchor, read the version-2 (or 3) way. */
+export function computeWholeFileTiersV2(root, lang, normalizeLocals, version = 2) {
+    return withVersion(version, () => {
+        const importedNames = collectImportedNames(root, lang);
+        const locals = collectLocals(root, null, lang, true);
+        return {
+            bodyNormalized: serializeBody(root, locals, normalizeLocals, lang, new Map()),
+            deps: collectDeps([root], lang, importedNames, locals),
+        };
+    });
 }
 //# sourceMappingURL=extract-v2.js.map