@telorun/ide-support 0.15.0 → 0.16.0

package/dist/completions/resolve-node.js

@@ -36,7 +36,11 @@ function enter(scope, map, ancestorsLen) {
     const kind = resourceKindOf(map);
     return kind ? { kind, depth: ancestorsLen } : scope;
 }
-function descend(node, ancestors, offset, scope) {
+/** Append one key segment to a concrete path (`routes[0]` + `handler`). */
+function joinKey(concrete, key) {
+    return concrete ? `${concrete}.${key}` : key;
+}
+function descend(node, ancestors, concrete, offset, scope) {
     if (node.kind === "map") {
         const mapScope = enter(scope, node, ancestors.length);
         for (const pair of node.entries) {
@@ -46,6 +50,7 @@ function descend(node, ancestors, offset, scope) {
                     type: "key",
                     container: node,
                     path: ancestors,
+                    concretePath: concrete,
                     keyNode: pair.key,
                     keyName,
                     scope: mapScope,
@@ -53,13 +58,15 @@ function descend(node, ancestors, offset, scope) {
             }
             if (pair.value && within(pair.value.range, offset)) {
                 const childAncestors = keyName != null ? [...ancestors, keyName] : ancestors;
+                const childConcrete = keyName != null ? joinKey(concrete, keyName) : concrete;
                 if (pair.value.kind === "map" || pair.value.kind === "seq") {
-                    return descend(pair.value, childAncestors, offset, mapScope) ?? { type: "empty" };
+                    return descend(pair.value, childAncestors, childConcrete, offset, mapScope) ?? { type: "empty" };
                 }
                 return {
                     type: "value",
                     container: node,
                     path: ancestors,
+                    concretePath: childConcrete,
                     keyName,
                     keyEnd: pair.key.range[1],
                     valueNode: pair.value,
@@ -70,23 +77,33 @@ function descend(node, ancestors, offset, scope) {
     }
     if (node.kind === "seq") {
         // Sequence items are transparent to the key path (mirrors the schema
-        // walker, which auto-descends arrays).
-        for (const item of node.items) {
+        // walker, which auto-descends arrays) but NOT to the concrete path: an
+        // `x-telo-context` scope, an error-bearing region and a step's identity are
+        // all addressed per item, so a CEL site is unreachable without the index.
+        for (const [index, item] of node.items.entries()) {
             if (within(item.range, offset)) {
+                const itemConcrete = `${concrete}[${index}]`;
                 if (item.kind === "map" || item.kind === "seq") {
-                    return descend(item, ancestors, offset, scope) ?? { type: "empty" };
+                    return descend(item, ancestors, itemConcrete, offset, scope) ?? { type: "empty" };
                 }
                 // A bare scalar list item (`targets:\n  - One`) has no enclosing map of
                 // keyed siblings — leave `container` undefined rather than treating the
                 // seq as a map.
-                return { type: "value", container: undefined, path: ancestors, keyEnd: item.range[0], valueNode: item };
+                return {
+                    type: "value",
+                    container: undefined,
+                    path: ancestors,
+                    concretePath: itemConcrete,
+                    keyEnd: item.range[0],
+                    valueNode: item,
+                };
             }
         }
         return undefined;
     }
     return undefined;
 }
-function collectScopes(node, ancestors, scope, lineOffsets, maps, pairs) {
+function collectScopes(node, ancestors, concrete, scope, lineOffsets, maps, pairs) {
     if (node.kind === "map") {
         const mapScope = enter(scope, node, ancestors.length);
         const keys = new Set();
@@ -99,11 +116,19 @@ function collectScopes(node, ancestors, scope, lineOffsets, maps, pairs) {
                 childColumn = offsetToPosition(pair.key.range[0], lineOffsets).character;
         }
         if (childColumn >= 0) {
-            maps.push({ path: ancestors, childColumn, keys, rangeStart: node.range[0], scope: mapScope });
+            maps.push({
+                path: ancestors,
+                concrete,
+                childColumn,
+                keys,
+                rangeStart: node.range[0],
+                scope: mapScope,
+            });
         }
         for (const pair of node.entries) {
             const keyName = scalarString(pair.key);
             const fullPath = keyName != null ? [...ancestors, keyName] : ancestors;
+            const fullConcrete = keyName != null ? joinKey(concrete, keyName) : concrete;
             const childKeys = new Set();
             if (pair.value?.kind === "map") {
                 for (const p of pair.value.entries) {
@@ -114,18 +139,19 @@ function collectScopes(node, ancestors, scope, lineOffsets, maps, pairs) {
             }
             pairs.push({
                 path: fullPath,
+                concrete: fullConcrete,
                 keyColumn: offsetToPosition(pair.key.range[0], lineOffsets).character,
                 keyOffset: pair.key.range[0],
                 childKeys,
                 scope: mapScope,
             });
-            if (pair.value)
-                collectScopes(pair.value, fullPath, mapScope, lineOffsets, maps, pairs);
+            if (pair.value) {
+                collectScopes(pair.value, fullPath, fullConcrete, mapScope, lineOffsets, maps, pairs);
+            }
         }
     }
     else if (node.kind === "seq") {
-        for (const item of node.items)
-            collectScopes(item, ancestors, scope, lineOffsets, maps, pairs);
+        node.items.forEach((item, index) => collectScopes(item, ancestors, `${concrete}[${index}]`, scope, lineOffsets, maps, pairs));
     }
 }
 /** Resolve the container a new key at `cursorColumn` belongs to. Prefers an
@@ -134,7 +160,7 @@ function collectScopes(node, ancestors, scope, lineOffsets, maps, pairs) {
 function columnSearch(root, cursorColumn, cursorOffset, lineOffsets) {
     const maps = [];
     const pairs = [];
-    collectScopes(root, [], { depth: 0 }, lineOffsets, maps, pairs);
+    collectScopes(root, [], "", { depth: 0 }, lineOffsets, maps, pairs);
     // Sibling level: a map whose children already sit at the cursor's column.
     let sibling;
     for (const m of maps) {
@@ -143,8 +169,14 @@ function columnSearch(root, cursorColumn, cursorOffset, lineOffsets) {
                 sibling = m;
         }
     }
-    if (sibling)
-        return { path: sibling.path, existingKeys: sibling.keys, scope: sibling.scope };
+    if (sibling) {
+        return {
+            path: sibling.path,
+            concrete: sibling.concrete,
+            existingKeys: sibling.keys,
+            scope: sibling.scope,
+        };
+    }
     // Nest under the nearest-preceding key shallower than the cursor.
     let nest;
     for (const p of pairs) {
@@ -156,9 +188,15 @@ function columnSearch(root, cursorColumn, cursorOffset, lineOffsets) {
             }
         }
     }
-    if (nest)
-        return { path: nest.path, existingKeys: nest.childKeys, scope: nest.scope };
-    return { path: [], existingKeys: new Set(), scope: { depth: 0 } };
+    if (nest) {
+        return {
+            path: nest.path,
+            concrete: nest.concrete,
+            existingKeys: nest.childKeys,
+            scope: nest.scope,
+        };
+    }
+    return { path: [], concrete: "", existingKeys: new Set(), scope: { depth: 0 } };
 }
 // ---------------------------------------------------------------------------
 function selectDoc(docs, offset) {
@@ -189,7 +227,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
         return undefined;
     const doc = docs[docIndex];
     const docKind = docKindOf(doc);
-    const found = doc.root ? descend(doc.root, [], offset, { depth: 0 }) : undefined;
+    const found = doc.root ? descend(doc.root, [], "", offset, { depth: 0 }) : undefined;
     // Cursor sits on an existing map key → key/prop-key position.
     if (found?.type === "key") {
         const existingKeys = new Set();
@@ -204,6 +242,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
             docKind,
             slot: "key",
             path: found.path,
+            concretePath: found.concretePath,
             node: found.keyNode,
             replaceRange: { start: toPos(found.keyNode.range[0]), end: toPos(found.keyNode.range[1]) },
             container: found.container,
@@ -226,13 +265,14 @@ export function resolveNodeAtPosition(text, docs, line, character) {
             toPos(value.range[0]).line !== toPos(found.keyEnd).line;
         if (isPartialKey && doc.root) {
             const col = toPos(value.range[0]).character;
-            const { path, existingKeys, scope } = columnSearch(doc.root, col, offset, lineOffsets);
+            const { path, concrete, existingKeys, scope } = columnSearch(doc.root, col, offset, lineOffsets);
             return {
                 docIndex,
                 offset,
                 docKind,
                 slot: "key",
                 path,
+                concretePath: concrete,
                 container: found.container,
                 existingKeys,
                 resourceKind: scope.kind,
@@ -246,6 +286,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
             docKind,
             slot: "value",
             path: found.keyName != null ? [...found.path, found.keyName] : found.path,
+            concretePath: found.concretePath,
             node: value,
             container: found.container,
             prefix: text.slice(value.range[0], clampedEnd),
@@ -259,13 +300,14 @@ export function resolveNodeAtPosition(text, docs, line, character) {
     // resolved by cursor column.
     const resolution = doc.root
         ? columnSearch(doc.root, character, offset, lineOffsets)
-        : { path: [], existingKeys: new Set(), scope: { depth: 0 } };
+        : { path: [], concrete: "", existingKeys: new Set(), scope: { depth: 0 } };
     return {
         docIndex,
         offset,
         docKind,
         slot: "key",
         path: resolution.path,
+        concretePath: resolution.concrete,
         existingKeys: resolution.existingKeys,
         resourceKind: resolution.scope.kind,
         resourceDepth: resolution.scope.depth,

package/dist/definition/build-definition.d.ts

@@ -1,4 +1,4 @@
-import { type AstDocument, type LoadedGraph } from "@telorun/analyzer";
+import { type AstDocument, type ManifestAnalysis, type LoadedGraph } from "@telorun/analyzer";
 import type { DefinitionResult } from "../types.js";
 /** Resolve the symbol under the cursor to where it is declared.
  *
@@ -16,5 +16,9 @@ import type { DefinitionResult } from "../types.js";
  *  cursor is on nothing navigable, or the target can't be found (a kernel
  *  built-in, a scope-local name, an unexported entry, or an import that failed
  *  to load). */
-export declare function buildDefinition(text: string, line: number, character: number, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[]): DefinitionResult | undefined;
+export declare function buildDefinition(text: string, line: number, character: number, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[], 
+/** Lets a `steps.<name>` read navigate to the step that produced it, and a
+ *  context binding to its declaration — both need the declaring kind's own
+ *  annotations, which only the analysis can read. */
+analysis?: ManifestAnalysis): DefinitionResult | undefined;
 //# sourceMappingURL=build-definition.d.ts.map

package/dist/definition/build-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-definition.d.ts","sourceRoot":"","sources":["../../src/definition/build-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,WAAW,EAAkB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACnG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAQpD;;;;;;;;;;;;;;;gBAegB;AAChB,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,gBAAgB,GAAG,SAAS,CAoB9B"}
+{"version":3,"file":"build-definition.d.ts","sourceRoot":"","sources":["../../src/definition/build-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAUpD;;;;;;;;;;;;;;;gBAegB;AAChB,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,IAAI,CAAC,EAAE,WAAW,EAAE;AACpB;;qDAEqD;AACrD,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,gBAAgB,GAAG,SAAS,CAoC9B"}

package/dist/definition/build-definition.js

@@ -1,6 +1,8 @@
-import { parseToAst } from "@telorun/analyzer";
+import { parseToAst, } from "@telorun/analyzer";
 import { resolveNodeAtPosition } from "../completions/resolve-node.js";
 import { splitAliasQualified } from "./alias-qualified-value.js";
+import { locateContextBinding } from "./locate-context-binding.js";
+import { locateStepDeclaration } from "./locate-step.js";
 import { moduleForFile } from "./manifest-navigation.js";
 import { resolveCelTarget } from "./resolve-cel-target.js";
 import { isKindSlot, resolveKindTarget } from "./resolve-kind-target.js";
@@ -21,14 +23,25 @@ import { resolveRefTarget } from "./resolve-ref-target.js";
  *  cursor is on nothing navigable, or the target can't be found (a kernel
  *  built-in, a scope-local name, an unexported entry, or an import that failed
  *  to load). */
-export function buildDefinition(text, line, character, graph, currentFilePath, docs) {
+export function buildDefinition(text, line, character, graph, currentFilePath, docs, 
+/** Lets a `steps.<name>` read navigate to the step that produced it, and a
+ *  context binding to its declaration — both need the declaring kind's own
+ *  annotations, which only the analysis can read. */
+analysis) {
     const astDocs = docs ?? parseToAst(text);
     const resolved = resolveNodeAtPosition(text, astDocs, line, character);
     if (!resolved)
         return undefined;
     const currentModule = moduleForFile(graph, currentFilePath) ?? graph.entry;
     if (resolved.cel) {
-        return resolveCelTarget(graph, currentModule, resolved.cel.segment, resolved.cel.offset);
+        return resolveCelTarget(graph, currentModule, resolved.cel.segment, resolved.cel.offset, {
+            // A step is resolved in the CURRENT document — `steps.<name>.result` is
+            // readable only inside the resource that declares it, which is one
+            // document. Supplied as a closure so the chain resolver stays free of the
+            // AST and the scope query alike.
+            locateStep: (stepName) => locateStepDeclaration(graph, currentFilePath, astDocs, resolved.docIndex, stepName, analysis?.celScope),
+            locateContextBinding: (parts) => locateContextBinding(graph, astDocs, resolved.docIndex, resolved.concretePath ?? "", parts, analysis?.celScope),
+        });
     }
     const node = resolved.node;
     if (resolved.slot !== "value" || node?.kind !== "scalar")

package/dist/definition/locate-context-binding.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Where a CEL context binding was declared.
+ *
+ * `request.query` is written in the route's own `request.schema`, `self.<field>`
+ * in the definition's `schema`, `result.<field>` in the INVOKED resource's
+ * `outputType` — each derived by an `x-telo-context-*` annotation rather than
+ * reached through a reference slot, so none of them is navigable by the graph
+ * walk the other CEL roots use. The scope query resolves the annotation to a
+ * manifest identity plus a path; locating that path in the loaded files is what
+ * this adds.
+ */
+import type { AstDocument, CelScopeQuery, LoadedGraph } from "@telorun/analyzer";
+import type { DefinitionResult } from "../types.js";
+export declare function locateContextBinding(graph: LoadedGraph, docs: AstDocument[], docIndex: number, sitePath: string, parts: string[], scopeQuery: CelScopeQuery | undefined): DefinitionResult | undefined;
+//# sourceMappingURL=locate-context-binding.d.ts.map

package/dist/definition/locate-context-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locate-context-binding.d.ts","sourceRoot":"","sources":["../../src/definition/locate-context-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAc,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAYpD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,WAAW,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,aAAa,GAAG,SAAS,GACpC,gBAAgB,GAAG,SAAS,CAqB9B"}

package/dist/definition/locate-context-binding.js

@@ -0,0 +1,35 @@
+import { docIdentity } from "../doc-identity.js";
+/** Every file of every module in the graph — a binding's declaration may sit in
+ *  another module (an invoked handler's `outputType`), so the search is not
+ *  confined to the current file. */
+function allFiles(graph) {
+    const out = [];
+    for (const mod of graph.modules.values())
+        out.push(mod.owner, ...mod.partials);
+    return out;
+}
+export function locateContextBinding(graph, docs, docIndex, sitePath, parts, scopeQuery) {
+    if (!scopeQuery)
+        return undefined;
+    const identity = docIdentity(docs[docIndex]);
+    const resource = scopeQuery.resourceFor(identity.kind, identity.name);
+    if (!resource)
+        return undefined;
+    const site = scopeQuery.contextDeclarationSite(resource, sitePath, parts);
+    if (!site)
+        return undefined;
+    for (const file of allFiles(graph)) {
+        for (let i = 0; i < file.manifests.length; i++) {
+            const manifest = file.manifests[i];
+            if (manifest?.kind !== site.kind || manifest.metadata?.name !== site.name)
+                continue;
+            const index = file.positions[i]?.positionIndex;
+            // The KEY span, so the jump underlines `query:` rather than the block that
+            // follows it — a declaration, not a selection.
+            const range = index?.get(`@key:${site.path}`) ?? index?.get(site.path);
+            if (range)
+                return { uri: file.source, range };
+        }
+    }
+    return undefined;
+}

package/dist/definition/locate-step.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Where a `Run` step is declared.
+ *
+ * The one CEL scope whose members really are written in the manifest but are
+ * reached through no reference slot — `steps.encode.result` names something a
+ * `!ref` resolver has never heard of. Finding it needs the declaring kind's own
+ * step-body annotation, which is why it goes through the scope query rather
+ * than through the graph navigation the other CEL roots use.
+ */
+import type { AstDocument, CelScopeQuery, LoadedGraph } from "@telorun/analyzer";
+import type { DefinitionResult } from "../types.js";
+export declare function locateStepDeclaration(graph: LoadedGraph, filePath: string, docs: AstDocument[], docIndex: number, stepName: string, scopeQuery: CelScopeQuery | undefined): DefinitionResult | undefined;
+//# sourceMappingURL=locate-step.d.ts.map

package/dist/definition/locate-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locate-step.d.ts","sourceRoot":"","sources":["../../src/definition/locate-step.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAc,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAcpD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,WAAW,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,aAAa,GAAG,SAAS,GACpC,gBAAgB,GAAG,SAAS,CAkB9B"}

package/dist/definition/locate-step.js

@@ -0,0 +1,33 @@
+import { docIdentity } from "../doc-identity.js";
+/** The loaded file for `filePath`, whose position index maps a manifest path to
+ *  a source range. */
+function loadedFile(graph, filePath) {
+    for (const mod of graph.modules.values()) {
+        if (mod.owner.source === filePath)
+            return mod.owner;
+        const partial = mod.partials.find((p) => p.source === filePath);
+        if (partial)
+            return partial;
+    }
+    return undefined;
+}
+export function locateStepDeclaration(graph, filePath, docs, docIndex, stepName, scopeQuery) {
+    if (!scopeQuery)
+        return undefined;
+    const identity = docIdentity(docs[docIndex]);
+    const resource = scopeQuery.resourceFor(identity.kind, identity.name);
+    if (!resource)
+        return undefined;
+    const stepPath = scopeQuery.stepDeclarationPath(resource, stepName);
+    if (!stepPath)
+        return undefined;
+    const file = loadedFile(graph, filePath);
+    const index = file?.positions[docIndex]?.positionIndex;
+    if (!index)
+        return undefined;
+    // The step's own `name:` value is what the jump underlines — the step object's
+    // range would highlight the whole block, which reads as a selection rather
+    // than as a declaration.
+    const range = index.get(`${stepPath}.name`) ?? index.get(`@key:${stepPath}.name`) ?? index.get(stepPath);
+    return range ? { uri: file.source, range } : undefined;
+}

package/dist/definition/resolve-cel-target.d.ts

@@ -13,5 +13,15 @@ import type { DefinitionResult } from "../types.js";
  *  analyzer reports the syntax error itself. Only that failure is tolerated: a
  *  defect in the CEL wrapper propagates rather than reading as "nothing to
  *  navigate to". */
-export declare function resolveCelTarget(graph: LoadedGraph, currentModule: LoadedModule, segment: CelSegment, offset: number): DefinitionResult | undefined;
+export interface CelTargetResolvers {
+    /** Where a step of the CURRENT resource is declared. Supplied by the caller
+     *  because finding one needs the declaring kind's step-body annotation, which
+     *  the graph alone does not carry. */
+    locateStep?(stepName: string): DefinitionResult | undefined;
+    /** Where a context binding (`request.query`, `self.<field>`,
+     *  `result.<field>`) was declared. Same reason: the site is derived by an
+     *  `x-telo-context-*` annotation, which only the scope query can read. */
+    locateContextBinding?(parts: string[]): DefinitionResult | undefined;
+}
+export declare function resolveCelTarget(graph: LoadedGraph, currentModule: LoadedModule, segment: CelSegment, offset: number, resolvers?: CelTargetResolvers): DefinitionResult | undefined;
 //# sourceMappingURL=resolve-cel-target.d.ts.map

package/dist/definition/resolve-cel-target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-cel-target.d.ts","sourceRoot":"","sources":["../../src/definition/resolve-cel-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqCpD;;;;;;;;;;;;oBAYoB;AACpB,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,SAAS,CAqB9B"}
+{"version":3,"file":"resolve-cel-target.d.ts","sourceRoot":"","sources":["../../src/definition/resolve-cel-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqCpD;;;;;;;;;;;;oBAYoB;AACpB,MAAM,WAAW,kBAAkB;IACjC;;0CAEsC;IACtC,UAAU,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAC5D;;8EAE0E;IAC1E,oBAAoB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAAC;CACtE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,kBAAkB,GAC7B,gBAAgB,GAAG,SAAS,CAkC9B"}

package/dist/definition/resolve-cel-target.js

@@ -25,20 +25,7 @@ function resolveResourceChain(graph, currentModule, parts, index) {
         return resolveExportedResource(graph, edge.targetSource, parts[2].name);
     return undefined;
 }
-/** Resolve the CEL identifier under the cursor to where it is declared.
- *
- *  `variables` / `secrets` / `ports` navigate to their block on the module doc,
- *  and their member to that block's entry. `resources` navigates through the
- *  same instance lookup a `!ref` uses. Anything else (a step result, a handler
- *  scope like `request`, a member of a resolved value) has no manifest
- *  declaration to jump to and resolves to nothing.
- *
- *  A body the author is still writing may not parse; that means there is no
- *  chain to hit-test, not an error to surface from a navigation request — the
- *  analyzer reports the syntax error itself. Only that failure is tolerated: a
- *  defect in the CEL wrapper propagates rather than reading as "nothing to
- *  navigate to". */
-export function resolveCelTarget(graph, currentModule, segment, offset) {
+export function resolveCelTarget(graph, currentModule, segment, offset, resolvers) {
     let ast;
     try {
         ast = segment.ast();
@@ -62,5 +49,18 @@ export function resolveCelTarget(graph, currentModule, segment, offset) {
     }
     if (root === "resources")
         return resolveResourceChain(graph, currentModule, parts, index);
+    // `steps.<name>` navigates to the step; `steps` itself and `.result` do not —
+    // the first names no one step, the second is the contract's output, which is
+    // declared by the invoked target rather than at the read site.
+    if (root === "steps" && index === 1 && resolvers?.locateStep) {
+        return resolvers.locateStep(parts[1].name);
+    }
+    // Anything else in scope came from an `x-telo-context-*` annotation, which
+    // names a real manifest node for `request` / `self` / `result` and friends.
+    // The chain UP TO the cursor is what resolves — hovering `query` in
+    // `request.query.lastEventId` navigates to `query`, not to the leaf.
+    if (index >= 1 && resolvers?.locateContextBinding) {
+        return resolvers.locateContextBinding(parts.slice(0, index + 1).map((p) => p.name));
+    }
     return undefined;
 }

package/dist/doc-identity.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A document's `kind` + `metadata.name` — the pair that names the resource an
+ * analyzed manifest set holds it under.
+ *
+ * Its own module because it is a document-identity primitive, not a completion
+ * one: hover, semantic tokens and both declaration locators need it, and
+ * reaching it through the completion entry point dragged that whole module
+ * graph — CEL completion, call-input resolution, the import-source machinery —
+ * into surfaces that use none of it.
+ */
+import type { AstDocument } from "@telorun/analyzer";
+/** Either half may be absent while the author is still writing the document. */
+export declare function docIdentity(doc: AstDocument | undefined): {
+    kind?: string;
+    name?: string;
+};
+//# sourceMappingURL=doc-identity.d.ts.map

package/dist/doc-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-identity.d.ts","sourceRoot":"","sources":["../src/doc-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,mBAAmB,CAAC;AAK7D,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAc1F"}

package/dist/doc-identity.js

@@ -0,0 +1,19 @@
+const scalar = (node) => node?.kind === "scalar" && typeof node.value === "string" ? node.value : undefined;
+/** Either half may be absent while the author is still writing the document. */
+export function docIdentity(doc) {
+    if (doc?.root?.kind !== "map")
+        return {};
+    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);
+        }
+    }
+    return { kind, name };
+}

package/dist/hover/build-hover.d.ts

@@ -1,4 +1,8 @@
-import { type AnalysisRegistry, type AstDocument } from "@telorun/analyzer";
+import { type AnalysisRegistry, type AstDocument, type ManifestAnalysis } from "@telorun/analyzer";
 import type { HoverResult } from "../types.js";
-export declare function buildHover(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, docs?: AstDocument[]): HoverResult | undefined;
+export declare function buildHover(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, docs?: AstDocument[], 
+/** The host's analysis. Without it a CEL identifier hovers as nothing — its
+ *  type is a property of the resolved scope, and there is no second source
+ *  for it. */
+analysis?: ManifestAnalysis): HoverResult | undefined;
 //# sourceMappingURL=build-hover.d.ts.map

package/dist/hover/build-hover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-hover.d.ts","sourceRoot":"","sources":["../../src/hover/build-hover.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyF/C,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,WAAW,GAAG,SAAS,CAOzB"}
+{"version":3,"file":"build-hover.d.ts","sourceRoot":"","sources":["../../src/hover/build-hover.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAGhB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA8F/C,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,IAAI,CAAC,EAAE,WAAW,EAAE;AACpB;;cAEc;AACd,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,WAAW,GAAG,SAAS,CAczB"}

package/dist/hover/build-hover.js

@@ -1,4 +1,7 @@
-import { parseToAst, readRefSlot, } from "@telorun/analyzer";
+import { CelParseError, parseToAst, readRefSlot, } from "@telorun/analyzer";
+import { chainAt } from "../cel-chain.js";
+import { celSymbolAt } from "../cel/symbols.js";
+import { docIdentity } from "../doc-identity.js";
 import { navigateSchema } from "../completions/detect-context.js";
 import { resolveNodeAtPosition, scalarString, } from "../completions/resolve-node.js";
 import { CAPABILITY_DOCS } from "../completions/valid-capabilities.js";
@@ -79,17 +82,75 @@ function fieldSchemaFor(resourceKind, relativePath, registry) {
     const def = registry.resolveDefinition(resourceKind);
     if (!def?.schema)
         return undefined;
-    return navigateSchema(def.schema, relativePath);
+    return navigateSchema(def.schema, relativePath, (from) => registry.resolveSchemaFrom(from, resourceKind));
 }
-export function buildHover(text, line, character, registry, docs) {
+export function buildHover(text, line, character, registry, docs, 
+/** The host's analysis. Without it a CEL identifier hovers as nothing — its
+ *  type is a property of the resolved scope, and there is no second source
+ *  for it. */
+analysis) {
     const astDocs = docs ?? parseToAst(text);
     const resolved = resolveNodeAtPosition(text, astDocs, line, character);
     if (!resolved)
         return undefined;
+    if (resolved.cel) {
+        const hover = hoverForCel(resolved, astDocs, analysis?.celScope);
+        // A CEL body is still a field value; when the cursor is on nothing
+        // nameable inside it (an operator, a literal), fall through to the field's
+        // own hover rather than reporting nothing.
+        if (hover)
+            return hover;
+    }
     if (resolved.slot === "value")
         return hoverForValue(resolved, registry);
     return hoverForKey(resolved, registry);
 }
+/**
+ * Hover for one identifier of a CEL chain.
+ *
+ * The TYPE comes from the resolved scope; a DESCRIPTION comes from whatever
+ * schema node declared the name. Where to jump is the other half's answer
+ * (`resolveCelTarget`) and is deliberately not consulted here — hover must
+ * still say what `steps.encode.result` IS even though nothing in the manifest
+ * declares it.
+ */
+function hoverForCel(resolved, docs, scopeQuery) {
+    if (!resolved.cel || !scopeQuery)
+        return undefined;
+    const identity = docIdentity(docs[resolved.docIndex]);
+    const resource = scopeQuery.resourceFor(identity.kind, identity.name);
+    if (!resource)
+        return undefined;
+    let ast;
+    try {
+        ast = resolved.cel.segment.ast();
+    }
+    catch (error) {
+        // An expression the author is still writing does not parse. That means
+        // there is no chain to hit-test, not an error to report from a hover — the
+        // analyzer reports the syntax error itself. Only that failure is tolerated.
+        if (!(error instanceof CelParseError))
+            throw error;
+        return undefined;
+    }
+    const hit = chainAt(ast, resolved.cel.offset);
+    if (!hit)
+        return undefined;
+    // The chain UP TO the cursor, not the whole chain: hovering `resources` in
+    // `resources.db.url` describes `resources`.
+    const parts = hit.parts.slice(0, hit.index + 1).map((p) => p.name);
+    const scope = scopeQuery.scopeAt(resource, resolved.concretePath ?? "");
+    const symbol = celSymbolAt(scope, parts);
+    if (!symbol)
+        return undefined;
+    const lines = [symbol.type ? `**${symbol.name}**: \`${symbol.type}\`` : `**${symbol.name}**`];
+    if (symbol.description)
+        lines.push("", symbol.description);
+    const chainText = parts.join(".");
+    if (chainText !== symbol.name)
+        lines.push("", `\`${chainText}\``);
+    return { contents: lines.join("\n") };
+}
 function hoverForValue(resolved, registry) {
     const key = resolved.path[resolved.path.length - 1];
     const value = scalarString(resolved.node);

package/dist/semantic-tokens/build-semantic-tokens.d.ts

@@ -1,12 +1,17 @@
-import { type AnalysisRegistry, type AstDocument } from "@telorun/analyzer";
+import { type AnalysisRegistry, type AstDocument, type ManifestAnalysis } from "@telorun/analyzer";
 import type { SemanticToken } from "../types.js";
 /** Registry-aware semantic tokens: a `kind:` value that resolves to a known
  *  definition is a `type`; a `capability:` value is an `interface`; a `!ref`
- *  target is a `variable`. Everything else (structure, CEL, tags) is left to the
- *  TextMate grammar. Ref targets are colored here rather than in the grammar
- *  because a `!ref` after a `key:` is tokenized by the bundled YAML grammar
- *  before a Telo pattern can claim it — the AST sees it unambiguously. An
- *  unresolved kind gets no token, so a typo stays uncolored — a quiet signal
- *  that pairs with the analyzer's `UNDEFINED_KIND` diagnostic. */
-export declare function buildSemanticTokens(text: string, registry: AnalysisRegistry | undefined, docs?: AstDocument[]): SemanticToken[];
+ *  target is a `variable`. Ref targets are colored here rather than in the
+ *  grammar because a `!ref` after a `key:` is tokenized by the bundled YAML
+ *  grammar before a Telo pattern can claim it — the AST sees it unambiguously.
+ *  An unresolved kind gets no token, so a typo stays uncolored — a quiet signal
+ *  that pairs with the analyzer's `UNDEFINED_KIND` diagnostic.
+ *
+ *  The inside of a `!cel` / `${{ }}` body is colored here too, and for the same
+ *  reason one level down: a grammar can only know the roots someone hardcoded
+ *  into it, while `scopeQuery` knows what is in scope at this exact site. With
+ *  no query the names are colored syntactically instead — a CEL body must never
+ *  read as a plain string, which is what the stock YAML grammar makes of it. */
+export declare function buildSemanticTokens(text: string, registry: AnalysisRegistry | undefined, docs?: AstDocument[], analysis?: ManifestAnalysis): SemanticToken[];
 //# sourceMappingURL=build-semantic-tokens.d.ts.map

package/dist/semantic-tokens/build-semantic-tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-semantic-tokens.d.ts","sourceRoot":"","sources":["../../src/semantic-tokens/build-semantic-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD;;;;;;;kEAOkE;AAClE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,aAAa,EAAE,CAqCjB"}
+{"version":3,"file":"build-semantic-tokens.d.ts","sourceRoot":"","sources":["../../src/semantic-tokens/build-semantic-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAIhB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAajD;;;;;;;;;;;;gFAYgF;AAChF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,IAAI,CAAC,EAAE,WAAW,EAAE,EACpB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,aAAa,EAAE,CA2EjB"}