@telorun/ide-support 0.7.10 → 0.9.0

package/README.md

@@ -48,7 +48,9 @@ See [examples/](./examples/) for a list of working applications.
 
 ## Status
 
-Telo is under **active development**. The core runtime, module system, and standard library are functional, but the API surface — including YAML shapes — may change without notice. Not yet recommended for production use.
+Telo is under heavy development. While it is pre-1.0, breaking changes ship in **minor** releases — manifest shapes, kind schemas, and APIs can change between versions. Pin your imports and expect to update manifests when you upgrade. The core runtime, module system, and standard library are functional, but Telo is not yet recommended for production use.
+
+**1.0 lands when the Rust kernel reaches feature parity with the Node.js implementation** — that is the milestone that freezes the manifest contract across runtimes.
 
 ## The Meaning of Telo
 

package/dist/completions/import-source.js

@@ -130,8 +130,8 @@ async function refSearchCompletions(prefix, replaceRange, adapter) {
 }
 /** The `org/name` tail of a location ref: its last two path segments, with the
  *  transport scheme (`oci://`, `https://`, …) and registry host dropped.
- *  `oci://ghcr.io/telorun/telo-console` → `telorun/telo-console`; `std/console`
- *  → `std/console`. Falls back to fewer segments (or the whole ref) when there
+ *  `oci://ghcr.io/telorun/telo-console` → `telorun/telo-console`; `acme/console`
+ *  → `acme/console`. Falls back to fewer segments (or the whole ref) when there
  *  aren't two. */
 function refDisplayName(ref) {
     const withoutScheme = ref.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");

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

@@ -6,6 +6,11 @@ import { type AstDocument, type AstMap, type AstNode, type CelSegment, type Posi
  *  "which container am I typing into". */
 export interface ResolvedCursor {
     docIndex: number;
+    /** The cursor as a document offset. Carried so a consumer hit-testing inside a
+     *  node (a CEL chain, the halves of an `Alias.Name` value) reuses the one this
+     *  resolution was performed with, rather than recomputing the line table and
+     *  risking a different answer. */
+    offset: number;
     /** Top-level `kind:` value of the cursor's document, when present. */
     docKind?: string;
     slot: "key" | "value";

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

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

package/dist/completions/resolve-node.js

@@ -200,6 +200,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
         }
         return {
             docIndex,
+            offset,
             docKind,
             slot: "key",
             path: found.path,
@@ -228,6 +229,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
             const { path, existingKeys, scope } = columnSearch(doc.root, col, offset, lineOffsets);
             return {
                 docIndex,
+                offset,
                 docKind,
                 slot: "key",
                 path,
@@ -240,6 +242,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
         const clampedEnd = Math.min(offset, value.range[1]);
         return {
             docIndex,
+            offset,
             docKind,
             slot: "value",
             path: found.keyName != null ? [...found.path, found.keyName] : found.path,
@@ -259,6 +262,7 @@ export function resolveNodeAtPosition(text, docs, line, character) {
         : { path: [], existingKeys: new Set(), scope: { depth: 0 } };
     return {
         docIndex,
+        offset,
         docKind,
         slot: "key",
         path: resolution.path,

package/dist/definition/alias-qualified-value.d.ts

@@ -0,0 +1,23 @@
+import type { AstScalar } from "@telorun/analyzer";
+/** An `<Alias>.<Name>` scalar split at its first dot — the grammar `kind:`,
+ *  `extends:`, `x-telo-ref` and `!ref` all share — plus which half the cursor
+ *  sits on, so the alias navigates to its import and the suffix to the thing
+ *  the alias qualifies. */
+export interface AliasQualifiedValue {
+    /** Undefined for an unqualified value (a bare local name). */
+    alias?: string;
+    /** Everything after the first dot, or the whole value when unqualified. */
+    name: string;
+    /** True when the cursor sits on the alias half (dot inclusive). */
+    onAlias: boolean;
+}
+/** Split the scalar at `node` around the cursor at `offset` (a document offset).
+ *
+ *  The parsed value is authoritative where there is one — the source range spans
+ *  the whole scalar token, so a quoted `x-telo-ref: "Alias.Kind"` would otherwise
+ *  carry its quotes into the alias and miss every lookup. A `!ref` / `!cel`
+ *  scalar resolves to a tagged sentinel rather than a string, so those fall back
+ *  to the raw slice. The range is still what locates the value inside the token,
+ *  which is what the cursor is hit-tested against. */
+export declare function splitAliasQualified(text: string, node: AstScalar, offset: number): AliasQualifiedValue | undefined;
+//# sourceMappingURL=alias-qualified-value.d.ts.map

package/dist/definition/alias-qualified-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-qualified-value.d.ts","sourceRoot":"","sources":["../../src/definition/alias-qualified-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;2BAG2B;AAC3B,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;sDAOsD;AACtD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,MAAM,GACb,mBAAmB,GAAG,SAAS,CAcjC"}

package/dist/definition/alias-qualified-value.js

@@ -0,0 +1,24 @@
+/** Split the scalar at `node` around the cursor at `offset` (a document offset).
+ *
+ *  The parsed value is authoritative where there is one — the source range spans
+ *  the whole scalar token, so a quoted `x-telo-ref: "Alias.Kind"` would otherwise
+ *  carry its quotes into the alias and miss every lookup. A `!ref` / `!cel`
+ *  scalar resolves to a tagged sentinel rather than a string, so those fall back
+ *  to the raw slice. The range is still what locates the value inside the token,
+ *  which is what the cursor is hit-tested against. */
+export function splitAliasQualified(text, node, offset) {
+    const raw = text.slice(node.range[0], node.range[1]);
+    const value = typeof node.value === "string" ? node.value : raw.trim();
+    if (!value)
+        return undefined;
+    const at = raw.indexOf(value);
+    const start = node.range[0] + (at >= 0 ? at : 0);
+    const dot = value.indexOf(".");
+    if (dot === -1)
+        return { name: value, onAlias: false };
+    return {
+        alias: value.slice(0, dot),
+        name: value.slice(dot + 1),
+        onAlias: offset <= start + dot,
+    };
+}

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

@@ -1,13 +1,20 @@
 import { type AstDocument, type LoadedGraph } from "@telorun/analyzer";
 import type { DefinitionResult } from "../types.js";
-/** Resolve the `!ref` under the cursor to its target resource's definition.
+/** Resolve the symbol under the cursor to where it is declared.
  *
- *  The ref grammar mirrors `resolveRefSentinels`: the tag's value is split on
- *  the first dot — a bare name (or `Self.name`) is a local resource in the
- *  current module; `Alias.name` is an exported instance of the module the import
- *  `Alias` points at, followed transitively through re-exports and gated on each
- *  module's `exports.resources`. Returns `undefined` when the cursor isn't on a
- *  `!ref`, or the target can't be found (e.g. a scope-local name, an unexported
- *  instance, or an import that failed to load). */
+ *  Three navigable symbol classes, each dispatched on what the cursor sits in
+ *  rather than on the field it happens to be under:
+ *
+ *  - a CEL identifier (`variables.port`, `resources.Store.conn`) → its
+ *    declaration on the module doc, or the resource it names;
+ *  - an alias-qualified kind (`kind: Http.Server`, `extends:`, `x-telo-ref`) →
+ *    the `Telo.Definition` that registers it;
+ *  - a `!ref` target → the resource instance it names.
+ *
+ *  In the last two the alias half (`Http`) navigates to the import that declares
+ *  it, and the suffix to what the alias qualifies. Returns `undefined` when the
+ *  cursor is on nothing navigable, or the target can't be found (a kernel
+ *  built-in, a scope-local name, an unexported entry, or an import that failed
+ *  to load). */
 export declare function buildDefinition(text: string, line: number, character: number, graph: LoadedGraph, currentFilePath: string, docs?: AstDocument[]): DefinitionResult | undefined;
 //# sourceMappingURL=build-definition.d.ts.map

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

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

package/dist/definition/build-definition.js

@@ -1,98 +1,44 @@
-import { parseToAst, } from "@telorun/analyzer";
+import { parseToAst } from "@telorun/analyzer";
 import { resolveNodeAtPosition } from "../completions/resolve-node.js";
-/** The module whose owner or partials includes `filePath`. */
-function moduleForFile(graph, filePath) {
-    for (const mod of graph.modules.values()) {
-        if (mod.owner.source === filePath)
-            return mod;
-        if (mod.partials.some((p) => p.source === filePath))
-            return mod;
-    }
-    return undefined;
-}
-/** First resource named `name` across `files`, located at its `metadata.name`
- *  (or its first line as a fallback). Names are unique within a module scope, so
- *  the first hit is the definition. */
-function locateResource(files, name) {
-    for (const file of files) {
-        for (let i = 0; i < file.manifests.length; i++) {
-            const manifest = file.manifests[i];
-            if (!manifest || manifest.metadata?.name !== name)
-                continue;
-            const pos = file.positions[i];
-            const range = pos?.positionIndex.get("metadata.name") ??
-                pos?.positionIndex.get("@key:metadata.name") ??
-                (pos ? { start: { line: pos.sourceLine, character: 0 }, end: { line: pos.sourceLine, character: 0 } } : undefined);
-            if (range)
-                return { uri: file.source, range };
-        }
-    }
-    return undefined;
-}
-/** The `exports.resources` list of a module's owner doc (empty when absent). */
-function exportedResources(mod) {
-    const doc = mod.owner.manifests.find((m) => m?.kind === "Telo.Library" || m?.kind === "Telo.Application");
-    const list = doc?.exports?.resources;
-    return Array.isArray(list) ? list.filter((e) => typeof e === "string") : [];
-}
-/** Follow `name` into `moduleSource` across the export boundary, honoring the
- *  `exports.resources` gate and re-export chains (`app → api → domain → …`). A
- *  terminal match is a locally-owned instance the module actually exports; a
- *  re-export entry `InnerAlias.name` hops through that module's own import edge.
- *  `seen` bounds cyclic import graphs. */
-function resolveExported(graph, moduleSource, name, seen = new Set()) {
-    if (seen.has(moduleSource))
-        return undefined;
-    seen.add(moduleSource);
-    const mod = graph.modules.get(moduleSource);
-    if (!mod)
-        return undefined;
-    const exports = exportedResources(mod);
-    // No `exports.resources` block → ungated (the module hasn't opted into the
-    // gate, same as `exports.kinds`): a plain name match keeps navigation working
-    // for modules that predate explicit exports.
-    if (exports.length === 0) {
-        return locateResource([mod.owner, ...mod.partials], name);
-    }
-    if (exports.includes(name)) {
-        const local = locateResource([mod.owner, ...mod.partials], name);
-        if (local)
-            return local;
-    }
-    const reexport = exports.find((e) => e.endsWith(`.${name}`));
-    if (!reexport)
-        return undefined;
-    const innerAlias = reexport.slice(0, reexport.length - name.length - 1);
-    const edge = graph.importEdges.get(mod.owner.source)?.get(innerAlias);
-    return edge ? resolveExported(graph, edge.targetSource, name, seen) : undefined;
-}
-/** Resolve the `!ref` under the cursor to its target resource's definition.
+import { splitAliasQualified } from "./alias-qualified-value.js";
+import { 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";
+/** Resolve the symbol under the cursor to where it is declared.
+ *
+ *  Three navigable symbol classes, each dispatched on what the cursor sits in
+ *  rather than on the field it happens to be under:
  *
- *  The ref grammar mirrors `resolveRefSentinels`: the tag's value is split on
- *  the first dot — a bare name (or `Self.name`) is a local resource in the
- *  current module; `Alias.name` is an exported instance of the module the import
- *  `Alias` points at, followed transitively through re-exports and gated on each
- *  module's `exports.resources`. Returns `undefined` when the cursor isn't on a
- *  `!ref`, or the target can't be found (e.g. a scope-local name, an unexported
- *  instance, or an import that failed to load). */
+ *  - a CEL identifier (`variables.port`, `resources.Store.conn`) → its
+ *    declaration on the module doc, or the resource it names;
+ *  - an alias-qualified kind (`kind: Http.Server`, `extends:`, `x-telo-ref`) →
+ *    the `Telo.Definition` that registers it;
+ *  - a `!ref` target → the resource instance it names.
+ *
+ *  In the last two the alias half (`Http`) navigates to the import that declares
+ *  it, and the suffix to what the alias qualifies. Returns `undefined` when the
+ *  cursor is on nothing navigable, or the target can't be found (a kernel
+ *  built-in, a scope-local name, an unexported entry, or an import that failed
+ *  to load). */
 export function buildDefinition(text, line, character, graph, currentFilePath, docs) {
     const astDocs = docs ?? parseToAst(text);
-    const node = resolveNodeAtPosition(text, astDocs, line, character)?.node;
-    if (!node || node.kind !== "scalar" || node.tag !== "!ref")
-        return undefined;
-    // The scalar's range covers the ref target text (the value after `!ref`).
-    const source = text.slice(node.range[0], node.range[1]).trim();
-    if (!source)
+    const resolved = resolveNodeAtPosition(text, astDocs, line, character);
+    if (!resolved)
         return undefined;
     const currentModule = moduleForFile(graph, currentFilePath) ?? graph.entry;
-    const dot = source.indexOf(".");
-    const alias = dot === -1 ? undefined : source.slice(0, dot);
-    const name = dot === -1 ? source : source.slice(dot + 1);
-    if (alias === undefined || alias === "Self") {
-        return locateResource([currentModule.owner, ...currentModule.partials], name);
+    if (resolved.cel) {
+        return resolveCelTarget(graph, currentModule, resolved.cel.segment, resolved.cel.offset);
     }
-    const edge = graph.importEdges.get(currentModule.owner.source)?.get(alias);
-    if (!edge)
+    const node = resolved.node;
+    if (resolved.slot !== "value" || node?.kind !== "scalar")
         return undefined;
-    return resolveExported(graph, edge.targetSource, name);
+    const split = splitAliasQualified(text, node, resolved.offset);
+    if (!split)
+        return undefined;
+    if (node.tag === "!ref")
+        return resolveRefTarget(graph, currentModule, split);
+    if (isKindSlot(resolved))
+        return resolveKindTarget(graph, currentModule, split);
+    return undefined;
 }

package/dist/definition/manifest-navigation.d.ts

@@ -0,0 +1,36 @@
+import type { LoadedFile, LoadedGraph, LoadedModule } from "@telorun/analyzer";
+import type { DefinitionResult } from "../types.js";
+/** The shape every navigation lookup reads off a `LoadedFile.manifests` entry.
+ *  Narrower than `ResourceManifest` on purpose — navigation only ever asks what
+ *  kind a doc is and what it is named. */
+export interface NavigableManifest {
+    kind?: string;
+    metadata?: {
+        name?: string;
+    };
+}
+/** The module whose owner or partials includes `filePath`. */
+export declare function moduleForFile(graph: LoadedGraph, filePath: string): LoadedModule | undefined;
+/** Every file in a module's scope, owner first. */
+export declare function moduleFiles(mod: LoadedModule): LoadedFile[];
+/** First manifest across `files` satisfying `match`, located at its
+ *  `metadata.name` (or its first line as a fallback). Names are unique within a
+ *  module scope, so the first hit is the definition. */
+export declare function locateManifest(files: LoadedFile[], match: (manifest: NavigableManifest) => boolean): DefinitionResult | undefined;
+/** The resource instance named `name` in a module scope. */
+export declare function locateResource(files: LoadedFile[], name: string): DefinitionResult | undefined;
+/** The `Telo.Definition` / `Telo.Abstract` doc registering kind suffix `name`.
+ *  Filtered by doc kind so an instance sharing the name never shadows it. */
+export declare function locateKindDefinition(files: LoadedFile[], name: string): DefinitionResult | undefined;
+/** The module doc's JSON projection, for reading its `exports` block. */
+export declare function moduleDoc(mod: LoadedModule): Record<string, unknown> | undefined;
+/** The module's `metadata.name` — the identity a canonical kind (`<module>.<Kind>`)
+ *  and an `ImportEdge.targetModuleName` are expressed in. */
+export declare function moduleName(mod: LoadedModule): string | undefined;
+/** A dotted key path on the module doc (`imports.Http`, `variables.port`),
+ *  located at the key itself. */
+export declare function locateModuleDocKey(mod: LoadedModule, path: string): DefinitionResult | undefined;
+/** Where the import bound to `alias` is declared: the `imports:` map entry, or
+ *  the legacy standalone `Telo.Import` doc named after the alias. */
+export declare function locateImport(mod: LoadedModule, alias: string): DefinitionResult | undefined;
+//# sourceMappingURL=manifest-navigation.d.ts.map

package/dist/definition/manifest-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-navigation.d.ts","sourceRoot":"","sources":["../../src/definition/manifest-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAS,MAAM,mBAAmB,CAAC;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;0CAE0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAKD,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAM5F;AAED,mDAAmD;AACnD,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,UAAU,EAAE,CAE3D;AA0BD;;wDAEwD;AACxD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EAAE,EACnB,KAAK,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,GAC9C,gBAAgB,GAAG,SAAS,CAU9B;AAED,4DAA4D;AAC5D,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE9F;AAED;6EAC6E;AAC7E,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,EAAE,EACnB,IAAI,EAAE,MAAM,GACX,gBAAgB,GAAG,SAAS,CAE9B;AAUD,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAGhF;AAED;6DAC6D;AAC7D,wBAAgB,UAAU,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAEhE;AAED;iCACiC;AACjC,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,MAAM,GACX,gBAAgB,GAAG,SAAS,CAK9B;AAED;qEACqE;AACrE,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAK3F"}

package/dist/definition/manifest-navigation.js

@@ -0,0 +1,92 @@
+const MODULE_DOC_KINDS = new Set(["Telo.Application", "Telo.Library"]);
+const KIND_DOC_KINDS = new Set(["Telo.Definition", "Telo.Abstract"]);
+/** The module whose owner or partials includes `filePath`. */
+export function moduleForFile(graph, filePath) {
+    for (const mod of graph.modules.values()) {
+        if (mod.owner.source === filePath)
+            return mod;
+        if (mod.partials.some((p) => p.source === filePath))
+            return mod;
+    }
+    return undefined;
+}
+/** Every file in a module's scope, owner first. */
+export function moduleFiles(mod) {
+    return [mod.owner, ...mod.partials];
+}
+function rangeAt(file, docIndex, key) {
+    return file.positions[docIndex]?.positionIndex.get(key);
+}
+/** The value span of `path`, falling back to its key when the value has none. */
+function valueRange(file, docIndex, path) {
+    return rangeAt(file, docIndex, path) ?? rangeAt(file, docIndex, `@key:${path}`);
+}
+/** The key span of `path` — what a declaration jump underlines, so the target
+ *  reads as `variables:` / `imports.Http`, not the whole block that follows. */
+function keyRange(file, docIndex, path) {
+    return rangeAt(file, docIndex, `@key:${path}`) ?? rangeAt(file, docIndex, path);
+}
+function docStartRange(file, docIndex) {
+    const pos = file.positions[docIndex];
+    if (!pos)
+        return undefined;
+    return {
+        start: { line: pos.sourceLine, character: 0 },
+        end: { line: pos.sourceLine, character: 0 },
+    };
+}
+/** First manifest across `files` satisfying `match`, located at its
+ *  `metadata.name` (or its first line as a fallback). Names are unique within a
+ *  module scope, so the first hit is the definition. */
+export function locateManifest(files, match) {
+    for (const file of files) {
+        for (let i = 0; i < file.manifests.length; i++) {
+            const manifest = file.manifests[i];
+            if (!manifest || !match(manifest))
+                continue;
+            const range = valueRange(file, i, "metadata.name") ?? docStartRange(file, i);
+            if (range)
+                return { uri: file.source, range };
+        }
+    }
+    return undefined;
+}
+/** The resource instance named `name` in a module scope. */
+export function locateResource(files, name) {
+    return locateManifest(files, (m) => m.metadata?.name === name);
+}
+/** The `Telo.Definition` / `Telo.Abstract` doc registering kind suffix `name`.
+ *  Filtered by doc kind so an instance sharing the name never shadows it. */
+export function locateKindDefinition(files, name) {
+    return locateManifest(files, (m) => KIND_DOC_KINDS.has(m.kind ?? "") && m.metadata?.name === name);
+}
+/** Index of the module's `Telo.Application` / `Telo.Library` doc in its owner
+ *  file — where `imports`, `variables`, `secrets` and `ports` are declared. */
+function moduleDocIndex(mod) {
+    return mod.owner.manifests.findIndex((m) => MODULE_DOC_KINDS.has(m?.kind ?? ""));
+}
+/** The module doc's JSON projection, for reading its `exports` block. */
+export function moduleDoc(mod) {
+    const index = moduleDocIndex(mod);
+    return index < 0 ? undefined : mod.owner.manifests[index] ?? undefined;
+}
+/** The module's `metadata.name` — the identity a canonical kind (`<module>.<Kind>`)
+ *  and an `ImportEdge.targetModuleName` are expressed in. */
+export function moduleName(mod) {
+    return moduleDoc(mod)?.metadata?.name;
+}
+/** A dotted key path on the module doc (`imports.Http`, `variables.port`),
+ *  located at the key itself. */
+export function locateModuleDocKey(mod, path) {
+    const index = moduleDocIndex(mod);
+    if (index < 0)
+        return undefined;
+    const range = keyRange(mod.owner, index, path);
+    return range ? { uri: mod.owner.source, range } : undefined;
+}
+/** Where the import bound to `alias` is declared: the `imports:` map entry, or
+ *  the legacy standalone `Telo.Import` doc named after the alias. */
+export function locateImport(mod, alias) {
+    return (locateModuleDocKey(mod, `imports.${alias}`) ??
+        locateManifest(moduleFiles(mod), (m) => m.kind === "Telo.Import" && m.metadata?.name === alias));
+}

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

@@ -0,0 +1,17 @@
+import { type CelSegment, type LoadedGraph, type LoadedModule } from "@telorun/analyzer";
+import type { DefinitionResult } from "../types.js";
+/** Resolve the CEL identifier under the cursor to where it is declared.
+ *
+ *  `variables` / `secrets` / `ports` navigate to their block on the module doc,
+ *  and their member to that block's entry. `resources` navigates through the
+ *  same instance lookup a `!ref` uses. Anything else (a step result, a handler
+ *  scope like `request`, a member of a resolved value) has no manifest
+ *  declaration to jump to and resolves to nothing.
+ *
+ *  A body the author is still writing may not parse; that means there is no
+ *  chain to hit-test, not an error to surface from a navigation request — the
+ *  analyzer reports the syntax error itself. Only that failure is tolerated: a
+ *  defect in the CEL wrapper propagates rather than reading as "nothing to
+ *  navigate to". */
+export declare function resolveCelTarget(graph: LoadedGraph, currentModule: LoadedModule, segment: CelSegment, offset: number): DefinitionResult | undefined;
+//# sourceMappingURL=resolve-cel-target.d.ts.map

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

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

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

@@ -0,0 +1,125 @@
+import { CelParseError, } from "@telorun/analyzer";
+import { locateImport, locateModuleDocKey, locateResource, moduleFiles, } from "./manifest-navigation.js";
+import { resolveExportedResource } from "./resolve-export-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
+ *  that instance rather than as a cross-module lookup. */
+function resolveResourceChain(graph, currentModule, parts, index) {
+    if (index === 0)
+        return undefined;
+    const first = parts[1].name;
+    const local = locateResource(moduleFiles(currentModule), first);
+    if (local)
+        return index === 1 ? local : undefined;
+    const edge = graph.importEdges.get(currentModule.owner.source)?.get(first);
+    if (!edge)
+        return undefined;
+    if (index === 1)
+        return locateImport(currentModule, first);
+    if (index === 2)
+        return resolveExportedResource(graph, edge.targetSource, parts[2].name);
+    return undefined;
+}
+/** Resolve the CEL identifier under the cursor to where it is declared.
+ *
+ *  `variables` / `secrets` / `ports` navigate to their block on the module doc,
+ *  and their member to that block's entry. `resources` navigates through the
+ *  same instance lookup a `!ref` uses. Anything else (a step result, a handler
+ *  scope like `request`, a member of a resolved value) has no manifest
+ *  declaration to jump to and resolves to nothing.
+ *
+ *  A body the author is still writing may not parse; that means there is no
+ *  chain to hit-test, not an error to surface from a navigation request — the
+ *  analyzer reports the syntax error itself. Only that failure is tolerated: a
+ *  defect in the CEL wrapper propagates rather than reading as "nothing to
+ *  navigate to". */
+export function resolveCelTarget(graph, currentModule, segment, offset) {
+    let ast;
+    try {
+        ast = segment.ast();
+    }
+    catch (error) {
+        if (!(error instanceof CelParseError))
+            throw error;
+        return undefined;
+    }
+    const hit = chainAt(ast, offset);
+    if (!hit)
+        return undefined;
+    const { parts, index } = hit;
+    const root = parts[0].name;
+    if (DECLARATION_SCOPES.has(root)) {
+        if (index === 0)
+            return locateModuleDocKey(currentModule, root);
+        if (index === 1)
+            return locateModuleDocKey(currentModule, `${root}.${parts[1].name}`);
+        return undefined;
+    }
+    if (root === "resources")
+        return resolveResourceChain(graph, currentModule, parts, index);
+    return undefined;
+}

package/dist/definition/resolve-export-chain.d.ts

@@ -0,0 +1,23 @@
+import { type LoadedGraph } from "@telorun/analyzer";
+import type { DefinitionResult } from "../types.js";
+/** Resolve the kind suffix `name` exported by the module at `targetSource` to
+ *  the `Telo.Definition` / `Telo.Abstract` doc that owns it.
+ *
+ *  The gate and the transitive re-export chain come from the analyzer's own
+ *  `resolveExportedKinds` fixpoint rather than a local walk, so navigation
+ *  cannot disagree with `telo check` about what an import exposes — including
+ *  the two rules a hand-rolled walk gets wrong: `exports.kinds: []` gates
+ *  everything while an absent block gates nothing, and a re-export FROM an
+ *  ungated module resolves straight to it. */
+export declare function resolveExportedKind(graph: LoadedGraph, targetSource: string, name: string): DefinitionResult | undefined;
+/** Resolve the instance `name` exported by the module at `targetSource`,
+ *  following `<Alias>.<name>` re-exports transitively. `seen` bounds cyclic
+ *  import graphs.
+ *
+ *  Unlike kinds there is no permissive default: the kernel reads
+ *  `exports.resources ?? []` and builds its export table strictly from that, so
+ *  an absent block exports nothing and an unlisted name is an
+ *  `UNRESOLVED_REFERENCE` — navigating to it would tell the author a wiring is
+ *  real that the analyzer rejects. */
+export declare function resolveExportedResource(graph: LoadedGraph, targetSource: string, name: string, seen?: Set<string>): DefinitionResult | undefined;
+//# sourceMappingURL=resolve-export-chain.d.ts.map

package/dist/definition/resolve-export-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-export-chain.d.ts","sourceRoot":"","sources":["../../src/definition/resolve-export-chain.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAkCpD;;;;;;;;8CAQ8C;AAC9C,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,gBAAgB,GAAG,SAAS,CAiC9B;AAED;;;;;;;;sCAQsC;AACtC,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,GAAG,CAAC,MAAM,CAAa,GAC5B,gBAAgB,GAAG,SAAS,CAgB9B"}