@telorun/sdk 0.73.0 → 0.75.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/invoke-step.d.ts

@@ -1,9 +1,35 @@
 import type { Invocable } from "./capabilities/invokable.js";
+import { type InvokeContext } from "./cancellation.js";
 import type { KindRef, ScopeContext } from "./ref.js";
 import { type ResourceInstance } from "./resource-instance.js";
-/** Retry policy for a single invoke step, passed through to `ctx.invoke`. */
+/**
+ * Retry policy for a single invoke step.
+ *
+ * The field names are `Http.Request`'s, deliberately: two spellings of one
+ * concern in one standard library is how an author learns that backoff means
+ * something different depending on where it is written. `delay` is the older
+ * duration-string spelling, kept because published manifests carry it, and read
+ * as `initialDelay` when that is absent.
+ *
+ * Consumed HERE, in the leaf, rather than passed to `ctx.invoke`. The leaf has
+ * four dispatch branches and only one of them went through `ctx.invoke`, so a
+ * policy handed downstream was silently ignored for a pre-injected `!ref` — the
+ * dominant shape — and no kernel path ever read it. Owning it at the one place
+ * every branch passes through is what makes the field mean anything at all.
+ */
 export interface InvokeStepRetry {
+    /** Re-attempts after the first try. 0 (or absent) disables retrying. */
     attempts?: number;
+    /** Milliseconds before the first re-attempt. */
+    initialDelay?: number;
+    /** Multiplier applied to the delay after each re-attempt. */
+    factor?: number;
+    /** Ceiling on the delay between re-attempts, in milliseconds. */
+    maxDelay?: number;
+    /** `full` picks each delay uniformly from [0, delay], decorrelating a fleet
+     *  that failed together. */
+    jitter?: "none" | "full";
+    /** DEPRECATED duration string (`"250ms"`, `"1s"`) — read as `initialDelay`. */
     delay?: string;
 }
 /**
@@ -19,15 +45,17 @@ export interface InvokeStep {
     retry?: InvokeStepRetry;
 }
 /** An inline flat invoke step on an Application's `targets`. Same as an
- *  `InvokeStep` but `name` is optional (only needed for `steps.<name>.result`
- *  plumbing; the boot runner synthesizes one when omitted) and `retry` is not
- *  supported — the boot invoke path takes no retry options, so it is omitted
- *  from the surface rather than silently ignored. */
+ *  {@link InvokeStep} but `name` is optional — it is only needed for
+ *  `steps.<name>.result` plumbing, and the boot runner synthesizes one when
+ *  omitted. Everything else a dispatch site carries applies here, `retry`
+ *  included: both are the same kernel-owned shape, and the schema half now says
+ *  so too. Control flow (`if`/`while`/`switch`/`try`) is still Run's. */
 export interface InlineInvokeTarget {
     name?: string;
     when?: string;
     invoke: KindRef<Invocable> | Invocable;
     inputs?: Record<string, unknown>;
+    retry?: InvokeStepRetry;
 }
 /** A single Application `targets` entry. The kernel boot runner dispatches by
  *  shape: a bare string or resolved `{ kind, name }` runs a Runnable/Service;
@@ -67,6 +95,24 @@ export interface InvokeStepState {
     steps: Record<string, unknown>;
     cel?: Record<string, unknown>;
     scope?: ScopeContext;
+    /**
+     * The invocation this step runs inside, forwarded from the composer's own
+     * `invoke(inputs, ctx)`.
+     *
+     * Needed for the WAIT, not for the dispatch. The kernel refuses a dispatch
+     * reached after the tree was cancelled, so every step boundary is already a
+     * cancellation point through the ambient context — but a backoff between two
+     * attempts is time spent inside this leaf, where the kernel's gate cannot see
+     * it and the ambient store is deliberately not on the SDK surface (it is one
+     * runtime's mechanism; a second-language leaf has no `AsyncLocalStorage`).
+     * Passing it explicitly is what makes the wait interruptible in any runtime.
+     *
+     * Present at boot too: the boot runner forwards the kernel's boot cancellation,
+     * which the CLI's SIGINT handler trips, so Ctrl-C ends a target parked in a
+     * backoff. Absent only for a caller that assembled a step in code and had no
+     * invocation to forward.
+     */
+    invokeCtx?: InvokeContext;
 }
 /**
  * Execute one invoke step: evaluate the `when` guard, expand `inputs`, resolve

package/dist/invoke-step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invoke-step.d.ts","sourceRoot":"","sources":["../src/invoke-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAkB,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB;AAED;;;;qDAIqD;AACrD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;;mFAGmF;AACnF,MAAM,MAAM,UAAU,GAClB,MAAM,GACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,kBAAkB,CAAC;AAEvB;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC;IAC3D,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1F,cAAc,CAAC,OAAO,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,GAAG,CAAC,CAAC;IAChB;;qDAEiD;IACjD,uBAAuB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;CACrF;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,IAAI,CAAC,CAuCf"}
+{"version":3,"file":"invoke-step.d.ts","sourceRoot":"","sources":["../src/invoke-step.ts"],"names":[],"mappings":"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"}

package/dist/invoke-step.js

@@ -1,3 +1,7 @@
+import { ERR_INVOKE_CANCELLED, isCancellationError, } from "./cancellation.js";
+import { isAmbientContractErrorCode } from "./contract-errors.js";
+import { tryParseDurationMs } from "./duration.js";
+import { InvokeError } from "./invoke-error.js";
 import { getRefIdentity } from "./resource-instance.js";
 /**
  * Execute one invoke step: evaluate the `when` guard, expand `inputs`, resolve
@@ -11,6 +15,124 @@ export async function executeInvokeStep(step, ctx, state) {
         return;
     const inputs = ctx.expandValue(step.inputs ?? {}, cel);
     const raw = step.invoke;
+    const result = await withStepRetry(step, state.invokeCtx, () => dispatch(raw, inputs, ctx, state));
+    state.steps[step.name] = { result };
+}
+/**
+ * Re-attempt a step's dispatch while its policy allows.
+ *
+ * Retries a DOMAIN failure and nothing else. There is no status to classify at
+ * this level, so the classification cannot be positive — what there is instead is
+ * an explicit author instruction, since a step carries `retry:` only because
+ * someone wrote it. So the rule is stated as exclusions, and both of them are
+ * decidable without judgement:
+ *
+ *   - **Cancellation.** The invocation has been asked to stop; re-issuing it
+ *     ignores that.
+ *   - **A contract violation**, and a **resolution failure** — the target does not
+ *     exist, or cannot be invoked. {@link isAmbientContractErrorCode} names the
+ *     first set; {@link UNRETRYABLE_CODES} adds the second. Both are the KERNEL's
+ *     verdict on the shape of the call rather than on the work, so they are a
+ *     property of the manifest and every re-attempt fails identically — a budget
+ *     spent on one is dead time between a typo and the diagnostic that names it,
+ *     up to `attempts × maxDelay`. Nothing about a misspelled resource name gets
+ *     truer after eight seconds of backoff.
+ *
+ * The WAIT between attempts is cancellable, for the first reason above. Every
+ * other point in a sequence already is — the kernel refuses a dispatch reached
+ * after the tree was cancelled — so a backoff is the one interval where a
+ * cancelled run would otherwise stay parked, for up to `attempts × maxDelay`.
+ *
+ * The defaults come from the schema (`Run` steps declare `default:` on every
+ * field, as `Http.Request.retry` does), so the `??` fallbacks here are the floor
+ * for a caller that assembled a policy in code rather than from a manifest — not
+ * a second, competing statement of what a default is.
+ */
+async function withStepRetry(step, invokeCtx, dispatch) {
+    const policy = step.retry;
+    const attempts = policy?.attempts ?? 0;
+    if (!policy || attempts <= 0)
+        return dispatch();
+    const initial = policy.initialDelay ?? parseDuration(policy.delay) ?? 250;
+    const factor = policy.factor ?? 2;
+    const maxDelay = policy.maxDelay ?? 32_000;
+    const jitter = policy.jitter ?? "full";
+    for (let resend = 0;; resend++) {
+        try {
+            return await dispatch();
+        }
+        catch (err) {
+            if (resend >= attempts || !isRetryable(err))
+                throw err;
+            const backoff = Math.min(maxDelay, initial * Math.pow(factor, resend));
+            await waitBeforeResend(jitter === "full" ? Math.random() * backoff : backoff, invokeCtx?.cancellation, step, err);
+        }
+    }
+}
+/** Kernel verdicts on the CALL rather than on the work, beyond the ambient
+ *  contract set. A dispatch that cannot resolve its target is a manifest defect;
+ *  re-issuing it re-resolves the same name against the same registry. */
+const UNRETRYABLE_CODES = new Set(["ERR_RESOURCE_NOT_FOUND", "ERR_RESOURCE_NOT_INVOKABLE"]);
+function isRetryable(err) {
+    if (isCancellationError(err))
+        return false;
+    const code = err?.code;
+    if (typeof code !== "string")
+        return true;
+    return !isAmbientContractErrorCode(code) && !UNRETRYABLE_CODES.has(code);
+}
+/**
+ * Wait out the backoff, or give up the moment the invocation is cancelled.
+ *
+ * The failure that CAUSED the wait rides in the cancellation's `data`. Without
+ * it, cancelling mid-backoff would report only that the run was cancelled and
+ * the attempt's actual error — the thing the author is retrying because of —
+ * would be gone, which is exactly the swallowing a retry loop is prone to.
+ *
+ * `onCancelled` fires synchronously when the token is already cancelled, so an
+ * already-cancelled run clears the timer and rejects without waiting a tick.
+ */
+function waitBeforeResend(ms, token, step, pending) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            unsubscribe?.();
+            resolve();
+        }, ms);
+        const unsubscribe = token?.onCancelled((reason) => {
+            clearTimeout(timer);
+            // Released on BOTH paths. The listener is the one thing this holds, and a
+            // subscription outliving the wait it belongs to is a leak per re-attempt.
+            unsubscribe?.();
+            reject(new InvokeError(ERR_INVOKE_CANCELLED, `Step "${step.name}": cancelled while waiting to re-attempt` +
+                `${reason ? ` (${reason})` : ""}.`, { step: step.name, pendingFailure: describeFailure(pending) }));
+        });
+    });
+}
+function describeFailure(err) {
+    const code = err?.code;
+    const message = err instanceof Error ? err.message : String(err);
+    return { ...(typeof code === "string" ? { code } : {}), message };
+}
+/**
+ * The deprecated `delay` duration string, in milliseconds.
+ *
+ * Delegates to the SDK's one duration grammar rather than restating it: a second
+ * spelling here would accept strings `telo check`'s `pattern` rejects, and the
+ * two would drift. A malformed value THROWS — falling back to the default would
+ * swallow a typo into a silently different backoff, and the schema's `pattern`
+ * means anything reaching this already failed static analysis.
+ */
+function parseDuration(value) {
+    if (value === undefined)
+        return undefined;
+    const ms = tryParseDurationMs(value);
+    if (ms === null) {
+        throw new InvokeError("ERR_INVALID_VALUE", `Step retry: invalid 'delay' ${JSON.stringify(value)}; use a number with a unit, e.g. ` +
+            `"250ms", "2s", "1.5m", "1h" — or the preferred 'initialDelay', in milliseconds.`);
+    }
+    return ms;
+}
+async function dispatch(raw, inputs, ctx, state) {
     let result;
     if (raw && typeof raw.invoke === "function") {
         // A pre-injected live instance (a `!ref` resolved at Phase 5). Route it
@@ -39,8 +161,8 @@ export async function executeInvokeStep(step, ctx, state) {
             result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs);
         }
         else {
-            result = await ctx.invoke(ref.kind, ref.name, inputs, { retry: step.retry });
+            result = await ctx.invoke(ref.kind, ref.name, inputs);
         }
     }
-    state.steps[step.name] = { result };
+    return result;
 }

package/dist/resource-context.d.ts

@@ -46,16 +46,19 @@ export type ParsedArgs = Partial<Record<string, string | boolean | string[]>> &
 /**
  * Per-call options for a by-name dispatch.
  *
- * A bag rather than a positional context parameter because this slot already
- * carried one meaning — `retry`, consumed by the step leaf — and
- * `ResourceContext` satisfies `InvokeStepContext` structurally, so a positional
- * `InvokeContext` here silently receives a step's retry options instead.
+ * A bag rather than a positional context parameter, because `ResourceContext`
+ * satisfies `InvokeStepContext` structurally: a positional fourth argument here
+ * is reachable from the step leaf's own `invoke` call, so the two surfaces would
+ * have to agree on its meaning forever. A named key cannot be filled by accident.
+ *
+ * `retry` USED to live here and was read by nobody — the step leaf handed it down
+ * on one of its four dispatch branches and no kernel path looked at it. It now
+ * belongs to the leaf, which is the one place every branch passes through; a key
+ * kept here would be a second, inert way to ask for the same thing.
  */
 export interface InvokeByNameOptions {
     /** Seeds the invocation context, replacing the ambient. */
     ctx?: InvokeContext;
-    /** Retry policy, read by `executeInvokeStep`. */
-    retry?: unknown;
 }
 export interface ResourceContext extends ControllerContext {
     readonly args: ParsedArgs;

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

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

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.75.0",
   "description": "Telo SDK - Public API for Telo module authors.",
   "keywords": [
     "telo",
@@ -36,9 +36,12 @@
   ],
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.lib.json"
+    "build": "tsc -p tsconfig.lib.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }

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/invoke-step.ts

@@ -1,10 +1,44 @@
 import type { Invocable } from "./capabilities/invokable.js";
+import {
+  type CancellationToken,
+  ERR_INVOKE_CANCELLED,
+  type InvokeContext,
+  isCancellationError,
+} from "./cancellation.js";
+import { isAmbientContractErrorCode } from "./contract-errors.js";
+import { tryParseDurationMs } from "./duration.js";
+import { InvokeError } from "./invoke-error.js";
 import type { KindRef, ScopeContext } from "./ref.js";
 import { getRefIdentity, type ResourceInstance } from "./resource-instance.js";
 
-/** Retry policy for a single invoke step, passed through to `ctx.invoke`. */
+/**
+ * Retry policy for a single invoke step.
+ *
+ * The field names are `Http.Request`'s, deliberately: two spellings of one
+ * concern in one standard library is how an author learns that backoff means
+ * something different depending on where it is written. `delay` is the older
+ * duration-string spelling, kept because published manifests carry it, and read
+ * as `initialDelay` when that is absent.
+ *
+ * Consumed HERE, in the leaf, rather than passed to `ctx.invoke`. The leaf has
+ * four dispatch branches and only one of them went through `ctx.invoke`, so a
+ * policy handed downstream was silently ignored for a pre-injected `!ref` — the
+ * dominant shape — and no kernel path ever read it. Owning it at the one place
+ * every branch passes through is what makes the field mean anything at all.
+ */
 export interface InvokeStepRetry {
+  /** Re-attempts after the first try. 0 (or absent) disables retrying. */
   attempts?: number;
+  /** Milliseconds before the first re-attempt. */
+  initialDelay?: number;
+  /** Multiplier applied to the delay after each re-attempt. */
+  factor?: number;
+  /** Ceiling on the delay between re-attempts, in milliseconds. */
+  maxDelay?: number;
+  /** `full` picks each delay uniformly from [0, delay], decorrelating a fleet
+   *  that failed together. */
+  jitter?: "none" | "full";
+  /** DEPRECATED duration string (`"250ms"`, `"1s"`) — read as `initialDelay`. */
   delay?: string;
 }
 
@@ -22,15 +56,17 @@ export interface InvokeStep {
 }
 
 /** An inline flat invoke step on an Application's `targets`. Same as an
- *  `InvokeStep` but `name` is optional (only needed for `steps.<name>.result`
- *  plumbing; the boot runner synthesizes one when omitted) and `retry` is not
- *  supported — the boot invoke path takes no retry options, so it is omitted
- *  from the surface rather than silently ignored. */
+ *  {@link InvokeStep} but `name` is optional — it is only needed for
+ *  `steps.<name>.result` plumbing, and the boot runner synthesizes one when
+ *  omitted. Everything else a dispatch site carries applies here, `retry`
+ *  included: both are the same kernel-owned shape, and the schema half now says
+ *  so too. Control flow (`if`/`while`/`switch`/`try`) is still Run's. */
 export interface InlineInvokeTarget {
   name?: string;
   when?: string;
   invoke: KindRef<Invocable> | Invocable;
   inputs?: Record<string, unknown>;
+  retry?: InvokeStepRetry;
 }
 
 /** A single Application `targets` entry. The kernel boot runner dispatches by
@@ -73,6 +109,24 @@ export interface InvokeStepState {
   steps: Record<string, unknown>;
   cel?: Record<string, unknown>;
   scope?: ScopeContext;
+  /**
+   * The invocation this step runs inside, forwarded from the composer's own
+   * `invoke(inputs, ctx)`.
+   *
+   * Needed for the WAIT, not for the dispatch. The kernel refuses a dispatch
+   * reached after the tree was cancelled, so every step boundary is already a
+   * cancellation point through the ambient context — but a backoff between two
+   * attempts is time spent inside this leaf, where the kernel's gate cannot see
+   * it and the ambient store is deliberately not on the SDK surface (it is one
+   * runtime's mechanism; a second-language leaf has no `AsyncLocalStorage`).
+   * Passing it explicitly is what makes the wait interruptible in any runtime.
+   *
+   * Present at boot too: the boot runner forwards the kernel's boot cancellation,
+   * which the CLI's SIGINT handler trips, so Ctrl-C ends a target parked in a
+   * backoff. Absent only for a caller that assembled a step in code and had no
+   * invocation to forward.
+   */
+  invokeCtx?: InvokeContext;
 }
 
 /**
@@ -91,6 +145,158 @@ export async function executeInvokeStep(
 
   const inputs = ctx.expandValue(step.inputs ?? {}, cel) as Record<string, unknown>;
   const raw = step.invoke as unknown;
+  const result = await withStepRetry(step, state.invokeCtx, () =>
+    dispatch(raw, inputs, ctx, state),
+  );
+
+  state.steps[step.name] = { result };
+}
+
+/**
+ * Re-attempt a step's dispatch while its policy allows.
+ *
+ * Retries a DOMAIN failure and nothing else. There is no status to classify at
+ * this level, so the classification cannot be positive — what there is instead is
+ * an explicit author instruction, since a step carries `retry:` only because
+ * someone wrote it. So the rule is stated as exclusions, and both of them are
+ * decidable without judgement:
+ *
+ *   - **Cancellation.** The invocation has been asked to stop; re-issuing it
+ *     ignores that.
+ *   - **A contract violation**, and a **resolution failure** — the target does not
+ *     exist, or cannot be invoked. {@link isAmbientContractErrorCode} names the
+ *     first set; {@link UNRETRYABLE_CODES} adds the second. Both are the KERNEL's
+ *     verdict on the shape of the call rather than on the work, so they are a
+ *     property of the manifest and every re-attempt fails identically — a budget
+ *     spent on one is dead time between a typo and the diagnostic that names it,
+ *     up to `attempts × maxDelay`. Nothing about a misspelled resource name gets
+ *     truer after eight seconds of backoff.
+ *
+ * The WAIT between attempts is cancellable, for the first reason above. Every
+ * other point in a sequence already is — the kernel refuses a dispatch reached
+ * after the tree was cancelled — so a backoff is the one interval where a
+ * cancelled run would otherwise stay parked, for up to `attempts × maxDelay`.
+ *
+ * The defaults come from the schema (`Run` steps declare `default:` on every
+ * field, as `Http.Request.retry` does), so the `??` fallbacks here are the floor
+ * for a caller that assembled a policy in code rather than from a manifest — not
+ * a second, competing statement of what a default is.
+ */
+async function withStepRetry<T>(
+  step: InvokeStep,
+  invokeCtx: InvokeContext | undefined,
+  dispatch: () => Promise<T>,
+): Promise<T> {
+  const policy = step.retry;
+  const attempts = policy?.attempts ?? 0;
+  if (!policy || attempts <= 0) return dispatch();
+
+  const initial = policy.initialDelay ?? parseDuration(policy.delay) ?? 250;
+  const factor = policy.factor ?? 2;
+  const maxDelay = policy.maxDelay ?? 32_000;
+  const jitter = policy.jitter ?? "full";
+
+  for (let resend = 0; ; resend++) {
+    try {
+      return await dispatch();
+    } catch (err) {
+      if (resend >= attempts || !isRetryable(err)) throw err;
+      const backoff = Math.min(maxDelay, initial * Math.pow(factor, resend));
+      await waitBeforeResend(
+        jitter === "full" ? Math.random() * backoff : backoff,
+        invokeCtx?.cancellation,
+        step,
+        err,
+      );
+    }
+  }
+}
+
+/** Kernel verdicts on the CALL rather than on the work, beyond the ambient
+ *  contract set. A dispatch that cannot resolve its target is a manifest defect;
+ *  re-issuing it re-resolves the same name against the same registry. */
+const UNRETRYABLE_CODES = new Set(["ERR_RESOURCE_NOT_FOUND", "ERR_RESOURCE_NOT_INVOKABLE"]);
+
+function isRetryable(err: unknown): boolean {
+  if (isCancellationError(err)) return false;
+  const code = (err as { code?: unknown } | null | undefined)?.code;
+  if (typeof code !== "string") return true;
+  return !isAmbientContractErrorCode(code) && !UNRETRYABLE_CODES.has(code);
+}
+
+/**
+ * Wait out the backoff, or give up the moment the invocation is cancelled.
+ *
+ * The failure that CAUSED the wait rides in the cancellation's `data`. Without
+ * it, cancelling mid-backoff would report only that the run was cancelled and
+ * the attempt's actual error — the thing the author is retrying because of —
+ * would be gone, which is exactly the swallowing a retry loop is prone to.
+ *
+ * `onCancelled` fires synchronously when the token is already cancelled, so an
+ * already-cancelled run clears the timer and rejects without waiting a tick.
+ */
+function waitBeforeResend(
+  ms: number,
+  token: CancellationToken | undefined,
+  step: InvokeStep,
+  pending: unknown,
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      unsubscribe?.();
+      resolve();
+    }, ms);
+    const unsubscribe = token?.onCancelled((reason) => {
+      clearTimeout(timer);
+      // Released on BOTH paths. The listener is the one thing this holds, and a
+      // subscription outliving the wait it belongs to is a leak per re-attempt.
+      unsubscribe?.();
+      reject(
+        new InvokeError(
+          ERR_INVOKE_CANCELLED,
+          `Step "${step.name}": cancelled while waiting to re-attempt` +
+            `${reason ? ` (${reason})` : ""}.`,
+          { step: step.name, pendingFailure: describeFailure(pending) },
+        ),
+      );
+    });
+  });
+}
+
+function describeFailure(err: unknown): { code?: string; message: string } {
+  const code = (err as { code?: unknown } | null | undefined)?.code;
+  const message = err instanceof Error ? err.message : String(err);
+  return { ...(typeof code === "string" ? { code } : {}), message };
+}
+
+/**
+ * The deprecated `delay` duration string, in milliseconds.
+ *
+ * Delegates to the SDK's one duration grammar rather than restating it: a second
+ * spelling here would accept strings `telo check`'s `pattern` rejects, and the
+ * two would drift. A malformed value THROWS — falling back to the default would
+ * swallow a typo into a silently different backoff, and the schema's `pattern`
+ * means anything reaching this already failed static analysis.
+ */
+function parseDuration(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const ms = tryParseDurationMs(value);
+  if (ms === null) {
+    throw new InvokeError(
+      "ERR_INVALID_VALUE",
+      `Step retry: invalid 'delay' ${JSON.stringify(value)}; use a number with a unit, e.g. ` +
+        `"250ms", "2s", "1.5m", "1h" — or the preferred 'initialDelay', in milliseconds.`,
+    );
+  }
+  return ms;
+}
+
+async function dispatch(
+  raw: unknown,
+  inputs: Record<string, unknown>,
+  ctx: InvokeStepContext,
+  state: InvokeStepState,
+): Promise<unknown> {
   let result: unknown;
 
   if (raw && typeof (raw as Invocable).invoke === "function") {
@@ -119,9 +325,8 @@ export async function executeInvokeStep(
       const instance = state.scope.getInstance(ref.name) as unknown as ResourceInstance;
       result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs);
     } else {
-      result = await ctx.invoke(ref.kind, ref.name, inputs, { retry: step.retry });
+      result = await ctx.invoke(ref.kind, ref.name, inputs);
     }
   }
-
-  state.steps[step.name] = { result };
+  return result;
 }

package/src/resource-context.ts

@@ -61,16 +61,19 @@ export type ParsedArgs = Partial<Record<string, string | boolean | string[]>> &
 /**
  * Per-call options for a by-name dispatch.
  *
- * A bag rather than a positional context parameter because this slot already
- * carried one meaning — `retry`, consumed by the step leaf — and
- * `ResourceContext` satisfies `InvokeStepContext` structurally, so a positional
- * `InvokeContext` here silently receives a step's retry options instead.
+ * A bag rather than a positional context parameter, because `ResourceContext`
+ * satisfies `InvokeStepContext` structurally: a positional fourth argument here
+ * is reachable from the step leaf's own `invoke` call, so the two surfaces would
+ * have to agree on its meaning forever. A named key cannot be filled by accident.
+ *
+ * `retry` USED to live here and was read by nobody — the step leaf handed it down
+ * on one of its four dispatch branches and no kernel path looked at it. It now
+ * belongs to the leaf, which is the one place every branch passes through; a key
+ * kept here would be a second, inert way to ask for the same thing.
  */
 export interface InvokeByNameOptions {
   /** Seeds the invocation context, replacing the ambient. */
   ctx?: InvokeContext;
-  /** Retry policy, read by `executeInvokeStep`. */
-  retry?: unknown;
 }
 
 export interface ResourceContext extends ControllerContext {

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."
     }
   ],