@telorun/analyzer 0.8.1 → 0.10.0

package/dist/normalize-inline-resources.d.ts

@@ -18,5 +18,5 @@ import type { AliasResolver } from "./alias-resolver.js";
  * Returns a new array containing the original manifests (mutated in-place) plus all
  * extracted manifests. The original array is not mutated.
  */
-export declare function normalizeInlineResources(resources: ResourceManifest[], registry: DefinitionRegistry, aliases?: AliasResolver): ResourceManifest[];
+export declare function normalizeInlineResources(resources: ResourceManifest[], registry: DefinitionRegistry, aliases?: AliasResolver, aliasesByModule?: Map<string, AliasResolver>): ResourceManifest[];
 //# sourceMappingURL=normalize-inline-resources.d.ts.map

package/dist/normalize-inline-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-inline-resources.d.ts","sourceRoot":"","sources":["../src/normalize-inline-resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,GACtB,gBAAgB,EAAE,CAkDpB"}
+{"version":3,"file":"normalize-inline-resources.d.ts","sourceRoot":"","sources":["../src/normalize-inline-resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,gBAAgB,EAAE,CAwDpB"}

package/dist/normalize-inline-resources.js

@@ -26,14 +26,19 @@ function sanitizeName(raw) {
  * Returns a new array containing the original manifests (mutated in-place) plus all
  * extracted manifests. The original array is not mutated.
  */
-export function normalizeInlineResources(resources, registry, aliases) {
+export function normalizeInlineResources(resources, registry, aliases, aliasesByModule) {
     const result = [...resources];
     // Queue: all non-system resources with a name. Extracted resources are appended.
     const queue = resources.filter((r) => typeof r.metadata?.name === "string" && !!r.kind && !SYSTEM_KINDS.has(r.kind));
     let i = 0;
     while (i < queue.length) {
         const resource = queue[i++];
-        const fieldMap = registry.getFieldMapForKind(resource.kind, aliases);
+        // When aliasesByModule is available, use the expanded map so inline refs
+        // hidden behind an x-telo-schema-from indirection (e.g. an encoder inside
+        // an HttpDispatch.Outcomes/$defs/Returns sub-schema) reach extraction.
+        const fieldMap = aliases && aliasesByModule
+            ? registry.expandedFieldMapForResource(resource, aliases, aliasesByModule)
+            : registry.getFieldMapForKind(resource.kind, aliases);
         if (!fieldMap)
             continue;
         const parentName = resource.metadata.name;

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/reference-field-map.d.ts

@@ -61,4 +61,9 @@ export declare function resolveFieldValues(obj: unknown, path: string): unknown[
  * - A node with `properties` → recurse into each property
  */
 export declare function buildReferenceFieldMap(schema: Record<string, any>): ReferenceFieldMap;
+/** Traverses an arbitrary JSON Schema starting at the given path prefix. Used to
+ *  expand x-telo-schema-from sub-schemas into nested ref/scope entries so Phase 2
+ *  inline normalization and Phase 5 injection see slots that the local field map
+ *  hid behind the schema-from indirection. */
+export declare function buildFieldMapAtPath(schema: Record<string, any>, pathPrefix: string): ReferenceFieldMap;
 //# sourceMappingURL=reference-field-map.d.ts.map

package/dist/reference-field-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-field-map.d.ts","sourceRoot":"","sources":["../src/reference-field-map.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B;sDACkD;IAClD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC;IACjB;8DAC0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B;2CACuC;IACvC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED;8CAC8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC;;qFAEiF;IACjF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,eAAe,GAAG,oBAAoB,CAAC;AAEnF;0FAC0F;AAC1F,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,aAAa,CAEvE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,eAAe,CAE3E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,oBAAoB,CAErF;AAED,oGAAoG;AACpG,eAAO,MAAM,cAAc,aAAwC,CAAC;AAEpE;;;;;;;;;2EAS2E;AAC3E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAItE;AAED;;;;;kEAKkE;AAClE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CA6BxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,iBAAiB,CAQrF"}
+{"version":3,"file":"reference-field-map.d.ts","sourceRoot":"","sources":["../src/reference-field-map.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B;sDACkD;IAClD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC;IACjB;8DAC0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B;2CACuC;IACvC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED;8CAC8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC;;qFAEiF;IACjF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,eAAe,GAAG,oBAAoB,CAAC;AAEnF;0FAC0F;AAC1F,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,aAAa,CAEvE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,eAAe,CAE3E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,KAAK,IAAI,oBAAoB,CAErF;AAED,oGAAoG;AACpG,eAAO,MAAM,cAAc,aAAwC,CAAC;AAEpE;;;;;;;;;2EAS2E;AAC3E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAItE;AAED;;;;;kEAKkE;AAClE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CA6BxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,iBAAiB,CAQrF;AAiBD;;;8CAG8C;AAC9C,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,UAAU,EAAE,MAAM,GACjB,iBAAiB,CAInB"}

package/dist/reference-field-map.js

@@ -101,6 +101,15 @@ function collectRefs(node) {
     }
     return refs;
 }
+/** Traverses an arbitrary JSON Schema starting at the given path prefix. Used to
+ *  expand x-telo-schema-from sub-schemas into nested ref/scope entries so Phase 2
+ *  inline normalization and Phase 5 injection see slots that the local field map
+ *  hid behind the schema-from indirection. */
+export function buildFieldMapAtPath(schema, pathPrefix) {
+    const map = new Map();
+    traverseNode(schema, pathPrefix, map);
+    return map;
+}
 function traverseNode(node, path, map) {
     // Scope slot — record and stop; do not recurse into scope contents
     if ("x-telo-scope" in node) {

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,CA2UtB"}

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.
@@ -74,7 +75,12 @@ export function validateReferences(resources, context) {
     for (const r of resources) {
         if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind))
             continue;
-        const fieldMap = registry.getFieldMapForKind(r.kind, aliases);
+        // Use the expanded map so refs nested behind x-telo-schema-from get the
+        // same kind-check / unresolved-name validation as locally-declared refs.
+        // Falls back to the base map when aliasesByModule isn't supplied.
+        const fieldMap = aliasesByModule
+            ? registry.expandedFieldMapForResource(r, aliases, aliasesByModule)
+            : registry.getFieldMapForKind(r.kind, aliases);
         if (!fieldMap)
             continue;
         const resourceLabel = `${r.kind}/${r.metadata.name}`;
@@ -228,6 +234,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.10.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);
@@ -34,13 +35,21 @@ export class AnalysisRegistry {
   /**
    * Iterates a resource's reference and scope fields as declared by its definition.
    * Calls onRef for each plain reference field and onScope for each scope field.
+   *
+   * Uses the expanded field map so x-telo-schema-from entries contribute their
+   * nested ref/scope slots — Phase 5 injection sees encoders that live inside a
+   * sub-schema (e.g. Server.notFoundHandler.returns[].content[mime].encoder).
    */
   iterateFieldEntries(
     resource: ResourceManifest,
     onRef: (fieldPath: string) => void,
     onScope: (fieldPath: string) => void,
   ): void {
-    const fieldMap = this.defs.getFieldMapForKind(resource.kind, this.aliases);
+    const fieldMap = this.defs.expandedFieldMapForResource(
+      resource,
+      this.aliases,
+      this.aliasesByModule,
+    );
     if (!fieldMap) return;
     for (const [fieldPath, entry] of fieldMap) {
       if (isScopeEntry(entry)) {
@@ -94,6 +103,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;
@@ -525,7 +525,7 @@ export class StaticAnalyzer {
     }
 
     // Phase 2: extract inline resources from x-telo-ref slots into first-class manifests
-    const allManifests = normalizeInlineResources(manifests, defs, aliases);
+    const allManifests = normalizeInlineResources(manifests, defs, aliases, aliasesByModule);
 
     // Build a name→manifest map for looking up referenced resources
     const byName = new Map<string, ResourceManifest>();
@@ -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));
@@ -738,7 +740,12 @@ export class StaticAnalyzer {
 
   normalize(manifests: ResourceManifest[], registry: AnalysisRegistry): ResourceManifest[] {
     const ctx = registry._context();
-    return normalizeInlineResources(manifests, ctx.definitions!, ctx.aliases);
+    return normalizeInlineResources(
+      manifests,
+      ctx.definitions!,
+      ctx.aliases,
+      ctx.aliasesByModule,
+    );
   }
 
   prepare(
@@ -751,7 +758,12 @@ export class StaticAnalyzer {
     if (errors.length > 0) {
       return { diagnostics: errors, order: null, cycleError: null };
     }
-    const graph = buildDependencyGraph(manifests, ctx.definitions!, ctx.aliases);
+    const graph = buildDependencyGraph(
+      manifests,
+      ctx.definitions!,
+      ctx.aliases,
+      ctx.aliasesByModule,
+    );
     if (graph.cycle) {
       return { diagnostics: [], order: null, cycleError: formatCycle(graph.cycle) };
     }

package/src/definition-registry.ts

@@ -1,7 +1,13 @@
-import type { ResourceDefinition } from "@telorun/sdk";
+import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
+import type { AliasResolver } from "./alias-resolver.js";
 import { KERNEL_BUILTINS } from "./builtins.js";
-import { buildReferenceFieldMap, type ReferenceFieldMap } from "./reference-field-map.js";
-import { createAjv, formatSingleError } from "./schema-compat.js";
+import {
+  buildFieldMapAtPath,
+  buildReferenceFieldMap,
+  isSchemaFromEntry,
+  type ReferenceFieldMap,
+} from "./reference-field-map.js";
+import { createAjv, formatSingleError, navigateJsonPointer } from "./schema-compat.js";
 
 /** Pure kind → ResourceDefinition map. No controller loading, no lifecycle. */
 export class DefinitionRegistry {
@@ -163,6 +169,73 @@ export class DefinitionRegistry {
     return resolved ? this.getFieldMap(resolved) : undefined;
   }
 
+  /** Returns the field map for `resource.kind` with x-telo-schema-from entries replaced
+   *  by their nested ref/scope slots — so Phase 2 inline normalization and Phase 5
+   *  injection see encoders nested behind a schema-from indirection (e.g.
+   *  http-server `Server.notFoundHandler.returns[].content[mime].encoder`).
+   *
+   *  Only static absolute schema-from paths with a dotted alias anchor are expanded
+   *  (e.g. "HttpDispatch.Outcomes/$defs/Returns"). Relative and unqualified absolute
+   *  anchors depend on a sibling property at runtime and stay unexpanded; the
+   *  analyzer's reference validation phase already flags the cases that matter. */
+  expandedFieldMapForResource(
+    resource: ResourceManifest,
+    aliases: AliasResolver,
+    aliasesByModule: Map<string, AliasResolver>,
+  ): ReferenceFieldMap | undefined {
+    const baseMap = this.getFieldMapForKind(resource.kind, aliases);
+    if (!baseMap) return undefined;
+
+    const resolvedKind = aliases.resolveKind(resource.kind) ?? resource.kind;
+    const def = this.resolve(resource.kind) ?? this.resolve(resolvedKind);
+    const ownerModule = (def?.metadata as { module?: string } | undefined)?.module;
+    const ownerScope =
+      (ownerModule ? aliasesByModule.get(ownerModule) : undefined) ?? aliases;
+
+    const expanded: ReferenceFieldMap = new Map();
+    for (const [path, entry] of baseMap) {
+      if (!isSchemaFromEntry(entry)) {
+        expanded.set(path, entry);
+        continue;
+      }
+      const sub = this.resolveSchemaFromSubMap(entry.schemaFrom, path, ownerScope);
+      if (!sub) continue;
+      for (const [subPath, subEntry] of sub) expanded.set(subPath, subEntry);
+    }
+    return expanded;
+  }
+
+  private resolveSchemaFromSubMap(
+    schemaFrom: string,
+    fieldPath: string,
+    ownerScope: AliasResolver,
+  ): ReferenceFieldMap | null {
+    const isAbsolute = schemaFrom.startsWith("/");
+    const expr = isAbsolute ? schemaFrom.slice(1) : schemaFrom;
+    const slashIdx = expr.indexOf("/");
+    if (slashIdx === -1) return null;
+    const anchorName = expr.slice(0, slashIdx);
+    const jsonPointer = "/" + expr.slice(slashIdx + 1);
+
+    // Static form: absolute path whose anchor is a dotted alias (e.g.
+    // "HttpDispatch.Outcomes/$defs/Returns"). Polymorphic forms — relative
+    // anchors or single-segment absolute anchors — only resolve once we know a
+    // sibling property's value, which is per-resource.
+    if (!anchorName.includes(".")) return null;
+
+    const targetKind = ownerScope.resolveKind(anchorName);
+    if (!targetKind) return null;
+    const targetDef = this.resolve(targetKind);
+    if (!targetDef?.schema) return null;
+    const subSchema = navigateJsonPointer(
+      targetDef.schema as Record<string, unknown>,
+      jsonPointer,
+    );
+    if (!subSchema || typeof subSchema !== "object") return null;
+
+    return buildFieldMapAtPath(subSchema as Record<string, any>, fieldPath);
+  }
+
   /** Returns all definitions that transitively extend the given abstract kind.
    *  Follows the capability chain to any depth (equivalent to instanceof in OOP).
    *  Definitions are included regardless of registration order. */

package/src/dependency-graph.ts

@@ -45,6 +45,7 @@ export function buildDependencyGraph(
   resources: ResourceManifest[],
   registry: DefinitionRegistry,
   aliases?: AliasResolver,
+  aliasesByModule?: Map<string, AliasResolver>,
 ): DependencyGraph {
   // --- Build node set ---
   const nodes = new Map<string, ResourceNode>();
@@ -62,7 +63,14 @@ export function buildDependencyGraph(
     if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind)) continue;
 
     const sourceKey = nodeKey(r.kind, r.metadata.name as string);
-    const fieldMap = registry.getFieldMapForKind(r.kind, aliases);
+    // Use the expanded map so refs nested behind x-telo-schema-from contribute
+    // edges to the DAG. Without these, a parent (e.g. Http.Server) can init
+    // before its extracted encoder and Phase 5 injection fires against a
+    // not-yet-created dependency.
+    const fieldMap =
+      aliases && aliasesByModule
+        ? registry.expandedFieldMapForResource(r, aliases, aliasesByModule)
+        : registry.getFieldMapForKind(r.kind, aliases);
     if (!fieldMap) continue;
 
     // Collect names of resources declared inside scope fields — these are initialized