experimental-ash 0.2.0-alpha.21 → 0.2.0-alpha.23

package/docs/public/session-context.md

@@ -1,13 +1,15 @@
 # Session Context
 
-Ash exposes six runtime helpers for authored code:
+Ash exposes runtime helpers for authored code:
 
 - `getSession()`
-- `getContext(key)`
-- `setContext(key, value)`
-- `ensureContext(key, valueOrFactory)`
 - `getSandbox(name)`
 - `getSkill(identifier)`
+- `getContext(key)` — returns `T | undefined`
+- `requireContext(key)` — returns `T`, throws if unset
+- `hasContext(key)` — returns `boolean`
+- `setContext(key, valueOrUpdater)` — returns `T`
+- `ensureContext(key, factory)` — returns `T`
 
 These APIs work only inside active authored runtime execution such as tools and other Ash-invoked
 callbacks. Under the hood, they read from a single `AshContext` container that the framework binds
@@ -20,7 +22,7 @@ Use `getSession()` when you need durable runtime metadata about the current exec
 `agent/tools/who_called_me.ts`
 
 ```ts
-import { getSession } from "experimental-ash";
+import { getSession } from "experimental-ash/context";
 import { defineTool } from "experimental-ash/tools";
 
 export default defineTool({
@@ -96,32 +98,11 @@ Important behavior:
 
 See [`skills.md`](./skills.md) for the full authoring model.
 
-## Durable Authored Context
-
-`ContextKey` values are session-durable by default. Once authored code sets a key, Ash hydrates it
-from `session.context` before later steps and commits it back after each step.
-
-```ts
-import { ContextKey, ensureContext, getContext, setContext } from "experimental-ash";
-
-const TenantKey = new ContextKey<string>("myapp.tenant");
-const NotesKey = new ContextKey<{ readonly notes: readonly string[] }>("myapp.notes");
-
-const tenant = getContext(TenantKey);
-const notes = ensureContext(NotesKey, () => ({ notes: [] }));
-
-setContext(NotesKey, {
-  notes: [...notes.notes, `Handled tenant ${tenant}`],
-});
-```
-
-Use `ensureContext` when a key needs a default value. `ContextKey({ initial })` no longer exists.
-
 ## Passing Custom Context From a Channel
 
-Channels can inject custom typed context into the agent inside `onDeliver`. This is useful when a
-channel needs to pass platform-specific metadata (tenant ID, feature flags, etc.) that authored
-tools can read.
+Channels can inject custom typed durable context into the agent inside `onDeliver`. This is useful
+when a channel needs to pass platform-specific metadata (tenant ID, feature flags, etc.) that
+authored tools can read on the same turn and on later turns.
 
 ### Defining a key
 
@@ -131,7 +112,7 @@ read it.
 `agent/channels/keys.ts`
 
 ```ts
-import { ContextKey } from "experimental-ash";
+import { ContextKey } from "experimental-ash/context";
 
 export const TenantKey = new ContextKey<string>("myapp.tenant");
 ```
@@ -139,9 +120,8 @@ export const TenantKey = new ContextKey<string>("myapp.tenant");
 ### Setting context from a channel
 
 Wrap an existing channel with `onDeliver` to set custom context keys. The hook receives a narrow
-`ContextAccessor` (`get`, `tryGet`, `has`, `set`, `ensure`) as its first argument and a
-`DeliverPayload` as the second. It runs on both `run()` and `deliver()`, after Ash has hydrated the
-durable context bag for that turn.
+`ContextAccessor` (typed `get`/`set`) as its first argument and a `DeliverPayload` as the second. It
+runs on both `run()` and `deliver()`.
 
 `agent/channels/slack.ts`
 
@@ -167,8 +147,8 @@ class TenantSlackChannel extends SlackChannel<TenantSlackState> {
     });
   }
 
-  async onDeliver(ctx, payload) {
-    ctx.set(TenantKey, this.state().tenantId);
+  override async onDeliver(ctx, payload) {
+    ctx.set(TenantKey, this.state.tenantId);
     return await super.onDeliver(ctx, payload);
   }
 }
@@ -181,30 +161,96 @@ export default slackRoute({
 Auth lives on `RunInput.auth` and `DeliverInput.auth`, not on the channel object. There is no
 `withAuth` or `withContext` wrapper.
 
-Keep channel constructor state immutable after the run starts. Stable transport identity belongs in
-serialized channel state; mutable per-session data belongs in durable context or `session.internal`.
-
 ### Reading context from a tool
 
 ```ts
-import { getContext } from "experimental-ash";
+import { requireContext } from "experimental-ash/context";
 import { defineTool } from "experimental-ash/tools";
 import { TenantKey } from "../channels/keys.js";
 
 export default defineTool({
   description: "Return the active tenant.",
   async execute() {
-    const tenant = getContext(TenantKey);
+    const tenant = requireContext(TenantKey);
     return { tenant };
   },
 });
 ```
 
+### Rebuilding virtual values with `ContextProvider`
+
+If a channel needs to vend a live non-serializable object each step, declare a static
+`contextProviders` array on the channel class. This must be a class field such as
+`static readonly contextProviders = [...]`; the runtime reads providers from the channel class, not
+from the channel instance.
+
+For Slack subclasses, the intended pattern is:
+
+- `onDeliver()` writes durable serializable facts such as tenant IDs, channel IDs, or installation
+  IDs.
+- `static readonly contextProviders = [...]` derives live step-local values such as SDK clients
+  from those durable keys.
+- tools and other authored step code read the derived value with `requireContext(...)` or
+  `getContext(...)`.
+
+Providers run after `onDeliver()` and rebuild virtual values for the current step only, so
+`onDeliver()` should not expect provider output to exist yet.
+
+```ts
+import {
+  ContextKey,
+  type ContextProvider,
+} from "experimental-ash/context";
+import {
+  slackRoute,
+  SlackChannel,
+  type SlackChannelState,
+} from "experimental-ash/channels/slack";
+
+const TenantKey = new ContextKey<string>("myapp.tenant");
+const SlackClientKey = new ContextKey<{ readonly tenantId: string }>("myapp.slackClient");
+
+const slackClientProvider: ContextProvider<{ readonly tenantId: string }> = {
+  key: SlackClientKey,
+  create(ctx) {
+    return { tenantId: ctx.require(TenantKey) };
+  },
+};
+
+interface TenantSlackState extends SlackChannelState {
+  readonly tenantId: string;
+}
+
+class TenantSlackChannel extends SlackChannel<TenantSlackState> {
+  static override readonly kind = "tenant-slack";
+  static readonly contextProviders = [slackClientProvider];
+
+  constructor(state: SlackChannelState) {
+    super({
+      ...state,
+      tenantId: lookupTenant(state),
+    });
+  }
+
+  override async onDeliver(ctx, payload) {
+    ctx.set(TenantKey, this.state.tenantId);
+    return await super.onDeliver(ctx, payload);
+  }
+}
+
+export default slackRoute({
+  channel: TenantSlackChannel,
+});
+```
+
+Provider output is readable through `requireContext(SlackClientKey)` or
+`getContext(SlackClientKey)` during that step, but it is not serialized.
+
 ### Context on deliver
 
 `onDeliver` runs on every turn, including `deliver()` follow-ups. The channel is deserialized from
-the session, so its stable serialized state (including custom fields like `tenantId`) is available
-on follow-up turns.
+the session, so its state (including any custom fields like `tenantId`) is available on follow-up
+turns.
 
 Auth on `deliver()` is also honored — `session.auth.current` reflects the caller of each follow-up
 message, not just the session initiator. Deliver-time auth is passed via `DeliverInput.auth` and the
@@ -229,18 +275,18 @@ explaining the required scope.
 
 ## How It Works
 
-All runtime helpers read from the same `AshContext` container bound by a single
-`AsyncLocalStorage`. The framework sets up this context before invoking authored code:
+All three accessors read from the same `AshContext` container bound by a single `AsyncLocalStorage`.
+The framework sets up this context before invoking authored code:
 
-1. The runtime entry point creates an `AshContext` and serializes only runtime seed keys such as
-   auth, session id, channel, and compiled bundle.
-2. Before each step, Ash rebuilds a fresh context, hydrates durable authored context from
-   `session.context`, seeds runtime-only bookkeeping, and runs `channel.onDeliver(...)`.
-3. Providers create derived values such as session metadata, sandbox access, and skill access.
+1. The runtime entry point creates an `AshContext` and populates durable seed keys (auth, session
+   ID, channel, compiled bundle).
+2. `onDeliver()` can write durable authored context for the turn.
+3. Before each step, providers create virtual step-local values (session metadata, sandbox access,
+   skill access, channel-scoped live objects) from the current context.
 4. The step callback runs inside the `AsyncLocalStorage` scope, making the context available to
    all authored code in the call chain.
-5. After the step, Ash commits the full durable context bag back to `session.context` and lets
-   mutable providers persist any provider-owned state.
+5. After the step, framework providers with provider-owned mutable state (for example sandboxes)
+   commit those changes back onto the harness session.
 
 This lifecycle is fully managed by the framework. Authored code only needs to call the public
 accessors.

package/docs/public/skills.md

@@ -78,7 +78,7 @@ Packaged skills are useful when you want files like:
 Inside authored runtime code, you can read those packaged files through `getSkill(identifier)`.
 
 ```ts
-import { getSkill } from "experimental-ash";
+import { getSkill } from "experimental-ash/skills";
 import { defineTool } from "experimental-ash/tools";
 
 export default defineTool({
@@ -138,7 +138,7 @@ Do not use a skill for:
 If markdown is not enough, you can author a skill in TypeScript with `defineSkill(...)`.
 
 ```ts
-import { defineSkill } from "experimental-ash";
+import { defineSkill } from "experimental-ash/skills";
 
 export default defineSkill({
   name: "research",

package/docs/public/tools.md

@@ -10,7 +10,7 @@ back.
 `agent/tools/get_weather.ts`
 
 ```ts
-import { getSession } from "experimental-ash";
+import { getSession } from "experimental-ash/context";
 import { defineTool } from "experimental-ash/tools";
 import { z } from "zod";
 
@@ -36,8 +36,8 @@ exposed to the model as `get_weather`; a file at `agent/tools/get-weather.ts` is
 `get-weather`. You can override that by setting `name` in the tool definition.
 
 `defineTool`, `disableTool`, `defineBashTool`, `defineReadFileTool`, and `defineWriteFileTool` live on the `experimental-ash/tools` subpath.
-Runtime helpers like `getSession`, `getContext`, `setContext`, `ensureContext`, `getSandbox`, and
-`getSkill` stay on the main `experimental-ash` barrel.
+Runtime context helpers (`getSession`, `getContext`, `requireContext`, `hasContext`, `setContext`, `ensureContext`) live on `experimental-ash/context`.
+`getSandbox` lives on `experimental-ash/sandboxes` and `getSkill` lives on `experimental-ash/skills`.
 
 ## What A Tool Definition Needs
 
@@ -106,8 +106,8 @@ execution surface by itself; executable behavior still comes from the tools the
 
 `read_file` reads a text file from the sandbox filesystem with line-numbered output. `write_file`
 writes a complete file, enforcing read-before-write for existing files and detecting stale reads.
-Both target the framework default sandbox. Compaction clears the durable read-file context so the
-model must re-read files before overwriting after compaction.
+Both target the framework default sandbox. Compaction clears the durable read-file state so the model
+must re-read files before overwriting after compaction.
 
 Authors can wrap, replace, or disable these defaults from `agent/tools/`.
 
@@ -225,23 +225,29 @@ export default defineWriteFileTool({
 ```
 
 When replacing the framework `read_file`, the authored version inherits the same compaction
-context-reset behavior by default. Provide an explicit `onCompact` to override that.
+state-reset behavior by default. Provide an explicit `onCompact` to override that.
 
 ### Replace A Default With Custom Context
 
-`agent/tools/todo.ts` - replace the framework `todo` tool with a custom durable-context version.
-Declare your own `ContextKey` and use `ensureContext` / `setContext` to read and write it:
+`agent/tools/todo.ts` - replace the framework `todo` tool with a custom durable context-backed
+version. Declare your own `ContextKey`, initialize it with `ensureContext`, and read/write it with
+`requireContext` / `setContext`:
 
 ```ts
-import { ContextKey, ensureContext, setContext } from "experimental-ash";
+import {
+  ContextKey,
+  ensureContext,
+  requireContext,
+  setContext,
+} from "experimental-ash/context";
 import { defineTool } from "experimental-ash/tools";
 import { z } from "zod";
 
-interface NoteListContext {
+interface NoteListState {
   readonly notes: readonly string[];
 }
 
-const NoteListContextKey = new ContextKey<NoteListContext>("myapp.notes");
+const NoteListStateKey = new ContextKey<NoteListState>("myapp.notes");
 
 export default defineTool({
   description: "Append a note or read the running list of notes.",
@@ -249,13 +255,15 @@ export default defineTool({
     note: z.string().optional(),
   }),
   async execute(input) {
+    ensureContext(NoteListStateKey, () => ({ notes: [] }));
+
     if (typeof input.note === "string" && input.note.length > 0) {
-      const current = ensureContext(NoteListContextKey, () => ({ notes: [] }));
-      setContext(NoteListContextKey, {
-        notes: [...current.notes, input.note],
-      });
+      const next = input.note;
+      setContext(NoteListStateKey, (current) => ({
+        notes: [...(current?.notes ?? []), next],
+      }));
     }
-    return ensureContext(NoteListContextKey, () => ({ notes: [] }));
+    return requireContext(NoteListStateKey);
   },
 });
 ```
@@ -263,8 +271,8 @@ export default defineTool({
 ### Subtleties Worth Knowing
 
 - The filename is the default name. There is also an explicit `name` property when you need it.
-- Durable context is owned by the replacement. Replacing `todo` with a fresh `defineTool` does not
-  inherit the framework's context key.
+- Context is owned by the replacement. Replacing `todo` with a fresh `defineTool` does not inherit
+  the framework's durable context key.
 - Authored-vs-authored collisions are impossible by construction. Two files cannot share a slug under
   the same `agent/tools/` directory.
 

package/docs/public/typescript-api.md

@@ -5,6 +5,8 @@ This page is the quick reference for Ash's public TypeScript surface.
 Source of truth:
 
 - main barrel: [`../../packages/ash/src/public/index.ts`](../../packages/ash/src/public/index.ts)
+- context subpath: [`../../packages/ash/src/public/context/index.ts`](../../packages/ash/src/public/context/index.ts)
+- skills subpath: [`../../packages/ash/src/public/skills/index.ts`](../../packages/ash/src/public/skills/index.ts)
 - tools subpath: [`../../packages/ash/src/public/tools/index.ts`](../../packages/ash/src/public/tools/index.ts)
 - sandboxes subpath: [`../../packages/ash/src/public/sandboxes/index.ts`](../../packages/ash/src/public/sandboxes/index.ts)
 - channel subpaths: [`../../packages/ash/src/public/channels/index.ts`](../../packages/ash/src/public/channels/index.ts)
@@ -12,24 +14,25 @@ Source of truth:
 
 ## Definition Helpers
 
-Use these to author the filesystem-backed surface. Tool authoring helpers live on
-`experimental-ash/tools`; sandbox helpers live on `experimental-ash/sandboxes`; everything else is
-on the main `experimental-ash` barrel.
+Use these to author the filesystem-backed surface. Each concern has its own subpath:
+`experimental-ash/tools` for tools, `experimental-ash/sandboxes` for sandboxes,
+`experimental-ash/skills` for skills, `experimental-ash/context` for context helpers,
+and the main `experimental-ash` barrel for agent config, routes, schedules, and systems.
 
 - `defineAgent(...)` - additive runtime config for `agent.ts`
 - `defineRoute(...)` - messaging-platform or HTTP route entrypoints in `channels/`
-- `defineSandbox(...)` - isolated bash-style environments in `sandboxes/`
+- `defineSandbox(...)` - isolated bash-style environments in `sandboxes/` (`experimental-ash/sandboxes`)
 - `defineSchedule(...)` - recurring jobs in `schedules/`
-- `defineSkill(...)` - module-authored skills
+- `defineSkill(...)` - module-authored skills (`experimental-ash/skills`)
 - `defineSubagent(...)` - local subagent entrypoint in `subagents/<id>/subagent.ts`
 - `defineSystem(...)` - module-authored system prompt
-- `defineTool(...)` - typed executable integration in `tools/<name>.ts`
-- `defineBashTool(...)` - model-visible shell tool targeting a named sandbox
-- `defineReadFileTool(...)` - model-visible file reader targeting a named sandbox
-- `defineWriteFileTool(...)` - model-visible file writer targeting a named sandbox
-- `disableTool()` - disable the framework default whose name matches `tools/<name>.ts`
+- `defineTool(...)` - typed executable integration in `tools/<name>.ts` (`experimental-ash/tools`)
+- `defineBashTool(...)` - model-visible shell tool targeting a named sandbox (`experimental-ash/tools`)
+- `defineReadFileTool(...)` - model-visible file reader targeting a named sandbox (`experimental-ash/tools`)
+- `defineWriteFileTool(...)` - model-visible file writer targeting a named sandbox (`experimental-ash/tools`)
+- `disableTool()` - disable the framework default whose name matches `tools/<name>.ts` (`experimental-ash/tools`)
 - `disableRoute()` - disable a framework-owned route that matches the file path
-- `defineEvalSuite(...)` - repeatable eval suite under `evals/*.eval.ts`
+- `defineEvalSuite(...)` - repeatable eval suite under `evals/*.eval.ts` (`experimental-ash/evals`)
 
 Framework defaults reachable for spread/wrap composition:
 
@@ -40,20 +43,19 @@ Most apps use `defineAgent`, `defineTool`, and `defineSandbox` the most.
 
 ## Runtime Helpers
 
-- `getSession()` - current session, turn, auth, and optional parent lineage
-- `getContext(key)` - read one durable authored context value
-- `setContext(key, value)` - write one durable authored context value
-- `ensureContext(key, valueOrFactory)` - read-or-create one durable context value
-- `getSandbox(name)` - live named sandbox session
-- `getSkill(identifier)` - handle for a named skill visible to the current agent
+Each runtime accessor lives on the subpath that owns its concern:
 
-Related exported types:
+- `getSession()` - current session, turn, auth, and optional parent lineage (`experimental-ash/context`)
+- `getSandbox(name)` - live named sandbox session (`experimental-ash/sandboxes`)
+- `getSkill(identifier)` - handle for a named skill visible to the current agent (`experimental-ash/skills`)
+- `getContext(key)` / `requireContext(key)` / `hasContext(key)` / `setContext(key)` / `ensureContext(key, factory)` - unified context helpers (`experimental-ash/context`)
 
-- `Session`, `SessionAuth`, `SessionAuthContext`, `SessionParent`, `SessionTurn`
-- `SkillHandle`, `SkillResource`
-- `RunMode`
-- `ContextKey`, `ContextKeyOptions`, `AshContext`
-- eval types from `experimental-ash/evals`
+Related exported types by subpath:
+
+- `experimental-ash/context`: `Session`, `SessionAuth`, `SessionAuthContext`, `SessionParent`, `SessionTurn`, `ContextKey`, `ContextKeyOptions`, `ContextProvider`, `ContextReader`, `ContextAccessor`, `AshContext`
+- `experimental-ash/skills`: `SkillHandle`, `SkillResource`, `SkillDefinition`
+- `experimental-ash`: `RunMode`
+- `experimental-ash/evals`: eval types
 
 Ash also exports lower-level runtime primitives such as `createToolLoopHarness(...)`,
 `createContinuousLoopRuntime(...)`, and `createWorkflowRuntime(...)`.
@@ -63,8 +65,6 @@ sessions must finish inside the current invocation.
 
 These helpers only work inside active authored runtime execution.
 
-Breaking change details and before/after examples live in [`migration-guide.md`](./migration-guide.md).
-
 ## Markdown Helpers
 
 Ash also exports helpers for turning markdown into the same shapes as module-authored definitions:
@@ -96,18 +96,24 @@ import { vercelOidc } from "experimental-ash/channels/auth";
 ### Typed Tool
 
 ```ts
-import { getSession } from "experimental-ash";
+import { getSession } from "experimental-ash/context";
 import { defineTool } from "experimental-ash/tools";
 ```
 
 ### Sandbox Access
 
 ```ts
-import { getSandbox } from "experimental-ash";
+import { getSandbox } from "experimental-ash/sandboxes";
 import { defineTool } from "experimental-ash/tools";
 import { defineBashTool } from "experimental-ash/tools";
 ```
 
+### Skill Access
+
+```ts
+import { defineSkill, getSkill } from "experimental-ash/skills";
+```
+
 ### Wrapping Or Disabling A Framework Default
 
 ```ts
@@ -138,11 +144,10 @@ import { Braintrust } from "experimental-ash/evals/reporters";
 - `defineRoute` and route/channel factories -> [`channels/README.md`](./channels/README.md)
 - `defineTool`, `disableTool`, `defineBashTool`, `defineReadFileTool`, `defineWriteFileTool`, and `experimental-ash/tools/defaults` -> [`tools.md`](./tools.md)
 - `defineSandbox` and `getSandbox` -> [`sandboxes.md`](./sandboxes.md)
+- `defineSkill` and `getSkill` -> [`skills.md`](./skills.md)
 - `getSession` -> [`session-context.md`](./session-context.md)
-- `getSkill` -> [`session-context.md`](./session-context.md)
 - `defineSubagent` -> [`subagents.md`](./subagents.md)
 - `defineSchedule` -> [`schedules.md`](./schedules.md)
-- `defineSkill` -> [`skills.md`](./skills.md)
 - `defineEvalSuite`, loaders, reporters, and scorers -> [`evals.md`](./evals.md)
 
 ## Practical Advice

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.2.0-alpha.21",
+  "version": "0.2.0-alpha.23",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -82,6 +82,16 @@
       "import": "./dist/src/evals/scores/index.js",
       "default": "./dist/src/evals/scores/index.js"
     },
+    "./skills": {
+      "types": "./dist/src/public/skills/index.d.ts",
+      "import": "./dist/src/public/skills/index.js",
+      "default": "./dist/src/public/skills/index.js"
+    },
+    "./context": {
+      "types": "./dist/src/public/context/index.d.ts",
+      "import": "./dist/src/public/context/index.js",
+      "default": "./dist/src/public/context/index.js"
+    },
     "./channels": {
       "types": "./dist/src/public/channels/index.d.ts",
       "import": "./dist/src/public/channels/index.js",

package/dist/src/context/durable-context.d.ts

@@ -1,18 +0,0 @@
-import type { HarnessSession } from "../harness/types.js";
-import type { AshContext } from "./container.js";
-/**
- * Hydrates all durable context values from `session.context`.
- *
- * Unknown keys are ignored. Keys without a persisted value remain absent until
- * authored code or a channel explicitly sets or ensures them.
- */
-export declare function hydrateDurableContext(ctx: AshContext, session: HarnessSession): Promise<void>;
-/**
- * Serializes all durable context values currently set on the context.
- */
-export declare function serializeDurableContext(ctx: AshContext): Record<string, unknown>;
-/**
- * Commits the full durable context bag back to `session.context`.
- */
-export declare function commitDurableContext(ctx: AshContext, session: HarnessSession): HarnessSession;
-//# sourceMappingURL=durable-context.d.ts.map

package/dist/src/context/durable-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"durable-context.d.ts","sourceRoot":"","sources":["../../../src/context/durable-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CAef;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYhF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,GAAG,cAAc,CAY7F"}

package/dist/src/context/durable-context.js

@@ -1,49 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import { isDurableContextKey, resolveContextKey } from "./key.js";
-/**
- * Hydrates all durable context values from `session.context`.
- *
- * Unknown keys are ignored. Keys without a persisted value remain absent until
- * authored code or a channel explicitly sets or ensures them.
- */
-export async function hydrateDurableContext(ctx, session) {
-    const data = session.context ?? {};
-    for (const [name, raw] of Object.entries(data)) {
-        if (raw === undefined) {
-            continue;
-        }
-        const key = resolveContextKey(name);
-        if (key === undefined) {
-            continue;
-        }
-        ctx.set(key, key.codec ? await key.codec.deserialize(raw, ctx) : raw);
-    }
-}
-/**
- * Serializes all durable context values currently set on the context.
- */
-export function serializeDurableContext(ctx) {
-    const data = {};
-    for (const [key, value] of ctx.entries()) {
-        if (!isDurableContextKey(key) || value === undefined) {
-            continue;
-        }
-        data[key.name] = key.codec ? key.codec.serialize(value) : value;
-    }
-    return data;
-}
-/**
- * Commits the full durable context bag back to `session.context`.
- */
-export function commitDurableContext(ctx, session) {
-    const nextContext = serializeDurableContext(ctx);
-    const currentContext = session.context ?? {};
-    if (isDeepStrictEqual(nextContext, currentContext)) {
-        return session;
-    }
-    return {
-        ...session,
-        context: Object.keys(nextContext).length > 0 ? nextContext : undefined,
-    };
-}
-//# sourceMappingURL=durable-context.js.map

package/dist/src/context/durable-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"durable-context.js","sourceRoot":"","sources":["../../../src/context/durable-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAI9C,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElE;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,GAAe,EACf,OAAuB;IAEvB,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;IAEnC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/C,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,SAAS;QACX,CAAC;QAED,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,SAAS;QACX,CAAC;QAED,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACxE,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAe;IACrD,MAAM,IAAI,GAA4B,EAAE,CAAC;IAEzC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACrD,SAAS;QACX,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAClE,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAe,EAAE,OAAuB;IAC3E,MAAM,WAAW,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IACjD,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;IAE7C,IAAI,iBAAiB,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE,CAAC;QACnD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO;QACL,GAAG,OAAO;QACV,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;KACvE,CAAC;AACJ,CAAC"}

package/dist/src/execution/step-context.d.ts

@@ -1,27 +0,0 @@
-import type { Channel, DeliverPayload, SessionAuthContext } from "../channel/types.js";
-import type { AshContext } from "../context/container.js";
-import type { HarnessSession, StepInput, StepResult } from "../harness/types.js";
-export interface StepDeliveryInput {
-    readonly auth?: SessionAuthContext | null;
-    readonly payload: DeliverPayload;
-}
-export interface PreparedStepContext {
-    readonly channel: Channel;
-    readonly channelStateSnapshot: Record<string, unknown>;
-    readonly ctx: AshContext;
-    readonly input: StepInput | undefined;
-}
-export declare function prepareStepContext(input: {
-    readonly delivery?: StepDeliveryInput;
-    readonly serializedRuntimeContext: Record<string, unknown>;
-    readonly session: HarnessSession;
-}): Promise<PreparedStepContext>;
-/**
- * Runs one step inside the provider lifecycle and asserts that the
- * channel's serialized state was not mutated during execution.
- *
- * Combines {@link runStep} with a post-step channel stability check so
- * callers do not need to repeat the three-call sequence themselves.
- */
-export declare function runStepWithChannelGuard(prepared: PreparedStepContext, session: HarnessSession, callback: (session: HarnessSession) => Promise<StepResult>): Promise<StepResult>;
-//# sourceMappingURL=step-context.d.ts.map

package/dist/src/execution/step-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step-context.d.ts","sourceRoot":"","sources":["../../../src/execution/step-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAM1D,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;CACvC;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3D,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA0B/B;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,UAAU,CAAC,GACzD,OAAO,CAAC,UAAU,CAAC,CAQrB"}