@telorun/analyzer 0.8.1 → 0.9.0

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

@@ -0,0 +1,12 @@
+import type { Environment } from "@marcbachmann/cel-js";
+import type { LoadedFile } from "./loaded-types.js";
+export interface ParseOptions {
+    /** When true, runs `precompileDoc` per document and stamps compiled CEL
+     *  on the manifests — same flag `LoadOptions.compile` carries today. */
+    compile?: boolean;
+    /** CEL environment for precompile. Defaults to `buildCelEnvironment()`. */
+    celEnv?: Environment;
+}
+/** Pure: text in, structured load result out. No I/O, no caches. */
+export declare function parseLoadedFile(source: string, requestedUrl: string, text: string, options?: ParseOptions): LoadedFile;
+//# sourceMappingURL=parse-loaded-file.d.ts.map

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

@@ -0,0 +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;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CA8CZ"}

package/dist/parse-loaded-file.js

@@ -0,0 +1,50 @@
+import { defaultCustomTags } from "@telorun/templating";
+import { parseAllDocuments } from "yaml";
+import { buildCelEnvironment } from "./cel-environment.js";
+import { buildDocumentPositions } from "./position-metadata.js";
+import { precompileDoc } from "./precompile.js";
+/** 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 parseErrors = [];
+    documents.forEach((doc, documentIndex) => {
+        for (const err of doc.errors) {
+            parseErrors.push({
+                documentIndex,
+                message: err.message,
+            });
+        }
+    });
+    const manifests = [];
+    let env;
+    for (const doc of documents) {
+        const raw = doc.toJSON();
+        if (raw === null || raw === undefined) {
+            manifests.push(null);
+            continue;
+        }
+        if (options?.compile) {
+            env ??= options.celEnv ?? buildCelEnvironment();
+            try {
+                const compiled = precompileDoc(raw, env);
+                manifests.push(compiled);
+            }
+            catch (error) {
+                throw new Error(`Failed to compile manifest in ${source}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            manifests.push(raw);
+        }
+    }
+    return {
+        source,
+        requestedUrl,
+        text,
+        documents,
+        manifests,
+        positions,
+        parseErrors,
+    };
+}

package/dist/position-metadata.d.ts

@@ -0,0 +1,27 @@
+import { type Document } from "yaml";
+import type { PositionIndex } from "./types.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
+ *  resolved against `positionIndex` / `sourceLine` line up identically
+ *  across hosts. */
+/** Per-document position metadata used by `normalizeDiagnostic`'s fallback chain. */
+export interface DocumentPosition {
+    sourceLine: number;
+    positionIndex: PositionIndex;
+}
+/** Builds DocumentPosition entries aligned to `parsedDocs[i]`. */
+export declare function buildDocumentPositions(text: string, parsedDocs: Document[]): 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 `---` directive. */
+export declare function documentLineOffsets(text: string): number[];
+/** Byte-offset → start-of-line lookup table. Index `i` is the byte offset of
+ *  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
+ *  by dotted path (e.g. "kind", "config.handler", "config.routes[0].path"). */
+export declare function buildPositionIndex(doc: Document, lineOffsets: number[]): PositionIndex;
+//# sourceMappingURL=position-metadata.d.ts.map

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

@@ -0,0 +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;;8CAE8C;AAC9C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ1D;AAED;;kDAEkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvD;AAaD;+EAC+E;AAC/E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CAuCtF"}

package/dist/position-metadata.js

@@ -0,0 +1,88 @@
+import { isMap, isPair, isScalar, isSeq } from "yaml";
+/** Builds DocumentPosition entries aligned to `parsedDocs[i]`. */
+export function buildDocumentPositions(text, parsedDocs) {
+    const docOffsets = documentLineOffsets(text);
+    const lineOffsets = buildLineOffsets(text);
+    return parsedDocs.map((doc, i) => ({
+        sourceLine: docOffsets[i] ?? 0,
+        positionIndex: buildPositionIndex(doc, lineOffsets),
+    }));
+}
+/** 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 `---` directive. */
+export function documentLineOffsets(text) {
+    const offsets = [0];
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const t = lines[i].trimEnd();
+        if (t === "---" || t.startsWith("--- "))
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+/** Byte-offset → start-of-line lookup table. Index `i` is the byte offset of
+ *  the first character on line `i`. Used with `offsetToPosition` to turn a
+ *  yaml-AST node range into Range coordinates. */
+export function buildLineOffsets(text) {
+    const offsets = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n")
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+function offsetToPosition(offset, lineOffsets) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineOffsets[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return { line: lo, character: offset - lineOffsets[lo] };
+}
+/** Walks the YAML AST and records source ranges for every field value, keyed
+ *  by dotted path (e.g. "kind", "config.handler", "config.routes[0].path"). */
+export function buildPositionIndex(doc, lineOffsets) {
+    const index = new Map();
+    function recordNode(node, path) {
+        if (!node || !node.range)
+            return;
+        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 (key == null)
+                    continue;
+                const childPath = path ? `${path}.${key}` : key;
+                if (pair.value != null) {
+                    recordNode(pair.value, childPath);
+                    walk(pair.value, childPath);
+                }
+            }
+        }
+        else if (isSeq(node)) {
+            for (let i = 0; i < node.items.length; i++) {
+                const item = node.items[i];
+                const childPath = `${path}[${i}]`;
+                recordNode(item, childPath);
+                walk(item, childPath);
+            }
+        }
+    }
+    if (doc.contents) {
+        walk(doc.contents, "");
+    }
+    return index;
+}

package/dist/types.d.ts

@@ -83,5 +83,11 @@ export interface AnalysisOptions {
 export interface AnalysisContext {
     aliases?: import("./alias-resolver.js").AliasResolver;
     definitions?: import("./definition-registry.js").DefinitionRegistry;
+    /** Per-library alias resolvers keyed by the library's module name. Populated by
+     *  the analyzer when imports are forwarded from inside imported libraries.
+     *  Validators that resolve schema-side annotations (e.g. x-telo-schema-from
+     *  pointing at an imported kind) consult the kind owner's scope here, since
+     *  the consumer's aliases will not contain a library's private imports. */
+    aliasesByModule?: Map<string, import("./alias-resolver.js").AliasResolver>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,cAAc,CAAC;AAErD,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD;;qEAEiE;IACjE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEjE;;qEAEiE;IACjE,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;6FACyF;IACzF,WAAW,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;CACrE"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,cAAc,CAAC;AAErD,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD;;qEAEiE;IACjE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEjE;;qEAEiE;IACjE,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;6FACyF;IACzF,WAAW,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;IACpE;;;;+EAI2E;IAC3E,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC,CAAC;CAC5E"}

package/dist/validate-references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAkD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAkQtB"}
+{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAkD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAsUtB"}

package/dist/validate-references.js

@@ -61,6 +61,7 @@ export function validateReferences(resources, context) {
     const diagnostics = [];
     const aliases = context.aliases;
     const registry = context.definitions;
+    const aliasesByModule = context.aliasesByModule;
     if (!aliases || !registry)
         return diagnostics;
     // Build outer resource lookup by name for resolution check.
@@ -228,6 +229,67 @@ export function validateReferences(resources, context) {
             }
             const anchorName = expr.slice(0, slashIdx);
             const jsonPointer = "/" + expr.slice(slashIdx + 1);
+            // Aliased absolute kind path — first segment carries a dot, e.g.
+            // "HttpDispatch.Outcomes/$defs/Returns". Resolves the alias through the
+            // *kind owner's* scope (not the consumer's), navigates the JSON Pointer
+            // into the resolved definition's schema, and validates each field value.
+            //
+            // Relative anchors are property names that cannot contain a dot
+            // (CEL-style identifiers), so a dot in anchorName is unambiguous.
+            if (!isAbsolute && anchorName.includes(".")) {
+                const resolvedResourceKind = aliases.resolveKind(r.kind) ?? r.kind;
+                const resourceDef = registry.resolve(r.kind) ?? registry.resolve(resolvedResourceKind);
+                const owningModule = resourceDef?.metadata?.module;
+                const ownerScope = (owningModule ? aliasesByModule?.get(owningModule) : undefined) ?? aliases;
+                const targetKind = ownerScope.resolveKind(anchorName);
+                if (!targetKind) {
+                    diagnostics.push({
+                        severity: DiagnosticSeverity.Error,
+                        code: "SCHEMA_FROM_MISSING_PATH",
+                        source: SOURCE,
+                        message: `${resourceLabel}: x-telo-schema-from at '${fieldPath}' → cannot resolve alias '${anchorName}'`,
+                        data: { resource: resourceData, filePath, path: fieldPath },
+                    });
+                    continue;
+                }
+                const targetDef = registry.resolve(targetKind);
+                if (!targetDef?.schema) {
+                    diagnostics.push({
+                        severity: DiagnosticSeverity.Error,
+                        code: "SCHEMA_FROM_MISSING_PATH",
+                        source: SOURCE,
+                        message: `${resourceLabel}: x-telo-schema-from at '${fieldPath}' → kind '${targetKind}' has no schema`,
+                        data: { resource: resourceData, filePath, path: fieldPath },
+                    });
+                    continue;
+                }
+                const subSchema = navigateJsonPointer(targetDef.schema, jsonPointer);
+                if (subSchema === undefined) {
+                    diagnostics.push({
+                        severity: DiagnosticSeverity.Error,
+                        code: "SCHEMA_FROM_MISSING_PATH",
+                        source: SOURCE,
+                        message: `${resourceLabel}: x-telo-schema-from at '${fieldPath}' → kind '${targetKind}' has no schema path '${jsonPointer}'`,
+                        data: { resource: resourceData, filePath, path: fieldPath },
+                    });
+                    continue;
+                }
+                for (const fieldValue of resolveFieldValues(r, fieldPath)) {
+                    if (fieldValue == null)
+                        continue;
+                    const issues = registry.validateWithRefs(fieldValue, subSchema);
+                    for (const issue of issues) {
+                        diagnostics.push({
+                            severity: DiagnosticSeverity.Error,
+                            code: "DEPENDENT_SCHEMA_MISMATCH",
+                            source: SOURCE,
+                            message: `${resourceLabel}: '${fieldPath}' does not match schema from '${anchorName}${jsonPointer}': ${issue}`,
+                            data: { resource: resourceData, filePath, path: fieldPath },
+                        });
+                    }
+                }
+                continue;
+            }
             // Derive the anchor path in the resource config.
             let anchorPath;
             if (isAbsolute) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -41,8 +41,8 @@
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
     "yaml": "^2.8.3",
-    "@telorun/sdk": "0.7.0",
-    "@telorun/templating": "0.2.1"
+    "@telorun/sdk": "0.10.0",
+    "@telorun/templating": "0.2.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/analysis-registry.ts

@@ -14,6 +14,7 @@ import type { AnalysisContext } from "./types.js";
 export class AnalysisRegistry {
   private readonly defs = new DefinitionRegistry();
   private readonly aliases = new AliasResolver();
+  private readonly aliasesByModule = new Map<string, AliasResolver>();
 
   registerDefinition(def: ResourceDefinition): void {
     this.defs.register(def);
@@ -94,6 +95,6 @@ export class AnalysisRegistry {
 
   /** @internal Bridge for StaticAnalyzer — do not use outside the analyzer package. */
   _context(): AnalysisContext {
-    return { aliases: this.aliases, definitions: this.defs };
+    return { aliases: this.aliases, definitions: this.defs, aliasesByModule: this.aliasesByModule };
   }
 }

package/src/analyzer.ts

@@ -433,7 +433,7 @@ export class StaticAnalyzer {
         rootModules.add(m.metadata.name as string);
       }
     }
-    const aliasesByModule = new Map<string, AliasResolver>();
+    const aliasesByModule = ctx?.aliasesByModule ?? new Map<string, AliasResolver>();
     for (const m of manifests) {
       if (isModuleKind(m.kind)) {
         const namespace = ((m.metadata as any).namespace as string | undefined) ?? null;
@@ -715,7 +715,9 @@ export class StaticAnalyzer {
     }
 
     // Validate resource references (Phase 3)
-    diagnostics.push(...validateReferences(allManifests, { aliases, definitions: defs }));
+    diagnostics.push(
+      ...validateReferences(allManifests, { aliases, definitions: defs, aliasesByModule }),
+    );
 
     // Validate `extends` fields and flag legacy `capability: <UserAbstract>` overload.
     diagnostics.push(...validateExtends(allManifests, defs, aliases));

package/src/flatten-for-analyzer.ts

@@ -0,0 +1,134 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { LoadedFile, LoadedGraph, LoadedModule } from "./loaded-types.js";
+import { isModuleKind } from "./module-kinds.js";
+
+/** Produce the flat manifest list `analyze()` consumes today.
+ *
+ *  Combines the entry module's manifests with `Telo.Definition`,
+ *  `Telo.Abstract`, and `Telo.Import` docs forwarded from imported libraries.
+ *  Stamps three flavours of metadata along the way:
+ *
+ *  - `metadata.source` and `metadata.sourceLine` — already on each manifest
+ *    from `parseLoadedFile`, copied here unchanged.
+ *  - `metadata.module` — the owning module's `Telo.Application` /
+ *    `Telo.Library` `metadata.name`, applied to non-module manifests that
+ *    don't already carry one.
+ *  - `metadata.resolvedModuleName` / `metadata.resolvedNamespace` — for every
+ *    `Telo.Import` manifest, looked up via `graph.importEdges` to find the
+ *    target module's own `Telo.Library` identity. Without this, the
+ *    analyzer's alias resolver and `validate-extends` fall back to
+ *    path-derived identity and produce spurious diagnostics.
+ *
+ *  Position metadata (`positionIndex`) is NOT stamped on manifests —
+ *  callers look it up via `findPositions(graph, ...)` on the LoadedGraph. */
+export function flattenForAnalyzer(graph: LoadedGraph): ResourceManifest[] {
+  const result: ResourceManifest[] = [];
+
+  const stampedEntry = collectModuleManifests(graph.entry);
+  result.push(...stampedEntry);
+
+  const seen = new Set<string>([graph.rootSource]);
+  const queue: string[] = [graph.rootSource];
+
+  while (queue.length > 0) {
+    const fromSource = queue.shift()!;
+    const edges = graph.importEdges.get(fromSource);
+    if (!edges) continue;
+
+    for (const edge of edges.values()) {
+      if (seen.has(edge.targetSource)) continue;
+      seen.add(edge.targetSource);
+      queue.push(edge.targetSource);
+
+      const targetModule = graph.modules.get(edge.targetSource);
+      if (!targetModule) continue;
+
+      const stamped = collectModuleManifests(targetModule);
+      for (const m of stamped) {
+        if (
+          m.kind === "Telo.Definition" ||
+          m.kind === "Telo.Abstract" ||
+          m.kind === "Telo.Import"
+        ) {
+          result.push(m);
+        }
+      }
+    }
+  }
+
+  // Stamp resolved import identity on every Telo.Import in the result by
+  // reading the edge's pre-resolved name/namespace — no re-derivation from
+  // manifest metadata. The edge is keyed by (owner-file, alias) which is
+  // exactly the (metadata.source, metadata.name) pair on each Telo.Import.
+  for (let i = 0; i < result.length; i++) {
+    const m = result[i];
+    if (m.kind !== "Telo.Import") continue;
+    const owner = (m.metadata as { source?: string } | undefined)?.source;
+    const alias = m.metadata?.name as string | undefined;
+    if (!owner || !alias) continue;
+    const edge = graph.importEdges.get(owner)?.get(alias);
+    if (!edge?.targetModuleName) continue;
+
+    const newMetadata: Record<string, unknown> = {
+      ...m.metadata,
+      resolvedModuleName: edge.targetModuleName,
+      resolvedNamespace: edge.targetNamespace,
+    };
+    result[i] = { ...m, metadata: newMetadata as ResourceManifest["metadata"] };
+  }
+
+  return result;
+}
+
+/** Project a LoadedModule (owner + partials) to a flat ResourceManifest[]
+ *  with `metadata.module` stamped on non-module docs. The kernel's runtime
+ *  entry load uses this to convert a `Loader.loadModule` result into the
+ *  classic ResourceManifest[] shape it iterates over. Imports are not
+ *  followed — the kernel's import-controller loads each import's module
+ *  separately at runtime. */
+export function flattenLoadedModule(mod: LoadedModule): ResourceManifest[] {
+  return collectModuleManifests(mod);
+}
+
+function collectModuleManifests(mod: LoadedModule): ResourceManifest[] {
+  const owner = stampFile(mod.owner, ownerModuleName(mod.owner));
+  const partials: ResourceManifest[] = [];
+  for (const p of mod.partials) {
+    partials.push(...stampFile(p, ownerModuleName(mod.owner)));
+  }
+  return [...owner, ...partials];
+}
+
+function ownerModuleName(file: LoadedFile): string | undefined {
+  for (const m of file.manifests) {
+    if (m && isModuleKind(m.kind)) {
+      const name = m.metadata?.name;
+      if (typeof name === "string") return name;
+    }
+  }
+  return undefined;
+}
+
+function stampFile(
+  file: LoadedFile,
+  ownerModule: string | undefined,
+): ResourceManifest[] {
+  const out: ResourceManifest[] = [];
+  for (let i = 0; i < file.manifests.length; i++) {
+    const m = file.manifests[i];
+    if (m === null || m === undefined) continue;
+    const { sourceLine } = file.positions[i];
+
+    const metadata: Record<string, unknown> = {
+      ...m.metadata,
+      source: file.source,
+      sourceLine,
+    };
+    if (ownerModule && !isModuleKind(m.kind) && !metadata.module) {
+      metadata.module = ownerModule;
+    }
+
+    out.push({ ...m, metadata: metadata as ResourceManifest["metadata"] });
+  }
+  return out;
+}

package/src/index.ts

@@ -1,8 +1,26 @@
 export { AnalysisRegistry } from "./analysis-registry.js";
 export { StaticAnalyzer } from "./analyzer.js";
+export type {
+    GraphLoadError,
+    ImportEdge,
+    LoadedFile,
+    LoadedGraph,
+    LoadedModule,
+    ParseError,
+} from "./loaded-types.js";
+export { flattenForAnalyzer, flattenLoadedModule } from "./flatten-for-analyzer.js";
 export { Loader } from "./manifest-loader.js";
 export { isModuleKind, MODULE_KINDS } from "./module-kinds.js";
 export type { ModuleKind } from "./module-kinds.js";
+export { parseLoadedFile } from "./parse-loaded-file.js";
+export type { ParseOptions } from "./parse-loaded-file.js";
+export {
+    buildDocumentPositions,
+    buildLineOffsets,
+    buildPositionIndex,
+    documentLineOffsets,
+} 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";
 export { DEFAULT_MANIFEST_FILENAME, DiagnosticSeverity } from "./types.js";

package/src/loaded-types.ts

@@ -0,0 +1,86 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { Document } from "yaml";
+import type { DocumentPosition } from "./position-metadata.js";
+import type { Range } from "./types.js";
+
+/** One physical file's parsed result. Returned for the owner manifest, for
+ *  each `include:` partial, and for each external import target.
+ *
+ *  Identity rule: every map key, every cross-reference, every editor-side
+ *  cache uses `source` — the URL the source adapter's `read()` returned. */
+export interface LoadedFile {
+  /** Canonical identity. The URL the source adapter's `read()` returned —
+   *  HTTPS for http/registry, an absolute path for local. */
+  source: string;
+  /** The URL the caller supplied (e.g. registry ref `std/javascript@0.3.0`).
+   *  Differs from `source` only for adapter-resolved URLs. */
+  requestedUrl: string;
+  /** Raw text exactly as `read()` returned it. */
+  text: string;
+  /** Per-document parsed AST, in source order. */
+  documents: Document[];
+  /** Per-document JSON projection (`doc.toJSON()`). Aligned to `documents`. */
+  manifests: Array<ResourceManifest | null>;
+  /** Per-document `{sourceLine, positionIndex}`. Aligned to `documents`. */
+  positions: DocumentPosition[];
+  /** Document-level parse errors aggregated from `yaml.Document.errors`. */
+  parseErrors: ParseError[];
+}
+
+export interface ParseError {
+  documentIndex: number;
+  message: string;
+  /** Line/character of the failure, when the yaml parser provided one. */
+  range?: Range;
+}
+
+/** An owner file plus the partial files it includes. The unit
+ *  `Loader.loadModule` returns. */
+export interface LoadedModule {
+  owner: LoadedFile;
+  /** Each `include:` target as its own LoadedFile. Empty when no `include:`.
+   *  Order matches the `include:` list (after glob expansion). */
+  partials: LoadedFile[];
+}
+
+/** Resolved Telo.Import edge: where the import points and what library
+ *  identity it resolves to. Carrying name/namespace on the edge means
+ *  `flattenForAnalyzer` can stamp `metadata.resolvedModuleName` /
+ *  `resolvedNamespace` from this single source rather than re-deriving
+ *  the target from manifest metadata, which would silently miss whenever
+ *  a future projection forgets to stamp `metadata.source` consistently. */
+export interface ImportEdge {
+  /** Canonical resolved URL of the target — a key into `modules`. */
+  targetSource: string;
+  /** Target library's `metadata.name`, or `null` when the target had no
+   *  Telo.Library doc (an error case captured in `LoadedGraph.errors`). */
+  targetModuleName: string | null;
+  /** Target library's `metadata.namespace` (or `null` when unset). */
+  targetNamespace: string | null;
+}
+
+/** An entry plus every transitively-imported library. Returned by
+ *  `Loader.loadGraph`. */
+export interface LoadedGraph {
+  /** Canonical entry source — equals `entry.owner.source`. */
+  rootSource: string;
+  entry: LoadedModule;
+  /** Map keyed by `LoadedFile.source` (canonical resolved URL). Includes
+   *  entry, partials, and every transitively reachable Telo.Import target +
+   *  its partials. */
+  modules: Map<string, LoadedModule>;
+  /** Per-Telo.Import resolution. Keyed by the resolved URL of the file the
+   *  Telo.Import was declared in, then by the import's PascalCase alias. */
+  importEdges: Map<string, Map<string, ImportEdge>>;
+  /** Surface-level errors that did not abort the graph load (e.g. an import
+   *  whose target failed to fetch). */
+  errors: GraphLoadError[];
+}
+
+export interface GraphLoadError {
+  /** URL of the file that failed to load. */
+  url: string;
+  /** Source of the import that triggered the load, or null for the entry. */
+  fromSource: string | null;
+  error: Error;
+}