@telorun/sdk 0.77.0 → 0.80.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
@@ -191,6 +214,20 @@ export interface ResourceContext extends ControllerContext {
      * says what was missing.
      */
     resolveRef<T>(value: unknown, guard: (candidate: unknown) => candidate is T, describe: () => string, expects?: string): T;
+    /**
+     * The manifest a name was DECLARED with, resolved in the context that OWNS
+     * this resource — the same order {@link resolveRef} uses, so a declaration
+     * lookup cannot disagree with an instance lookup about what a name means.
+     *
+     * The counterpart to {@link resolveRef} for a slot that wants a FACT about its
+     * target rather than the target itself. A declaration is readable whether or
+     * not the resource has been constructed, which is what lets such a slot avoid
+     * an ordering edge — and what lets a resource read a slot pointing at itself.
+     *
+     * Optional because a third-party context implementation must keep compiling;
+     * absent reads as "no declaration in scope".
+     */
+    resolveDeclaredManifest?(name: string, alias?: string): ResourceManifest | undefined;
     validateSchema(value: any, schema: any): void;
     /** Compile an author-written JSON Schema from a resource field into a
      *  reusable validator, through the runtime's own engine — so its formats and

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,