@telorun/ide-support 0.20.1 → 0.21.0

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

@@ -19,6 +19,10 @@ export interface CelCursorChain {
      *  prefix's members are offered and functions are not. */
     member: boolean;
 }
+/** 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]`. */
+export declare function bodyStart(text: string, segment: CelSegment): number;
 /**
  * Split the text before the cursor into a resolved prefix and a partial token.
  *

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

@@ -1 +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"}
+{"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;AAED;;oEAEoE;AACpE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,MAAM,CAInE;AAID;;;;;;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

@@ -1,7 +1,7 @@
 /** 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) {
+export 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;

package/dist/cel/module-calls.d.ts

@@ -0,0 +1,56 @@
+/**
+ * **Module calls inside a CEL body** — `Self.total(items)`, `Billing.isStale(x)`.
+ *
+ * In the tree an editor parses, a module call is a receiver-style call whose
+ * receiver is a plain identifier naming a module: `Self`, the module's own name
+ * or an import alias. Which identifiers those are is the scope's answer
+ * (`CelScope.moduleNames`), never a guess from the spelling, and what a call
+ * resolves to is the analyzer's (`CelScope.moduleFunction`), so completion,
+ * hover, signature help and go-to-declaration all name the function `telo check`
+ * binds the call to.
+ */
+import { type CallableFlags, type CelNode, type CelScope, type ResolvedFunction } from "@telorun/analyzer";
+/** One module call written in a CEL body. */
+export interface ModuleCallSite {
+    node: Extract<CelNode, {
+        kind: "methodCall";
+    }>;
+    receiver: string;
+    name: string;
+    /** `Receiver.name`, as the analyzer keys a call. */
+    qualified: string;
+    receiverRange: [number, number];
+    /** The function name alone, in document offsets. */
+    nameRange: [number, number];
+}
+/** Whether `node` is a module call: a method call whose receiver is a plain
+ *  identifier `isModule` accepts. The one recognizer every editor feature reads,
+ *  mirroring the templating rule — `a.Billing.format(x)` is an ordinary method
+ *  call, since its receiver is a field access. */
+export declare function isModuleCallNode(node: CelNode, isModule: (receiver: string) => boolean): node is Extract<CelNode, {
+    kind: "methodCall";
+}> & {
+    receiver: Extract<CelNode, {
+        kind: "ident";
+    }>;
+};
+/** Every call in `ast` whose receiver `isModule` accepts. */
+export declare function moduleCallSites(text: string, ast: CelNode, isModule: (receiver: string) => boolean): ModuleCallSite[];
+/** The module call whose receiver or name the cursor is on — the innermost, when
+ *  one call's argument holds another. */
+export declare function moduleCallAt(text: string, ast: CelNode, offset: number, scope: CelScope): (ModuleCallSite & {
+    onReceiver: boolean;
+}) | undefined;
+/** A function's signature as a reader sees it, with each parameter's span inside
+ *  the label — the shape signature help highlights the active parameter by. */
+export declare function functionSignature(qualified: string, fn: ResolvedFunction): {
+    label: string;
+    parameters: Array<{
+        label: [number, number];
+        documentation?: string;
+    }>;
+};
+/** What a reader is told a function promises: its description and derived
+ *  determinism, naming the chain to the leaf that decided it. */
+export declare function describeFunction(fn: ResolvedFunction, flags: CallableFlags | undefined): string;
+//# sourceMappingURL=module-calls.d.ts.map

package/dist/cel/module-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-calls.d.ts","sourceRoot":"","sources":["../../src/cel/module-calls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAI3B,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC,CAAC;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,oDAAoD;IACpD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAYD;;;kDAGkD;AAClD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GACtC,IAAI,IAAI,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,GAAG;IACpD,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC/C,CAEA;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GACtC,cAAc,EAAE,CAgBlB;AAED;yCACyC;AACzC,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,GACd,CAAC,cAAc,GAAG;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,GAAG,SAAS,CAQxD;AAED;+EAC+E;AAC/E,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,gBAAgB,GACnB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAe3F;AAED;iEACiE;AACjE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,MAAM,CAiB/F"}

package/dist/cel/module-calls.js

@@ -0,0 +1,98 @@
+/**
+ * **Module calls inside a CEL body** — `Self.total(items)`, `Billing.isStale(x)`.
+ *
+ * In the tree an editor parses, a module call is a receiver-style call whose
+ * receiver is a plain identifier naming a module: `Self`, the module's own name
+ * or an import alias. Which identifiers those are is the scope's answer
+ * (`CelScope.moduleNames`), never a guess from the spelling, and what a call
+ * resolves to is the analyzer's (`CelScope.moduleFunction`), so completion,
+ * hover, signature help and go-to-declaration all name the function `telo check`
+ * binds the call to.
+ */
+import { renderChain, } from "@telorun/analyzer";
+import { walkCel } from "../cel-chain.js";
+import { schemaTypeName } from "./symbols.js";
+/** The span of a method's name after its receiver, read off the document text —
+ *  the parsed node carries no span for the name itself. */
+function nameRangeOf(text, node) {
+    const at = text.indexOf(node.name, node.receiver.range[1]);
+    return at >= 0 && at + node.name.length <= node.range[1] ? [at, at + node.name.length] : undefined;
+}
+/** Whether `node` is a module call: a method call whose receiver is a plain
+ *  identifier `isModule` accepts. The one recognizer every editor feature reads,
+ *  mirroring the templating rule — `a.Billing.format(x)` is an ordinary method
+ *  call, since its receiver is a field access. */
+export function isModuleCallNode(node, isModule) {
+    return node.kind === "methodCall" && node.receiver.kind === "ident" && isModule(node.receiver.name);
+}
+/** Every call in `ast` whose receiver `isModule` accepts. */
+export function moduleCallSites(text, ast, isModule) {
+    const out = [];
+    walkCel(ast, (node) => {
+        if (!isModuleCallNode(node, isModule))
+            return;
+        const nameRange = nameRangeOf(text, node);
+        if (!nameRange)
+            return;
+        out.push({
+            node,
+            receiver: node.receiver.name,
+            name: node.name,
+            qualified: `${node.receiver.name}.${node.name}`,
+            receiverRange: node.receiver.range,
+            nameRange,
+        });
+    });
+    return out;
+}
+/** The module call whose receiver or name the cursor is on — the innermost, when
+ *  one call's argument holds another. */
+export function moduleCallAt(text, ast, offset, scope) {
+    const within = (range) => offset >= range[0] && offset <= range[1];
+    let hit;
+    for (const site of moduleCallSites(text, ast, (receiver) => scope.moduleNames.has(receiver))) {
+        if (within(site.nameRange))
+            hit = { ...site, onReceiver: false };
+        else if (within(site.receiverRange))
+            hit = { ...site, onReceiver: true };
+    }
+    return hit;
+}
+/** A function's signature as a reader sees it, with each parameter's span inside
+ *  the label — the shape signature help highlights the active parameter by. */
+export function functionSignature(qualified, fn) {
+    let label = `${qualified}(`;
+    const parameters = [];
+    fn.params.forEach((param, index) => {
+        if (index > 0)
+            label += ", ";
+        const text = `${param.name}${param.optional ? "?" : ""}: ${schemaTypeName(param.schema) ?? "dyn"}`;
+        const description = param.schema?.description;
+        parameters.push({
+            label: [label.length, label.length + text.length],
+            ...(typeof description === "string" ? { documentation: description } : {}),
+        });
+        label += text;
+    });
+    label += `) → ${schemaTypeName(fn.returns) ?? fn.celType}`;
+    return { label, parameters };
+}
+/** What a reader is told a function promises: its description and derived
+ *  determinism, naming the chain to the leaf that decided it. */
+export function describeFunction(fn, flags) {
+    const lines = [];
+    const description = fn.manifest.metadata?.description;
+    if (typeof description === "string" && description)
+        lines.push(description);
+    if (flags) {
+        const facts = [];
+        facts.push(flags.deterministic
+            ? "deterministic"
+            : `non-deterministic${flags.nondeterministicVia.length ? ` (${renderChain(flags.nondeterministicVia)})` : ""}`);
+        if (flags.hostBacked) {
+            facts.push(`host-backed${flags.hostBackedVia.length ? ` (${renderChain(flags.hostBackedVia)})` : ""}`);
+        }
+        lines.push(facts.join(" · "));
+    }
+    return lines.join("\n\n");
+}

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

@@ -1 +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"}
+{"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;AAKrD;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,CA2HhB"}

package/dist/cel/tokens.js

@@ -15,6 +15,7 @@
  */
 import { CelParseError } from "@telorun/analyzer";
 import { flattenChain } from "../cel-chain.js";
+import { isModuleCallNode } from "./module-calls.js";
 import { celRootSymbols, celSymbolAt } from "./symbols.js";
 const LITERAL_TYPE = (value) => {
     if (typeof value === "number" || typeof value === "bigint")
@@ -113,7 +114,14 @@ export function celSegmentTokens(text, segment, scope) {
                 return;
             }
             case "methodCall": {
-                visit(node.receiver);
+                // A module call's receiver is a module — a namespace a function is called
+                // through — and never a value the scope could confirm as a root name.
+                if (scope && isModuleCallNode(node, (receiver) => scope.moduleNames.has(receiver))) {
+                    out.push({ range: node.receiver.range, type: "namespace" });
+                }
+                else {
+                    visit(node.receiver);
+                }
                 const span = spanOf(node.name, node.receiver.range[1], node.range[1]);
                 if (span)
                     out.push({ range: span, type: "function" });

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

@@ -1 +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"}
+{"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;AAKlE,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,CAmEpB"}

package/dist/completions/cel-completions.js

@@ -1,4 +1,5 @@
 import { celCursorChain } from "../cel/cursor-chain.js";
+import { describeFunction, functionSignature } from "../cel/module-calls.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
@@ -36,6 +37,20 @@ export function celCompletions(text, segment, offset, concretePath, target, quer
     const chain = celCursorChain(text, segment, offset);
     const prefix = chain?.prefix ?? [];
     if (chain?.member) {
+        // `<Module>.` offers the functions that module makes callable here — its own
+        // through `Self` or its name, an import's exported ones through the alias.
+        if (prefix.length === 1 && scope.moduleNames.has(prefix[0])) {
+            return scope.moduleFunctionsOf(prefix[0]).map(({ name, function: fn }) => {
+                const qualified = `${prefix[0]}.${name}`;
+                const about = describeFunction(fn, scope.moduleCallFlags(qualified));
+                return {
+                    label: name,
+                    kind: "value",
+                    detail: functionSignature(qualified, fn).label,
+                    ...(about ? { documentation: about } : {}),
+                };
+            });
+        }
         return celMemberSymbols(scope, prefix).map((s) => toResult(s));
     }
     const roots = celRootSymbols(scope);

package/dist/completions/valid-capabilities.d.ts

@@ -1,4 +1,4 @@
-export declare const CAPABILITY_VALUES: readonly ["Telo.Service", "Telo.Runnable", "Telo.Invocable", "Telo.Provider", "Telo.Mount", "Telo.Type"];
+export declare const CAPABILITY_VALUES: readonly ["Telo.Service", "Telo.Runnable", "Telo.Invocable", "Telo.Provider", "Telo.Mount", "Telo.Sink", "Telo.Callable", "Telo.Type"];
 /** One-line role summary per capability, surfaced on hover. Kept in sync with
  *  the capability list in `CLAUDE.md` / the kernel builtins. */
 export declare const CAPABILITY_DOCS: Record<string, string>;

package/dist/completions/valid-capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valid-capabilities.d.ts","sourceRoot":"","sources":["../../src/completions/valid-capabilities.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,0GAOpB,CAAC;AAEX;gEACgE;AAChE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOlD,CAAC"}
+{"version":3,"file":"valid-capabilities.d.ts","sourceRoot":"","sources":["../../src/completions/valid-capabilities.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,wIASpB,CAAC;AAEX;gEACgE;AAChE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWlD,CAAC"}

package/dist/completions/valid-capabilities.js

@@ -4,6 +4,8 @@ export const CAPABILITY_VALUES = [
     "Telo.Invocable",
     "Telo.Provider",
     "Telo.Mount",
+    "Telo.Sink",
+    "Telo.Callable",
     "Telo.Type",
 ];
 /** One-line role summary per capability, surfaced on hover. Kept in sync with
@@ -14,5 +16,7 @@ export const CAPABILITY_DOCS = {
     "Telo.Invocable": "Request handler: `invoke(inputs)` (scripts, endpoints).",
     "Telo.Provider": "Value-flow source: `init()` + optional `provide()` (config, secrets).",
     "Telo.Mount": "Mounted into a Service (HTTP APIs, middleware).",
+    "Telo.Sink": "Record-stream destination: `write(record)` + `flush()` / `flushSync()` / `close()`, written to directly rather than dispatched.",
+    "Telo.Callable": "Function: synchronous `call(args)` against a declared `params` / `returns` signature, called from CEL through a module name.",
     "Telo.Type": "Pure schema definition — no runtime instance.",
 };

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,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"}
+{"version":3,"file":"build-definition.d.ts","sourceRoot":"","sources":["../../src/definition/build-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAGhB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAYpD;;;;;;;;;;;;;;;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,CAsC9B"}

package/dist/definition/build-definition.js

@@ -1,9 +1,11 @@
-import { parseToAst, } from "@telorun/analyzer";
+import { CelParseError, parseToAst, } from "@telorun/analyzer";
+import { moduleCallAt } from "../cel/module-calls.js";
 import { resolveNodeAtPosition } from "../completions/resolve-node.js";
+import { docIdentity } from "../doc-identity.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 { locateImport, moduleForFile } from "./manifest-navigation.js";
 import { resolveCelTarget } from "./resolve-cel-target.js";
 import { isKindSlot, resolveKindTarget } from "./resolve-kind-target.js";
 import { resolveRefTarget } from "./resolve-ref-target.js";
@@ -34,6 +36,9 @@ analysis) {
         return undefined;
     const currentModule = moduleForFile(graph, currentFilePath) ?? graph.entry;
     if (resolved.cel) {
+        const call = moduleCallTarget(graph, currentModule, text, astDocs, resolved, analysis);
+        if (call !== NOT_A_MODULE_CALL)
+            return call;
         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
@@ -55,3 +60,42 @@ analysis) {
         return resolveKindTarget(graph, currentModule, split);
     return undefined;
 }
+const NOT_A_MODULE_CALL = Symbol("not a module call");
+/**
+ * A module call under the cursor navigates to the callable resource it binds
+ * to — resolved the way a `!ref` of the same spelling is, since a call names a
+ * resource through the same grammar — and its alias to the import declaring it.
+ * Needs the analysis: which receivers are modules is the scope's answer.
+ */
+function moduleCallTarget(graph, currentModule, text, docs, resolved, analysis) {
+    const query = analysis?.celScope;
+    if (!resolved.cel || !query)
+        return NOT_A_MODULE_CALL;
+    const identity = docIdentity(docs[resolved.docIndex]);
+    const resource = query.resourceFor(identity.kind, identity.name);
+    if (!resource)
+        return NOT_A_MODULE_CALL;
+    let ast;
+    try {
+        ast = resolved.cel.segment.ast();
+    }
+    catch (error) {
+        if (!(error instanceof CelParseError))
+            throw error;
+        return NOT_A_MODULE_CALL;
+    }
+    const scope = query.scopeAt(resource, resolved.concretePath ?? "");
+    const call = moduleCallAt(text, ast, resolved.cel.offset, scope);
+    if (!call)
+        return NOT_A_MODULE_CALL;
+    const imported = graph.importEdges.get(currentModule.owner.source)?.has(call.receiver) === true;
+    if (call.onReceiver)
+        return imported ? locateImport(currentModule, call.receiver) : undefined;
+    if (!scope.moduleFunction(call.qualified))
+        return undefined;
+    return resolveRefTarget(graph, currentModule, {
+        ...(imported ? { alias: call.receiver } : {}),
+        name: call.name,
+        onAlias: false,
+    });
+}

package/dist/diagnostics/normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/diagnostics/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI3E;;;;;;;;;;iDAUiD;AACjD,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,kBAAkB,EACrB,GAAG,EAAE,iBAAiB,GACrB,oBAAoB,CAiBtB"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/diagnostics/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI3E;;;;;;;;;;iDAUiD;AACjD,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,kBAAkB,EACrB,GAAG,EAAE,iBAAiB,GACrB,oBAAoB,CAyBtB"}

package/dist/diagnostics/normalize.js

@@ -14,7 +14,15 @@ import { resolveSeverity } from "./severity.js";
  *  editor for no difference the user can see. */
 export function normalizeDiagnostic(d, ctx) {
     const fix = diagnosticFix(d);
-    const suggestions = fix ? [{ kind: "replace", replacement: fix.replacement }] : undefined;
+    const suggestions = fix
+        ? [
+            {
+                kind: "replace",
+                replacement: fix.replacement,
+                ...(fix.tag ? { tag: fix.tag } : {}),
+            },
+        ]
+        : undefined;
     return {
         range: resolveRange(d, ctx),
         severity: resolveSeverity(d),

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,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"}
+{"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;AA+F/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,5 +1,6 @@
 import { CelParseError, parseToAst, readRefSlot, } from "@telorun/analyzer";
 import { chainAt } from "../cel-chain.js";
+import { describeFunction, functionSignature, moduleCallAt } from "../cel/module-calls.js";
 import { celSymbolAt } from "../cel/symbols.js";
 import { docIdentity } from "../doc-identity.js";
 import { navigateSchema } from "../completions/detect-context.js";
@@ -94,7 +95,7 @@ analysis) {
     if (!resolved)
         return undefined;
     if (resolved.cel) {
-        const hover = hoverForCel(resolved, astDocs, analysis?.celScope);
+        const hover = hoverForCel(text, 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.
@@ -114,7 +115,7 @@ analysis) {
  * still say what `steps.encode.result` IS even though nothing in the manifest
  * declares it.
  */
-function hoverForCel(resolved, docs, scopeQuery) {
+function hoverForCel(text, resolved, docs, scopeQuery) {
     if (!resolved.cel || !scopeQuery)
         return undefined;
     const identity = docIdentity(docs[resolved.docIndex]);
@@ -133,13 +134,26 @@ function hoverForCel(resolved, docs, scopeQuery) {
             throw error;
         return undefined;
     }
+    const scope = scopeQuery.scopeAt(resource, resolved.concretePath ?? "");
+    // A module call's name hovers as the function it binds to: its signature and
+    // what it promises about determinism.
+    const call = moduleCallAt(text, ast, resolved.cel.offset, scope);
+    if (call && !call.onReceiver) {
+        const fn = scope.moduleFunction(call.qualified);
+        if (!fn)
+            return undefined;
+        const lines = ["```\n" + functionSignature(call.qualified, fn).label + "\n```"];
+        const about = describeFunction(fn, scope.moduleCallFlags(call.qualified));
+        if (about)
+            lines.push("", about);
+        return { contents: lines.join("\n") };
+    }
     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;

package/dist/index.d.ts

@@ -5,7 +5,9 @@ export * from "./hover/index.js";
 export * from "./semantic-tokens/index.js";
 export * from "./definition/index.js";
 export * from "./rename/index.js";
+export * from "./signature-help/index.js";
 export * from "./import-upgrades/index.js";
 export * from "./workspace/index.js";
 export { walkCel, flattenChain, chainAt, type ChainPart } from "./cel-chain.js";
+export { functionSignature } from "./cel/module-calls.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AAIrC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AAIrC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhF,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -5,9 +5,13 @@ export * from "./hover/index.js";
 export * from "./semantic-tokens/index.js";
 export * from "./definition/index.js";
 export * from "./rename/index.js";
+export * from "./signature-help/index.js";
 export * from "./import-upgrades/index.js";
 export * from "./workspace/index.js";
 // The repo's single CEL-tree walk. Exported because every host that has to
 // answer "where is this name read" needs it and a second copy would be a second
 // answer — the editor asks it before deleting a resource.
 export { walkCel, flattenChain, chainAt } from "./cel-chain.js";
+// A function's signature as every surface renders it — hover, completion,
+// signature help and `telo cel functions` alike.
+export { functionSignature } from "./cel/module-calls.js";

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

@@ -1,4 +1,4 @@
-import { type AstDocument, type LoadedGraph } from "@telorun/analyzer";
+import { type AstDocument, type LoadedGraph, type ManifestAnalysis } from "@telorun/analyzer";
 import type { RenamePreparation, RenameResult } from "./types.js";
 /**
  * Rename a name and every reference to it.
@@ -35,5 +35,8 @@ import type { RenamePreparation, RenameResult } from "./types.js";
  */
 export declare function prepareRename(text: string, line: number, character: number, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[]): RenamePreparation;
 /** Prepare, validate the new name, then collect every edit. */
-export declare function buildRename(text: string, line: number, character: number, newName: string, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[]): RenameResult;
+export declare function buildRename(text: string, line: number, character: number, newName: string, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[], 
+/** Decides whether a resource's name denotes a type (a named shape) or a
+ *  value. Without it every resource name is checked as a value. */
+analysis?: ManifestAnalysis): RenameResult;
 //# sourceMappingURL=build-rename.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build-rename.d.ts","sourceRoot":"","sources":["../../src/rename/build-rename.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,WAAW,EAGhB,KAAK,WAAW,EAGjB,MAAM,mBAAmB,CAAC;AAa3B,OAAO,KAAK,EAGV,iBAAiB,EACjB,YAAY,EAEb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC3B,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,iBAAiB,CAsBnB;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,YAAY,CA0Bd"}
+{"version":3,"file":"build-rename.d.ts","sourceRoot":"","sources":["../../src/rename/build-rename.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,WAAW,EAGhB,KAAK,WAAW,EAEhB,KAAK,gBAAgB,EAGtB,MAAM,mBAAmB,CAAC;AAe3B,OAAO,KAAK,EAGV,iBAAiB,EACjB,YAAY,EAEb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC3B,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,iBAAiB,CAsBnB;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,IAAI,CAAC,EAAE,WAAW,EAAE;AACpB;mEACmE;AACnE,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,YAAY,CA2Bd"}

package/dist/rename/build-rename.js

@@ -2,7 +2,8 @@ import { CelParseError, buildLineOffsets, checkName, offsetToPosition, parseToAs
 import { chainAt } from "../cel-chain.js";
 import { resolveNodeAtPosition, scalarString } from "../completions/resolve-node.js";
 import { moduleDoc, moduleForFile, moduleFiles } from "../definition/manifest-navigation.js";
-import { declarationSites, resourceDeclarations, resourceSites, stepDeclarations, stepSites, } from "./find-sites.js";
+import { moduleCallSites } from "../cel/module-calls.js";
+import { declarationSites, functionCallSites, resourceDeclarations, resourceSites, stepDeclarations, stepSites, } from "./find-sites.js";
 /**
  * Rename a name and every reference to it.
  *
@@ -50,7 +51,7 @@ export function prepareRename(text, line, character, graph, currentFilePath, doc
         start: offsetToPosition(span[0], lineOffsets),
         end: offsetToPosition(span[1], lineOffsets),
     });
-    const symbol = symbolAt(resolved, astDocs, toRange);
+    const symbol = symbolAt(resolved, astDocs, toRange, text, ownReceivers(mod));
     if (!symbol)
         return { ok: false, reason: "Nothing renameable here." };
     if ("reason" in symbol)
@@ -59,25 +60,28 @@ export function prepareRename(text, line, character, graph, currentFilePath, doc
     return refusal ? { ok: false, reason: refusal } : { ok: true, symbol };
 }
 /** Prepare, validate the new name, then collect every edit. */
-export function buildRename(text, line, character, newName, graph, currentFilePath, docs) {
+export function buildRename(text, line, character, newName, graph, currentFilePath, docs, 
+/** Decides whether a resource's name denotes a type (a named shape) or a
+ *  value. Without it every resource name is checked as a value. */
+analysis) {
     const prepared = prepareRename(text, line, character, graph, currentFilePath, docs);
     if (!prepared.ok)
         return prepared;
     const { symbol } = prepared;
     if (newName === symbol.name)
         return { ok: true, symbol, files: [] };
-    // Every renameable surface is value-level, so the new name is checked against
-    // that half of the convention — the same rule `telo check` enforces. Renaming
-    // *into* a name the analyzer would reject is a mistake worth catching in the
-    // rename box rather than as a squiggle afterwards.
-    const violation = checkName(newName, "value", surfaceLabel(symbol));
+    const mod = moduleForFile(graph, currentFilePath);
+    // The new name is checked against the half of the convention its declaration
+    // belongs to — the same rule `telo check` enforces. Renaming *into* a name the
+    // analyzer would reject is a mistake worth catching in the rename box rather
+    // than as a squiggle afterwards.
+    const violation = checkName(newName, nameLevelOf(symbol, mod, analysis), surfaceLabel(symbol));
     if (violation)
         return { ok: false, reason: violation.message };
-    const mod = moduleForFile(graph, currentFilePath);
     const files = filesForRename(symbol, mod, currentFilePath, text, docs);
     const out = [];
     for (const file of files) {
-        const edits = editsIn(file, symbol, newName);
+        const edits = editsIn(file, symbol, newName, ownReceivers(mod));
         if (edits.length > 0)
             out.push({ uri: file.uri, edits });
     }
@@ -86,6 +90,22 @@ export function buildRename(text, line, character, newName, graph, currentFilePa
     }
     return { ok: true, symbol, files: out };
 }
+/** Steps and config keys are values; a resource is whatever its capability makes
+ *  it — a named shape's name is a type. */
+function nameLevelOf(symbol, mod, analysis) {
+    if (symbol.kind !== "resource" || !analysis)
+        return "value";
+    const sources = new Set(moduleFiles(mod).map((file) => file.source));
+    const declaration = analysis.manifests.find((m) => m.metadata?.name === symbol.name &&
+        sources.has(m.metadata?.source ?? ""));
+    return declaration ? analysis.nameLevel(declaration) : "value";
+}
+/** The receivers a module call names a function of THIS module through: `Self`
+ *  and the module's own name. */
+function ownReceivers(mod) {
+    const name = moduleDoc(mod)?.metadata?.name;
+    return new Set(typeof name === "string" && name ? ["Self", name] : ["Self"]);
+}
 const DECLARATION_BLOCKS = new Set(["variables", "secrets", "ports"]);
 const MODULE_DOC_KINDS = new Set(["Telo.Application", "Telo.Library"]);
 const KIND_DOC_KINDS = new Set(["Telo.Definition", "Telo.Abstract"]);
@@ -93,9 +113,9 @@ const SELF_PREFIX = "Self.";
 /** Dispatch on what the cursor sits IN rather than on the field it is under —
  *  the posture `buildDefinition` takes, so the two features agree about what a
  *  given position means. */
-function symbolAt(resolved, astDocs, toRange) {
+function symbolAt(resolved, astDocs, toRange, text, receivers) {
     if (resolved.cel)
-        return celSymbol(resolved.cel, toRange);
+        return celSymbol(resolved.cel, toRange, text, receivers);
     const path = resolved.path;
     const node = resolved.node;
     // A key inside `variables:` / `secrets:` / `ports:` on the module doc.
@@ -176,7 +196,7 @@ function symbolAt(resolved, astDocs, toRange) {
 }
 /** A CEL chain root that names a renameable scope, with the cursor on its
  *  member. Anything deeper is a field of a resolved value, not a declaration. */
-function celSymbol(cel, toRange) {
+function celSymbol(cel, toRange, text, receivers) {
     let ast;
     try {
         ast = cel.segment.ast();
@@ -186,6 +206,10 @@ function celSymbol(cel, toRange) {
             throw error;
         return undefined;
     }
+    // A call of one of this module's functions renames the function resource.
+    const call = moduleCallSites(text, ast, (receiver) => receivers.has(receiver)).find((site) => cel.offset >= site.nameRange[0] && cel.offset <= site.nameRange[1]);
+    if (call)
+        return { kind: "resource", name: call.name, range: toRange(call.nameRange) };
     const hit = chainAt(ast, cel.offset);
     if (!hit || hit.index !== 1)
         return undefined;
@@ -312,7 +336,7 @@ function filesForRename(symbol, mod, currentFilePath, text, docs) {
     }
     return [];
 }
-function editsIn(file, symbol, newName) {
+function editsIn(file, symbol, newName, receivers) {
     const lineOffsets = buildLineOffsets(file.text);
     const spans = [];
     for (const doc of file.docs) {
@@ -321,6 +345,9 @@ function editsIn(file, symbol, newName) {
                 spans.push(span);
             for (const site of resourceSites(doc, symbol.name))
                 spans.push(site.range);
+            for (const site of functionCallSites(doc, file.text, receivers, symbol.name)) {
+                spans.push(site.range);
+            }
             for (const span of exportEntrySpans(doc, symbol.name))
                 spans.push(span);
         }

package/dist/rename/find-sites.d.ts

@@ -22,6 +22,11 @@ export interface NameSite {
 /** A resource's references within one document: `!ref <name>` (and its `Self.`
  *  form) plus `resources.<name>` in CEL. */
 export declare function resourceSites(doc: AstDocument, name: string): NameSite[];
+/** A function's calls within one document: `<receiver>.<name>(…)` in CEL, for a
+ *  receiver naming the declaring module itself (`Self`, its own name). A call
+ *  through an import alias is another module's reference and is not matched.
+ *  `text` is the document text the CEL offsets are measured against. */
+export declare function functionCallSites(doc: AstDocument, text: string, receivers: ReadonlySet<string>, name: string): NameSite[];
 /** A step's references within its declaring document: `steps.<name>` in CEL.
  *  Deliberately document-scoped — `steps.<name>.result` is readable only inside
  *  the resource whose body declares the step, and a resource is one document. */