@telorun/sdk 0.77.0 → 0.79.0

package/dist/invoke-step.js

@@ -1,5 +1,7 @@
-import { ERR_INVOKE_CANCELLED, isCancellationError, } from "./cancellation.js";
+import { ERR_INVOKE_CANCELLED, UNCANCELLABLE_CONTEXT, createCancellationSource, deriveContext, isCancellationError, } from "./cancellation.js";
 import { isAmbientContractErrorCode } from "./contract-errors.js";
+import { durableHandleOf, journalingSuppressed, stepPath, } from "./durable-run.js";
+import { SUSPENDING_BACKOFF_MS, assertMaySuspend, isSuspension, parkRun, } from "./durable-suspension.js";
 import { tryParseDurationMs } from "./duration.js";
 import { InvokeError } from "./invoke-error.js";
 import { getRefIdentity } from "./resource-instance.js";
@@ -13,11 +15,129 @@ export async function executeInvokeStep(step, ctx, state) {
     const cel = { steps: state.steps, ...state.cel };
     if (step.when !== undefined && !ctx.expandValue(step.when, cel))
         return;
-    const inputs = ctx.expandValue(step.inputs ?? {}, cel);
+    const rawHandle = durableHandleOf(state.invokeCtx);
+    // Inside a collapsed region the engine records NOTHING of its own: the region
+    // re-runs whole on resume, so per-step entries would describe work that is
+    // about to happen again. A resource inside it may still journal directly —
+    // which is what lets `Durable.Value` pin an impure evaluation there rather
+    // than be a prescription with nowhere to write.
+    const handle = rawHandle && journalingSuppressed(ctx, state.invokeCtx, rawHandle) ? undefined : rawHandle;
+    const path = state.journalPath ?? step.name;
+    // The RESOLVED inputs are journaled, not re-derived. They are read from a CEL
+    // scope carrying live readings — `resources.<name>.status` is republished on
+    // every dispatch by design — so a fresh process can compute different
+    // arguments for the same step and hand them to a target the journal will then
+    // answer for, with no mismatch to detect.
+    const inputs = (handle
+        ? await handle.decide(stepPath(path, "inputs"), "inputs", () => ctx.expandValue(step.inputs ?? {}, cel))
+        : ctx.expandValue(step.inputs ?? {}, cel));
     const raw = step.invoke;
-    const result = await withStepRetry(step, state.invokeCtx, () => dispatch(raw, inputs, ctx, state));
+    // The dispatch carries THIS step's path, so anything it reaches that runs a
+    // step body of its own hangs those paths under this one rather than starting
+    // over at the root. Set only inside a durable run: outside one there is no
+    // path to carry, and deriving a context would be a rebuild for nothing.
+    // Derived from the RAW handle, not the collapse-suppressed one: collapse
+    // suppresses the engine's own per-step entries, never the journal. A
+    // `Durable.Value` or a parking kind inside a collapsed region still records
+    // directly, and it keys off this path — so dropping it here would give every
+    // such resource in the region ONE key inherited from an enclosing level.
+    const stepCtx = rawHandle && state.invokeCtx
+        ? deriveContext(state.invokeCtx, { durablePath: path })
+        : state.invokeCtx;
+    const execute = () => withStepRetry(step, stepCtx, ctx, rawHandle, path, (attemptCtx) => withStepTimeout(step, attemptCtx, (dispatchCtx) => dispatch(raw, inputs, ctx, { ...state, invokeCtx: dispatchCtx })));
+    // Retry and the timeout sit INSIDE the handed-over effect, not around it: a
+    // re-attempt is part of performing this step once, so a backend that ships the
+    // step elsewhere ships its policy with it rather than re-attempting a remote
+    // dispatch it does not own. This is also what keeps the attempt loop's own
+    // rule intact — the journal records the OUTCOME of the step, and a step whose
+    // third attempt succeeded completed once.
+    const result = handle
+        ? await handle.step(path, targetIdentityOf(raw, ctx, state), inputs, execute)
+        : await execute();
     state.steps[step.name] = { result };
 }
+/**
+ * The target's DECLARATION-SITE identity, for a backend that may execute the
+ * step somewhere the instance does not exist.
+ *
+ * Derived from the `!ref` identity the kernel stamps at Phase-5 injection, which
+ * is the only declaration-site fact a resolved target carries — instance
+ * identity is process-local by construction. Undefined when the step dispatches
+ * something with no stamp (a truly anonymous instance), which a local backend
+ * handles by simply running `execute` and a relocating one must refuse rather
+ * than guess.
+ */
+function targetIdentityOf(raw, ctx, state) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    // A pre-injected instance carries the stamp already.
+    const behind = getRefIdentity(raw) ? undefined : instanceBehind(raw, ctx, state);
+    const stamped = getRefIdentity(raw) ?? (behind && getRefIdentity(behind.instance));
+    const ref = raw;
+    const kind = stamped?.kind ?? (typeof ref.kind === "string" ? ref.kind : undefined);
+    const name = stamped?.name ?? (typeof ref.name === "string" ? ref.name : undefined);
+    if (!kind || !name)
+        return undefined;
+    return {
+        kind,
+        name,
+        // Whether the name resolved inside a `with:` scope, which is knowable HERE
+        // and only here — the resolution is what answers it. The tuple identifying
+        // which scope RUN is not derivable yet, so this is what stops such a target
+        // being encoded as the module-level resource that shares its name.
+        ...(behind?.scoped ? { scoped: true } : {}),
+        // Carried through verbatim: the kernel derived it at the declaration site,
+        // which is the only place it is knowable, and a consumer that must name this
+        // target elsewhere has nothing else to name it with.
+        ...(stamped?.origin?.module === undefined ? {} : { module: stamped.origin.module }),
+        ...(stamped?.origin?.pointer === undefined ? {} : { pointer: stamped.origin.pointer }),
+    };
+}
+/**
+ * The live instance behind a step's `invoke:` REF, when this host can name one.
+ *
+ * A step's slot is not a Phase-5 injection site — it resolves at dispatch — so a
+ * step target arrives as a `{kind, name, alias?}` reference and carries no stamp
+ * of its own. Reading the instance's is what recovers the declaration site, and
+ * the resolution mirrors `dispatch`'s branches exactly so the identity describes
+ * the resource the step will actually reach.
+ *
+ * Reports whether the name resolved inside a `with:` SCOPE as well as what it
+ * resolved to, because that is a fact only the resolution knows and it changes
+ * what the identity means: a scoped name and a module-level one can be the same
+ * string and different resources.
+ *
+ * Best-effort by design: every resolver here is optional, and a host that
+ * supplies none yields an identity of kind and name alone — enough for a local
+ * backend, and refused by a relocating one rather than guessed at.
+ */
+function instanceBehind(raw, ctx, state) {
+    const ref = raw;
+    if (typeof ref.name !== "string")
+        return undefined;
+    try {
+        if (ref.alias && ref.alias !== "Self") {
+            const imported = ctx.resolveImportedInstance?.(ref.alias, ref.name);
+            return imported && { instance: imported, scoped: false };
+        }
+        if (state.scope) {
+            // Scope-local FIRST, enclosing module as the fallback — the order
+            // `ScopeContext.getInstance` and the CEL `resources` layering already use,
+            // so what this reports a name to mean is what the dispatch will reach.
+            const scoped = state.scope.getInstance(ref.name);
+            if (scoped)
+                return { instance: scoped, scoped: true };
+        }
+        const local = ctx.resolveLocalInstance?.(ref.name);
+        return local && { instance: local, scoped: false };
+    }
+    catch {
+        // A resolver that throws is answering "not here", and the dispatch below is
+        // where that becomes an error with a message about the dispatch. Recovering
+        // provenance must not be the thing that reports it.
+        return undefined;
+    }
+}
 /**
  * Re-attempt a step's dispatch while its policy allows.
  *
@@ -48,39 +168,156 @@ export async function executeInvokeStep(step, ctx, state) {
  * 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) {
+async function withStepRetry(step, invokeCtx, ctx, handle, path, 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;
+        return dispatch(invokeCtx);
     const jitter = policy.jitter ?? "full";
     for (let resend = 0;; resend++) {
         try {
-            return await dispatch();
+            return await dispatch(invokeCtx);
         }
         catch (err) {
-            if (resend >= attempts || !isRetryable(err))
+            if (resend >= attempts || !isRetryable(err, policy.nonRetryable))
                 throw err;
-            const backoff = Math.min(maxDelay, initial * Math.pow(factor, resend));
-            await waitBeforeResend(jitter === "full" ? Math.random() * backoff : backoff, invokeCtx?.cancellation, step, err);
+            // The UN-JITTERED backoff, which is a pure function of the declared policy
+            // and the attempt index — and which is therefore what the park decision
+            // below turns on. Deciding on the jittered value instead would put
+            // `Math.random()` on a control-flow branch inside a determinism contract:
+            // the same attempt could sleep on one pass and park on the next, for no
+            // reason a reader of the manifest could see. It would also make the static
+            // check unstateable, since the analyzer cannot know which way a coin
+            // landed. Jitter still does its whole job — spreading re-attempts — on the
+            // duration itself, in both branches.
+            const backoff = retryBackoffMs(policy, resend);
+            const delay = jitter === "full" ? Math.random() * backoff : backoff;
+            // A LONG backoff inside a durable run suspends rather than sleeps, and the
+            // attempt state is journaled with it. The obvious reading — only the
+            // outcome matters, so journal once — is wrong the moment a backoff
+            // suspends: a run that parks mid-retry and resumes in another process must
+            // know which attempt it was on, or it restarts the policy from zero and a
+            // three-attempt cap becomes unbounded.
+            //
+            // ONE DECISION PER ATTEMPT, holding when that attempt was due, is the
+            // whole mechanism. It needs nothing beyond `decide`: on resume the loop
+            // re-runs from attempt zero, each recorded attempt hands back a due time
+            // already in the past and is therefore consumed without waiting, and the
+            // first UNRECORDED attempt computes a fresh one and parks. The budget is
+            // preserved because the replayed attempts still count against it.
+            if (handle && backoff >= SUSPENDING_BACKOFF_MS) {
+                const attemptPath = stepPath(path, "retry", resend);
+                const dueAt = (await handle.decide(attemptPath, "value", () => Date.now() + delay));
+                if (Date.now() < dueAt) {
+                    // Refused inside a region that promised nothing in it suspends. The
+                    // check is here rather than at the policy, because a short backoff
+                    // never suspends and rejecting one would forbid a retry that is
+                    // perfectly safe in a lease.
+                    assertMaySuspend(ctx, invokeCtx, { resource: step.name ?? path });
+                    await parkRun(handle, { path: attemptPath, resource: step.name ?? path }, { at: dueAt });
+                }
+                continue;
+            }
+            await waitBeforeResend(delay, invokeCtx?.cancellation, step, err);
         }
     }
 }
+/**
+ * The backoff before attempt `resend + 1`, before jitter.
+ *
+ * ONE formula, exported because the analyzer needs the same number: it decides
+ * statically whether a step's declared policy would park inside a region that
+ * cannot be held open, and a second copy of exponential-backoff arithmetic in
+ * the analyzer would be a rule that drifts from the behaviour it describes the
+ * first time either side gains a knob.
+ *
+ * Jitter is deliberately NOT applied here. It belongs to the duration, not to
+ * the shape of the policy, and the two consumers want the shape: the runtime
+ * branches on it (see `withStepRetry`) and the analyzer reports on it.
+ *
+ * The `??` fallbacks are the floor for a caller that assembled a policy in code;
+ * a manifest gets its defaults from the schema.
+ */
+export function retryBackoffMs(policy, resend) {
+    const initial = policy.initialDelay ?? parseDuration(policy.delay) ?? 250;
+    const factor = policy.factor ?? 2;
+    const maxDelay = policy.maxDelay ?? 32_000;
+    return Math.min(maxDelay, initial * Math.pow(factor, resend));
+}
 /** 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) {
+function isRetryable(err, nonRetryable) {
     if (isCancellationError(err))
         return false;
+    // A suspension is not a failure — it is the run leaving. Re-attempting it
+    // would park again under the same policy until the budget ran out, and the
+    // last attempt would propagate a park the earlier ones had already recorded.
+    if (isSuspension(err))
+        return false;
     const code = err?.code;
     if (typeof code !== "string")
         return true;
+    // The author's own exclusions, checked beside the built-in ones rather than
+    // before or after them: they are the same question — is re-issuing this call
+    // capable of a different answer — asked about a domain failure the leaf has no
+    // way to classify. A step timeout is never in this set by default; whether a
+    // slow call is worth re-attempting is exactly the judgement an author makes.
+    if (nonRetryable?.includes(code))
+        return false;
     return !isAmbientContractErrorCode(code) && !UNRETRYABLE_CODES.has(code);
 }
+/**
+ * Bound ONE attempt, by cancellation rather than by abandonment.
+ *
+ * A `Promise.race` that simply rejects would leave the call running, holding its
+ * connection and eventually completing a side effect nobody is waiting on — the
+ * failure mode a timeout is usually adopted to prevent. So a timeout mints a
+ * cancellation source, LINKS it to the caller's token (or the caller's
+ * cancellation would stop propagating the moment a step declared a bound), and
+ * threads its context into the dispatch. A target that honours cancellation
+ * stops; one that does not is no worse off than before.
+ *
+ * The elapse is reported as `ERR_STEP_TIMEOUT` rather than as a cancellation,
+ * because the two want opposite follow-ups: a cancelled run was asked to stop,
+ * while a timed-out step is a target that is too slow for this call site — and
+ * `catches:` can only tell them apart if they carry different codes.
+ */
+async function withStepTimeout(step, invokeCtx, dispatch) {
+    const ms = step.timeout;
+    if (ms === undefined || !(ms > 0))
+        return dispatch(invokeCtx);
+    const source = createCancellationSource();
+    const base = invokeCtx ?? UNCANCELLABLE_CONTEXT;
+    // Everything else on the context — zones, tracing, and whatever a later
+    // member adds — rides across unchanged. Rebuilding it as a literal here is
+    // the drop `deriveContext` exists to prevent.
+    const scoped = deriveContext(base, { cancellation: source.token });
+    const unlink = invokeCtx?.cancellation.onCancelled((reason) => source.cancel(reason));
+    let elapsed = false;
+    source.cancelAfter(ms);
+    const timedOut = source.token.onCancelled(() => {
+        if (!invokeCtx?.cancellation.isCancelled)
+            elapsed = true;
+    });
+    try {
+        return await dispatch(scoped);
+    }
+    catch (err) {
+        if (elapsed && isCancellationError(err)) {
+            throw new InvokeError("ERR_STEP_TIMEOUT", `Step '${step.name}' exceeded its timeout of ${ms}ms and was cancelled`, { step: step.name, timeout: ms });
+        }
+        throw err;
+    }
+    finally {
+        timedOut();
+        unlink?.();
+        // Releases the pending deadline timer, so a step that finished early does
+        // not pin a timer alive until its bound elapses.
+        source.dispose();
+    }
+}
 /**
  * Wait out the backoff, or give up the moment the invocation is cancelled.
  *
@@ -134,6 +371,12 @@ function parseDuration(value) {
 }
 async function dispatch(raw, inputs, ctx, state) {
     let result;
+    // The context this attempt runs under: the step's timeout scope when it
+    // declares one, else whatever the composer forwarded. Threaded explicitly
+    // rather than installed as ambient because the SDK leaf has no ambient store
+    // to install into — that is one runtime's mechanism, and a second-language
+    // leaf has no `AsyncLocalStorage`.
+    const attemptCtx = state.invokeCtx;
     if (raw && typeof raw.invoke === "function") {
         // A pre-injected live instance (a `!ref` resolved at Phase 5). Route it
         // through the traced chokepoint using the identity the kernel stamped at
@@ -141,8 +384,8 @@ async function dispatch(raw, inputs, ctx, state) {
         // A truly anonymous instance (no stamp) falls back to a direct call.
         const identity = getRefIdentity(raw);
         result = identity
-            ? await ctx.invokeResolved(identity.kind, identity.name, raw, inputs)
-            : await raw.invoke(inputs);
+            ? await ctx.invokeResolved(identity.kind, identity.name, raw, inputs, attemptCtx)
+            : await raw.invoke(inputs, attemptCtx);
     }
     else {
         const ref = raw;
@@ -154,14 +397,14 @@ async function dispatch(raw, inputs, ctx, state) {
             if (!instance) {
                 throw new Error(`Cross-module reference '${ref.alias}.${ref.name}' did not resolve to an exported instance.`);
             }
-            result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs);
+            result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs, attemptCtx);
         }
         else if (state.scope) {
             const instance = state.scope.getInstance(ref.name);
-            result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs);
+            result = await ctx.invokeResolved(ref.kind, ref.name, instance, inputs, attemptCtx);
         }
         else {
-            result = await ctx.invoke(ref.kind, ref.name, inputs);
+            result = await ctx.invoke(ref.kind, ref.name, inputs, { ctx: attemptCtx });
         }
     }
     return result;

package/dist/resource-context.d.ts

@@ -11,6 +11,7 @@ import { ResourceInstance } from "./resource-instance.js";
 import { ResourceManifest } from "./resource-manifest.js";
 import { RuntimeResource } from "./runtime-resource.js";
 import type { RuntimeSeam } from "./runtime-seam.js";
+import type { OpenZoneAttributes } from "./zone-attribute.js";
 export interface LoadOptions {
     /** When true, `${{ }}` templates are replaced with CompiledValue wrappers
      *  so they can be evaluated at runtime. Leave unset for static analysis. */
@@ -130,6 +131,28 @@ export interface ResourceContext extends ControllerContext {
      *  one). No kind parameter: the provider's own per-instance map already
      *  discriminates — a zone this instance's owner did not open simply misses. */
     zonesFor(instance: ResourceInstance, ctx?: InvokeContext): readonly ZoneEntry[];
+    /**
+     * Every open zone with what it DECLARES about its contents, innermost first —
+     * the runtime half of `x-telo-provides-zone`'s attributes.
+     *
+     * Read off the declaring kind's schema, never off the entry: a
+     * {@link ZoneEntry} is three identities *because* that keeps it
+     * ABI-serializable and stops any module reading another's private state off
+     * the stack, and hanging attributes on it would trade that away for every
+     * zone. The kernel resolves the schema instead — the one place that lookup is
+     * already available — and hands the attributes over WITHOUT branching on a
+     * name, exactly as `readRefSlot` returns `use` without acting on it.
+     *
+     * The vocabulary is closed (`sdk/zone-attributes/`), which is what lets this
+     * be a typed record rather than a string-keyed bag. That is a readability
+     * gain and not a semantic one: interpreting an attribute is entirely the
+     * caller's — the step engine reads `atomic` to decide collapse, a parking kind
+     * reads `noSuspend` to refuse, and the kernel reads neither.
+     *
+     * Each value is the author's REASON, so a controller refusing on an attribute
+     * quotes the manifest's own sentence instead of inventing a generic message.
+     */
+    zoneAttributes(ctx?: InvokeContext): readonly OpenZoneAttributes[];
     /** The root context for runtime-driven inbound work (request, timer, queue
      *  message): inherits nothing from whatever ambient happens to be live at the
      *  registration site — no zones, no trace parent, no caller token. An inbound

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/resource-instance.d.ts

@@ -28,6 +28,26 @@ export declare const TEARDOWN_LAST = 1000;
 export interface RefIdentity {
     kind: string;
     name: string;
+    /**
+     * Where the instance was DECLARED, for a consumer that must name it somewhere
+     * the instance does not exist — a durable step shipped to another process.
+     *
+     * Optional because it is derived from the declaration and an instance stamped
+     * by a path that has none is still dispatchable; a consumer that genuinely
+     * needs it refuses rather than guessing (see `encodeDurableTarget`). Kept ON
+     * the identity rather than in a second table because it answers the same
+     * question the identity does — *which declaration is this* — one level more
+     * precisely.
+     */
+    origin?: RefOrigin;
+}
+/** The declaration site behind a live instance. `module` is the source of the
+ *  module that declared it, which is what tells two libraries' same-named
+ *  resources apart; `pointer` is set when the declaration is inline, and is a
+ *  JSON pointer into its declaring resource. */
+export interface RefOrigin {
+    module?: string;
+    pointer?: string;
 }
 /**
  * Kernel-minted, unique per LIVE instance, stable for its lifetime. Distinct
@@ -59,7 +79,7 @@ export declare const sameResource: (a: ResourceHandle, b: ResourceHandle) => boo
 export declare const REF_IDENTITY: unique symbol;
 /** Stamp the resolved kind+name onto an injected instance. Idempotent — an
  *  instance has exactly one identity, so re-injection into other slots is a no-op. */
-export declare function stampRefIdentity(instance: object, kind: string, name: string): void;
+export declare function stampRefIdentity(instance: object, kind: string, name: string, origin?: RefOrigin): void;
 /** Read the identity stamped by {@link stampRefIdentity}, if any. */
 export declare function getRefIdentity(instance: object): RefIdentity | undefined;
 //# sourceMappingURL=resource-instance.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resource-instance.d.ts","sourceRoot":"","sources":["../src/resource-instance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,CACjF,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAC3B,GACC,OAAO,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG;IAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,QAAQ,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAChE;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEJ;;mBAEmB;AACnB,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAErF;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,kBAAkB,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,KAAG,OAAwB,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,OAAO,MAAuC,CAAC;AAE1E;sFACsF;AACtF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CASnF;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAExE"}
+{"version":3,"file":"resource-instance.d.ts","sourceRoot":"","sources":["../src/resource-instance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,CACjF,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAC3B,GACC,OAAO,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG;IAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,QAAQ,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAChE;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEJ;;mBAEmB;AACnB,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED;;;gDAGgD;AAChD,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAErF;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,kBAAkB,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,KAAG,OAAwB,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,OAAO,MAAuC,CAAC;AAE1E;sFACsF;AACtF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,SAAS,GACjB,IAAI,CAaN;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAExE"}

package/dist/resource-instance.js

@@ -13,10 +13,14 @@ export const sameResource = (a, b) => a.id === b.id;
 export const REF_IDENTITY = Symbol.for("telo.refIdentity");
 /** Stamp the resolved kind+name onto an injected instance. Idempotent — an
  *  instance has exactly one identity, so re-injection into other slots is a no-op. */
-export function stampRefIdentity(instance, kind, name) {
+export function stampRefIdentity(instance, kind, name, origin) {
     if (!(REF_IDENTITY in instance)) {
         Object.defineProperty(instance, REF_IDENTITY, {
-            value: { kind, name },
+            value: {
+                kind,
+                name,
+                ...(origin && (origin.module || origin.pointer) ? { origin } : {}),
+            },
             enumerable: false,
             configurable: true,
             writable: false,

package/dist/step-engine.d.ts

@@ -0,0 +1,170 @@
+/**
+ * The step grammar and its execution: `invoke` / `value` / `if` / `while` /
+ * `switch` / `try` / `throw`, the `steps.<name>.result` accumulator, and the
+ * nested-scope walk that resolves an inline `invoke:` into a named resource.
+ *
+ * WHY THE SDK OWNS THIS. The leaf ({@link executeInvokeStep}) has always lived
+ * here; everything above it lived in `modules/run` for no reason anyone chose,
+ * and that is what made a step body something only `run`'s own kinds could have.
+ * `@telorun/sdk` is the single name in the bundle loader's `REALM_COLLAPSE_NAMES`
+ * — symlinked onto the KERNEL's own copy rather than inlined — so it is one
+ * version per process whatever anyone pins, and it is reachable from a controller
+ * bundle and from the kernel's own boot runner alike. A module library
+ * (`exports.code:`) is no longer copied per consumer, but it is still one scope
+ * per pinned version, it is outside the seam entirely for an npm-delivered
+ * controller, and the kernel cannot reach one at all. For a component whose
+ * contract is determinism across a durable run, one implementation is the whole
+ * premise.
+ *
+ * The context is STRUCTURAL ({@link StepEngineContext}), the property the leaf
+ * already proved: `ResourceContext` satisfies it, and so does a kernel-side
+ * adapter. Nothing here imports the kernel or `run`.
+ */
+import type { InvokeContext } from "./cancellation.js";
+import { type InvokeStep, type InvokeStepContext } from "./invoke-step.js";
+import type { KindRef, ScopeContext } from "./ref.js";
+/**
+ * What the engine needs beyond the leaf's own contract: turning an inline
+ * `invoke: { kind, … }` into a named reference.
+ *
+ * Widened from {@link InvokeStepContext} rather than replaced, so one interface
+ * describes a step site whether or not control flow is involved. Satisfied
+ * structurally by `ResourceContext`; a host that composes steps in code supplies
+ * its own.
+ */
+export interface StepEngineContext extends InvokeStepContext {
+    ensureKindRef(value: any, resourceName?: string): KindRef;
+}
+export interface IfStep {
+    name: string;
+    if: string;
+    then: Step[];
+    elseif?: Array<{
+        if: string;
+        then: Step[];
+    }>;
+    else?: Step[];
+}
+export interface WhileStep {
+    name: string;
+    while: string;
+    do: Step[];
+}
+export interface SwitchStep {
+    name: string;
+    switch: string;
+    cases: Record<string, Step[]>;
+    default?: Step[];
+}
+export interface TryStep {
+    name: string;
+    when?: string;
+    try: Step[];
+    catch?: Step[];
+    finally?: Step[];
+}
+export interface ThrowStep {
+    name: string;
+    throw: {
+        code: string;
+        message?: string;
+        data?: unknown;
+    };
+}
+export interface ValueStep {
+    name: string;
+    value: unknown;
+}
+export type Step = InvokeStep | IfStep | WhileStep | SwitchStep | TryStep | ThrowStep | ValueStep;
+/** Code assigned to any caught failure that is not a structured `InvokeError`.
+ *  Guarantees `error.code` is always a non-empty string inside a `catch`, so a
+ *  `throw: { code: "${{ error.code }}" }` rethrow can never resolve to null.
+ *  The analyzer's throws resolver mirrors this constant. */
+export declare const PLAIN_ERROR_CODE = "INTERNAL_ERROR";
+/** The `error` variable a `catch:` / `catches:` branch sees. */
+export interface SequenceError {
+    message: string;
+    code: string;
+    data?: unknown;
+    step: string;
+}
+/**
+ * Who is running this body — the two facts the generated name of an inline
+ * `invoke:` is built from.
+ *
+ * Taken as identity rather than as a finished prefix because that name is
+ * MANIFEST-VISIBLE topology: it is what `steps.<name>.result`, a trace span and
+ * an `ERR_RESOURCE_NOT_FOUND` all print. Every caller used to spell the recipe
+ * itself (`` `Iteration${pascalCase(name)}` ``), which is the half of a
+ * must-not-fork component that forked anyway — the fifth composer would get the
+ * casing subtly wrong, or collide with the fourth.
+ */
+export interface StepBodyOwner {
+    /** The owning kind's suffix (`Sequence`, `Iteration`, `Transaction`). */
+    kind: string;
+    /** The owning resource's `metadata.name`. */
+    resourceName: string;
+}
+/** Runs a step list against an `extraCtx` CEL scope, owning the full grammar —
+ *  `invoke` / `value` / `if` / `while` / `switch` / `try` / `throw`. A composing
+ *  kind injects its own scope variables (`item`, `index`, `iteration`,
+ *  `previous`, …) through `extraCtx`; the engine knows none of them. */
+export declare class StepEngine {
+    private readonly ctx;
+    /** Prefix for generated inline-invoke resource names; unique per host resource
+     *  (`SequenceMySeq`, `LoopPollUntilReady`). */
+    private readonly namePrefix;
+    constructor(ctx: StepEngineContext, owner: StepBodyOwner);
+    resolveInvokes(stepList: Step[], path?: string[]): void;
+    private inlineInvokeResourceName;
+    /**
+     * @param path Journal key prefix for this list — see {@link stepPath}. A
+     *   composer that repeats a body (an iteration element, a loop turn) qualifies
+     *   it with the index, which is what makes each repetition an independently
+     *   resumable subtree. Omitted, it is derived from the ambient step path, so a
+     *   NESTED body nests its keys instead of restarting at the root — see
+     *   {@link baseStepPath}.
+     */
+    executeSteps(stepList: Step[], steps: Record<string, unknown>, scope: ScopeContext | undefined, extraCtx: Record<string, unknown>, invokeCtx?: InvokeContext, path?: string): Promise<void>;
+    /**
+     * The journal key of one step.
+     *
+     * Composed from the WRITTEN structure — the enclosing list's path plus this
+     * step's own name — never from execution order. A per-run call ordinal would
+     * be simpler and is wrong: two branches of a concurrent fan-out interleave
+     * their dispatches, so an ordinal numbers them differently on every run while
+     * these paths stay fixed.
+     */
+    private pathOf;
+    /** The run handle to journal through, or undefined when this body is not
+     *  inside a durable run — in which case the engine behaves exactly as it did
+     *  before durability existed, and pays nothing for it. */
+    private handle;
+    /**
+     * Evaluate a control-flow decision, journaling it when a run is durable.
+     *
+     * EVERY decision goes through here, which is the closure property the whole
+     * design rests on: a predicate, a loop condition and a switch key are all read
+     * from a CEL scope carrying live readings, so re-deriving one in a fresh
+     * process can send the replay down a different branch than the run took —
+     * silently, because the journal would then hand back a recorded result under a
+     * key the run reached for a different reason.
+     */
+    private decide;
+    private executeStep;
+    private executeIfStep;
+    private executeWhileStep;
+    private executeSwitchStep;
+    /** A pure step: expand the expression in the step scope and publish it as
+     *  `steps.<name>.result`, the same shape an invoke step records — so a
+     *  downstream step cannot tell how the value was produced. Nothing is
+     *  dispatched, so there is no span and no topology edge. */
+    private executeValueStep;
+    private executeThrowStep;
+    private executeTryStep;
+}
+/** Normalize any caught failure to the `error` shape a `catch:` branch reads.
+ *  Shared with the composers' whole-operation `catches:`, so one caught failure
+ *  has one shape wherever it is read. */
+export declare function toSequenceError(err: unknown, stepName: string): SequenceError;
+//# sourceMappingURL=step-engine.d.ts.map

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

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