@telorun/ide-support 0.13.3 → 0.14.0

package/dist/cel-chain.d.ts

@@ -0,0 +1,36 @@
+import type { CelNode } from "@telorun/analyzer";
+/** One identifier of a dotted CEL chain, with the span a cursor hit-tests
+ *  against and a rename replaces. */
+export interface ChainPart {
+    name: string;
+    range: [number, number];
+}
+/**
+ * Flatten `a.b.c` into its identifiers. Returns undefined as soon as the chain
+ * is rooted in something other than a plain identifier (a call, an index), so a
+ * navigable — or renameable — prefix is never invented out of a computed
+ * expression.
+ */
+export declare function flattenChain(node: CelNode): ChainPart[] | undefined;
+/**
+ * A node's children.
+ *
+ * Exhaustive by construction: a new `CelNode` variant fails the build here
+ * rather than silently going unwalked, so the analyzer's node model and the
+ * walks over it cannot drift apart unnoticed. That matters twice over — for
+ * go-to-definition an unwalked variant is a missed jump, for a rename it is a
+ * reference left pointing at the old name.
+ */
+export declare function celChildren(node: CelNode): CelNode[];
+/** Every node of the tree, outermost first. */
+export declare function walkCel(node: CelNode, visit: (node: CelNode) => void): void;
+/**
+ * The dotted chain under `offset`, and which of its identifiers was hit. The
+ * walk is outermost-first so the longest chain wins — `resources.store.conn`
+ * resolves as one chain rather than as its `resources.store` prefix.
+ */
+export declare function chainAt(node: CelNode, offset: number): {
+    parts: ChainPart[];
+    index: number;
+} | undefined;
+//# sourceMappingURL=cel-chain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cel-chain.d.ts","sourceRoot":"","sources":["../src/cel-chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD;qCACqC;AACrC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,EAAE,GAAG,SAAS,CAKnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,EAAE,CA0BpD;AAED,+CAA+C;AAC/C,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAG3E;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAYnD"}

package/dist/cel-chain.js

@@ -0,0 +1,77 @@
+/**
+ * Flatten `a.b.c` into its identifiers. Returns undefined as soon as the chain
+ * is rooted in something other than a plain identifier (a call, an index), so a
+ * navigable — or renameable — prefix is never invented out of a computed
+ * expression.
+ */
+export function flattenChain(node) {
+    if (node.kind === "ident")
+        return [{ name: node.name, range: node.range }];
+    if (node.kind !== "member")
+        return undefined;
+    const head = flattenChain(node.target);
+    return head ? [...head, { name: node.property, range: node.propertyRange }] : undefined;
+}
+/**
+ * A node's children.
+ *
+ * Exhaustive by construction: a new `CelNode` variant fails the build here
+ * rather than silently going unwalked, so the analyzer's node model and the
+ * walks over it cannot drift apart unnoticed. That matters twice over — for
+ * go-to-definition an unwalked variant is a missed jump, for a rename it is a
+ * reference left pointing at the old name.
+ */
+export function celChildren(node) {
+    switch (node.kind) {
+        case "literal":
+        case "ident":
+            return [];
+        case "member":
+            return [node.target];
+        case "index":
+            return [node.target, node.index];
+        case "call":
+            return node.args;
+        case "methodCall":
+            return [node.receiver, ...node.args];
+        case "list":
+            return node.items;
+        case "map":
+            return node.entries.flatMap((e) => [e.key, e.value]);
+        case "ternary":
+            return [node.cond, node.then, node.else];
+        case "unary":
+            return [node.operand];
+        case "binary":
+            return [node.left, node.right];
+    }
+    const unhandled = node;
+    throw new Error(`Unhandled CEL node: ${JSON.stringify(unhandled)}`);
+}
+/** Every node of the tree, outermost first. */
+export function walkCel(node, visit) {
+    visit(node);
+    for (const child of celChildren(node))
+        walkCel(child, visit);
+}
+/**
+ * The dotted chain under `offset`, and which of its identifiers was hit. The
+ * walk is outermost-first so the longest chain wins — `resources.store.conn`
+ * resolves as one chain rather than as its `resources.store` prefix.
+ */
+export function chainAt(node, offset) {
+    if (offset < node.range[0] || offset > node.range[1])
+        return undefined;
+    const parts = flattenChain(node);
+    if (parts) {
+        const index = parts.findIndex((p) => offset >= p.range[0] && offset <= p.range[1]);
+        if (index >= 0)
+            return { parts, index };
+    }
+    for (const child of celChildren(node)) {
+        const hit = chainAt(child, offset);
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}

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

@@ -44,11 +44,11 @@ export type CompletionCtx = {
     replaceRange: ReplaceRange;
 };
 /** Navigate a JSON Schema hierarchy following `path`, auto-descending into
- *  array items and peeling `anyOf` / `oneOf` branches. 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. */
+ *  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;
 /** 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

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;AAuBN;;;;;sCAKsC;AACtC,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,CA4BjC;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,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"}

package/dist/completions/detect-context.js

@@ -24,15 +24,66 @@ function peelCombinators(node) {
     visit(node);
     return out;
 }
+/** One JSON Pointer segment: RFC 6901 escapes, then percent-decoding, which a
+ *  pointer carried in a URI fragment is subject to. A malformed escape is
+ *  returned raw rather than thrown — `decodeURIComponent` raises `URIError`, and
+ *  a stray `%` in someone's `$defs` key must not take completion down. */
+function decodePointerSegment(segment) {
+    const unescaped = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+    try {
+        return decodeURIComponent(unescaped);
+    }
+    catch {
+        return unescaped;
+    }
+}
+/**
+ * Follow a document-local `$ref` (`#/$defs/<Name>`) against the schema root.
+ *
+ * The one reference form that occurs inside a kind schema, and the one the
+ * editor's resolver accepts — a schema-valued slot points at the hoisted
+ * `JsonSchema7` / `KindSchema` fragment this way, and the fragment points at
+ * itself to describe a nested schema. Without the hop, completion stopped dead
+ * at the first key of every `schema:` / `status:` block.
+ *
+ * A chain ends at a REPEATED pointer, which is what bounds the walk: a
+ * self-referential fragment is the normal case here, so a cycle must degrade to
+ * "no completion" rather than hang the editor.
+ */
+function resolveLocalRef(node, root) {
+    let current = node;
+    const seen = new Set();
+    while (current && typeof current.$ref === "string" && current.$ref.startsWith("#/")) {
+        const pointer = current.$ref;
+        if (seen.has(pointer))
+            return undefined;
+        seen.add(pointer);
+        let target = root;
+        for (const segment of pointer.slice(2).split("/")) {
+            target = target?.[decodePointerSegment(segment)];
+        }
+        if (!target || typeof target !== "object")
+            return undefined;
+        // Keep whatever the slot declared beside the `$ref` (its title, its
+        // `x-telo-fragment` stamp) — that is what tells a consumer WHICH shape it
+        // pointed at, and draft-07 drops it at the validation layer only.
+        const { $ref: _, ...siblings } = current;
+        current = { ...target, ...siblings };
+    }
+    return current;
+}
 /** Navigate a JSON Schema hierarchy following `path`, auto-descending into
- *  array items and peeling `anyOf` / `oneOf` branches. 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. */
+ *  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) {
     let current = schema;
     for (const segment of path) {
+        current = resolveLocalRef(current, schema);
+        if (!current)
+            return undefined;
         const candidates = peelCombinators(current).flatMap((node) => {
             const expanded = [];
             let cur = node;
@@ -50,10 +101,26 @@ export function navigateSchema(schema, path) {
                 break;
             }
         }
+        // A map-valued node (a schema's `properties:`, a kind's name-keyed field)
+        // names its entries nowhere, so every segment lands on
+        // `additionalProperties`. Without this the walk stopped one level into a
+        // `schema:` block — at exactly the field the author is writing.
+        if (!next) {
+            for (const cand of candidates) {
+                const additional = cand.additionalProperties;
+                if (additional && typeof additional === "object") {
+                    next = additional;
+                    break;
+                }
+            }
+        }
         if (!next)
             return undefined;
         current = next;
     }
+    current = resolveLocalRef(current, schema);
+    if (!current)
+        return undefined;
     // Auto-descend through a trailing array at the leaf (e.g. cursor inside `mounts:` items)
     while (current.type === "array" && current.items) {
         current = current.items;

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

@@ -1,4 +1,4 @@
-import type { AnalysisRegistry } from "@telorun/analyzer";
+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[];
 //# 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,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,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,GACrC,gBAAgB,EAAE,CAkCpB"}

package/dist/completions/prop-keys.js

@@ -1,3 +1,4 @@
+import { manifestFragmentOf, TELO_SCHEMA_ANNOTATIONS, } from "@telorun/analyzer";
 import { navigateSchema } from "./detect-context.js";
 /** Kernel-implicit fields. Every Telo resource declares its `kind` and a
  *  `metadata` object; the analyzer's schema validator injects them when
@@ -37,9 +38,25 @@ export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
     const required = new Set(Array.isArray(targetSchema.required) ? targetSchema.required : []);
     const properties = yamlPath.length === 0
         ? { ...ROOT_IMPLICIT_PROPS, ...targetSchema.properties }
-        : targetSchema.properties;
+        : { ...targetSchema.properties, ...annotationKeys(targetSchema) };
     return buildItems(properties, existingKeys, required);
 }
+/**
+ * The `x-telo-*` vocabulary, offered only inside a KIND's own schema.
+ *
+ * Read off the fragment stamp rather than the position: a kind schema nests, so
+ * "am I inside one" is a fact about the node, not about how deep the cursor
+ * sits. A plain data schema — an `inputType:`, a `status:` block — stamps
+ * `JsonSchema7` and gets nothing, because an annotation there configures a slot
+ * that does not exist.
+ *
+ * The vocabulary lives on the analyzer side and never enters a manifest: a
+ * `properties` map holding a literal `x-telo-ref` key reads to the annotation
+ * walkers as an annotated node.
+ */
+function annotationKeys(node) {
+    return manifestFragmentOf(node) === "KindSchema" ? TELO_SCHEMA_ANNOTATIONS : {};
+}
 function buildItems(properties, existingKeys, required) {
     const items = [];
     for (const [prop, propSchema] of Object.entries(properties)) {

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

@@ -1 +1 @@
-{"version":3,"file":"resolve-cel-target.d.ts","sourceRoot":"","sources":["../../src/definition/resolve-cel-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAwGpD;;;;;;;;;;;;oBAYoB;AACpB,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,SAAS,CAqB9B"}
+{"version":3,"file":"resolve-cel-target.d.ts","sourceRoot":"","sources":["../../src/definition/resolve-cel-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqCpD;;;;;;;;;;;;oBAYoB;AACpB,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,SAAS,CAqB9B"}

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

@@ -1,69 +1,10 @@
 import { CelParseError, } from "@telorun/analyzer";
 import { locateImport, locateModuleDocKey, locateResource, moduleFiles, } from "./manifest-navigation.js";
 import { resolveExportedResource } from "./resolve-export-chain.js";
+import { chainAt } from "../cel-chain.js";
 /** Root CEL scopes whose members are declared as a block on the module doc, so
  *  `variables.port` navigates to `variables:` and then to its `port:` entry. */
 const DECLARATION_SCOPES = new Set(["variables", "secrets", "ports"]);
-/** Flatten `a.b.c` into its identifiers. Returns undefined as soon as the chain
- *  is rooted in something other than a plain identifier (a call, an index), so a
- *  navigable prefix is never invented out of a computed expression. */
-function flattenChain(node) {
-    if (node.kind === "ident")
-        return [{ name: node.name, range: node.range }];
-    if (node.kind !== "member")
-        return undefined;
-    const head = flattenChain(node.target);
-    return head ? [...head, { name: node.property, range: node.propertyRange }] : undefined;
-}
-/** Exhaustive by construction: a new `CelNode` variant fails the build here
- *  rather than silently going unwalked, so the analyzer's node model and this
- *  walk cannot drift apart unnoticed. */
-function celChildren(node) {
-    switch (node.kind) {
-        case "literal":
-        case "ident":
-            return [];
-        case "member":
-            return [node.target];
-        case "index":
-            return [node.target, node.index];
-        case "call":
-            return node.args;
-        case "methodCall":
-            return [node.receiver, ...node.args];
-        case "list":
-            return node.items;
-        case "map":
-            return node.entries.flatMap((e) => [e.key, e.value]);
-        case "ternary":
-            return [node.cond, node.then, node.else];
-        case "unary":
-            return [node.operand];
-        case "binary":
-            return [node.left, node.right];
-    }
-    const unhandled = node;
-    throw new Error(`Unhandled CEL node: ${JSON.stringify(unhandled)}`);
-}
-/** The dotted chain under `offset`, and which of its identifiers was hit. The
- *  walk is outermost-first so the longest chain wins — `resources.Store.conn`
- *  resolves as one chain rather than as its `resources.Store` prefix. */
-function chainAt(node, offset) {
-    if (offset < node.range[0] || offset > node.range[1])
-        return undefined;
-    const parts = flattenChain(node);
-    if (parts) {
-        const index = parts.findIndex((p) => offset >= p.range[0] && offset <= p.range[1]);
-        if (index >= 0)
-            return { parts, index };
-    }
-    for (const child of celChildren(node)) {
-        const hit = chainAt(child, offset);
-        if (hit)
-            return hit;
-    }
-    return undefined;
-}
 /** `resources.<name>` is a local instance; `resources.<Alias>.<name>` is an
  *  imported module's exported one. A local name wins over an import alias, so a
  *  deeper access on a local instance (`resources.db.url`) reads as a field of

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from "./diagnostics/index.js";
 export * from "./hover/index.js";
 export * from "./semantic-tokens/index.js";
 export * from "./definition/index.js";
+export * from "./rename/index.js";
 export * from "./import-upgrades/index.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,4BAA4B,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,4BAA4B,CAAC"}

package/dist/index.js

@@ -4,4 +4,5 @@ export * from "./diagnostics/index.js";
 export * from "./hover/index.js";
 export * from "./semantic-tokens/index.js";
 export * from "./definition/index.js";
+export * from "./rename/index.js";
 export * from "./import-upgrades/index.js";

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

@@ -0,0 +1,39 @@
+import { type AstDocument, type LoadedGraph } from "@telorun/analyzer";
+import type { RenamePreparation, RenameResult } from "./types.js";
+/**
+ * Rename a name and every reference to it.
+ *
+ * **This is a refactor, not a fix**, and the distinction is the reason it lives
+ * here rather than behind a `DiagnosticFix`. A fix is a whole-value replacement
+ * for ONE node, verified by the diagnostic that produced it; a rename is only
+ * correct when every reference moves with it, which means the operation's unit
+ * is the reference graph, not the node. Renaming `metadata.name` alone leaves
+ * every `!ref`, `resources.<name>` and `steps.<name>.result` pointing at a name
+ * that no longer exists — so a rename offered as a quick fix would break the
+ * file it claimed to repair.
+ *
+ * **Three renameable surfaces, and every other one is an explicit refusal.**
+ * What they have in common is that their reference set is *enumerable from this
+ * workspace*: a resource instance, a step, and a `variables:` / `secrets:` /
+ * `ports:` key are all module-local. A kind name, a module name and an import
+ * alias are not supported yet — their references reach schema annotations
+ * (`x-telo-ref`, `extends`, `exports.kinds`) as alias-qualified halves of a
+ * larger value, which is a materially bigger surface than a bare identifier and
+ * wants its own pass.
+ *
+ * **A name in `exports.resources` is refused outright**, and that is the load-
+ * bearing refusal. Such a name is the library's public ABI: a consumer writes
+ * `!ref Alias.name` and reads `resources.Alias.name`, in files this workspace
+ * may not contain and, for a published consumer, cannot. Renaming it is a
+ * breaking change to be *versioned*, not an edit to be applied — and a rename
+ * box that silently ships one would be the worst available framing.
+ *
+ * **Ambiguity is refused rather than guessed.** A name declared twice in reach
+ * (a `with:`-scoped resource shadowing a module-level one, two steps in one
+ * resource sharing a spelling) has references that resolve to different
+ * declarations, and no edit set is right for both.
+ */
+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;
+//# sourceMappingURL=build-rename.d.ts.map

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

@@ -0,0 +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"}