💥 Rename DurableCtx to DurableContext

packages/core/src/execute.ts

@@ -834,7 +834,7 @@ function* executeDocument(options: ExecuteOptions): Operation<DocumentExecution>
       yield* LiveFailure.set(liveFailure);
 
       // Create per-document eval scope (spec §3.1).
-      // Created in the same scope as durableRun so that DurableCtx
+      // Created in the same scope as durableRun so that DurableContext
       // (set by durableRun) is visible to eval code that calls
       // renderChildren → importComponent → createDurableOperation.
       const rootEvalScope = yield* useEvalScope();

packages/core/src/loop.ts

@@ -1,12 +1,11 @@
 import { createContext, useScope } from "effection";
 import type { Context, Operation } from "effection";
-import { createDurableOperation, DurableCtx, StaleInputError } from "@executablemd/durable-streams";
-import type {
+import {
+  createDurableOperation,
   DurableContext,
-  EffectDescription,
-  Json,
-  Workflow,
+  StaleInputError,
 } from "@executablemd/durable-streams";
+import type { EffectDescription, Json, Workflow } from "@executablemd/durable-streams";
 
 /**
  * The loop a `<Break>` exits (spec §6.5 `<Loop>`).
@@ -191,5 +190,5 @@ export function* recordOutcome(identity: LoopIdentity, record: LoopRecord): Oper
 
 function* durableContext(): Operation<DurableContext | undefined> {
   const scope = yield* useScope();
-  return scope.get(DurableCtx);
+  return scope.get(DurableContext);
 }

packages/durable-streams/combinators.ts

@@ -27,7 +27,7 @@ import {
   useScope,
 } from "effection";
 import type { Operation, Task } from "effection";
-import { type DurableContext, DurableCtx } from "./context.ts";
+import { DurableContext } from "./context.ts";
 import {
   activeDurabilityFailure,
   appendDurableEvent,
@@ -46,7 +46,7 @@ import type { Close, Json, Workflow, WorkflowValue } from "./types.ts";
  *
  * It:
  *  1. Checks if the child already completed (has Close event) — short-circuits
- *  2. Sets DurableCtx on the child's scope with the child's coroutineId
+ *  2. Sets DurableContext on the child's scope with the child's coroutineId
  *  3. Runs the child workflow (its DurableEffects use the child's coroutineId)
  *  4. Appends Close(ok|err) when the child terminates
  *
@@ -102,7 +102,7 @@ function* runDurableChild<T extends WorkflowValue>(
     childCounter: 0,
     durability: parentCtx.durability,
   };
-  scope.set(DurableCtx, childCtx);
+  scope.set(DurableContext, childCtx);
 
   let closeEvent: Close | undefined;
   let suppressClose = false;
@@ -144,7 +144,7 @@ function* runDurableChild<T extends WorkflowValue>(
 
   try {
     // Run the child workflow. DurableEffects inside the child read
-    // DurableCtx from the scope, so they'll use childId.
+    // DurableContext from the scope, so they'll use childId.
     const result: T = yield* childWorkflow();
 
     const durabilityFailure = activeDurabilityFailure(childCtx);
@@ -224,7 +224,7 @@ export function durableSpawn<T extends WorkflowValue>(
   return ephemeral(
     (function* (): Operation<Task<T>> {
       const scope = yield* useScope();
-      const ctx = scope.expect<DurableContext>(DurableCtx);
+      const ctx = scope.expect<DurableContext>(DurableContext);
 
       // Assign deterministic child ID
       const childIndex = ctx.childCounter++;
@@ -256,7 +256,7 @@ export function durableAll<T extends WorkflowValue>(
   return ephemeral(
     (function* (): Operation<T[]> {
       const scope = yield* useScope();
-      const ctx = scope.expect<DurableContext>(DurableCtx);
+      const ctx = scope.expect<DurableContext>(DurableContext);
 
       // Build child Operations, one per workflow. Each gets its own
       // deterministic coroutineId and Close event handling.
@@ -303,7 +303,7 @@ export function durableRace<T extends WorkflowValue>(
   return ephemeral(
     (function* (): Operation<T> {
       const scope = yield* useScope();
-      const ctx = scope.expect<DurableContext>(DurableCtx);
+      const ctx = scope.expect<DurableContext>(DurableContext);
 
       // Build Operations for each child — each gets its own coroutineId
       // and Close event handling via runDurableChild.

packages/durable-streams/context.ts

@@ -37,5 +37,5 @@ export interface DurableContext {
  * Effection Context for durable execution state.
  * Set on the root scope by durableRun(); inherited by child scopes.
  */
-export const DurableCtx: Context<DurableContext> =
+export const DurableContext: Context<DurableContext> =
   createContext<DurableContext>("@effection/durable");

packages/durable-streams/effect.ts

@@ -21,7 +21,7 @@
  */
 
 import type { Operation } from "effection";
-import { type DurableContext, DurableCtx } from "./context.ts";
+import { DurableContext } from "./context.ts";
 import { Divergence } from "./divergence.ts";
 import {
   activeDurabilityFailure,
@@ -209,7 +209,7 @@ export function createDurableEffect<T>(
       resolve: Resolve<EffectionResult<T>>,
       routine,
     ): (resolve: Resolve<EffectionResult<void>>) => void {
-      const ctx = routine.scope.expect<DurableContext>(DurableCtx);
+      const ctx = routine.scope.expect<DurableContext>(DurableContext);
       const durabilityFailure = activeDurabilityFailure(ctx);
       if (durabilityFailure) {
         resolve({ ok: false, error: durabilityFailure });
@@ -328,7 +328,7 @@ export function createDurableOperation<T extends Json>(
       resolve: Resolve<EffectionResult<T>>,
       routine,
     ): (resolve: Resolve<EffectionResult<void>>) => void {
-      const ctx = routine.scope.expect<DurableContext>(DurableCtx);
+      const ctx = routine.scope.expect<DurableContext>(DurableContext);
       const durabilityFailure = activeDurabilityFailure(ctx);
       if (durabilityFailure) {
         resolve({ ok: false, error: durabilityFailure });

packages/durable-streams/mod.ts

@@ -59,8 +59,7 @@ export { ReplayGuard } from "./replay-guard.ts";
 export type { ReplayOutcome } from "./replay-guard.ts";
 
 // Context
-export { DurableCtx } from "./context.ts";
-export type { DurableContext } from "./context.ts";
+export { DurableContext } from "./context.ts";
 
 // Serialization utilities
 export {

packages/durable-streams/run.ts

@@ -15,7 +15,7 @@
 
 import { useScope } from "effection";
 import type { Operation, Scope } from "effection";
-import { DurableCtx } from "./context.ts";
+import { DurableContext } from "./context.ts";
 import { activeDurabilityFailure, appendDurableEvent } from "./durability.ts";
 import { EarlyReturnDivergenceError, TerminalDivergenceError } from "./errors.ts";
 import { ReplayGuard } from "./replay-guard.ts";
@@ -97,7 +97,7 @@ export function* durableRun<T extends WorkflowValue>(
     childCounter: 0,
     durability: {},
   };
-  scope.set(DurableCtx, ctx);
+  scope.set(DurableContext, ctx);
 
   // ── REPLAY GUARD: Check phase ──
   // Run before the workflow starts. Middleware can yield* for I/O (hash

packages/durable-streams/specs/DECISIONS.md

@@ -264,7 +264,7 @@ Updated before completion of every phase and committed at the end of each phase.
   runner/reducer or inside each effect.
 - **Decision:** Each `DurableEffect.enter()` handles its own replay/live
   dispatch internally, reading `DurableContext` from the scope via
-  `routine.scope.expect(DurableCtx)`.
+  `routine.scope.expect(DurableContext)`.
 - **Rationale:** Keeps the Effection reducer completely untouched. The reducer
   calls `enter()` on every effect — whether `enter()` resolves synchronously
   (replay) or asynchronously (live + persist) is invisible to it. This is
@@ -365,7 +365,7 @@ Updated before completion of every phase and committed at the end of each phase.
   the parent generator's try/catch).
 - **Consequences:** `durableAll` and `durableRace` delegate to Effection's
   native combinators. The durable layer wraps each child in an Operation
-  that (1) checks for replay short-circuit, (2) sets DurableCtx with a
+  that (1) checks for replay short-circuit, (2) sets DurableContext with a
   child coroutineId, and (3) emits Close events in finally. This is a
   thin wrapper that preserves Effection's error semantics perfectly.
 

packages/durable-streams/specs/effection-integration.md

@@ -355,7 +355,7 @@ interface DurableContext {
   childCounter: number;
 }
 
-const DurableCtx = createContext<DurableContext>("@effection/durable");
+const DurableContext = createContext<DurableContext>("@effection/durable");
 
 type Executor = (resolve: (result: Result) => void, reject: (error: Error) => void) => () => void;
 
@@ -364,7 +364,7 @@ function createDurableEffect<T>(desc: EffectDescription, execute: Executor): Dur
     description: `${desc.type}(${desc.name})`,
     effectDescription: desc,
     enter(resolve, routine) {
-      const ctx = routine.scope.expect<DurableContext>(DurableCtx);
+      const ctx = routine.scope.expect<DurableContext>(DurableContext);
       const entry = ctx.replayIndex.peekYield(ctx.coroutineId);
 
       if (entry) {
@@ -623,9 +623,9 @@ interface DurableContext {
 When `durableSpawn()` creates a child scope:
 
 ```typescript
-let parentCtx = scope.expect(DurableCtx);
+let parentCtx = scope.expect(DurableContext);
 let childId = `${parentCtx.coroutineId}.${parentCtx.childCounter++}`;
-childScope.set(DurableCtx, {
+childScope.set(DurableContext, {
   replayIndex: parentCtx.replayIndex, // shared
   stream: parentCtx.stream, // shared
   coroutineId: childId,
@@ -734,7 +734,7 @@ export function durableSpawn<T extends Json | void>(
   return ephemeral(
     (function* (): Operation<Task<T>> {
       const scope = yield* useScope();
-      const ctx = scope.expect<DurableContext>(DurableCtx);
+      const ctx = scope.expect<DurableContext>(DurableContext);
       const childId = `${ctx.coroutineId}.${ctx.childCounter++}`;
       return yield* spawn(() => runDurableChild(childWorkflow, childId, ctx));
     })(),
@@ -755,7 +755,7 @@ function* durableAll<T extends Json | void>(
   workflows: (() => Workflow<T> | Operation<T>)[],
 ): Operation<T[]> {
   const scope = yield* useScope();
-  const ctx = scope.expect<DurableContext>(DurableCtx);
+  const ctx = scope.expect<DurableContext>(DurableContext);
 
   const childOps: Operation<T>[] = workflows.map((workflow) => {
     const childId = `${ctx.coroutineId}.${ctx.childCounter++}`;
@@ -803,7 +803,7 @@ function* durableRace<T extends Json | void>(
   workflows: (() => Workflow<T> | Operation<T>)[],
 ): Operation<T> {
   const scope = yield* useScope();
-  const ctx = scope.expect<DurableContext>(DurableCtx);
+  const ctx = scope.expect<DurableContext>(DurableContext);
 
   const childOps: Operation<T>[] = workflows.map((workflow) => {
     const childId = `${ctx.coroutineId}.${ctx.childCounter++}`;
@@ -931,7 +931,7 @@ durable context, and runs the workflow:
 
 ```typescript
 const ctx = { replayIndex, stream, coroutineId, childCounter: 0, durability: {} };
-scope.set(DurableCtx, ctx);
+scope.set(DurableContext, ctx);
 replayIndex.claim(coroutineId);
 
 try {

packages/durable-streams/tests/context.test.ts

@@ -0,0 +1,28 @@
+/**
+ * The durable execution state is reachable from a workflow through the
+ * exported DurableContext, which names both the Effection context and the
+ * shape that context holds.
+ */
+
+import { describe, it } from "@executablemd/test-support/bdd";
+import { expect } from "@executablemd/test-support/expect";
+import { type Operation, useScope } from "effection";
+import { DurableContext, durableRun, InMemoryStream } from "../mod.ts";
+
+describe("DurableContext", () => {
+  it("holds the state durableRun installs on the workflow scope", function* () {
+    const stream = new InMemoryStream();
+
+    function* workflow(): Operation<string> {
+      const scope = yield* useScope();
+      const state: DurableContext = scope.expect(DurableContext);
+      expect(state.stream).toBe(stream);
+      expect(state.childCounter).toBe(0);
+      return state.coroutineId;
+    }
+
+    const coroutineId = yield* durableRun(workflow, { stream, coroutineId: "root.7" });
+
+    expect(coroutineId).toBe("root.7");
+  });
+});

specs/decisions.md

@@ -458,7 +458,7 @@ operations that cannot proceed without a provider (`importComponent`,
 `applyModifiers`, `codeBlock`, `content`) throw named missing-provider
 errors that identify the missing installation.
 
-Durable-streams' own contexts (e.g. `DurableCtx`) are unchanged: they
+Durable-streams' own contexts (e.g. `DurableContext`) are unchanged: they
 store durable runtime state, not overridable core operations.
 
 ---

specs/executable-mdx-spec.md

@@ -1337,7 +1337,7 @@ A component invocation creates its eval scope on its own expansion frame and
 runs its body inside a task that scope owns:
 
 ```
-invocation frame           expansion providers, error mode, DurableCtx
+invocation frame           expansion providers, error mode, DurableContext
 └─ evalHost
    └─ A's loop task        the invocation's eval scope
       └─ body task         the component body, its resources and its middleware