@telorun/templating 0.13.0 → 0.15.0

package/dist/builtins.d.ts

@@ -8,6 +8,17 @@ import type { TemplatingEngine } from "./engine.js";
  *  another (e.g. `cel + literal`); always ship the same set. */
 export declare const builtinEngines: readonly TemplatingEngine[];
 export declare function createDefaultRegistry(): TemplatingEngineRegistry;
+/**
+ * The type a tag always produces, or undefined when its produced type is a
+ * function of the slot rather than of the tag (`!cel`, `!ref`).
+ *
+ * The single reader of `TemplatingEngine.producedType`, so a consumer asks the
+ * registry what a tag produces instead of recognising tag names — the same seam
+ * `fileClaims` opened for payload membership. Reads the default registry
+ * because a produced type is a property of the engine, not of a host's
+ * configuration, and every host ships the same built-in set.
+ */
+export declare function producedTypeOf(engineName: string): Record<string, unknown> | undefined;
 /** Memoized singleton: returns the default registry. Hosts that don't need
  *  per-instance isolation (precompile, the analyzer's tagged-value walker)
  *  should use this so they share the same registry instance the YAML tag

package/dist/builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;gEAKgE;AAChE,eAAO,MAAM,cAAc,EAAE,SAAS,gBAAgB,EAOrD,CAAC;AAEF,wBAAgB,qBAAqB,IAAI,wBAAwB,CAMhE;AAID;;;oBAGoB;AACpB,wBAAgB,eAAe,IAAI,wBAAwB,CAK1D"}
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;gEAKgE;AAChE,eAAO,MAAM,cAAc,EAAE,SAAS,gBAAgB,EAOrD,CAAC;AAEF,wBAAgB,qBAAqB,IAAI,wBAAwB,CAMhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAEtF;AAID;;;oBAGoB;AACpB,wBAAgB,eAAe,IAAI,wBAAwB,CAK1D"}

package/dist/builtins.js

@@ -25,6 +25,19 @@ export function createDefaultRegistry() {
     }
     return registry;
 }
+/**
+ * The type a tag always produces, or undefined when its produced type is a
+ * function of the slot rather than of the tag (`!cel`, `!ref`).
+ *
+ * The single reader of `TemplatingEngine.producedType`, so a consumer asks the
+ * registry what a tag produces instead of recognising tag names — the same seam
+ * `fileClaims` opened for payload membership. Reads the default registry
+ * because a produced type is a property of the engine, not of a host's
+ * configuration, and every host ships the same built-in set.
+ */
+export function producedTypeOf(engineName) {
+    return defaultRegistry().get(engineName)?.producedType?.();
+}
 let defaultRegistryCache;
 /** Memoized singleton: returns the default registry. Hosts that don't need
  *  per-instance isolation (precompile, the analyzer's tagged-value walker)

package/dist/cel/analyze.d.ts

@@ -29,7 +29,8 @@ export declare function findNullableAccessIssues(node: ASTNode, contextSchema: R
  * Check whether a member-access chain accesses only fields declared in a JSON Schema.
  * Returns an error string if a field is unknown in a schema that declares explicit
  * properties without `additionalProperties: true`, or if the chain attempts to
- * reach inside an `x-telo-stream: true` property.
+ * reach inside a `live` value type — one whose consumption has effects, so its
+ * contents exist only for a consumer that drains it.
  * Returns null when the chain is valid or the schema is too open to judge.
  */
 export declare function validateChainAgainstSchema(chain: string[], schema: Record<string, any>): string | null;

package/dist/cel/analyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/cel/analyze.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,EAAE,CAI7D;AA0DD;;+DAE+D;AAC/D,eAAO,MAAM,aAAa,QAAQ,CAAC;AAqBnC,UAAU,aAAa;IACrB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;CAChB;AAoFD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjC,aAAa,EAAE,CAIjB;AA2FD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,MAAM,GAAG,IAAI,CA2Bf"}
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/cel/analyze.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGpD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,EAAE,CAI7D;AA0DD;;+DAE+D;AAC/D,eAAO,MAAM,aAAa,QAAQ,CAAC;AAqBnC,UAAU,aAAa;IACrB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;CAChB;AAoFD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjC,aAAa,EAAE,CAIjB;AA2FD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,MAAM,GAAG,IAAI,CAsBf"}

package/dist/cel/analyze.js

@@ -1,3 +1,4 @@
+import { isLiveSlot } from "@telorun/sdk";
 /**
  * Extract all member-access chains from a CEL AST.
  * Returns arrays like ["request", "query", "name"] for `request.query.name`.
@@ -254,7 +255,8 @@ function walkNullable(node, nonNull, boundVars, issues, schema) {
  * Check whether a member-access chain accesses only fields declared in a JSON Schema.
  * Returns an error string if a field is unknown in a schema that declares explicit
  * properties without `additionalProperties: true`, or if the chain attempts to
- * reach inside an `x-telo-stream: true` property.
+ * reach inside a `live` value type — one whose consumption has effects, so its
+ * contents exist only for a consumer that drains it.
  * Returns null when the chain is valid or the schema is too open to judge.
  */
 export function validateChainAgainstSchema(chain, schema) {
@@ -268,10 +270,7 @@ export function validateChainAgainstSchema(chain, schema) {
             return null;
         if (key in props) {
             const propSchema = props[key];
-            if (propSchema &&
-                typeof propSchema === "object" &&
-                propSchema["x-telo-stream"] === true &&
-                i < chain.length - 1) {
+            if (isLiveSlot(propSchema) && i < chain.length - 1) {
                 const path = chain.slice(0, i + 1).join(".");
                 return `'${path}' yields a stream — pipe it through an Encoder or iterate in a JS.Script step (no member access on stream-typed values)`;
             }

package/dist/cel/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/cel/catalog.ts"],"names":[],"mappings":"AAGA;;;0DAG0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAClE,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAClC;AA2CD,MAAM,MAAM,mBAAmB,GAC3B,YAAY,GACZ,MAAM,GACN,MAAM,GACN,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,MAAM,GACN,UAAU,GACV,SAAS,GACT,MAAM,CAAC;AAEX;;;qBAGqB;AACrB,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;0EACsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;yDAIqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;wBACoB;IACpB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;2EACuE;IACvE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;CACjE;AAED,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;AAyE5D,eAAO,MAAM,aAAa,EAAE,SAAS,cAAc,EA+hBlD,CAAC;AAEF,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,eAAe,EAAE,CAEtD"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/cel/catalog.ts"],"names":[],"mappings":"AAGA;;;0DAG0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAClE,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAClC;AA2CD,MAAM,MAAM,mBAAmB,GAC3B,YAAY,GACZ,MAAM,GACN,MAAM,GACN,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,MAAM,GACN,UAAU,GACV,SAAS,GACT,MAAM,CAAC;AAEX;;;qBAGqB;AACrB,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;0EACsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;yDAIqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;wBACoB;IACpB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;2EACuE;IACvE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;CACjE;AAED,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;AAwH5D,eAAO,MAAM,aAAa,EAAE,SAAS,cAAc,EAslBlD,CAAC;AAEF,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,eAAe,EAAE,CAEtD"}

package/dist/cel/catalog.js

@@ -106,6 +106,51 @@ const dateInZone = (tz) => {
     const p = zoneParts(now, tz, { year: "numeric", month: "2-digit", day: "2-digit" });
     return `${p.year}-${p.month}-${p.day}`;
 };
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Base64 → bytes, written out rather than delegated: `Buffer` is not browser-
+ *  safe and `atob` round-trips through a string, which is the corruption this
+ *  pair exists to avoid. Accepts the URL-safe alphabet and tolerates missing
+ *  padding, both of which appear in real API payloads; a character outside the
+ *  alphabet is a hard error rather than a silently dropped byte. */
+function decodeBase64ToBytes(input) {
+    const clean = input.replace(/[\r\n\t ]/g, "").replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+    // A remainder of 1 cannot come from any byte sequence: base64 encodes 3 bytes
+    // as 4 characters, so the valid remainders are 0, 2 and 3. Left to the loop it
+    // would leave 6 bits unwritten and return a SHORT buffer — the silently dropped
+    // byte this function refuses for a bad character.
+    if (clean.length % 4 === 1) {
+        throw new Error("bytesFromBase64: input length is not valid base64");
+    }
+    const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let bits = 0;
+    let acc = 0;
+    let written = 0;
+    for (const ch of clean) {
+        const value = BASE64_ALPHABET.indexOf(ch);
+        if (value < 0)
+            throw new Error(`bytesFromBase64: '${ch}' is not a base64 character`);
+        acc = (acc << 6) | value;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = (acc >> bits) & 0xff;
+        }
+    }
+    return out.subarray(0, written);
+}
+function encodeBytesToBase64(input) {
+    let out = "";
+    for (let i = 0; i < input.length; i += 3) {
+        const a = input[i];
+        const b = i + 1 < input.length ? input[i + 1] : undefined;
+        const c = i + 2 < input.length ? input[i + 2] : undefined;
+        out += BASE64_ALPHABET[a >> 2];
+        out += BASE64_ALPHABET[((a & 0x03) << 4) | ((b ?? 0) >> 4)];
+        out += b === undefined ? "=" : BASE64_ALPHABET[((b & 0x0f) << 2) | ((c ?? 0) >> 6)];
+        out += c === undefined ? "=" : BASE64_ALPHABET[c & 0x3f];
+    }
+    return out;
+}
 export const CEL_FUNCTIONS = [
     // Collections
     {
@@ -303,6 +348,37 @@ export const CEL_FUNCTIONS = [
         hostBacked: false,
         build: () => (s, suffix) => suffix && s.endsWith(suffix) ? s.slice(0, s.length - suffix.length) : s,
     },
+    // One `slice` over the three sequence types rather than three names: CEL
+    // already treats `size()` that way, and the alternative teaches an author that
+    // slicing bytes is a different operation from slicing a string.
+    //
+    // ONE `dyn` signature rather than a concrete overload per element type. The
+    // concrete set is more precise, but cel-js refuses overloads that overlap, so
+    // it cannot also carry the `dyn` case — and a step result whose producer
+    // declares no output type IS `dyn`, which is the common receiver. With only the
+    // concrete set the checker resolves such a call to whichever overload it tries
+    // first and pins the result to that type, so slicing an untyped byte buffer
+    // came back typed `string`. Precision here would be lost at the CEL boundary
+    // anyway, where type arguments are erased.
+    {
+        name: "slice",
+        signature: "slice(dyn, int, int): dyn",
+        // Not "string": it is the one function over strings, bytes AND lists, and the
+        // category is what groups it in the generated reference — filing it under
+        // strings hides it from the byte and list readers who need it most.
+        category: "collection",
+        summary: "Take the half-open range [start, end) of a string, bytes or list.",
+        deterministic: true,
+        hostBacked: false,
+        // Indices arrive as BigInt (a CEL int is int64), and both `String.slice` and
+        // `TypedArray.subarray` reject one. `subarray` rather than `slice` for bytes:
+        // a view costs no copy, and every consumer treats the result as read-only.
+        build: () => (value, start, end) => {
+            const from = Number(start);
+            const to = Number(end);
+            return value instanceof Uint8Array ? value.subarray(from, to) : value.slice(from, to);
+        },
+    },
     // Math
     {
         name: "abs",
@@ -416,6 +492,30 @@ export const CEL_FUNCTIONS = [
         hostBacked: true,
         build: (h) => (s) => h.base64Decode(s),
     },
+    // Base64 <-> BYTES, as distinct from the two above, which are UTF-8
+    // string<->string and silently corrupt anything that is not text. Those keep
+    // their meaning (changing it would change what shipped manifests mean); these
+    // are the correct path for binary, and the pair a byte-typed slot needs.
+    // Pure-JS on purpose: `Buffer` is what made the string pair host-backed, and
+    // this package has to stay browser-safe.
+    {
+        name: "bytesFromBase64",
+        signature: "bytesFromBase64(string): bytes",
+        category: "encoding",
+        summary: "Decode a base64 string to raw bytes.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => decodeBase64ToBytes(s),
+    },
+    {
+        name: "bytesToBase64",
+        signature: "bytesToBase64(bytes): string",
+        category: "encoding",
+        summary: "Encode raw bytes as a base64 string.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (b) => encodeBytesToBase64(b),
+    },
     {
         name: "urlEncode",
         signature: "urlEncode(string): string",

package/dist/engine.d.ts

@@ -131,5 +131,24 @@ export interface TemplatingEngine {
      *  A source the engine considers malformed claims nothing; `analyze` is what
      *  reports why. */
     fileClaims?(source: string): readonly EngineFileClaim[];
+    /** The type this tag ALWAYS produces, as a JSON Schema fragment.
+     *
+     *  Declared by the engine, never recognised by a consumer — the `fileClaims`
+     *  precedent applied to the one fact it left behind. Before this, the analyzer
+     *  hardcoded two tag names to hand an `!include-bytes` a byte placeholder and
+     *  an `!include-text` a string one; the only place a tag's produced type was
+     *  written down was in its consumer, so a future tag producing bytes had to be
+     *  added to a set rather than declaring it.
+     *
+     *  Absent for an engine whose produced type is a function of the SLOT rather
+     *  than of the tag — `!cel`, whose type is only derivable from the expression,
+     *  and `!ref`, which is an identity marker. Their values keep taking a
+     *  slot-shaped placeholder.
+     *
+     *  What falls out is the property this preserves exactly: because an embed's
+     *  type is a constant of the tag, a byte embed at a string slot and text at a
+     *  byte slot both fail statically, through the ordinary schema check and with
+     *  no diagnostic code of their own. */
+    producedType?(): Record<string, unknown>;
 }
 //# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD;;wEAEwE;AACxE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED;;;;;;;;;eASe;AACf,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;0EAa0E;AAC1E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;oDAEoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED;;;;yBAIyB;AACzB,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;oDAEgD;IAChD,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;iFAGiF;AACjF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;4CAgB4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;wBAEwB;AACxB,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;2EAKuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B;;;yDAGqD;IACrD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,aAAa,GAAG,OAAO,CAAC;IAElE;;iEAE6D;IAC7D,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,aAAa,CAAC;IAExD;;;;;;;;;;;;uBAYmB;IACnB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE,CAAC;CACzD"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD;;wEAEwE;AACxE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED;;;;;;;;;eASe;AACf,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;0EAa0E;AAC1E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;oDAEoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED;;;;yBAIyB;AACzB,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;oDAEgD;IAChD,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;iFAGiF;AACjF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;4CAgB4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;wBAEwB;AACxB,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;2EAKuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B;;;yDAGqD;IACrD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,aAAa,GAAG,OAAO,CAAC;IAElE;;iEAE6D;IAC7D,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,aAAa,CAAC;IAExD;;;;;;;;;;;;uBAYmB;IACnB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE,CAAC;IAExD;;;;;;;;;;;;;;;;;2CAiBuC;IACvC,YAAY,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C"}

package/dist/engines/include.d.ts

@@ -19,7 +19,10 @@ export interface NormalizedIncludePath {
 export declare function normalizeIncludePath(source: string): NormalizedIncludePath;
 /** Embeds a file's contents as a UTF-8 string. */
 export declare const includeTextEngine: TemplatingEngine;
-/** Embeds a file's contents as raw bytes — a `Uint8Array`, the shape every
- *  `x-telo-binary` slot accepts. */
+/** Embeds a file's contents as raw bytes — the shape every `Telo.Bytes` slot
+ *  accepts. The name is written as a literal rather than imported from the SDK:
+ *  templating is the lower package, and a produced type is a schema fragment,
+ *  which is data. What checks it is the registry the analyzer and the kernel both
+ *  read. */
 export declare const includeBytesEngine: TemplatingEngine;
 //# sourceMappingURL=include.d.ts.map

package/dist/engines/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../../src/engines/include.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAaxF,MAAM,WAAW,qBAAqB;IACpC;kEAC8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CA0E1E;AA0CD,kDAAkD;AAClD,eAAO,MAAM,iBAAiB,EAAE,gBAAqD,CAAC;AAEtF;oCACoC;AACpC,eAAO,MAAM,kBAAkB,EAAE,gBAAsD,CAAC"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../../src/engines/include.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAaxF,MAAM,WAAW,qBAAqB;IACpC;kEAC8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CA0E1E;AA8CD,kDAAkD;AAClD,eAAO,MAAM,iBAAiB,EAAE,gBAE9B,CAAC;AAEH;;;;YAIY;AACZ,eAAO,MAAM,kBAAkB,EAAE,gBAE/B,CAAC"}

package/dist/engines/include.js

@@ -106,12 +106,15 @@ export function normalizeIncludePath(source) {
  * `analyze` reports why a path is unusable; `fileClaims` reports the path itself
  * so publish can place the file in a layer without recognising the tag by name.
  */
-function includeEngine(name) {
+function includeEngine(name, produced) {
     return {
         name,
         compile(source) {
             return makeTaggedSentinel(name, source);
         },
+        producedType() {
+            return produced;
+        },
         analyze(source) {
             const { diagnostic } = normalizeIncludePath(source);
             return { diagnostics: diagnostic ? [diagnostic] : [], calls: [] };
@@ -126,7 +129,14 @@ function includeEngine(name) {
     };
 }
 /** Embeds a file's contents as a UTF-8 string. */
-export const includeTextEngine = includeEngine(INCLUDE_TEXT_ENGINE);
-/** Embeds a file's contents as raw bytes — a `Uint8Array`, the shape every
- *  `x-telo-binary` slot accepts. */
-export const includeBytesEngine = includeEngine(INCLUDE_BYTES_ENGINE);
+export const includeTextEngine = includeEngine(INCLUDE_TEXT_ENGINE, {
+    type: "string",
+});
+/** Embeds a file's contents as raw bytes — the shape every `Telo.Bytes` slot
+ *  accepts. The name is written as a literal rather than imported from the SDK:
+ *  templating is the lower package, and a produced type is a schema fragment,
+ *  which is data. What checks it is the registry the analyzer and the kernel both
+ *  read. */
+export const includeBytesEngine = includeEngine(INCLUDE_BYTES_ENGINE, {
+    "x-telo-type": "Telo.Bytes",
+});

package/dist/index.d.ts

@@ -10,9 +10,9 @@ export { literalEngine } from "./engines/literal.js";
 export { refEngine } from "./engines/ref.js";
 export { sqlEngine, isParameterizedSql, type ParameterizedSql } from "./engines/sql.js";
 export { TemplatingEngineRegistry } from "./registry.js";
-export { builtinEngines, createDefaultRegistry, defaultRegistry } from "./builtins.js";
+export { builtinEngines, createDefaultRegistry, defaultRegistry, producedTypeOf, } from "./builtins.js";
 export type { AnalyzeEnv, AnalyzeResult, CallSite, CompileEnv, DiagnosticFix, EngineDiagnostic, EngineFileClaim, TemplatingEngine, } from "./engine.js";
-export { INCLUDE_BYTES_ENGINE, INCLUDE_ENGINE_NAMES, INCLUDE_TEXT_ENGINE, isIncludeSentinel, isRefSentinel, isTaggedSentinel, makeTaggedSentinel, type TaggedSentinel, } from "./sentinel.js";
+export { CEL_ENGINE, INCLUDE_BYTES_ENGINE, INCLUDE_ENGINE_NAMES, INCLUDE_TEXT_ENGINE, isIncludeSentinel, isRefSentinel, isTaggedSentinel, makeTaggedSentinel, plainChainOf, type TaggedSentinel, } from "./sentinel.js";
 export { buildCustomTags, defaultCustomTags } from "./yaml-tags.js";
-export { MANIFEST_SCHEMA_URI, ManifestRootSchema, ResourceRefSchema, normalizeRefSlots, } from "./manifest-schemas.js";
+export { MANIFEST_SCHEMA_URI, ManifestRootSchema, ResourceRefSchema, } from "./manifest-schemas.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,EACL,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,WAAW,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,aAAa,EACb,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,kBAAkB,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAExF,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACvF,YAAY,EACV,UAAU,EACV,aAAa,EACb,QAAQ,EACR,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,WAAW,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,aAAa,EACb,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,kBAAkB,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAExF,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,cAAc,GACf,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,UAAU,EACV,aAAa,EACb,QAAQ,EACR,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -10,7 +10,7 @@ export { literalEngine } from "./engines/literal.js";
 export { refEngine } from "./engines/ref.js";
 export { sqlEngine, isParameterizedSql } from "./engines/sql.js";
 export { TemplatingEngineRegistry } from "./registry.js";
-export { builtinEngines, createDefaultRegistry, defaultRegistry } from "./builtins.js";
-export { INCLUDE_BYTES_ENGINE, INCLUDE_ENGINE_NAMES, INCLUDE_TEXT_ENGINE, isIncludeSentinel, isRefSentinel, isTaggedSentinel, makeTaggedSentinel, } from "./sentinel.js";
+export { builtinEngines, createDefaultRegistry, defaultRegistry, producedTypeOf, } from "./builtins.js";
+export { CEL_ENGINE, INCLUDE_BYTES_ENGINE, INCLUDE_ENGINE_NAMES, INCLUDE_TEXT_ENGINE, isIncludeSentinel, isRefSentinel, isTaggedSentinel, makeTaggedSentinel, plainChainOf, } from "./sentinel.js";
 export { buildCustomTags, defaultCustomTags } from "./yaml-tags.js";
-export { MANIFEST_SCHEMA_URI, ManifestRootSchema, ResourceRefSchema, normalizeRefSlots, } from "./manifest-schemas.js";
+export { MANIFEST_SCHEMA_URI, ManifestRootSchema, ResourceRefSchema, } from "./manifest-schemas.js";

package/dist/manifest-schemas.d.ts

@@ -70,22 +70,6 @@ export declare const ResourceRefSchema: {
         additionalProperties: boolean;
     })[];
 };
-/** Deep-clone `schema`, dropping the stale scalar `type` constraint from every
- *  reference-slot node — one carrying an `x-telo-ref` string annotation.
- *
- *  A reference slot's value is always a `!ref` sentinel or its resolved
- *  `{kind, name, alias?}` object (never a bare string, post-migration). Older
- *  published modules still pin `type: "string"` on these slots — the encoding
- *  references took when they were written as plain strings — which now rejects
- *  the resolved object. Removing only the scalar `type` lets the analyzer and
- *  kernel accept references uniformly across module versions during the
- *  migration away from `{kind, name}` / string references, without disturbing
- *  slots that legitimately accept an inline object (e.g. `inputType` /
- *  `outputType`, which take a Telo.Type reference *or* an inline JSON schema).
- *  The `x-telo-ref` constraint itself (which kind the reference must satisfy) is
- *  checked separately by the analyzer's reference walker, which reads the
- *  original schema — not this validation-only copy. */
-export declare function normalizeRefSlots(schema: unknown): unknown;
 /** Stable URI under which the shared manifest root schema is registered
  *  with module-side AJV instances. Module YAMLs reach the fragments via
  *  `$ref: "telo://manifest#/$defs/<Name>"`. The URI is the contract;

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

@@ -1 +1 @@
-{"version":3,"file":"manifest-schemas.d.ts","sourceRoot":"","sources":["../src/manifest-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;kBAMkB;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEA+ByE;AACzE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB7B,CAAC;AAqCF;;;;;;;;;;;;;;uDAcuD;AACvD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CA+C1D;AAED;;;;;+BAK+B;AAC/B,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AAErD;;;8BAG8B;AAC9B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK9B,CAAC"}
+{"version":3,"file":"manifest-schemas.d.ts","sourceRoot":"","sources":["../src/manifest-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;kBAMkB;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEA+ByE;AACzE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB7B,CAAC;AAGF;;;;;+BAK+B;AAC/B,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AAErD;;;8BAG8B;AAC9B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK9B,CAAC"}

package/dist/manifest-schemas.js

@@ -58,101 +58,6 @@ export const ResourceRefSchema = {
         },
     ],
 };
-const REF_ANNOTATION = "x-telo-ref";
-// The legacy base types a reference slot used to pin when references were
-// written as plain strings. Post-migration a reference resolves to an object
-// (the `{kind, name, alias?}` shape, or an unresolved `!ref` sentinel), so a
-// scalar `type` on a ref slot is a stale constraint that would reject the
-// resolved value. Object / array `type`s are left alone — they already admit
-// the reference object (and any inline value a slot like `inputType` accepts).
-const LEGACY_REF_SCALAR_TYPES = new Set(["string", "number", "integer", "boolean"]);
-// JSON Schema keywords whose values are themselves subschemas. Split by shape so
-// the ref-slot normalizer recurses only into schema positions — never into
-// data-bearing keywords (`default`, `const`, `enum`, `examples`), where a stray
-// `x-telo-ref` key would be data, not an annotation.
-const SUBSCHEMA_SINGLE = [
-    "additionalProperties",
-    "additionalItems",
-    "contains",
-    "not",
-    "if",
-    "then",
-    "else",
-    "propertyNames",
-    "unevaluatedItems",
-    "unevaluatedProperties",
-];
-const SUBSCHEMA_LIST = ["allOf", "anyOf", "oneOf", "prefixItems"];
-const SUBSCHEMA_MAP = [
-    "properties",
-    "patternProperties",
-    "$defs",
-    "definitions",
-    "dependentSchemas",
-];
-/** Deep-clone `schema`, dropping the stale scalar `type` constraint from every
- *  reference-slot node — one carrying an `x-telo-ref` string annotation.
- *
- *  A reference slot's value is always a `!ref` sentinel or its resolved
- *  `{kind, name, alias?}` object (never a bare string, post-migration). Older
- *  published modules still pin `type: "string"` on these slots — the encoding
- *  references took when they were written as plain strings — which now rejects
- *  the resolved object. Removing only the scalar `type` lets the analyzer and
- *  kernel accept references uniformly across module versions during the
- *  migration away from `{kind, name}` / string references, without disturbing
- *  slots that legitimately accept an inline object (e.g. `inputType` /
- *  `outputType`, which take a Telo.Type reference *or* an inline JSON schema).
- *  The `x-telo-ref` constraint itself (which kind the reference must satisfy) is
- *  checked separately by the analyzer's reference walker, which reads the
- *  original schema — not this validation-only copy. */
-export function normalizeRefSlots(schema) {
-    if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
-        return schema;
-    }
-    const node = schema;
-    const out = { ...node };
-    // Reference slot with a stale scalar `type` (legacy string-ref encoding):
-    // drop the constraint so the resolved reference object / sentinel validates.
-    //
-    // A presence test, not a shape test — deliberately, since `templating` sits
-    // BELOW the analyzer in the dependency order and cannot reach the shared
-    // `readRefSlot` accessor. Presence is the only thing this rule needs, and it
-    // is stable across every annotation shape.
-    if (node[REF_ANNOTATION] !== undefined &&
-        typeof node.type === "string" &&
-        LEGACY_REF_SCALAR_TYPES.has(node.type)) {
-        delete out.type;
-    }
-    for (const key of SUBSCHEMA_SINGLE) {
-        const value = node[key];
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-            out[key] = normalizeRefSlots(value);
-        }
-    }
-    for (const key of SUBSCHEMA_LIST) {
-        const value = node[key];
-        if (Array.isArray(value))
-            out[key] = value.map(normalizeRefSlots);
-    }
-    // `items` is either a single subschema or a tuple of subschemas.
-    if (Array.isArray(node.items)) {
-        out.items = node.items.map(normalizeRefSlots);
-    }
-    else if (node.items && typeof node.items === "object") {
-        out.items = normalizeRefSlots(node.items);
-    }
-    for (const key of SUBSCHEMA_MAP) {
-        const value = node[key];
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-            const mapped = {};
-            for (const [name, sub] of Object.entries(value)) {
-                mapped[name] = normalizeRefSlots(sub);
-            }
-            out[key] = mapped;
-        }
-    }
-    return out;
-}
 /** Stable URI under which the shared manifest root schema is registered
  *  with module-side AJV instances. Module YAMLs reach the fragments via
  *  `$ref: "telo://manifest#/$defs/<Name>"`. The URI is the contract;

package/dist/sentinel.d.ts

@@ -19,11 +19,29 @@ export declare function makeTaggedSentinel(engine: string, source: string): Tagg
 export declare function isRefSentinel(v: unknown): v is TaggedSentinel & {
     engine: "ref";
 };
+/** The CEL engine's name. Beside the other sentinel predicates for the same
+ *  reason they are: a consumer that spells an engine name inline is a second
+ *  place the registry's key is written down. */
+export declare const CEL_ENGINE = "cel";
 /** Engine names of the two file-embedding tags. Named here beside the other
  *  sentinel predicates so the kernel's resolution pass and the engines
  *  themselves agree on one spelling. */
 export declare const INCLUDE_TEXT_ENGINE = "include-text";
 export declare const INCLUDE_BYTES_ENGINE = "include-bytes";
+/**
+ * The dotted chain a value names, or undefined.
+ *
+ * Only a PLAIN CHAIN — `steps.encode.result.output` — in either spelling a
+ * manifest may carry it: a `!cel` sentinel or the `${{ }}` string form. An
+ * expression that COMPUTES rather than names has no schema to read off a context,
+ * so a caller that navigates one gets nothing and reports nothing: silence where
+ * the analyzer knows least is the conservative direction.
+ *
+ * Here rather than in each caller because "is this expression a plain chain" is
+ * one question, and two copies of the answer would eventually disagree about a
+ * shape like `a.b[0]`.
+ */
+export declare function plainChainOf(value: unknown): string | undefined;
 /** Both file-embedding tag names, for a consumer holding an engine NAME rather
  *  than a value (the analyzer's expression walk reports names). */
 export declare const INCLUDE_ENGINE_NAMES: ReadonlySet<string>;

package/dist/sentinel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sentinel.d.ts","sourceRoot":"","sources":["../src/sentinel.ts"],"names":[],"mappings":"AAAA;;;;;YAKY;AACZ,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,CAQhE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,CAEjF;AAED;;;;4CAI4C;AAC5C,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,GAAG;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,CAEjF;AAED;;wCAEwC;AACxC,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAClD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AAEpD;mEACmE;AACnE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAGnD,CAAC;AAEH;;;;;;;qCAOqC;AACrC,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,cAAc,GAAG;IAAE,MAAM,EAAE,OAAO,mBAAmB,GAAG,OAAO,oBAAoB,CAAA;CAAE,CAI5F"}
+{"version":3,"file":"sentinel.d.ts","sourceRoot":"","sources":["../src/sentinel.ts"],"names":[],"mappings":"AAAA;;;;;YAKY;AACZ,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,CAQhE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,CAEjF;AAED;;;;4CAI4C;AAC5C,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,GAAG;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,CAEjF;AAED;;gDAEgD;AAChD,eAAO,MAAM,UAAU,QAAQ,CAAC;AAEhC;;wCAEwC;AACxC,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAClD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAa/D;AAED;mEACmE;AACnE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAGnD,CAAC;AAEH;;;;;;;qCAOqC;AACrC,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,cAAc,GAAG;IAAE,MAAM,EAAE,OAAO,mBAAmB,GAAG,OAAO,oBAAoB,CAAA;CAAE,CAI5F"}

package/dist/sentinel.js

@@ -16,11 +16,43 @@ export function makeTaggedSentinel(engine, source) {
 export function isRefSentinel(v) {
     return isTaggedSentinel(v) && v.engine === "ref";
 }
+/** The CEL engine's name. Beside the other sentinel predicates for the same
+ *  reason they are: a consumer that spells an engine name inline is a second
+ *  place the registry's key is written down. */
+export const CEL_ENGINE = "cel";
 /** Engine names of the two file-embedding tags. Named here beside the other
  *  sentinel predicates so the kernel's resolution pass and the engines
  *  themselves agree on one spelling. */
 export const INCLUDE_TEXT_ENGINE = "include-text";
 export const INCLUDE_BYTES_ENGINE = "include-bytes";
+/**
+ * The dotted chain a value names, or undefined.
+ *
+ * Only a PLAIN CHAIN — `steps.encode.result.output` — in either spelling a
+ * manifest may carry it: a `!cel` sentinel or the `${{ }}` string form. An
+ * expression that COMPUTES rather than names has no schema to read off a context,
+ * so a caller that navigates one gets nothing and reports nothing: silence where
+ * the analyzer knows least is the conservative direction.
+ *
+ * Here rather than in each caller because "is this expression a plain chain" is
+ * one question, and two copies of the answer would eventually disagree about a
+ * shape like `a.b[0]`.
+ */
+export function plainChainOf(value) {
+    const source = isTaggedSentinel(value)
+        ? value.engine === CEL_ENGINE
+            ? value.source
+            : undefined
+        : typeof value === "string"
+            ? /^\s*\$\{\{(.+)\}\}\s*$/.exec(value)?.[1]
+            : undefined;
+    if (typeof source !== "string")
+        return undefined;
+    const trimmed = source.trim();
+    return /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(trimmed)
+        ? trimmed
+        : undefined;
+}
 /** Both file-embedding tag names, for a consumer holding an engine NAME rather
  *  than a value (the analyzer's expression walk reports names). */
 export const INCLUDE_ENGINE_NAMES = new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/templating",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Telo Templating - Engine registry and shared CEL core for Telo manifests.",
   "keywords": [
     "telo",
@@ -44,7 +44,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.72.0"
+    "@telorun/sdk": "0.74.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/builtins.ts

@@ -29,6 +29,20 @@ export function createDefaultRegistry(): TemplatingEngineRegistry {
   return registry;
 }
 
+/**
+ * The type a tag always produces, or undefined when its produced type is a
+ * function of the slot rather than of the tag (`!cel`, `!ref`).
+ *
+ * The single reader of `TemplatingEngine.producedType`, so a consumer asks the
+ * registry what a tag produces instead of recognising tag names — the same seam
+ * `fileClaims` opened for payload membership. Reads the default registry
+ * because a produced type is a property of the engine, not of a host's
+ * configuration, and every host ships the same built-in set.
+ */
+export function producedTypeOf(engineName: string): Record<string, unknown> | undefined {
+  return defaultRegistry().get(engineName)?.producedType?.();
+}
+
 let defaultRegistryCache: TemplatingEngineRegistry | undefined;
 
 /** Memoized singleton: returns the default registry. Hosts that don't need

package/src/cel/analyze.ts

@@ -1,4 +1,5 @@
 import type { ASTNode } from "@marcbachmann/cel-js";
+import { isLiveSlot } from "@telorun/sdk";
 
 /**
  * Extract all member-access chains from a CEL AST.
@@ -291,7 +292,8 @@ function walkNullable(
  * Check whether a member-access chain accesses only fields declared in a JSON Schema.
  * Returns an error string if a field is unknown in a schema that declares explicit
  * properties without `additionalProperties: true`, or if the chain attempts to
- * reach inside an `x-telo-stream: true` property.
+ * reach inside a `live` value type — one whose consumption has effects, so its
+ * contents exist only for a consumer that drains it.
  * Returns null when the chain is valid or the schema is too open to judge.
  */
 export function validateChainAgainstSchema(
@@ -306,12 +308,7 @@ export function validateChainAgainstSchema(
     if (!props) return null;
     if (key in props) {
       const propSchema = props[key];
-      if (
-        propSchema &&
-        typeof propSchema === "object" &&
-        propSchema["x-telo-stream"] === true &&
-        i < chain.length - 1
-      ) {
+      if (isLiveSlot(propSchema) && i < chain.length - 1) {
         const path = chain.slice(0, i + 1).join(".");
         return `'${path}' yields a stream — pipe it through an Encoder or iterate in a JS.Script step (no member access on stream-typed values)`;
       }

package/src/cel/catalog.ts

@@ -170,6 +170,53 @@ const dateInZone = (tz: string): string => {
   return `${p.year}-${p.month}-${p.day}`;
 };
 
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/** Base64 → bytes, written out rather than delegated: `Buffer` is not browser-
+ *  safe and `atob` round-trips through a string, which is the corruption this
+ *  pair exists to avoid. Accepts the URL-safe alphabet and tolerates missing
+ *  padding, both of which appear in real API payloads; a character outside the
+ *  alphabet is a hard error rather than a silently dropped byte. */
+function decodeBase64ToBytes(input: string): Uint8Array {
+  const clean = input.replace(/[\r\n\t ]/g, "").replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+  // A remainder of 1 cannot come from any byte sequence: base64 encodes 3 bytes
+  // as 4 characters, so the valid remainders are 0, 2 and 3. Left to the loop it
+  // would leave 6 bits unwritten and return a SHORT buffer — the silently dropped
+  // byte this function refuses for a bad character.
+  if (clean.length % 4 === 1) {
+    throw new Error("bytesFromBase64: input length is not valid base64");
+  }
+  const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+  let bits = 0;
+  let acc = 0;
+  let written = 0;
+  for (const ch of clean) {
+    const value = BASE64_ALPHABET.indexOf(ch);
+    if (value < 0) throw new Error(`bytesFromBase64: '${ch}' is not a base64 character`);
+    acc = (acc << 6) | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = (acc >> bits) & 0xff;
+    }
+  }
+  return out.subarray(0, written);
+}
+
+function encodeBytesToBase64(input: Uint8Array): string {
+  let out = "";
+  for (let i = 0; i < input.length; i += 3) {
+    const a = input[i]!;
+    const b = i + 1 < input.length ? input[i + 1]! : undefined;
+    const c = i + 2 < input.length ? input[i + 2]! : undefined;
+    out += BASE64_ALPHABET[a >> 2];
+    out += BASE64_ALPHABET[((a & 0x03) << 4) | ((b ?? 0) >> 4)];
+    out += b === undefined ? "=" : BASE64_ALPHABET[((b & 0x0f) << 2) | ((c ?? 0) >> 6)];
+    out += c === undefined ? "=" : BASE64_ALPHABET[c & 0x3f];
+  }
+  return out;
+}
+
 export const CEL_FUNCTIONS: readonly CelFunctionDoc[] = [
   // Collections
   {
@@ -373,6 +420,37 @@ export const CEL_FUNCTIONS: readonly CelFunctionDoc[] = [
     build: () => (s: string, suffix: string) =>
       suffix && s.endsWith(suffix) ? s.slice(0, s.length - suffix.length) : s,
   },
+  // One `slice` over the three sequence types rather than three names: CEL
+  // already treats `size()` that way, and the alternative teaches an author that
+  // slicing bytes is a different operation from slicing a string.
+  //
+  // ONE `dyn` signature rather than a concrete overload per element type. The
+  // concrete set is more precise, but cel-js refuses overloads that overlap, so
+  // it cannot also carry the `dyn` case — and a step result whose producer
+  // declares no output type IS `dyn`, which is the common receiver. With only the
+  // concrete set the checker resolves such a call to whichever overload it tries
+  // first and pins the result to that type, so slicing an untyped byte buffer
+  // came back typed `string`. Precision here would be lost at the CEL boundary
+  // anyway, where type arguments are erased.
+  {
+    name: "slice",
+    signature: "slice(dyn, int, int): dyn",
+    // Not "string": it is the one function over strings, bytes AND lists, and the
+    // category is what groups it in the generated reference — filing it under
+    // strings hides it from the byte and list readers who need it most.
+    category: "collection",
+    summary: "Take the half-open range [start, end) of a string, bytes or list.",
+    deterministic: true,
+    hostBacked: false,
+    // Indices arrive as BigInt (a CEL int is int64), and both `String.slice` and
+    // `TypedArray.subarray` reject one. `subarray` rather than `slice` for bytes:
+    // a view costs no copy, and every consumer treats the result as read-only.
+    build: () => (value: string | Uint8Array | unknown[], start: bigint, end: bigint) => {
+      const from = Number(start);
+      const to = Number(end);
+      return value instanceof Uint8Array ? value.subarray(from, to) : value.slice(from, to);
+    },
+  },
   // Math
   {
     name: "abs",
@@ -488,6 +566,30 @@ export const CEL_FUNCTIONS: readonly CelFunctionDoc[] = [
     hostBacked: true,
     build: (h) => (s: string) => h.base64Decode(s),
   },
+  // Base64 <-> BYTES, as distinct from the two above, which are UTF-8
+  // string<->string and silently corrupt anything that is not text. Those keep
+  // their meaning (changing it would change what shipped manifests mean); these
+  // are the correct path for binary, and the pair a byte-typed slot needs.
+  // Pure-JS on purpose: `Buffer` is what made the string pair host-backed, and
+  // this package has to stay browser-safe.
+  {
+    name: "bytesFromBase64",
+    signature: "bytesFromBase64(string): bytes",
+    category: "encoding",
+    summary: "Decode a base64 string to raw bytes.",
+    deterministic: true,
+    hostBacked: false,
+    build: () => (s: string) => decodeBase64ToBytes(s),
+  },
+  {
+    name: "bytesToBase64",
+    signature: "bytesToBase64(bytes): string",
+    category: "encoding",
+    summary: "Encode raw bytes as a base64 string.",
+    deterministic: true,
+    hostBacked: false,
+    build: () => (b: Uint8Array) => encodeBytesToBase64(b),
+  },
   {
     name: "urlEncode",
     signature: "urlEncode(string): string",

package/src/engine.ts

@@ -143,4 +143,24 @@ export interface TemplatingEngine {
    *  A source the engine considers malformed claims nothing; `analyze` is what
    *  reports why. */
   fileClaims?(source: string): readonly EngineFileClaim[];
+
+  /** The type this tag ALWAYS produces, as a JSON Schema fragment.
+   *
+   *  Declared by the engine, never recognised by a consumer — the `fileClaims`
+   *  precedent applied to the one fact it left behind. Before this, the analyzer
+   *  hardcoded two tag names to hand an `!include-bytes` a byte placeholder and
+   *  an `!include-text` a string one; the only place a tag's produced type was
+   *  written down was in its consumer, so a future tag producing bytes had to be
+   *  added to a set rather than declaring it.
+   *
+   *  Absent for an engine whose produced type is a function of the SLOT rather
+   *  than of the tag — `!cel`, whose type is only derivable from the expression,
+   *  and `!ref`, which is an identity marker. Their values keep taking a
+   *  slot-shaped placeholder.
+   *
+   *  What falls out is the property this preserves exactly: because an embed's
+   *  type is a constant of the tag, a byte embed at a string slot and text at a
+   *  byte slot both fail statically, through the ordinary schema check and with
+   *  no diagnostic code of their own. */
+  producedType?(): Record<string, unknown>;
 }

package/src/engines/include.ts

@@ -122,7 +122,7 @@ export function normalizeIncludePath(source: string): NormalizedIncludePath {
  * `analyze` reports why a path is unusable; `fileClaims` reports the path itself
  * so publish can place the file in a layer without recognising the tag by name.
  */
-function includeEngine(name: string): TemplatingEngine {
+function includeEngine(name: string, produced: Record<string, unknown>): TemplatingEngine {
   return {
     name,
 
@@ -130,6 +130,10 @@ function includeEngine(name: string): TemplatingEngine {
       return makeTaggedSentinel(name, source);
     },
 
+    producedType() {
+      return produced;
+    },
+
     analyze(source) {
       const { diagnostic } = normalizeIncludePath(source);
       return { diagnostics: diagnostic ? [diagnostic] : [], calls: [] };
@@ -146,8 +150,15 @@ function includeEngine(name: string): TemplatingEngine {
 }
 
 /** Embeds a file's contents as a UTF-8 string. */
-export const includeTextEngine: TemplatingEngine = includeEngine(INCLUDE_TEXT_ENGINE);
+export const includeTextEngine: TemplatingEngine = includeEngine(INCLUDE_TEXT_ENGINE, {
+  type: "string",
+});
 
-/** Embeds a file's contents as raw bytes — a `Uint8Array`, the shape every
- *  `x-telo-binary` slot accepts. */
-export const includeBytesEngine: TemplatingEngine = includeEngine(INCLUDE_BYTES_ENGINE);
+/** Embeds a file's contents as raw bytes — the shape every `Telo.Bytes` slot
+ *  accepts. The name is written as a literal rather than imported from the SDK:
+ *  templating is the lower package, and a produced type is a schema fragment,
+ *  which is data. What checks it is the registry the analyzer and the kernel both
+ *  read. */
+export const includeBytesEngine: TemplatingEngine = includeEngine(INCLUDE_BYTES_ENGINE, {
+  "x-telo-type": "Telo.Bytes",
+});

package/src/index.ts

@@ -39,7 +39,12 @@ export { refEngine } from "./engines/ref.js";
 export { sqlEngine, isParameterizedSql, type ParameterizedSql } from "./engines/sql.js";
 
 export { TemplatingEngineRegistry } from "./registry.js";
-export { builtinEngines, createDefaultRegistry, defaultRegistry } from "./builtins.js";
+export {
+  builtinEngines,
+  createDefaultRegistry,
+  defaultRegistry,
+  producedTypeOf,
+} from "./builtins.js";
 export type {
   AnalyzeEnv,
   AnalyzeResult,
@@ -52,6 +57,7 @@ export type {
 } from "./engine.js";
 
 export {
+  CEL_ENGINE,
   INCLUDE_BYTES_ENGINE,
   INCLUDE_ENGINE_NAMES,
   INCLUDE_TEXT_ENGINE,
@@ -59,6 +65,7 @@ export {
   isRefSentinel,
   isTaggedSentinel,
   makeTaggedSentinel,
+  plainChainOf,
   type TaggedSentinel,
 } from "./sentinel.js";
 export { buildCustomTags, defaultCustomTags } from "./yaml-tags.js";
@@ -66,5 +73,4 @@ export {
   MANIFEST_SCHEMA_URI,
   ManifestRootSchema,
   ResourceRefSchema,
-  normalizeRefSlots,
 } from "./manifest-schemas.js";

package/src/manifest-schemas.ts

@@ -60,104 +60,6 @@ export const ResourceRefSchema = {
   ],
 };
 
-const REF_ANNOTATION = "x-telo-ref";
-
-// The legacy base types a reference slot used to pin when references were
-// written as plain strings. Post-migration a reference resolves to an object
-// (the `{kind, name, alias?}` shape, or an unresolved `!ref` sentinel), so a
-// scalar `type` on a ref slot is a stale constraint that would reject the
-// resolved value. Object / array `type`s are left alone — they already admit
-// the reference object (and any inline value a slot like `inputType` accepts).
-const LEGACY_REF_SCALAR_TYPES = new Set(["string", "number", "integer", "boolean"]);
-
-// JSON Schema keywords whose values are themselves subschemas. Split by shape so
-// the ref-slot normalizer recurses only into schema positions — never into
-// data-bearing keywords (`default`, `const`, `enum`, `examples`), where a stray
-// `x-telo-ref` key would be data, not an annotation.
-const SUBSCHEMA_SINGLE = [
-  "additionalProperties",
-  "additionalItems",
-  "contains",
-  "not",
-  "if",
-  "then",
-  "else",
-  "propertyNames",
-  "unevaluatedItems",
-  "unevaluatedProperties",
-] as const;
-const SUBSCHEMA_LIST = ["allOf", "anyOf", "oneOf", "prefixItems"] as const;
-const SUBSCHEMA_MAP = [
-  "properties",
-  "patternProperties",
-  "$defs",
-  "definitions",
-  "dependentSchemas",
-] as const;
-
-/** Deep-clone `schema`, dropping the stale scalar `type` constraint from every
- *  reference-slot node — one carrying an `x-telo-ref` string annotation.
- *
- *  A reference slot's value is always a `!ref` sentinel or its resolved
- *  `{kind, name, alias?}` object (never a bare string, post-migration). Older
- *  published modules still pin `type: "string"` on these slots — the encoding
- *  references took when they were written as plain strings — which now rejects
- *  the resolved object. Removing only the scalar `type` lets the analyzer and
- *  kernel accept references uniformly across module versions during the
- *  migration away from `{kind, name}` / string references, without disturbing
- *  slots that legitimately accept an inline object (e.g. `inputType` /
- *  `outputType`, which take a Telo.Type reference *or* an inline JSON schema).
- *  The `x-telo-ref` constraint itself (which kind the reference must satisfy) is
- *  checked separately by the analyzer's reference walker, which reads the
- *  original schema — not this validation-only copy. */
-export function normalizeRefSlots(schema: unknown): unknown {
-  if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
-    return schema;
-  }
-  const node = schema as Record<string, unknown>;
-  const out: Record<string, unknown> = { ...node };
-  // Reference slot with a stale scalar `type` (legacy string-ref encoding):
-  // drop the constraint so the resolved reference object / sentinel validates.
-  //
-  // A presence test, not a shape test — deliberately, since `templating` sits
-  // BELOW the analyzer in the dependency order and cannot reach the shared
-  // `readRefSlot` accessor. Presence is the only thing this rule needs, and it
-  // is stable across every annotation shape.
-  if (
-    node[REF_ANNOTATION] !== undefined &&
-    typeof node.type === "string" &&
-    LEGACY_REF_SCALAR_TYPES.has(node.type)
-  ) {
-    delete out.type;
-  }
-  for (const key of SUBSCHEMA_SINGLE) {
-    const value = node[key];
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      out[key] = normalizeRefSlots(value);
-    }
-  }
-  for (const key of SUBSCHEMA_LIST) {
-    const value = node[key];
-    if (Array.isArray(value)) out[key] = value.map(normalizeRefSlots);
-  }
-  // `items` is either a single subschema or a tuple of subschemas.
-  if (Array.isArray(node.items)) {
-    out.items = node.items.map(normalizeRefSlots);
-  } else if (node.items && typeof node.items === "object") {
-    out.items = normalizeRefSlots(node.items);
-  }
-  for (const key of SUBSCHEMA_MAP) {
-    const value = node[key];
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const mapped: Record<string, unknown> = {};
-      for (const [name, sub] of Object.entries(value as Record<string, unknown>)) {
-        mapped[name] = normalizeRefSlots(sub);
-      }
-      out[key] = mapped;
-    }
-  }
-  return out;
-}
 
 /** Stable URI under which the shared manifest root schema is registered
  *  with module-side AJV instances. Module YAMLs reach the fragments via

package/src/sentinel.ts

@@ -33,12 +33,45 @@ export function isRefSentinel(v: unknown): v is TaggedSentinel & { engine: "ref"
   return isTaggedSentinel(v) && v.engine === "ref";
 }
 
+/** The CEL engine's name. Beside the other sentinel predicates for the same
+ *  reason they are: a consumer that spells an engine name inline is a second
+ *  place the registry's key is written down. */
+export const CEL_ENGINE = "cel";
+
 /** Engine names of the two file-embedding tags. Named here beside the other
  *  sentinel predicates so the kernel's resolution pass and the engines
  *  themselves agree on one spelling. */
 export const INCLUDE_TEXT_ENGINE = "include-text";
 export const INCLUDE_BYTES_ENGINE = "include-bytes";
 
+/**
+ * The dotted chain a value names, or undefined.
+ *
+ * Only a PLAIN CHAIN — `steps.encode.result.output` — in either spelling a
+ * manifest may carry it: a `!cel` sentinel or the `${{ }}` string form. An
+ * expression that COMPUTES rather than names has no schema to read off a context,
+ * so a caller that navigates one gets nothing and reports nothing: silence where
+ * the analyzer knows least is the conservative direction.
+ *
+ * Here rather than in each caller because "is this expression a plain chain" is
+ * one question, and two copies of the answer would eventually disagree about a
+ * shape like `a.b[0]`.
+ */
+export function plainChainOf(value: unknown): string | undefined {
+  const source = isTaggedSentinel(value)
+    ? value.engine === CEL_ENGINE
+      ? value.source
+      : undefined
+    : typeof value === "string"
+      ? /^\s*\$\{\{(.+)\}\}\s*$/.exec(value)?.[1]
+      : undefined;
+  if (typeof source !== "string") return undefined;
+  const trimmed = source.trim();
+  return /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(trimmed)
+    ? trimmed
+    : undefined;
+}
+
 /** Both file-embedding tag names, for a consumer holding an engine NAME rather
  *  than a value (the analyzer's expression walk reports names). */
 export const INCLUDE_ENGINE_NAMES: ReadonlySet<string> = new Set([