@telorun/ide-support 0.4.1 → 0.4.4

package/dist/completions/detect-context.js

@@ -23,16 +23,38 @@ export function extractKindFromDoc(lines, start, end) {
     }
     return undefined;
 }
-export function extractRootKeys(lines, start, end) {
+/** Collects every top-level key in the doc bounds, skipping `skipLine` so the
+ *  cursor's own line is treated as "being edited" — its key (if any) stays in
+ *  the suggestion list. Without this the user can't autocomplete an existing
+ *  key from its own line (e.g. `ver|sion:`). */
+export function extractRootKeys(lines, start, end, skipLine) {
     const keys = new Set();
     for (let i = start; i < end; i++) {
+        if (i === skipLine)
+            continue;
         const m = lines[i]?.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
         if (m)
             keys.add(m[1]);
     }
     return keys;
 }
-/** Walk backward from cursorLine to build the chain of parent YAML keys. */
+/** Walk backward from cursorLine to build the chain of parent YAML keys.
+ *
+ *  List-item handling (`  - request:` style): the `-` marker sits at the
+ *  line's textual indent, but the key after it (`request`) lives at indent
+ *  `+2`. Whether that post-dash key joins the path depends on the cursor's
+ *  descent:
+ *    - When the cursor's current target indent is GREATER than the post-dash
+ *      key's column, the descent passes through that key (e.g. cursor inside
+ *      `request.method` at indent 6, key `request` at column 4) → push it.
+ *    - When the cursor's current target indent EQUALS the post-dash key's
+ *      column, the post-dash key is a sibling at the list-item level
+ *      (e.g. cursor on `handler:` at indent 4, key `request:` at column 4) →
+ *      skip it; descend straight to the array's parent.
+ *
+ *  In both cases the next walk step targets `lineIndent` so the `routes:` /
+ *  `steps:` parent of the array is captured. The schema walker auto-descends
+ *  arrays, so no `[]` marker is appended. */
 export function buildYamlPath(lines, cursorLine, docStart, cursorIndent) {
     if (cursorIndent === 0)
         return [];
@@ -53,19 +75,35 @@ export function buildYamlPath(lines, cursorLine, docStart, cursorIndent) {
                 if (lineIndent === 0)
                     break;
             }
+            else if (trimmed.startsWith("- ")) {
+                const postDash = trimmed.slice(2);
+                const km = postDash.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+                const keyColumn = lineIndent + 2;
+                if (km && keyColumn < targetIndent) {
+                    path.unshift(km[1]);
+                }
+                targetIndent = lineIndent;
+            }
+            else if (trimmed === "-") {
+                targetIndent = lineIndent;
+            }
             else {
-                // Hit something we can't parse (e.g. a list item `- ...`); stop
+                // Hit something we can't parse; stop
                 break;
             }
         }
     }
     return path;
 }
-/** Extract sibling keys already present at `indent` within the doc bounds. */
-export function extractKeysAtIndent(lines, start, end, indent) {
+/** Extract sibling keys already present at `indent` within the doc bounds.
+ *  `skipLine` lets the caller exclude the cursor's own line so a key being
+ *  edited (`ver|sion:`) doesn't filter itself out of the suggestion list. */
+export function extractKeysAtIndent(lines, start, end, indent, skipLine) {
     const keys = new Set();
     const prefix = " ".repeat(indent);
     for (let i = start; i < end; i++) {
+        if (i === skipLine)
+            continue;
         const line = lines[i] ?? "";
         if (!line.startsWith(prefix))
             continue;
@@ -77,62 +115,207 @@ export function extractKeysAtIndent(lines, start, end, indent) {
     }
     return keys;
 }
-/** Navigate a JSON Schema hierarchy following `path`, auto-descending into array items. */
+/** Returns every schema branch reachable from `node` after peeling `anyOf` /
+ *  `oneOf` recursively. A branch with no combinators is its own only entry.
+ *  Used so an `x-telo-ref` slot like `{anyOf: [{type: string}, {type: object,
+ *  properties: …}]}` exposes the object branch's properties to completion. */
+function peelCombinators(node) {
+    const out = [];
+    const visit = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        const branches = [];
+        if (Array.isArray(n.anyOf))
+            branches.push(...n.anyOf);
+        if (Array.isArray(n.oneOf))
+            branches.push(...n.oneOf);
+        if (branches.length === 0) {
+            out.push(n);
+            return;
+        }
+        for (const b of branches)
+            visit(b);
+    };
+    visit(node);
+    return out;
+}
+/** Navigate a JSON Schema hierarchy following `path`, auto-descending into
+ *  array items and peeling `anyOf` / `oneOf` branches. When multiple peeled
+ *  branches define `properties`, returns a synthetic node whose `properties`
+ *  is the union (first-wins on key collision) and whose `required` is the
+ *  intersection — enough for propKeyCompletions to surface every key a value
+ *  at this slot can legally carry. */
 export function navigateSchema(schema, path) {
     let current = schema;
     for (const segment of path) {
-        // Auto-descend through arrays before looking up the next key
-        while (current.type === "array" && current.items) {
-            current = current.items;
+        const candidates = peelCombinators(current).flatMap((node) => {
+            const expanded = [];
+            let cur = node;
+            while (cur.type === "array" && cur.items)
+                cur = cur.items;
+            for (const peeled of peelCombinators(cur))
+                expanded.push(peeled);
+            return expanded;
+        });
+        let next;
+        for (const cand of candidates) {
+            const sub = cand.properties?.[segment];
+            if (sub) {
+                next = sub;
+                break;
+            }
         }
-        const props = current.properties;
-        if (!props?.[segment])
+        if (!next)
             return undefined;
-        current = props[segment];
+        current = next;
     }
     // Auto-descend through a trailing array at the leaf (e.g. cursor inside `mounts:` items)
     while (current.type === "array" && current.items) {
         current = current.items;
     }
-    return current;
+    const leaves = peelCombinators(current);
+    if (leaves.length === 1)
+        return leaves[0];
+    return unionLeaves(current, leaves);
 }
-/**
- * For blank lines (and lines with only whitespace), infer the intended indent
- * from context rather than relying on the cursor column, which is often 0
- * even when the cursor is semantically inside a nested block.
- *
- * Strategy: look at the previous non-empty line.
- *   - If it ends with `:` (bare object key, no value) → cursor is one level deeper.
- *   - Otherwise → cursor is a sibling of that key (same indent).
- */
-export function inferIndentForBlankLine(lines, cursorLine, docStart) {
-    for (let i = cursorLine - 1; i >= docStart; i--) {
-        const line = lines[i] ?? "";
-        if (line.trim() === "" || line.trim().startsWith("#"))
-            continue;
-        if (line.trimEnd() === "---")
-            break;
-        const lineIndent = line.length - line.trimStart().length;
-        if (line.trimEnd().endsWith(":")) {
-            return lineIndent + 2;
+/** Merge multiple peeled schema branches into one node for completion purposes.
+ *  Property maps are unioned (first branch wins on key collision). `required`
+ *  becomes the intersection so optional-in-any-branch keys still surface.
+ *  `x-telo-ref` from the unpeeled parent is preserved so ref-aware lookups
+ *  (`lookupRefConstraint`) still see the constraint when navigateSchema is
+ *  called on a property that places the annotation alongside `anyOf`/`oneOf`. */
+function unionLeaves(parent, leaves) {
+    const properties = {};
+    const requiredSets = [];
+    for (const leaf of leaves) {
+        const props = leaf.properties;
+        if (props) {
+            for (const [k, v] of Object.entries(props)) {
+                if (!(k in properties))
+                    properties[k] = v;
+            }
+        }
+        requiredSets.push(new Set(Array.isArray(leaf.required) ? leaf.required : []));
+    }
+    let required = [];
+    if (requiredSets.length > 0) {
+        required = [...requiredSets[0]].filter((k) => requiredSets.every((s) => s.has(k)));
+    }
+    const out = { type: "object", properties, required };
+    if (typeof parent["x-telo-ref"] === "string")
+        out["x-telo-ref"] = parent["x-telo-ref"];
+    return out;
+}
+/** Walks up and down from `cursorLine` looking for a sibling line at the
+ *  exact same indent whose key is `kind`. The value of the first such line
+ *  is returned (alias form, e.g. `"Sql.Connection"`). Used by ref-name
+ *  completion to discover what kind of resource the user is targeting in an
+ *  object-form ref. Walking stops at the first line with a strictly smaller
+ *  indent (that's the parent's structural boundary). */
+export function findSiblingKindValue(lines, docStart, docEnd, cursorLine, indent) {
+    const prefix = " ".repeat(indent);
+    const scan = (range) => {
+        for (const i of range) {
+            const line = lines[i] ?? "";
+            if (line.trim() === "" || line.trim().startsWith("#"))
+                continue;
+            if (line.trimEnd() === "---")
+                return undefined;
+            const lineIndent = line.length - line.trimStart().length;
+            if (lineIndent < indent)
+                return undefined; // parent boundary
+            if (lineIndent !== indent || !line.startsWith(prefix))
+                continue;
+            const m = line.slice(indent).match(/^kind:\s*(\S+)/);
+            if (m)
+                return m[1];
         }
-        return lineIndent;
+        return undefined;
+    };
+    // Forward then backward — order doesn't matter for correctness because
+    // any sibling kind value at this indent applies to the same object.
+    const after = [];
+    for (let i = cursorLine + 1; i < docEnd; i++)
+        after.push(i);
+    const before = [];
+    for (let i = cursorLine - 1; i >= docStart; i--)
+        before.push(i);
+    return scan(after) ?? scan(before);
+}
+/** Looks up the `x-telo-ref` string carried by the schema node at `yamlPath`
+ *  inside `definitionSchema`. Checks both the property node directly and its
+ *  peeled `anyOf` / `oneOf` branches, since some library schemas place the
+ *  annotation at the property level and others inside a branch. Returns
+ *  `undefined` when the path doesn't resolve or no ref constraint is declared. */
+export function lookupRefConstraint(definitionSchema, yamlPath) {
+    const node = navigateSchema(definitionSchema, yamlPath);
+    if (!node)
+        return undefined;
+    if (typeof node["x-telo-ref"] === "string")
+        return node["x-telo-ref"];
+    for (const branch of peelCombinators(node)) {
+        if (typeof branch["x-telo-ref"] === "string")
+            return branch["x-telo-ref"];
     }
-    return 0;
+    return undefined;
 }
 export function detectContext(text, line, character) {
     const lines = text.split("\n");
     const currentLine = lines[line] ?? "";
-    // Kind value completion: `kind: ` or `kind: SomePrefix`
-    if (/^kind:\s*\S*$/.test(currentLine)) {
-        return { type: "kind" };
-    }
     const { start, end } = findDocBounds(lines, line);
     const docKind = extractKindFromDoc(lines, start, end);
+    // Kind value completion fires ONLY when the cursor sits past the `:` of a
+    // `kind:` line. With the cursor on the key portion (start, middle, or right
+    // before the colon) we fall through to prop-key completion so `kind` itself
+    // can be suggested. Matches both top-level (`kind: …`) and indented forms;
+    // indented form also surfaces the enclosing ref slot for filtering.
+    const kindLineMatch = currentLine.match(/^(\s*)kind:(\s*)(\S*)$/);
+    if (kindLineMatch) {
+        const indent = kindLineMatch[1].length;
+        const valueStart = indent + "kind:".length + kindLineMatch[2].length;
+        if (character >= valueStart) {
+            if (indent === 0)
+                return { type: "kind", valueStartColumn: valueStart };
+            if (docKind) {
+                const yamlPath = buildYamlPath(lines, line, start, indent);
+                return { type: "kind", docKind, yamlPath, valueStartColumn: valueStart };
+            }
+        }
+        // Cursor is on the key portion — fall through to prop-key handling.
+    }
     // Capability value completion: only inside Telo.Definition docs
     if (/^capability:\s*\S*$/.test(currentLine) && docKind === "Telo.Definition") {
         return { type: "capability" };
     }
+    // Ref-name value completion: cursor on the value of a `name:` line inside
+    // an object-form ref (sibling `kind:` declares which resource kind we're
+    // referencing). The enclosing parent slot's schema carries the ref
+    // constraint, but we don't need to consult it here — `buildCompletions`
+    // will fall back to filtering by `refKind` regardless of the schema. Doing
+    // so keeps editor autocomplete working even when the registry hasn't fully
+    // resolved the resource's definition.
+    const nameLineMatch = currentLine.match(/^(\s+)name:(\s*)(\S*)$/);
+    if (nameLineMatch && docKind) {
+        const indent = nameLineMatch[1].length;
+        const valueStart = indent + "name:".length + nameLineMatch[2].length;
+        const valuePrefix = nameLineMatch[3];
+        if (character >= valueStart) {
+            const yamlPath = buildYamlPath(lines, line, start, indent);
+            // The yamlPath built here points at the parent slot — for
+            // `connection: { kind: …, name: | }` the path is `["connection"]`.
+            // The sibling `kind:` lives at the same indent as our `name:`, so we
+            // scan the doc bounds for it.
+            const refKind = findSiblingKindValue(lines, start, end, line, indent);
+            return {
+                type: "ref-name",
+                docKind,
+                yamlPath,
+                refKind,
+                prefix: valuePrefix,
+                valueStartColumn: valueStart,
+            };
+        }
+    }
     if (!docKind)
         return undefined;
     // Field-value completion: `source: <prefix>` on a top-level Telo.Import field.
@@ -149,19 +332,42 @@ export function detectContext(text, line, character) {
         }
     }
     const trimmed = currentLine.trim();
-    // Only trigger when the line looks like a key being typed (or is blank)
-    const isKeyLine = trimmed === "" || /^[a-zA-Z_][a-zA-Z0-9_]*:?$/.test(trimmed);
+    // Trigger when the cursor is on the KEY portion of the line. Three cases:
+    //   1. Blank line / whitespace only — `existingKeys` skip means the user is
+    //      starting a fresh key.
+    //   2. Line has no `:` yet (e.g. `vers`, `version`) — partial key being typed.
+    //   3. Line has `key: value` and the cursor is at or before the colon.
+    //      The line text is preserved so `version|: 1.0.0` keeps suggesting keys
+    //      while `version: |1.0.0` falls through to no completion.
+    const colonIdx = currentLine.indexOf(":");
+    const beforeColon = colonIdx === -1 ? currentLine : currentLine.slice(0, colonIdx);
+    const isKeyLine = trimmed === "" ||
+        (colonIdx === -1 && /^\s*[a-zA-Z_][a-zA-Z0-9_]*$/.test(currentLine)) ||
+        (colonIdx !== -1 &&
+            character <= colonIdx &&
+            /^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*$/.test(beforeColon));
     if (!isKeyLine)
         return undefined;
+    // Indent resolution: for a whitespace-only line the cursor's column tells
+    // us exactly where the user is about to type — VS Code parks the cursor at
+    // the new auto-indent after Enter, and any deviation (backspace to col 0,
+    // type extra spaces) is intentional. Trusting `character` also lets the
+    // user reach root level (col 0) on a trailing blank line even when the
+    // previous non-blank line was nested.
     const indent = trimmed === ""
-        ? inferIndentForBlankLine(lines, line, start)
+        ? character
         : currentLine.length - currentLine.trimStart().length;
     if (indent === 0) {
-        return { type: "prop-key", docKind, yamlPath: [], existingKeys: extractRootKeys(lines, start, end) };
+        return {
+            type: "prop-key",
+            docKind,
+            yamlPath: [],
+            existingKeys: extractRootKeys(lines, start, end, line),
+        };
     }
     const yamlPath = buildYamlPath(lines, line, start, indent);
     if (yamlPath.length === 0)
         return undefined; // couldn't resolve parent — bail
-    const existingKeys = extractKeysAtIndent(lines, start, end, indent);
+    const existingKeys = extractKeysAtIndent(lines, start, end, indent, line);
     return { type: "prop-key", docKind, yamlPath, existingKeys };
 }

package/dist/completions/prop-keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prop-keys.d.ts","sourceRoot":"","sources":["../../src/completions/prop-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,gBAAgB,EAAE,CA+CpB"}
+{"version":3,"file":"prop-keys.d.ts","sourceRoot":"","sources":["../../src/completions/prop-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAiBpD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,gBAAgB,EAAE,CAkCpB"}

package/dist/completions/prop-keys.js

@@ -1,22 +1,50 @@
 import { navigateSchema } from "./detect-context.js";
+/** Kernel-implicit fields. Every Telo resource declares its `kind` and a
+ *  `metadata` object; the analyzer's schema validator injects them when
+ *  the definition uses `additionalProperties: false`. Completion has the
+ *  same need — domain-specific schemas (`Http.Api`, `Sql.Query`, …) don't
+ *  enumerate these in their own `properties`, so without an explicit fallback
+ *  the user can't autocomplete `kind:` or `metadata:` on those resources. */
+const ROOT_IMPLICIT_PROPS = {
+    kind: { type: "string", description: "The fully-qualified resource kind." },
+    metadata: {
+        type: "object",
+        description: "Resource metadata (name, namespace, version).",
+    },
+};
 export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
     if (!registry)
         return [];
     const definition = registry.resolveDefinition(kind);
-    if (!definition?.schema)
+    if (!definition?.schema) {
+        // Unknown kind (often: an unloaded import). At root level, still surface
+        // the universal `kind` / `metadata` keys so completion isn't dead when
+        // the registry hasn't resolved the resource type yet.
+        if (yamlPath.length === 0) {
+            return buildItems(ROOT_IMPLICIT_PROPS, existingKeys, new Set());
+        }
         return [];
+    }
     const targetSchema = yamlPath.length === 0
         ? definition.schema
         : navigateSchema(definition.schema, yamlPath);
-    if (!targetSchema?.properties)
+    if (!targetSchema?.properties) {
+        if (yamlPath.length === 0) {
+            return buildItems(ROOT_IMPLICIT_PROPS, existingKeys, new Set());
+        }
         return [];
+    }
     const required = new Set(Array.isArray(targetSchema.required) ? targetSchema.required : []);
+    const properties = yamlPath.length === 0
+        ? { ...ROOT_IMPLICIT_PROPS, ...targetSchema.properties }
+        : targetSchema.properties;
+    return buildItems(properties, existingKeys, required);
+}
+function buildItems(properties, existingKeys, required) {
     const items = [];
-    for (const [prop, propSchema] of Object.entries(targetSchema.properties)) {
+    for (const [prop, propSchema] of Object.entries(properties)) {
         if (existingKeys.has(prop))
             continue;
-        if (yamlPath.length === 0 && (prop === "kind" || prop === "metadata"))
-            continue;
         const item = {
             label: prop,
             kind: "property",

package/dist/diagnostics/range-resolver.d.ts

@@ -3,8 +3,14 @@ import type { DiagnosticContext } from "../types.js";
 /** Falls back through the chain from the VS Code extension's inline resolver
  *  (ide/vscode/src/extension.ts:203-216 before this package existed):
  *    1. `d.range` if present.
- *    2. `positionIndex.get(d.data.path)` when both are available.
- *    3. Whole-line span at `sourceLine` when known.
- *    4. `(0,0)-(0,0)` as a last resort. Never undefined. */
+ *    2. `positionIndex.get(d.data.path)` for a direct hit (covers diagnostics
+ *       that target an existing value, e.g. wrong type, enum violation).
+ *    3. If the leaf is missing (e.g. "missing required property" — `.type`
+ *       isn't in the YAML yet), walk one segment up at a time and squiggle
+ *       just the parent's key identifier (`@key:<parent>`), not the parent's
+ *       full value block. Keeps the squiggle scoped to the incomplete entry
+ *       instead of spreading across every line of the surrounding map.
+ *    4. Whole-line span at `sourceLine` when known.
+ *    5. `(0,0)-(0,0)` as a last resort. Never undefined. */
 export declare function resolveRange(d: AnalysisDiagnostic, ctx: DiagnosticContext): Range;
 //# sourceMappingURL=range-resolver.d.ts.map

package/dist/diagnostics/range-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"range-resolver.d.ts","sourceRoot":"","sources":["../../src/diagnostics/range-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD;;;;;4DAK4D;AAC5D,wBAAgB,YAAY,CAAC,CAAC,EAAE,kBAAkB,EAAE,GAAG,EAAE,iBAAiB,GAAG,KAAK,CAiBjF"}
+{"version":3,"file":"range-resolver.d.ts","sourceRoot":"","sources":["../../src/diagnostics/range-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD;;;;;;;;;;;4DAW4D;AAC5D,wBAAgB,YAAY,CAAC,CAAC,EAAE,kBAAkB,EAAE,GAAG,EAAE,iBAAiB,GAAG,KAAK,CAuBjF"}

package/dist/diagnostics/range-resolver.js

@@ -5,17 +5,31 @@ const ZERO_RANGE = {
 /** Falls back through the chain from the VS Code extension's inline resolver
  *  (ide/vscode/src/extension.ts:203-216 before this package existed):
  *    1. `d.range` if present.
- *    2. `positionIndex.get(d.data.path)` when both are available.
- *    3. Whole-line span at `sourceLine` when known.
- *    4. `(0,0)-(0,0)` as a last resort. Never undefined. */
+ *    2. `positionIndex.get(d.data.path)` for a direct hit (covers diagnostics
+ *       that target an existing value, e.g. wrong type, enum violation).
+ *    3. If the leaf is missing (e.g. "missing required property" — `.type`
+ *       isn't in the YAML yet), walk one segment up at a time and squiggle
+ *       just the parent's key identifier (`@key:<parent>`), not the parent's
+ *       full value block. Keeps the squiggle scoped to the incomplete entry
+ *       instead of spreading across every line of the surrounding map.
+ *    4. Whole-line span at `sourceLine` when known.
+ *    5. `(0,0)-(0,0)` as a last resort. Never undefined. */
 export function resolveRange(d, ctx) {
     if (d.range)
         return d.range;
     const fieldPath = d.data?.path;
     if (fieldPath !== undefined && ctx.positionIndex) {
-        const fieldRange = ctx.positionIndex.get(fieldPath);
-        if (fieldRange)
-            return fieldRange;
+        const direct = ctx.positionIndex.get(fieldPath);
+        if (direct)
+            return direct;
+        for (const parent of parentPaths(fieldPath).slice(1)) {
+            const keyRange = ctx.positionIndex.get(`@key:${parent}`);
+            if (keyRange)
+                return keyRange;
+            const valueRange = ctx.positionIndex.get(parent);
+            if (valueRange)
+                return valueRange;
+        }
     }
     if (ctx.sourceLine !== undefined) {
         return {
@@ -25,3 +39,22 @@ export function resolveRange(d, ctx) {
     }
     return ZERO_RANGE;
 }
+/** Yield `path`, then progressively shorter parents formed by stripping
+ *  trailing dotted segments and array index suffixes. For
+ *  `"secrets.openaiApiKey.type"` → `["secrets.openaiApiKey.type",
+ *  "secrets.openaiApiKey", "secrets"]`. For `"routes[0].handler"` →
+ *  `["routes[0].handler", "routes[0]", "routes"]`. */
+function parentPaths(path) {
+    const out = [];
+    let cur = path;
+    while (cur.length > 0) {
+        out.push(cur);
+        const lastDot = cur.lastIndexOf(".");
+        const lastBracket = cur.lastIndexOf("[");
+        const cut = Math.max(lastDot, lastBracket);
+        if (cut <= 0)
+            break;
+        cur = cur.slice(0, cut);
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/ide-support",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "description": "Editor-host-agnostic IDE support (completions, diagnostic normalization) for Telo manifests.",
   "keywords": [
     "telo",
@@ -36,13 +36,16 @@
     "src/**"
   ],
   "dependencies": {
-    "@telorun/analyzer": "0.10.1"
+    "@telorun/analyzer": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.lib.json"
+    "build": "tsc -p tsconfig.lib.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }