@telorun/sdk 0.73.0 → 0.74.0

package/dist/bigint-json.d.ts

@@ -39,4 +39,25 @@ export declare function isBigIntJsonEnabled(): boolean;
  * Everything that wants exact digits on the wire needs no replacer at all.
  */
 export declare function bigIntAt(holder: unknown, key: string): bigint | undefined;
+/**
+ * A declared-integer input read as a JS number, whichever representation the
+ * call site produced.
+ *
+ * A CEL integer is an int64 — a BigInt — and the kernel normalizes a declared
+ * `type: integer` OUTPUT to that form, so one resource's result reaching another
+ * resource's input arrives as a BigInt while a YAML literal at the same slot
+ * arrives as a plain number. A controller that reads such an input with
+ * `Number.isInteger(...)` or plain arithmetic therefore works for one call site
+ * and throws `Cannot mix BigInt and other types` for the other. Inputs are
+ * deliberately NOT normalized (that would change the authoring surface of every
+ * module rather than repair a false declaration), so this is how a controller
+ * reads one.
+ *
+ * Returns `undefined` for anything that is not an integer in either
+ * representation — including a BigInt too large for a double, since silently
+ * rounding it would be the precision loss int64 support exists to remove — so a
+ * caller's own "must be a non-negative integer" check still rejects what it
+ * should.
+ */
+export declare function integerInput(value: unknown): number | undefined;
 //# sourceMappingURL=bigint-json.d.ts.map

package/dist/bigint-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bigint-json.d.ts","sourceRoot":"","sources":["../src/bigint-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;uCAGuC;AACvC,eAAO,MAAM,yBAAyB,QAAgB,CAAC;AAEvD,oFAAoF;AACpF,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE"}
+{"version":3,"file":"bigint-json.d.ts","sourceRoot":"","sources":["../src/bigint-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;uCAGuC;AACvC,eAAO,MAAM,yBAAyB,QAAgB,CAAC;AAEvD,oFAAoF;AACpF,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAK/D"}

package/dist/bigint-json.js

@@ -45,3 +45,31 @@ export function bigIntAt(holder, key) {
     const source = holder?.[key];
     return typeof source === "bigint" ? source : undefined;
 }
+/**
+ * A declared-integer input read as a JS number, whichever representation the
+ * call site produced.
+ *
+ * A CEL integer is an int64 — a BigInt — and the kernel normalizes a declared
+ * `type: integer` OUTPUT to that form, so one resource's result reaching another
+ * resource's input arrives as a BigInt while a YAML literal at the same slot
+ * arrives as a plain number. A controller that reads such an input with
+ * `Number.isInteger(...)` or plain arithmetic therefore works for one call site
+ * and throws `Cannot mix BigInt and other types` for the other. Inputs are
+ * deliberately NOT normalized (that would change the authoring surface of every
+ * module rather than repair a false declaration), so this is how a controller
+ * reads one.
+ *
+ * Returns `undefined` for anything that is not an integer in either
+ * representation — including a BigInt too large for a double, since silently
+ * rounding it would be the precision loss int64 support exists to remove — so a
+ * caller's own "must be a non-negative integer" check still rejects what it
+ * should.
+ */
+export function integerInput(value) {
+    if (typeof value === "number")
+        return Number.isInteger(value) ? value : undefined;
+    if (typeof value !== "bigint")
+        return undefined;
+    const asNumber = Number(value);
+    return Number.isSafeInteger(asNumber) ? asNumber : undefined;
+}

package/dist/value-type.d.ts

@@ -38,6 +38,12 @@ export type ValueTypeRepresentation = "json" | "instance";
  *  second parameter can be added without a migration. */
 export interface ValueTypeParameter {
     readonly name: string;
+    /** This parameter's argument is what ITERATING a value of the type yields.
+     *  Declared here so "what is the element of this collection" is answered by
+     *  the vocabulary rather than by a consumer that knows one type's name — the
+     *  same reason `live` is a field and not a check against `Telo.Stream`. At
+     *  most one parameter per entry may carry it. */
+    readonly element?: boolean;
     readonly description?: string;
 }
 /** One value type, exactly as its entry file declares it. */
@@ -124,6 +130,17 @@ 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 schema of what iterating a value at this slot yields, or undefined when
+ * the slot declares no value type, or one with no element parameter.
+ *
+ * The whole point of reading it from the entry is that no consumer names a type:
+ * a future iterable value type is covered by declaring `element` on its own
+ * parameter, with nothing to change here or in the analyzer. An element
+ * parameter left unsupplied means *any*, exactly as every other omitted argument
+ * does, so an unparameterized use degrades to permissive rather than to nothing.
+ */
+export declare function elementSchemaOf(schema: unknown): unknown | undefined;
 /** 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;

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

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

package/dist/value-type.js

@@ -80,20 +80,34 @@ function readParameters(file, raw) {
         return [];
     if (!Array.isArray(raw))
         throw new ValueTypeEntryError(file, "'parameters' must be a sequence");
-    return raw.map((entry, i) => {
+    const params = 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") {
+            if (key !== "name" && key !== "description" && key !== "element") {
                 throw new ValueTypeEntryError(file, `parameters[${i}] has no key '${key}'`);
             }
         }
+        if (entry.element !== undefined && typeof entry.element !== "boolean") {
+            throw new ValueTypeEntryError(file, `parameters[${i}].element must be a boolean when present`);
+        }
         const name = requireString(file, entry, "name");
-        return entry.description === undefined
-            ? { name }
-            : { name, description: requireString(file, entry, "description") };
+        return {
+            name,
+            ...(entry.element === true ? { element: true } : {}),
+            ...(entry.description === undefined
+                ? {}
+                : { description: requireString(file, entry, "description") }),
+        };
     });
+    // Two element parameters would make "the element of this value" ambiguous, and
+    // the reader is the only place that can refuse it — every consumer takes the
+    // first match and would silently pick one.
+    if (params.filter((p) => p.element).length > 1) {
+        throw new ValueTypeEntryError(file, "at most one parameter may declare 'element'");
+    }
+    return params;
 }
 /**
  * Read one entry file's parsed data.
@@ -242,6 +256,23 @@ export function isLiveSlot(schema) {
 export function isInstanceSlot(schema) {
     return valueTypeOf(schema)?.representation === "instance";
 }
+/**
+ * The schema of what iterating a value at this slot yields, or undefined when
+ * the slot declares no value type, or one with no element parameter.
+ *
+ * The whole point of reading it from the entry is that no consumer names a type:
+ * a future iterable value type is covered by declaring `element` on its own
+ * parameter, with nothing to change here or in the analyzer. An element
+ * parameter left unsupplied means *any*, exactly as every other omitted argument
+ * does, so an unparameterized use degrades to permissive rather than to nothing.
+ */
+export function elementSchemaOf(schema) {
+    const slot = readValueTypeSlot(schema);
+    const parameter = slot?.entry?.parameters.find((p) => p.element);
+    if (!parameter)
+        return undefined;
+    return slot.args[parameter.name] ?? {};
+}
 /** The binding row for a schema node's declared type, or undefined when it
  *  declares none / declares a `json` one. */
 export function bindingOf(schema) {

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

@@ -7,6 +7,7 @@
     "parameters": [
         {
             "name": "of",
+            "element": true,
             "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."
         }
     ],

package/package.json

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

package/src/bigint-json.ts

@@ -49,3 +49,30 @@ export function bigIntAt(holder: unknown, key: string): bigint | undefined {
   const source = (holder as Record<string, unknown> | null | undefined)?.[key];
   return typeof source === "bigint" ? source : undefined;
 }
+
+/**
+ * A declared-integer input read as a JS number, whichever representation the
+ * call site produced.
+ *
+ * A CEL integer is an int64 — a BigInt — and the kernel normalizes a declared
+ * `type: integer` OUTPUT to that form, so one resource's result reaching another
+ * resource's input arrives as a BigInt while a YAML literal at the same slot
+ * arrives as a plain number. A controller that reads such an input with
+ * `Number.isInteger(...)` or plain arithmetic therefore works for one call site
+ * and throws `Cannot mix BigInt and other types` for the other. Inputs are
+ * deliberately NOT normalized (that would change the authoring surface of every
+ * module rather than repair a false declaration), so this is how a controller
+ * reads one.
+ *
+ * Returns `undefined` for anything that is not an integer in either
+ * representation — including a BigInt too large for a double, since silently
+ * rounding it would be the precision loss int64 support exists to remove — so a
+ * caller's own "must be a non-negative integer" check still rejects what it
+ * should.
+ */
+export function integerInput(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isInteger(value) ? value : undefined;
+  if (typeof value !== "bigint") return undefined;
+  const asNumber = Number(value);
+  return Number.isSafeInteger(asNumber) ? asNumber : undefined;
+}

package/src/value-type.ts

@@ -44,6 +44,12 @@ export type ValueTypeRepresentation = "json" | "instance";
  *  second parameter can be added without a migration. */
 export interface ValueTypeParameter {
   readonly name: string;
+  /** This parameter's argument is what ITERATING a value of the type yields.
+   *  Declared here so "what is the element of this collection" is answered by
+   *  the vocabulary rather than by a consumer that knows one type's name — the
+   *  same reason `live` is a field and not a check against `Telo.Stream`. At
+   *  most one parameter per entry may carry it. */
+  readonly element?: boolean;
   readonly description?: string;
 }
 
@@ -136,20 +142,34 @@ function requireString(file: string, node: Record<string, unknown>, key: string)
 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) => {
+  const params = 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") {
+      if (key !== "name" && key !== "description" && key !== "element") {
         throw new ValueTypeEntryError(file, `parameters[${i}] has no key '${key}'`);
       }
     }
+    if (entry.element !== undefined && typeof entry.element !== "boolean") {
+      throw new ValueTypeEntryError(file, `parameters[${i}].element must be a boolean when present`);
+    }
     const name = requireString(file, entry, "name");
-    return entry.description === undefined
-      ? { name }
-      : { name, description: requireString(file, entry, "description") };
+    return {
+      name,
+      ...(entry.element === true ? { element: true as const } : {}),
+      ...(entry.description === undefined
+        ? {}
+        : { description: requireString(file, entry, "description") }),
+    };
   });
+  // Two element parameters would make "the element of this value" ambiguous, and
+  // the reader is the only place that can refuse it — every consumer takes the
+  // first match and would silently pick one.
+  if (params.filter((p) => p.element).length > 1) {
+    throw new ValueTypeEntryError(file, "at most one parameter may declare 'element'");
+  }
+  return params;
 }
 
 /**
@@ -334,6 +354,23 @@ export function isInstanceSlot(schema: unknown): boolean {
   return valueTypeOf(schema)?.representation === "instance";
 }
 
+/**
+ * The schema of what iterating a value at this slot yields, or undefined when
+ * the slot declares no value type, or one with no element parameter.
+ *
+ * The whole point of reading it from the entry is that no consumer names a type:
+ * a future iterable value type is covered by declaring `element` on its own
+ * parameter, with nothing to change here or in the analyzer. An element
+ * parameter left unsupplied means *any*, exactly as every other omitted argument
+ * does, so an unparameterized use degrades to permissive rather than to nothing.
+ */
+export function elementSchemaOf(schema: unknown): unknown | undefined {
+  const slot = readValueTypeSlot(schema);
+  const parameter = slot?.entry?.parameters.find((p) => p.element);
+  if (!parameter) return undefined;
+  return slot!.args[parameter.name] ?? {};
+}
+
 /** 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 {

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

@@ -7,6 +7,7 @@
   "parameters": [
     {
       "name": "of",
+      "element": true,
       "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."
     }
   ],