@telorun/ide-support 0.14.1 → 0.16.0

package/dist/completions/call-inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-inputs.d.ts","sourceRoot":"","sources":["../../src/completions/call-inputs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAEtB,MAAM,mBAAmB,CAAC;AAe3B;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,YAAY,EAAE,MAAM,GACnB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA0CjC"}

package/dist/completions/call-inputs.js

@@ -0,0 +1,78 @@
+/**
+ * The arguments a call site declares.
+ *
+ * A slot that transfers control names its argument slot on its own `x-telo-ref`
+ * — `inputs: /inputs`, a JSON Pointer relative to the object enclosing the slot.
+ * That is the only thing tying an `inputs:` map to the resource it is arguments
+ * FOR: the map itself is an open object, and the reference sits in a sibling
+ * field whose name no walker may assume.
+ *
+ * Reading the pointer here means completion offers exactly the keys the invoked
+ * target declares — resolved through the shared contract resolver, so they are
+ * the keys `telo check` validates that call against and the kernel binds at
+ * dispatch, instance declaration first.
+ */
+import { navigateConcretePath, readRefSlot, } from "@telorun/analyzer";
+import { navigateSchema } from "./detect-context.js";
+/** Resolve a JSON Pointer that is a plain property path (`/inputs`) into path
+ *  segments. Pointers here address a sibling FIELD, never an array element, so
+ *  anything else is left alone rather than guessed at. */
+function pointerSegments(pointer) {
+    if (!pointer.startsWith("/"))
+        return undefined;
+    const segments = pointer
+        .slice(1)
+        .split("/")
+        .map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return segments.every((s) => s.length > 0 && !/^\d+$/.test(s)) ? segments : undefined;
+}
+/**
+ * The declared input contract of the call whose argument slot is at
+ * `concretePath`, or undefined when this path is not one.
+ *
+ * Both halves have to line up: the enclosing object's schema must declare a ref
+ * slot whose `inputs` pointer names this field, and the manifest must fill that
+ * ref. Either missing means there is no call here to take arguments for.
+ */
+export function callInputsAt(registry, analysis, docKind, resourceName, concretePath) {
+    if (!registry || !analysis || !concretePath)
+        return undefined;
+    const resource = analysis.resourceFor(docKind, resourceName);
+    if (!resource)
+        return undefined;
+    const definition = registry.resolveDefinition(docKind);
+    if (!definition?.schema)
+        return undefined;
+    const segments = concretePath.split(".").map((seg) => seg.replace(/\[\d+\]$/, ""));
+    // The pointer is relative to the object ENCLOSING the annotated slot, and it
+    // may name a nested field (`/handler/inputs`), so every prefix of this path is
+    // a candidate enclosing object — not just the immediate parent. Trying them
+    // longest-first keeps the nearest enclosing declaration winning.
+    const concreteSegments = concretePath.split(".");
+    for (let depth = segments.length - 1; depth >= 0; depth--) {
+        const enclosing = segments.slice(0, depth);
+        const tail = segments.slice(depth);
+        const enclosingSchema = navigateSchema(definition.schema, 
+        // Schema navigation is index-free; the concrete path is not.
+        enclosing.filter(Boolean), (from) => registry.resolveSchemaFrom(from, docKind));
+        const properties = enclosingSchema?.properties;
+        if (!properties)
+            continue;
+        for (const [siblingName, siblingSchema] of Object.entries(properties)) {
+            const slot = readRefSlot(siblingSchema);
+            if (!slot?.inputs)
+                continue;
+            const pointed = pointerSegments(slot.inputs);
+            if (!pointed || pointed.length !== tail.length)
+                continue;
+            if (!pointed.every((seg, i) => seg === tail[i]))
+                continue;
+            const refPath = [...concreteSegments.slice(0, depth), siblingName].filter(Boolean).join(".");
+            const ref = navigateConcretePath(resource, refPath);
+            if (!ref || typeof ref !== "object" || !ref.name)
+                continue;
+            return analysis.contractFor(ref, "inputType");
+        }
+    }
+    return undefined;
+}

package/dist/completions/cel-completions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Completion inside a CEL body.
+ *
+ * Every candidate comes from the scope the analyzer resolved for this exact
+ * site, so the list is a claim that what it offers will type-check — not a
+ * separate model of what CEL sees. Where the scope declares nothing (an open
+ * node, a permissive contract, a live value) nothing is offered, which is the
+ * honest answer rather than a guess.
+ */
+import type { CelScopeQuery, CelSegment } from "@telorun/analyzer";
+import type { CompletionResult } from "../types.js";
+/** The resource a cursor's document addresses. */
+export interface CelCompletionTarget {
+    kind?: string;
+    name?: string;
+}
+/**
+ * Candidates for the cursor inside `segment`.
+ *
+ * A member position (`req.|`) offers only what the prefix declares — no
+ * functions, since a receiver-style call is rare next to a field access and
+ * mixing them buries the fields. A root position offers the scope's names
+ * first, then the global functions the environment declares.
+ */
+export declare function celCompletions(text: string, segment: CelSegment, offset: number, concretePath: string, target: CelCompletionTarget, query: CelScopeQuery | undefined): CompletionResult[];
+//# sourceMappingURL=cel-completions.d.ts.map

package/dist/completions/cel-completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-completions.d.ts","sourceRoot":"","sources":["../../src/completions/cel-completions.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAgB,MAAM,aAAa,CAAC;AAIlE,kDAAkD;AAClD,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAqBD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,aAAa,GAAG,SAAS,GAC/B,gBAAgB,EAAE,CAqDpB"}

package/dist/completions/cel-completions.js

@@ -0,0 +1,78 @@
+import { celCursorChain } from "../cel/cursor-chain.js";
+import { celFunctions, celMemberSymbols, celRootSymbols } from "../cel/symbols.js";
+/** Markdown listing every overload, with the function's own description above
+ *  it. A single-signature function needs no list — its one signature is already
+ *  on the detail line. */
+function describeOverloads(signatures, description) {
+    if (signatures.length <= 1)
+        return description;
+    const list = signatures.map((s) => `- \`${s}\``).join("\n");
+    return description ? `${description}\n\n${list}` : list;
+}
+function toResult(symbol, replaceRange) {
+    return {
+        label: symbol.name,
+        kind: "property",
+        detail: symbol.type,
+        documentation: symbol.description,
+        replaceRange,
+    };
+}
+/**
+ * Candidates for the cursor inside `segment`.
+ *
+ * A member position (`req.|`) offers only what the prefix declares — no
+ * functions, since a receiver-style call is rare next to a field access and
+ * mixing them buries the fields. A root position offers the scope's names
+ * first, then the global functions the environment declares.
+ */
+export function celCompletions(text, segment, offset, concretePath, target, query) {
+    if (!query)
+        return [];
+    const resource = query.resourceFor(target.kind, target.name);
+    if (!resource)
+        return [];
+    const scope = query.scopeAt(resource, concretePath);
+    const chain = celCursorChain(text, segment, offset);
+    const prefix = chain?.prefix ?? [];
+    if (chain?.member) {
+        return celMemberSymbols(scope, prefix).map((s) => toResult(s));
+    }
+    const roots = celRootSymbols(scope);
+    const results = roots.map((s) => toResult(s));
+    // A CEL type name (`double`, `int`, `string`) is registered as a variable of
+    // type `type` AND as the conversion function of the same name. Both are real,
+    // but two identical labels are two things an author cannot choose between, so
+    // the callable form wins the slot and says it also names the type — that is
+    // the form written at a root position.
+    const typeNames = new Set(roots.filter((s) => s.type === "type").map((s) => s.name));
+    // Global functions only: a receiver-style one (`string.startsWith`) is
+    // reachable through a member position, where the receiver's type is known.
+    for (const fn of celFunctions(scope)) {
+        if (fn.receiverType)
+            continue;
+        const alsoAType = typeNames.has(fn.name);
+        if (alsoAType) {
+            const at = results.findIndex((r) => r.label === fn.name);
+            if (at >= 0)
+                results.splice(at, 1);
+        }
+        results.push({
+            label: fn.name,
+            kind: "value",
+            // One candidate per function, so the extra overloads are reported IN it
+            // rather than as repeated labels: the count on the detail line, the
+            // signatures themselves in the documentation.
+            detail: fn.signatures.length > 1
+                ? `${fn.signatures[0]}  (+${fn.signatures.length - 1} overloads)`
+                : fn.signatures[0],
+            documentation: describeOverloads(fn.signatures, alsoAType
+                ? [fn.description, `Also names the CEL type \`${fn.name}\`.`].filter(Boolean).join("\n\n")
+                : fn.description),
+            // Sorted after the scope's own names: a variable is what an author is
+            // reaching for at a root position far more often than a built-in.
+            sortText: `z${fn.name}`,
+        });
+    }
+    return results;
+}

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

@@ -1,4 +1,4 @@
-import { type AstDocument } from "@telorun/analyzer";
+import { type AstDocument, type CelSegment } from "@telorun/analyzer";
 import type { ReplaceRange } from "../types.js";
 export type { ReplaceRange };
 export type CompletionCtx = {
@@ -19,6 +19,11 @@ export type CompletionCtx = {
     type: "prop-key";
     docKind: string;
     yamlPath: string[];
+    /** The same location with sequence indices kept, so a caller can find the
+     *  manifest node this slot sits in — what resolving an enclosing call's
+     *  reference needs. */
+    concretePath: string;
+    docIndex: number;
     existingKeys: Set<string>;
 } | {
     /** Cursor sits on the value of an object-form ref's `name:` field
@@ -42,14 +47,48 @@ export type CompletionCtx = {
     prefix: string;
     /** Full source range of the value being completed. */
     replaceRange: ReplaceRange;
+} | {
+    /** Cursor sits on an ordinary field VALUE whose schema declares the values
+     *  it may take — `enum` (closed) or `examples` (open). Untargeted on
+     *  purpose: every value slot resolves here and the ones declaring neither
+     *  simply offer nothing. */
+    type: "value-suggestions";
+    docKind: string;
+    /** Path from the document root to the field, so its schema can be found. */
+    yamlPath: string[];
+    replaceRange: ReplaceRange;
+} | {
+    /** Cursor sits inside a CEL body — closed or still open (`!cel "req.|`).
+     *  What completes is decided by the scope the analyzer resolves for this
+     *  site, so the host must supply a `CelScopeQuery`; without one the
+     *  candidate list would be a guess rather than a claim about what
+     *  `telo check` accepts, and nothing is offered. */
+    type: "cel";
+    docKind?: string;
+    /** Which `---` document the cursor is in, so the host can name the
+     *  resource this expression belongs to. */
+    docIndex: number;
+    /** The site's address with sequence indices kept — what the scope is
+     *  resolved at. */
+    concretePath: string;
+    segment: CelSegment;
+    /** Cursor as a document offset. */
+    offset: number;
 };
+/**
+ * Resolves an `x-telo-schema-from` annotation to the schema it derives. Supplied
+ * by the caller because the anchor is alias-qualified and only the registry can
+ * resolve it in the declaring kind's module scope.
+ */
+export type SchemaFromResolver = (schemaFrom: string) => Record<string, any> | undefined;
 /** Navigate a JSON Schema hierarchy following `path`, auto-descending into
- *  array items, peeling `anyOf` / `oneOf` branches and following document-local
- *  `$ref`s. When multiple peeled branches define `properties`, returns a
- *  synthetic node whose `properties` is the union (first-wins on key collision)
- *  and whose `required` is the intersection — enough for propKeyCompletions to
- *  surface every key a value at this slot can legally carry. */
-export declare function navigateSchema(schema: Record<string, any>, path: string[]): Record<string, any> | undefined;
+ *  array items, peeling `anyOf` / `oneOf` branches, following document-local
+ *  `$ref`s and expanding `x-telo-schema-from` slots. When multiple peeled
+ *  branches define `properties`, returns a synthetic node whose `properties` is
+ *  the union (first-wins on key collision) and whose `required` is the
+ *  intersection — enough for propKeyCompletions to surface every key a value at
+ *  this slot can legally carry. */
+export declare function navigateSchema(schema: Record<string, any>, path: string[], schemaFrom?: SchemaFromResolver): Record<string, any> | undefined;
 /** Walks up and down from `cursorLine` looking for a sibling line at the
  *  exact same indent whose key is `kind`. The value of the first such line
  *  is returned (alias form, e.g. `"Sql.Connection"`). Used by ref-name
@@ -64,7 +103,7 @@ export declare function navigateSchema(schema: Record<string, any>, path: string
  *  the first branch. The analyzer's accessor unions a `kind:` list and the
  *  `anyOf` / `oneOf` branches alike, so completion now offers what the slot
  *  actually takes. */
-export declare function lookupRefConstraints(definitionSchema: Record<string, any>, yamlPath: string[]): string[];
+export declare function lookupRefConstraints(definitionSchema: Record<string, any>, yamlPath: string[], schemaFrom?: SchemaFromResolver): string[];
 /** 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

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":"AAAA,OAAO,EAA8C,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACjG,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;AAyEN;;;;;gEAKgE;AAChE,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,CA6CjC;AAwCD;;;;;wDAKwD;AACxD;;;;;;;sBAOsB;AACtB,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,QAAQ,EAAE,MAAM,EAAE,GACjB,MAAM,EAAE,CAIV;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"}
+{"version":3,"file":"detect-context.d.ts","sourceRoot":"","sources":["../../src/completions/detect-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAC3B,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;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;2BAEuB;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B,GACD;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,GACD;IACE;;;gCAG4B;IAC5B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;CAC5B,GACD;IACE;;;;wDAIoD;IACpD,IAAI,EAAE,KAAK,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;+CAC2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB;uBACmB;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC;IACpB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAyEN;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AA0BzF;;;;;;mCAMmC;AACnC,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,EAAE,MAAM,EAAE,EACd,UAAU,CAAC,EAAE,kBAAkB,GAC9B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA6CjC;AAwCD;;;;;wDAKwD;AACxD;;;;;;;sBAOsB;AACtB,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,QAAQ,EAAE,MAAM,EAAE,EAClB,UAAU,CAAC,EAAE,kBAAkB,GAC9B,MAAM,EAAE,CAIV;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,CAqF3B"}

package/dist/completions/detect-context.js

@@ -1,4 +1,4 @@
-import { parseToAst, readRefSlot, refSlotAnnotation } from "@telorun/analyzer";
+import { parseToAst, readRefSlot, refSlotAnnotation, } 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.
@@ -72,16 +72,39 @@ function resolveLocalRef(node, root) {
     }
     return current;
 }
+/**
+ * Expand a node whose shape comes from a sibling kind's schema.
+ *
+ * A slot annotated `x-telo-schema-from` declares NO `properties` of its own — an
+ * `Http.Api` route's `request:` is exactly this — so every walk that reads
+ * `properties` finds an empty node and silently offers nothing. The derived
+ * schema is merged UNDER whatever the slot itself declared, so a slot that adds
+ * a title or narrows a field keeps winning.
+ */
+function resolveSchemaFrom(node, resolve) {
+    const from = node?.["x-telo-schema-from"];
+    if (!node || !resolve || typeof from !== "string")
+        return node;
+    const derived = resolve(from);
+    if (!derived)
+        return node;
+    return {
+        ...derived,
+        ...node,
+        properties: { ...(derived.properties ?? {}), ...(node.properties ?? {}) },
+    };
+}
 /** Navigate a JSON Schema hierarchy following `path`, auto-descending into
- *  array items, peeling `anyOf` / `oneOf` branches and following document-local
- *  `$ref`s. When multiple peeled branches define `properties`, returns a
- *  synthetic node whose `properties` is the union (first-wins on key collision)
- *  and whose `required` is the intersection — enough for propKeyCompletions to
- *  surface every key a value at this slot can legally carry. */
-export function navigateSchema(schema, path) {
+ *  array items, peeling `anyOf` / `oneOf` branches, following document-local
+ *  `$ref`s and expanding `x-telo-schema-from` slots. When multiple peeled
+ *  branches define `properties`, returns a synthetic node whose `properties` is
+ *  the union (first-wins on key collision) and whose `required` is the
+ *  intersection — enough for propKeyCompletions to surface every key a value at
+ *  this slot can legally carry. */
+export function navigateSchema(schema, path, schemaFrom) {
     let current = schema;
     for (const segment of path) {
-        current = resolveLocalRef(current, schema);
+        current = resolveSchemaFrom(resolveLocalRef(current, schema), schemaFrom);
         if (!current)
             return undefined;
         const candidates = peelCombinators(current).flatMap((node) => {
@@ -118,7 +141,7 @@ export function navigateSchema(schema, path) {
             return undefined;
         current = next;
     }
-    current = resolveLocalRef(current, schema);
+    current = resolveSchemaFrom(resolveLocalRef(current, schema), schemaFrom);
     if (!current)
         return undefined;
     // Auto-descend through a trailing array at the leaf (e.g. cursor inside `mounts:` items)
@@ -176,8 +199,8 @@ function unionLeaves(parent, leaves) {
  *  the first branch. The analyzer's accessor unions a `kind:` list and the
  *  `anyOf` / `oneOf` branches alike, so completion now offers what the slot
  *  actually takes. */
-export function lookupRefConstraints(definitionSchema, yamlPath) {
-    const node = navigateSchema(definitionSchema, yamlPath);
+export function lookupRefConstraints(definitionSchema, yamlPath, schemaFrom) {
+    const node = navigateSchema(definitionSchema, yamlPath, schemaFrom);
     if (!node)
         return [];
     return readRefSlot(node)?.kinds ?? [];
@@ -193,10 +216,18 @@ export function detectContext(text, line, character, docs) {
         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;
+        // Inside a CEL body — structural completion does not apply; what completes
+        // are the names the expression may use.
+        if (resolved.cel) {
+            return {
+                type: "cel",
+                docKind,
+                docIndex: resolved.docIndex,
+                concretePath: resolved.concretePath ?? "",
+                segment: resolved.cel.segment,
+                offset: resolved.cel.offset,
+            };
+        }
         const replaceRange = resolved.replaceRange;
         if (!replaceRange)
             return undefined;
@@ -237,6 +268,9 @@ export function detectContext(text, line, character, docs) {
                 return { type: "field-value", docKind, field: "import-source", prefix, replaceRange };
             }
         }
+        if (docKind) {
+            return { type: "value-suggestions", docKind, yamlPath: resolved.path, replaceRange };
+        }
         return undefined;
     }
     // Key position (existing key, blank line, or trailing indent). Complete
@@ -251,6 +285,8 @@ export function detectContext(text, line, character, docs) {
         type: "prop-key",
         docKind: scopeKind,
         yamlPath: resolved.path.slice(resolved.resourceDepth ?? 0),
+        concretePath: resolved.concretePath ?? "",
+        docIndex: resolved.docIndex,
         existingKeys: resolved.existingKeys ?? new Set(),
     };
 }

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

@@ -1,4 +1,8 @@
 import { type AnalysisRegistry } from "@telorun/analyzer";
 import type { CompletionResult } from "../types.js";
-export declare function propKeyCompletions(kind: string, yamlPath: string[], existingKeys: Set<string>, registry: AnalysisRegistry | undefined): CompletionResult[];
+export declare function propKeyCompletions(kind: string, yamlPath: string[], existingKeys: Set<string>, registry: AnalysisRegistry | undefined, 
+/** The arguments the enclosing call declares, when this path IS that call's
+ *  argument slot. Resolved by the caller, which is the side holding the
+ *  manifest the reference names. */
+callInputs?: Record<string, any>): CompletionResult[];
 //# sourceMappingURL=prop-keys.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"prop-keys.d.ts","sourceRoot":"","sources":["../../src/completions/prop-keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAiBpD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,gBAAgB,EAAE,CAkCpB"}
+{"version":3,"file":"prop-keys.d.ts","sourceRoot":"","sources":["../../src/completions/prop-keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAiBpD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,gBAAgB,GAAG,SAAS;AACtC;;oCAEoC;AACpC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,gBAAgB,EAAE,CAoDpB"}

package/dist/completions/prop-keys.js

@@ -13,7 +13,14 @@ const ROOT_IMPLICIT_PROPS = {
         description: "Resource metadata (name, namespace, version).",
     },
 };
-export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
+export function propKeyCompletions(kind, yamlPath, existingKeys, registry, 
+/** The arguments the enclosing call declares, when this path IS that call's
+ *  argument slot. Resolved by the caller, which is the side holding the
+ *  manifest the reference names. */
+callInputs) {
+    if (callInputs?.properties) {
+        return buildItems(callInputs.properties, existingKeys, new Set(Array.isArray(callInputs.required) ? callInputs.required : []));
+    }
     if (!registry)
         return [];
     const definition = registry.resolveDefinition(kind);
@@ -28,8 +35,17 @@ export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
     }
     const targetSchema = yamlPath.length === 0
         ? definition.schema
-        : navigateSchema(definition.schema, yamlPath);
+        : navigateSchema(definition.schema, yamlPath, (from) => registry.resolveSchemaFrom(from, kind));
+    // A NAME-KEYED map declares its keys nowhere in `properties` — they are the
+    // author's own (a media type, a header name). `propertyNames` is JSON
+    // Schema's own vocabulary for what they may be, and it carries the open/closed
+    // distinction already: `enum` constrains, `examples` only suggests. So an open
+    // list of known values needs no annotation and no analyzer-side knowledge of
+    // any domain.
+    const keySuggestions = propertyNameSuggestions(targetSchema, existingKeys);
     if (!targetSchema?.properties) {
+        if (keySuggestions.length > 0)
+            return keySuggestions;
         if (yamlPath.length === 0) {
             return buildItems(ROOT_IMPLICIT_PROPS, existingKeys, new Set());
         }
@@ -39,7 +55,39 @@ export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
     const properties = yamlPath.length === 0
         ? { ...ROOT_IMPLICIT_PROPS, ...targetSchema.properties }
         : { ...targetSchema.properties, ...annotationKeys(targetSchema) };
-    return buildItems(properties, existingKeys, required);
+    return [...keySuggestions, ...buildItems(properties, existingKeys, required)];
+}
+/**
+ * Key candidates a map-valued node declares through `propertyNames`.
+ *
+ * `enum` is a closed set and `examples` an open one — suggestions with no
+ * validation effect, which is exactly "these are the known values, others are
+ * allowed". Both are stock JSON Schema, so nothing here knows what a media type
+ * is and any name-keyed field gains the same behaviour by declaring it.
+ */
+function propertyNameSuggestions(schema, existingKeys) {
+    const names = schema?.propertyNames;
+    if (!names || typeof names !== "object")
+        return [];
+    const closed = Array.isArray(names.enum) ? names.enum : undefined;
+    const open = Array.isArray(names.examples) ? names.examples : [];
+    const values = closed ?? open;
+    const out = [];
+    for (const value of values) {
+        if (typeof value !== "string" || existingKeys.has(value))
+            continue;
+        out.push({
+            label: value,
+            kind: "enumMember",
+            insertText: `${value}: $0`,
+            snippet: true,
+            detail: closed ? names.title ?? "allowed key" : names.title ?? "known key",
+            // Ahead of any structural key at the same level: at a name-keyed slot the
+            // author is choosing one of these, not adding a sibling field.
+            sortText: `0_${value}`,
+        });
+    }
+    return out;
 }
 /**
  * The `x-telo-*` vocabulary, offered only inside a KIND's own schema.

package/dist/completions/resolve-node.d.ts

@@ -41,8 +41,15 @@ export interface ResolvedCursor {
     /** Key slot: number of `path` segments that reach `resourceKind`'s map, so
      *  the schema-relative path is `path.slice(resourceDepth)`. */
     resourceDepth?: number;
-    /** Set when the cursor sits inside a CEL body (closed or open). Populated for
-     *  a future CEL-completion feature; this refactor does not consume it. */
+    /** The path with sequence INDICES kept (`routes[0].handler.url`),
+     *  as distinct from `path`, through which arrays are transparent. This is the
+     *  address the analyzer speaks — an `x-telo-context` scope, an error-bearing
+     *  region and a step's identity are all resolved per item — so it is what a
+     *  CEL site is looked up by. */
+    concretePath?: string;
+    /** Set when the cursor sits inside a CEL body (closed or open). The CEL
+     *  segment plus the cursor's document offset — what completion and hover
+     *  hit-test the expression's chain against. */
     cel?: {
         segment: CelSegment;
         offset: number;

package/dist/completions/resolve-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-node.d.ts","sourceRoot":"","sources":["../../src/completions/resolve-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,OAAO,EAEZ,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,mBAAmB,CAAC;AAE3B;;;;0CAI0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB;;;sCAGkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC;IACtB;4DACwD;IACxD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC;IAClD,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;gFAC4E;IAC5E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;gCAC4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;iDAC6C;IAC7C,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B;;yCAEqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;mEAC+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;8EAC0E;IAC1E,GAAG,CAAC,EAAE;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAMD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG1E;AAwPD;8DAC8D;AAC9D,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,cAAc,GAAG,SAAS,CAgG5B"}
+{"version":3,"file":"resolve-node.d.ts","sourceRoot":"","sources":["../../src/completions/resolve-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,OAAO,EAEZ,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,mBAAmB,CAAC;AAE3B;;;;0CAI0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB;;;sCAGkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC;IACtB;4DACwD;IACxD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC;IAClD,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;gFAC4E;IAC5E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;gCAC4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;iDAC6C;IAC7C,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B;;yCAEqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;mEAC+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;oCAIgC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;mDAE+C;IAC/C,GAAG,CAAC,EAAE;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAMD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG1E;AA8SD;8DAC8D;AAC9D,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,cAAc,GAAG,SAAS,CAoG5B"}