@mnemonik/shared 6.50.0 → 6.51.0

package/dist/ast/astChunker.js

@@ -0,0 +1,559 @@
+/**
+ * The AST chunker: source text in, named line-ranges out. No filesystem, no
+ * logging of file contents, one pure entry point (`chunkWithAst`).
+ *
+ * WHY THIS EXISTS. The heuristic chunker matches a regex whose name pattern
+ * requires a leading `function`/`class`/`const` keyword — a keyword a method's
+ * first line never has. So it produces method-shaped chunks with no
+ * `symbolName`: 1,512 methods in this repo, unnameable and therefore unusable
+ * as citation anchors. Measured over the same 1,037 TypeScript files, the
+ * heuristic named 16.9% of its 16,604 chunks; the tag queries name 100% of
+ * 6,471 definitions.
+ *
+ * THE NESTING RULE. Emitting both a whole class and each of its methods would
+ * duplicate every method body and double the embedding bill, so:
+ *
+ * - a STRUCTURAL definition — one whose body is a container of other definitions
+ *   (class, interface, enum, struct, trait, object, module, namespace) — emits a
+ *   HEADER chunk from its own first line to the line before its first nested
+ *   definition: the declaration plus the fields that precede the first method.
+ *   Real contiguous source, never an elision;
+ * - every other definition is a LEAF and becomes one chunk over its FULL line
+ *   range, whatever it happens to contain. A local arrow function is part of
+ *   what the enclosing function IS, not a sibling of it, so definitions nested
+ *   inside a leaf are not emitted separately — the leaf's chunk already carries
+ *   their source verbatim. See `STRUCTURAL_KINDS` for why that distinction is
+ *   load-bearing rather than cosmetic;
+ * - every remaining uncovered line span becomes a `raw` chunk.
+ *
+ * Coverage is therefore total: every non-blank line of a file belongs to some
+ * chunk, replacing the ~50% coverage of the old heuristic and giving citation
+ * anchoring a line -> chunk map with no holes.
+ *
+ * A NEWLINE IS A TERMINATOR, NOT A LINE. `'...}\n'.split('\n')` yields a phantom
+ * trailing `''` that is not a line of the file. It is dropped before any length
+ * arithmetic, because `memory_file_index.end_line` feeds citation anchoring and
+ * the golden eval's containment scoring, and a one-line drift misaligns both
+ * silently.
+ *
+ * CHUNKS ARE LINE-GRANULAR, NOT BYTE-GRANULAR. A chunk's content is always
+ * `lines.slice(startLine - 1, endLine).join('\n')`. That is deliberate: the tag
+ * queries capture `class_declaration`, which starts at `class` and excludes the
+ * `export ` in front of it, and a citation anchor that omitted `export` would
+ * not match what a reader sees. Line granularity also keeps content verbatim
+ * and contiguous by construction.
+ *
+ * SYMBOL NAMES ARE BARE. `verifyForFile`, not `CitationManager.verifyForFile`.
+ * `memory_file_index.symbol_name` is one column with a partial index on
+ * `(project_id, symbol_name)` and citations reference bare names; storing
+ * qualified names would break lookup. Qualified names are a deliberate
+ * deferral — see the plan's Task 11 gate.
+ *
+ * WASM MEMORY IS NOT GC'd BY THE JS HEAP. Every `Tree` and `TreeCursor` created
+ * here is explicitly deleted in a `finally`. Skipping that leaks across a
+ * whole-repo walk in a long-lived daemon (the scanner is one).
+ */
+import { Parser } from 'web-tree-sitter';
+import { loadGrammar } from './grammars.js';
+/**
+ * Parse ceiling, derived from Task 4's measurement rather than guessed: the
+ * largest source file in this repo is 415 KB (`src/agent/ContextAgent.ts`) and
+ * the slowest per-file parse across 1,061 files was 108.6 ms. 2 MiB is ~5x that
+ * largest real file, which bounds the worst case near half a second — while
+ * still refusing the multi-megabyte generated blobs that `MAX_SCANNED_FILE_BYTES`
+ * (10 MB) otherwise lets through. Above the ceiling the caller degrades to the
+ * heuristic chunker, which is line-bounded and cheap.
+ */
+export const MAX_AST_PARSE_BYTES = 2 * 1024 * 1024;
+/**
+ * Line budget for a single `raw` span chunk, mirroring `ScanOptions.maxChunkSize`
+ * (8000 chars, ~2000 tokens) so AST raw spans and heuristic raw chunks land in
+ * the same size class.
+ */
+const MAX_RAW_SPAN_CHARS = 8000;
+const MAX_SIGNATURE_CHARS = 500;
+/**
+ * `definition.<kind>` -> the wire enum. `chunkType` is constrained to
+ * `function|class|module|raw` by `CodeChunk` and by `scanChunkSchema`;
+ * `symbolKind` is not, and keeps the capture name verbatim.
+ *
+ * Kinds absent here (`constant`, `field`, `property`, `variable`) fall to
+ * `'raw'`: the enum has no value-shaped member, and claiming a constant is a
+ * `class` or a `module` would be false where `'raw'` only says "no coarse class
+ * for this" — the identity is still carried by `symbolName` + `symbolKind`.
+ */
+const CHUNK_TYPE_BY_KIND = {
+    function: 'function',
+    method: 'function',
+    macro: 'function',
+    class: 'class',
+    interface: 'class',
+    enum: 'class',
+    object: 'class',
+    struct: 'class',
+    trait: 'class',
+    type: 'class',
+    module: 'module',
+    namespace: 'module',
+};
+/**
+ * Kinds whose BODY IS A CONTAINER of other definitions. Only these split into a
+ * header chunk; every other kind is a LEAF and gets its full line range.
+ *
+ * The distinction is load-bearing, not cosmetic. When every `definition.*`
+ * capture counted as a nested child, a function declaring one local arrow
+ * function collapsed to its first two lines: `ContextAgent.registerDocsTools`
+ * spans 513 lines and was recorded as 2. A wrong extent is worse than no extent —
+ * it anchors citations confidently at the wrong place instead of failing to
+ * anchor them.
+ *
+ * A closure, a variable, a constant, a field and a property are VALUE-SHAPED:
+ * they are part of what the enclosing definition IS. So is a nested helper
+ * function. Definitions inside a leaf are therefore not emitted at all; the
+ * leaf's own chunk carries their source verbatim, and emitting both would
+ * duplicate it and double the embedding bill.
+ *
+ * `type` stays out deliberately. C's `(type_definition declarator:
+ * (type_identifier) @name) @definition.type` matches `typedef struct {...} Foo;`,
+ * whose nested `struct_specifier` opens on the typedef's own first line — as a
+ * container it would split to an empty header and be dropped entirely, so the
+ * typedef is the leaf and keeps the whole range.
+ */
+const STRUCTURAL_KINDS = new Set([
+    'class',
+    'interface',
+    'enum',
+    'struct',
+    'trait',
+    'object',
+    'module',
+    'namespace',
+]);
+/**
+ * One `Parser` per language for the life of the process. Constructing a parser
+ * per file allocates and frees a wasm parser object 30,000 times on a repo walk
+ * for no benefit; the parse itself is synchronous and stateless once the
+ * language is set.
+ */
+const parsers = new Map();
+function parserFor(binding) {
+    const cached = parsers.get(binding.id);
+    if (cached)
+        return cached;
+    // `Parser.init()` has already run: `loadGrammar` awaits it before
+    // `Language.load`, and we only get a binding after that succeeded.
+    const parser = new Parser();
+    parser.setLanguage(binding.language);
+    parsers.set(binding.id, parser);
+    return parser;
+}
+/**
+ * Chunk `content` by syntax for a language with a vendored grammar.
+ *
+ * Async only because `loadGrammar` is; the grammar is cached per process, so
+ * after the first file of a given language there is no per-file async cost.
+ * Never throws — every failure is a named `unsupported` reason with a detail the
+ * caller can log before degrading.
+ */
+export async function chunkWithAst(content, languageId, opts) {
+    // Size first: refusing a 6 MB generated file must not first instantiate a
+    // 5 MB grammar we then throw away.
+    const ceiling = opts?.maxParseBytes ?? MAX_AST_PARSE_BYTES;
+    const bytes = Buffer.byteLength(content, 'utf8');
+    if (bytes > ceiling) {
+        return {
+            unsupported: 'file_too_large',
+            detail: `${bytes} bytes exceeds the AST parse ceiling of ${ceiling} bytes`,
+        };
+    }
+    const loaded = await loadGrammar(languageId);
+    if ('unavailable' in loaded) {
+        return {
+            unsupported: 'grammar_unavailable',
+            detail: `${String(languageId)}: ${loaded.unavailable}: ${loaded.detail}`,
+        };
+    }
+    const startedAt = performance.now();
+    let tree;
+    try {
+        tree = parserFor(loaded.ok).parse(content);
+    }
+    catch (err) {
+        return {
+            unsupported: 'parse_failed',
+            detail: `${languageId}: web-tree-sitter threw while parsing ${bytes} bytes: ${describe(err)}`,
+        };
+    }
+    if (!tree) {
+        // Documented return value of `Parser.parse`, not a theoretical branch: it
+        // is null when the parse is cancelled or the language is unset.
+        return {
+            unsupported: 'parse_failed',
+            detail: `${languageId}: web-tree-sitter returned no tree for ${bytes} bytes`,
+        };
+    }
+    const parseMs = performance.now() - startedAt;
+    try {
+        const lines = content.split('\n');
+        // A trailing newline TERMINATES the last line, it does not open a new one,
+        // but `split` yields a phantom '' for it. Dropping it here — before
+        // `lines.length` is read by the coverage array, `uncoveredSpans` or
+        // `sliceLines` — is what keeps `endLine` equal to the file's last line
+        // number. Left in, the final raw chunk of every newline-terminated file (109
+        // of this repo's 268 `src/` TypeScript files) ran one line past the end, and
+        // `memory_file_index.end_line` feeds citation anchoring and the golden eval's
+        // containment scoring.
+        if (content.endsWith('\n'))
+            lines.pop();
+        const collected = collectDefinitions(loaded.ok.query, tree.rootNode);
+        const built = buildChunks(collected.definitions, lines);
+        return {
+            chunks: built.chunks,
+            errorNodes: countErrorNodes(tree),
+            parseMs,
+            // A definition can be lost at either stage — collapsed onto another
+            // definition's byte range here, or reaching no chunk in `buildChunks` — and
+            // the caller logs one number, so both have to be in it.
+            droppedDefinitions: built.droppedDefinitions + collected.collapsedDefinitions,
+        };
+    }
+    finally {
+        tree.delete();
+    }
+}
+/**
+ * Every `definition.*` capture with its paired `@name`, outermost first.
+ *
+ * `matches()` rather than `captures()`: a match is one pattern's captures, so
+ * the `@name` belonging to a definition is unambiguous. `captures()` returns a
+ * flat stream in which pairing is guesswork — and the composed QUERY_CHAIN
+ * concatenates several files' patterns, so guessing would mispair across
+ * grammars.
+ */
+function collectDefinitions(query, root) {
+    // Keyed by byte range: the composed chain can match one node from two
+    // patterns (javascript's `class` and `class_declaration` alternates, for
+    // instance), and two chunks over one range would collide on
+    // `filePath:startLine-endLine`, the key ProjectManager uses for staleness.
+    const byRange = new Map();
+    let collapsedDefinitions = 0;
+    for (const match of query.matches(root)) {
+        let definition;
+        let kind = '';
+        let name;
+        for (const capture of match.captures) {
+            if (!definition && capture.name.startsWith('definition.')) {
+                definition = capture.node;
+                kind = capture.name.slice('definition.'.length);
+            }
+            else if (!name && capture.name === 'name') {
+                name = capture.node;
+            }
+        }
+        if (!definition)
+            continue;
+        const extent = widenToDefinition(definition);
+        const key = `${extent.startIndex}:${extent.endIndex}`;
+        // A `@name` from outside the definition's extent would be a query bug;
+        // dropping it costs a name, keeping it would attach a wrong one.
+        const named = name && name.startIndex >= extent.startIndex && name.endIndex <= extent.endIndex
+            ? name.text
+            : undefined;
+        const existing = byRange.get(key);
+        if (existing) {
+            // Two names over one range means a real symbol is gone from
+            // `memory_file_index`, and a citation to it will resolve as
+            // `unresolved_symbol`; the same name twice means the same symbol twice.
+            if (named !== undefined && existing.name !== undefined && existing.name !== named) {
+                collapsedDefinitions++;
+            }
+            continue;
+        }
+        byRange.set(key, {
+            startIndex: extent.startIndex,
+            endIndex: extent.endIndex,
+            startRow: extent.startPosition.row,
+            endRow: extent.endPosition.row,
+            kind,
+            ...(named ? { name: named } : {}),
+        });
+    }
+    // Start ascending, end descending: a parent therefore always precedes the
+    // children it contains, which is what makes the single-pass stack below
+    // correct.
+    const definitions = [...byRange.values()].sort((a, b) => a.startIndex === b.startIndex ? b.endIndex - a.endIndex : a.startIndex - b.startIndex);
+    return { definitions, collapsedDefinitions };
+}
+/**
+ * Ascend from a `@definition.*` capture to the node that actually SPANS the
+ * definition.
+ *
+ * Some tag queries bind the capture to a node that names the definition without
+ * containing its body. `c.tags.scm` and `cpp.tags.scm` are the loud case:
+ *
+ *     (function_declarator declarator: (identifier) @name) @definition.function
+ *
+ * `function_declarator` ends at the closing paren of the parameter list, so
+ * naming it alone reproduces — for two whole languages — the exact defect this
+ * module exists to fix: a named signature line plus an anonymous raw chunk
+ * holding the body.
+ *
+ * The rule is general rather than a C special case, and it takes TWO forms
+ * because C and C++ nest declarators inside other declarators:
+ *
+ * 1. THE `declarator` FIELD. Ascend while the node is bound to its parent's
+ *    `declarator` field. That field is the grammar's own statement of "this node
+ *    is the declarator OF something larger", so the ascent lands on the node that
+ *    owns the body (`function_definition`, `declaration`, `field_declaration`,
+ *    through any `pointer_declarator` or `array_declarator` in between).
+ * 2. A DECLARATOR WRAPPER. `int &f()` parses as
+ *    `(function_definition declarator: (reference_declarator (function_declarator …)))`
+ *    and `int (*f(void))[4]` as `… (parenthesized_declarator (pointer_declarator …))`.
+ *    Neither `reference_declarator` nor `parenthesized_declarator` NAMES the
+ *    declarator it wraps — the child sits in an unnamed field — so rule 1 alone
+ *    stopped dead at `function_declarator` and reproduced the very defect above
+ *    for `T &operator[]`, `std::string &name()`, and every other
+ *    reference-returning accessor in real C++. So also ascend when the parent is
+ *    itself a declarator that holds this declarator in an UNNAMED field.
+ *
+ * Both forms keep the property that made rule 1 safe: neither can reach an
+ * unrelated ancestor. Rule 1 follows a field the grammar defines only within a
+ * declaration; rule 2 requires BOTH ends to be declarator nodes, and a
+ * `field_declaration_list` is not one — a method inside a class body therefore
+ * still stops at its own `function_definition` and a class is never swallowed.
+ * Grammars that already bind the whole definition (every JS/TS, Python, Go, Rust,
+ * Ruby pattern) fail both conditions on the first iteration, which makes this a
+ * no-op for them: TypeScript's `variable_declarator` sits unnamed in a
+ * `lexical_declaration`, which is not a declarator, so rule 2 does not fire and
+ * `const a = 1; const b = () => 2;` stays two statements.
+ */
+function widenToDefinition(node) {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (!parent)
+            return current;
+        // `childrenForFieldName`, not `childForFieldName`: `int a, f(int x);` binds
+        // two declarators to one declaration, and the singular accessor answers only
+        // the first — which would refuse to widen every declarator but one.
+        const boundToDeclaratorField = parent
+            .childrenForFieldName('declarator')
+            .some((child) => child.id === current.id);
+        if (!boundToDeclaratorField && !wrapsDeclarator(parent, current))
+            return current;
+        current = parent;
+    }
+}
+/** A declarator node type, by the grammars' own naming convention. */
+function isDeclarator(node) {
+    return node.type.endsWith('_declarator');
+}
+/**
+ * True when `parent` is a declarator that wraps `child` without naming the field
+ * — `reference_declarator` (`&` / `&&`) and `parenthesized_declarator` (`( … )`),
+ * whose grammar rules are a bare token sequence around the inner declarator.
+ *
+ * Both ends must be declarators, and the field must be UNNAMED: a declarator's
+ * named fields hold things that are NOT the wrapped declarator (`parameters`,
+ * `size`, `value`), and ascending out of one of those would leave the
+ * declaration the capture belongs to.
+ */
+function wrapsDeclarator(parent, child) {
+    if (!isDeclarator(parent) || !isDeclarator(child))
+        return false;
+    return fieldNameForChild(parent, child) === null;
+}
+/**
+ * The field name binding `child` to `parent`, or null when the child sits in an
+ * unnamed field. `Node` exposes no direct accessor, so the index has to be found
+ * first; declarator nodes have a handful of children, so the scan is trivial.
+ */
+function fieldNameForChild(parent, child) {
+    for (let i = 0; i < parent.childCount; i++) {
+        if (parent.child(i)?.id === child.id)
+            return parent.fieldNameForChild(i);
+    }
+    return null;
+}
+function buildChunks(definitions, lines) {
+    // `headerEndRow[i]` is the 0-based row of definition `i`'s first nested
+    // definition — set only for STRUCTURAL definitions, since only they split.
+    // `suppressed[i]` marks a definition that lies inside a leaf and is therefore
+    // already carried, verbatim, by that leaf's own chunk.
+    const headerEndRow = new Map();
+    const suppressed = new Uint8Array(definitions.length);
+    const open = [];
+    for (let i = 0; i < definitions.length; i++) {
+        const current = definitions[i];
+        if (!current)
+            continue;
+        while (open.length > 0) {
+            const top = definitions[open[open.length - 1] ?? -1];
+            if (top && top.endIndex > current.startIndex)
+                break;
+            open.pop();
+        }
+        const parentIndex = open[open.length - 1];
+        const parent = parentIndex === undefined ? undefined : definitions[parentIndex];
+        if (parentIndex !== undefined && parent) {
+            if (suppressed[parentIndex] === 1 || !STRUCTURAL_KINDS.has(parent.kind)) {
+                // Inside a leaf (or inside something already inside one). Suppression
+                // propagates: a class declared inside a function belongs to that
+                // function's chunk, and so do the class's own methods.
+                suppressed[i] = 1;
+            }
+            else if (!headerEndRow.has(parentIndex)) {
+                headerEndRow.set(parentIndex, current.startRow);
+            }
+        }
+        open.push(i);
+    }
+    const chunks = [];
+    const emittedRanges = new Set();
+    const covered = new Uint8Array(lines.length + 2);
+    let droppedDefinitions = 0;
+    /** True when the chunk was emitted; false when its range cannot carry one. */
+    const emit = (chunk) => {
+        if (chunk.endLine < chunk.startLine)
+            return false;
+        const key = `${chunk.startLine}:${chunk.endLine}`;
+        if (emittedRanges.has(key))
+            return false;
+        if (chunk.content.trim() === '')
+            return false;
+        emittedRanges.add(key);
+        chunks.push(chunk);
+        for (let line = chunk.startLine; line <= chunk.endLine; line++)
+            covered[line] = 1;
+        return true;
+    };
+    for (let i = 0; i < definitions.length; i++) {
+        const definition = definitions[i];
+        if (!definition || suppressed[i] === 1)
+            continue;
+        // THE ONE 0-based -> 1-based conversion. `Point.row` is 0-based; startLine
+        // and endLine are 1-based inclusive. A structural definition's first child
+        // starts on `headerEnd + 1`, so its header ends on the line before that:
+        // `headerEnd`. When the child opens on the container's own first line
+        // (`class A { m() {} }`) that range is empty, `emit` refuses it and the
+        // refusal is counted — emitting the line anyway would duplicate the child's
+        // source. Clamped to the last real line so a definition whose node runs to
+        // end-of-file cannot name a line that does not exist.
+        const headerEnd = headerEndRow.get(i);
+        const startLine = definition.startRow + 1;
+        const endLine = Math.min(headerEnd ?? definition.endRow + 1, lines.length);
+        const content = sliceLines(lines, startLine, endLine);
+        const signature = (content.split('\n')[0] ?? '').trim().slice(0, MAX_SIGNATURE_CHARS);
+        const emitted = emit({
+            content,
+            startLine,
+            endLine,
+            chunkType: CHUNK_TYPE_BY_KIND[definition.kind] ?? 'raw',
+            ...(definition.name ? { symbolName: definition.name } : {}),
+            symbolKind: definition.kind,
+            ...(signature ? { signature } : {}),
+        });
+        // A definition that reaches no chunk reaches no index either, and a citation
+        // to it resolves as `unresolved_symbol`. It cannot be emitted without
+        // colliding on the staleness key, so it is counted and reported instead of
+        // vanishing — a silent no-op is the defect class, not the collision.
+        if (!emitted)
+            droppedDefinitions++;
+    }
+    for (const span of uncoveredSpans(covered, lines.length)) {
+        for (const [startLine, endLine] of splitSpan(lines, span)) {
+            // Uncovered spans are not counted when refused: a whitespace-only span is
+            // owed no chunk, which is the documented contract of `splitSpan`.
+            emit({
+                content: sliceLines(lines, startLine, endLine),
+                startLine,
+                endLine,
+                chunkType: 'raw',
+            });
+        }
+    }
+    return {
+        chunks: chunks.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine),
+        droppedDefinitions,
+    };
+}
+const sliceLines = (lines, startLine, endLine) => lines.slice(startLine - 1, endLine).join('\n');
+/** Maximal runs of lines no definition chunk claimed, as 1-based inclusive pairs. */
+function uncoveredSpans(covered, lineCount) {
+    const spans = [];
+    let start = null;
+    for (let line = 1; line <= lineCount; line++) {
+        if (covered[line] === 1) {
+            if (start !== null)
+                spans.push([start, line - 1]);
+            start = null;
+        }
+        else if (start === null) {
+            start = line;
+        }
+    }
+    if (start !== null)
+        spans.push([start, lineCount]);
+    return spans;
+}
+/**
+ * Break an uncovered span on line boundaries so no chunk exceeds
+ * `MAX_RAW_SPAN_CHARS`. No overlap — overlap would re-embed the same lines — and
+ * no mid-line splitting: two chunks over one line range would collide on the
+ * `filePath:startLine-endLine` staleness key, so an over-long single line is
+ * left whole and the embedding layer truncates it with a warning
+ * (`EmbeddingService` caps each input at the 8191-token per-input limit).
+ *
+ * Whitespace-only spans yield nothing — `emit` drops them, and the blank lines
+ * between definitions are the one thing total coverage does not owe a chunk.
+ */
+function splitSpan(lines, [spanStart, spanEnd]) {
+    const pieces = [];
+    let start = spanStart;
+    let length = 0;
+    for (let line = spanStart; line <= spanEnd; line++) {
+        const lineLength = (lines[line - 1] ?? '').length + 1;
+        if (line > start && length + lineLength > MAX_RAW_SPAN_CHARS) {
+            pieces.push([start, line - 1]);
+            start = line;
+            length = 0;
+        }
+        length += lineLength;
+    }
+    pieces.push([start, spanEnd]);
+    return pieces;
+}
+/**
+ * ERROR and MISSING nodes, so a caller can see that a file parsed badly instead
+ * of inferring it from thin chunks.
+ *
+ * Short-circuits on a clean tree, and descends only into subtrees whose own
+ * `hasError` is true — 97.6% of this repo's TypeScript files have no error at
+ * all, and they must not pay for a full tree walk.
+ */
+function countErrorNodes(tree) {
+    if (!tree.rootNode.hasError)
+        return 0;
+    const cursor = tree.walk();
+    let count = 0;
+    try {
+        for (;;) {
+            const node = cursor.currentNode;
+            if (node.isError || node.isMissing)
+                count++;
+            if (node.hasError && cursor.gotoFirstChild())
+                continue;
+            for (;;) {
+                if (cursor.gotoNextSibling())
+                    break;
+                if (!cursor.gotoParent())
+                    return count;
+            }
+        }
+    }
+    finally {
+        cursor.delete();
+    }
+}
+const describe = (err) => err instanceof Error ? err.message.slice(0, 200) || err.constructor.name : String(err);
+//# sourceMappingURL=astChunker.js.map

package/dist/ast/astChunker.js.map

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