@telorun/analyzer 0.65.0 → 0.67.0

package/dist/schema-projection.d.ts.map

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

package/dist/schema-projection.js

@@ -34,6 +34,8 @@
  * row shape lives in one instance's own `columns:`, which no definition-level
  * derivation can reach.
  */
+import { isRefSentinel } from "@telorun/templating";
+import { isInjectedDeclaration } from "./resource-input.js";
 function isObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -55,6 +57,20 @@ export function readSchemaProjection(definition) {
         nameField: typeof raw.name === "string" ? raw.name : undefined,
         nullable: typeof raw.nullable === "string" ? raw.nullable : undefined,
         array: typeof raw.array === "string" ? raw.array : undefined,
+        reference: readProjectionReference(raw.reference),
+    };
+}
+function readProjectionReference(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const { from, keyword, base, baseFrom } = raw;
+    if (typeof from !== "string" || typeof keyword !== "string")
+        return undefined;
+    return {
+        from,
+        keyword,
+        base: isObject(base) ? base : undefined,
+        baseFrom: typeof baseFrom === "string" ? baseFrom : undefined,
     };
 }
 /** The annotation as written, from either position — the document (canonical)
@@ -79,7 +95,37 @@ export function schemaProjectionIsMisplaced(definition) {
     const schema = definition.schema;
     return isObject(schema) && schema["x-telo-schema-projection"] !== undefined;
 }
+/**
+ * The schema node that CARRIES the value vocabulary — the node itself, or the
+ * branch of a union that declares the map.
+ *
+ * A slot unioning a closed value vocabulary with a reference keeps its map on the
+ * value branch, exactly as the ref-slot reader peels the same union for its
+ * constraint. Exported because the strict half checks the map against the same
+ * branch's `enum`, and two implementations of "which branch is the value one"
+ * would eventually disagree — silently, since the failure of missing one is a
+ * completeness check that quietly stops running.
+ */
+export function schemaMapBranch(node) {
+    if (!isObject(node))
+        return undefined;
+    if (node["x-telo-schema-map"] !== undefined)
+        return node;
+    for (const key of ["oneOf", "anyOf"]) {
+        const branches = node[key];
+        if (!Array.isArray(branches))
+            continue;
+        for (const branch of branches) {
+            if (isObject(branch) && branch["x-telo-schema-map"] !== undefined)
+                return branch;
+        }
+    }
+    return undefined;
+}
 export function readSchemaMap(node) {
+    return ownSchemaMap(schemaMapBranch(node));
+}
+function ownSchemaMap(node) {
     if (!isObject(node))
         return undefined;
     const raw = node["x-telo-schema-map"];
@@ -134,6 +180,66 @@ export function projectionKeyMap(kindSchema, projection) {
         return undefined;
     return readSchemaMap(entry.properties[projection.key]);
 }
+/**
+ * The node an entry whose keyed field holds a REFERENCE projects to.
+ *
+ * This is the one place a projection crosses to another declaration, and it is
+ * a deliberate exception to the projection's lossiness: length, precision and
+ * collation stop at the boundary because the database enforces them, while a
+ * domain crosses because it IS the type at the granularity a consumer acts on —
+ * the enum in a CRUD model's OpenAPI operation, a completion list in the editor,
+ * a filter a repository can reject before the query.
+ *
+ * **A reference that cannot be read projects OPEN, never to nothing**, and that
+ * is the opposite of the rule an unmapped VALUE follows. The two failures are
+ * not the same failure: an unmapped value is a gap in the kind's own vocabulary,
+ * so there is no entry to speak of, while an unreadable reference names an entry
+ * the declaration plainly HAS and only leaves its type unknown. Dropping it made
+ * the projection deny the entry exists — a table whose enum reference had a typo
+ * reported `'status' is not allowed` against a column declared three lines up,
+ * blaming the seed row for the reference's mistake. Open is the honest
+ * under-approximation, and the reason is reported alongside.
+ */
+function referencedNode(value, entryName, projection, map, options) {
+    const reference = projection.reference;
+    if (!reference || !isObject(value))
+        return undefined;
+    // Through the single reader, so the name in the diagnostic is the one the
+    // author wrote whichever shape the slot holds — reading `value.name` here
+    // reported `<unnamed>` for an unresolved `!ref`, which is precisely the case
+    // that produces the diagnostic.
+    const name = readProjectionRef(value)?.name ?? "<unnamed>";
+    const report = () => {
+        options?.failures?.push({
+            reason: "entry-reference",
+            // The EMPTY pointer means the projected declaration is the one carrying
+            // the diagnostic, so the entry's own path is a real anchor in that file —
+            // the column, not the document root. Any other pointer names a slot
+            // holding a reference to a DIFFERENT manifest, whose entry paths mean
+            // nothing here, so the slot stays the anchor.
+            pointer: options?.pointer === ""
+                ? `${projection.entries}/${entryName}`
+                : (options?.pointer ?? projection.entries),
+            entry: entryName,
+            name,
+        });
+        return {};
+    };
+    const found = options?.scope?.resolveManifest(value);
+    if (!found || "ambiguous" in found)
+        return report();
+    const values = found.manifest[reference.from];
+    if (!Array.isArray(values) || values.length === 0)
+        return report();
+    let base = reference.base;
+    if (reference.baseFrom !== undefined) {
+        const declared = found.manifest[reference.baseFrom];
+        base = typeof declared === "string" ? map[declared] : undefined;
+    }
+    if (!base)
+        return report();
+    return { ...base, [reference.keyword]: values };
+}
 /**
  * Project one declaration to an object schema.
  *
@@ -148,7 +254,12 @@ export function projectionKeyMap(kindSchema, projection) {
  * enough to double as a validator would move the domain's semantics into the
  * type layer.
  */
-export function projectEntries(manifest, projection, map) {
+export function projectEntries(manifest, projection, map, 
+/** What a REFERENCE at the keyed field is resolved through, and where a
+ *  failure to resolve one is reported. A caller with no scope cannot resolve
+ *  one, so such an entry projects OPEN — present, untyped — rather than
+ *  vanishing from the row. */
+options) {
     const entries = navigate(manifest, projection.entries);
     if (entries === undefined)
         return undefined;
@@ -157,7 +268,9 @@ export function projectEntries(manifest, projection, map) {
         if (!isObject(entry) || name === undefined)
             return;
         const key = entry[projection.key];
-        const mapped = typeof key === "string" ? map[key] : undefined;
+        const mapped = typeof key === "string"
+            ? map[key]
+            : referencedNode(key, name, projection, map, options);
         // A value with no map entry projects to nothing rather than to `any`: the
         // vocabulary is the kind's own enum, so an unmapped value is a gap in the
         // kind's declaration, not a shape to guess at.
@@ -193,11 +306,26 @@ export function projectEntries(manifest, projection, map) {
         additionalProperties: false,
     };
 }
-/** The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
- *  a host whose slot may hold EITHER shape can fall back to this reading. */
+/**
+ * The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
+ * a host whose slot may hold EITHER shape can fall back to this reading.
+ *
+ * The unresolved `!ref` SENTINEL is read too. `resolveRefSentinels` normally
+ * rewrites one before this pass, but not when the reference names nothing — and
+ * that is exactly when a projection failure is reported, so reading only the
+ * resolved shape made the diagnostic name the target `<unnamed>`, which is the
+ * one fact the author needed from it. A round-trip host (`compile` off) carries
+ * the sentinel for every reference, resolved or not.
+ */
 export function readProjectionRef(value) {
     if (!isObject(value))
         return undefined;
+    if (isRefSentinel(value)) {
+        const dot = value.source.indexOf(".");
+        return dot > 0
+            ? { name: value.source.slice(dot + 1), alias: value.source.slice(0, dot) }
+            : { name: value.source };
+    }
     const name = value.name;
     if (typeof name !== "string")
         return undefined;
@@ -251,6 +379,9 @@ function refTarget(value, scope, pointer) {
     if ("ambiguous" in found)
         return { reason: "ambiguous", pointer, name };
     const manifest = found.manifest;
+    if (isInjectedDeclaration(manifest)) {
+        return { reason: "injected", pointer, name };
+    }
     if (typeof manifest.kind !== "string")
         return { reason: "unresolved", pointer, name };
     const definition = scope.resolveDefinition(manifest.kind);
@@ -258,18 +389,44 @@ function refTarget(value, scope, pointer) {
         return { reason: "no-projection", pointer, kind: manifest.kind };
     return { manifest, definition };
 }
+/** The declaration the annotation is written on, as a projection target. */
+function ownTarget(manifest, scope) {
+    if (typeof manifest.kind !== "string") {
+        return { reason: "no-ref", pointer: "" };
+    }
+    const definition = scope.resolveDefinition(manifest.kind);
+    if (!definition)
+        return { reason: "no-projection", pointer: "", kind: manifest.kind };
+    return { manifest, definition };
+}
 export function describeProjectionFailure(failure) {
     switch (failure.reason) {
         case "no-ref":
-            return `'${failure.pointer}' does not hold a reference, so there is no declaration to project.`;
+            return failure.pointer === ""
+                ? "this resource declares no 'kind:', so there is no definition to project it through."
+                : `'${failure.pointer}' does not hold a reference, so there is no declaration to project.`;
         case "unresolved":
             return `'${failure.pointer}' references '${failure.name}', which resolves to no resource.`;
+        case "injected":
+            return (`'${failure.pointer}' references '${failure.name}', a resource input this module does ` +
+                `not declare — its entries belong to whoever supplies it.`);
         case "ambiguous":
             return (`'${failure.pointer}' references '${failure.name}', which matches more than one resource ` +
                 `in scope. Rename one of them so the reference names exactly one declaration.`);
         case "no-projection":
             return (`'${failure.pointer}' references a resource of kind '${failure.kind}', which declares no ` +
                 `'x-telo-schema-projection' — so there is nothing for this slot to be typed from.`);
+        case "no-projection-map":
+            return (`kind '${failure.kind}' declares an 'x-telo-schema-projection' whose key field carries ` +
+                `no 'x-telo-schema-map', so there is no vocabulary to project its entries through and ` +
+                `'${failure.pointer || "this declaration"}' cannot be typed from it.`);
+        case "no-entries":
+            return (`'${failure.entries}' holds no entry collection on this ${failure.kind}, so the ` +
+                `projection has nothing to type '${failure.pointer || "this declaration"}' from.`);
+        case "entry-reference":
+            return (`entry '${failure.entry}' at '${failure.pointer}' references '${failure.name}', which ` +
+                `resolves to no declaration this analysis can read — so that entry is projected as an ` +
+                `open value and nothing typed from it is checked against the shape it was meant to have.`);
     }
 }
 /**
@@ -282,36 +439,74 @@ export function describeProjectionFailure(failure) {
  * `failures`, because degrading SILENTLY is the failure this whole mechanism
  * exists to move earlier: the consumer's contract quietly reopens and a
  * misspelled field passes `telo check` exactly as it did before.
+ *
+ * **A node that projected NOTHING is returned by IDENTITY**, and that is a
+ * correctness property of the caller rather than a micro-optimization:
+ * `DefinitionRegistry` memoizes a compiled AJV validator per schema OBJECT,
+ * because every resource of a kind is checked against the same one at keystroke
+ * time. Rebuilding each node unconditionally — which this did — misses that memo
+ * for every resource in the analysis, so AJV recompiled the whole kind schema
+ * once per resource: on `apps/hub` that was 197 compiles instead of 54, and 723
+ * ms instead of 97. Returning the input where nothing changed restores it for
+ * every kind that declares no projection at all, which is nearly all of them.
  */
 export function resolveSchemaProjections(schema, manifest, scope, failures) {
     if (Array.isArray(schema)) {
-        return schema.map((item) => resolveSchemaProjections(item, manifest, scope, failures));
+        let moved = false;
+        const items = schema.map((item) => {
+            const next = resolveSchemaProjections(item, manifest, scope, failures);
+            if (next !== item)
+                moved = true;
+            return next;
+        });
+        return moved ? items : schema;
     }
     if (!isObject(schema))
         return schema;
     const pointer = readProjectionFrom(schema);
-    if (pointer && manifest) {
-        const target = refTarget(navigate(manifest, pointer), scope, pointer);
+    if (pointer !== undefined && manifest) {
+        // The EMPTY pointer names the declaration this annotation is written on,
+        // rather than a slot holding a reference to another. Resolution is skipped
+        // because the declaration is already in hand — which is what lets a kind
+        // type its own data against its own entries (a table's seed rows against its
+        // columns), something no reference could reach.
+        const target = pointer === ""
+            ? ownTarget(manifest, scope)
+            : refTarget(navigate(manifest, pointer), scope, pointer);
         if ("reason" in target) {
             failures?.push(target);
         }
         else {
+            const kind = String(target.manifest.kind ?? "<unknown>");
             const projection = readSchemaProjection(target.definition);
             const map = projection && projectionKeyMap(target.definition.schema, projection);
-            const projected = projection && map ? projectEntries(target.manifest, projection, map) : undefined;
+            const projected = projection && map
+                ? projectEntries(target.manifest, projection, map, { scope, pointer, failures })
+                : undefined;
             if (projected) {
                 const { ["x-telo-schema-projection-from"]: _dropped, ...rest } = schema;
                 return { ...rest, ...projected };
             }
-            failures?.push({
-                reason: "no-projection",
-                pointer,
-                kind: String(target.manifest.kind ?? "<unknown>"),
-            });
+            // Three distinct omissions, three repairs by three different authors: the
+            // kind declares no projection, the kind declares one the key field has no
+            // vocabulary for, or this DECLARATION simply lists no entries.
+            if (!projection)
+                failures?.push({ reason: "no-projection", pointer, kind });
+            else if (!map)
+                failures?.push({ reason: "no-projection-map", pointer, kind });
+            else {
+                failures?.push({ reason: "no-entries", pointer, kind, entries: projection.entries });
+            }
         }
     }
-    return Object.fromEntries(Object.entries(schema).map(([key, value]) => [
-        key,
-        key.startsWith("x-telo-") ? value : resolveSchemaProjections(value, manifest, scope, failures),
-    ]));
+    let moved = false;
+    const entries = Object.entries(schema).map(([key, value]) => {
+        const next = key.startsWith("x-telo-")
+            ? value
+            : resolveSchemaProjections(value, manifest, scope, failures);
+        if (next !== value)
+            moved = true;
+        return [key, next];
+    });
+    return moved ? Object.fromEntries(entries) : schema;
 }

package/dist/system-kinds.d.ts

@@ -19,7 +19,12 @@ export declare const DEPENDENCY_GRAPH_SKIP_KINDS: ReadonlySet<string>;
 /** Skipped by `!ref` sentinel resolution: kinds whose bodies are
  *  blueprints or import-time metadata, not resource instances with
  *  user-referenced ref slots. Mirrors `REF_VALIDATION_SKIP_KINDS` but
- *  also drops Telo.Import (its `source` isn't a ref slot, and walking
- *  the field map on it is pointless since there's no registered kind). */
+ *  also lists Telo.Import, because walking its field map is pointless —
+ *  there is no registered kind behind it.
+ *
+ *  `resolveRefSentinels` reaches Telo.Import's `resources:` block AHEAD of this
+ *  set, deliberately: those are the references an importer supplies for a
+ *  library's declared inputs, and they resolve exactly like any other. Nothing
+ *  else on the document is a reference slot, so only that subtree is walked. */
 export declare const REF_RESOLUTION_SKIP_KINDS: ReadonlySet<string>;
 //# sourceMappingURL=system-kinds.d.ts.map

package/dist/system-kinds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-kinds.d.ts","sourceRoot":"","sources":["../src/system-kinds.ts"],"names":[],"mappings":"AAAA;;;;sEAIsE;AAEtE;;;;;;0CAM0C;AAC1C,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAGxD,CAAC;AAEH;;;4CAG4C;AAC5C,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,CAG1D,CAAC;AAEH;;;;0EAI0E;AAC1E,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAIxD,CAAC"}
+{"version":3,"file":"system-kinds.d.ts","sourceRoot":"","sources":["../src/system-kinds.ts"],"names":[],"mappings":"AAAA;;;;sEAIsE;AAEtE;;;;;;0CAM0C;AAC1C,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAGxD,CAAC;AAEH;;;4CAG4C;AAC5C,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,CAG1D,CAAC;AAEH;;;;;;;;;gFASgF;AAChF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAIxD,CAAC"}

package/dist/system-kinds.js

@@ -25,8 +25,13 @@ export const DEPENDENCY_GRAPH_SKIP_KINDS = new Set([
 /** Skipped by `!ref` sentinel resolution: kinds whose bodies are
  *  blueprints or import-time metadata, not resource instances with
  *  user-referenced ref slots. Mirrors `REF_VALIDATION_SKIP_KINDS` but
- *  also drops Telo.Import (its `source` isn't a ref slot, and walking
- *  the field map on it is pointless since there's no registered kind). */
+ *  also lists Telo.Import, because walking its field map is pointless —
+ *  there is no registered kind behind it.
+ *
+ *  `resolveRefSentinels` reaches Telo.Import's `resources:` block AHEAD of this
+ *  set, deliberately: those are the references an importer supplies for a
+ *  library's declared inputs, and they resolve exactly like any other. Nothing
+ *  else on the document is a reference slot, so only that subtree is walked. */
 export const REF_RESOLUTION_SKIP_KINDS = new Set([
     "Telo.Definition",
     "Telo.Abstract",

package/dist/telo-version.d.ts

@@ -1,3 +1,3 @@
 /** The surface generation this analyzer implements. */
-export declare const TELO_SURFACE_VERSION = "0.82.0";
+export declare const TELO_SURFACE_VERSION = "0.83.0";
 //# sourceMappingURL=telo-version.d.ts.map

package/dist/telo-version.js

@@ -5,4 +5,4 @@
 // its release identity, this is the scale a module's `requires.telo` range is
 // written against, and every kernel in every language reports the same scale.
 /** The surface generation this analyzer implements. */
-export const TELO_SURFACE_VERSION = "0.82.0";
+export const TELO_SURFACE_VERSION = "0.83.0";

package/dist/template-body.d.ts

@@ -0,0 +1,50 @@
+import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
+import type { AliasResolver } from "./alias-resolver.js";
+import type { DefinitionRegistry } from "./definition-registry.js";
+import type { ModuleScopes } from "./alias-resolver.js";
+/**
+ * A `Telo.Definition`'s `resources:` entries — the bodies a kind writes for
+ * ANOTHER kind — read as what they are: declarations of that other kind.
+ *
+ * The consequence is the whole point. CEL inside such a body used to be typed in
+ * the ENCLOSING definition's scope, against one fixed permissive context
+ * (`self`, plus open `request` / `result` / `steps` / `error`). So `inputs` and
+ * `item` were undefined wherever the nested kind declares them, while `error`
+ * was offered everywhere regardless of whether a `catch:` was in scope — a body
+ * of more than one dispatch was unwritable, which is why no standard-library
+ * template has one.
+ *
+ * Resolving through the nested kind's OWN annotations — its `x-telo-context`
+ * regions, its step body, its error branches — makes a nested declaration answer
+ * exactly as the same declaration written at the top level does, with `self`
+ * merged in from the enclosing definition's `schema:`.
+ *
+ * Browser-safe.
+ */
+export interface TemplateBody {
+    /** Concrete path prefix of this entry (`resources[0]`), as CEL sites are
+     *  addressed. */
+    prefix: string;
+    /** JSONPath prefix for context scopes (`$.resources[0]`). */
+    scopePrefix: string;
+    manifest: ResourceManifest;
+    definition: ResourceDefinition | undefined;
+}
+/** The template bodies a manifest declares — empty for anything that is not a
+ *  `Telo.Definition` with a `resources:` array. */
+export declare function templateBodies(m: ResourceManifest, registry: DefinitionRegistry, aliases: AliasResolver | undefined, scopes: ModuleScopes | undefined): TemplateBody[];
+/** True when a CEL path lies at or inside a body's own subtree. */
+export declare function pathInBody(path: string, prefix: string): boolean;
+/** The body a CEL path belongs to, or undefined for a path in the definition's
+ *  own fields. Generic over what the caller keyed to each body — the resolver
+ *  carries a step context and an error map, the visitor carries the schema. */
+export declare function bodyForPath<T extends {
+    prefix: string;
+}>(bodies: readonly T[], path: string): T | undefined;
+/** `self` is in scope throughout a template body — it is how the body reaches
+ *  the configuration its enclosing kind was given — so it is merged into every
+ *  context the nested kind declares, which knows nothing about it. Merged UNDER
+ *  the nested kind's own properties: a name the nested kind declares wins, since
+ *  that is what its controller will bind. */
+export declare function withTemplateSelf(contextSchema: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=template-body.d.ts.map

package/dist/template-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-body.d.ts","sourceRoot":"","sources":["../src/template-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,YAAY;IAC3B;qBACiB;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,kBAAkB,GAAG,SAAS,CAAC;CAC5C;AAED;mDACmD;AACnD,wBAAgB,cAAc,CAC5B,CAAC,EAAE,gBAAgB,EACnB,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,YAAY,EAAE,CA8BhB;AAED,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAIhE;AAED;;+EAE+E;AAC/E,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACtD,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,SAAS,CAEf;AAED;;;;6CAI6C;AAC7C,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQxF"}

package/dist/template-body.js

@@ -0,0 +1,58 @@
+/** The template bodies a manifest declares — empty for anything that is not a
+ *  `Telo.Definition` with a `resources:` array. */
+export function templateBodies(m, registry, aliases, scopes) {
+    if (m.kind !== "Telo.Definition")
+        return [];
+    const bodies = m.resources;
+    if (!Array.isArray(bodies))
+        return [];
+    // A nested kind is written through the alias scope of the module that DECLARED
+    // the definition, never the consumer's — the same rule every other kind
+    // resolution in a forwarded manifest follows.
+    const ownModule = m.metadata?.module;
+    const scope = (ownModule && scopes && !scopes.rootModules.has(ownModule)
+        ? scopes.aliasesByModule.get(ownModule)
+        : undefined) ?? aliases;
+    const out = [];
+    for (let i = 0; i < bodies.length; i++) {
+        const body = bodies[i];
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            continue;
+        const kind = body.kind;
+        if (typeof kind !== "string")
+            continue;
+        const canonical = scope?.resolveKind(kind);
+        const definition = registry.resolve(kind) ?? (canonical ? registry.resolve(canonical) : undefined);
+        out.push({
+            prefix: `resources[${i}]`,
+            scopePrefix: `$.resources[${i}]`,
+            manifest: body,
+            definition,
+        });
+    }
+    return out;
+}
+/** True when a CEL path lies at or inside a body's own subtree. */
+export function pathInBody(path, prefix) {
+    return (path === prefix || path.startsWith(`${prefix}.`) || path.startsWith(`${prefix}[`));
+}
+/** The body a CEL path belongs to, or undefined for a path in the definition's
+ *  own fields. Generic over what the caller keyed to each body — the resolver
+ *  carries a step context and an error map, the visitor carries the schema. */
+export function bodyForPath(bodies, path) {
+    return bodies.find((b) => pathInBody(path, b.prefix));
+}
+/** `self` is in scope throughout a template body — it is how the body reaches
+ *  the configuration its enclosing kind was given — so it is merged into every
+ *  context the nested kind declares, which knows nothing about it. Merged UNDER
+ *  the nested kind's own properties: a name the nested kind declares wins, since
+ *  that is what its controller will bind. */
+export function withTemplateSelf(contextSchema) {
+    return {
+        ...contextSchema,
+        properties: {
+            self: { "x-telo-context-from-root": "schema" },
+            ...(contextSchema.properties ?? {}),
+        },
+    };
+}

package/dist/validate-cel-context.d.ts

@@ -1,4 +1,5 @@
 export { extractAccessChains, validateChainAgainstSchema } from "@telorun/templating";
+export { extractCelRegionScopes, pathMatchesScope } from "./eval-paths.js";
 export interface ContextResolveOpts {
     /** When provided, used to resolve `x-telo-context-from-root` annotations against the
      *  root manifest. When omitted, defaults to `manifestItem`. */
@@ -15,14 +16,6 @@ export interface ContextResolveOpts {
     allManifests?: Record<string, any>[];
 }
 export declare function resolveTypeFieldToSchema(value: unknown, allManifests: Record<string, any>[], ancestry?: ReadonlySet<string>): Record<string, any> | undefined;
-/**
- * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].inputs.q")
- * falls within the scope of a context (e.g. "$.routes[*].inputs").
- *
- * The scope is matched directly (no sibling sharing): a context at "$.routes[*].inputs" only
- * applies to expressions whose path starts with "routes[N].inputs", not to other sibling fields.
- */
-export declare function pathMatchesScope(exprPath: string, scope: string): boolean;
 /**
  * Resolves `x-telo-context-*` annotations in a context schema using the concrete
  * manifest item (per-scope) and the manifest root.
@@ -91,13 +84,4 @@ export declare function extractContextsFromSchema(schema: Record<string, any>, p
     scope: string;
     schema: Record<string, any>;
 }>;
-/**
- * Walk a JSON Schema tree and collect the JSONPath scopes of every field that
- * declares a CEL-bearing region (`x-telo-context` / `x-telo-step-context` /
- * `x-telo-error-context`). Used — alongside `x-telo-eval` paths — to decide
- * whether a `!cel` expression sits in a slot the runtime actually evaluates.
- * Scopes use the same `$.a.b[*]` form as `extractContextsFromSchema`, matched
- * against expression paths with `pathMatchesScope`.
- */
-export declare function extractCelRegionScopes(schema: Record<string, any>, path?: string): string[];
 //# sourceMappingURL=validate-cel-context.d.ts.map

package/dist/validate-cel-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-cel-context.d.ts","sourceRoot":"","sources":["../src/validate-cel-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAWtF,MAAM,WAAW,kBAAkB;IACjC;mEAC+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC;;kDAE8C;IAC9C,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;KACxD,CAAC;IACF,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KAC/C,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CACtC;AA4CD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GACxC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA0EjC;AAyID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAoBzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,IAAI,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAChD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyKrB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQrB;AAWD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,SAAM,GACT,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAGvD;AAYD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,SAAM,GAAG,MAAM,EAAE,CAqBxF"}
+{"version":3,"file":"validate-cel-context.d.ts","sourceRoot":"","sources":["../src/validate-cel-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAatF,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AA2B3E,MAAM,WAAW,kBAAkB;IACjC;mEAC+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC;;kDAE8C;IAC9C,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;KACxD,CAAC;IACF,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KAC/C,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CACtC;AA4CD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GACxC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA0EjC;AAyID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,IAAI,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAChD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAoLrB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAuBrB;AAqBD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,SAAM,GACT,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAGvD"}