@telorun/templating 0.14.0 → 0.16.0

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,EA8lBlD,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,45 @@ 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.
+    //
+    // OVERLOADED BY PARAMETER TYPE, so a wrong receiver is rejected — `slice(42, 0,
+    // 1)` matches nothing. What cannot ALSO be registered is a `dyn` parameter
+    // variant: cel-js refuses overloads that overlap, and a `dyn` first parameter
+    // overlaps all three. That is why the RETURN is `dyn` rather than the input's
+    // own type. A step result whose producer declares no output type is `dyn`, and
+    // with concrete returns the checker resolves such a call to whichever overload
+    // was registered first and pins the result to it — so slicing an untyped byte
+    // buffer came back typed `string`, and a byte consumer downstream reported a
+    // mismatch against perfectly valid CEL. Precision on the way out would be lost
+    // at the CEL boundary anyway, where type arguments are erased; being wrong
+    // about an untyped receiver would not be.
+    {
+        name: "slice",
+        signature: "slice(dyn, int, int): dyn",
+        register: [
+            "slice(bytes, int, int): dyn",
+            "slice(string, int, int): dyn",
+            "slice(list, 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 +500,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/index.d.ts

@@ -14,5 +14,4 @@ export { builtinEngines, createDefaultRegistry, defaultRegistry, producedTypeOf,
 export type { AnalyzeEnv, AnalyzeResult, CallSite, CompileEnv, DiagnosticFix, EngineDiagnostic, EngineFileClaim, TemplatingEngine, } from "./engine.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, } 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,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"}
+{"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"}

package/dist/index.js

@@ -13,4 +13,3 @@ export { TemplatingEngineRegistry } from "./registry.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, } from "./manifest-schemas.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/templating",
-  "version": "0.14.0",
+  "version": "0.16.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.73.0"
+    "@telorun/sdk": "0.75.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

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,45 @@ 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.
+  //
+  // OVERLOADED BY PARAMETER TYPE, so a wrong receiver is rejected — `slice(42, 0,
+  // 1)` matches nothing. What cannot ALSO be registered is a `dyn` parameter
+  // variant: cel-js refuses overloads that overlap, and a `dyn` first parameter
+  // overlaps all three. That is why the RETURN is `dyn` rather than the input's
+  // own type. A step result whose producer declares no output type is `dyn`, and
+  // with concrete returns the checker resolves such a call to whichever overload
+  // was registered first and pins the result to it — so slicing an untyped byte
+  // buffer came back typed `string`, and a byte consumer downstream reported a
+  // mismatch against perfectly valid CEL. Precision on the way out would be lost
+  // at the CEL boundary anyway, where type arguments are erased; being wrong
+  // about an untyped receiver would not be.
+  {
+    name: "slice",
+    signature: "slice(dyn, int, int): dyn",
+    register: [
+      "slice(bytes, int, int): dyn",
+      "slice(string, int, int): dyn",
+      "slice(list, 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 +574,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/index.ts

@@ -69,8 +69,3 @@ export {
   type TaggedSentinel,
 } from "./sentinel.js";
 export { buildCustomTags, defaultCustomTags } from "./yaml-tags.js";
-export {
-  MANIFEST_SCHEMA_URI,
-  ManifestRootSchema,
-  ResourceRefSchema,
-} from "./manifest-schemas.js";

package/dist/manifest-schemas.d.ts

@@ -1,122 +0,0 @@
-/** Shared JSON-Schema fragments referenced from every module's `telo.yaml`
- *  via `$ref: "telo://manifest#/$defs/<Name>"`. Lives in the templating
- *  package (alongside the YAML tag mechanism) because the analyzer cannot
- *  depend on the kernel — both consume this package, so this is the only
- *  layer where a single source of truth can sit. The kernel re-exports
- *  these symbols from its own `manifest-schemas` surface for downstream
- *  ergonomics. */
-/** Schema fragment for a resource-reference slot. The only form a manifest
- *  author writes is the `!ref <name>` (or `!ref <Alias>.<name>`) YAML tag,
- *  which parses to a `TaggedSentinel` (engine "ref") whose `source` is the
- *  bare resource name. In practice module schemas mark a ref slot with a bare
- *  `x-telo-ref` annotation (plus, where the slot only ever holds a reference,
- *  `type: object` to reject a stray scalar); the analyzer's reference walker
- *  reads `x-telo-ref` to look the name up against that constraint, independent
- *  of this fragment. A slot opts into `$ref:
- *  "telo://manifest#/$defs/ResourceRef"` only when it wants this exact
- *  two-branch shape enforced at the AJV layer too — it is not required, and
- *  slots that also accept an inline value (e.g. `inputType` / `outputType`)
- *  deliberately do not use it (an inline JSON Schema has no `kind`).
- *
- *  Two `anyOf` branches because the value's shape depends on the phase at
- *  which it is validated:
- *
- *   1. The raw `!ref` sentinel — what survives to AJV when a cross-module
- *      reference can't be resolved in standalone single-file analysis (the
- *      imported module isn't loaded). `substituteCelFields` deliberately
- *      keeps the sentinel so this branch matches.
- *   2. A resolved reference object — `{kind, name, alias?}` substituted in
- *      place of a sentinel (or an inline definition `{kind, ...config}`
- *      reached through a local `$ref` that escapes extraction). Both the
- *      kernel and the analyzer validate ref slots *after* sentinel
- *      resolution, so this is the shape AJV usually sees.
- *
- *  The object-form `{kind, name}` reference a user could once type directly
- *  is gone: a plain object at a ref slot is only ever an inline definition
- *  or the resolver's own substitution, never an author-written reference.
- *  That removal is enforced by the analyzer (it rejects an author-written
- *  `{kind, name}` before normalization), not by this schema — branch 2
- *  cannot distinguish an author's `{kind, name}` from the resolver's. */
-export declare const ResourceRefSchema: {
-    title: string;
-    anyOf: ({
-        type: string;
-        required: string[];
-        properties: {
-            __tagged: {
-                const: boolean;
-            };
-            engine: {
-                const: string;
-            };
-            source: {
-                type: string;
-                minLength: number;
-            };
-            kind?: undefined;
-        };
-        additionalProperties: boolean;
-    } | {
-        type: string;
-        required: string[];
-        properties: {
-            kind: {
-                type: string;
-            };
-            __tagged?: undefined;
-            engine?: undefined;
-            source?: undefined;
-        };
-        additionalProperties: boolean;
-    })[];
-};
-/** 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;
- *  the symbol names intentionally omit a host-specific prefix since the
- *  fragments live in `@telorun/templating` (the only layer both kernel
- *  and analyzer depend on). */
-export declare const MANIFEST_SCHEMA_URI = "telo://manifest";
-/** Root schema registered with AJV under `MANIFEST_SCHEMA_URI`. Carries
- *  `$defs` only — it isn't validated against directly. Adding a new
- *  shared fragment means putting it under `$defs` here and `$ref`-ing
- *  it from module schemas. */
-export declare const ManifestRootSchema: {
-    $id: string;
-    $defs: {
-        ResourceRef: {
-            title: string;
-            anyOf: ({
-                type: string;
-                required: string[];
-                properties: {
-                    __tagged: {
-                        const: boolean;
-                    };
-                    engine: {
-                        const: string;
-                    };
-                    source: {
-                        type: string;
-                        minLength: number;
-                    };
-                    kind?: undefined;
-                };
-                additionalProperties: boolean;
-            } | {
-                type: string;
-                required: string[];
-                properties: {
-                    kind: {
-                        type: string;
-                    };
-                    __tagged?: undefined;
-                    engine?: undefined;
-                    source?: undefined;
-                };
-                additionalProperties: boolean;
-            })[];
-        };
-    };
-};
-//# sourceMappingURL=manifest-schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-/** Shared JSON-Schema fragments referenced from every module's `telo.yaml`
- *  via `$ref: "telo://manifest#/$defs/<Name>"`. Lives in the templating
- *  package (alongside the YAML tag mechanism) because the analyzer cannot
- *  depend on the kernel — both consume this package, so this is the only
- *  layer where a single source of truth can sit. The kernel re-exports
- *  these symbols from its own `manifest-schemas` surface for downstream
- *  ergonomics. */
-/** Schema fragment for a resource-reference slot. The only form a manifest
- *  author writes is the `!ref <name>` (or `!ref <Alias>.<name>`) YAML tag,
- *  which parses to a `TaggedSentinel` (engine "ref") whose `source` is the
- *  bare resource name. In practice module schemas mark a ref slot with a bare
- *  `x-telo-ref` annotation (plus, where the slot only ever holds a reference,
- *  `type: object` to reject a stray scalar); the analyzer's reference walker
- *  reads `x-telo-ref` to look the name up against that constraint, independent
- *  of this fragment. A slot opts into `$ref:
- *  "telo://manifest#/$defs/ResourceRef"` only when it wants this exact
- *  two-branch shape enforced at the AJV layer too — it is not required, and
- *  slots that also accept an inline value (e.g. `inputType` / `outputType`)
- *  deliberately do not use it (an inline JSON Schema has no `kind`).
- *
- *  Two `anyOf` branches because the value's shape depends on the phase at
- *  which it is validated:
- *
- *   1. The raw `!ref` sentinel — what survives to AJV when a cross-module
- *      reference can't be resolved in standalone single-file analysis (the
- *      imported module isn't loaded). `substituteCelFields` deliberately
- *      keeps the sentinel so this branch matches.
- *   2. A resolved reference object — `{kind, name, alias?}` substituted in
- *      place of a sentinel (or an inline definition `{kind, ...config}`
- *      reached through a local `$ref` that escapes extraction). Both the
- *      kernel and the analyzer validate ref slots *after* sentinel
- *      resolution, so this is the shape AJV usually sees.
- *
- *  The object-form `{kind, name}` reference a user could once type directly
- *  is gone: a plain object at a ref slot is only ever an inline definition
- *  or the resolver's own substitution, never an author-written reference.
- *  That removal is enforced by the analyzer (it rejects an author-written
- *  `{kind, name}` before normalization), not by this schema — branch 2
- *  cannot distinguish an author's `{kind, name}` from the resolver's. */
-export const ResourceRefSchema = {
-    title: "Resource reference",
-    anyOf: [
-        {
-            type: "object",
-            required: ["__tagged", "engine", "source"],
-            properties: {
-                __tagged: { const: true },
-                engine: { const: "ref" },
-                source: { type: "string", minLength: 1 },
-            },
-            additionalProperties: false,
-        },
-        {
-            type: "object",
-            required: ["kind"],
-            properties: { kind: { type: "string" } },
-            additionalProperties: true,
-        },
-    ],
-};
-/** 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;
- *  the symbol names intentionally omit a host-specific prefix since the
- *  fragments live in `@telorun/templating` (the only layer both kernel
- *  and analyzer depend on). */
-export const MANIFEST_SCHEMA_URI = "telo://manifest";
-/** Root schema registered with AJV under `MANIFEST_SCHEMA_URI`. Carries
- *  `$defs` only — it isn't validated against directly. Adding a new
- *  shared fragment means putting it under `$defs` here and `$ref`-ing
- *  it from module schemas. */
-export const ManifestRootSchema = {
-    $id: MANIFEST_SCHEMA_URI,
-    $defs: {
-        ResourceRef: ResourceRefSchema,
-    },
-};

package/src/manifest-schemas.ts

@@ -1,81 +0,0 @@
-/** Shared JSON-Schema fragments referenced from every module's `telo.yaml`
- *  via `$ref: "telo://manifest#/$defs/<Name>"`. Lives in the templating
- *  package (alongside the YAML tag mechanism) because the analyzer cannot
- *  depend on the kernel — both consume this package, so this is the only
- *  layer where a single source of truth can sit. The kernel re-exports
- *  these symbols from its own `manifest-schemas` surface for downstream
- *  ergonomics. */
-
-/** Schema fragment for a resource-reference slot. The only form a manifest
- *  author writes is the `!ref <name>` (or `!ref <Alias>.<name>`) YAML tag,
- *  which parses to a `TaggedSentinel` (engine "ref") whose `source` is the
- *  bare resource name. In practice module schemas mark a ref slot with a bare
- *  `x-telo-ref` annotation (plus, where the slot only ever holds a reference,
- *  `type: object` to reject a stray scalar); the analyzer's reference walker
- *  reads `x-telo-ref` to look the name up against that constraint, independent
- *  of this fragment. A slot opts into `$ref:
- *  "telo://manifest#/$defs/ResourceRef"` only when it wants this exact
- *  two-branch shape enforced at the AJV layer too — it is not required, and
- *  slots that also accept an inline value (e.g. `inputType` / `outputType`)
- *  deliberately do not use it (an inline JSON Schema has no `kind`).
- *
- *  Two `anyOf` branches because the value's shape depends on the phase at
- *  which it is validated:
- *
- *   1. The raw `!ref` sentinel — what survives to AJV when a cross-module
- *      reference can't be resolved in standalone single-file analysis (the
- *      imported module isn't loaded). `substituteCelFields` deliberately
- *      keeps the sentinel so this branch matches.
- *   2. A resolved reference object — `{kind, name, alias?}` substituted in
- *      place of a sentinel (or an inline definition `{kind, ...config}`
- *      reached through a local `$ref` that escapes extraction). Both the
- *      kernel and the analyzer validate ref slots *after* sentinel
- *      resolution, so this is the shape AJV usually sees.
- *
- *  The object-form `{kind, name}` reference a user could once type directly
- *  is gone: a plain object at a ref slot is only ever an inline definition
- *  or the resolver's own substitution, never an author-written reference.
- *  That removal is enforced by the analyzer (it rejects an author-written
- *  `{kind, name}` before normalization), not by this schema — branch 2
- *  cannot distinguish an author's `{kind, name}` from the resolver's. */
-export const ResourceRefSchema = {
-  title: "Resource reference",
-  anyOf: [
-    {
-      type: "object",
-      required: ["__tagged", "engine", "source"],
-      properties: {
-        __tagged: { const: true },
-        engine: { const: "ref" },
-        source: { type: "string", minLength: 1 },
-      },
-      additionalProperties: false,
-    },
-    {
-      type: "object",
-      required: ["kind"],
-      properties: { kind: { type: "string" } },
-      additionalProperties: true,
-    },
-  ],
-};
-
-
-/** 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;
- *  the symbol names intentionally omit a host-specific prefix since the
- *  fragments live in `@telorun/templating` (the only layer both kernel
- *  and analyzer depend on). */
-export const MANIFEST_SCHEMA_URI = "telo://manifest";
-
-/** Root schema registered with AJV under `MANIFEST_SCHEMA_URI`. Carries
- *  `$defs` only — it isn't validated against directly. Adding a new
- *  shared fragment means putting it under `$defs` here and `$ref`-ing
- *  it from module schemas. */
-export const ManifestRootSchema = {
-  $id: MANIFEST_SCHEMA_URI,
-  $defs: {
-    ResourceRef: ResourceRefSchema,
-  },
-};