@telorun/ide-support 0.15.0 → 0.16.0

package/dist/cel/cursor-chain.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The dotted chain the cursor is in the middle of typing.
+ *
+ * Deliberately TEXTUAL, and only for completion. `chainAt` (over the parsed
+ * CEL AST) is what hover and go-to-declaration use, because there the
+ * expression is complete and the cursor sits on a specific identifier whose
+ * span matters. Completion fires on text that frequently does not parse —
+ * `req.` is not an expression — so a parse-first approach would go silent
+ * exactly while the user is asking for help. An open segment recovers to its
+ * longest parseable PREFIX, which by definition drops the token being typed.
+ */
+import type { CelSegment } from "@telorun/analyzer";
+export interface CelCursorChain {
+    /** Identifiers resolved before the token under the cursor (`req.query.` → `["req","query"]`). */
+    prefix: string[];
+    /** The partial identifier being typed, possibly empty. */
+    token: string;
+    /** True when the cursor follows a `.` — a member position, where only the
+     *  prefix's members are offered and functions are not. */
+    member: boolean;
+}
+/**
+ * Split the text before the cursor into a resolved prefix and a partial token.
+ *
+ * Returns undefined when the cursor does not follow an identifier-shaped run —
+ * after an operator, inside a string literal's content, at the start of an
+ * empty body — where the caller offers the root scope instead of a member list.
+ */
+export declare function celCursorChain(text: string, segment: CelSegment, offset: number): CelCursorChain | undefined;
+//# sourceMappingURL=cursor-chain.d.ts.map

package/dist/cel/cursor-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-chain.d.ts","sourceRoot":"","sources":["../../src/cel/cursor-chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B,iGAAiG;IACjG,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd;8DAC0D;IAC1D,MAAM,EAAE,OAAO,CAAC;CACjB;AAaD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACb,cAAc,GAAG,SAAS,CAY5B"}

package/dist/cel/cursor-chain.js

@@ -0,0 +1,30 @@
+/** Where `segment.source` starts in document offsets. The segment range spans
+ *  the delimiters (`${{ … }}`) and any trimmed whitespace, so the body has to be
+ *  located inside it rather than assumed to start at `range[0]`. */
+function bodyStart(text, segment) {
+    const span = text.slice(segment.range[0], segment.range[1]);
+    const at = span.indexOf(segment.source);
+    return at < 0 ? segment.range[0] : segment.range[0] + at;
+}
+const TRAILING_CHAIN = /[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*\.?$/;
+/**
+ * Split the text before the cursor into a resolved prefix and a partial token.
+ *
+ * Returns undefined when the cursor does not follow an identifier-shaped run —
+ * after an operator, inside a string literal's content, at the start of an
+ * empty body — where the caller offers the root scope instead of a member list.
+ */
+export function celCursorChain(text, segment, offset) {
+    const start = bodyStart(text, segment);
+    const index = Math.max(0, Math.min(offset - start, segment.source.length));
+    const before = segment.source.slice(0, index);
+    const match = TRAILING_CHAIN.exec(before);
+    if (!match)
+        return undefined;
+    const run = match[0];
+    if (run.endsWith(".")) {
+        return { prefix: run.slice(0, -1).split("."), token: "", member: true };
+    }
+    const parts = run.split(".");
+    return { prefix: parts.slice(0, -1), token: parts[parts.length - 1], member: parts.length > 1 };
+}

package/dist/cel/symbols.d.ts

@@ -0,0 +1,82 @@
+/**
+ * **What a name means inside a CEL expression.**
+ *
+ * The TYPE half of CEL language support — completion's candidate list and
+ * hover's tooltip are both this, read off the scope the analyzer resolved. It
+ * is deliberately separate from the DECLARATION half (`definition/`), which
+ * answers where a name was written: the two take different inputs and
+ * legitimately disagree. `steps.encode.result` has a type and no manifest node
+ * to jump to; a transport binding like `request` has a scope entry and no
+ * declaration at all. Joining them is hover's job, not this module's.
+ */
+import type { CelScope } from "@telorun/analyzer";
+/** One name in scope, with whatever the scope knows about it. Both `type` and
+ *  `schema` are optional and neither implies the other: a CEL environment
+ *  variable carries a type and no schema, a context property carries a schema
+ *  and gets its type from it. */
+export interface CelSymbol {
+    name: string;
+    /** CEL type name (`int`, `string`, `map`), when the environment declares one. */
+    type?: string;
+    /** JSON Schema node, when the context declares the shape. */
+    schema?: Record<string, any>;
+    description?: string;
+}
+/**
+ * One callable, with every overload the environment registered for it.
+ *
+ * Grouped rather than one entry per overload: the registry declares a signature
+ * per accepted argument list — `double` has four — and offering each as its own
+ * candidate turns a completion list into four identical labels the author
+ * cannot choose between. What varies between them is the signature, so that is
+ * what the grouped entry carries.
+ */
+export interface CelFunctionSymbol {
+    name: string;
+    /** Every registered overload's signature, in registration order. */
+    signatures: string[];
+    /** The type a receiver-style call is made ON (`string.startsWith`), or null
+     *  for a global function. Part of the grouping key, since a global and a
+     *  method sharing a name are genuinely two callables. */
+    receiverType: string | null;
+    /** The first description any overload carries — they describe the function,
+     *  not the individual argument list. */
+    description?: string;
+}
+/** The type a schema node declares, rendered for display. Unions are joined
+ *  rather than collapsed — a slot admitting several shapes says so. */
+export declare function schemaTypeName(schema: Record<string, any> | undefined): string | undefined;
+/**
+ * The names an expression may start with.
+ *
+ * Both sources, because neither is complete: the context schema carries the
+ * scope's own bindings (`steps`, `error`, a kind's named bindings, a transport's
+ * `request`), while the environment carries what was registered onto it
+ * directly — which is where the kernel globals live when no context applied.
+ * A name in both takes its schema from the context, which is the narrower.
+ */
+export declare function celRootSymbols(scope: CelScope): CelSymbol[];
+/**
+ * The members available after `prefix`.
+ *
+ * Empty when the prefix resolves to nothing OR to something whose shape the
+ * scope does not declare — an open node, a live value, a permissive contract.
+ * That is the honest answer: offering a guess here would be offering names the
+ * checker has no opinion about, which is exactly what the shared scope rule
+ * exists to prevent.
+ */
+export declare function celMemberSymbols(scope: CelScope, prefix: string[]): CelSymbol[];
+/** What the chain `parts` resolves to — used for hover, where the cursor sits on
+ *  one identifier of a complete chain and the symbol wanted is the one at that
+ *  identifier, not at the chain's tail. */
+export declare function celSymbolAt(scope: CelScope, parts: string[]): CelSymbol | undefined;
+/**
+ * The callables the environment declares, one entry per function.
+ *
+ * Read off `getDefinitions()` rather than a curated list, exactly as the call
+ * classifier does — so a function the registry gained is offered without this
+ * module being told, and one it never had is never offered. Overloads are
+ * folded into their function; see {@link CelFunctionSymbol}.
+ */
+export declare function celFunctions(scope: CelScope): CelFunctionSymbol[];
+//# sourceMappingURL=symbols.d.ts.map

package/dist/cel/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../src/cel/symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;iCAGiC;AACjC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB;;6DAEyD;IACzD,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;4CACwC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;uEACuE;AACvE,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgB1F;AASD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAAE,CAoB3D;AAcD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAc/E;AAED;;2CAE2C;AAC3C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,SAAS,CAanF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,iBAAiB,EAAE,CAkBjE"}

package/dist/cel/symbols.js

@@ -0,0 +1,147 @@
+import { navigateSchema } from "../completions/detect-context.js";
+/** The type a schema node declares, rendered for display. Unions are joined
+ *  rather than collapsed — a slot admitting several shapes says so. */
+export function schemaTypeName(schema) {
+    if (!schema)
+        return undefined;
+    const valueType = schema["x-telo-type"];
+    if (typeof valueType === "string")
+        return valueType;
+    if (valueType && typeof valueType === "object" && typeof valueType.name === "string") {
+        return valueType.name;
+    }
+    const t = schema.type;
+    if (Array.isArray(t))
+        return t.join(" | ");
+    if (typeof t === "string")
+        return t;
+    if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+        const branches = (schema.anyOf ?? schema.oneOf);
+        const names = branches.map((b) => schemaTypeName(b)).filter(Boolean);
+        if (names.length > 0)
+            return [...new Set(names)].join(" | ");
+    }
+    return undefined;
+}
+/** The context's property map, or an empty one when the site is typed by the
+ *  environment alone. */
+function contextProperties(scope) {
+    const props = scope.contextSchema?.properties;
+    return props && typeof props === "object" ? props : {};
+}
+/**
+ * The names an expression may start with.
+ *
+ * Both sources, because neither is complete: the context schema carries the
+ * scope's own bindings (`steps`, `error`, a kind's named bindings, a transport's
+ * `request`), while the environment carries what was registered onto it
+ * directly — which is where the kernel globals live when no context applied.
+ * A name in both takes its schema from the context, which is the narrower.
+ */
+export function celRootSymbols(scope) {
+    const out = new Map();
+    for (const variable of scope.env.getDefinitions().variables) {
+        out.set(variable.name, {
+            name: variable.name,
+            type: variable.type,
+            description: variable.description ?? undefined,
+        });
+    }
+    for (const [name, schema] of Object.entries(contextProperties(scope))) {
+        const node = schema;
+        out.set(name, {
+            name,
+            type: schemaTypeName(node) ?? out.get(name)?.type,
+            schema: node,
+            description: typeof node.description === "string" ? node.description : out.get(name)?.description,
+        });
+    }
+    return [...out.values()];
+}
+/** The schema at a dotted path from the scope root, or undefined when the path
+ *  leaves what the context declares. Navigation is the shared schema walk, so a
+ *  member reached through an array, a `$ref` or an `anyOf` branch resolves the
+ *  same way it does for a structural field. */
+function schemaAtPath(scope, parts) {
+    if (parts.length === 0)
+        return scope.contextSchema ?? undefined;
+    const root = contextProperties(scope)[parts[0]];
+    if (!root)
+        return undefined;
+    if (parts.length === 1)
+        return root;
+    return navigateSchema(root, parts.slice(1));
+}
+/**
+ * The members available after `prefix`.
+ *
+ * Empty when the prefix resolves to nothing OR to something whose shape the
+ * scope does not declare — an open node, a live value, a permissive contract.
+ * That is the honest answer: offering a guess here would be offering names the
+ * checker has no opinion about, which is exactly what the shared scope rule
+ * exists to prevent.
+ */
+export function celMemberSymbols(scope, prefix) {
+    if (prefix.length === 0)
+        return celRootSymbols(scope);
+    const node = schemaAtPath(scope, prefix);
+    const props = node?.properties;
+    if (!props || typeof props !== "object")
+        return [];
+    return Object.entries(props).map(([name, raw]) => {
+        const child = raw;
+        return {
+            name,
+            type: schemaTypeName(child),
+            schema: child,
+            description: typeof child.description === "string" ? child.description : undefined,
+        };
+    });
+}
+/** What the chain `parts` resolves to — used for hover, where the cursor sits on
+ *  one identifier of a complete chain and the symbol wanted is the one at that
+ *  identifier, not at the chain's tail. */
+export function celSymbolAt(scope, parts) {
+    if (parts.length === 0)
+        return undefined;
+    if (parts.length === 1) {
+        return celRootSymbols(scope).find((s) => s.name === parts[0]);
+    }
+    const schema = schemaAtPath(scope, parts);
+    if (!schema)
+        return undefined;
+    return {
+        name: parts[parts.length - 1],
+        type: schemaTypeName(schema),
+        schema,
+        description: typeof schema.description === "string" ? schema.description : undefined,
+    };
+}
+/**
+ * The callables the environment declares, one entry per function.
+ *
+ * Read off `getDefinitions()` rather than a curated list, exactly as the call
+ * classifier does — so a function the registry gained is offered without this
+ * module being told, and one it never had is never offered. Overloads are
+ * folded into their function; see {@link CelFunctionSymbol}.
+ */
+export function celFunctions(scope) {
+    const byKey = new Map();
+    for (const fn of scope.env.getDefinitions().functions) {
+        const key = `${fn.receiverType ?? ""}.${fn.name}`;
+        const existing = byKey.get(key);
+        if (existing) {
+            if (!existing.signatures.includes(fn.signature))
+                existing.signatures.push(fn.signature);
+            existing.description ??= fn.description ?? undefined;
+            continue;
+        }
+        byKey.set(key, {
+            name: fn.name,
+            signatures: [fn.signature],
+            receiverType: fn.receiverType,
+            description: fn.description ?? undefined,
+        });
+    }
+    return [...byKey.values()];
+}

package/dist/cel/tokens.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Semantic tokens for the inside of a CEL body.
+ *
+ * A `!cel "..."` scalar is not a string, and under a stock YAML grammar it is
+ * painted as one. Colouring it through the SEMANTIC layer rather than a grammar
+ * is what makes one implementation serve both hosts — VS Code and the editor's
+ * Monaco already share `buildSemanticTokens`, while a Monarch tokenizer beside
+ * the TextMate one would be a second CEL lexer to keep in agreement.
+ *
+ * It is also the only layer that can be right about NAMES. A grammar knows the
+ * seven kernel roots someone hardcoded into it, which is why `request` and
+ * `steps` go uncoloured today; the scope query knows what is actually in scope
+ * at this exact site. So a name the scope confirms is coloured and a name it
+ * cannot is left alone — the quiet signal an unresolved `kind:` already gives.
+ */
+import { type CelScope, type CelSegment } from "@telorun/analyzer";
+import type { SemanticTokenType } from "../types.js";
+/** A token before it is placed on a line — document offsets, resolved by the
+ *  caller which owns the line table. */
+export interface CelTokenSpan {
+    range: [number, number];
+    type: SemanticTokenType;
+}
+/**
+ * Tokens for one CEL segment.
+ *
+ * A body that does not parse yields nothing: mid-typing is the normal case
+ * here, and the analyzer reports the syntax error itself. Only that failure is
+ * tolerated — a defect in the CEL wrapper propagates.
+ */
+export declare function celSegmentTokens(text: string, segment: CelSegment, scope: CelScope | undefined): CelTokenSpan[];
+//# sourceMappingURL=tokens.d.ts.map

package/dist/cel/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/cel/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAA+B,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAChG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD;wCACwC;AACxC,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAeD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,QAAQ,GAAG,SAAS,GAC1B,YAAY,EAAE,CAqHhB"}

package/dist/cel/tokens.js

@@ -0,0 +1,162 @@
+/**
+ * Semantic tokens for the inside of a CEL body.
+ *
+ * A `!cel "..."` scalar is not a string, and under a stock YAML grammar it is
+ * painted as one. Colouring it through the SEMANTIC layer rather than a grammar
+ * is what makes one implementation serve both hosts — VS Code and the editor's
+ * Monaco already share `buildSemanticTokens`, while a Monarch tokenizer beside
+ * the TextMate one would be a second CEL lexer to keep in agreement.
+ *
+ * It is also the only layer that can be right about NAMES. A grammar knows the
+ * seven kernel roots someone hardcoded into it, which is why `request` and
+ * `steps` go uncoloured today; the scope query knows what is actually in scope
+ * at this exact site. So a name the scope confirms is coloured and a name it
+ * cannot is left alone — the quiet signal an unresolved `kind:` already gives.
+ */
+import { CelParseError } from "@telorun/analyzer";
+import { flattenChain } from "../cel-chain.js";
+import { celRootSymbols, celSymbolAt } from "./symbols.js";
+const LITERAL_TYPE = (value) => {
+    if (typeof value === "number" || typeof value === "bigint")
+        return "number";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "boolean" || value === null)
+        return "keyword";
+    return undefined;
+};
+/**
+ * Tokens for one CEL segment.
+ *
+ * A body that does not parse yields nothing: mid-typing is the normal case
+ * here, and the analyzer reports the syntax error itself. Only that failure is
+ * tolerated — a defect in the CEL wrapper propagates.
+ */
+export function celSegmentTokens(text, segment, scope) {
+    let ast;
+    try {
+        ast = segment.ast();
+    }
+    catch (error) {
+        if (!(error instanceof CelParseError))
+            throw error;
+        return [];
+    }
+    const out = [];
+    const mode = scope ? "scoped" : "syntactic";
+    // Resolved once per SEGMENT, not once per name: the root set is a property of
+    // the scope, and this runs over the whole document on every token request.
+    const inScope = scope ? new Set(celRootSymbols(scope).map((s) => s.name)) : undefined;
+    /** True when the scope confirms the chain `parts`. Callers walk a chain
+     *  left-to-right and stop at the first unconfirmed hop, so each name is
+     *  resolved once rather than the chain being re-walked from its root per hop. */
+    const confirms = (parts) => {
+        if (mode === "syntactic")
+            return true;
+        if (parts.length === 1)
+            return inScope.has(parts[0]);
+        return celSymbolAt(scope, parts) !== undefined;
+    };
+    /** The span of `name` between two offsets, or undefined when it is not there
+     *  (a receiver-style call written across an unexpected layout). Nothing is
+     *  invented: a token placed on a guessed span would paint the wrong text. */
+    const spanOf = (name, from, to) => {
+        const at = text.indexOf(name, from);
+        return at >= 0 && at + name.length <= to ? [at, at + name.length] : undefined;
+    };
+    const visit = (node) => {
+        switch (node.kind) {
+            case "literal": {
+                const type = LITERAL_TYPE(node.value);
+                if (type)
+                    out.push({ range: node.range, type });
+                return;
+            }
+            case "ident":
+                // A root-position name is a scope the runtime injects, not data the
+                // author declared — see `SemanticTokenType`.
+                if (confirms([node.name]))
+                    out.push({ range: node.range, type: "namespace" });
+                return;
+            case "member": {
+                // A plain chain is resolved as a whole, so each hop is judged against
+                // what the one before it declared — `resources.db.url` colours `db` only
+                // if `resources` really carries it. A chain rooted in something computed
+                // (`f().x`) flattens to nothing, and the scope has no opinion about it.
+                const parts = flattenChain(node);
+                if (parts) {
+                    // A hop the scope cannot confirm makes every hop past it unresolvable
+                    // too, so the walk STOPS there rather than re-resolving the rest — the
+                    // chain is resolved once, not once per hop.
+                    for (let i = 0; i < parts.length; i++) {
+                        if (!confirms(parts.slice(0, i + 1).map((p) => p.name)))
+                            break;
+                        out.push({ range: parts[i].range, type: i === 0 ? "namespace" : "property" });
+                    }
+                    return;
+                }
+                visit(node.target);
+                if (mode === "syntactic")
+                    out.push({ range: node.propertyRange, type: "property" });
+                return;
+            }
+            case "index":
+                visit(node.target);
+                visit(node.index);
+                return;
+            case "call": {
+                // `foo(...)` starts with its own name, so the head of the node IS the
+                // callee's span.
+                out.push({ range: [node.range[0], node.range[0] + node.name.length], type: "function" });
+                for (const arg of node.args)
+                    visit(arg);
+                return;
+            }
+            case "methodCall": {
+                visit(node.receiver);
+                const span = spanOf(node.name, node.receiver.range[1], node.range[1]);
+                if (span)
+                    out.push({ range: span, type: "function" });
+                for (const arg of node.args)
+                    visit(arg);
+                return;
+            }
+            case "list":
+                for (const item of node.items)
+                    visit(item);
+                return;
+            case "map":
+                for (const entry of node.entries) {
+                    visit(entry.key);
+                    visit(entry.value);
+                }
+                return;
+            case "ternary":
+                visit(node.cond);
+                visit(node.then);
+                visit(node.else);
+                return;
+            case "unary": {
+                const span = spanOf(node.op, node.range[0], node.operand.range[0]);
+                if (span)
+                    out.push({ range: span, type: "operator" });
+                visit(node.operand);
+                return;
+            }
+            case "binary": {
+                visit(node.left);
+                const span = spanOf(node.op, node.left.range[1], node.right.range[0]);
+                if (span)
+                    out.push({ range: span, type: "operator" });
+                visit(node.right);
+                return;
+            }
+        }
+        // Exhaustive by construction: a new `CelNode` variant fails the build here
+        // rather than going silently uncoloured.
+        const unhandled = node;
+        throw new Error(`Unhandled CEL node: ${JSON.stringify(unhandled)}`);
+    };
+    visit(ast);
+    return out;
+}

package/dist/completions/build.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 { CompletionResult, IdeEnvironmentAdapter } from "../types.js";
-export declare function buildCompletions(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, adapter?: IdeEnvironmentAdapter, docs?: AstDocument[]): Promise<CompletionResult[]>;
+export declare function buildCompletions(text: string, line: number, character: number, registry: AnalysisRegistry | undefined, adapter?: IdeEnvironmentAdapter, docs?: AstDocument[], 
+/** The host's analysis of the manifests it loaded. Required for anything
+ *  that has to resolve against the manifest SET — CEL completion, and a
+ *  target's declared inputs. */
+analysis?: ManifestAnalysis): Promise<CompletionResult[]>;
 //# sourceMappingURL=build.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/completions/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,gBAAgB,EAAE,KAAK,WAAW,EAAe,MAAM,mBAAmB,CAAC;AACrG,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AA8I3E,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAyB7B"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/completions/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEhB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAqK3E,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,WAAW,EAAE;AACpB;;gCAEgC;AAChC,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAuD7B"}

package/dist/completions/build.js

@@ -1,5 +1,8 @@
-import { parseToAst } from "@telorun/analyzer";
-import { detectContext, lookupRefConstraints } from "./detect-context.js";
+import { parseToAst, } from "@telorun/analyzer";
+import { callInputsAt } from "./call-inputs.js";
+import { celCompletions } from "./cel-completions.js";
+import { docIdentity } from "../doc-identity.js";
+import { detectContext, lookupRefConstraints, navigateSchema } from "./detect-context.js";
 import { importSourceCompletions } from "./import-source.js";
 import { propKeyCompletions } from "./prop-keys.js";
 import { CAPABILITY_VALUES } from "./valid-capabilities.js";
@@ -8,24 +11,10 @@ import { CAPABILITY_VALUES } from "./valid-capabilities.js";
  *  either is simply skipped; the analyzer remains the source of truth. */
 function extractInFileResources(docs) {
     const out = [];
-    const scalar = (node) => node?.kind === "scalar" && typeof node.value === "string" ? node.value : undefined;
     for (const doc of docs) {
-        if (doc.root?.kind !== "map")
-            continue;
-        let kind;
-        let name;
-        for (const pair of doc.root.entries) {
-            const key = scalar(pair.key);
-            if (key === "kind")
-                kind = scalar(pair.value);
-            else if (key === "metadata" && pair.value?.kind === "map") {
-                const meta = pair.value;
-                const nameEntry = meta.entries.find((e) => scalar(e.key) === "name");
-                name = scalar(nameEntry?.value);
-            }
-        }
-        if (kind && name)
-            out.push({ kind, name });
+        const identity = docIdentity(doc);
+        if (identity.kind && identity.name)
+            out.push({ kind: identity.kind, name: identity.name });
     }
     return out;
 }
@@ -78,7 +67,7 @@ function refConstrainedKinds(registry, parentDocKind, parentYamlPath) {
     const definition = registry.resolveDefinition(parentDocKind);
     if (!definition?.schema)
         return undefined;
-    const constraints = lookupRefConstraints(definition.schema, parentYamlPath);
+    const constraints = lookupRefConstraints(definition.schema, parentYamlPath, (from) => registry.resolveSchemaFrom(from, parentDocKind));
     if (constraints.length === 0)
         return undefined;
     const resolved = constraints.map((c) => registry.userFacingKindsForRef(c));
@@ -111,6 +100,33 @@ function kindCompletions(registry, docKind, yamlPath, replaceRange) {
     }
     return results;
 }
+/**
+ * The values a field's schema says it may take.
+ *
+ * `enum` is closed and `examples` open — the same distinction `propertyNames`
+ * carries for a map's keys, one level down. Nothing is offered when the schema
+ * declares neither, which is most slots.
+ */
+function valueSuggestions(registry, docKind, yamlPath, replaceRange) {
+    const definition = registry?.resolveDefinition(docKind);
+    if (!registry || !definition?.schema || yamlPath.length === 0)
+        return [];
+    const field = navigateSchema(definition.schema, yamlPath, (from) => registry.resolveSchemaFrom(from, docKind));
+    if (!field)
+        return [];
+    const closed = Array.isArray(field.enum) ? field.enum : undefined;
+    const values = closed ?? (Array.isArray(field.examples) ? field.examples : []);
+    return values
+        .filter((v) => v !== null && typeof v !== "object")
+        .map((value) => ({
+        label: String(value),
+        kind: "enumMember",
+        detail: closed ? "allowed value" : "known value",
+        // Whole-value replacement, so picking over a partially typed value leaves
+        // no suffix — the rule every other value completion here follows.
+        replaceRange,
+    }));
+}
 function capabilityCompletions() {
     return CAPABILITY_VALUES.map((cap) => ({
         label: cap,
@@ -118,7 +134,11 @@ function capabilityCompletions() {
         detail: "Telo capability",
     }));
 }
-export async function buildCompletions(text, line, character, registry, adapter, docs) {
+export async function buildCompletions(text, line, character, registry, adapter, docs, 
+/** The host's analysis of the manifests it loaded. Required for anything
+ *  that has to resolve against the manifest SET — CEL completion, and a
+ *  target's declared inputs. */
+analysis) {
     // 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.
@@ -131,10 +151,16 @@ export async function buildCompletions(text, line, character, registry, adapter,
     }
     if (ctx.type === "capability")
         return capabilityCompletions();
+    if (ctx.type === "value-suggestions") {
+        return valueSuggestions(registry, ctx.docKind, ctx.yamlPath, ctx.replaceRange);
+    }
+    if (ctx.type === "cel") {
+        return celCompletions(text, ctx.segment, ctx.offset, ctx.concretePath, docIdentity(astDocs[ctx.docIndex]), analysis?.celScope);
+    }
     if (ctx.type === "ref-name") {
         const definition = registry?.resolveDefinition(ctx.docKind);
-        const refConstraints = definition?.schema
-            ? lookupRefConstraints(definition.schema, ctx.yamlPath)
+        const refConstraints = registry && definition?.schema
+            ? lookupRefConstraints(definition.schema, ctx.yamlPath, (from) => registry.resolveSchemaFrom(from, ctx.docKind))
             : [];
         return refNameCompletions(astDocs, ctx.refKind, refConstraints, registry, ctx.replaceRange);
     }
@@ -144,5 +170,7 @@ export async function buildCompletions(text, line, character, registry, adapter,
         }
         return [];
     }
-    return propKeyCompletions(ctx.docKind, ctx.yamlPath, ctx.existingKeys, registry);
+    // A slot that IS an enclosing call's argument map completes from the target's
+    // declared inputs rather than from its own (open) schema.
+    return propKeyCompletions(ctx.docKind, ctx.yamlPath, ctx.existingKeys, registry, callInputsAt(registry, analysis, docIdentity(astDocs[ctx.docIndex]).kind ?? ctx.docKind, docIdentity(astDocs[ctx.docIndex]).name, ctx.concretePath));
 }

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

@@ -0,0 +1,25 @@
+/**
+ * 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 { type AnalysisRegistry, type ManifestAnalysis } from "@telorun/analyzer";
+/**
+ * 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 declare function callInputsAt(registry: AnalysisRegistry | undefined, analysis: ManifestAnalysis | undefined, docKind: string, resourceName: string | undefined, concretePath: string): Record<string, any> | undefined;
+//# sourceMappingURL=call-inputs.d.ts.map