@telorun/ide-support 0.6.0 → 0.7.0

package/dist/completions/build.d.ts

@@ -1,4 +1,4 @@
-import type { AnalysisRegistry } from "@telorun/analyzer";
+import { type AnalysisRegistry, type AstDocument } from "@telorun/analyzer";
 import type { CompletionResult, IdeEnvironmentAdapter } from "../types.js";
-export declare function buildCompletions(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, adapter?: IdeEnvironmentAdapter): Promise<CompletionResult[]>;
+export declare function buildCompletions(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, adapter?: IdeEnvironmentAdapter, docs?: AstDocument[]): Promise<CompletionResult[]>;
 //# sourceMappingURL=build.d.ts.map

package/dist/completions/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/completions/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAsK3E,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA2B7B"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/completions/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,gBAAgB,EAAE,KAAK,WAAW,EAAe,MAAM,mBAAmB,CAAC;AACrG,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAuI3E,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAyB7B"}

package/dist/completions/build.js

@@ -1,55 +1,32 @@
+import { parseToAst } from "@telorun/analyzer";
 import { detectContext, lookupRefConstraint } from "./detect-context.js";
 import { importSourceCompletions } from "./import-source.js";
 import { propKeyCompletions } from "./prop-keys.js";
 import { CAPABILITY_VALUES } from "./valid-capabilities.js";
-/** Roughly extract `(kind, metadata.name)` pairs from a multi-doc YAML text.
- *  This is intentionally lightweight: it scans for top-level `kind:` and the
- *  first `name:` under a `metadata:` block per `---`-separated section, with
- *  no full YAML parse. The output is consumed only for completion ranking,
- *  so misses on edge-case manifests are acceptable; the analyzer remains
- *  the source of truth for validation. */
-function extractInFileResources(text) {
+/** Read the top-level `kind` and `metadata.name` scalar of each document from
+ *  the AST. Consumed only for ref-name completion ranking, so a doc missing
+ *  either is simply skipped; the analyzer remains the source of truth. */
+function extractInFileResources(docs) {
     const out = [];
-    const lines = text.split("\n");
-    let currentKind;
-    let currentName;
-    let inMetadata = false;
-    const flush = () => {
-        if (currentKind && currentName) {
-            out.push({ kind: currentKind, name: currentName });
-        }
-        currentKind = undefined;
-        currentName = undefined;
-        inMetadata = false;
-    };
-    for (const line of lines) {
-        if (line.trimEnd() === "---") {
-            flush();
-            continue;
-        }
-        const kindMatch = line.match(/^kind:\s*(\S+)/);
-        if (kindMatch) {
-            currentKind = kindMatch[1];
+    const scalar = (node) => node?.kind === "scalar" && typeof node.value === "string" ? node.value : undefined;
+    for (const doc of docs) {
+        if (doc.root?.kind !== "map")
             continue;
-        }
-        if (/^metadata:\s*$/.test(line)) {
-            inMetadata = true;
-            continue;
-        }
-        if (inMetadata) {
-            // Lines inside metadata are indented. Pick the first `name:` we see.
-            const nameMatch = line.match(/^\s+name:\s*(\S+)/);
-            if (nameMatch && !currentName) {
-                currentName = nameMatch[1];
-            }
-            // Leaving the metadata block — any line that is not indented marks
-            // the end of the block.
-            if (line.length > 0 && !/^\s/.test(line)) {
-                inMetadata = false;
+        let kind;
+        let name;
+        for (const pair of doc.root.entries) {
+            const key = scalar(pair.key);
+            if (key === "kind")
+                kind = scalar(pair.value);
+            else if (key === "metadata" && pair.value?.kind === "map") {
+                const meta = pair.value;
+                const nameEntry = meta.entries.find((e) => scalar(e.key) === "name");
+                name = scalar(nameEntry?.value);
             }
         }
+        if (kind && name)
+            out.push({ kind, name });
     }
-    flush();
     return out;
 }
 /** Returns the resource records whose kind satisfies the slot. When the
@@ -59,8 +36,8 @@ function extractInFileResources(text) {
  *  kind match. Falls back to listing every in-file resource so the
  *  user still sees something rather than nothing when the registry
  *  doesn't recognize the kind yet. */
-function refNameCompletions(text, refKind, refConstraint, registry, valueStartColumn) {
-    const resources = extractInFileResources(text);
+function refNameCompletions(docs, refKind, refConstraint, registry, replaceRange) {
+    const resources = extractInFileResources(docs);
     let acceptable;
     if (refKind) {
         acceptable = new Set([refKind]);
@@ -82,10 +59,9 @@ function refNameCompletions(text, refKind, refConstraint, registry, valueStartCo
             label: r.name,
             kind: "value",
             detail: r.kind,
-            // Anchor the replace range to the value's start column so names with
-            // `.`, `-`, or `/` (legal in resource names) replace the whole typed
-            // prefix instead of the trailing word VS Code would pick by default.
-            replaceFromColumn: valueStartColumn,
+            // Replace the whole existing value so names with `.`, `-`, or `/` (legal
+            // in resource names) overwrite cleanly instead of the trailing word.
+            replaceRange,
         });
     }
     return out;
@@ -103,7 +79,7 @@ function refConstrainedKinds(registry, parentDocKind, parentYamlPath) {
         return undefined;
     return registry.userFacingKindsForRef(refString);
 }
-function kindCompletions(registry, docKind, yamlPath, valueStartColumn) {
+function kindCompletions(registry, docKind, yamlPath, replaceRange) {
     let kinds;
     if (registry && docKind && yamlPath && yamlPath.length > 0) {
         const filtered = refConstrainedKinds(registry, docKind, yamlPath);
@@ -121,15 +97,10 @@ function kindCompletions(registry, docKind, yamlPath, valueStartColumn) {
         if (seen.has(kind))
             continue;
         seen.add(kind);
-        const item = { label: kind, kind: "class", detail: "Telo resource kind" };
-        // Anchor the replace range to the value's start column so kinds with `.`
-        // (e.g. `Sql.Connection`) cleanly overwrite the existing prefix. Without
-        // this, VS Code's default word boundary stops at the last `.` and a pick
-        // of `Sql.Connection` while the buffer reads `Sql.Co|` becomes
-        // `Sql.Sql.Connection`.
-        if (valueStartColumn !== undefined)
-            item.replaceFromColumn = valueStartColumn;
-        results.push(item);
+        // Replace the whole existing kind scalar so a pick of `Sql.Connection`
+        // over `Sql.Co|nnection` leaves no `nnection` suffix and no `Sql.` prefix
+        // duplication (VS Code's default word range stops at the last `.`).
+        results.push({ label: kind, kind: "class", detail: "Telo resource kind", replaceRange });
     }
     return results;
 }
@@ -140,12 +111,16 @@ function capabilityCompletions() {
         detail: "Telo capability",
     }));
 }
-export async function buildCompletions(text, line, character, registry, adapter) {
-    const ctx = detectContext(text, line, character);
+export async function buildCompletions(text, line, character, registry, adapter, docs) {
+    // Reuse the host's already-parsed AST when it matches the current buffer;
+    // otherwise parse once here (Part 1 stands alone). Both `detectContext` and
+    // ref-name in-file resource extraction share this single parse.
+    const astDocs = docs ?? parseToAst(text);
+    const ctx = detectContext(text, line, character, astDocs);
     if (!ctx)
         return [];
     if (ctx.type === "kind") {
-        return kindCompletions(registry, ctx.docKind, ctx.yamlPath, ctx.valueStartColumn);
+        return kindCompletions(registry, ctx.docKind, ctx.yamlPath, ctx.replaceRange);
     }
     if (ctx.type === "capability")
         return capabilityCompletions();
@@ -154,11 +129,11 @@ export async function buildCompletions(text, line, character, registry, adapter)
         const refConstraint = definition?.schema
             ? lookupRefConstraint(definition.schema, ctx.yamlPath)
             : undefined;
-        return refNameCompletions(text, ctx.refKind, refConstraint, registry, ctx.valueStartColumn);
+        return refNameCompletions(astDocs, ctx.refKind, refConstraint, registry, ctx.replaceRange);
     }
     if (ctx.type === "field-value") {
         if (ctx.field === "import-source") {
-            return importSourceCompletions(ctx.prefix, ctx.valueStartColumn, adapter);
+            return importSourceCompletions(ctx.prefix, ctx.replaceRange, adapter);
         }
         return [];
     }

package/dist/completions/detect-context.d.ts

@@ -1,3 +1,6 @@
+import { type AstDocument } from "@telorun/analyzer";
+import type { ReplaceRange } from "../types.js";
+export type { ReplaceRange };
 export type CompletionCtx = {
     type: "kind";
     /** Set for indented `kind:` lines. The enclosing docKind + the YAML
@@ -6,12 +9,10 @@ export type CompletionCtx = {
      *  Absent for top-level `kind:` — there, no constraint applies. */
     docKind?: string;
     yamlPath?: string[];
-    /** Column where the kind value begins (after `kind:` + whitespace).
-     *  Editor hosts use this to anchor the replace range so completions
-     *  cleanly overwrite a kind that contains `.` (e.g. `Sql.Co|` →
-     *  selecting `Sql.Connection` must replace `Sql.Co`, not just `Co`,
-     *  which VS Code's default word range would). */
-    valueStartColumn: number;
+    /** Full source range of the kind value, so a pick overwrites the whole
+     *  existing scalar (e.g. `Sql.Co|nnection` + `Sql.Connection` → no
+     *  suffix left behind). */
+    replaceRange: ReplaceRange;
 } | {
     type: "capability";
 } | {
@@ -32,48 +33,16 @@ export type CompletionCtx = {
     /** The kind value of the sibling `kind:` line, if present. */
     refKind?: string;
     prefix: string;
-    valueStartColumn: number;
+    replaceRange: ReplaceRange;
 } | {
     type: "field-value";
     docKind: string;
     field: string;
     /** Text from the start of the value to the cursor. */
     prefix: string;
-    /** 0-based column where the value starts (right after `<field>:` + whitespace). */
-    valueStartColumn: number;
+    /** Full source range of the value being completed. */
+    replaceRange: ReplaceRange;
 };
-export declare function findDocBounds(lines: string[], cursorLine: number): {
-    start: number;
-    end: number;
-};
-export declare function extractKindFromDoc(lines: string[], start: number, end: number): string | undefined;
-/** 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 declare function extractRootKeys(lines: string[], start: number, end: number, skipLine?: number): Set<string>;
-/** 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 declare function buildYamlPath(lines: string[], cursorLine: number, docStart: number, cursorIndent: number): string[];
-/** 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 declare function extractKeysAtIndent(lines: string[], start: number, end: number, indent: number, skipLine?: number): Set<string>;
 /** 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`
@@ -87,12 +56,16 @@ export declare function navigateSchema(schema: Record<string, any>, path: string
  *  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 declare function findSiblingKindValue(lines: string[], docStart: number, docEnd: number, cursorLine: number, indent: number): string | undefined;
 /** 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 declare function lookupRefConstraint(definitionSchema: Record<string, any>, yamlPath: string[]): string | undefined;
-export declare function detectContext(text: string, line: number, character: number): CompletionCtx | undefined;
+/** Derive a `CompletionCtx` from the AST-resolved cursor (Approach B). The
+ *  structural resolution lives in `resolveNodeAtPosition`; this only maps a
+ *  resolved slot onto the completion the editor should offer. `docs` lets a
+ *  host thread its already-parsed AST; without it we parse locally so this
+ *  stands alone. */
+export declare function detectContext(text: string, line: number, character: number, docs?: AstDocument[]): CompletionCtx | undefined;
 //# sourceMappingURL=detect-context.d.ts.map

package/dist/completions/detect-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect-context.d.ts","sourceRoot":"","sources":["../../src/completions/detect-context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"detect-context.d.ts","sourceRoot":"","sources":["../../src/completions/detect-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,YAAY,EAAE,YAAY,EAAE,CAAC;AAE7B,MAAM,MAAM,aAAa,GACrB;IACE,IAAI,EAAE,MAAM,CAAC;IACb;;;uEAGmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;+BAE2B;IAC3B,YAAY,EAAE,YAAY,CAAC;CAC5B,GACD;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,GACpF;IACE;;;gDAG4C;IAC5C,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB;6DACyD;IACzD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAuBN;;;;;sCAKsC;AACtC,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,EAAE,MAAM,EAAE,GACb,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA4BjC;AAoCD;;;;;wDAKwD;AACxD;;;;kFAIkF;AAClF,wBAAgB,mBAAmB,CACjC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,QAAQ,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAQpB;AAED;;;;oBAIoB;AACpB,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,aAAa,GAAG,SAAS,CAsE3B"}

package/dist/completions/detect-context.js

@@ -1,120 +1,5 @@
-export function findDocBounds(lines, cursorLine) {
-    let start = 0;
-    for (let i = cursorLine; i >= 0; i--) {
-        if (lines[i]?.trimEnd() === "---") {
-            start = i + 1;
-            break;
-        }
-    }
-    let end = lines.length;
-    for (let i = cursorLine + 1; i < lines.length; i++) {
-        if (lines[i]?.trimEnd() === "---") {
-            end = i;
-            break;
-        }
-    }
-    return { start, end };
-}
-export function extractKindFromDoc(lines, start, end) {
-    for (let i = start; i < end; i++) {
-        const m = lines[i]?.match(/^kind:\s*(\S+)/);
-        if (m)
-            return m[1];
-    }
-    return undefined;
-}
-/** 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.
- *
- *  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 [];
-    const path = [];
-    let targetIndent = cursorIndent;
-    for (let i = cursorLine - 1; i >= docStart; i--) {
-        const line = lines[i] ?? "";
-        const trimmed = line.trimStart();
-        if (trimmed === "" || trimmed.startsWith("#"))
-            continue;
-        const lineIndent = line.length - trimmed.length;
-        if (lineIndent < targetIndent) {
-            // Match a plain object key (not a list item marker)
-            const m = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
-            if (m) {
-                path.unshift(m[1]);
-                targetIndent = lineIndent;
-                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; stop
-                break;
-            }
-        }
-    }
-    return path;
-}
-/** 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;
-        const rest = line.slice(indent);
-        const m = rest.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
-        if (m && line.length - line.trimStart().length === indent) {
-            keys.add(m[1]);
-        }
-    }
-    return keys;
-}
+import { parseToAst } from "@telorun/analyzer";
+import { resolveNodeAtPosition } from "./resolve-node.js";
 /** 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,
@@ -212,36 +97,6 @@ function unionLeaves(parent, leaves) {
  *  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 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
@@ -259,129 +114,75 @@ export function lookupRefConstraint(definitionSchema, yamlPath) {
     }
     return undefined;
 }
-export function detectContext(text, line, character) {
-    const lines = text.split("\n");
-    const currentLine = lines[line] ?? "";
-    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 };
-            }
+/** Derive a `CompletionCtx` from the AST-resolved cursor (Approach B). The
+ *  structural resolution lives in `resolveNodeAtPosition`; this only maps a
+ *  resolved slot onto the completion the editor should offer. `docs` lets a
+ *  host thread its already-parsed AST; without it we parse locally so this
+ *  stands alone. */
+export function detectContext(text, line, character, docs) {
+    const resolved = resolveNodeAtPosition(text, docs ?? parseToAst(text), line, character);
+    if (!resolved)
+        return undefined;
+    const { docKind } = resolved;
+    if (resolved.slot === "value") {
+        // Inside a CEL body — structural completion does not apply (a future
+        // CEL-completion feature consumes `resolved.cel`).
+        if (resolved.cel)
+            return undefined;
+        const replaceRange = resolved.replaceRange;
+        if (!replaceRange)
+            return undefined;
+        const key = resolved.path[resolved.path.length - 1];
+        const parentPath = resolved.path.slice(0, -1);
+        const prefix = resolved.prefix ?? "";
+        if (key === "kind") {
+            if (parentPath.length === 0)
+                return { type: "kind", replaceRange };
+            if (docKind)
+                return { type: "kind", docKind, yamlPath: parentPath, replaceRange };
+            return undefined;
         }
-        // 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);
+        if (key === "capability" && docKind === "Telo.Definition") {
+            return { type: "capability" };
+        }
+        // Any `name:` value is a candidate ref target; the sibling `kind:` (when
+        // present) narrows the in-file resource list. Harmless on `metadata.name`,
+        // where no ref constraint resolves and the list is the fallback.
+        if (key === "name" && docKind) {
             return {
                 type: "ref-name",
                 docKind,
-                yamlPath,
-                refKind,
-                prefix: valuePrefix,
-                valueStartColumn: valueStart,
+                yamlPath: parentPath,
+                refKind: resolved.siblingKind,
+                prefix,
+                replaceRange,
             };
         }
-    }
-    if (!docKind)
-        return undefined;
-    // Import-source value completion: entries in the `imports:` map on a module
-    // doc. Two shapes are completed against filesystem paths / registry ids:
-    //   scalar shorthand  `  Alias: <src>`     → the entry value IS the source
-    //   object form       `    source: <src>`  → the `source:` under `imports.<Alias>`
-    // Gated on the enclosing path resolving to the `imports:` map so unrelated
-    // `source:` fields (e.g. `Assert.Manifest.source`) never trigger it.
-    if (docKind === "Telo.Application" || docKind === "Telo.Library") {
-        // Require a space after the colon (`key: …`) so a bare object-form header —
-        // `  Tiny:` about to carry a nested `source:`/`variables:` — is treated as a
-        // key position, not an import-source value. A flow-map (`Alias: { … }`) never
-        // matches: `\S*` can't span the spaces inside the braces.
-        const entryMatch = currentLine.match(/^(\s+)([A-Za-z_][\w-]*):(\s+)(\S*)$/);
-        if (entryMatch) {
-            const indent = entryMatch[1].length;
-            const key = entryMatch[2];
-            const valueStartColumn = indent + key.length + 1 + entryMatch[3].length;
-            if (character >= valueStartColumn) {
-                const parentPath = buildYamlPath(lines, line, start, indent);
-                const isScalarEntry = parentPath.length === 1 && parentPath[0] === "imports";
-                const isObjectSource = key === "source" && parentPath.length === 2 && parentPath[0] === "imports";
-                if (isScalarEntry || isObjectSource) {
-                    const prefix = currentLine.slice(valueStartColumn, character);
-                    return { type: "field-value", docKind, field: "import-source", prefix, valueStartColumn };
-                }
+        // Import-source: the scalar shorthand `imports.<Alias>` or the object-form
+        // `imports.<Alias>.source`. `spaceAfterColon` distinguishes `Console: ` (a
+        // value) from a bare `Tiny:` header about to carry a nested `source:`.
+        if ((docKind === "Telo.Application" || docKind === "Telo.Library") &&
+            resolved.spaceAfterColon) {
+            const isScalarEntry = parentPath.length === 1 && parentPath[0] === "imports";
+            const isObjectSource = key === "source" && parentPath.length === 2 && parentPath[0] === "imports";
+            if (isScalarEntry || isObjectSource) {
+                return { type: "field-value", docKind, field: "import-source", prefix, replaceRange };
             }
         }
-    }
-    const trimmed = currentLine.trim();
-    // 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 === ""
-        ? character
-        : currentLine.length - currentLine.trimStart().length;
-    if (indent === 0) {
-        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, line);
-    return { type: "prop-key", docKind, yamlPath, existingKeys };
+    // Key position (existing key, blank line, or trailing indent). Complete
+    // against the nearest enclosing inline resource's schema (or the root
+    // resource), with the path made relative to it — so a prop key inside
+    // `mount: { kind: Crud.Resource, … }` offers Crud.Resource's fields, not the
+    // outer ref slot's.
+    const scopeKind = resolved.resourceKind ?? docKind;
+    if (!scopeKind)
+        return undefined;
+    return {
+        type: "prop-key",
+        docKind: scopeKind,
+        yamlPath: resolved.path.slice(resolved.resourceDepth ?? 0),
+        existingKeys: resolved.existingKeys ?? new Set(),
+    };
 }