@telorun/sdk 0.72.0 → 0.73.0

package/dist/index.d.ts

@@ -34,4 +34,5 @@ export * from "./runtime-event.js";
 export * from "./runtime-resource.js";
 export * from "./stream.js";
 export * from "./types.js";
+export * from "./value-type.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,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -34,3 +34,4 @@ export * from "./runtime-event.js";
 export * from "./runtime-resource.js";
 export * from "./stream.js";
 export * from "./types.js";
+export * from "./value-type.js";

package/dist/resource-context.d.ts

@@ -20,6 +20,12 @@ export interface LoadOptions {
      *  inline imports resolve and execute identically to authored `Telo.Import`
      *  documents. Mirrors the analyzer loader's option of the same name. */
     desugarImports?: boolean;
+    /** When true, legacy manifest spellings are rewritten to the current ones
+     *  before the manifests are returned, so a module published years ago loads
+     *  against today's vocabulary. On for every runtime load; off only for a
+     *  round-trip view that must show the author's own text. Mirrors the analyzer
+     *  loader's option of the same name. */
+    migrate?: boolean;
 }
 export interface DataValidator {
     validate(data: any): void;

package/dist/resource-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource-context.d.ts","sourceRoot":"","sources":["../src/resource-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,eAAe,EACf,SAAS,EACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B;gFAC4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;4EAGwE;IACxE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO;IAIP,QAAQ;CAGT;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC,GAAG;IAAE,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEhG;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;4EAKwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IACzC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD;;iCAE6B;IAC7B,wBAAwB,IAAI,kBAAkB,CAAC;IAC/C;+EAC2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,CAAC,EACR,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,EACxD,IAAI,CAAC,EAAE,aAAa,GACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IACd;kFAC8E;IAC9E,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC3D,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS,CAAC;IACpE;;;mFAG+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,SAAS,EAAE,CAAC;IAChF;;;;sCAIkC;IAClC,WAAW,CAAC,IAAI,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,kBAAkB,CAAA;KAAE,GAAG,aAAa,CAAC;IACzE;;;;;2EAKuE;IACvE,WAAW,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC9C;;;;;kBAKc;IACd,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpF;;;qCAGiC;IACjC,MAAM,CAAC,OAAO,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,GAAG,CAAC,CAAC;IAChB,cAAc,CAAC,OAAO,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,OAAO,EACf,GAAG,CAAC,EAAE,aAAa,GAClB,OAAO,CAAC,GAAG,CAAC,CAAC;IAChB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IACvE,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IACtC,iBAAiB,IAAI,iBAAiB,CAAC;IACvC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,iBAAiB,CAAC;IAChE,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACnD;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D;kFAC8E;IAC9E,eAAe,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtF;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,EACV,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,EAC7C,QAAQ,EAAE,MAAM,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,GACf,CAAC,CAAC;IACL,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC;IAC9C;;;;;yEAKqE;IACrE,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,aAAa,CAAC;IAClD,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/C,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IACzD,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,GAAG,SAAS,CAAC;IACtD,kFAAkF;IAClF,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GAAG,aAAa,CAAC;IACtF,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjG,kBAAkB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI,CAAC;IAC1C;yDACqD;IACrD,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3F;;;;OAIG;IACH,mBAAmB,IAAI,gBAAgB,GAAG,SAAS,CAAC;IACpD;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,MAAM,GAAG,SAAS,CAAC;IAClC;;;;iEAI6D;IAC7D,cAAc,IAAI,MAAM,GAAG,SAAS,CAAC;IACrC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD;wDACoD;IACpD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC5E;;;sBAGkB;IAClB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACxD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CACxC"}
+{"version":3,"file":"resource-context.d.ts","sourceRoot":"","sources":["../src/resource-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,eAAe,EACf,SAAS,EACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B;gFAC4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;4EAGwE;IACxE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;4CAIwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO;IAIP,QAAQ;CAGT;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC,GAAG;IAAE,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEhG;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;4EAKwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IACzC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD;;iCAE6B;IAC7B,wBAAwB,IAAI,kBAAkB,CAAC;IAC/C;+EAC2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,CAAC,EACR,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,EACxD,IAAI,CAAC,EAAE,aAAa,GACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IACd;kFAC8E;IAC9E,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC3D,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS,CAAC;IACpE;;;mFAG+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS,SAAS,EAAE,CAAC;IAChF;;;;sCAIkC;IAClC,WAAW,CAAC,IAAI,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,kBAAkB,CAAA;KAAE,GAAG,aAAa,CAAC;IACzE;;;;;2EAKuE;IACvE,WAAW,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC9C;;;;;kBAKc;IACd,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpF;;;qCAGiC;IACjC,MAAM,CAAC,OAAO,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,GAAG,CAAC,CAAC;IAChB,cAAc,CAAC,OAAO,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,OAAO,EACf,GAAG,CAAC,EAAE,aAAa,GAClB,OAAO,CAAC,GAAG,CAAC,CAAC;IAChB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IACvE,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IACtC,iBAAiB,IAAI,iBAAiB,CAAC;IACvC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,iBAAiB,CAAC;IAChE,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACnD;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D;kFAC8E;IAC9E,eAAe,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtF;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,EACV,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,EAC7C,QAAQ,EAAE,MAAM,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,GACf,CAAC,CAAC;IACL,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC;IAC9C;;;;;yEAKqE;IACrE,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,aAAa,CAAC;IAClD,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/C,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IACzD,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,GAAG,SAAS,CAAC;IACtD,kFAAkF;IAClF,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GAAG,aAAa,CAAC;IACtF,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjG,kBAAkB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI,CAAC;IAC1C;yDACqD;IACrD,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3F;;;;OAIG;IACH,mBAAmB,IAAI,gBAAgB,GAAG,SAAS,CAAC;IACpD;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,MAAM,GAAG,SAAS,CAAC;IAClC;;;;iEAI6D;IAC7D,cAAc,IAAI,MAAM,GAAG,SAAS,CAAC;IACrC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD;wDACoD;IACpD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC5E;;;sBAGkB;IAClB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACxD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CACxC"}

package/dist/type-schema-ref.d.ts

@@ -28,6 +28,17 @@ export declare const TELO_TYPE_SCHEME = "telo://";
  * and the loader rewrites it to this. Published manifests are unaffected.
  */
 export declare function canonicalTypeSchemaId(moduleName: string, typeName: string): string;
+/** The inverse of {@link canonicalTypeSchemaId}. Returns null for any other
+ *  string, including the authoring authority form and fragment-bearing built-ins.
+ *
+ *  A resolver reads a named shape through this rather than by bare name: the
+ *  canonical id carries the OWNING MODULE, so two libraries declaring a shape of
+ *  the same name stay distinct. Resolving by name alone was how an alias got
+ *  silently dropped. */
+export declare function parseCanonicalTypeSchemaId(ref: unknown): {
+    moduleName: string;
+    typeName: string;
+} | null;
 /**
  * Resolve `extends` into a single self-contained object schema by deep-merging an
  * ordered list of already-resolved schemas (parents first, the own schema last):

package/dist/type-schema-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-schema-ref.d.ts","sourceRoot":"","sources":["../src/type-schema-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElF;AAiBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GACjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCzB;AAED,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAKjE"}
+{"version":3,"file":"type-schema-ref.d.ts","sourceRoot":"","sources":["../src/type-schema-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElF;AAED;;;;;;wBAMwB;AACxB,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,GACX;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKjD;AAiBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GACjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCzB;AAED,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAKjE"}

package/dist/type-schema-ref.js

@@ -30,6 +30,21 @@ export const TELO_TYPE_SCHEME = "telo://";
 export function canonicalTypeSchemaId(moduleName, typeName) {
     return `telo:${moduleName}/${typeName}`;
 }
+/** The inverse of {@link canonicalTypeSchemaId}. Returns null for any other
+ *  string, including the authoring authority form and fragment-bearing built-ins.
+ *
+ *  A resolver reads a named shape through this rather than by bare name: the
+ *  canonical id carries the OWNING MODULE, so two libraries declaring a shape of
+ *  the same name stay distinct. Resolving by name alone was how an alias got
+ *  silently dropped. */
+export function parseCanonicalTypeSchemaId(ref) {
+    if (typeof ref !== "string")
+        return null;
+    const match = /^telo:([^/#:]+)\/([^#/]+)$/.exec(ref);
+    if (!match)
+        return null;
+    return { moduleName: match[1], typeName: match[2] };
+}
 /** Top-level keywords merged structurally rather than copied wholesale when
  *  resolving `extends`: object shape (`properties` / `required` /
  *  `additionalProperties`) is deep-merged, and composition keywords (`allOf` /

package/dist/value-type.d.ts

@@ -0,0 +1,149 @@
+/**
+ * `x-telo-type` — the one annotation that says what the value at a slot IS,
+ * beyond what JSON Schema's `type` vocabulary can express, and the single
+ * accessor every surface reads it through (the `ref-slot.ts` precedent).
+ *
+ * It replaced three keywords that answered one question differently: a nominal
+ * brand from a closed kernel table (`x-telo-type: TcpPort`), raw bytes
+ * (`x-telo-binary: true`), and a live handle (`x-telo-stream: true`). They
+ * differed in POSTURE toward the JSON Schema layer — refine, replace, exempt —
+ * not in kind, so each spelled as its own keyword meant a fourth cost eleven
+ * files across four packages, and left three defects: a typo'd brand degraded
+ * silently, bytes had no CEL identity, and a module string-matched the keyword
+ * because there was nothing on its surface to read.
+ *
+ * THE VOCABULARY IS DATA; THE BINDING TO A LANGUAGE IS NOT. Entries live at
+ * `sdk/value-types/*.json` (see the README there) and are copied in by the SDK's
+ * `prepare`. Every runtime that hosts Telo reads the same files — the Rust half
+ * types an `!include-bytes` slot from them in a kernel with no CEL engine — so
+ * an entry declares a symbolic `binding`, never a constructor name, and each
+ * runtime carries its own table mapping that key to its own identity.
+ *
+ * THE REGISTRY IS IN THE SDK because it is dependency-free and Node-built-in-free
+ * (so a browser-side analyzer can read it), because `Stream` already lives here,
+ * and because it is the only placement a module controller can reach: a module
+ * may import `@telorun/sdk` and nothing else.
+ */
+export declare const X_TELO_TYPE = "x-telo-type";
+/** How a value is represented, which is the one thing an entry declares.
+ *
+ *  - `json`     — an ordinary value its declared schema already validates. The
+ *                 name adds nominal identity for static wiring, nothing else.
+ *  - `instance` — not JSON at all. This is what makes a value unauthorable: no
+ *                 YAML literal is ever a byte buffer or a stream handle. */
+export type ValueTypeRepresentation = "json" | "instance";
+/** A named type parameter. Every parameter is optional and defaults to *any*,
+ *  so an unparameterized use of a generic type stays legal. Named rather than
+ *  positional so a diagnostic can say `of` instead of "argument 0", and so a
+ *  second parameter can be added without a migration. */
+export interface ValueTypeParameter {
+    readonly name: string;
+    readonly description?: string;
+}
+/** One value type, exactly as its entry file declares it. */
+export interface ValueTypeEntry {
+    /** `Telo.`-qualified. The closed vocabulary an author writes at the name slot. */
+    readonly name: string;
+    readonly representation: ValueTypeRepresentation;
+    /** `json` only — the JSON Schema type this name refines. */
+    readonly base?: string;
+    /** `instance` only — the symbolic key a runtime's binding table maps. */
+    readonly binding?: string;
+    /** An instance whose consumption has effects, so it is exempt from validation
+     *  rather than asserted. Exemption is from VALIDATION, never from TYPING. */
+    readonly live: boolean;
+    readonly parameters: readonly ValueTypeParameter[];
+    readonly description: string;
+}
+/** What one runtime can say about an `instance` representation. Node's identity
+ *  is a constructor (`instanceof` is the assertion) plus the CEL type an
+ *  expression at such a slot carries. */
+export interface ValueTypeBinding {
+    /** The constructor an assertion tests against. `Buffer` extends `Uint8Array`,
+     *  so a Node buffer satisfies `bytes` without a second rule. */
+    readonly constructor: Function;
+    /** The CEL type a value of this representation carries. */
+    readonly celType: string;
+    /** A stand-in the analyzer substitutes for a CEL leaf at such a slot, so the
+     *  static check and the runtime assertion agree BY CONSTRUCTION rather than by
+     *  two rules kept in step. Absent for a `live` type, whose value is never
+     *  validated and so needs nothing to satisfy. */
+    readonly placeholder?: () => unknown;
+}
+/**
+ * Node's binding table — the ONLY per-language artifact in the whole mechanism.
+ *
+ * Keyed by an entry's symbolic `binding`, never by its name, so a runtime that
+ * represents two entries the same way says so once and a rename of a type does
+ * not touch any table.
+ */
+export declare const VALUE_TYPE_BINDINGS: Readonly<Record<string, ValueTypeBinding>>;
+/**
+ * Read one entry file's parsed data.
+ *
+ * Reading is STRICT and the vocabulary is closed at every level. A malformed or
+ * typo'd entry is an authoring mistake whose only other outcome is a type that
+ * quietly is not in the vocabulary — which reads to an author as "unknown name",
+ * pointing at their manifest instead of at the entry.
+ */
+export declare function parseValueTypeEntry(file: string, data: unknown): ValueTypeEntry;
+/** Every declared value type, keyed by its `Telo.`-qualified name. */
+export declare const VALUE_TYPES: ReadonlyMap<string, ValueTypeEntry>;
+/** The declared names, in entry order — what `telo cel types` and the generated
+ *  docs section enumerate. */
+export declare function valueTypeNames(): string[];
+/** A read `x-telo-type` annotation: the type it names plus its type arguments. */
+export interface ValueTypeSlot {
+    /** The name exactly as written, which is also the canonical one — the
+     *  vocabulary is closed, so there is nothing to resolve. */
+    readonly name: string;
+    /** The registry entry, or undefined when the name is not a declared type.
+     *  Present separately from `name` so a diagnostic can report the name the
+     *  author wrote rather than swallowing an unknown one. */
+    readonly entry: ValueTypeEntry | undefined;
+    /** Type arguments by parameter name. Each value is a schema node. */
+    readonly args: Readonly<Record<string, unknown>>;
+}
+/**
+ * Read the annotation off a schema node.
+ *
+ * Two spellings, one meaning: a bare name (`x-telo-type: Telo.Bytes`) and the
+ * object form carrying arguments (`{ name: Telo.Stream, of: … }`). Returns
+ * undefined when the node carries no annotation at all — an unknown NAME still
+ * returns a slot, with `entry` undefined, because silently reading it as "no
+ * value type" is the degrade this annotation replaced.
+ */
+export declare function readValueTypeSlot(schema: unknown): ValueTypeSlot | undefined;
+/** The entry a schema node declares, or undefined. The common read. */
+export declare function valueTypeOf(schema: unknown): ValueTypeEntry | undefined;
+/** True when this node declares a value type at all (known or not). */
+export declare function isValueTypeSlot(schema: unknown): boolean;
+/** True when the node declares a `live` type, so its value is exempt from
+ *  validation — never traversed, never asserted. Typing is unaffected. */
+export declare function isLiveSlot(schema: unknown): boolean;
+/** True when the node declares a type represented as a runtime instance —
+ *  the values no manifest literal can ever be. */
+export declare function isInstanceSlot(schema: unknown): boolean;
+/** The binding row for a schema node's declared type, or undefined when it
+ *  declares none / declares a `json` one. */
+export declare function bindingOf(schema: unknown): ValueTypeBinding | undefined;
+/** The stand-in for a CEL leaf at this slot, or undefined when the slot declares
+ *  no instance type (ordinary JSON, so the schema's own shape decides) or a live
+ *  one (nothing validates it, so nothing has to satisfy anything). */
+export declare function valueTypePlaceholder(schema: unknown): unknown | undefined;
+/**
+ * The CEL type a value at this slot carries.
+ *
+ * A `json` representation carries its own NAME as a nominal brand — which is the
+ * whole point of one, since a `Telo.TcpPort` and a `Telo.UdpPort` are structurally
+ * identical. An `instance` carries whatever its binding says.
+ */
+export declare function celTypeOfValueType(entry: ValueTypeEntry): string;
+/** The CEL type a brand degrades to where the consuming slot declares none —
+ *  gradual typing, so a `Telo.TcpPort` flows freely into a plain integer field.
+ *  Undefined for an `instance`, which has no base to fall back to. */
+export declare function celBaseOfValueType(entry: ValueTypeEntry): string | undefined;
+/** Every `json` representation's CEL brand → the base type it refines. The
+ *  gradual-typing table, derived rather than hand-written. */
+export declare function valueBrandBases(): Record<string, string>;
+//# sourceMappingURL=value-type.d.ts.map

package/dist/value-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-type.d.ts","sourceRoot":"","sources":["../src/value-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAKH,eAAO,MAAM,WAAW,gBAAgB,CAAC;AAEzC;;;;;4EAK4E;AAC5E,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D;;;yDAGyD;AACzD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,uBAAuB,CAAC;IACjD,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;iFAC6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;yCAEyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B;oEACgE;IAChE,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;qDAGiD;IACjD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;CACtC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAG1E,CAAC;AA+DF;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,cAAc,CA2D/E;AAqCD,sEAAsE;AACtE,eAAO,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAmB,CAAC;AAEhF;8BAC8B;AAC9B,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC;AAED,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B;gEAC4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;8DAE0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAAC;IAC3C,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAClD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAuB5E;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAExD;AAED;0EAC0E;AAC1E,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAEnD;AAED;kDACkD;AAClD,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAEvD;AAED;6CAC6C;AAC7C,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAGvE;AAED;;sEAEsE;AACtE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAIhE;AAED;;sEAEsE;AACtE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAE5E;AAED;8DAC8D;AAC9D,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOxD"}

package/dist/value-type.js

@@ -0,0 +1,286 @@
+/**
+ * `x-telo-type` — the one annotation that says what the value at a slot IS,
+ * beyond what JSON Schema's `type` vocabulary can express, and the single
+ * accessor every surface reads it through (the `ref-slot.ts` precedent).
+ *
+ * It replaced three keywords that answered one question differently: a nominal
+ * brand from a closed kernel table (`x-telo-type: TcpPort`), raw bytes
+ * (`x-telo-binary: true`), and a live handle (`x-telo-stream: true`). They
+ * differed in POSTURE toward the JSON Schema layer — refine, replace, exempt —
+ * not in kind, so each spelled as its own keyword meant a fourth cost eleven
+ * files across four packages, and left three defects: a typo'd brand degraded
+ * silently, bytes had no CEL identity, and a module string-matched the keyword
+ * because there was nothing on its surface to read.
+ *
+ * THE VOCABULARY IS DATA; THE BINDING TO A LANGUAGE IS NOT. Entries live at
+ * `sdk/value-types/*.json` (see the README there) and are copied in by the SDK's
+ * `prepare`. Every runtime that hosts Telo reads the same files — the Rust half
+ * types an `!include-bytes` slot from them in a kernel with no CEL engine — so
+ * an entry declares a symbolic `binding`, never a constructor name, and each
+ * runtime carries its own table mapping that key to its own identity.
+ *
+ * THE REGISTRY IS IN THE SDK because it is dependency-free and Node-built-in-free
+ * (so a browser-side analyzer can read it), because `Stream` already lives here,
+ * and because it is the only placement a module controller can reach: a module
+ * may import `@telorun/sdk` and nothing else.
+ */
+import { Stream } from "./stream.js";
+import { VALUE_TYPE_ENTRY_FILES } from "./value-types/entries/index.js";
+export const X_TELO_TYPE = "x-telo-type";
+/**
+ * Node's binding table — the ONLY per-language artifact in the whole mechanism.
+ *
+ * Keyed by an entry's symbolic `binding`, never by its name, so a runtime that
+ * represents two entries the same way says so once and a rename of a type does
+ * not touch any table.
+ */
+export const VALUE_TYPE_BINDINGS = {
+    bytes: { constructor: Uint8Array, celType: "bytes", placeholder: () => new Uint8Array() },
+    stream: { constructor: Stream, celType: "Stream" },
+};
+/** The CEL type a `json` representation's declared base carries. A brand's own
+ *  name is the CEL type; this is what it degrades to when the consuming slot
+ *  declares no brand of its own (gradual typing). */
+const CEL_TYPE_FOR_BASE = {
+    integer: "int",
+    number: "double",
+    string: "string",
+    boolean: "bool",
+    array: "list",
+    object: "map",
+};
+class ValueTypeEntryError extends Error {
+    constructor(file, detail) {
+        super(`Invalid value-type entry '${file}': ${detail}`);
+        this.name = "ValueTypeEntryError";
+    }
+}
+const ENTRY_KEYS = [
+    "name",
+    "representation",
+    "base",
+    "binding",
+    "live",
+    "parameters",
+    "description",
+    "$comment",
+];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(file, node, key) {
+    const value = node[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ValueTypeEntryError(file, `'${key}' must be a non-empty string`);
+    }
+    return value;
+}
+function readParameters(file, raw) {
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw))
+        throw new ValueTypeEntryError(file, "'parameters' must be a sequence");
+    return raw.map((entry, i) => {
+        if (!isPlainObject(entry)) {
+            throw new ValueTypeEntryError(file, `parameters[${i}] must be a mapping`);
+        }
+        for (const key of Object.keys(entry)) {
+            if (key !== "name" && key !== "description") {
+                throw new ValueTypeEntryError(file, `parameters[${i}] has no key '${key}'`);
+            }
+        }
+        const name = requireString(file, entry, "name");
+        return entry.description === undefined
+            ? { name }
+            : { name, description: requireString(file, entry, "description") };
+    });
+}
+/**
+ * Read one entry file's parsed data.
+ *
+ * Reading is STRICT and the vocabulary is closed at every level. A malformed or
+ * typo'd entry is an authoring mistake whose only other outcome is a type that
+ * quietly is not in the vocabulary — which reads to an author as "unknown name",
+ * pointing at their manifest instead of at the entry.
+ */
+export function parseValueTypeEntry(file, data) {
+    if (!isPlainObject(data))
+        throw new ValueTypeEntryError(file, "an entry must be a mapping");
+    for (const key of Object.keys(data)) {
+        if (!ENTRY_KEYS.includes(key)) {
+            throw new ValueTypeEntryError(file, `an entry has no key '${key}'. Known keys: ${ENTRY_KEYS.join(", ")}.`);
+        }
+    }
+    const name = requireString(file, data, "name");
+    if (!name.startsWith("Telo.")) {
+        throw new ValueTypeEntryError(file, `'name' must be Telo.-qualified — a representation is kernel-owned and cannot be module-defined`);
+    }
+    const representation = requireString(file, data, "representation");
+    if (representation !== "json" && representation !== "instance") {
+        throw new ValueTypeEntryError(file, `'representation' must be 'json' or 'instance'`);
+    }
+    if (data.live !== undefined && typeof data.live !== "boolean") {
+        throw new ValueTypeEntryError(file, "'live' must be a boolean when present");
+    }
+    // The two representations take disjoint parameters, and mixing them is a
+    // statement with no meaning: a `json` value has no constructor to assert, and
+    // an `instance` has no JSON base to refine.
+    if (representation === "json") {
+        if (data.binding !== undefined) {
+            throw new ValueTypeEntryError(file, "a 'json' representation takes no 'binding'");
+        }
+        const base = requireString(file, data, "base");
+        if (!(base in CEL_TYPE_FOR_BASE)) {
+            throw new ValueTypeEntryError(file, `'base' '${base}' is not a JSON Schema type (${Object.keys(CEL_TYPE_FOR_BASE).join(", ")})`);
+        }
+        if (data.live === true) {
+            throw new ValueTypeEntryError(file, "a 'json' representation cannot be 'live' — it is data");
+        }
+    }
+    else {
+        if (data.base !== undefined) {
+            throw new ValueTypeEntryError(file, "an 'instance' representation takes no 'base'");
+        }
+        requireString(file, data, "binding");
+    }
+    const entry = {
+        name,
+        representation,
+        ...(representation === "json" ? { base: data.base } : { binding: data.binding }),
+        live: data.live === true,
+        parameters: readParameters(file, data.parameters),
+        description: requireString(file, data, "description"),
+    };
+    return entry;
+}
+function buildRegistry() {
+    const registry = new Map();
+    for (const [file, data] of VALUE_TYPE_ENTRY_FILES) {
+        const entry = parseValueTypeEntry(file, data);
+        if (registry.has(entry.name)) {
+            throw new ValueTypeEntryError(file, `'${entry.name}' is already declared by another entry`);
+        }
+        // A binding with no row in THIS host's table is a hard error, never a
+        // skipped assertion: a type that cannot be asserted would silently exempt
+        // every slot declaring it, converting a contract into a hole. The same class
+        // of failure as an unrecognized `use` token degrading to the legacy reading.
+        if (entry.binding !== undefined && !(entry.binding in VALUE_TYPE_BINDINGS)) {
+            throw new ValueTypeEntryError(file, `binding '${entry.binding}' has no row in this runtime's table — a value type ` +
+                `whose assertion cannot be produced would silently exempt every slot that declares it`);
+        }
+        registry.set(entry.name, entry);
+    }
+    // Defence in depth against the packaging mistake, because the failure it
+    // produces is indistinguishable from an author's typo: every `x-telo-type`
+    // becomes an unknown name, reported against manifests that are correct. The
+    // build script refuses a missing source directory; this refuses the state that
+    // would reach a user if some other path ever produced it.
+    if (registry.size === 0) {
+        throw new Error("The value-type vocabulary is empty. `sdk/value-types/*.json` did not reach this " +
+            "build — check the file allowlist of whatever packaged it. Continuing would report " +
+            "every declared value type as an unknown name.");
+    }
+    return registry;
+}
+/** Every declared value type, keyed by its `Telo.`-qualified name. */
+export const VALUE_TYPES = buildRegistry();
+/** The declared names, in entry order — what `telo cel types` and the generated
+ *  docs section enumerate. */
+export function valueTypeNames() {
+    return [...VALUE_TYPES.keys()];
+}
+/**
+ * Read the annotation off a schema node.
+ *
+ * Two spellings, one meaning: a bare name (`x-telo-type: Telo.Bytes`) and the
+ * object form carrying arguments (`{ name: Telo.Stream, of: … }`). Returns
+ * undefined when the node carries no annotation at all — an unknown NAME still
+ * returns a slot, with `entry` undefined, because silently reading it as "no
+ * value type" is the degrade this annotation replaced.
+ */
+export function readValueTypeSlot(schema) {
+    if (!isPlainObject(schema))
+        return undefined;
+    const raw = schema[X_TELO_TYPE];
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw === "string") {
+        return { name: raw, entry: VALUE_TYPES.get(raw), args: {} };
+    }
+    if (isPlainObject(raw)) {
+        const name = typeof raw.name === "string" ? raw.name : "";
+        const args = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (key === "name")
+                continue;
+            // A bare NAME as an argument is sugar for a schema node carrying only that
+            // annotation, so `of: Telo.Bytes` and `of: { x-telo-type: Telo.Bytes }`
+            // are one thing. Normalized HERE, in the single reader, so no consumer
+            // re-derives it — a comparator that saw the string form would compare a
+            // string against a schema and quietly conclude nothing.
+            args[key] = typeof value === "string" ? { [X_TELO_TYPE]: value } : value;
+        }
+        return { name, entry: VALUE_TYPES.get(name), args };
+    }
+    return { name: "", entry: undefined, args: {} };
+}
+/** The entry a schema node declares, or undefined. The common read. */
+export function valueTypeOf(schema) {
+    return readValueTypeSlot(schema)?.entry;
+}
+/** True when this node declares a value type at all (known or not). */
+export function isValueTypeSlot(schema) {
+    return readValueTypeSlot(schema) !== undefined;
+}
+/** True when the node declares a `live` type, so its value is exempt from
+ *  validation — never traversed, never asserted. Typing is unaffected. */
+export function isLiveSlot(schema) {
+    return valueTypeOf(schema)?.live === true;
+}
+/** True when the node declares a type represented as a runtime instance —
+ *  the values no manifest literal can ever be. */
+export function isInstanceSlot(schema) {
+    return valueTypeOf(schema)?.representation === "instance";
+}
+/** The binding row for a schema node's declared type, or undefined when it
+ *  declares none / declares a `json` one. */
+export function bindingOf(schema) {
+    const binding = valueTypeOf(schema)?.binding;
+    return binding === undefined ? undefined : VALUE_TYPE_BINDINGS[binding];
+}
+/** The stand-in for a CEL leaf at this slot, or undefined when the slot declares
+ *  no instance type (ordinary JSON, so the schema's own shape decides) or a live
+ *  one (nothing validates it, so nothing has to satisfy anything). */
+export function valueTypePlaceholder(schema) {
+    return bindingOf(schema)?.placeholder?.();
+}
+/**
+ * The CEL type a value at this slot carries.
+ *
+ * A `json` representation carries its own NAME as a nominal brand — which is the
+ * whole point of one, since a `Telo.TcpPort` and a `Telo.UdpPort` are structurally
+ * identical. An `instance` carries whatever its binding says.
+ */
+export function celTypeOfValueType(entry) {
+    if (entry.representation === "json")
+        return entry.name;
+    const binding = VALUE_TYPE_BINDINGS[entry.binding];
+    return binding.celType;
+}
+/** The CEL type a brand degrades to where the consuming slot declares none —
+ *  gradual typing, so a `Telo.TcpPort` flows freely into a plain integer field.
+ *  Undefined for an `instance`, which has no base to fall back to. */
+export function celBaseOfValueType(entry) {
+    return entry.representation === "json" ? CEL_TYPE_FOR_BASE[entry.base] : undefined;
+}
+/** Every `json` representation's CEL brand → the base type it refines. The
+ *  gradual-typing table, derived rather than hand-written. */
+export function valueBrandBases() {
+    const out = {};
+    for (const entry of VALUE_TYPES.values()) {
+        const base = celBaseOfValueType(entry);
+        if (base !== undefined)
+            out[entry.name] = base;
+    }
+    return out;
+}

package/dist/value-types/entries/index.d.ts

@@ -0,0 +1,3 @@
+/** Every value-type entry file, in the order the registry reads them. */
+export declare const VALUE_TYPE_ENTRY_FILES: ReadonlyArray<readonly [file: string, data: unknown]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/value-types/entries/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/value-types/entries/index.ts"],"names":[],"mappings":"AAOA,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAKxF,CAAC"}

package/dist/value-types/entries/index.js

@@ -0,0 +1,13 @@
+// GENERATED by scripts/copy-value-type-entries.mjs — do not edit, and do not commit.
+// Source: sdk/value-types/*.json (lexically ordered).
+import e0 from "./telo-bytes.json" with { type: "json" };
+import e1 from "./telo-stream.json" with { type: "json" };
+import e2 from "./telo-tcp-port.json" with { type: "json" };
+import e3 from "./telo-udp-port.json" with { type: "json" };
+/** Every value-type entry file, in the order the registry reads them. */
+export const VALUE_TYPE_ENTRY_FILES = [
+    ["telo-bytes.json", e0],
+    ["telo-stream.json", e1],
+    ["telo-tcp-port.json", e2],
+    ["telo-udp-port.json", e3],
+];

package/dist/value-types/entries/telo-bytes.json

@@ -0,0 +1,7 @@
+{
+    "$comment": "Bytes are not expressible in JSON Schema's type vocabulary. `type: object` is satisfied by every object, so a mistyped literal reached the controller instead of failing check; `type: binary` is not an option, since a validator refuses to COMPILE an unknown type and a published telo.yaml would stop being JSON Schema for the hub, the editor and every third-party reader. Declaring the representation instead is what makes the check fall out: no YAML literal is ever a byte buffer, so a literal at a byte slot is rejected statically and a value arriving by reference passes.",
+    "name": "Telo.Bytes",
+    "representation": "instance",
+    "binding": "bytes",
+    "description": "Raw bytes. Never authorable inline — a byte slot is filled by reference (an `!include-bytes` embed, a resource output, a CEL expression), and the runtime asserts the value really is a byte buffer."
+}

package/dist/value-types/entries/telo-stream.json

@@ -0,0 +1,14 @@
+{
+    "$comment": "`live` is what separates a stream from bytes: consuming it has effects, so it is EXEMPT from validation rather than asserted — iterating a stream to check its elements is precisely what the exemption forbids. The exemption is from VALIDATION, never from TYPING: `of` still travels through every schema-typing walk, because that is where the argument check reads it.",
+    "name": "Telo.Stream",
+    "representation": "instance",
+    "binding": "stream",
+    "live": true,
+    "parameters": [
+        {
+            "name": "of",
+            "description": "The element the stream yields. Any schema node — an inline shape, a value type, a `!ref` to a named shape, or another parameterized type. Omitted means any element."
+        }
+    ],
+    "description": "A live handle over a sequence of values, consumed by reading. Its elements are never buffered or validated, and member access past it is rejected — a consumer iterates it instead."
+}

package/dist/value-types/entries/telo-tcp-port.json

@@ -0,0 +1,7 @@
+{
+    "$comment": "A `json` representation adds nominal identity to a value the declared schema already validates. A TcpPort and a UdpPort are both integers, so nothing structural tells them apart — the name is the whole difference, and it is what makes wiring one into the other's slot a static error.",
+    "name": "Telo.TcpPort",
+    "representation": "json",
+    "base": "integer",
+    "description": "A TCP port number. Distinct from a UDP port even though both are integers, so wiring one into the other's slot is a static error."
+}

package/dist/value-types/entries/telo-udp-port.json

@@ -0,0 +1,6 @@
+{
+    "name": "Telo.UdpPort",
+    "representation": "json",
+    "base": "integer",
+    "description": "A UDP port number. Distinct from a TCP port even though both are integers, so wiring one into the other's slot is a static error."
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/sdk",
-  "version": "0.72.0",
+  "version": "0.73.0",
   "description": "Telo SDK - Public API for Telo module authors.",
   "keywords": [
     "telo",

package/src/index.ts

@@ -34,4 +34,5 @@ export * from "./runtime-event.js";
 export * from "./runtime-resource.js";
 export * from "./stream.js";
 export * from "./types.js";
+export * from "./value-type.js";
 

package/src/resource-context.ts

@@ -27,6 +27,12 @@ export interface LoadOptions {
    *  inline imports resolve and execute identically to authored `Telo.Import`
    *  documents. Mirrors the analyzer loader's option of the same name. */
   desugarImports?: boolean;
+  /** When true, legacy manifest spellings are rewritten to the current ones
+   *  before the manifests are returned, so a module published years ago loads
+   *  against today's vocabulary. On for every runtime load; off only for a
+   *  round-trip view that must show the author's own text. Mirrors the analyzer
+   *  loader's option of the same name. */
+  migrate?: boolean;
 }
 
 export interface DataValidator {

package/src/type-schema-ref.ts

@@ -33,6 +33,22 @@ export function canonicalTypeSchemaId(moduleName: string, typeName: string): str
   return `telo:${moduleName}/${typeName}`;
 }
 
+/** The inverse of {@link canonicalTypeSchemaId}. Returns null for any other
+ *  string, including the authoring authority form and fragment-bearing built-ins.
+ *
+ *  A resolver reads a named shape through this rather than by bare name: the
+ *  canonical id carries the OWNING MODULE, so two libraries declaring a shape of
+ *  the same name stay distinct. Resolving by name alone was how an alias got
+ *  silently dropped. */
+export function parseCanonicalTypeSchemaId(
+  ref: unknown,
+): { moduleName: string; typeName: string } | null {
+  if (typeof ref !== "string") return null;
+  const match = /^telo:([^/#:]+)\/([^#/]+)$/.exec(ref);
+  if (!match) return null;
+  return { moduleName: match[1]!, typeName: match[2]! };
+}
+
 /** Top-level keywords merged structurally rather than copied wholesale when
  *  resolving `extends`: object shape (`properties` / `required` /
  *  `additionalProperties`) is deep-merged, and composition keywords (`allOf` /

package/src/value-type.ts

@@ -0,0 +1,380 @@
+/**
+ * `x-telo-type` — the one annotation that says what the value at a slot IS,
+ * beyond what JSON Schema's `type` vocabulary can express, and the single
+ * accessor every surface reads it through (the `ref-slot.ts` precedent).
+ *
+ * It replaced three keywords that answered one question differently: a nominal
+ * brand from a closed kernel table (`x-telo-type: TcpPort`), raw bytes
+ * (`x-telo-binary: true`), and a live handle (`x-telo-stream: true`). They
+ * differed in POSTURE toward the JSON Schema layer — refine, replace, exempt —
+ * not in kind, so each spelled as its own keyword meant a fourth cost eleven
+ * files across four packages, and left three defects: a typo'd brand degraded
+ * silently, bytes had no CEL identity, and a module string-matched the keyword
+ * because there was nothing on its surface to read.
+ *
+ * THE VOCABULARY IS DATA; THE BINDING TO A LANGUAGE IS NOT. Entries live at
+ * `sdk/value-types/*.json` (see the README there) and are copied in by the SDK's
+ * `prepare`. Every runtime that hosts Telo reads the same files — the Rust half
+ * types an `!include-bytes` slot from them in a kernel with no CEL engine — so
+ * an entry declares a symbolic `binding`, never a constructor name, and each
+ * runtime carries its own table mapping that key to its own identity.
+ *
+ * THE REGISTRY IS IN THE SDK because it is dependency-free and Node-built-in-free
+ * (so a browser-side analyzer can read it), because `Stream` already lives here,
+ * and because it is the only placement a module controller can reach: a module
+ * may import `@telorun/sdk` and nothing else.
+ */
+
+import { Stream } from "./stream.js";
+import { VALUE_TYPE_ENTRY_FILES } from "./value-types/entries/index.js";
+
+export const X_TELO_TYPE = "x-telo-type";
+
+/** How a value is represented, which is the one thing an entry declares.
+ *
+ *  - `json`     — an ordinary value its declared schema already validates. The
+ *                 name adds nominal identity for static wiring, nothing else.
+ *  - `instance` — not JSON at all. This is what makes a value unauthorable: no
+ *                 YAML literal is ever a byte buffer or a stream handle. */
+export type ValueTypeRepresentation = "json" | "instance";
+
+/** A named type parameter. Every parameter is optional and defaults to *any*,
+ *  so an unparameterized use of a generic type stays legal. Named rather than
+ *  positional so a diagnostic can say `of` instead of "argument 0", and so a
+ *  second parameter can be added without a migration. */
+export interface ValueTypeParameter {
+  readonly name: string;
+  readonly description?: string;
+}
+
+/** One value type, exactly as its entry file declares it. */
+export interface ValueTypeEntry {
+  /** `Telo.`-qualified. The closed vocabulary an author writes at the name slot. */
+  readonly name: string;
+  readonly representation: ValueTypeRepresentation;
+  /** `json` only — the JSON Schema type this name refines. */
+  readonly base?: string;
+  /** `instance` only — the symbolic key a runtime's binding table maps. */
+  readonly binding?: string;
+  /** An instance whose consumption has effects, so it is exempt from validation
+   *  rather than asserted. Exemption is from VALIDATION, never from TYPING. */
+  readonly live: boolean;
+  readonly parameters: readonly ValueTypeParameter[];
+  readonly description: string;
+}
+
+/** What one runtime can say about an `instance` representation. Node's identity
+ *  is a constructor (`instanceof` is the assertion) plus the CEL type an
+ *  expression at such a slot carries. */
+export interface ValueTypeBinding {
+  /** The constructor an assertion tests against. `Buffer` extends `Uint8Array`,
+   *  so a Node buffer satisfies `bytes` without a second rule. */
+  readonly constructor: Function;
+  /** The CEL type a value of this representation carries. */
+  readonly celType: string;
+  /** A stand-in the analyzer substitutes for a CEL leaf at such a slot, so the
+   *  static check and the runtime assertion agree BY CONSTRUCTION rather than by
+   *  two rules kept in step. Absent for a `live` type, whose value is never
+   *  validated and so needs nothing to satisfy. */
+  readonly placeholder?: () => unknown;
+}
+
+/**
+ * Node's binding table — the ONLY per-language artifact in the whole mechanism.
+ *
+ * Keyed by an entry's symbolic `binding`, never by its name, so a runtime that
+ * represents two entries the same way says so once and a rename of a type does
+ * not touch any table.
+ */
+export const VALUE_TYPE_BINDINGS: Readonly<Record<string, ValueTypeBinding>> = {
+  bytes: { constructor: Uint8Array, celType: "bytes", placeholder: () => new Uint8Array() },
+  stream: { constructor: Stream, celType: "Stream" },
+};
+
+/** The CEL type a `json` representation's declared base carries. A brand's own
+ *  name is the CEL type; this is what it degrades to when the consuming slot
+ *  declares no brand of its own (gradual typing). */
+const CEL_TYPE_FOR_BASE: Readonly<Record<string, string>> = {
+  integer: "int",
+  number: "double",
+  string: "string",
+  boolean: "bool",
+  array: "list",
+  object: "map",
+};
+
+class ValueTypeEntryError extends Error {
+  constructor(file: string, detail: string) {
+    super(`Invalid value-type entry '${file}': ${detail}`);
+    this.name = "ValueTypeEntryError";
+  }
+}
+
+const ENTRY_KEYS = [
+  "name",
+  "representation",
+  "base",
+  "binding",
+  "live",
+  "parameters",
+  "description",
+  "$comment",
+] as const;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function requireString(file: string, node: Record<string, unknown>, key: string): string {
+  const value = node[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ValueTypeEntryError(file, `'${key}' must be a non-empty string`);
+  }
+  return value;
+}
+
+function readParameters(file: string, raw: unknown): ValueTypeParameter[] {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) throw new ValueTypeEntryError(file, "'parameters' must be a sequence");
+  return raw.map((entry, i) => {
+    if (!isPlainObject(entry)) {
+      throw new ValueTypeEntryError(file, `parameters[${i}] must be a mapping`);
+    }
+    for (const key of Object.keys(entry)) {
+      if (key !== "name" && key !== "description") {
+        throw new ValueTypeEntryError(file, `parameters[${i}] has no key '${key}'`);
+      }
+    }
+    const name = requireString(file, entry, "name");
+    return entry.description === undefined
+      ? { name }
+      : { name, description: requireString(file, entry, "description") };
+  });
+}
+
+/**
+ * Read one entry file's parsed data.
+ *
+ * Reading is STRICT and the vocabulary is closed at every level. A malformed or
+ * typo'd entry is an authoring mistake whose only other outcome is a type that
+ * quietly is not in the vocabulary — which reads to an author as "unknown name",
+ * pointing at their manifest instead of at the entry.
+ */
+export function parseValueTypeEntry(file: string, data: unknown): ValueTypeEntry {
+  if (!isPlainObject(data)) throw new ValueTypeEntryError(file, "an entry must be a mapping");
+  for (const key of Object.keys(data)) {
+    if (!(ENTRY_KEYS as readonly string[]).includes(key)) {
+      throw new ValueTypeEntryError(
+        file,
+        `an entry has no key '${key}'. Known keys: ${ENTRY_KEYS.join(", ")}.`,
+      );
+    }
+  }
+
+  const name = requireString(file, data, "name");
+  if (!name.startsWith("Telo.")) {
+    throw new ValueTypeEntryError(
+      file,
+      `'name' must be Telo.-qualified — a representation is kernel-owned and cannot be module-defined`,
+    );
+  }
+  const representation = requireString(file, data, "representation");
+  if (representation !== "json" && representation !== "instance") {
+    throw new ValueTypeEntryError(file, `'representation' must be 'json' or 'instance'`);
+  }
+  if (data.live !== undefined && typeof data.live !== "boolean") {
+    throw new ValueTypeEntryError(file, "'live' must be a boolean when present");
+  }
+
+  // The two representations take disjoint parameters, and mixing them is a
+  // statement with no meaning: a `json` value has no constructor to assert, and
+  // an `instance` has no JSON base to refine.
+  if (representation === "json") {
+    if (data.binding !== undefined) {
+      throw new ValueTypeEntryError(file, "a 'json' representation takes no 'binding'");
+    }
+    const base = requireString(file, data, "base");
+    if (!(base in CEL_TYPE_FOR_BASE)) {
+      throw new ValueTypeEntryError(
+        file,
+        `'base' '${base}' is not a JSON Schema type (${Object.keys(CEL_TYPE_FOR_BASE).join(", ")})`,
+      );
+    }
+    if (data.live === true) {
+      throw new ValueTypeEntryError(file, "a 'json' representation cannot be 'live' — it is data");
+    }
+  } else {
+    if (data.base !== undefined) {
+      throw new ValueTypeEntryError(file, "an 'instance' representation takes no 'base'");
+    }
+    requireString(file, data, "binding");
+  }
+
+  const entry: ValueTypeEntry = {
+    name,
+    representation,
+    ...(representation === "json" ? { base: data.base as string } : { binding: data.binding as string }),
+    live: data.live === true,
+    parameters: readParameters(file, data.parameters),
+    description: requireString(file, data, "description"),
+  };
+  return entry;
+}
+
+function buildRegistry(): ReadonlyMap<string, ValueTypeEntry> {
+  const registry = new Map<string, ValueTypeEntry>();
+  for (const [file, data] of VALUE_TYPE_ENTRY_FILES) {
+    const entry = parseValueTypeEntry(file, data);
+    if (registry.has(entry.name)) {
+      throw new ValueTypeEntryError(file, `'${entry.name}' is already declared by another entry`);
+    }
+    // A binding with no row in THIS host's table is a hard error, never a
+    // skipped assertion: a type that cannot be asserted would silently exempt
+    // every slot declaring it, converting a contract into a hole. The same class
+    // of failure as an unrecognized `use` token degrading to the legacy reading.
+    if (entry.binding !== undefined && !(entry.binding in VALUE_TYPE_BINDINGS)) {
+      throw new ValueTypeEntryError(
+        file,
+        `binding '${entry.binding}' has no row in this runtime's table — a value type ` +
+          `whose assertion cannot be produced would silently exempt every slot that declares it`,
+      );
+    }
+    registry.set(entry.name, entry);
+  }
+  // Defence in depth against the packaging mistake, because the failure it
+  // produces is indistinguishable from an author's typo: every `x-telo-type`
+  // becomes an unknown name, reported against manifests that are correct. The
+  // build script refuses a missing source directory; this refuses the state that
+  // would reach a user if some other path ever produced it.
+  if (registry.size === 0) {
+    throw new Error(
+      "The value-type vocabulary is empty. `sdk/value-types/*.json` did not reach this " +
+        "build — check the file allowlist of whatever packaged it. Continuing would report " +
+        "every declared value type as an unknown name.",
+    );
+  }
+  return registry;
+}
+
+/** Every declared value type, keyed by its `Telo.`-qualified name. */
+export const VALUE_TYPES: ReadonlyMap<string, ValueTypeEntry> = buildRegistry();
+
+/** The declared names, in entry order — what `telo cel types` and the generated
+ *  docs section enumerate. */
+export function valueTypeNames(): string[] {
+  return [...VALUE_TYPES.keys()];
+}
+
+/** A read `x-telo-type` annotation: the type it names plus its type arguments. */
+export interface ValueTypeSlot {
+  /** The name exactly as written, which is also the canonical one — the
+   *  vocabulary is closed, so there is nothing to resolve. */
+  readonly name: string;
+  /** The registry entry, or undefined when the name is not a declared type.
+   *  Present separately from `name` so a diagnostic can report the name the
+   *  author wrote rather than swallowing an unknown one. */
+  readonly entry: ValueTypeEntry | undefined;
+  /** Type arguments by parameter name. Each value is a schema node. */
+  readonly args: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * Read the annotation off a schema node.
+ *
+ * Two spellings, one meaning: a bare name (`x-telo-type: Telo.Bytes`) and the
+ * object form carrying arguments (`{ name: Telo.Stream, of: … }`). Returns
+ * undefined when the node carries no annotation at all — an unknown NAME still
+ * returns a slot, with `entry` undefined, because silently reading it as "no
+ * value type" is the degrade this annotation replaced.
+ */
+export function readValueTypeSlot(schema: unknown): ValueTypeSlot | undefined {
+  if (!isPlainObject(schema)) return undefined;
+  const raw = schema[X_TELO_TYPE];
+  if (raw === undefined) return undefined;
+
+  if (typeof raw === "string") {
+    return { name: raw, entry: VALUE_TYPES.get(raw), args: {} };
+  }
+  if (isPlainObject(raw)) {
+    const name = typeof raw.name === "string" ? raw.name : "";
+    const args: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(raw)) {
+      if (key === "name") continue;
+      // A bare NAME as an argument is sugar for a schema node carrying only that
+      // annotation, so `of: Telo.Bytes` and `of: { x-telo-type: Telo.Bytes }`
+      // are one thing. Normalized HERE, in the single reader, so no consumer
+      // re-derives it — a comparator that saw the string form would compare a
+      // string against a schema and quietly conclude nothing.
+      args[key] = typeof value === "string" ? { [X_TELO_TYPE]: value } : value;
+    }
+    return { name, entry: VALUE_TYPES.get(name), args };
+  }
+  return { name: "", entry: undefined, args: {} };
+}
+
+/** The entry a schema node declares, or undefined. The common read. */
+export function valueTypeOf(schema: unknown): ValueTypeEntry | undefined {
+  return readValueTypeSlot(schema)?.entry;
+}
+
+/** True when this node declares a value type at all (known or not). */
+export function isValueTypeSlot(schema: unknown): boolean {
+  return readValueTypeSlot(schema) !== undefined;
+}
+
+/** True when the node declares a `live` type, so its value is exempt from
+ *  validation — never traversed, never asserted. Typing is unaffected. */
+export function isLiveSlot(schema: unknown): boolean {
+  return valueTypeOf(schema)?.live === true;
+}
+
+/** True when the node declares a type represented as a runtime instance —
+ *  the values no manifest literal can ever be. */
+export function isInstanceSlot(schema: unknown): boolean {
+  return valueTypeOf(schema)?.representation === "instance";
+}
+
+/** The binding row for a schema node's declared type, or undefined when it
+ *  declares none / declares a `json` one. */
+export function bindingOf(schema: unknown): ValueTypeBinding | undefined {
+  const binding = valueTypeOf(schema)?.binding;
+  return binding === undefined ? undefined : VALUE_TYPE_BINDINGS[binding];
+}
+
+/** The stand-in for a CEL leaf at this slot, or undefined when the slot declares
+ *  no instance type (ordinary JSON, so the schema's own shape decides) or a live
+ *  one (nothing validates it, so nothing has to satisfy anything). */
+export function valueTypePlaceholder(schema: unknown): unknown | undefined {
+  return bindingOf(schema)?.placeholder?.();
+}
+
+/**
+ * The CEL type a value at this slot carries.
+ *
+ * A `json` representation carries its own NAME as a nominal brand — which is the
+ * whole point of one, since a `Telo.TcpPort` and a `Telo.UdpPort` are structurally
+ * identical. An `instance` carries whatever its binding says.
+ */
+export function celTypeOfValueType(entry: ValueTypeEntry): string {
+  if (entry.representation === "json") return entry.name;
+  const binding = VALUE_TYPE_BINDINGS[entry.binding!];
+  return binding!.celType;
+}
+
+/** The CEL type a brand degrades to where the consuming slot declares none —
+ *  gradual typing, so a `Telo.TcpPort` flows freely into a plain integer field.
+ *  Undefined for an `instance`, which has no base to fall back to. */
+export function celBaseOfValueType(entry: ValueTypeEntry): string | undefined {
+  return entry.representation === "json" ? CEL_TYPE_FOR_BASE[entry.base!] : undefined;
+}
+
+/** Every `json` representation's CEL brand → the base type it refines. The
+ *  gradual-typing table, derived rather than hand-written. */
+export function valueBrandBases(): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const entry of VALUE_TYPES.values()) {
+    const base = celBaseOfValueType(entry);
+    if (base !== undefined) out[entry.name] = base;
+  }
+  return out;
+}

package/src/value-types/entries/index.ts

@@ -0,0 +1,14 @@
+// GENERATED by scripts/copy-value-type-entries.mjs — do not edit, and do not commit.
+// Source: sdk/value-types/*.json (lexically ordered).
+import e0 from "./telo-bytes.json" with { type: "json" };
+import e1 from "./telo-stream.json" with { type: "json" };
+import e2 from "./telo-tcp-port.json" with { type: "json" };
+import e3 from "./telo-udp-port.json" with { type: "json" };
+
+/** Every value-type entry file, in the order the registry reads them. */
+export const VALUE_TYPE_ENTRY_FILES: ReadonlyArray<readonly [file: string, data: unknown]> = [
+  ["telo-bytes.json", e0],
+  ["telo-stream.json", e1],
+  ["telo-tcp-port.json", e2],
+  ["telo-udp-port.json", e3],
+];

package/src/value-types/entries/telo-bytes.json

@@ -0,0 +1,7 @@
+{
+  "$comment": "Bytes are not expressible in JSON Schema's type vocabulary. `type: object` is satisfied by every object, so a mistyped literal reached the controller instead of failing check; `type: binary` is not an option, since a validator refuses to COMPILE an unknown type and a published telo.yaml would stop being JSON Schema for the hub, the editor and every third-party reader. Declaring the representation instead is what makes the check fall out: no YAML literal is ever a byte buffer, so a literal at a byte slot is rejected statically and a value arriving by reference passes.",
+  "name": "Telo.Bytes",
+  "representation": "instance",
+  "binding": "bytes",
+  "description": "Raw bytes. Never authorable inline — a byte slot is filled by reference (an `!include-bytes` embed, a resource output, a CEL expression), and the runtime asserts the value really is a byte buffer."
+}

package/src/value-types/entries/telo-stream.json

@@ -0,0 +1,14 @@
+{
+  "$comment": "`live` is what separates a stream from bytes: consuming it has effects, so it is EXEMPT from validation rather than asserted — iterating a stream to check its elements is precisely what the exemption forbids. The exemption is from VALIDATION, never from TYPING: `of` still travels through every schema-typing walk, because that is where the argument check reads it.",
+  "name": "Telo.Stream",
+  "representation": "instance",
+  "binding": "stream",
+  "live": true,
+  "parameters": [
+    {
+      "name": "of",
+      "description": "The element the stream yields. Any schema node — an inline shape, a value type, a `!ref` to a named shape, or another parameterized type. Omitted means any element."
+    }
+  ],
+  "description": "A live handle over a sequence of values, consumed by reading. Its elements are never buffered or validated, and member access past it is rejected — a consumer iterates it instead."
+}

package/src/value-types/entries/telo-tcp-port.json

@@ -0,0 +1,7 @@
+{
+  "$comment": "A `json` representation adds nominal identity to a value the declared schema already validates. A TcpPort and a UdpPort are both integers, so nothing structural tells them apart — the name is the whole difference, and it is what makes wiring one into the other's slot a static error.",
+  "name": "Telo.TcpPort",
+  "representation": "json",
+  "base": "integer",
+  "description": "A TCP port number. Distinct from a UDP port even though both are integers, so wiring one into the other's slot is a static error."
+}

package/src/value-types/entries/telo-udp-port.json

@@ -0,0 +1,6 @@
+{
+  "name": "Telo.UdpPort",
+  "representation": "json",
+  "base": "integer",
+  "description": "A UDP port number. Distinct from a TCP port even though both are integers, so wiring one into the other's slot is a static error."
+}