@telorun/ide-support 0.5.0 → 0.7.0

package/src/completions/build.ts

@@ -1,5 +1,6 @@
-import type { AnalysisRegistry } from "@telorun/analyzer";
+import { parseToAst, type AnalysisRegistry, type AstDocument, type AstMap } from "@telorun/analyzer";
 import type { CompletionResult, IdeEnvironmentAdapter } from "../types.js";
+import type { ReplaceRange } from "./detect-context.js";
 import { detectContext, lookupRefConstraint } from "./detect-context.js";
 import { importSourceCompletions } from "./import-source.js";
 import { propKeyCompletions } from "./prop-keys.js";
@@ -10,56 +11,29 @@ interface ResourceRecord {
   name: string;
 }
 
-/** 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: string): ResourceRecord[] {
+/** 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: AstDocument[]): ResourceRecord[] {
   const out: ResourceRecord[] = [];
-  const lines = text.split("\n");
-  let currentKind: string | undefined;
-  let currentName: string | undefined;
-  let inMetadata = false;
+  const scalar = (node: { kind: string; value?: unknown } | undefined): string | undefined =>
+    node?.kind === "scalar" && typeof node.value === "string" ? node.value : undefined;
 
-  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];
-      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;
+  for (const doc of docs) {
+    if (doc.root?.kind !== "map") continue;
+    let kind: string | undefined;
+    let name: string | undefined;
+    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 as AstMap;
+        const nameEntry = meta.entries.find((e) => scalar(e.key) === "name");
+        name = scalar(nameEntry?.value);
       }
     }
+    if (kind && name) out.push({ kind, name });
   }
-  flush();
   return out;
 }
 
@@ -71,13 +45,13 @@ function extractInFileResources(text: string): ResourceRecord[] {
  *  user still sees something rather than nothing when the registry
  *  doesn't recognize the kind yet. */
 function refNameCompletions(
-  text: string,
+  docs: AstDocument[],
   refKind: string | undefined,
   refConstraint: string | undefined,
   registry: AnalysisRegistry | undefined,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
 ): CompletionResult[] {
-  const resources = extractInFileResources(text);
+  const resources = extractInFileResources(docs);
   let acceptable: Set<string> | undefined;
 
   if (refKind) {
@@ -97,10 +71,9 @@ function refNameCompletions(
       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;
@@ -129,7 +102,7 @@ function kindCompletions(
   registry: AnalysisRegistry | undefined,
   docKind: string | undefined,
   yamlPath: string[] | undefined,
-  valueStartColumn: number | undefined,
+  replaceRange: ReplaceRange,
 ): CompletionResult[] {
   let kinds: Iterable<string>;
   if (registry && docKind && yamlPath && yamlPath.length > 0) {
@@ -145,14 +118,10 @@ function kindCompletions(
   for (const kind of kinds) {
     if (seen.has(kind)) continue;
     seen.add(kind);
-    const item: CompletionResult = { 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;
 }
@@ -171,11 +140,16 @@ export async function buildCompletions(
   character: number,
   registry: AnalysisRegistry | undefined,
   adapter?: IdeEnvironmentAdapter,
+  docs?: AstDocument[],
 ): Promise<CompletionResult[]> {
-  const ctx = detectContext(text, line, character);
+  // 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();
   if (ctx.type === "ref-name") {
@@ -183,17 +157,11 @@ export async function buildCompletions(
     const refConstraint = definition?.schema
       ? lookupRefConstraint(definition.schema as Record<string, any>, 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/src/completions/detect-context.ts

@@ -1,3 +1,9 @@
+import { parseToAst, type AstDocument } from "@telorun/analyzer";
+import type { ReplaceRange } from "../types.js";
+import { resolveNodeAtPosition } from "./resolve-node.js";
+
+export type { ReplaceRange };
+
 export type CompletionCtx =
   | {
       type: "kind";
@@ -7,12 +13,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" }
   | { type: "prop-key"; docKind: string; yamlPath: string[]; existingKeys: Set<string> }
@@ -29,7 +33,7 @@ export type CompletionCtx =
       /** The kind value of the sibling `kind:` line, if present. */
       refKind?: string;
       prefix: string;
-      valueStartColumn: number;
+      replaceRange: ReplaceRange;
     }
   | {
       type: "field-value";
@@ -37,141 +41,10 @@ export type CompletionCtx =
       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 function findDocBounds(lines: string[], cursorLine: number): { start: number; end: number } {
-  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: string[], start: number, end: number): string | undefined {
-  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: string[],
-  start: number,
-  end: number,
-  skipLine?: number,
-): Set<string> {
-  const keys = new Set<string>();
-  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: string[],
-  cursorLine: number,
-  docStart: number,
-  cursorIndent: number,
-): string[] {
-  if (cursorIndent === 0) return [];
-
-  const path: string[] = [];
-  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: string[],
-  start: number,
-  end: number,
-  indent: number,
-  skipLine?: number,
-): Set<string> {
-  const keys = new Set<string>();
-  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;
-}
-
 /** 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,
@@ -272,36 +145,6 @@ function unionLeaves(
  *  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: string[],
-  docStart: number,
-  docEnd: number,
-  cursorLine: number,
-  indent: number,
-): string | undefined {
-  const prefix = " ".repeat(indent);
-  const scan = (range: number[]): string | undefined => {
-    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
@@ -320,144 +163,84 @@ export function lookupRefConstraint(
   return 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 function detectContext(
   text: string,
   line: number,
   character: number,
+  docs?: AstDocument[],
 ): CompletionCtx | undefined {
-  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 };
-      }
+  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" };
-  }
+    if (key === "capability" && 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);
+    // 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),
-    };
+    return undefined;
   }
 
-  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<string>(),
+  };
 }