@noetic-tools/core 5.7.0 → 5.9.0

package/dist/runtime/channel-store.js

@@ -1,7 +1,20 @@
-import { frameworkCast, NoeticErrorImpl } from '@noetic-tools/types';
-const MAX_TOPIC_TIMEOUT = 300_000; // 5 minutes
+import { frameworkCast, NoeticConfigError, NoeticErrorImpl } from '@noetic-tools/types';
 const DEFAULT_SEND_TIMEOUT = 30_000;
 const RESOLVED = Promise.resolve();
+/**
+ * Reject a negative (or NaN) channel timeout. `0` is legal and disables the
+ * timeout; anything below it is a caller bug, not a shorter wait.
+ */
+function invalidTimeout(channelName, timeout) {
+    if (timeout >= 0) {
+        return null;
+    }
+    return new NoeticConfigError({
+        code: 'INVALID_CHANNEL_TIMEOUT',
+        message: `Channel '${channelName}': timeout must be a non-negative number of milliseconds, got ${timeout}.`,
+        hint: 'Pass a positive timeout in milliseconds, or 0 to wait with no timeout.',
+    });
+}
 /** Build the `cancelled` error a blocked channel operation rejects with on abort. */
 function cancelledError(signal) {
     return new NoeticErrorImpl({
@@ -9,6 +22,10 @@ function cancelledError(signal) {
         reason: typeof signal.reason === 'string' ? signal.reason : undefined,
     });
 }
+/** Print a channel warning with the `[noetic]` prefix. */
+export function warnToConsole(warning) {
+    console.warn(`[noetic] ${warning.message}`);
+}
 export class ChannelStore {
     channels = new Map();
     closedExecutions = new Set();
@@ -21,25 +38,87 @@ export class ChannelStore {
      */
     handleObserved = new Set();
     subscribersByExecution = new Map();
+    /**
+     * Channel name → ids of the root executions that used it, which decides
+     * the channels an execution's checkpoint carries. Ids stay after their
+     * execution closes: a host may checkpoint a finished run, and channel
+     * state itself lives for the harness lifetime (spec 06, Lifecycle).
+     */
+    users = new Map();
+    warn;
+    constructor(opts = {}) {
+        this.warn = opts.onWarning ?? warnToConsole;
+    }
     getOrCreate(channel) {
-        let state = frameworkCast(this.channels.get(channel.name));
-        if (!state) {
-            state = {
-                mode: channel.mode,
-                hasValue: false,
-                valueWaiters: [],
-                queue: [],
-                capacity: channel.capacity ?? 1_000,
-                queueWaiters: [],
-                pendingSenders: [],
-                topicSubscribers: new Set(),
-                wakeSubscribers: new Set(),
-                externalSubscribers: new Set(),
-            };
-            this.channels.set(channel.name, frameworkCast(state));
+        const existing = frameworkCast(this.channels.get(channel.name));
+        if (existing) {
+            return existing;
         }
+        const state = emptyState(channel.mode, channel.capacity ?? 1_000);
+        this.channels.set(channel.name, frameworkCast(state));
         return state;
     }
+    /**
+     * Record that `executionId` (a root execution) uses `channel`, so the
+     * channel rides along in its checkpoints.
+     */
+    claim(channel, executionId) {
+        this.addUser(channel.name, executionId);
+    }
+    addUser(channelName, executionId) {
+        let ids = this.users.get(channelName);
+        if (!ids) {
+            ids = new Set();
+            this.users.set(channelName, ids);
+        }
+        ids.add(executionId);
+    }
+    /**
+     * Stored state (values, queued items) of every channel `executionId` used.
+     * Parked receivers, parked senders, and subscribers are live promises and
+     * stay out; topic channels store nothing and are skipped.
+     */
+    snapshot(executionId) {
+        const out = [];
+        for (const [name, ids] of this.users) {
+            const state = this.channels.get(name);
+            if (!state || !ids.has(executionId)) {
+                continue;
+            }
+            if (state.mode === 'value') {
+                out.push({
+                    name,
+                    mode: 'value',
+                    value: state.currentValue,
+                    hasValue: state.hasValue,
+                });
+            }
+            if (state.mode === 'queue') {
+                out.push({
+                    name,
+                    mode: 'queue',
+                    capacity: state.capacity,
+                    queue: [
+                        ...state.queue,
+                    ],
+                });
+            }
+        }
+        return out;
+    }
+    /**
+     * Refill channel state from a checkpoint and mark `executionId` as a user.
+     * A channel that already has live state keeps it — live state is never
+     * older than a snapshot.
+     */
+    restore(executionId, snapshots) {
+        for (const snap of snapshots) {
+            if (!this.channels.has(snap.name)) {
+                this.channels.set(snap.name, restoredState(snap));
+            }
+            this.addUser(snap.name, executionId);
+        }
+    }
     /**
      * Subscribe to wake notifications on a channel without consuming any value.
      * Fired once on the next `send()` for any mode, then auto-removed. Returns
@@ -70,8 +149,16 @@ export class ChannelStore {
      * - **topic**: deliver to current subscribers, resolve immediately.
      *
      * External callers use `ChannelHandle.send` (sync, drop-oldest) instead.
+     * `opts.timeout: 0` parks with no timeout and warns `unbounded_wait`.
+     *
+     * @throws `NoeticConfigError` with code `INVALID_CHANNEL_TIMEOUT` (as a
+     * rejection) when `opts.timeout` is negative.
      */
     send(channel, value, opts) {
+        const invalid = invalidTimeout(channel.name, opts?.timeout ?? DEFAULT_SEND_TIMEOUT);
+        if (invalid) {
+            return Promise.reject(invalid);
+        }
         const state = this.getOrCreate(channel);
         let result = RESOLVED;
         switch (state.mode) {
@@ -106,8 +193,8 @@ export class ChannelStore {
                 }
                 break;
             case 'topic':
-                for (const sub of state.topicSubscribers) {
-                    sub(value);
+                for (const waiter of state.topicWaiters.splice(0)) {
+                    waiter.resolve(value);
                 }
                 for (const sub of state.externalSubscribers) {
                     sub.push(value);
@@ -153,7 +240,15 @@ export class ChannelStore {
                 state.pendingSenders.splice(idx, 1);
                 return true;
             };
-            if (timeout > 0) {
+            if (timeout === 0) {
+                this.warn({
+                    kind: 'unbounded_wait',
+                    channelName,
+                    operation: 'send',
+                    message: `Channel '${channelName}': send parked on a full queue with timeout 0 — it waits until a consumer frees a slot or the context aborts.`,
+                });
+            }
+            else {
                 timer = setTimeout(() => {
                     if (removeEntry()) {
                         entry.reject(new NoeticErrorImpl({
@@ -208,7 +303,20 @@ export class ChannelStore {
             wake();
         }
     }
+    /**
+     * Receive by mode: value returns the current value, queue dequeues the
+     * head, topic waits for the next send. A receiver that has to wait gets
+     * `channel_timeout` after `timeout` ms; `0` waits with no timeout in every
+     * mode and warns `unbounded_wait`.
+     *
+     * @throws `NoeticConfigError` with code `INVALID_CHANNEL_TIMEOUT` (as a
+     * rejection) when `timeout` is negative.
+     */
     async recv(channel, timeout = 30_000, signal) {
+        const invalid = invalidTimeout(channel.name, timeout);
+        if (invalid) {
+            throw invalid;
+        }
         // An already-aborted context must reject promptly rather than park a
         // waiter that nothing will ever wake (spec 09, Cancellation item 2).
         if (signal?.aborted) {
@@ -235,46 +343,8 @@ export class ChannelStore {
                 }
                 return this.waitWithTimeout(state.queueWaiters, channel.name, timeout, signal);
             }
-            case 'topic': {
-                // Clamp timeout to prevent indefinite subscriber leaks
-                let effectiveTimeout = timeout;
-                if (effectiveTimeout <= 0) {
-                    console.warn(`[noetic] Channel '${channel.name}': topic recv with non-positive timeout, clamping to ${MAX_TOPIC_TIMEOUT}ms`);
-                    effectiveTimeout = MAX_TOPIC_TIMEOUT;
-                }
-                return new Promise((resolve, reject) => {
-                    let removeAbortListener = null;
-                    const timer = setTimeout(() => {
-                        state.topicSubscribers.delete(handler);
-                        removeAbortListener?.();
-                        reject(new NoeticErrorImpl({
-                            kind: 'channel_timeout',
-                            channelName: channel.name,
-                            timeout: effectiveTimeout,
-                        }));
-                    }, effectiveTimeout);
-                    const handler = (value) => {
-                        clearTimeout(timer);
-                        state.topicSubscribers.delete(handler);
-                        removeAbortListener?.();
-                        resolve(value);
-                    };
-                    state.topicSubscribers.add(handler);
-                    if (signal) {
-                        const onAbort = () => {
-                            clearTimeout(timer);
-                            state.topicSubscribers.delete(handler);
-                            reject(cancelledError(signal));
-                        };
-                        signal.addEventListener('abort', onAbort, {
-                            once: true,
-                        });
-                        removeAbortListener = () => {
-                            signal.removeEventListener('abort', onAbort);
-                        };
-                    }
-                });
-            }
+            case 'topic':
+                return this.waitWithTimeout(state.topicWaiters, channel.name, timeout, signal);
         }
     }
     tryRecv(channel) {
@@ -325,7 +395,15 @@ export class ChannelStore {
                 waiters.splice(idx, 1);
                 return true;
             };
-            if (timeout > 0) {
+            if (timeout === 0) {
+                this.warn({
+                    kind: 'unbounded_wait',
+                    channelName,
+                    operation: 'recv',
+                    message: `Channel '${channelName}': recv waiting with timeout 0 — it waits until a value arrives or the context aborts.`,
+                });
+            }
+            else {
                 timer = setTimeout(() => {
                     if (removeEntry()) {
                         wrappedReject(new NoeticErrorImpl({
@@ -362,7 +440,12 @@ export class ChannelStore {
             state.queueWaiters.length === 0 &&
             state.queue.length >= state.capacity;
         if (isFullQueue) {
-            console.warn(`[noetic] Channel '${channel.name}': queue at capacity (${state.capacity}), dropping oldest message (external sender).`);
+            this.warn({
+                kind: 'overflow_drop',
+                channelName: channel.name,
+                capacity: state.capacity,
+                message: `Channel '${channel.name}': queue at capacity (${state.capacity}), dropping oldest message (external sender).`,
+            });
             state.queue.shift();
             state.queue.push(value);
             this.fireWakes(state);
@@ -391,10 +474,12 @@ export class ChannelStore {
         if (this.closedExecutions.has(executionId)) {
             return CLOSED_ITERABLE;
         }
+        this.claim(channel, executionId);
         const state = this.getOrCreate(channel);
         const subscriber = new ExternalSubscriber({
             channelName: channel.name,
             conflate: state.mode === 'value',
+            warn: this.warn,
             takeShared: state.mode === 'queue'
                 ? () => {
                     const head = this.dequeueHead(state);
@@ -462,6 +547,7 @@ export class ChannelStore {
     }
     getHandle(channel, executionId) {
         this.handleObserved.add(executionId);
+        this.claim(channel, executionId);
         const store = this;
         return {
             get closed() {
@@ -506,6 +592,31 @@ export class ChannelStore {
         this.closedExecutions.delete(executionId);
     }
 }
+function emptyState(mode, capacity) {
+    return {
+        mode,
+        hasValue: false,
+        valueWaiters: [],
+        queue: [],
+        capacity,
+        queueWaiters: [],
+        pendingSenders: [],
+        topicWaiters: [],
+        wakeSubscribers: new Set(),
+        externalSubscribers: new Set(),
+    };
+}
+function restoredState(snap) {
+    if (snap.mode === 'value') {
+        const state = emptyState('value', 1_000);
+        state.currentValue = snap.value;
+        state.hasValue = snap.hasValue;
+        return state;
+    }
+    const state = emptyState('queue', snap.capacity);
+    state.queue.push(...snap.queue);
+    return state;
+}
 const MAX_EXTERNAL_BUFFER = 1_000;
 const CLOSED_ITERABLE = {
     [Symbol.asyncIterator]() {
@@ -559,7 +670,12 @@ class ExternalSubscriber {
             return;
         }
         if (this.buffer.length >= MAX_EXTERNAL_BUFFER) {
-            console.warn(`[noetic] Channel '${this.opts.channelName}': external subscriber buffer at capacity (${MAX_EXTERNAL_BUFFER}), dropping oldest value.`);
+            this.opts.warn({
+                kind: 'subscriber_drop',
+                channelName: this.opts.channelName,
+                capacity: MAX_EXTERNAL_BUFFER,
+                message: `Channel '${this.opts.channelName}': external subscriber buffer at capacity (${MAX_EXTERNAL_BUFFER}), dropping oldest value.`,
+            });
             this.buffer.shift();
         }
         this.buffer.push(value);

package/dist/runtime/context-impl.d.ts

@@ -1,5 +1,11 @@
 import type { AgentHarnessContract, Channel, ChannelStore, Context, ContextData, ContextLayer, CwdState, EventBroadcaster, FrontierFrame, FsAdapter, Item, ItemLog, ItemSchemaRegistry, LastLayerUsage, Span, StepMeta, TokenUsage, Tool } from './context-deps.js';
 import type { StepLedger } from './durable/step-ledger.js';
+/**
+ * @internal
+ * Id of the root execution `ctx` runs under — the id `run()` opens and
+ * closes channel scopes with (spec 06).
+ */
+export declare function rootIdOf(ctx: Context): string;
 /**
  * @internal
  * The cancellation tree rooted at `ctx`, in pre-order (a parent before its
@@ -63,30 +69,24 @@ export declare class ContextImpl implements Context<ContextData> {
     private readonly _children;
     private _contextData?;
     /**
-     * Stack of steps currently in flight on this context, most-recent last.
-     * Pushed by `enterStep` at the top of `execute()` and popped by
-     * `leaveStep` when the step resolves (success or failure). The harness'
-     * checkpoint writer serialises this stack as the execution frontier so
-     * a restart can identify which step the context was paused inside.
+     * Steps in flight on this context, in dispatch order. `enterStep` adds a frame and
+     * `leaveStep` removes that same frame, so concurrent dispatches can settle in any
+     * order without disturbing each other. The checkpoint writer serialises this set as
+     * the execution frontier.
      * @internal
      */
-    private readonly _frontier;
+    private readonly _inFlight;
     /**
-     * Path segment for each in-flight frame, parallel to `_frontier`. Kept separate so
-     * `serialiseFrontier()` keeps emitting the published `FrontierFrame` shape.
+     * Execution path of the step whose lane this is. On the context itself it is the
+     * prefix its steps hang under: empty on a root context, the parent's path plus a
+     * discriminator on an inParallel/spawn child, so a path stays unique across the whole
+     * step tree. A lane (see `enterStep`) reads its own step's path here instead.
      * @internal
      */
-    private readonly _segments;
-    /**
-     * Path this context's steps hang under. Empty on a root context; an inParallel/spawn child
-     * inherits its parent's current path plus a discriminator, so a path key stays unique
-     * across the whole step tree rather than restarting per child context.
-     * @internal
-     */
-    private readonly _pathPrefix;
+    private readonly _path;
     /**
      * Dispatch counts per `<parent path>/<step id>`, so a loop body re-entered on each
-     * iteration gets `#0`, `#1`, … instead of colliding on one key.
+     * iteration gets `#0`, `#1`, … instead of colliding on one key. Shared by every lane.
      * @internal
      */
     private readonly _occurrences;
@@ -156,7 +156,7 @@ export declare class ContextImpl implements Context<ContextData> {
     recv<T>(ch: Channel<T>, opts?: {
         timeout?: number;
     }): Promise<T>;
-    send<T>(ch: Channel<T>, value: T): Promise<void>;
+    send<T>(ch: Channel<T>, value: NoInfer<T>): Promise<void>;
     tryRecv<T>(ch: Channel<T>): T | null;
     checkpoint(): Promise<void>;
     complete<T>(value: T): void;
@@ -173,28 +173,26 @@ export declare class ContextImpl implements Context<ContextData> {
     get abortSignal(): AbortSignal;
     /**
      * @internal
-     * Push a frame onto the execution frontier. Called by `execute()` at the
-     * top of every step dispatch so that the frontier reflects exactly the
-     * stack of steps currently in-flight on this context.
+     * Register `frame` as in flight and return the lane its step runs on: a view of
+     * this context that shares everything except its execution path. `execute()` hands
+     * the lane to the step, so steps the step dispatches hang under its path no matter
+     * how other dispatches on this context interleave. The occurrence ordinal is taken
+     * here, at dispatch, never at settle.
      */
-    enterStep(frame: FrontierFrame): void;
+    enterStep(frame: FrontierFrame): ContextImpl;
     /**
      * @internal
-     * The execution path of the step currently on top of the frontier — the ledger key
-     * identifying this exact dispatch. Stable across a replay given the same control
-     * flow, which is what lets a resumed run line recorded outputs up with the steps
-     * that produced them.
+     * The execution path of the step this lane belongs to — the ledger key identifying
+     * this exact dispatch. Stable across a replay given the same control flow, which is
+     * what lets a resumed run line recorded outputs up with the steps that produced them.
      */
     currentPath(): string;
     /**
      * @internal
-     * Pop the top frame. Called when a step resolves (success or failure)
-     * so that the frontier unwinds cleanly. The value of `expectedStepId`
-     * is used as a consistency check — if it does not match the top frame
-     * the pop is still performed, but a best-effort warning is surfaced to
-     * stderr rather than swallowed silently.
+     * Drop `frame` from the in-flight set. Called when its step resolves, success or
+     * failure.
      */
-    leaveStep(expectedStepId: string): void;
+    leaveStep(frame: FrontierFrame): void;
     /**
      * @internal
      * Return a defensive copy of the current frontier. Consumed by the
@@ -202,3 +200,9 @@ export declare class ContextImpl implements Context<ContextData> {
      */
     serialiseFrontier(): FrontierFrame[];
 }
+/**
+ * @internal
+ * The context a lane views, or `ctx` itself when it is not a lane. For per-execution
+ * caches keyed by context identity, which every lane of one context must share.
+ */
+export declare function laneBase(ctx: Context<ContextData>): Context<ContextData>;

package/dist/runtime/context-impl.js

@@ -9,6 +9,18 @@ class NoopSpan {
     addEvent(_name, _attributes) { }
     end() { }
 }
+/**
+ * @internal
+ * Id of the root execution `ctx` runs under — the id `run()` opens and
+ * closes channel scopes with (spec 06).
+ */
+export function rootIdOf(ctx) {
+    let node = ctx;
+    while (node.parent) {
+        node = node.parent;
+    }
+    return node.id;
+}
 /**
  * @internal
  * The cancellation tree rooted at `ctx`, in pre-order (a parent before its
@@ -87,30 +99,24 @@ export class ContextImpl {
     _children = new Set();
     _contextData;
     /**
-     * Stack of steps currently in flight on this context, most-recent last.
-     * Pushed by `enterStep` at the top of `execute()` and popped by
-     * `leaveStep` when the step resolves (success or failure). The harness'
-     * checkpoint writer serialises this stack as the execution frontier so
-     * a restart can identify which step the context was paused inside.
+     * Steps in flight on this context, in dispatch order. `enterStep` adds a frame and
+     * `leaveStep` removes that same frame, so concurrent dispatches can settle in any
+     * order without disturbing each other. The checkpoint writer serialises this set as
+     * the execution frontier.
      * @internal
      */
-    _frontier = [];
+    _inFlight = new Set();
     /**
-     * Path segment for each in-flight frame, parallel to `_frontier`. Kept separate so
-     * `serialiseFrontier()` keeps emitting the published `FrontierFrame` shape.
+     * Execution path of the step whose lane this is. On the context itself it is the
+     * prefix its steps hang under: empty on a root context, the parent's path plus a
+     * discriminator on an inParallel/spawn child, so a path stays unique across the whole
+     * step tree. A lane (see `enterStep`) reads its own step's path here instead.
      * @internal
      */
-    _segments = [];
-    /**
-     * Path this context's steps hang under. Empty on a root context; an inParallel/spawn child
-     * inherits its parent's current path plus a discriminator, so a path key stays unique
-     * across the whole step tree rather than restarting per child context.
-     * @internal
-     */
-    _pathPrefix;
+    _path;
     /**
      * Dispatch counts per `<parent path>/<step id>`, so a loop body re-entered on each
-     * iteration gets `#0`, `#1`, … instead of colliding on one key.
+     * iteration gets `#0`, `#1`, … instead of colliding on one key. Shared by every lane.
      * @internal
      */
     _occurrences = new Map();
@@ -133,7 +139,7 @@ export class ContextImpl {
         this.resourceId = opts.resourceId;
         this.channelStore = opts.channelStore;
         this._checkpointFn = opts.checkpointFn;
-        this._pathPrefix = opts.pathPrefix ?? '';
+        this._path = opts.pathPrefix ?? '';
         this.ledger = opts.ledger;
         this.layers = opts.layers;
         this.unifiedTools = opts.unifiedTools;
@@ -215,6 +221,7 @@ export class ContextImpl {
         if (!this.channelStore) {
             return Promise.reject(new Error('No channel store configured'));
         }
+        this.channelStore.claim(ch, rootIdOf(this));
         return this.channelStore.recv(ch, opts?.timeout, this._abortController.signal);
     }
     send(ch, value) {
@@ -224,6 +231,7 @@ export class ContextImpl {
         // Internal sender: back-pressured on full queue channels (default 30s →
         // channel_timeout); aborting this context rejects a parked send with
         // 'cancelled' via the shared abort signal.
+        this.channelStore.claim(ch, rootIdOf(this));
         return this.channelStore.send(ch, value, {
             signal: this._abortController.signal,
         });
@@ -232,6 +240,7 @@ export class ContextImpl {
         if (!this.channelStore) {
             throw new Error('No channel store configured');
         }
+        this.channelStore.claim(ch, rootIdOf(this));
         return this.channelStore.tryRecv(ch);
     }
     async checkpoint() {
@@ -285,45 +294,35 @@ export class ContextImpl {
     }
     /**
      * @internal
-     * Push a frame onto the execution frontier. Called by `execute()` at the
-     * top of every step dispatch so that the frontier reflects exactly the
-     * stack of steps currently in-flight on this context.
+     * Register `frame` as in flight and return the lane its step runs on: a view of
+     * this context that shares everything except its execution path. `execute()` hands
+     * the lane to the step, so steps the step dispatches hang under its path no matter
+     * how other dispatches on this context interleave. The occurrence ordinal is taken
+     * here, at dispatch, never at settle.
      */
     enterStep(frame) {
-        const parent = this.currentPath();
-        const key = `${parent}/${frame.stepId}`;
+        const key = `${this._path}/${frame.stepId}`;
         const occurrence = this._occurrences.get(key) ?? 0;
         this._occurrences.set(key, occurrence + 1);
-        this._segments.push(`/${frame.stepId}#${occurrence}`);
-        this._frontier.push(frame);
+        this._inFlight.add(frame);
+        return laneOf(this, `${key}#${occurrence}`);
     }
     /**
      * @internal
-     * The execution path of the step currently on top of the frontier — the ledger key
-     * identifying this exact dispatch. Stable across a replay given the same control
-     * flow, which is what lets a resumed run line recorded outputs up with the steps
-     * that produced them.
+     * The execution path of the step this lane belongs to — the ledger key identifying
+     * this exact dispatch. Stable across a replay given the same control flow, which is
+     * what lets a resumed run line recorded outputs up with the steps that produced them.
      */
     currentPath() {
-        return this._pathPrefix + this._segments.join('');
+        return this._path;
     }
     /**
      * @internal
-     * Pop the top frame. Called when a step resolves (success or failure)
-     * so that the frontier unwinds cleanly. The value of `expectedStepId`
-     * is used as a consistency check — if it does not match the top frame
-     * the pop is still performed, but a best-effort warning is surfaced to
-     * stderr rather than swallowed silently.
+     * Drop `frame` from the in-flight set. Called when its step resolves, success or
+     * failure.
      */
-    leaveStep(expectedStepId) {
-        const top = this._frontier[this._frontier.length - 1];
-        if (top && top.stepId !== expectedStepId) {
-            // A mismatch indicates bookkeeping drift. We unwind best-effort and
-            // let the caller observe via `serialiseFrontier()` if needed.
-            console.warn(`ContextImpl.leaveStep: expected "${expectedStepId}" on top of frontier but saw "${top.stepId}".`);
-        }
-        this._frontier.pop();
-        this._segments.pop();
+    leaveStep(frame) {
+        this._inFlight.delete(frame);
     }
     /**
      * @internal
@@ -331,10 +330,46 @@ export class ContextImpl {
      * checkpoint writer — see `AgentHarness.checkpoint`.
      */
     serialiseFrontier() {
-        return this._frontier.map((frame) => ({
+        return [
+            ...this._inFlight,
+        ].map((frame) => ({
             stepId: frame.stepId,
             input: frame.input,
             state: frame.state,
         }));
     }
 }
+//#region Lanes
+/** The context each lane views, so `laneOf` never stacks a proxy on a proxy. */
+const laneTargets = new WeakMap();
+/**
+ * A view of `ctx` that reads `path` as its execution path and forwards every other
+ * read and write to the context itself, so state, usage, abort, and the in-flight set
+ * stay shared. A Proxy rather than a subclass: steps assign `ctx.state` and friends
+ * directly, and a copy would keep those writes to itself.
+ */
+function laneOf(ctx, path) {
+    const target = laneTargets.get(ctx) ?? ctx;
+    const lane = new Proxy(target, {
+        get(base, prop, receiver) {
+            if (prop === '_path') {
+                return path;
+            }
+            return Reflect.get(base, prop, receiver);
+        },
+        set(base, prop, value) {
+            return Reflect.set(base, prop, value);
+        },
+    });
+    laneTargets.set(lane, target);
+    return lane;
+}
+/**
+ * @internal
+ * The context a lane views, or `ctx` itself when it is not a lane. For per-execution
+ * caches keyed by context identity, which every lane of one context must share.
+ */
+export function laneBase(ctx) {
+    return ctx instanceof ContextImpl ? (laneTargets.get(ctx) ?? ctx) : ctx;
+}
+//#endregion