context-mode 1.0.162 → 1.0.164

package/build/session/analytics.d.ts

@@ -278,7 +278,7 @@ export interface AdapterDirEntry {
  * so a single call surfaces "your work everywhere on this machine across
  * all AI tools" (the marketing line).
  *
- * Returns ALL 15 adapters even when the dir doesn't exist on disk — the
+ * Returns ALL 17 adapters even when the dir doesn't exist on disk — the
  * scanner functions filter to existing dirs. That keeps the enumeration
  * pure / testable without filesystem dependencies.
  */

package/build/session/analytics.js

@@ -359,7 +359,7 @@ export class AnalyticsEngine {
  * so a single call surfaces "your work everywhere on this machine across
  * all AI tools" (the marketing line).
  *
- * Returns ALL 15 adapters even when the dir doesn't exist on disk — the
+ * Returns ALL 17 adapters even when the dir doesn't exist on disk — the
  * scanner functions filter to existing dirs. That keeps the enumeration
  * pure / testable without filesystem dependencies.
  */
@@ -370,10 +370,12 @@ export function enumerateAdapterDirs(opts) {
         ["claude-code", [".claude"]],
         ["gemini-cli", [".gemini"]],
         ["antigravity", [".gemini"]],
+        ["antigravity-cli", [".gemini"]],
         ["openclaw", [".openclaw"]],
         ["codex", [".codex"]],
         ["cursor", [".cursor"]],
         ["vscode-copilot", [".vscode"]],
+        ["copilot-cli", [".copilot"]],
         ["kiro", [".kiro"]],
         ["pi", [".pi"]],
         ["omp", [".omp"]],
@@ -1188,10 +1190,12 @@ export const adapterLabels = {
     "claude-code": "Claude Code",
     "gemini-cli": "Gemini CLI",
     "antigravity": "Antigravity",
+    "antigravity-cli": "Antigravity CLI",
     "openclaw": "Openclaw",
     "codex": "Codex CLI",
     "cursor": "Cursor",
     "vscode-copilot": "VS Code Copilot",
+    "copilot-cli": "GitHub Copilot CLI",
     "kiro": "Kiro",
     "pi": "Pi",
     "omp": "OMP",

package/build/session/db.js

@@ -899,7 +899,12 @@ export class SessionDB extends SQLiteBase {
                 .slice(0, 16)
                 .toUpperCase();
             const attribution = attributions?.[i];
-            const projectDir = String(attribution?.projectDir ?? event.project_dir ?? this._getSessionProjectDir(sessionId) ?? "").trim();
+            // #827: store project_dir in canonical path shape so the search-time
+            // allow-set lookup (getSessionIdsForProject) matches regardless of the
+            // separator / trailing-slash form the host adapter happened to emit.
+            // normalizeWorktreePath is the same rule used for project-hash stability.
+            const rawProjectDir = String(attribution?.projectDir ?? event.project_dir ?? this._getSessionProjectDir(sessionId) ?? "").trim();
+            const projectDir = rawProjectDir === "" ? "" : normalizeWorktreePath(rawProjectDir);
             const attributionSource = String(attribution?.source ?? event.attribution_source ?? "unknown");
             const rawConfidence = Number(attribution?.confidence ?? event.attribution_confidence ?? 0);
             const attributionConfidence = Number.isFinite(rawConfidence)
@@ -1031,11 +1036,26 @@ export class SessionDB extends SQLiteBase {
      */
     getSessionIdsForProject(projectDir) {
         try {
+            // #827: match by canonical path shape, not raw bytes. The host adapter
+            // may store `project_dir` in a different separator / trailing-slash
+            // shape than the search path resolves the scope in — most visibly on
+            // Windows, where attribution often carries `C:\Users\me\proj` while the
+            // server resolves `C:/Users/me/proj`. An exact `project_dir = ?` match
+            // then returned an EMPTY allow-set and ctx_search reported "No results
+            // found" even though the content was present. We fold BOTH sides through
+            // the same canonical rule used for project-hash stability
+            // (normalizeWorktreePath): backslash → forward slash, then strip the
+            // trailing slash. Normalizing in SQL (RTRIM(REPLACE(...))) covers rows
+            // already written un-normalized without a migration, while the JS-side
+            // normalize keeps the bound parameter in the identical shape. This
+            // preserves the #737 project scope — distinct directories still differ
+            // after normalization, so cross-project isolation is intact.
+            const normalized = normalizeWorktreePath(projectDir);
             const rows = this.db
                 .prepare(`SELECT DISTINCT session_id
              FROM session_events
-            WHERE project_dir = ?`)
-                .all(projectDir);
+            WHERE RTRIM(REPLACE(project_dir, '\\', '/'), '/') = ?`)
+                .all(normalized);
             return rows.map((r) => r.session_id);
         }
         catch {

package/build/session/extract.js

@@ -1439,6 +1439,72 @@ const ROLE_MIN_CHARS = 8;
 const ROLE_MAX_CHARS = 120;
 const TWO_LEXICAL_TOKENS_PATTERN = /\p{L}+\s+\p{L}+/u;
 const CONTINUOUS_LETTER_RUN_PATTERN = /\p{L}{6,}/u;
+// Issue #856 — persona / standing-directive cue gate.
+//
+// The structural test below ("two lexical tokens OR a 6-codepoint letter run,
+// 8..120 chars, no '?', no clause separator") is intentionally coarse and
+// matches ANY short declarative sentence. That let casual conversational
+// acknowledgements ("that's fine for now", "go with the second option") freeze
+// as a priority-3 `role`, which the Pi adapter then re-injected as a standing
+// behavioral_directive every turn → do-nothing loop.
+//
+// A genuine role/behavioral prompt always LEADS with a persona declaration
+// ("You are X", "Tu es X", "あなたは…", "你是…") or a standing-directive verb
+// ("always respond…", "act as…"). Casual phrases never do, so we require that
+// cue as a NECESSARY condition. This preserves legitimate role persistence
+// (issue #535 multilingual corpus) while killing the casual-phrase loop.
+//
+// ALGORITHMIC ONLY — pure lowercase + prefix membership, no regex (project
+// hard rule). Multilingual openers are matched by `startsWith` on the
+// normalized first clause; leading conversational filler tokens are stripped
+// by array operations before the check.
+const ROLE_FILLER_TOKENS = new Set([
+    "ok", "okay", "sure", "yeah", "yep", "yup", "alright", "fine",
+    "well", "so", "hmm", "right", "please",
+]);
+// Second-person persona openers across the supported-language corpus
+// (issue #535 multilingual role test set) plus common English persona framings.
+const ROLE_PERSONA_PREFIXES = [
+    "you are", "you're", "your role", "you will be", "you act", "you will act",
+    "act as", "act like", "behave as", "behave like", "imagine you", "pretend you",
+    "assume the role", "take the role", "play the role", "respond as",
+    "tu es", "tu est", "vous etes", "vous êtes", // French
+    "sen ", "siz ", // Turkish (Sen kıdemli…)
+    "eres ", "tú eres", "usted es", // Spanish (Eres…)
+    "ты ", "вы ", // Russian (Ты опытный…)
+    "あなたは", "君は", "お前は", "あなたが", // Japanese (あなたは…)
+    "你是", "您是", // Chinese (你是…)
+    "तुम ", "आप ", "तू ", // Hindi (तुम…)
+    "أنت ", "انت ", "أنتَ ", // Arabic (أنت…)
+];
+// Standing-directive verb openers — imperative behavioral rules that should
+// persist ("always respond in TypeScript", "never use emojis").
+const ROLE_DIRECTIVE_PREFIXES = [
+    "always ", "never ", "respond ", "reply ", "answer ", "speak ",
+    "write ", "prefer ", "format ", "output ", "communicate ", "use only ",
+];
+function hasRoleCue(firstClause) {
+    const lower = firstClause.toLowerCase().trim();
+    if (!lower)
+        return false;
+    // Strip leading conversational filler tokens via array ops (no regex).
+    const tokens = lower.split(" ").filter((t) => t.length > 0);
+    while (tokens.length > 0 && ROLE_FILLER_TOKENS.has(tokens[0])) {
+        tokens.shift();
+    }
+    const normalized = tokens.join(" ");
+    if (!normalized)
+        return false;
+    for (const prefix of ROLE_PERSONA_PREFIXES) {
+        if (normalized.startsWith(prefix))
+            return true;
+    }
+    for (const prefix of ROLE_DIRECTIVE_PREFIXES) {
+        if (normalized.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
 function looksLikeRole(trimmed) {
     // Role prompts are persona-prefix shaped: the FIRST SENTENCE declares the
     // role (e.g. "You are a senior backend engineer. <long context...>").
@@ -1457,6 +1523,10 @@ function looksLikeRole(trimmed) {
     const codepointLength = [...firstClause].length;
     if (codepointLength < ROLE_MIN_CHARS || codepointLength > ROLE_MAX_CHARS)
         return false;
+    // Issue #856 — require a persona / standing-directive cue so casual
+    // conversational acknowledgements do not freeze as a role directive.
+    if (!hasRoleCue(firstClause))
+        return false;
     return (TWO_LEXICAL_TOKENS_PATTERN.test(firstClause) ||
         CONTINUOUS_LETTER_RUN_PATTERN.test(firstClause));
 }
@@ -1749,6 +1819,14 @@ const TOOL_NAME_NORMALIZE = {
     "container.exec": "Bash",
     local_shell: "Bash",
     grep_files: "Grep",
+    // Antigravity CLI (`agy`) native names. Keep in sync with the two other agy
+    // maps: hooks/antigravity-cli/payload.mjs (normalizeAgyToolName) and
+    // hooks/core/routing.mjs (TOOL_ALIASES).
+    run_command: "Bash",
+    view_file: "Read",
+    read_url_content: "WebFetch",
+    list_dir: "LS",
+    search_web: "WebSearch",
 };
 function normalizeHookInput(input) {
     const normalized = TOOL_NAME_NORMALIZE[input.tool_name];

package/build/store.d.ts

@@ -88,7 +88,7 @@ export declare class ContentStore {
     indexPlainText(content: string, source: string, linesPerChunk?: number, attribution?: {
         sessionId?: string;
         eventId?: string;
-    }): IndexResult;
+    }, maxChunkBytes?: number): IndexResult;
     /**
      * Index JSON content by walking the object tree and using key paths
      * as chunk titles (analogous to heading hierarchy in markdown). Objects

package/build/store.js

@@ -108,6 +108,20 @@ function maxEditDistance(wordLength) {
 // length normalization and produce unwieldy search results. Split at paragraph
 // boundaries when a chunk exceeds this cap.
 const MAX_CHUNK_BYTES = 4096;
+// Blank-line sectioning is used only for output that is *naturally* sectioned:
+// at least a few sections, not an unbounded explosion, and no single section so
+// large that the split is clearly not the real structure (those fall back to
+// line-grouping). Sections that pass the heuristic but still exceed
+// MAX_CHUNK_BYTES are sub-split so no persisted chunk breaks the cap.
+const MIN_BLANK_LINE_SECTIONS = 3;
+const MAX_BLANK_LINE_SECTIONS = 200;
+const BLANK_SECTION_STRATEGY_MAX_BYTES = 5000;
+// Number of leading characters of a chunk's first line used as its title.
+const CHUNK_TITLE_MAX_CHARS = 80;
+// When byte-splitting an oversized single line, prefer to break at a whitespace
+// boundary for readability — but only if that boundary is past this fraction of
+// the slice, otherwise we'd waste too much of the byte budget.
+const WHITESPACE_BREAK_RATIO = 0.5;
 // ─────────────────────────────────────────────────────────
 // ContentStore
 // ─────────────────────────────────────────────────────────
@@ -820,11 +834,11 @@ export class ContentStore {
      * into fixed-size line groups. Unlike markdown indexing, this does not
      * look for headings — it chunks by line count with overlap.
      */
-    indexPlainText(content, source, linesPerChunk = 20, attribution) {
+    indexPlainText(content, source, linesPerChunk = 20, attribution, maxChunkBytes = MAX_CHUNK_BYTES) {
         if (!content || content.trim().length === 0) {
             return this.#insertChunks([], source, "", undefined, undefined, attribution);
         }
-        const chunks = this.#chunkPlainText(content, linesPerChunk);
+        const chunks = this.#chunkPlainText(content, linesPerChunk, maxChunkBytes);
         return withRetry(() => this.#insertChunks(chunks.map((c) => ({ ...c, hasCode: false })), source, content, undefined, undefined, attribution));
     }
     // ── Index JSON ──
@@ -837,19 +851,19 @@ export class ContentStore {
      */
     indexJSON(content, source, maxChunkBytes = MAX_CHUNK_BYTES, attribution) {
         if (!content || content.trim().length === 0) {
-            return this.indexPlainText("", source, undefined, attribution);
+            return this.indexPlainText("", source, undefined, attribution, maxChunkBytes);
         }
         let parsed;
         try {
             parsed = JSON.parse(content);
         }
         catch {
-            return this.indexPlainText(content, source, undefined, attribution);
+            return this.indexPlainText(content, source, undefined, attribution, maxChunkBytes);
         }
         const chunks = [];
         this.#walkJSON(parsed, [], chunks, maxChunkBytes);
         if (chunks.length === 0) {
-            return this.indexPlainText(content, source, undefined, attribution);
+            return this.indexPlainText(content, source, undefined, attribution, maxChunkBytes);
         }
         return withRetry(() => this.#insertChunks(chunks, source, content, undefined, undefined, attribution));
     }
@@ -1448,27 +1462,119 @@ export class ContentStore {
         flush();
         return chunks;
     }
-    #chunkPlainText(text, linesPerChunk) {
+    /**
+     * Return the largest prefix of `str` whose UTF-8 byte length does not exceed
+     * `maxBytes`, walking by Unicode code point so multibyte sequences (CJK) and
+     * surrogate pairs (emoji) are never cut mid-character. Guarantees forward
+     * progress: if even the first code point exceeds `maxBytes`, it is still
+     * returned whole (a 1-4 byte overshoot beats an infinite loop).
+     */
+    #byteCappedPrefix(str, maxBytes) {
+        if (Buffer.byteLength(str) <= maxBytes)
+            return str;
+        let prefix = "";
+        let bytes = 0;
+        for (const char of str) {
+            const charBytes = Buffer.byteLength(char);
+            if (bytes + charBytes > maxBytes)
+                break;
+            prefix += char;
+            bytes += charBytes;
+        }
+        // Defensive: a single code point wider than the cap (only possible with a
+        // pathologically small maxBytes) still advances by one character.
+        if (prefix.length === 0)
+            return [...str][0] ?? "";
+        return prefix;
+    }
+    /**
+     * Split a single oversized plain-text chunk into byte-capped sub-chunks
+     * by accumulating lines until the byte count would exceed maxChunkBytes.
+     * Falls back to byte-accurate splitting for extremely long single lines.
+     */
+    #splitOversizedPlainChunk(lines, titlePrefix, maxChunkBytes) {
+        const subChunks = [];
+        let accumulator = [];
+        let partIndex = 1;
+        const flushAccumulator = () => {
+            if (accumulator.length === 0)
+                return;
+            const content = accumulator.join("\n");
+            const partTitle = partIndex === 1 ? titlePrefix : `${titlePrefix} (${partIndex})`;
+            subChunks.push({ title: partTitle, content });
+            partIndex++;
+            accumulator = [];
+        };
+        for (const line of lines) {
+            // If a single line itself exceeds the cap (even as first line),
+            // split it by character before accumulating
+            if (Buffer.byteLength(line) > maxChunkBytes) {
+                flushAccumulator();
+                // Split the long line into byte-capped pieces
+                let remaining = line;
+                let linePart = 1;
+                while (remaining.length > 0) {
+                    // Byte-accurate slice: never exceeds the cap, never cuts a multibyte
+                    // character (CJK) or surrogate pair (emoji) in half.
+                    let slice = this.#byteCappedPrefix(remaining, maxChunkBytes);
+                    // Try to break at a whitespace boundary near the end for readability,
+                    // but only when text remains after this slice.
+                    if (slice.length < remaining.length) {
+                        const lastSpace = slice.lastIndexOf(" ");
+                        const lastNewline = slice.lastIndexOf("\n");
+                        const breakPoint = Math.max(lastSpace, lastNewline);
+                        if (breakPoint > slice.length * WHITESPACE_BREAK_RATIO) {
+                            slice = slice.slice(0, breakPoint);
+                        }
+                    }
+                    const linePartTitle = partIndex === 1 && linePart === 1
+                        ? titlePrefix
+                        : `${titlePrefix} (${partIndex}.${linePart})`;
+                    subChunks.push({ title: linePartTitle, content: slice });
+                    remaining = remaining.slice(slice.length);
+                    linePart++;
+                    partIndex++;
+                }
+                continue;
+            }
+            const candidate = accumulator.length > 0
+                ? accumulator.join("\n") + "\n" + line
+                : line;
+            // If adding this line would exceed the cap, flush accumulator first
+            if (Buffer.byteLength(candidate) > maxChunkBytes && accumulator.length > 0) {
+                flushAccumulator();
+            }
+            accumulator.push(line);
+        }
+        flushAccumulator();
+        return subChunks;
+    }
+    #chunkPlainText(text, linesPerChunk, maxChunkBytes = MAX_CHUNK_BYTES) {
         // Try blank-line splitting first for naturally-sectioned output
         const sections = text.split(/\n\s*\n/);
-        if (sections.length >= 3 &&
-            sections.length <= 200 &&
-            sections.every((s) => Buffer.byteLength(s) < 5000)) {
-            return sections
-                .map((section, i) => {
+        if (sections.length >= MIN_BLANK_LINE_SECTIONS &&
+            sections.length <= MAX_BLANK_LINE_SECTIONS &&
+            sections.every((s) => Buffer.byteLength(s) < BLANK_SECTION_STRATEGY_MAX_BYTES)) {
+            return sections.flatMap((section, i) => {
                 const trimmed = section.trim();
-                const firstLine = trimmed.split("\n")[0].slice(0, 80);
-                return {
-                    title: firstLine || `Section ${i + 1}`,
-                    content: trimmed,
-                };
-            })
-                .filter((s) => s.content.length > 0);
+                if (trimmed.length === 0)
+                    return [];
+                const title = trimmed.split("\n")[0].slice(0, CHUNK_TITLE_MAX_CHARS) || `Section ${i + 1}`;
+                // A section may pass the strategy guard yet still exceed the byte cap
+                // (4097–4999B band): sub-split it so no stored chunk breaks the cap.
+                if (Buffer.byteLength(trimmed) <= maxChunkBytes) {
+                    return [{ title, content: trimmed }];
+                }
+                return this.#splitOversizedPlainChunk(trimmed.split("\n"), title, maxChunkBytes);
+            });
         }
         const lines = text.split("\n");
-        // Small enough for a single chunk
+        // Small enough for a single chunk — but still enforce byte cap
         if (lines.length <= linesPerChunk) {
-            return [{ title: "Output", content: text }];
+            if (Buffer.byteLength(text) <= maxChunkBytes) {
+                return [{ title: "Output", content: text }];
+            }
+            return this.#splitOversizedPlainChunk(lines, "Output", maxChunkBytes);
         }
         // Fixed-size line groups with 2-line overlap
         const chunks = [];
@@ -1480,11 +1586,19 @@ export class ContentStore {
                 break;
             const startLine = i + 1;
             const endLine = Math.min(i + slice.length, lines.length);
-            const firstLine = slice[0]?.trim().slice(0, 80);
-            chunks.push({
-                title: firstLine || `Lines ${startLine}-${endLine}`,
-                content: slice.join("\n"),
-            });
+            const firstLine = slice[0]?.trim().slice(0, CHUNK_TITLE_MAX_CHARS);
+            const joined = slice.join("\n");
+            // Enforce byte cap: sub-split oversized line-group chunks
+            if (Buffer.byteLength(joined) <= maxChunkBytes) {
+                chunks.push({
+                    title: firstLine || `Lines ${startLine}-${endLine}`,
+                    content: joined,
+                });
+            }
+            else {
+                const subChunks = this.#splitOversizedPlainChunk(slice, firstLine || `Lines ${startLine}-${endLine}`, maxChunkBytes);
+                chunks.push(...subChunks);
+            }
         }
         return chunks;
     }

package/build/tool-naming.d.ts

@@ -0,0 +1,4 @@
+export declare function getToolName(platform: string, bareTool: string): string;
+export type ToolNamer = (bareTool: string) => string;
+export declare function createToolNamer(platform: string): ToolNamer;
+export declare const KNOWN_PLATFORMS: string[];

package/build/tool-naming.js

@@ -0,0 +1,24 @@
+const TOOL_PREFIXES = {
+    "claude-code": (tool) => `mcp__plugin_context-mode_context-mode__${tool}`,
+    "gemini-cli": (tool) => `mcp__context-mode__${tool}`,
+    "antigravity": (tool) => `mcp__context-mode__${tool}`,
+    "opencode": (tool) => `context-mode_${tool}`,
+    "kilo": (tool) => `context-mode_${tool}`,
+    "vscode-copilot": (tool) => `context-mode_${tool}`,
+    "jetbrains-copilot": (tool) => `context-mode_${tool}`,
+    "kiro": (tool) => `@context-mode/${tool}`,
+    "zed": (tool) => `mcp:context-mode:${tool}`,
+    "cursor": (tool) => tool,
+    "codex": (tool) => tool,
+    "openclaw": (tool) => tool,
+    "pi": (tool) => tool,
+    "qwen-code": (tool) => `mcp__context-mode__${tool}`,
+};
+export function getToolName(platform, bareTool) {
+    const fn = TOOL_PREFIXES[platform] || TOOL_PREFIXES["claude-code"];
+    return fn(bareTool);
+}
+export function createToolNamer(platform) {
+    return (bareTool) => getToolName(platform, bareTool);
+}
+export const KNOWN_PLATFORMS = Object.keys(TOOL_PREFIXES);

package/build/util/jsonc.d.ts

@@ -0,0 +1,14 @@
+/**
+ * util/jsonc — string-aware JSONC comment + trailing-comma stripping and a
+ * tolerant parse. Several agent CLIs ship config files as JSONC (VS Code
+ * `mcp.json`, Zed `settings.json`), so a strict `JSON.parse` false-fails on a
+ * perfectly valid commented file. Use `parseJsonc` whenever reading a
+ * platform config we did not write ourselves.
+ */
+/** Strip `//` line + `/* *​/` block comments and trailing commas, string-aware. */
+export declare function stripJsonComments(str: string): string;
+/**
+ * Parse JSON or JSONC. Tries strict `JSON.parse` first (fast, exact), then a
+ * comment/trailing-comma-stripped parse. Returns `undefined` when both fail.
+ */
+export declare function parseJsonc<T = unknown>(raw: string): T | undefined;

package/build/util/jsonc.js

@@ -0,0 +1,104 @@
+/**
+ * util/jsonc — string-aware JSONC comment + trailing-comma stripping and a
+ * tolerant parse. Several agent CLIs ship config files as JSONC (VS Code
+ * `mcp.json`, Zed `settings.json`), so a strict `JSON.parse` false-fails on a
+ * perfectly valid commented file. Use `parseJsonc` whenever reading a
+ * platform config we did not write ourselves.
+ */
+/** Strip `//` line + `/* *​/` block comments and trailing commas, string-aware. */
+export function stripJsonComments(str) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    let inBlockComment = false;
+    for (let i = 0; i < str.length; i++) {
+        const c = str[i];
+        const next = str[i + 1];
+        if (inBlockComment) {
+            if (c === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (escaped) {
+            out += c;
+            escaped = false;
+            continue;
+        }
+        if (c === "\\") {
+            out += c;
+            escaped = inString;
+            continue;
+        }
+        if (c === '"') {
+            inString = !inString;
+            out += c;
+            continue;
+        }
+        if (!inString && c === "/" && next === "/") {
+            while (i < str.length && str[i] !== "\n")
+                i++;
+            if (i < str.length)
+                out += "\n";
+            continue;
+        }
+        if (!inString && c === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    // Trailing-comma removal, string-aware. The scan above already removed
+    // comments, so this second pass over `out` only needs to track string state:
+    // a comma is "trailing" when the next significant char is `}` or `]`. Doing
+    // it here — instead of a post-hoc trailing-comma regex over the whole string —
+    // preserves commas inside string literals (e.g. "[1, ]"), which that regex
+    // silently corrupted to "[1 ]". See #787 review.
+    let result = "";
+    let inStr = false;
+    let esc = false;
+    for (let i = 0; i < out.length; i++) {
+        const c = out[i];
+        if (esc) {
+            result += c;
+            esc = false;
+            continue;
+        }
+        if (c === "\\") {
+            result += c;
+            esc = inStr;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            result += c;
+            continue;
+        }
+        if (!inStr && c === ",") {
+            let j = i + 1;
+            while (j < out.length && (out[j] === " " || out[j] === "\t" || out[j] === "\r" || out[j] === "\n"))
+                j++;
+            if (out[j] === "}" || out[j] === "]")
+                continue;
+        }
+        result += c;
+    }
+    return result;
+}
+/**
+ * Parse JSON or JSONC. Tries strict `JSON.parse` first (fast, exact), then a
+ * comment/trailing-comma-stripped parse. Returns `undefined` when both fail.
+ */
+export function parseJsonc(raw) {
+    for (const candidate of [raw, stripJsonComments(raw)]) {
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return undefined;
+}