@telorun/analyzer 0.10.1 → 0.12.0

package/dist/dependency-graph.js

@@ -1,13 +1,6 @@
+import { isRefSentinel } from "@telorun/templating";
 import { isRefEntry, isScopeEntry, resolveFieldValues } from "./reference-field-map.js";
-/** System resource kinds that are not runtime nodes in the dependency graph.
- *  Module-identity docs (Telo.Application, Telo.Library) are intentionally
- *  not in this set: an Application's `targets` use `x-telo-ref` to real
- *  Runnable/Service resources, so the Application legitimately depends on
- *  them in boot order — modeling that as a graph edge is correct. A Library
- *  has no `targets`, so it becomes a zero-edge node, which is harmless.
- *  If the graph is ever consumed as "things to init", skip these kinds at
- *  the consumer site; the controller already runs them separately. */
-const SYSTEM_KINDS = new Set(["Telo.Definition", "Telo.Import"]);
+import { DEPENDENCY_GRAPH_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 const nodeKey = (kind, name) => `${kind}\0${name}`;
 /**
  * Builds a directed acyclic graph (DAG) of runtime resource dependencies and
@@ -22,13 +15,19 @@ const nodeKey = (kind, name) => `${kind}\0${name}`;
  * not pre-compute or pass field maps separately.
  */
 export function buildDependencyGraph(resources, registry, aliases, aliasesByModule) {
-    // --- Build node set ---
+    // --- Build node set + name index ---
     const nodes = new Map();
+    // Sentinel lookup (`!ref <name>`) needs to resolve a bare name to its
+    // declared kind. Names are unique within a manifest scope, so a flat
+    // map suffices and lets the sentinel branch below avoid a full
+    // O(N) scan of the node set on every reference.
+    const nodesByName = new Map();
     for (const r of resources) {
         if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind))
             continue;
-        const key = nodeKey(r.kind, r.metadata.name);
-        nodes.set(key, { kind: r.kind, name: r.metadata.name });
+        const node = { kind: r.kind, name: r.metadata.name };
+        nodes.set(nodeKey(node.kind, node.name), node);
+        nodesByName.set(node.name, node);
     }
     // --- Build adjacency: from → deps (from depends on dep) ---
     const deps = new Map();
@@ -66,7 +65,22 @@ export function buildDependencyGraph(resources, registry, aliases, aliasesByModu
             if (!isRefEntry(entry))
                 continue;
             for (const val of resolveFieldValues(r, fieldPath)) {
-                if (!val || typeof val !== "object")
+                if (!val)
+                    continue;
+                // `!ref <name>` sentinel — look up the target's kind from the
+                // name (resources are unique by name) so the edge carries the
+                // concrete kind, matching the {kind, name} edge shape below.
+                if (isRefSentinel(val)) {
+                    const refName = val.source;
+                    if (scopedNames.has(refName))
+                        continue;
+                    const node = nodesByName.get(refName);
+                    if (node) {
+                        deps.get(sourceKey).add(nodeKey(node.kind, node.name));
+                    }
+                    continue;
+                }
+                if (typeof val !== "object")
                     continue;
                 const ref = val;
                 if (!ref.kind || !ref.name)

package/dist/index.d.ts

@@ -7,10 +7,12 @@ 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 { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.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 { withSyntheticPositions } from "./with-synthetic-positions.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":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -4,7 +4,9 @@ export { flattenForAnalyzer, flattenLoadedModule } from "./flatten-for-analyzer.
 export { Loader } from "./manifest-loader.js";
 export { isModuleKind, MODULE_KINDS } from "./module-kinds.js";
 export { parseLoadedFile } from "./parse-loaded-file.js";
+export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
 export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, } from "./position-metadata.js";
 export { HttpSource } from "./sources/http-source.js";
 export { RegistrySource } from "./sources/registry-source.js";
+export { withSyntheticPositions } from "./with-synthetic-positions.js";
 export { DEFAULT_MANIFEST_FILENAME, DiagnosticSeverity } from "./types.js";

package/dist/kernel-globals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kernel-globals.d.ts","sourceRoot":"","sources":["../src/kernel-globals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,uDAAwD,CAAC;AASzF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAiCrB;AA2BD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB"}
+{"version":3,"file":"kernel-globals.d.ts","sourceRoot":"","sources":["../src/kernel-globals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,uDAAwD,CAAC;AASzF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAiCrB;AAwBD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB"}

package/dist/kernel-globals.js

@@ -1,3 +1,4 @@
+import { residualEntrySchemaMap } from "./residual-schema.js";
 /**
  * Kernel global names available in every CEL evaluation context at runtime.
  * Both `buildKernelGlobalsSchema` (chain-access validation) and
@@ -59,18 +60,15 @@ export function buildKernelGlobalsSchema(manifests) {
     };
 }
 /** Wrap a JSON Schema property map (like `Telo.Application.variables`) into a
- *  closed object schema suitable for chain-access validation. Falls back to
- *  an open map when the module declares no variables/secrets. */
+ *  closed object schema suitable for chain-access validation. For Application
+ *  entries the per-entry shape carries kernel-specific keys (`env`, `default`)
+ *  on top of an otherwise-standard JSON Schema property schema; those keys are
+ *  stripped via `residualEntrySchemaMap` so CEL sees the coerced shape, not
+ *  the env-binding wrapper. Library entries are pure JSON Schema property
+ *  schemas and pass through the same call unchanged. Falls back to an open map
+ *  when the module declares no variables/secrets. */
 function buildSchemaMapSchema(schemaMap) {
-    if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) {
-        return { type: "object", additionalProperties: true };
-    }
-    const props = {};
-    for (const [key, value] of Object.entries(schemaMap)) {
-        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-            props[key] = value;
-        }
-    }
+    const props = residualEntrySchemaMap(schemaMap);
     if (Object.keys(props).length === 0) {
         return { type: "object", additionalProperties: true };
     }

package/dist/manifest-loader.d.ts

@@ -6,12 +6,25 @@ export declare class Loader {
      *  caller (kernel) and a raw-mode caller (analyzer/editor) on the same file
      *  get distinct entries, so neither sees the wrong manifest tree. */
     private readonly fileCache;
+    /** requestUrl → canonical `source`. Lets `loadFile` skip the source read
+     *  when a URL it has already canonicalised is requested again — kernel
+     *  load → boot and the import-controller each ask the loader for the same
+     *  modules. Without this fast path every duplicate request re-runs the
+     *  source's `read()` (a `fetch` for `RegistrySource`, a disk read for
+     *  `LocalFileSource`). */
+    private readonly urlToSource;
     protected sources: ManifestSource[];
     private readonly celEnv;
     constructor(extraSourcesOrOptions?: ManifestSource[] | LoaderInitOptions);
     register(source: ManifestSource): this;
     private pick;
     resolveEntryPoint(url: string): Promise<string>;
+    /** Returns the canonical source URL the loader has already mapped `url`
+     *  to during a prior `loadFile`/`loadModule`/`loadGraph` call, or
+     *  `undefined` when the URL has not been seen. Callers use it to test
+     *  set-membership against a previous graph walk's modules without
+     *  triggering an extra source read. */
+    canonicalize(url: string): string | undefined;
     /** Read one file via the source chain and parse it into a LoadedFile.
      *  The result is shared with `Loader.fileCache`. Callers that want a
      *  private mutable copy must call `parseLoadedFile` directly with the
@@ -26,7 +39,16 @@ export declare class Loader {
      *  `importEdges` mapping each importing file's PascalCase aliases to their
      *  target's canonical source. */
     loadGraph(entryUrl: string, options?: LoadOptions): Promise<LoadedGraph>;
-    private resolveImportUrl;
+    /** Resolve an `import` URL against the file it appears in. Relative /
+     *  absolute-path forms run through the owning `ManifestSource`'s
+     *  `resolveRelative`; registry refs and full URLs pass through
+     *  unchanged. Exposed so the import-controller (and any other
+     *  caller-side resolver) lands on the *exact same* canonical URL the
+     *  loader used when walking the entry graph — divergent resolution
+     *  would silently break optimizations like `canonicalize()`-keyed
+     *  cache hits whenever a non-trivial `ManifestSource.resolveRelative`
+     *  is in play. */
+    resolveImportUrl(fromSource: string, importSource: string): string;
     private assertSingleModuleDeclaration;
     private assertNoSystemKindsInPartialContext;
     private assertImportTargetIsLibrary;

package/dist/manifest-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AASpB,qBAAa,MAAM;IACjB;;;yEAGqE;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAE3D,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,qBAAqB,GAAE,cAAc,EAAE,GAAG,iBAAsB;IAmB5E,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKtC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOrD;;;+BAG2B;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAcvE;;wEAEoE;IAC9D,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAsB3E;;;qCAGiC;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAwG9E,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,6BAA6B;IAarC,OAAO,CAAC,mCAAmC;IAc3C,OAAO,CAAC,2BAA2B;YAkCrB,eAAe;IAmB7B;;;0CAGsC;IAChC,gBAAgB,CACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CA0B5D"}
+{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AASpB,qBAAa,MAAM;IACjB;;;yEAGqE;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAE3D;;;;;8BAK0B;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,qBAAqB,GAAE,cAAc,EAAE,GAAG,iBAAsB;IAmB5E,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKtC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrD;;;;2CAIuC;IACvC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAM7C;;;+BAG2B;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAgDvE;;wEAEoE;IAC9D,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAsB3E;;;qCAGiC;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAwG9E;;;;;;;;sBAQkB;IAClB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAOlE,OAAO,CAAC,6BAA6B;IAarC,OAAO,CAAC,mCAAmC;IAc3C,OAAO,CAAC,2BAA2B;YAkCrB,eAAe;IAmB7B;;;0CAGsC;IAChC,gBAAgB,CACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CA0B5D"}

package/dist/manifest-loader.js

@@ -16,6 +16,13 @@ export class Loader {
      *  caller (kernel) and a raw-mode caller (analyzer/editor) on the same file
      *  get distinct entries, so neither sees the wrong manifest tree. */
     fileCache = new Map();
+    /** requestUrl → canonical `source`. Lets `loadFile` skip the source read
+     *  when a URL it has already canonicalised is requested again — kernel
+     *  load → boot and the import-controller each ask the loader for the same
+     *  modules. Without this fast path every duplicate request re-runs the
+     *  source's `read()` (a `fetch` for `RegistrySource`, a disk read for
+     *  `LocalFileSource`). */
+    urlToSource = new Map();
     sources;
     celEnv;
     constructor(extraSourcesOrOptions = []) {
@@ -45,8 +52,21 @@ export class Loader {
         return s;
     }
     async resolveEntryPoint(url) {
-        const { source } = await this.pick(url).read(url);
-        return source;
+        // Route through `loadFile` so the resolved source URL and parsed
+        // entry are populated in `urlToSource` + `fileCache` in one read.
+        // Callers (kernel.load) immediately call `loadGraph(entryUrl)`
+        // afterwards — without this priming, the entry file would be read
+        // twice (twice over the network for `RegistrySource`).
+        const file = await this.loadFile(url);
+        return file.source;
+    }
+    /** Returns the canonical source URL the loader has already mapped `url`
+     *  to during a prior `loadFile`/`loadModule`/`loadGraph` call, or
+     *  `undefined` when the URL has not been seen. Callers use it to test
+     *  set-membership against a previous graph walk's modules without
+     *  triggering an extra source read. */
+    canonicalize(url) {
+        return this.urlToSource.get(url);
     }
     // --- New API: returns LoadedFile / LoadedModule / LoadedGraph ----------
     /** Read one file via the source chain and parse it into a LoadedFile.
@@ -54,8 +74,42 @@ export class Loader {
      *  private mutable copy must call `parseLoadedFile` directly with the
      *  LoadedFile's `text`. */
     async loadFile(url, options) {
+        const compileKey = options?.compile ? "compiled" : "raw";
+        const knownSource = this.urlToSource.get(url);
+        if (knownSource) {
+            const cached = this.fileCache.get(`${compileKey}:${knownSource}`);
+            if (cached)
+                return cached;
+            // The other compile-mode entry is cached — reparse from its text
+            // instead of re-reading the source.
+            //
+            // NOTE for watch-mode reactivation (cli/nodejs/src/commands/run.ts
+            // currently has `setupWatchMode` commented out): this branch
+            // assumes file contents don't change underneath a single Loader.
+            // Reviving watch mode will need a public `invalidate(url)` (or
+            // similar) that drops both `urlToSource[url]` and the cached
+            // entries for its canonical source before the loader serves the
+            // file again.
+            const altKey = `${compileKey === "compiled" ? "raw" : "compiled"}:${knownSource}`;
+            const alt = this.fileCache.get(altKey);
+            if (alt) {
+                const reparsed = parseLoadedFile(knownSource, url, alt.text, {
+                    compile: options?.compile,
+                    celEnv: this.celEnv,
+                });
+                this.fileCache.set(`${compileKey}:${knownSource}`, reparsed);
+                return reparsed;
+            }
+        }
         const { text, source } = await this.pick(url).read(url);
-        const cacheKey = `${options?.compile ? "compiled" : "raw"}:${source}`;
+        this.urlToSource.set(url, source);
+        // Also map the canonical source to itself so subsequent `loadFile`
+        // calls that already received a canonical URL — `kernel.load` passes
+        // the result of `resolveEntryPoint` to `loadGraph`, which then asks
+        // for that exact URL — hit the urlToSource fast path instead of
+        // falling through to a redundant `pick(url).read(url)`.
+        this.urlToSource.set(source, source);
+        const cacheKey = `${compileKey}:${source}`;
         const cached = this.fileCache.get(cacheKey);
         if (cached && cached.text === text)
             return cached;
@@ -190,6 +244,15 @@ export class Loader {
         }
         return { rootSource, entry, modules, importEdges, errors };
     }
+    /** Resolve an `import` URL against the file it appears in. Relative /
+     *  absolute-path forms run through the owning `ManifestSource`'s
+     *  `resolveRelative`; registry refs and full URLs pass through
+     *  unchanged. Exposed so the import-controller (and any other
+     *  caller-side resolver) lands on the *exact same* canonical URL the
+     *  loader used when walking the entry graph — divergent resolution
+     *  would silently break optimizations like `canonicalize()`-keyed
+     *  cache hits whenever a non-trivial `ManifestSource.resolveRelative`
+     *  is in play. */
     resolveImportUrl(fromSource, importSource) {
         if (importSource.startsWith(".") || importSource.startsWith("/")) {
             return this.pick(fromSource).resolveRelative(fromSource, importSource);

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,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,gBAAgB,EAAE,CAwDpB"}
+{"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,CA+DpB"}

package/dist/normalize-inline-resources.js

@@ -60,7 +60,7 @@ export function normalizeInlineResources(resources, registry, aliases, aliasesBy
                 fieldPath.startsWith(prefix + ".") ||
                 fieldPath.startsWith(prefix + "["));
             const invocationContext = isRefEntry(entry) ? entry.context : undefined;
-            const extracted = extractInlinesAtPath(resource, fieldPath, parentName, parentModule, invocationContext);
+            const extracted = extractInlinesAtPath(resource, fieldPath, parentName, resource.kind, parentModule, invocationContext);
             for (const manifest of extracted) {
                 result.push(manifest);
                 queue.push(manifest);
@@ -75,11 +75,22 @@ export function normalizeInlineResources(resources, registry, aliases, aliasesBy
  * Walks `resource` following `fieldPath` (dot notation, `[]` = array traversal).
  * Mutates the resource in-place: replaces each inline value with `{kind, name}`.
  * Returns the extracted manifests.
+ *
+ * Each extracted manifest carries `metadata.xTeloOrigin` so downstream
+ * diagnostics can be rerouted back to the parent doc's YAML position:
+ *   - `parentKind` / `parentName` — the resource that owned the inline slot
+ *   - `pathFromParent` — concrete dotted path with `[N]` indices, matching
+ *     `buildPositionIndex` keys (e.g. `routes[0].handler`)
  */
-function extractInlinesAtPath(resource, fieldPath, parentName, parentModule, invocationContext) {
+function extractInlinesAtPath(resource, fieldPath, parentName, parentKind, parentModule, invocationContext) {
     const extracted = [];
     const parts = fieldPath.split(".");
-    function traverse(obj, partsLeft, nameParts) {
+    function emit(inline, nameSegments, concretePath) {
+        const name = sanitizeName([parentName, ...nameSegments].join("_"));
+        extracted.push(buildManifest(inline, name, parentKind, parentName, concretePath, parentModule, invocationContext));
+        return name;
+    }
+    function traverse(obj, partsLeft, nameParts, pathSoFar) {
         if (!obj || typeof obj !== "object" || partsLeft.length === 0)
             return;
         const [head, ...rest] = partsLeft;
@@ -92,15 +103,15 @@ function extractInlinesAtPath(resource, fieldPath, parentName, parentModule, inv
                 if (!elem || typeof elem !== "object")
                     continue;
                 const sanitizedKey = sanitizeName(mapKey);
+                const childPath = pathSoFar ? `${pathSoFar}.${mapKey}` : mapKey;
                 if (rest.length === 0) {
                     if (isInlineResource(elem)) {
-                        const name = sanitizeName([parentName, ...nameParts, sanitizedKey].join("_"));
-                        extracted.push(buildManifest(elem, name, parentModule, invocationContext));
+                        const name = emit(elem, [...nameParts, sanitizedKey], childPath);
                         container[mapKey] = { kind: elem.kind, name };
                     }
                 }
                 else {
-                    traverse(elem, rest, [...nameParts, sanitizedKey]);
+                    traverse(elem, rest, [...nameParts, sanitizedKey], childPath);
                 }
             }
             return;
@@ -111,6 +122,7 @@ function extractInlinesAtPath(resource, fieldPath, parentName, parentModule, inv
         const val = container[key];
         if (val == null)
             return;
+        const keyPath = pathSoFar ? `${pathSoFar}.${key}` : key;
         if (isArr) {
             if (!Array.isArray(val))
                 return;
@@ -121,16 +133,16 @@ function extractInlinesAtPath(resource, fieldPath, parentName, parentModule, inv
                 const elemId = typeof elem.name === "string"
                     ? elem.name
                     : String(idx);
+                const childPath = `${keyPath}[${idx}]`;
                 if (rest.length === 0) {
                     // Array element itself is the ref slot
                     if (isInlineResource(elem)) {
-                        const name = sanitizeName([parentName, ...nameParts, key, elemId].join("_"));
-                        extracted.push(buildManifest(elem, name, parentModule, invocationContext));
+                        const name = emit(elem, [...nameParts, key, elemId], childPath);
                         val[idx] = { kind: elem.kind, name };
                     }
                 }
                 else {
-                    traverse(elem, rest, [...nameParts, key, elemId]);
+                    traverse(elem, rest, [...nameParts, key, elemId], childPath);
                 }
             }
         }
@@ -138,20 +150,19 @@ function extractInlinesAtPath(resource, fieldPath, parentName, parentModule, inv
             if (rest.length === 0) {
                 // val is the ref slot
                 if (val && typeof val === "object" && !Array.isArray(val) && isInlineResource(val)) {
-                    const name = sanitizeName([parentName, ...nameParts, key].join("_"));
-                    extracted.push(buildManifest(val, name, parentModule, invocationContext));
+                    const name = emit(val, [...nameParts, key], keyPath);
                     container[key] = { kind: val.kind, name };
                 }
             }
             else {
-                traverse(val, rest, [...nameParts, key]);
+                traverse(val, rest, [...nameParts, key], keyPath);
             }
         }
     }
-    traverse(resource, parts, []);
+    traverse(resource, parts, [], "");
     return extracted;
 }
-function buildManifest(inline, name, parentModule, invocationContext) {
+function buildManifest(inline, name, parentKind, parentName, pathFromParent, parentModule, invocationContext) {
     const existingMeta = inline.metadata && typeof inline.metadata === "object"
         ? inline.metadata
         : {};
@@ -163,6 +174,7 @@ function buildManifest(inline, name, parentModule, invocationContext) {
             // Inherit parent module only if the inline doesn't already declare one
             ...(parentModule && !existingMeta.module ? { module: parentModule } : {}),
             ...(invocationContext ? { xTeloInvocationContext: invocationContext } : {}),
+            xTeloOrigin: { parentKind, parentName, pathFromParent },
         },
     };
 }

package/dist/position-metadata.d.ts

@@ -15,13 +15,22 @@ export interface DocumentPosition {
 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. */
+ *  to the line after each `---` separator.
+ *
+ *  A `---` at line 0 is the doc-start marker for doc 0 (the parser still
+ *  emits a single document), not a separator before an empty doc — skipping
+ *  it keeps `offsets.length === parsedDocs.length` so diagnostics for doc N
+ *  don't land inside doc N-1's text. */
 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"). */
+ *  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;
 //# 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;;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"}
+{"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"}

package/dist/position-metadata.js

@@ -10,14 +10,22 @@ export function buildDocumentPositions(text, parsedDocs) {
 }
 /** 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. */
+ *  to the line after each `---` separator.
+ *
+ *  A `---` at line 0 is the doc-start marker for doc 0 (the parser still
+ *  emits a single document), not a separator before an empty doc — skipping
+ *  it keeps `offsets.length === parsedDocs.length` so diagnostics for doc N
+ *  don't land inside doc N-1's text. */
 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("--- "))
+        if (t === "---" || t.startsWith("--- ")) {
+            if (i === 0)
+                continue;
             offsets.push(i + 1);
+        }
     }
     return offsets;
 }
@@ -45,7 +53,11 @@ function offsetToPosition(offset, lineOffsets) {
     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"). */
+ *  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, lineOffsets) {
     const index = new Map();
     function recordNode(node, path) {
@@ -66,6 +78,9 @@ export function buildPositionIndex(doc, lineOffsets) {
                 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.value, childPath);
                     walk(pair.value, childPath);

package/dist/precompile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precompile.d.ts","sourceRoot":"","sources":["../src/precompile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAmCrE"}
+{"version":3,"file":"precompile.d.ts","sourceRoot":"","sources":["../src/precompile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CA0CrE"}

package/dist/precompile.js

@@ -1,5 +1,5 @@
 import { isCompiledValue } from "@telorun/sdk";
-import { compileString, defaultRegistry, isTaggedSentinel } from "@telorun/templating";
+import { compileString, defaultRegistry, isRefSentinel, isTaggedSentinel } from "@telorun/templating";
 /**
  * Walks a raw YAML document and replaces all `${{ expr }}` strings (and
  * `!cel`-tagged sentinels) with CompiledValue wrappers. Throws on CEL syntax
@@ -19,6 +19,14 @@ export function precompileDoc(doc, env) {
     // analyzer's diagnostic walk can identify it on compiled trees too;
     // engines returning plain values (e.g. `literal` → a string) pass through
     // verbatim — the runtime contract is "any scalar value is fine."
+    // `!ref` sentinels are identity markers, not templating values. They must
+    // survive precompile intact so the analyzer's `resolveRefSentinels` pass
+    // can substitute them with `{kind, name}` objects against the resolved
+    // resource manifest. Running the engine's `compile` here would prematurely
+    // collapse the sentinel into its source string and the ref slot would
+    // arrive at the controller as a bare name with no kind.
+    if (isRefSentinel(doc))
+        return doc;
     if (isTaggedSentinel(doc)) {
         const engine = defaultRegistry().get(doc.engine);
         if (!engine) {

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

@@ -43,12 +43,29 @@ export declare const REFERENCE_KEYS: Set<string>;
  *  A named reference (has string `name`) may carry extra keys (e.g. `inputs`)
  *  that are runtime call parameters — those are never inline resources. */
 export declare function isInlineResource(val: Record<string, unknown>): boolean;
-/** Resolves all values at a field map path in a resource config.
- *  Path-segment markers:
- *   - `[]`  iterate array values at this key
+/** A value found at a field-map path, paired with the concrete path that
+ *  produced it. `path` has every `[]` substituted with `[N]` and every `{}`
+ *  substituted with the actual map key, matching the format produced by
+ *  `buildPositionIndex`. Used so diagnostics emitted against a specific
+ *  array element / map entry can be resolved back to a YAML range. */
+export interface ResolvedFieldEntry {
+    value: unknown;
+    path: string;
+}
+/** Resolves all `{value, path}` entries at a field map path in a resource
+ *  config. The returned `path` is the concrete dotted path produced by the
+ *  substitutions below, matching the format `buildPositionIndex` keys on.
+ *  Path-segment markers accepted in the input `path`:
+ *   - `[]`  iterate array values at this key, substituting `[N]` per item
+ *           (e.g. `routes[]` → `routes[0]`, `routes[1]`, …).
  *   - `{}`  iterate map values (every value in an `additionalProperties`-typed
  *           object — used for fields like `content[mime]` whose schema declares
- *           a key-as-MIME map). The path is `<key>.{}.<rest>`. */
+ *           a key-as-MIME map). Substituted with the literal map key joined by
+ *           a dot, so the input `content.{}.encoder` yields concrete paths
+ *           like `content.application/json.encoder`. */
+export declare function resolveFieldEntries(obj: unknown, path: string): ResolvedFieldEntry[];
+/** Backwards-compat wrapper that drops the concrete path. Prefer
+ *  `resolveFieldEntries` for new code that wants positions. */
 export declare function resolveFieldValues(obj: unknown, path: string): unknown[];
 /**
  * Traverses a definition's JSON Schema once and returns a field map recording every

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;AAiBD;;;8CAG8C;AAC9C,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,UAAU,EAAE,MAAM,GACjB,iBAAiB,CAInB"}
+{"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;;;;sEAIsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;wDAUwD;AACxD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAoCpF;AAED;+DAC+D;AAC/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAExE;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"}