@restatedev/restate-sdk-gen 1.15.0-rc.1 → 1.15.0-rc.2

package/README.md

@@ -72,7 +72,8 @@ Imported directly from `@restatedev/restate-sdk-gen`:
 - **`sleep(duration)`** — journaled timer.
 - **`awakeable<T>()`** — journaled awakeable; returns `{ id, promise: Future<T> }`.
 - **`channel<T>()`** — single-shot in-memory `Channel<T>`.
-- **`state<T>()` / `sharedState<T>()`** — typed key-value store.
+- **`state<T>()` / `sharedState<T>()`** — typed key-value store (durable, survives across invocations).
+- **`contextLocal<T>(default?)`** — ambient, in-memory storage scoped to the current invocation and shared by every fiber under it. Set once near the top, read anywhere downstream without threading a parameter. Not durable — for state that must outlive the invocation, use `state()`.
 - **`serviceClient` / `objectClient` / `workflowClient`** (+ `*SendClient`) — typed RPC into other Restate services.
 - **`genericCall` / `genericSend`** — untyped RPC.
 - **`cancel(invocationId)`** — cancel another invocation.
@@ -83,7 +84,8 @@ Imported directly from `@restatedev/restate-sdk-gen`:
 - **`all(futures)`** — wait for every future, return their values in order. Heterogeneous-tuple typed (mirrors `Promise.all`).
 - **`race(futures)`** — return the first to settle; the losing routines are abandoned once the main operation settles (under the default `onMainExit: "abandon"`), so their results are discarded. Under `onMainExit: "join"` the losers keep running and a loser parked on a never-settling source keeps the handler alive (see Cancellation).
 - **`select({ tag1: future1, tag2: future2, ... })`** — Tokio/Go-style. Returns `{ tag, future }` of the winning branch; switch on `tag` and unwrap `future`.
-- **`spawn(op)`** — register an `Operation` as a new routine; returns a `Future<T>` for its result. Under the default `onMainExit: "abandon"`, a spawned routine still running when the main operation settles is abandoned — fire-and-forget spawns are **not** guaranteed to complete. To ensure completion, `yield*` the returned future before returning, or run with `{ onMainExit: "join" }`.
+- **`spawn(op)`** — register an `Operation` as a new routine; returns a `Task<T>` (a `Future<T>` plus `interrupt(err?)`). Under the default `onMainExit: "abandon"`, a spawned routine still running when the main operation settles is abandoned — fire-and-forget spawns are **not** guaranteed to complete. To ensure completion, `yield*` the returned future before returning, or run with `{ onMainExit: "join" }`.
+- **`task.interrupt(err?)`** — throw `err` into a spawned routine at its next yield point (verbatim; a default `InterruptedError` if omitted) and abort its in-flight `run` I/O. **Cascades down the spawn subtree** — every routine the task spawned (transitively) is interrupted too, with the same error, so interrupting a parent winds down the whole tree it rooted; routines spawned elsewhere are untouched. The routine's own try/catch may catch and recover (interrupt is swallowable). Under the default `onMainExit: "abandon"`, interrupt-then-return abandons the routine before its cleanup runs — interrupt then `yield*` the task ("interrupt-then-join") to drive its `catch`/`finally`.
 
 Combinators have a fast path: when every input Future is journal-backed, they collapse to a single `RestatePromise.all/race`. Otherwise they fall back to a synthesized fiber. Same semantics either way.
 

package/dist/index.cjs

@@ -172,11 +172,12 @@ const any = (futures) => currentOps().any(futures);
 */
 const allSettled = (futures) => currentOps().allSettled(futures);
 /**
-* Register `op` as a fresh routine and return a `Future<T>` for its
-* eventual outcome. Eager — the child is already in flight by the time
-* `spawn` returns. A spawned routine still running when the main
-* operation settles is abandoned by default (see `OnMainExit`). See
-* `RestateOperations.spawn` for full semantics.
+* Register `op` as a fresh routine and return a `Task<T>` for its
+* eventual outcome — a `Future<T>` plus `interrupt(err?)` to throw into
+* the routine at its next yield point. Eager — the child is already in
+* flight by the time `spawn` returns. A spawned routine still running
+* when the main operation settles is abandoned by default (see
+* `OnMainExit`). See `RestateOperations.spawn` for full semantics.
 */
 const spawn = (op) => currentOps().spawn(op);
 
@@ -216,6 +217,43 @@ function* select(branches) {
 	};
 }
 
+//#endregion
+//#region src/context.ts
+function contextLocal(defaultValue) {
+	const key = Symbol("restate.contextLocal");
+	return {
+		get: () => getCurrent().getLocal(key, defaultValue),
+		set: (value) => getCurrent().setLocal(key, value)
+	};
+}
+
+//#endregion
+//#region src/task.ts
+/**
+* The default error thrown by `interrupt()` when no explicit error is
+* given. A plain `Error` (not a `TerminalError`) — interrupt imposes no
+* blast radius of its own; if you want an uncaught interrupt to fail the
+* invocation terminally, pass a `TerminalError` to `interrupt(err)`.
+*/
+var InterruptedError = class extends Error {
+	constructor(message = "Task interrupted") {
+		super(message);
+		this.name = "InterruptedError";
+	}
+};
+/**
+* Augment a spawned routine's Future with `interrupt`, producing a Task.
+* Takes a plain `(err) => void` callback (the fiber's `interrupt`) rather
+* than the Fiber itself, so this module stays free of scheduler/fiber
+* imports. `Object.assign` mutates and returns the same Future object —
+* its `[Symbol.iterator]` and symbol-keyed backing are untouched, so the
+* Task remains fully yieldable and composable.
+*/
+function makeTask(future, interruptFiber) {
+	const interrupt = (err) => interruptFiber(err === void 0 ? new InterruptedError() : err);
+	return Object.assign(future, { interrupt });
+}
+
 //#endregion
 //#region src/future.ts
 const futureBacking = Symbol("restateFutureBacking");
@@ -243,6 +281,29 @@ function isJournalBacked(f) {
 	return getBacking(f).kind === "journal";
 }
 
+//#endregion
+//#region src/abort.ts
+/**
+* Create a controller whose signal is a child of `parent`: pre-aborted
+* if the parent has already fired, otherwise aborted the moment it does.
+*
+* The subscription uses `{ once, signal: c.signal }` so it self-detaches
+* on either exit — when the parent fires (`once`) or when this controller
+* is aborted by some other path (`signal`). A controller that is retired
+* and replaced therefore drops its listener immediately, so at most one
+* listener per child lives on the parent at a time — no accumulation
+* across cancel/recover or interrupt/recover cycles.
+*/
+function linkAbortController(parent) {
+	const c = new AbortController();
+	if (parent.aborted) c.abort(parent.reason);
+	else parent.addEventListener("abort", () => c.abort(parent.reason), {
+		once: true,
+		signal: c.signal
+	});
+	return c;
+}
+
 //#endregion
 //#region src/fiber.ts
 var Fiber = class {
@@ -253,9 +314,45 @@ var Fiber = class {
 		resume: null
 	};
 	waiters = [];
-	constructor(op, sched) {
+	/**
+	* Monotonic park-episode id, bumped on every `wake` (invariant I2).
+	* Consumed by `epochGuarded` (waiter validity) and `wokenDuringStep`
+	* (self-interrupt detection). Generalizes the old per-AwaitRace `won`
+	* flag into a persistent, per-fiber guard.
+	*/
+	epoch = 0;
+	/**
+	* Whether the generator has been started (`it.next()` called at least
+	* once). `it.throw()` on a not-yet-started generator propagates the
+	* error out *without* running any body code, bypassing the routine's
+	* own try/catch/finally — so an interrupt delivered before the first
+	* advance must prime the generator first (see `stepIterator`).
+	*/
+	started = false;
+	/**
+	* Lazily-created AbortController for this fiber's `run` closures. Born
+	* a child of the scheduler's current signal (so invocation cancellation
+	* / attempt-end abort it) and aborted directly by `interrupt`. Recreated
+	* when aborted, so cleanup `run`s after a swallowed interrupt see a
+	* fresh, unaborted signal. Null until the fiber first needs a run signal.
+	*/
+	runController = null;
+	/**
+	* Spawn-tree links. `parent` is the fiber that was advancing when this
+	* one was created; `children` are the fibers it spawned (including the
+	* synth fibers behind combinator fallbacks). `interrupt` cascades down
+	* `children`. On `finish`, a fiber's still-live children are re-homed
+	* onto its `parent` (not dropped) so the subtree stays connected to a
+	* live ancestor and a later cascade still reaches them — `parent` is
+	* therefore reassignable as ancestors complete.
+	*/
+	parent;
+	children = /* @__PURE__ */ new Set();
+	constructor(op, sched, parent = null) {
 		this.it = op[Symbol.iterator]();
 		this.sched = sched;
+		this.parent = parent;
+		parent?.children.add(this);
 	}
 	isDone() {
 		return this.state.kind === "done";
@@ -295,9 +392,13 @@ var Fiber = class {
 	* notifies the scheduler. May be called from any state except done
 	* (waking a done fiber is a programming error and is ignored
 	* defensively).
+	*
+	* Bumps the park epoch so any waiters left registered on the targets
+	* of the park we're leaving become stale no-ops (see `epoch`).
 	*/
 	wake(resume) {
 		if (this.state.kind === "done") return;
+		this.epoch++;
 		this.state = {
 			kind: "ready",
 			resume
@@ -305,6 +406,72 @@ var Fiber = class {
 		this.sched.markReady(this);
 	}
 	/**
+	* Wrap a handler as a waiter that fires only while the fiber is still
+	* in the park episode that registered it (see `epoch`, invariant I2).
+	* A waiter left on a target after the fiber moved on — a re-park after
+	* interrupt, or a losing race source — becomes a no-op. This is the
+	* single mechanism behind both the AwaitRace "first source wins" dedup
+	* and the cross-episode stale-waiter guard.
+	*/
+	epochGuarded(handler) {
+		const at = this.epoch;
+		return (s) => {
+			if (this.epoch !== at) return;
+			handler(s);
+		};
+	}
+	/**
+	* Whether a re-entrant `wake` fired during the step that began at
+	* `epochBefore` — i.e. the fiber interrupted *itself* while advancing
+	* (the only wake that can target the currently-advancing fiber). It
+	* leaves a fresh resume in `this.state` to deliver at this yield rather
+	* than parking on the op the body just produced.
+	*/
+	wokenDuringStep(epochBefore) {
+		return this.epoch !== epochBefore && this.state.kind === "ready";
+	}
+	/**
+	* The AbortSignal handed to this fiber's `run` closures. Lazily
+	* created as a child of the scheduler's current signal, so invocation
+	* cancellation and attempt-end abort it like before; additionally,
+	* `interrupt` aborts it directly to stop just this fiber's in-flight
+	* I/O. Recreated once aborted, so a `run` issued after a swallowed
+	* interrupt (or after cancellation recovery) gets a fresh signal.
+	*/
+	runSignal() {
+		if (this.runController === null || this.runController.signal.aborted) this.runController = linkAbortController(this.sched.abortSignal);
+		return this.runController.signal;
+	}
+	/**
+	* Throw `err` into this fiber at its next yield point, and abort its
+	* in-flight `run` I/O.
+	*
+	* Two effects: (1) abort the per-fiber run signal so an in-flight
+	* `run(fetch(url, { signal }))` stops promptly — harmless if the fiber
+	* has no live controller; the next `runSignal()` makes a fresh one for
+	* post-interrupt cleanup. (2) wake the fiber with a failure resume so
+	* `stepIterator` delivers `it.throw(err)` at the next advance — the
+	* fiber's own try/catch may catch and recover (interrupt is
+	* swallowable / non-sticky). A done fiber is left untouched (`wake`
+	* no-ops). Same machinery as the cancellation fan-out, scoped to one
+	* fiber.
+	*
+	* Self-interrupt (a fiber interrupting its own task while advancing)
+	* is uniform: the re-entrant `wake` fires during the fiber's own
+	* step, and `advance` detects the epoch bump and delivers the throw at
+	* the fiber's next yield rather than parking (see `advance`). If the
+	* body returns before reaching another yield, the self-interrupt is
+	* moot — there is no yield point to throw at.
+	*/
+	interrupt(err) {
+		this.runController?.abort(err);
+		this.wake({
+			ok: false,
+			e: err
+		});
+		for (const child of this.children) child.interrupt(err);
+	}
+	/**
 	* Drive the fiber's iterator until it parks (yields a primitive
 	* whose dispatch ends with the fiber waiting on a source) or
 	* finishes (returns or throws).
@@ -318,9 +485,10 @@ var Fiber = class {
 		try {
 			let resume = this.state.resume;
 			while (true) {
+				const epochBefore = this.epoch;
 				let next;
 				try {
-					next = stepIterator(this.it, resume);
+					next = stepIterator(this.it, resume, this.started);
 				} catch (e) {
 					this.finish({
 						ok: false,
@@ -328,6 +496,7 @@ var Fiber = class {
 					});
 					return;
 				}
+				this.started = true;
 				if (next.done) {
 					this.finish({
 						ok: true,
@@ -335,6 +504,10 @@ var Fiber = class {
 					});
 					return;
 				}
+				if (this.wokenDuringStep(epochBefore)) {
+					resume = this.state.resume;
+					continue;
+				}
 				const node = next.value[opTag];
 				let outcome;
 				switch (node._tag) {
@@ -371,7 +544,7 @@ var Fiber = class {
 			};
 			return null;
 		}
-		const settled = backing.target.awaitCompletion((s) => this.wake(s));
+		const settled = backing.target.awaitCompletion(this.epochGuarded((s) => this.wake(s)));
 		if (settled !== null) return settled;
 		this.state = {
 			kind: "parked",
@@ -385,11 +558,13 @@ var Fiber = class {
 	* (wrapped as Settled) on short-circuit, or null if parked.
 	*
 	* On the parked path, every source registers a one-shot fire
-	* callback that wakes the fiber with `{index, settled}`. The `won`
-	* flag guards against duplicate wakes when multiple sources settle
-	* in the same tick. Local sources (fibers, channels) park on the
-	* target's waiter list; journal sources race in the main loop's
-	* race promise.
+	* callback that wakes the fiber with `{index, settled}`. The epoch
+	* guard ensures only the first source to settle wakes the fiber
+	* (`wake` bumps the epoch, so any later same-tick fire sees a stale
+	* epoch and no-ops) and that a waiter surviving an interrupt-and-
+	* re-park can't fire onto the moved-on fiber. Local sources (fibers,
+	* channels) park on the target's waiter list; journal sources race in
+	* the main loop's race promise.
 	*/
 	parkOnAwaitRace(futures) {
 		for (let i = 0; i < futures.length; i++) {
@@ -402,22 +577,17 @@ var Fiber = class {
 				}
 			};
 		}
-		let won = false;
 		const promises = [];
 		for (let i = 0; i < futures.length; i++) {
 			const idx = i;
 			const b = getBacking(futures[i]);
-			const fireOnce = (settled) => {
-				if (won) return;
-				won = true;
-				this.wake({
-					ok: true,
-					v: {
-						index: idx,
-						settled
-					}
-				});
-			};
+			const fireOnce = this.epochGuarded((settled) => this.wake({
+				ok: true,
+				v: {
+					index: idx,
+					settled
+				}
+			}));
 			if (b.kind === "local") b.target.awaitCompletion(fireOnce);
 			else promises.push({
 				promise: b.promise,
@@ -439,6 +609,13 @@ var Fiber = class {
 			kind: "done",
 			settled
 		};
+		const gp = this.parent;
+		for (const child of this.children) {
+			child.parent = gp;
+			gp?.children.add(child);
+		}
+		this.children.clear();
+		gp?.children.delete(this);
 		const waiters = this.waiters;
 		this.waiters = [];
 		for (const w of waiters) w(settled);
@@ -451,10 +628,23 @@ var Fiber = class {
 * very first step; `{ok: true, v}` resumes with a value; `{ok: false,
 * e}` throws into the iterator (or, if the iterator has no `throw`
 * method, rethrows so the fiber fails).
+*
+* `started` is whether the generator has run at least once. Throwing
+* into a *not-yet-started* generator propagates the error straight out
+* without executing any body code (its try/catch/finally never engage).
+* That happens when a spawned routine is interrupted before its first
+* advance. To honor the "delivered at the next yield point" /
+* swallowable contract, we prime the generator with one `next()` first,
+* so the throw lands at the body's first yield. If the body returns
+* before reaching a yield, there is no yield point and the throw is moot.
 */
-function stepIterator(it, resume) {
+function stepIterator(it, resume, started) {
 	if (resume === null) return it.next(void 0);
 	if (resume.ok) return it.next(resume.v);
+	if (!started) {
+		const first = it.next(void 0);
+		if (first.done) return first;
+	}
 	if (it.throw) return it.throw(resume.e);
 	throw resume.e;
 }
@@ -524,6 +714,13 @@ var Scheduler = class {
 	* production `execute()` always constructs a fresh scheduler.
 	*/
 	main = null;
+	/**
+	* The fiber currently being advanced by `drainReady`, or null between
+	* advances. `run` reads this (via `currentRunSignal`) to hand a `run`
+	* closure the *current fiber's* signal rather than a single global one,
+	* so a targeted `interrupt` aborts only that fiber's in-flight I/O.
+	*/
+	advancingFiber = null;
 	abortController;
 	/**
 	* Parent AbortSignal supplied at construction (production: the SDK's
@@ -546,6 +743,16 @@ var Scheduler = class {
 	* keep this module independent of `restate-operations.ts`.
 	*/
 	contextSlot;
+	/**
+	* Context-local storage: an ambient key/value bag scoped to this
+	* scheduler — i.e. to this one `execute()` call, since production
+	* builds a fresh scheduler per invocation (like `fibers` / `ready` /
+	* `abortController`, this is per-run state, not shared across runs).
+	* Every fiber under this scheduler reaches the same bag (global-per-
+	* invocation; see `context.ts`). Keyed by the opaque symbol a
+	* `contextLocal()` handle owns. In-memory only — never journaled.
+	*/
+	localStore = /* @__PURE__ */ new Map();
 	constructor(lib, parentSignal, options) {
 		this.lib = lib;
 		this.onMainExit = options?.onMainExit ?? "abandon";
@@ -580,13 +787,18 @@ var Scheduler = class {
 	* attempt itself is over — a parent abort is sticky.
 	*/
 	newAbortController() {
-		const c = new AbortController();
-		if (this.parentSignal.aborted) c.abort(this.parentSignal.reason);
-		else this.parentSignal.addEventListener("abort", () => c.abort(this.parentSignal.reason), {
-			once: true,
-			signal: c.signal
-		});
-		return c;
+		return linkAbortController(this.parentSignal);
+	}
+	/**
+	* The AbortSignal for the currently-advancing fiber's `run` closures —
+	* scoped per fiber so a targeted `interrupt(task)` aborts only that
+	* task's in-flight I/O, while invocation cancellation / attempt-end
+	* still cascade in (the fiber signal is a child of `abortSignal`).
+	* Falls back to the scheduler signal when no fiber is advancing (a
+	* defensive case — `run` is always called from inside a fiber).
+	*/
+	currentRunSignal() {
+		return this.advancingFiber !== null ? this.advancingFiber.runSignal() : this.abortSignal;
 	}
 	markReady(f) {
 		this.ready.push(f);
@@ -595,7 +807,7 @@ var Scheduler = class {
 		this.fibers.delete(f);
 	}
 	createFiber(op) {
-		const f = new Fiber(op, this);
+		const f = new Fiber(op, this, this.advancingFiber);
 		this.fibers.add(f);
 		this.ready.push(f);
 		return f;
@@ -607,24 +819,44 @@ var Scheduler = class {
 		});
 	}
 	/**
-	* Register an Operation as a fresh fiber and return a Future that
-	* resolves with its eventual value. Eager: by the time this returns,
-	* the fiber is queued ready and will be advanced on the next drain.
+	* Register an Operation as a fresh fiber, returning both its
+	* local-backed Future and the underlying Fiber. Eager: by the time
+	* this returns, the fiber is queued ready and will be advanced on the
+	* next drain.
 	*
 	* Lifetime is bounded by the main fiber under the default
 	* `"abandon"` policy: a spawned fiber still running when the main
 	* fiber settles is abandoned (see {@link OnMainExit}). Under
 	* `"join"` it keeps the scheduler alive until it finishes.
 	*
-	* Used by combinator fallbacks (race, allSettled, …), by
-	* `RestateOperations.spawn`, and via the slot interface by the free
-	* `spawn` function.
+	* Internal: combinator fallbacks (race, allSettled, …) use this to get
+	* a plain Future. The public `spawn` wraps the same pair into a `Task`.
+	*/
+	spawnRoutine(op) {
+		const fiber = this.createFiber(op);
+		return {
+			future: makeFuture({
+				kind: "local",
+				target: fiber
+			}),
+			fiber
+		};
+	}
+	/** Spawn returning just the Future — for combinator fallbacks, which
+	*  never expose `interrupt` on their synthesized fibers. */
+	spawnFuture(op) {
+		return this.spawnRoutine(op).future;
+	}
+	/**
+	* Register an Operation as a fresh fiber and return a `Task<U>` — a
+	* `Future<U>` for its eventual value, plus `interrupt(err?)` to throw
+	* into it at its next yield point. Eager: by the time this returns the
+	* fiber is queued ready. Reached by `RestateOperations.spawn` and the
+	* free `spawn` function.
 	*/
 	spawn(op) {
-		return makeFuture({
-			kind: "local",
-			target: this.createFiber(op)
-		});
+		const { future, fiber } = this.spawnRoutine(op);
+		return makeTask(future, (err) => fiber.interrupt(err));
 	}
 	/**
 	* Construct a single-shot in-memory channel. Send must be called from
@@ -635,6 +867,19 @@ var Scheduler = class {
 		return makeChannel();
 	}
 	/**
+	* Read a context-local value, or `fallback` if `key` was never set in
+	* this invocation. `has`-checked so an explicit `setLocal(key,
+	* undefined)` reads back as `undefined` rather than falling through to
+	* the handle's default.
+	*/
+	getLocal(key, fallback) {
+		return this.localStore.has(key) ? this.localStore.get(key) : fallback;
+	}
+	/** Write a context-local value for the rest of this invocation. */
+	setLocal(key, value) {
+		this.localStore.set(key, value);
+	}
+	/**
 	* Combinator over Futures. Fast path when every input is journal-
 	* backed: use the lib's all/race for a single combinator entry.
 	* Otherwise, fall back to a synthesized fiber that yields each in
@@ -651,7 +896,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.all(promises));
 		}
-		return this.spawn(gen(function* () {
+		return this.spawnFuture(gen(function* () {
 			const out = new Array(fs.length);
 			for (let i = 0; i < fs.length; i++) out[i] = yield* fs[i];
 			return out;
@@ -659,7 +904,7 @@ var Scheduler = class {
 	}
 	race(futures) {
 		const fs = futures;
-		return this.spawn(gen(function* () {
+		return this.spawnFuture(gen(function* () {
 			const result = yield* awaitRace(fs);
 			if (result.settled.ok) return result.settled.v;
 			throw result.settled.e;
@@ -686,7 +931,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.any(promises));
 		}
-		return this.spawn(gen(function* () {
+		return this.spawnFuture(gen(function* () {
 			const errors = new Array(fs.length);
 			const remaining = /* @__PURE__ */ new Set();
 			for (let i = 0; i < fs.length; i++) remaining.add(i);
@@ -720,7 +965,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.allSettled(promises));
 		}
-		return this.spawn(gen(function* () {
+		return this.spawnFuture(gen(function* () {
 			const out = new Array(fs.length);
 			for (let i = 0; i < fs.length; i++) try {
 				out[i] = {
@@ -748,7 +993,16 @@ var Scheduler = class {
 		return this.onMainExit === "abandon" && this.main !== null && this.main.isDone();
 	}
 	drainReady() {
-		while (this.ready.length > 0 && !this.mainExited()) this.ready.shift().advance();
+		while (this.ready.length > 0 && !this.mainExited()) {
+			const f = this.ready.shift();
+			const prev = this.advancingFiber;
+			this.advancingFiber = f;
+			try {
+				f.advance();
+			} finally {
+				this.advancingFiber = prev;
+			}
+		}
 	}
 	/**
 	* Run an operation to completion. Drain the ready queue, then loop:
@@ -1032,6 +1286,12 @@ var RestateOperations = class {
 	isProcessing() {
 		return this.ctx.isProcessing();
 	}
+	getLocal(key, fallback) {
+		return this.sched.getLocal(key, fallback);
+	}
+	setLocal(key, value) {
+		this.sched.setLocal(key, value);
+	}
 	/**
 	* Run a side-effecting closure as a journal entry.
 	*
@@ -1073,7 +1333,7 @@ var RestateOperations = class {
 	*/
 	run(action, opts) {
 		const name = resolveRunName(action, opts);
-		const wrapped = wrapActionForCancellation(this.sched.abortSignal, action);
+		const wrapped = wrapActionForCancellation(this.sched.currentRunSignal(), action);
 		return this.sched.makeJournalFuture(adapt(this.ctx.run(name, wrapped, toSdkRunOptions(opts))));
 	}
 	sleep(duration, name) {
@@ -1172,6 +1432,9 @@ var RestateOperations = class {
 	* A spawned routine still running when the main operation settles is
 	* abandoned by default (its handler returns without it); pass
 	* `{ onMainExit: "join" }` to `execute` to wait for it instead.
+	*
+	* Returns a `Task<T>` — a `Future<T>` plus `interrupt(err?)` to throw
+	* into the routine at its next yield point.
 	*/
 	spawn(op) {
 		return this.sched.spawn(op);
@@ -1611,6 +1874,7 @@ function isProcessing() {
 }
 
 //#endregion
+exports.InterruptedError = InterruptedError;
 exports.all = all;
 exports.allSettled = allSettled;
 exports.any = any;
@@ -1626,6 +1890,7 @@ Object.defineProperty(exports, 'clients', {
     return ingress_exports;
   }
 });
+exports.contextLocal = contextLocal;
 exports.date = date;
 exports.execute = execute;
 exports.gen = gen;