@telorun/analyzer 0.40.0 → 0.41.1

package/dist/cel-ast.d.ts

@@ -0,0 +1,98 @@
+import { type ASTNode as CelJsNode } from "@marcbachmann/cel-js";
+/** Read-only CEL expression tree owned by the analyzer. The third-party
+ *  `@marcbachmann/cel-js` `ASTNode` stays an internal detail — `wrapCelAst`
+ *  translates it into this union so no external AST type leaks through the
+ *  public surface (full symmetry with the YAML `AstNode` decision). Every
+ *  `range` is `[start, end]` in DOCUMENT offsets. */
+export type CelNode = {
+    kind: "literal";
+    range: [number, number];
+    value: unknown;
+} | {
+    kind: "ident";
+    range: [number, number];
+    name: string;
+} | {
+    kind: "member";
+    range: [number, number];
+    target: CelNode;
+    property: string;
+    /** Span of just the `.prop` identifier, for a future rename. */
+    propertyRange: [number, number];
+    /** `.?` optional member access. */
+    optional: boolean;
+} | {
+    kind: "index";
+    range: [number, number];
+    target: CelNode;
+    index: CelNode;
+    /** `[?]` optional index. */
+    optional: boolean;
+} | {
+    kind: "call";
+    range: [number, number];
+    name: string;
+    args: CelNode[];
+} | {
+    kind: "methodCall";
+    range: [number, number];
+    name: string;
+    receiver: CelNode;
+    args: CelNode[];
+} | {
+    kind: "list";
+    range: [number, number];
+    items: CelNode[];
+} | {
+    kind: "map";
+    range: [number, number];
+    entries: {
+        key: CelNode;
+        value: CelNode;
+    }[];
+} | {
+    kind: "ternary";
+    range: [number, number];
+    cond: CelNode;
+    then: CelNode;
+    else: CelNode;
+} | {
+    kind: "unary";
+    range: [number, number];
+    op: string;
+    operand: CelNode;
+} | {
+    kind: "binary";
+    range: [number, number];
+    op: string;
+    left: CelNode;
+    right: CelNode;
+};
+/** A `${{ }}` / `!cel` region inside a YAML scalar. Ranges are DOCUMENT
+ *  offsets; `source` is the CEL body (a longest-valid prefix when `open`).
+ *  `ast()` parses lazily — nothing parses CEL during `parseToAst`, only the
+ *  expression a caller actually inspects. */
+export interface CelSegment {
+    /** Segment span in document offsets (includes the `${{ }}` for interpolation). */
+    range: [number, number];
+    /** The CEL body (a prefix when `open`). */
+    source: string;
+    /** True when a `${{` has no matching `}}` yet (the user is mid-typing). */
+    open: boolean;
+    /** Lazily parse + wrap; ranges are already absolute. */
+    ast(): CelNode;
+}
+/** Maps a `@marcbachmann/cel-js` node into the analyzer `CelNode`, translating
+ *  each node's segment-relative `start`/`end` to absolute document offsets by
+ *  adding `segmentStart`. */
+export declare function wrapCelAst(node: CelJsNode, segmentStart: number): CelNode;
+/** Build the CEL segments of a scalar from its raw source slice. `scalarText`
+ *  is `text.slice(start, valueEnd)` and `scalarStart` its document offset.
+ *
+ *  - `tag === "!cel"` → one closed segment spanning the tagged body.
+ *  - otherwise → one closed segment per `${{ … }}` match, plus a trailing
+ *    `open` segment for a dangling `${{` with no `}}` (bounded to its line, so
+ *    an unterminated quote that swallowed following lines still recovers the
+ *    region the user is typing in). */
+export declare function buildCelSegments(scalarText: string, scalarStart: number, tag: string | undefined, taggedSource: string | undefined): CelSegment[];
+//# sourceMappingURL=cel-ast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cel-ast.d.ts","sourceRoot":"","sources":["../src/cel-ast.ts"],"names":[],"mappings":"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"}

package/dist/cel-ast.js

@@ -0,0 +1,188 @@
+import { parse } from "@marcbachmann/cel-js";
+const BINARY_OPS = new Set([
+    "!=",
+    "==",
+    "in",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "||",
+    "&&",
+]);
+/** Maps a `@marcbachmann/cel-js` node into the analyzer `CelNode`, translating
+ *  each node's segment-relative `start`/`end` to absolute document offsets by
+ *  adding `segmentStart`. */
+export function wrapCelAst(node, segmentStart) {
+    const range = abs(node, segmentStart);
+    const op = node.op;
+    const args = node.args;
+    if (op === "value")
+        return { kind: "literal", range, value: args };
+    if (op === "id")
+        return { kind: "ident", range, name: String(args) };
+    if (op === "." || op === ".?") {
+        const [target, property] = args;
+        return {
+            kind: "member",
+            range,
+            target: wrapCelAst(target, segmentStart),
+            property,
+            propertyRange: [range[1] - property.length, range[1]],
+            optional: op === ".?",
+        };
+    }
+    if (op === "[]" || op === "[?]") {
+        const [target, index] = args;
+        return {
+            kind: "index",
+            range,
+            target: wrapCelAst(target, segmentStart),
+            index: wrapCelAst(index, segmentStart),
+            optional: op === "[?]",
+        };
+    }
+    if (op === "call") {
+        const [name, callArgs] = args;
+        return { kind: "call", range, name, args: callArgs.map((a) => wrapCelAst(a, segmentStart)) };
+    }
+    if (op === "rcall") {
+        const [name, receiver, callArgs] = args;
+        return {
+            kind: "methodCall",
+            range,
+            name,
+            receiver: wrapCelAst(receiver, segmentStart),
+            args: callArgs.map((a) => wrapCelAst(a, segmentStart)),
+        };
+    }
+    if (op === "list") {
+        return { kind: "list", range, items: args.map((a) => wrapCelAst(a, segmentStart)) };
+    }
+    if (op === "map") {
+        return {
+            kind: "map",
+            range,
+            entries: args.map(([k, v]) => ({
+                key: wrapCelAst(k, segmentStart),
+                value: wrapCelAst(v, segmentStart),
+            })),
+        };
+    }
+    if (op === "?:") {
+        const [cond, then, els] = args;
+        return {
+            kind: "ternary",
+            range,
+            cond: wrapCelAst(cond, segmentStart),
+            then: wrapCelAst(then, segmentStart),
+            else: wrapCelAst(els, segmentStart),
+        };
+    }
+    if (op === "!_" || op === "-_") {
+        return { kind: "unary", range, op, operand: wrapCelAst(args, segmentStart) };
+    }
+    if (BINARY_OPS.has(op)) {
+        const [left, right] = args;
+        return {
+            kind: "binary",
+            range,
+            op,
+            left: wrapCelAst(left, segmentStart),
+            right: wrapCelAst(right, segmentStart),
+        };
+    }
+    // Unknown operator — surface it as a literal so consumers can still hit-test
+    // the range rather than crash on an unmapped node.
+    return { kind: "literal", range, value: undefined };
+}
+function abs(node, segmentStart) {
+    const r = node.range ?? { start: node.start, end: node.end };
+    return [r.start + segmentStart, r.end + segmentStart];
+}
+/** Parse `source` and wrap it, tolerating a trailing partial member/index
+ *  access (`req.`, `req.fo`) by falling back to the longest parseable prefix.
+ *  Used for `open` segments where completion fires mid-token. */
+function parseLenient(source, segmentStart, range) {
+    const candidates = [source, source.replace(/[.?[]+\w*$/, ""), source.replace(/[.?[(]+.*$/, "")];
+    for (const candidate of candidates) {
+        const trimmed = candidate.trim();
+        if (!trimmed)
+            break;
+        try {
+            return wrapCelAst(parse(trimmed).ast, segmentStart);
+        }
+        catch {
+            // try the next-shorter prefix
+        }
+    }
+    return { kind: "ident", range, name: source.trim() };
+}
+const OPEN_MARKER = "${{";
+/** Build the CEL segments of a scalar from its raw source slice. `scalarText`
+ *  is `text.slice(start, valueEnd)` and `scalarStart` its document offset.
+ *
+ *  - `tag === "!cel"` → one closed segment spanning the tagged body.
+ *  - otherwise → one closed segment per `${{ … }}` match, plus a trailing
+ *    `open` segment for a dangling `${{` with no `}}` (bounded to its line, so
+ *    an unterminated quote that swallowed following lines still recovers the
+ *    region the user is typing in). */
+export function buildCelSegments(scalarText, scalarStart, tag, taggedSource) {
+    if (tag === "!cel" && taggedSource != null) {
+        const idx = scalarText.indexOf(taggedSource);
+        const bodyStart = scalarStart + (idx >= 0 ? idx : 0);
+        const range = [bodyStart, bodyStart + taggedSource.length];
+        return [
+            {
+                range,
+                source: taggedSource,
+                open: false,
+                ast: () => wrapCelAst(parse(taggedSource).ast, bodyStart),
+            },
+        ];
+    }
+    const segments = [];
+    const re = /\$\{\{([\s\S]*?)\}\}/g;
+    let match;
+    let lastClosedEnd = 0;
+    while ((match = re.exec(scalarText)) !== null) {
+        const whole = match[0];
+        const inner = match[1];
+        const leadingWs = inner.match(/^\s*/)?.[0].length ?? 0;
+        const bodyStart = scalarStart + match.index + OPEN_MARKER.length + leadingWs;
+        const source = inner.trim();
+        segments.push({
+            range: [scalarStart + match.index, scalarStart + match.index + whole.length],
+            source,
+            open: false,
+            ast: () => wrapCelAst(parse(source).ast, bodyStart),
+        });
+        lastClosedEnd = match.index + whole.length;
+    }
+    const openIdx = scalarText.indexOf(OPEN_MARKER, lastClosedEnd);
+    if (openIdx >= 0 && scalarText.indexOf("}}", openIdx) < 0) {
+        let lineEnd = scalarText.indexOf("\n", openIdx);
+        if (lineEnd < 0)
+            lineEnd = scalarText.length;
+        const after = openIdx + OPEN_MARKER.length;
+        // Drop a trailing scalar-closing quote so `foo: "${{ req"` recovers `req`,
+        // not `req"` — the quote closes the YAML string, it isn't part of the CEL.
+        const rawBody = scalarText.slice(after, lineEnd).replace(/["']\s*$/, "");
+        const leadingWs = rawBody.match(/^\s*/)?.[0].length ?? 0;
+        const bodyStart = scalarStart + after + leadingWs;
+        const source = rawBody.trim();
+        const range = [scalarStart + openIdx, scalarStart + lineEnd];
+        segments.push({
+            range,
+            source,
+            open: true,
+            ast: () => parseLenient(source, bodyStart, range),
+        });
+    }
+    return segments;
+}

package/dist/index.d.ts

@@ -23,7 +23,7 @@ export type { SyntheticImport } from "./inline-imports.js";
 export { reconcileModuleVersions } from "./reconcile-module-versions.js";
 export type { VersionReconciliation } from "./reconcile-module-versions.js";
 export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
-export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, } from "./position-metadata.js";
+export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, offsetToPosition, } from "./position-metadata.js";
 export type { DocumentPosition } from "./position-metadata.js";
 export { HttpSource } from "./sources/http-source.js";
 export { RegistrySource } from "./sources/registry-source.js";
@@ -37,6 +37,10 @@ export { isLocalPathSource } from "./sources/local-path-ref.js";
 export { MANIFEST_CACHE_BASE_URL, ManifestCacheSource, isHttpsModuleRef, manifestCacheKey, manifestCacheUrl, ociManifestCacheCoords, urlManifestCacheCoords, } from "./sources/manifest-cache.js";
 export type { ManifestCacheCoords } from "./sources/manifest-cache.js";
 export { withSyntheticPositions } from "./with-synthetic-positions.js";
+export { documentToAst, parseToAst } from "./yaml-ast.js";
+export type { AstDocument, AstMap, AstNode, AstPair, AstScalar, AstSeq } from "./yaml-ast.js";
+export { buildCelSegments, wrapCelAst } from "./cel-ast.js";
+export type { CelNode, CelSegment } from "./cel-ast.js";
 export { DEFAULT_MANIFEST_FILENAME, DiagnosticSeverity } from "./types.js";
 export type { AnalysisDiagnostic, AnalysisOptions, LoaderInitOptions, LoadOptions, ManifestSource, Position, PositionIndex, Range } from "./types.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":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -13,7 +13,7 @@ export { parseLoadedFile } from "./parse-loaded-file.js";
 export { desugarLoadedFile, inlineImportManifests } from "./inline-imports.js";
 export { reconcileModuleVersions } from "./reconcile-module-versions.js";
 export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
-export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, } from "./position-metadata.js";
+export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, offsetToPosition, } from "./position-metadata.js";
 export { HttpSource } from "./sources/http-source.js";
 export { RegistrySource } from "./sources/registry-source.js";
 export { defaultSources } from "./sources/default-sources.js";
@@ -23,4 +23,6 @@ export { OCI_SCHEME, isOciRef, parseOciRef } from "./sources/oci-ref.js";
 export { isLocalPathSource } from "./sources/local-path-ref.js";
 export { MANIFEST_CACHE_BASE_URL, ManifestCacheSource, isHttpsModuleRef, manifestCacheKey, manifestCacheUrl, ociManifestCacheCoords, urlManifestCacheCoords, } from "./sources/manifest-cache.js";
 export { withSyntheticPositions } from "./with-synthetic-positions.js";
+export { documentToAst, parseToAst } from "./yaml-ast.js";
+export { buildCelSegments, wrapCelAst } from "./cel-ast.js";
 export { DEFAULT_MANIFEST_FILENAME, DiagnosticSeverity } from "./types.js";

package/dist/loaded-types.d.ts

@@ -2,6 +2,7 @@ import type { ResourceManifest } from "@telorun/sdk";
 import type { Document } from "yaml";
 import type { DocumentPosition } from "./position-metadata.js";
 import type { AnalysisDiagnostic, Range } from "./types.js";
+import type { AstDocument } from "./yaml-ast.js";
 /** One physical file's parsed result. Returned for the owner manifest, for
  *  each `include:` partial, and for each external import target.
  *
@@ -16,8 +17,13 @@ export interface LoadedFile {
     requestedUrl: string;
     /** Raw text exactly as `read()` returned it. */
     text: string;
-    /** Per-document parsed AST, in source order. */
+    /** Per-document parsed `yaml` AST, in source order. The editor's mutable
+     *  round-trip model reads this handle; structure-only consumers use the
+     *  read-only `astDocuments` instead so `yaml` stays an internal detail. */
     documents: Document[];
+    /** Per-document read-only `AstNode` view (`yaml`-free), aligned to
+     *  `documents`. The shared structural source of truth for IDE features. */
+    astDocuments: AstDocument[];
     /** Per-document JSON projection (`doc.toJSON()`). Aligned to `documents`. */
     manifests: Array<ResourceManifest | null>;
     /** Per-document `{sourceLine, positionIndex}`. Aligned to `documents`. */

package/dist/loaded-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loaded-types.d.ts","sourceRoot":"","sources":["../src/loaded-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;4EAI4E;AAC5E,MAAM,WAAW,UAAU;IACzB;+DAC2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf;gEAC4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6EAA6E;IAC7E,SAAS,EAAE,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC1C,0EAA0E;IAC1E,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,0EAA0E;IAC1E,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;mCACmC;AACnC,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB;oEACgE;IAChE,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED;;;;;2EAK2E;AAC3E,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC;IACrB;6EACyE;IACzE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,oEAAoE;IACpE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;0BAC0B;AAC1B,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;IACpB;;wBAEoB;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACnC;;;;2BAIuB;IACvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IAClD;;;iFAG6E;IAC7E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;iDAG6C;IAC7C,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;IACzC;;;8EAG0E;IAC1E,gBAAgB,EAAE,kBAAkB,EAAE,CAAC;IACvC;yCACqC;IACrC,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B;8BAC0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ;;qEAEiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;gFAE4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;CACd"}
+{"version":3,"file":"loaded-types.d.ts","sourceRoot":"","sources":["../src/loaded-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;4EAI4E;AAC5E,MAAM,WAAW,UAAU;IACzB;+DAC2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf;gEAC4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb;;+EAE2E;IAC3E,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB;+EAC2E;IAC3E,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,SAAS,EAAE,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC1C,0EAA0E;IAC1E,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,0EAA0E;IAC1E,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;mCACmC;AACnC,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB;oEACgE;IAChE,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED;;;;;2EAK2E;AAC3E,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC;IACrB;6EACyE;IACzE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,oEAAoE;IACpE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;0BAC0B;AAC1B,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;IACpB;;wBAEoB;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACnC;;;;2BAIuB;IACvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IAClD;;;iFAG6E;IAC7E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;iDAG6C;IAC7C,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;IACzC;;;8EAG0E;IAC1E,gBAAgB,EAAE,kBAAkB,EAAE,CAAC;IACvC;yCACqC;IACrC,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B;8BAC0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ;;qEAEiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;gFAE4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;CACd"}

package/dist/parse-loaded-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-loaded-file.d.ts","sourceRoot":"","sources":["../src/parse-loaded-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,mBAAmB,CAAC;AAIhE,MAAM,WAAW,YAAY;IAC3B;4EACwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AA4BD,oEAAoE;AACpE,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CA+CZ"}
+{"version":3,"file":"parse-loaded-file.d.ts","sourceRoot":"","sources":["../src/parse-loaded-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,mBAAmB,CAAC;AAKhE,MAAM,WAAW,YAAY;IAC3B;4EACwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AA4BD,oEAAoE;AACpE,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAiDZ"}

package/dist/parse-loaded-file.js

@@ -3,6 +3,7 @@ import { parseAllDocuments } from "yaml";
 import { buildCelEnvironment } from "./cel-environment.js";
 import { buildDocumentPositions } from "./position-metadata.js";
 import { precompileDoc } from "./precompile.js";
+import { documentToAst } from "./yaml-ast.js";
 /** Append an actionable hint to raw yaml-parser messages that are otherwise
  *  cryptic. The parser reports `BLOCK_AS_IMPLICIT_KEY` ("Nested mappings are
  *  not allowed in compact mappings") when a plain (unquoted) scalar contains
@@ -29,7 +30,8 @@ function rangeFromLinePos(linePos) {
 /** Pure: text in, structured load result out. No I/O, no caches. */
 export function parseLoadedFile(source, requestedUrl, text, options) {
     const documents = parseAllDocuments(text, { customTags: defaultCustomTags() });
-    const positions = buildDocumentPositions(text, documents);
+    const astDocuments = documents.map((doc) => documentToAst(doc, text));
+    const positions = buildDocumentPositions(text, astDocuments);
     const parseErrors = [];
     documents.forEach((doc, documentIndex) => {
         for (const err of doc.errors) {
@@ -67,6 +69,7 @@ export function parseLoadedFile(source, requestedUrl, text, options) {
         requestedUrl,
         text,
         documents,
+        astDocuments,
         manifests,
         positions,
         parseErrors,

package/dist/position-metadata.d.ts

@@ -1,9 +1,9 @@
-import { type Document } from "yaml";
-import type { PositionIndex } from "./types.js";
+import type { Position, PositionIndex } from "./types.js";
+import type { AstDocument } from "./yaml-ast.js";
 /** Single source of truth for "given the source text of a multi-document YAML
  *  file, where does each document start, and what is the byte→(line,char)
  *  table for the file." Both the analyzer's `Loader` and editor frontends
- *  feed the same parsed `yaml.Document[]` through this so diagnostics
+ *  feed the same adapted `AstDocument[]` through this so diagnostics
  *  resolved against `positionIndex` / `sourceLine` line up identically
  *  across hosts. */
 /** Per-document position metadata used by `normalizeDiagnostic`'s fallback chain. */
@@ -12,7 +12,7 @@ export interface DocumentPosition {
     positionIndex: PositionIndex;
 }
 /** Builds DocumentPosition entries aligned to `parsedDocs[i]`. */
-export declare function buildDocumentPositions(text: string, parsedDocs: Document[]): DocumentPosition[];
+export declare function buildDocumentPositions(text: string, parsedDocs: AstDocument[]): DocumentPosition[];
 /** Line numbers (0-indexed) where each YAML document in a multi-doc file
  *  starts. The first document is always at line 0; subsequent entries point
  *  to the line after each `---` separator.
@@ -26,11 +26,12 @@ export declare function documentLineOffsets(text: string): number[];
  *  the first character on line `i`. Used with `offsetToPosition` to turn a
  *  yaml-AST node range into Range coordinates. */
 export declare function buildLineOffsets(text: string): number[];
-/** Walks the YAML AST and records source ranges for every field value, keyed
+export declare function offsetToPosition(offset: number, lineOffsets: number[]): Position;
+/** Walks the AST and records source ranges for every field value, keyed
  *  by dotted path (e.g. "kind", "config.handler", "config.routes[0].path").
  *  Map keys are also recorded under the `@key:<path>` namespace so diagnostic
  *  resolvers can squiggle just the key identifier instead of the full value
  *  block — used when a diagnostic targets a missing child property and the
  *  resolver has to fall back to the parent. */
-export declare function buildPositionIndex(doc: Document, lineOffsets: number[]): PositionIndex;
+export declare function buildPositionIndex(doc: AstDocument, lineOffsets: number[]): PositionIndex;
 //# sourceMappingURL=position-metadata.d.ts.map

package/dist/position-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position-metadata.d.ts","sourceRoot":"","sources":["../src/position-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrE,OAAO,KAAK,EAAY,aAAa,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;oBAKoB;AAEpB,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,kEAAkE;AAClE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,QAAQ,EAAE,GACrB,gBAAgB,EAAE,CAOpB;AAED;;;;;;;wCAOwC;AACxC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAW1D;AAED;;kDAEkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvD;AAaD;;;;;+CAK+C;AAC/C,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CA0CtF"}
+{"version":3,"file":"position-metadata.d.ts","sourceRoot":"","sources":["../src/position-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAW,MAAM,eAAe,CAAC;AAE1D;;;;;oBAKoB;AAEpB,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,kEAAkE;AAClE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,WAAW,EAAE,GACxB,gBAAgB,EAAE,CAOpB;AAED;;;;;;;wCAOwC;AACxC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAW1D;AAED;;kDAEkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,QAAQ,CAShF;AAED;;;;;+CAK+C;AAC/C,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CAsCzF"}

package/dist/position-metadata.js

@@ -1,4 +1,3 @@
-import { isMap, isPair, isScalar, isSeq } from "yaml";
 /** Builds DocumentPosition entries aligned to `parsedDocs[i]`. */
 export function buildDocumentPositions(text, parsedDocs) {
     const docOffsets = documentLineOffsets(text);
@@ -40,7 +39,7 @@ export function buildLineOffsets(text) {
     }
     return offsets;
 }
-function offsetToPosition(offset, lineOffsets) {
+export function offsetToPosition(offset, lineOffsets) {
     let lo = 0;
     let hi = lineOffsets.length - 1;
     while (lo < hi) {
@@ -52,7 +51,7 @@ function offsetToPosition(offset, lineOffsets) {
     }
     return { line: lo, character: offset - lineOffsets[lo] };
 }
-/** Walks the YAML AST and records source ranges for every field value, keyed
+/** Walks the AST and records source ranges for every field value, keyed
  *  by dotted path (e.g. "kind", "config.handler", "config.routes[0].path").
  *  Map keys are also recorded under the `@key:<path>` namespace so diagnostic
  *  resolvers can squiggle just the key identifier instead of the full value
@@ -61,33 +60,27 @@ function offsetToPosition(offset, lineOffsets) {
 export function buildPositionIndex(doc, lineOffsets) {
     const index = new Map();
     function recordNode(node, path) {
-        if (!node || !node.range)
-            return;
-        const [start, , end] = node.range;
+        const [start, end] = node.range;
         index.set(path, {
             start: offsetToPosition(start, lineOffsets),
             end: offsetToPosition(end, lineOffsets),
         });
     }
     function walk(node, path) {
-        if (isMap(node)) {
-            for (const pair of node.items) {
-                if (!isPair(pair))
-                    continue;
-                const key = isScalar(pair.key) ? String(pair.key.value) : null;
+        if (node.kind === "map") {
+            for (const pair of node.entries) {
+                const key = pair.key.kind === "scalar" ? String(pair.key.value) : null;
                 if (key == null)
                     continue;
                 const childPath = path ? `${path}.${key}` : key;
-                if (pair.key && pair.key.range) {
-                    recordNode(pair.key, `@key:${childPath}`);
-                }
-                if (pair.value != null) {
+                recordNode(pair.key, `@key:${childPath}`);
+                if (pair.value) {
                     recordNode(pair.value, childPath);
                     walk(pair.value, childPath);
                 }
             }
         }
-        else if (isSeq(node)) {
+        else if (node.kind === "seq") {
             for (let i = 0; i < node.items.length; i++) {
                 const item = node.items[i];
                 const childPath = `${path}[${i}]`;
@@ -96,8 +89,8 @@ export function buildPositionIndex(doc, lineOffsets) {
             }
         }
     }
-    if (doc.contents) {
-        walk(doc.contents, "");
+    if (doc.root) {
+        walk(doc.root, "");
     }
     return index;
 }

package/dist/yaml-ast.d.ts

@@ -0,0 +1,46 @@
+import { type Document } from "yaml";
+import { type CelSegment } from "./cel-ast.js";
+/** Read-only YAML node model owned by the analyzer — the shared, browser-safe
+ *  structural source of truth for every IDE feature. Ranges are `[start, end]`
+ *  in byte offsets (yaml's value-end, so a range spans exactly the node's own
+ *  text, not the trailing newline). `yaml` is an internal implementation
+ *  detail behind `parseToAst`; no consumer imports it to read structure. */
+export type AstNode = AstMap | AstSeq | AstScalar;
+export interface AstMap {
+    kind: "map";
+    range: [number, number];
+    entries: AstPair[];
+}
+export interface AstSeq {
+    kind: "seq";
+    range: [number, number];
+    items: AstNode[];
+}
+export interface AstScalar {
+    kind: "scalar";
+    range: [number, number];
+    /** Resolved scalar value — a `TaggedSentinel` for `!cel` / `!ref` scalars. */
+    value: unknown;
+    /** The scalar's tag when present (`!cel`, `!ref`, …). */
+    tag?: string;
+    /** The embedded CEL regions (lazy — nothing parses CEL until called). */
+    celSegments(): CelSegment[];
+}
+export interface AstPair {
+    key: AstNode;
+    value?: AstNode;
+}
+export interface AstDocument {
+    root?: AstNode;
+    /** Full document span `[start, end]` — used to select the `---` document a
+     *  cursor offset falls in. */
+    range: [number, number];
+}
+/** Parse `text` into the read-only AST. Wraps `parseAllDocuments` with the
+ *  repo's custom tags (`!cel` / `!ref`) and adapts each `yaml` tree into a
+ *  thin `AstNode` view — CEL parsing stays deferred to `celSegments().ast()`. */
+export declare function parseToAst(text: string): AstDocument[];
+/** Adapt one already-parsed `yaml.Document` into an `AstDocument`. Lets a host
+ *  that already parsed for analysis reuse that parse instead of re-parsing. */
+export declare function documentToAst(doc: Document, text: string): AstDocument;
+//# sourceMappingURL=yaml-ast.d.ts.map

package/dist/yaml-ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-ast.d.ts","sourceRoot":"","sources":["../src/yaml-ast.ts"],"names":[],"mappings":"AACA,OAAO,EAA6C,KAAK,QAAQ,EAAa,MAAM,MAAM,CAAC;AAC3F,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEjE;;;;4EAI4E;AAC5E,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAElD,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,OAAO,EAAE,OAAO,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,8EAA8E;IAC9E,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,WAAW,IAAI,UAAU,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;kCAC8B;IAC9B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB;AAED;;iFAEiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAGtD;AAED;+EAC+E;AAC/E,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAMtE"}

package/dist/yaml-ast.js

@@ -0,0 +1,58 @@
+import { defaultCustomTags, isTaggedSentinel } from "@telorun/templating";
+import { isMap, isScalar, isSeq, parseAllDocuments } from "yaml";
+import { buildCelSegments } from "./cel-ast.js";
+/** Parse `text` into the read-only AST. Wraps `parseAllDocuments` with the
+ *  repo's custom tags (`!cel` / `!ref`) and adapts each `yaml` tree into a
+ *  thin `AstNode` view — CEL parsing stays deferred to `celSegments().ast()`. */
+export function parseToAst(text) {
+    const documents = parseAllDocuments(text, { customTags: defaultCustomTags() });
+    return documents.map((doc) => documentToAst(doc, text));
+}
+/** Adapt one already-parsed `yaml.Document` into an `AstDocument`. Lets a host
+ *  that already parsed for analysis reuse that parse instead of re-parsing. */
+export function documentToAst(doc, text) {
+    const r = doc.range;
+    return {
+        root: doc.contents ? adaptNode(doc.contents, text) : undefined,
+        range: r ? [r[0], r[2]] : [0, text.length],
+    };
+}
+function nodeRange(node) {
+    const r = node.range;
+    return r ? [r[0], r[1]] : [0, 0];
+}
+function adaptNode(node, text) {
+    if (isMap(node)) {
+        const entries = [];
+        for (const item of node.items) {
+            const key = adaptNode(item.key, text);
+            if (!key)
+                continue;
+            const value = item.value != null ? adaptNode(item.value, text) : undefined;
+            entries.push({ key, value });
+        }
+        return { kind: "map", range: nodeRange(node), entries };
+    }
+    if (isSeq(node)) {
+        const items = [];
+        for (const item of node.items) {
+            const adapted = adaptNode(item, text);
+            if (adapted)
+                items.push(adapted);
+        }
+        return { kind: "seq", range: nodeRange(node), items };
+    }
+    if (isScalar(node)) {
+        const range = nodeRange(node);
+        const value = node.value;
+        const tag = typeof node.tag === "string" ? node.tag : undefined;
+        return {
+            kind: "scalar",
+            range,
+            value,
+            tag,
+            celSegments: () => buildCelSegments(text.slice(range[0], range[1]), range[0], tag, isTaggedSentinel(value) ? value.source : undefined),
+        };
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.40.0",
+  "version": "0.41.1",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -42,7 +42,7 @@
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
     "yaml": "^2.8.3",
-    "@telorun/templating": "0.10.1"
+    "@telorun/templating": "0.11.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/cel-ast.ts

@@ -0,0 +1,259 @@
+import { parse, type ASTNode as CelJsNode } from "@marcbachmann/cel-js";
+
+/** Read-only CEL expression tree owned by the analyzer. The third-party
+ *  `@marcbachmann/cel-js` `ASTNode` stays an internal detail — `wrapCelAst`
+ *  translates it into this union so no external AST type leaks through the
+ *  public surface (full symmetry with the YAML `AstNode` decision). Every
+ *  `range` is `[start, end]` in DOCUMENT offsets. */
+export type CelNode =
+  | { kind: "literal"; range: [number, number]; value: unknown }
+  | { kind: "ident"; range: [number, number]; name: string }
+  | {
+      kind: "member";
+      range: [number, number];
+      target: CelNode;
+      property: string;
+      /** Span of just the `.prop` identifier, for a future rename. */
+      propertyRange: [number, number];
+      /** `.?` optional member access. */
+      optional: boolean;
+    }
+  | {
+      kind: "index";
+      range: [number, number];
+      target: CelNode;
+      index: CelNode;
+      /** `[?]` optional index. */
+      optional: boolean;
+    }
+  | { kind: "call"; range: [number, number]; name: string; args: CelNode[] }
+  | {
+      kind: "methodCall";
+      range: [number, number];
+      name: string;
+      receiver: CelNode;
+      args: CelNode[];
+    }
+  | { kind: "list"; range: [number, number]; items: CelNode[] }
+  | { kind: "map"; range: [number, number]; entries: { key: CelNode; value: CelNode }[] }
+  | {
+      kind: "ternary";
+      range: [number, number];
+      cond: CelNode;
+      then: CelNode;
+      else: CelNode;
+    }
+  | { kind: "unary"; range: [number, number]; op: string; operand: CelNode }
+  | { kind: "binary"; range: [number, number]; op: string; left: CelNode; right: CelNode };
+
+/** A `${{ }}` / `!cel` region inside a YAML scalar. Ranges are DOCUMENT
+ *  offsets; `source` is the CEL body (a longest-valid prefix when `open`).
+ *  `ast()` parses lazily — nothing parses CEL during `parseToAst`, only the
+ *  expression a caller actually inspects. */
+export interface CelSegment {
+  /** Segment span in document offsets (includes the `${{ }}` for interpolation). */
+  range: [number, number];
+  /** The CEL body (a prefix when `open`). */
+  source: string;
+  /** True when a `${{` has no matching `}}` yet (the user is mid-typing). */
+  open: boolean;
+  /** Lazily parse + wrap; ranges are already absolute. */
+  ast(): CelNode;
+}
+
+const BINARY_OPS = new Set([
+  "!=",
+  "==",
+  "in",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "||",
+  "&&",
+]);
+
+/** Maps a `@marcbachmann/cel-js` node into the analyzer `CelNode`, translating
+ *  each node's segment-relative `start`/`end` to absolute document offsets by
+ *  adding `segmentStart`. */
+export function wrapCelAst(node: CelJsNode, segmentStart: number): CelNode {
+  const range = abs(node, segmentStart);
+  const op = node.op;
+  const args = node.args as unknown;
+
+  if (op === "value") return { kind: "literal", range, value: args };
+  if (op === "id") return { kind: "ident", range, name: String(args) };
+  if (op === "." || op === ".?") {
+    const [target, property] = args as [CelJsNode, string];
+    return {
+      kind: "member",
+      range,
+      target: wrapCelAst(target, segmentStart),
+      property,
+      propertyRange: [range[1] - property.length, range[1]],
+      optional: op === ".?",
+    };
+  }
+  if (op === "[]" || op === "[?]") {
+    const [target, index] = args as [CelJsNode, CelJsNode];
+    return {
+      kind: "index",
+      range,
+      target: wrapCelAst(target, segmentStart),
+      index: wrapCelAst(index, segmentStart),
+      optional: op === "[?]",
+    };
+  }
+  if (op === "call") {
+    const [name, callArgs] = args as [string, CelJsNode[]];
+    return { kind: "call", range, name, args: callArgs.map((a) => wrapCelAst(a, segmentStart)) };
+  }
+  if (op === "rcall") {
+    const [name, receiver, callArgs] = args as [string, CelJsNode, CelJsNode[]];
+    return {
+      kind: "methodCall",
+      range,
+      name,
+      receiver: wrapCelAst(receiver, segmentStart),
+      args: callArgs.map((a) => wrapCelAst(a, segmentStart)),
+    };
+  }
+  if (op === "list") {
+    return { kind: "list", range, items: (args as CelJsNode[]).map((a) => wrapCelAst(a, segmentStart)) };
+  }
+  if (op === "map") {
+    return {
+      kind: "map",
+      range,
+      entries: (args as [CelJsNode, CelJsNode][]).map(([k, v]) => ({
+        key: wrapCelAst(k, segmentStart),
+        value: wrapCelAst(v, segmentStart),
+      })),
+    };
+  }
+  if (op === "?:") {
+    const [cond, then, els] = args as [CelJsNode, CelJsNode, CelJsNode];
+    return {
+      kind: "ternary",
+      range,
+      cond: wrapCelAst(cond, segmentStart),
+      then: wrapCelAst(then, segmentStart),
+      else: wrapCelAst(els, segmentStart),
+    };
+  }
+  if (op === "!_" || op === "-_") {
+    return { kind: "unary", range, op, operand: wrapCelAst(args as CelJsNode, segmentStart) };
+  }
+  if (BINARY_OPS.has(op)) {
+    const [left, right] = args as [CelJsNode, CelJsNode];
+    return {
+      kind: "binary",
+      range,
+      op,
+      left: wrapCelAst(left, segmentStart),
+      right: wrapCelAst(right, segmentStart),
+    };
+  }
+  // Unknown operator — surface it as a literal so consumers can still hit-test
+  // the range rather than crash on an unmapped node.
+  return { kind: "literal", range, value: undefined };
+}
+
+function abs(node: CelJsNode, segmentStart: number): [number, number] {
+  const r = node.range ?? { start: node.start, end: node.end };
+  return [r.start + segmentStart, r.end + segmentStart];
+}
+
+/** Parse `source` and wrap it, tolerating a trailing partial member/index
+ *  access (`req.`, `req.fo`) by falling back to the longest parseable prefix.
+ *  Used for `open` segments where completion fires mid-token. */
+function parseLenient(source: string, segmentStart: number, range: [number, number]): CelNode {
+  const candidates = [source, source.replace(/[.?[]+\w*$/, ""), source.replace(/[.?[(]+.*$/, "")];
+  for (const candidate of candidates) {
+    const trimmed = candidate.trim();
+    if (!trimmed) break;
+    try {
+      return wrapCelAst(parse(trimmed).ast, segmentStart);
+    } catch {
+      // try the next-shorter prefix
+    }
+  }
+  return { kind: "ident", range, name: source.trim() };
+}
+
+const OPEN_MARKER = "${{";
+
+/** Build the CEL segments of a scalar from its raw source slice. `scalarText`
+ *  is `text.slice(start, valueEnd)` and `scalarStart` its document offset.
+ *
+ *  - `tag === "!cel"` → one closed segment spanning the tagged body.
+ *  - otherwise → one closed segment per `${{ … }}` match, plus a trailing
+ *    `open` segment for a dangling `${{` with no `}}` (bounded to its line, so
+ *    an unterminated quote that swallowed following lines still recovers the
+ *    region the user is typing in). */
+export function buildCelSegments(
+  scalarText: string,
+  scalarStart: number,
+  tag: string | undefined,
+  taggedSource: string | undefined,
+): CelSegment[] {
+  if (tag === "!cel" && taggedSource != null) {
+    const idx = scalarText.indexOf(taggedSource);
+    const bodyStart = scalarStart + (idx >= 0 ? idx : 0);
+    const range: [number, number] = [bodyStart, bodyStart + taggedSource.length];
+    return [
+      {
+        range,
+        source: taggedSource,
+        open: false,
+        ast: () => wrapCelAst(parse(taggedSource).ast, bodyStart),
+      },
+    ];
+  }
+
+  const segments: CelSegment[] = [];
+  const re = /\$\{\{([\s\S]*?)\}\}/g;
+  let match: RegExpExecArray | null;
+  let lastClosedEnd = 0;
+  while ((match = re.exec(scalarText)) !== null) {
+    const whole = match[0];
+    const inner = match[1];
+    const leadingWs = inner.match(/^\s*/)?.[0].length ?? 0;
+    const bodyStart = scalarStart + match.index + OPEN_MARKER.length + leadingWs;
+    const source = inner.trim();
+    segments.push({
+      range: [scalarStart + match.index, scalarStart + match.index + whole.length],
+      source,
+      open: false,
+      ast: () => wrapCelAst(parse(source).ast, bodyStart),
+    });
+    lastClosedEnd = match.index + whole.length;
+  }
+
+  const openIdx = scalarText.indexOf(OPEN_MARKER, lastClosedEnd);
+  if (openIdx >= 0 && scalarText.indexOf("}}", openIdx) < 0) {
+    let lineEnd = scalarText.indexOf("\n", openIdx);
+    if (lineEnd < 0) lineEnd = scalarText.length;
+    const after = openIdx + OPEN_MARKER.length;
+    // Drop a trailing scalar-closing quote so `foo: "${{ req"` recovers `req`,
+    // not `req"` — the quote closes the YAML string, it isn't part of the CEL.
+    const rawBody = scalarText.slice(after, lineEnd).replace(/["']\s*$/, "");
+    const leadingWs = rawBody.match(/^\s*/)?.[0].length ?? 0;
+    const bodyStart = scalarStart + after + leadingWs;
+    const source = rawBody.trim();
+    const range: [number, number] = [scalarStart + openIdx, scalarStart + lineEnd];
+    segments.push({
+      range,
+      source,
+      open: true,
+      ast: () => parseLenient(source, bodyStart, range),
+    });
+  }
+
+  return segments;
+}

package/src/index.ts

@@ -68,6 +68,7 @@ export {
     buildLineOffsets,
     buildPositionIndex,
     documentLineOffsets,
+    offsetToPosition,
 } from "./position-metadata.js";
 export type { DocumentPosition } from "./position-metadata.js";
 export { HttpSource } from "./sources/http-source.js";
@@ -97,6 +98,10 @@ export {
 } from "./sources/manifest-cache.js";
 export type { ManifestCacheCoords } from "./sources/manifest-cache.js";
 export { withSyntheticPositions } from "./with-synthetic-positions.js";
+export { documentToAst, parseToAst } from "./yaml-ast.js";
+export type { AstDocument, AstMap, AstNode, AstPair, AstScalar, AstSeq } from "./yaml-ast.js";
+export { buildCelSegments, wrapCelAst } from "./cel-ast.js";
+export type { CelNode, CelSegment } from "./cel-ast.js";
 export { DEFAULT_MANIFEST_FILENAME, DiagnosticSeverity } from "./types.js";
 export type {
     AnalysisDiagnostic,

package/src/loaded-types.ts

@@ -2,6 +2,7 @@ import type { ResourceManifest } from "@telorun/sdk";
 import type { Document } from "yaml";
 import type { DocumentPosition } from "./position-metadata.js";
 import type { AnalysisDiagnostic, Range } from "./types.js";
+import type { AstDocument } from "./yaml-ast.js";
 
 /** One physical file's parsed result. Returned for the owner manifest, for
  *  each `include:` partial, and for each external import target.
@@ -17,8 +18,13 @@ export interface LoadedFile {
   requestedUrl: string;
   /** Raw text exactly as `read()` returned it. */
   text: string;
-  /** Per-document parsed AST, in source order. */
+  /** Per-document parsed `yaml` AST, in source order. The editor's mutable
+   *  round-trip model reads this handle; structure-only consumers use the
+   *  read-only `astDocuments` instead so `yaml` stays an internal detail. */
   documents: Document[];
+  /** Per-document read-only `AstNode` view (`yaml`-free), aligned to
+   *  `documents`. The shared structural source of truth for IDE features. */
+  astDocuments: AstDocument[];
   /** Per-document JSON projection (`doc.toJSON()`). Aligned to `documents`. */
   manifests: Array<ResourceManifest | null>;
   /** Per-document `{sourceLine, positionIndex}`. Aligned to `documents`. */

package/src/parse-loaded-file.ts

@@ -6,6 +6,7 @@ import { buildCelEnvironment } from "./cel-environment.js";
 import type { LoadedFile, ParseError } from "./loaded-types.js";
 import { buildDocumentPositions } from "./position-metadata.js";
 import { precompileDoc } from "./precompile.js";
+import { documentToAst } from "./yaml-ast.js";
 
 export interface ParseOptions {
   /** When true, runs `precompileDoc` per document and stamps compiled CEL
@@ -49,7 +50,8 @@ export function parseLoadedFile(
   options?: ParseOptions,
 ): LoadedFile {
   const documents = parseAllDocuments(text, { customTags: defaultCustomTags() });
-  const positions = buildDocumentPositions(text, documents);
+  const astDocuments = documents.map((doc) => documentToAst(doc, text));
+  const positions = buildDocumentPositions(text, astDocuments);
 
   const parseErrors: ParseError[] = [];
   documents.forEach((doc, documentIndex) => {
@@ -90,6 +92,7 @@ export function parseLoadedFile(
     requestedUrl,
     text,
     documents,
+    astDocuments,
     manifests,
     positions,
     parseErrors,

package/src/position-metadata.ts

@@ -1,10 +1,10 @@
-import { isMap, isPair, isScalar, isSeq, type Document } from "yaml";
 import type { Position, PositionIndex } from "./types.js";
+import type { AstDocument, AstNode } from "./yaml-ast.js";
 
 /** Single source of truth for "given the source text of a multi-document YAML
  *  file, where does each document start, and what is the byte→(line,char)
  *  table for the file." Both the analyzer's `Loader` and editor frontends
- *  feed the same parsed `yaml.Document[]` through this so diagnostics
+ *  feed the same adapted `AstDocument[]` through this so diagnostics
  *  resolved against `positionIndex` / `sourceLine` line up identically
  *  across hosts. */
 
@@ -17,7 +17,7 @@ export interface DocumentPosition {
 /** Builds DocumentPosition entries aligned to `parsedDocs[i]`. */
 export function buildDocumentPositions(
   text: string,
-  parsedDocs: Document[],
+  parsedDocs: AstDocument[],
 ): DocumentPosition[] {
   const docOffsets = documentLineOffsets(text);
   const lineOffsets = buildLineOffsets(text);
@@ -59,7 +59,7 @@ export function buildLineOffsets(text: string): number[] {
   return offsets;
 }
 
-function offsetToPosition(offset: number, lineOffsets: number[]): Position {
+export function offsetToPosition(offset: number, lineOffsets: number[]): Position {
   let lo = 0;
   let hi = lineOffsets.length - 1;
   while (lo < hi) {
@@ -70,40 +70,36 @@ function offsetToPosition(offset: number, lineOffsets: number[]): Position {
   return { line: lo, character: offset - lineOffsets[lo] };
 }
 
-/** Walks the YAML AST and records source ranges for every field value, keyed
+/** Walks the AST and records source ranges for every field value, keyed
  *  by dotted path (e.g. "kind", "config.handler", "config.routes[0].path").
  *  Map keys are also recorded under the `@key:<path>` namespace so diagnostic
  *  resolvers can squiggle just the key identifier instead of the full value
  *  block — used when a diagnostic targets a missing child property and the
  *  resolver has to fall back to the parent. */
-export function buildPositionIndex(doc: Document, lineOffsets: number[]): PositionIndex {
+export function buildPositionIndex(doc: AstDocument, lineOffsets: number[]): PositionIndex {
   const index: PositionIndex = new Map();
 
-  function recordNode(node: any, path: string): void {
-    if (!node || !node.range) return;
-    const [start, , end] = node.range as [number, number, number];
+  function recordNode(node: AstNode, path: string): void {
+    const [start, end] = node.range;
     index.set(path, {
       start: offsetToPosition(start, lineOffsets),
       end: offsetToPosition(end, lineOffsets),
     });
   }
 
-  function walk(node: any, path: string): void {
-    if (isMap(node)) {
-      for (const pair of node.items) {
-        if (!isPair(pair)) continue;
-        const key = isScalar(pair.key) ? String(pair.key.value) : null;
+  function walk(node: AstNode, path: string): void {
+    if (node.kind === "map") {
+      for (const pair of node.entries) {
+        const key = pair.key.kind === "scalar" ? String(pair.key.value) : null;
         if (key == null) continue;
         const childPath = path ? `${path}.${key}` : key;
-        if (pair.key && (pair.key as any).range) {
-          recordNode(pair.key, `@key:${childPath}`);
-        }
-        if (pair.value != null) {
+        recordNode(pair.key, `@key:${childPath}`);
+        if (pair.value) {
           recordNode(pair.value, childPath);
           walk(pair.value, childPath);
         }
       }
-    } else if (isSeq(node)) {
+    } else if (node.kind === "seq") {
       for (let i = 0; i < node.items.length; i++) {
         const item = node.items[i];
         const childPath = `${path}[${i}]`;
@@ -113,8 +109,8 @@ export function buildPositionIndex(doc: Document, lineOffsets: number[]): Positi
     }
   }
 
-  if (doc.contents) {
-    walk(doc.contents, "");
+  if (doc.root) {
+    walk(doc.root, "");
   }
 
   return index;

package/src/yaml-ast.ts

@@ -0,0 +1,108 @@
+import { defaultCustomTags, isTaggedSentinel } from "@telorun/templating";
+import { isMap, isScalar, isSeq, parseAllDocuments, type Document, type Node } from "yaml";
+import { buildCelSegments, type CelSegment } from "./cel-ast.js";
+
+/** Read-only YAML node model owned by the analyzer — the shared, browser-safe
+ *  structural source of truth for every IDE feature. Ranges are `[start, end]`
+ *  in byte offsets (yaml's value-end, so a range spans exactly the node's own
+ *  text, not the trailing newline). `yaml` is an internal implementation
+ *  detail behind `parseToAst`; no consumer imports it to read structure. */
+export type AstNode = AstMap | AstSeq | AstScalar;
+
+export interface AstMap {
+  kind: "map";
+  range: [number, number];
+  entries: AstPair[];
+}
+
+export interface AstSeq {
+  kind: "seq";
+  range: [number, number];
+  items: AstNode[];
+}
+
+export interface AstScalar {
+  kind: "scalar";
+  range: [number, number];
+  /** Resolved scalar value — a `TaggedSentinel` for `!cel` / `!ref` scalars. */
+  value: unknown;
+  /** The scalar's tag when present (`!cel`, `!ref`, …). */
+  tag?: string;
+  /** The embedded CEL regions (lazy — nothing parses CEL until called). */
+  celSegments(): CelSegment[];
+}
+
+export interface AstPair {
+  key: AstNode;
+  value?: AstNode;
+}
+
+export interface AstDocument {
+  root?: AstNode;
+  /** Full document span `[start, end]` — used to select the `---` document a
+   *  cursor offset falls in. */
+  range: [number, number];
+}
+
+/** Parse `text` into the read-only AST. Wraps `parseAllDocuments` with the
+ *  repo's custom tags (`!cel` / `!ref`) and adapts each `yaml` tree into a
+ *  thin `AstNode` view — CEL parsing stays deferred to `celSegments().ast()`. */
+export function parseToAst(text: string): AstDocument[] {
+  const documents = parseAllDocuments(text, { customTags: defaultCustomTags() });
+  return documents.map((doc) => documentToAst(doc, text));
+}
+
+/** Adapt one already-parsed `yaml.Document` into an `AstDocument`. Lets a host
+ *  that already parsed for analysis reuse that parse instead of re-parsing. */
+export function documentToAst(doc: Document, text: string): AstDocument {
+  const r = doc.range as [number, number, number] | null | undefined;
+  return {
+    root: doc.contents ? adaptNode(doc.contents, text) : undefined,
+    range: r ? [r[0], r[2]] : [0, text.length],
+  };
+}
+
+function nodeRange(node: Node): [number, number] {
+  const r = node.range as [number, number, number] | null | undefined;
+  return r ? [r[0], r[1]] : [0, 0];
+}
+
+function adaptNode(node: Node, text: string): AstNode | undefined {
+  if (isMap(node)) {
+    const entries: AstPair[] = [];
+    for (const item of node.items) {
+      const key = adaptNode(item.key as Node, text);
+      if (!key) continue;
+      const value = item.value != null ? adaptNode(item.value as Node, text) : undefined;
+      entries.push({ key, value });
+    }
+    return { kind: "map", range: nodeRange(node), entries };
+  }
+  if (isSeq(node)) {
+    const items: AstNode[] = [];
+    for (const item of node.items) {
+      const adapted = adaptNode(item as Node, text);
+      if (adapted) items.push(adapted);
+    }
+    return { kind: "seq", range: nodeRange(node), items };
+  }
+  if (isScalar(node)) {
+    const range = nodeRange(node);
+    const value = node.value;
+    const tag = typeof node.tag === "string" ? node.tag : undefined;
+    return {
+      kind: "scalar",
+      range,
+      value,
+      tag,
+      celSegments: () =>
+        buildCelSegments(
+          text.slice(range[0], range[1]),
+          range[0],
+          tag,
+          isTaggedSentinel(value) ? value.source : undefined,
+        ),
+    };
+  }
+  return undefined;
+}