From 152a5e524f9eddb4a978a81e9f5de4ea4699a136 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 15:33:44 -0400
Subject: [PATCH 1/9] feat: component-declared output via <Output> (#88)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Components render their entire body, so documentation prose leaks into
consumers. A component (or root) now declares its rendered region with a
top-level <Output> boundary; everything outside is documentation that
executes for side effects but never renders.

- error-policy.ts: contextual ErrorPolicyCtx (collect/throw), raise, and
  DocumentationError for documentation fail-fast.
- expand.ts: source-AST structural preflight (validateOutputPlacement),
  provenance-based buildBody/expandBody, misplaced-<Output> defensive
  branch, and consumer-boundary re-raise of transported errors.
- run-document.ts: root buffers when it declares <Output> (emit once after
  success, none on failure, none when empty); streams otherwise.
- spec §5.4/§6.1/§6.2 pseudocode, new §6.9, decision row 68, test-plan rows.
- Tests: expand + run-document coverage; smoke Show.md/OutputDemo.md.
---
 AGENTS.md                       |  23 +-
 core/src/error-policy.ts        |  55 +++
 core/src/expand.ts              | 579 +++++++++++++++++++++++---------
 core/src/run-document.ts        |  42 ++-
 core/tests/expand.test.ts       | 271 +++++++++++++++
 core/tests/run-document.test.ts | 124 +++++++
 core/tests/smoke.test.ts        |   8 +
 smoke-test/OutputDemo.md        |  26 ++
 smoke-test/README.md            |  12 +
 smoke-test/Show.md              |  16 +
 specs/executable-mdx-spec.md    | 211 ++++++++++--
 11 files changed, 1179 insertions(+), 188 deletions(-)
 create mode 100644 core/src/error-policy.ts
 create mode 100644 smoke-test/OutputDemo.md
 create mode 100644 smoke-test/Show.md

diff --git a/AGENTS.md b/AGENTS.md
index ee46e49..1d7cb95 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -31,6 +31,8 @@ Do not commit if any check fails. Fix the issue first, then re-run all three.
    language in specifications or source code.
 6. Parse to infer type; Do not type cast with `as`.
 7. Do not use braceless `if` statements.
+8. Keep the release spec current — changes to the release configuration
+   require changes to specs/release-process-spec.md to match.
 
 ## PR Process
 
@@ -38,4 +40,23 @@ Do not commit if any check fails. Fix the issue first, then re-run all three.
 2. After PR is open, monitor PR for 
    1. CI failures
    2. Comments with feedback
-   3. Integrate changes feedback appears
\ No newline at end of file
+   3. Integrate changes feedback appears
+
+## Agent Roles
+
+If you're an Opus model, you're an Implementor agent.
+If you're a GPT model, you're an Planner agent.
+If you're a Fabel model, you're a Problem solver agent.
+
+### Implementor agent
+
+Writes code following Code Rules.
+
+### Planner agent
+
+##### When reviewing Implementor agent's plans**
+
+**User will ask you**: Review <subject>; verdict; prompt on failure.
+**Respond by:**
+* Interviewing user to resolve ambiguity; do not ask the Implementor agent to make decisions.
+* Writing a feedback prompt that user will handoff to the Implementor agent
diff --git a/core/src/error-policy.ts b/core/src/error-policy.ts
new file mode 100644
index 0000000..23ec243
--- /dev/null
+++ b/core/src/error-policy.ts
@@ -0,0 +1,55 @@
+/**
+ * Contextual error policy for expansion (spec §6.9).
+ *
+ * Inside a rendered region — an `<Output>` region, or anywhere when no
+ * `<Output>` is declared — an ErrorSegment renders as an HTML comment
+ * ("collect"). While executing suppressed documentation, the first
+ * ErrorSegment produced throws immediately ("throw") so it propagates to be
+ * handled above.
+ */
+
+import { createContext } from "effection";
+import type { Operation } from "effection";
+import type { ErrorSegment, Segment } from "./types.ts";
+
+export type ErrorPolicy = "collect" | "throw";
+
+/**
+ * Effection context holding the ambient error policy. Unset defaults to
+ * "collect" — today's behavior where ErrorSegments render as comments.
+ */
+export const ErrorPolicyCtx = createContext<ErrorPolicy>("errorPolicy");
+
+/**
+ * Thrown when an ErrorSegment is produced or transported into a suppressed
+ * documentation region. Carries the offending segment so callers above can
+ * inspect it.
+ */
+export class DocumentationError extends Error {
+  readonly segment: ErrorSegment;
+
+  constructor(segment: ErrorSegment) {
+    super(segment.message);
+    this.name = "DocumentationError";
+    this.segment = segment;
+  }
+}
+
+/** Read the ambient error policy, defaulting to "collect" when unset. */
+export function* currentErrorPolicy(): Operation<ErrorPolicy> {
+  const policy = yield* ErrorPolicyCtx.get();
+  return policy ?? "collect";
+}
+
+/**
+ * Route an ErrorSegment through the ambient policy. Under "throw" it raises a
+ * DocumentationError (fail-fast); under "collect" it returns the segment so
+ * the caller renders it as a comment.
+ */
+export function* raise(segment: ErrorSegment): Operation<Segment[]> {
+  const policy = yield* currentErrorPolicy();
+  if (policy === "throw") {
+    throw new DocumentationError(segment);
+  }
+  return [segment];
+}
diff --git a/core/src/expand.ts b/core/src/expand.ts
index 96dfb5b..26c61b8 100644
--- a/core/src/expand.ts
+++ b/core/src/expand.ts
@@ -19,7 +19,9 @@ import { ContentCtx } from "./content-context.ts";
 import type { ContentHandle } from "./content-context.ts";
 import type {
   Segment,
+  TextSegment,
   ErrorSegment,
+  ComponentInvocation,
   ComponentDefinition,
   FunctionComponentDefinition,
   Json,
@@ -31,6 +33,7 @@ import { interpolate } from "./interpolate.ts";
 import { interpolateEvalBindings } from "./eval-interpolate.ts";
 import { EvalEnvCtx, EvalScopeCtx } from "./eval-env.ts";
 import type { EvalEnv } from "./eval-env.ts";
+import { ErrorPolicyCtx, DocumentationError, currentErrorPolicy, raise } from "./error-policy.ts";
 import { useEvalScope, unbox } from "@effectionx/scope-eval";
 import type { EvalScope } from "@effectionx/scope-eval";
 import { validateProps } from "./validate.ts";
@@ -124,6 +127,15 @@ export function* expandSegments(
       }
 
       case "component": {
+        if (segment.name === "Output") {
+          // Definition-owned <Output> is consumed by buildBody before it
+          // reaches here. Reaching this branch means a misplaced or
+          // dynamically scanned <Output> (e.g. render(markdown) content) —
+          // diagnose it defensively per the ambient policy.
+          result.push(...(yield* raise(misplacedOutputError())));
+          break;
+        }
+
         if (segment.name === "Capture") {
           const captureResult = yield* expandCapture(
             segment,
@@ -134,7 +146,7 @@ export function* expandSegments(
             counter,
           );
           if (captureResult) {
-            result.push(captureResult);
+            result.push(...(yield* raise(captureResult)));
           }
           break;
         }
@@ -149,7 +161,15 @@ export function* expandSegments(
           counter,
           segment.projectedEnv,
         );
-        result.push(...expanded);
+        // Consumer boundary: re-raise transported error segments under the
+        // ambient policy before appending them (spec §6.9).
+        for (const expandedSegment of expanded) {
+          if (expandedSegment.type === "error") {
+            result.push(...(yield* raise(expandedSegment)));
+          } else {
+            result.push(expandedSegment);
+          }
+        }
         break;
       }
 
@@ -183,11 +203,13 @@ export function* expandSegments(
           const codeResult = yield* ctx.runModifierChain(segment.modifiers, context);
 
           if (codeResult.exitCode !== 0 && codeResult.output === "") {
-            result.push({
-              type: "error",
-              message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
-              source: segment.content,
-            });
+            result.push(
+              ...(yield* raise({
+                type: "error",
+                message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
+                source: segment.content,
+              })),
+            );
           } else if (codeResult.output !== "") {
             result.push({
               type: "execOutput",
@@ -201,17 +223,31 @@ export function* expandSegments(
           }
           // If output is empty and exit code is 0, nothing added (e.g., silent)
         } catch (error) {
-          result.push({
-            type: "error",
-            message: error instanceof Error ? error.message : String(error),
-            source: segment.content,
-          });
+          // A DocumentationError from nested expansion (e.g. renderChildren
+          // inside an eval block) is our own fail-fast — never swallow it.
+          if (error instanceof DocumentationError) {
+            throw error;
+          }
+          result.push(
+            ...(yield* raise({
+              type: "error",
+              message: error instanceof Error ? error.message : String(error),
+              source: segment.content,
+            })),
+          );
         }
         break;
       }
 
-      default:
-        result.push(segment);
+      default: {
+        if (segment.type === "error") {
+          // Pre-existing error segments (e.g. slot/substitution errors) follow
+          // the ambient policy.
+          result.push(...(yield* raise(segment)));
+        } else {
+          result.push(segment);
+        }
+      }
     }
   }
 
@@ -336,39 +372,33 @@ function* expandComponent(
 ): Operation<Segment[]> {
   // Cycle detection — Prosser's algorithm
   if (hideSet.has(name)) {
-    return [
-      {
-        type: "error",
-        message: `Cycle detected: ${name} is already being expanded (hide set: ${[...hideSet].join(" → ")})`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: `Cycle detected: ${name} is already being expanded (hide set: ${[...hideSet].join(" → ")})`,
+      source: name,
+    });
   }
 
   if (hideSet.size >= MAX_EXPANSION_DEPTH) {
-    return [
-      {
-        type: "error",
-        message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
+      source: name,
+    });
   }
 
   let imported: ComponentDefinition | FunctionComponentDefinition;
   try {
     imported = yield* ctx.importComponent(name);
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message:
-          error instanceof Error
-            ? `Failed to import component ${name}: ${error.message}`
-            : `Failed to import component ${name}: ${String(error)}`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message:
+        error instanceof Error
+          ? `Failed to import component ${name}: ${error.message}`
+          : `Failed to import component ${name}: ${String(error)}`,
+      source: name,
+    });
   }
 
   // Function component: call the generator function directly
@@ -388,6 +418,15 @@ function* expandComponent(
 
   const definition = imported;
 
+  // Structural preflight (spec §6.9): validate <Output> placement against the
+  // component's own source AST before any part of its body executes. A
+  // structurally invalid component runs no eval, exec, Capture, nested
+  // components, or other side effects.
+  const placementError = validateOutputPlacement(definition.bodySegments);
+  if (placementError) {
+    return yield* raise(placementError);
+  }
+
   // Resolve eval expression props against env.values using the shared
   // VM context. This must happen before validation so that resolved
   // values can be type-checked. See spec §5.1 (expression prop evaluation).
@@ -395,23 +434,19 @@ function* expandComponent(
   try {
     resolvedProps = yield* resolveExpressionProps(props, expressions, name, projectedEnv);
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+      source: name,
+    });
   }
 
   if ("as" in expressions) {
-    return [
-      {
-        type: "error",
-        message: `Prop "as" on <${name} /> must be a string literal.`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: `Prop "as" on <${name} /> must be a string literal.`,
+      source: name,
+    });
   }
 
   // Validate props against declared inputs.
@@ -429,13 +464,11 @@ function* expandComponent(
     const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps;
     validatedProps = validateProps(name, propsForValidation, definition.inputs);
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+      source: name,
+    });
   }
 
   // Capture the caller's eval environment before creating the component's
@@ -452,19 +485,6 @@ function* expandComponent(
     ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
     : contextEnv;
 
-  // Substitute raw children into <Content /> positions. Children are NOT
-  // pre-expanded — they expand in document order when the component body
-  // is expanded. This ensures eval blocks before <Content /> (e.g.,
-  // provider middleware installation) run before children's code blocks.
-  // Children segments are tagged with callerEvalEnv so expression props
-  const substituted = substituteContent(
-    definition.bodySegments,
-    children,
-    definition.meta,
-    validatedProps,
-    callerEvalEnv ?? undefined,
-  );
-
   // Recurse with augmented hide set.
   // Each component gets its own fresh binding environment so that
   // eval blocks within a component share bindings but don't leak
@@ -588,40 +608,49 @@ function* expandComponent(
     });
   };
 
+  // Expand the body through expandBody, which renders only the declared
+  // <Output> regions (executing documentation for side effects) when the
+  // definition declares output, and renders the whole body otherwise.
   const expanded = yield* EvalEnvCtx.with(componentEnv, function* () {
     if (childEvalScope) {
       return yield* EvalScopeCtx.with(childEvalScope, function* () {
-        return yield* expandSegments(
-          substituted,
+        return yield* expandBody(
+          definition.bodySegments,
+          children,
           definition.meta,
           validatedProps,
           newHideSet,
           ctx,
           counter,
+          callerEvalEnv ?? undefined,
         );
       });
     }
-    return yield* expandSegments(
-      substituted,
+    return yield* expandBody(
+      definition.bodySegments,
+      children,
       definition.meta,
       validatedProps,
       newHideSet,
       ctx,
       counter,
+      callerEvalEnv ?? undefined,
     );
   });
 
   if (asBinding) {
     const parentEnv = yield* EvalEnvCtx.get();
     if (!parentEnv) {
-      return [
-        {
-          type: "error",
-          message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
-          source: name,
-        },
-      ];
+      return yield* raise({
+        type: "error",
+        message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
+        source: name,
+      });
     }
+    // Consumer boundary (spec §6.9): re-raise transported errors under the
+    // ambient policy so documentation never captures and hides an error
+    // comment.
+    yield* consume(expanded);
     parentEnv.values[asBinding] = renderSegments(expanded);
     return [];
   }
@@ -652,13 +681,11 @@ function* expandFunctionComponent(
   projectedEnv?: EvalEnv,
 ): Operation<Segment[]> {
   if ("as" in expressions) {
-    return [
-      {
-        type: "error",
-        message: `Prop "as" on <${name} /> must be a string literal.`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: `Prop "as" on <${name} /> must be a string literal.`,
+      source: name,
+    });
   }
 
   // Resolve expression props
@@ -666,25 +693,21 @@ function* expandFunctionComponent(
   try {
     resolvedProps = yield* resolveExpressionProps(props, expressions, name, projectedEnv);
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+      source: name,
+    });
   }
 
   // Strip slot prop before validation
   const asBindingResult = validateBindingName(resolvedProps.as);
   if (!asBindingResult.ok) {
-    return [
-      {
-        type: "error",
-        message: `Prop "as" on <${name} /> ${asBindingResult.error}`,
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: `Prop "as" on <${name} /> ${asBindingResult.error}`,
+      source: name,
+    });
   }
   const asBinding = asBindingResult.value;
   const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps;
@@ -694,13 +717,11 @@ function* expandFunctionComponent(
   try {
     validatedProps = validateProps(name, propsForValidation, definition.inputs);
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        source: name,
-      },
-    ];
+    return yield* raise({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+      source: name,
+    });
   }
 
   // Set ContentCtx on the scope so the function component can
@@ -730,29 +751,30 @@ function* expandFunctionComponent(
     if (asBinding) {
       const parentEnv = yield* EvalEnvCtx.get();
       if (!parentEnv) {
-        return [
-          {
-            type: "error",
-            message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
-            source: name,
-          },
-        ];
+        return yield* raise({
+          type: "error",
+          message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
+          source: name,
+        });
       }
       parentEnv.values[asBinding] = output;
       return [];
     }
     return [{ type: "text", content: output }];
   } catch (error) {
-    return [
-      {
-        type: "error",
-        message:
-          error instanceof Error
-            ? `Function component ${name} error: ${error.message}`
-            : `Function component ${name} error: ${String(error)}`,
-        source: name,
-      },
-    ];
+    // A DocumentationError from a content-rendering path (renderDefault /
+    // useContent) is fail-fast — propagate it unchanged.
+    if (error instanceof DocumentationError) {
+      throw error;
+    }
+    return yield* raise({
+      type: "error",
+      message:
+        error instanceof Error
+          ? `Function component ${name} error: ${error.message}`
+          : `Function component ${name} error: ${String(error)}`,
+      source: name,
+    });
   }
 }
 
@@ -982,6 +1004,72 @@ export function stripSlotProp(segment: Segment): Segment {
 // Content slot substitution (spec §6.3)
 // ---------------------------------------------------------------------------
 
+/** Projects the caller's eval env onto substituted children. */
+type ProjectFn = (segments: Segment[]) => Segment[];
+
+/** Mutable flag so slot validation errors are emitted only once. */
+interface SubstitutionState {
+  errorsEmitted: boolean;
+}
+
+/**
+ * Build the projection function that tags substituted children with the
+ * caller's eval env so their expression props resolve in the caller's scope.
+ */
+function makeProjectFn(callerEnv: EvalEnv | undefined): ProjectFn {
+  const project: ProjectFn = (segments) => {
+    if (!callerEnv) {
+      return segments;
+    }
+    return segments.map((seg) => {
+      if (seg.type === "component") {
+        return {
+          ...seg,
+          projectedEnv: callerEnv,
+          children: project(seg.children),
+        };
+      }
+      return seg;
+    });
+  };
+  return project;
+}
+
+/**
+ * Replace `<Content />` / `<Content slot="X" />` in a segment list with the
+ * caller's children (partitioned by slot) and interpolate {meta}/{props} in
+ * text. Slot validation errors are emitted once, at the first projection
+ * point, tracked via the shared `state`.
+ */
+function substituteSegmentList(
+  segments: Segment[],
+  slots: SlotMap,
+  meta: Record<string, unknown>,
+  props: Record<string, Json>,
+  project: ProjectFn,
+  state: SubstitutionState,
+): Segment[] {
+  return segments.flatMap((segment) => {
+    if (segment.type === "component" && segment.name === "Content") {
+      const targetSlot = segment.props.slot;
+      const pendingErrors = !state.errorsEmitted ? slots.errors : [];
+      if (pendingErrors.length > 0) {
+        state.errorsEmitted = true;
+      }
+
+      if (targetSlot !== undefined) {
+        const slotKey = String(targetSlot);
+        return [...pendingErrors, ...project((slots.named.get(slotKey) ?? []).map(stripSlotProp))];
+      }
+      return [...pendingErrors, ...project(slots.default)];
+    }
+    if (segment.type === "text") {
+      return [{ ...segment, content: interpolate(segment.content, meta, props) }];
+    }
+    return [segment];
+  });
+}
+
 /**
  * Replace `<Content />` and `<Content slot="X" />` invocations with the
  * caller's children, partitioned by slot assignment.
@@ -998,49 +1086,210 @@ function substituteContent(
   callerEnv?: EvalEnv,
 ): Segment[] {
   const slots = partitionBySlot(children);
-  // Track whether errors have been emitted (only emit once)
-  let errorsEmitted = false;
+  const state: SubstitutionState = { errorsEmitted: false };
+  const project = makeProjectFn(callerEnv);
+  return substituteSegmentList(bodySegments, slots, meta, props, project, state);
+}
 
-  // Tag projected children with the caller's eval env so expression
-  const tagProjected = (segments: Segment[]): Segment[] => {
-    if (!callerEnv) return segments;
-    return segments.map((seg) => {
-      if (seg.type === "component") {
-        return {
-          ...seg,
-          projectedEnv: callerEnv,
-          children: tagProjected(seg.children),
-        };
+// ---------------------------------------------------------------------------
+// Component-declared output: <Output> (spec §6.9)
+// ---------------------------------------------------------------------------
+
+/** A body chunk produced by buildBody: a rendered output region or documentation. */
+interface BodyChunk {
+  output: boolean;
+  segments: Segment[];
+}
+
+/** True when a top-level segment is an `<Output>` declaration. */
+function isTopLevelOutput(segment: Segment): boolean {
+  return segment.type === "component" && segment.name === "Output";
+}
+
+/** True when the definition body declares at least one top-level `<Output>`. */
+export function bodyHasOutput(bodySegments: Segment[]): boolean {
+  return bodySegments.some(isTopLevelOutput);
+}
+
+/** The diagnostic for a misplaced `<Output>` tag. */
+function misplacedOutputError(): ErrorSegment {
+  return {
+    type: "error",
+    message:
+      "<Output> must be a direct top-level child of the component or document " +
+      "that declares it. For conditional rendering, use <Show> inside <Output>.",
+    source: "Output",
+  };
+}
+
+/** A short, stable preview of an `<Output>` region for aggregate diagnostics. */
+function previewOutput(segment: ComponentInvocation): string {
+  const text = segment.children
+    .filter((child): child is TextSegment => child.type === "text")
+    .map((child) => child.content)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (text.length === 0) {
+    return "<Output> (empty)";
+  }
+  const clipped = text.slice(0, 40);
+  return `<Output> containing "${clipped}${text.length > 40 ? "…" : ""}"`;
+}
+
+/**
+ * Structural preflight (spec §6.9). Validates `<Output>` placement against the
+ * body's own source AST. Only a direct top-level `<Output>` is a valid
+ * declaration; any `<Output>` at depth > 0 — including inside unreachable or
+ * discarded children — is a placement violation. All violations are combined
+ * into a single aggregate ErrorSegment. Returns undefined when placement is
+ * valid.
+ */
+export function validateOutputPlacement(bodySegments: Segment[]): ErrorSegment | undefined {
+  const violations: string[] = [];
+
+  const walk = (segments: Segment[], depth: number): void => {
+    for (const segment of segments) {
+      if (segment.type !== "component") {
+        continue;
       }
-      return seg;
-    });
+      if (segment.name === "Output" && depth > 0) {
+        violations.push(previewOutput(segment));
+      }
+      walk(segment.children, depth + 1);
+    }
   };
 
-  return bodySegments.flatMap((segment) => {
-    if (segment.type === "component" && segment.name === "Content") {
-      const targetSlot = segment.props.slot as string | undefined;
-      // Emit slot validation errors at the first Content projection point
-      const pendingErrors = !errorsEmitted ? slots.errors : [];
-      if (pendingErrors.length > 0) errorsEmitted = true;
+  walk(bodySegments, 0);
 
-      if (targetSlot !== undefined) {
-        // Named slot projection — strip slot prop from each child
-        return [
-          ...pendingErrors,
-          ...tagProjected((slots.named.get(targetSlot) ?? []).map(stripSlotProp)),
-        ];
+  if (violations.length === 0) {
+    return undefined;
+  }
+
+  const list = violations.map((entry) => `  - ${entry}`).join("\n");
+  return {
+    type: "error",
+    message:
+      "<Output> must be a direct top-level child of the component or document " +
+      "that declares it. For conditional rendering, use <Show> inside " +
+      `<Output>. Misplaced <Output> found:\n${list}`,
+    source: "Output",
+  };
+}
+
+/** Validate that a top-level `<Output>` carries no props. */
+function validateOutputProps(segment: ComponentInvocation): ErrorSegment | undefined {
+  const hasProps = Object.keys(segment.props).length > 0;
+  const hasExpressions = Object.keys(segment.expressions).length > 0;
+  if (hasProps || hasExpressions) {
+    return { type: "error", message: "<Output> accepts no props.", source: "Output" };
+  }
+  return undefined;
+}
+
+/**
+ * Partition a definition body into ordered chunks (spec §6.9). Output policy
+ * is determined by definition provenance — top-level `<Output>` segments in
+ * the source, before `<Content />` substitution — so caller-projected
+ * `<Output>` can neither activate nor alter it. `<Content />` inside a
+ * top-level `<Output>` is substituted one level in; slot errors are emitted
+ * once across the whole body via the shared substitution state.
+ */
+function buildBody(
+  bodySegments: Segment[],
+  children: Segment[],
+  meta: Record<string, unknown>,
+  props: Record<string, Json>,
+  callerEnv: EvalEnv | undefined,
+): BodyChunk[] {
+  const slots = partitionBySlot(children);
+  const state: SubstitutionState = { errorsEmitted: false };
+  const project = makeProjectFn(callerEnv);
+  const chunks: BodyChunk[] = [];
+
+  for (const segment of bodySegments) {
+    if (segment.type === "component" && segment.name === "Output") {
+      const propsError = validateOutputProps(segment);
+      if (propsError) {
+        chunks.push({ output: true, segments: [propsError] });
+        continue;
       }
-      // Default slot projection
-      return [...pendingErrors, ...tagProjected(slots.default)];
+      const outputSegments = substituteSegmentList(
+        segment.children,
+        slots,
+        meta,
+        props,
+        project,
+        state,
+      );
+      chunks.push({ output: true, segments: outputSegments });
+      continue;
     }
-    if (segment.type === "text") {
-      return [
-        {
-          ...segment,
-          content: interpolate(segment.content, meta, props),
-        },
-      ];
+
+    const docSegments = substituteSegmentList([segment], slots, meta, props, project, state);
+    chunks.push({ output: false, segments: docSegments });
+  }
+
+  return chunks;
+}
+
+/**
+ * Expand a definition body (spec §6.9). Without a top-level `<Output>`, the
+ * whole body renders (backward compatible). With `<Output>`, only the declared
+ * regions render; documentation executes for its side effects under a "throw"
+ * policy (fail-fast) and its rendered result is discarded; output regions run
+ * under "collect" (errors render as comments). Regions and documentation run
+ * in document order, so output can depend on bindings computed by preceding
+ * documentation.
+ */
+export function* expandBody(
+  bodySegments: Segment[],
+  children: Segment[],
+  meta: Record<string, unknown>,
+  props: Record<string, Json>,
+  hideSet: Set<string>,
+  ctx: ExpansionContext,
+  counter: BlockCounter,
+  callerEnv: EvalEnv | undefined,
+): Operation<Segment[]> {
+  if (!bodyHasOutput(bodySegments)) {
+    const substituted = substituteContent(bodySegments, children, meta, props, callerEnv);
+    return yield* expandSegments(substituted, meta, props, hideSet, ctx, counter);
+  }
+
+  const chunks = buildBody(bodySegments, children, meta, props, callerEnv);
+  const output: Segment[] = [];
+
+  for (const chunk of chunks) {
+    if (chunk.output) {
+      const expanded = yield* ErrorPolicyCtx.with("collect", function* () {
+        return yield* expandSegments(chunk.segments, meta, props, hideSet, ctx, counter);
+      });
+      output.push(...expanded);
+    } else {
+      // Documentation: execute for side effects, discard rendered output.
+      yield* ErrorPolicyCtx.with("throw", function* () {
+        return yield* expandSegments(chunk.segments, meta, props, hideSet, ctx, counter);
+      });
     }
-    return [segment];
-  });
+  }
+
+  return output;
+}
+
+/**
+ * Consumer boundary (spec §6.9). When consuming a component's returned
+ * segments in a documentation context, re-raise the first transported error
+ * so it is never captured and hidden. Under "collect" it is a no-op.
+ */
+function* consume(segments: Segment[]): Operation<void> {
+  const policy = yield* currentErrorPolicy();
+  if (policy !== "throw") {
+    return;
+  }
+  for (const segment of segments) {
+    if (segment.type === "error") {
+      throw new DocumentationError(segment);
+    }
+  }
 }
diff --git a/core/src/run-document.ts b/core/src/run-document.ts
index e8480a9..ace6af4 100644
--- a/core/src/run-document.ts
+++ b/core/src/run-document.ts
@@ -31,7 +31,13 @@ import type {
 } from "./types.ts";
 import { scanSegments } from "./scanner.ts";
 import { parseFrontmatter } from "./frontmatter.ts";
-import { expandSegments, createBlockCounter } from "./expand.ts";
+import {
+  expandSegments,
+  expandBody,
+  bodyHasOutput,
+  validateOutputPlacement,
+  createBlockCounter,
+} from "./expand.ts";
 import type { ExpansionContext } from "./expand.ts";
 import { renderSegment } from "./render.ts";
 import { DocumentOutput } from "./api.ts";
@@ -285,6 +291,40 @@ function* documentWorkflow(
   // The EvalEnvCtx.with() wraps the entire loop so all segments share
   // the same binding environment.
   const scopedExpansion: Operation<string> = EvalEnvCtx.with(env, function* () {
+    // Structural preflight (spec §6.9): a root with misplaced <Output>
+    // executes no body side effects; the aggregate diagnostic renders as a
+    // comment (root policy is "collect").
+    const placementError = validateOutputPlacement(root.bodySegments);
+    if (placementError) {
+      const text = renderSegment(placementError);
+      yield* ephemeral(DocumentOutput.operations.output(text));
+      return text;
+    }
+
+    // A root declaring top-level <Output> buffers completely (spec §5.4):
+    // execute the whole body, then emit the selected regions only after
+    // successful completion. A documentation failure throws before any emit,
+    // so no partial output is produced.
+    if (bodyHasOutput(root.bodySegments)) {
+      const expanded = yield* expandBody(
+        root.bodySegments,
+        [],
+        root.meta,
+        {},
+        new Set(),
+        ctx,
+        counter,
+        undefined,
+      );
+      const text = expanded.map(renderSegment).join("");
+      // An empty buffered root emits no output event.
+      if (text) {
+        yield* ephemeral(DocumentOutput.operations.output(text));
+      }
+      return text;
+    }
+
+    // Per-root-segment emission loop for roots without <Output> (spec §5.4).
     const chunks: string[] = [];
 
     for (const segment of root.bodySegments) {
diff --git a/core/tests/expand.test.ts b/core/tests/expand.test.ts
index d41a8fe..7af6920 100644
--- a/core/tests/expand.test.ts
+++ b/core/tests/expand.test.ts
@@ -358,6 +358,277 @@ describe("expansion", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Component-declared output — <Output> (spec §6.9)
+// ---------------------------------------------------------------------------
+
+/** ExpansionContext that records executed code-block contents. */
+function recordingCtx(
+  components: Record<string, ComponentDefinition>,
+  codeResult?: CodeBlockResult,
+): { ctx: ExpansionContext; execCalls: string[] } {
+  const execCalls: string[] = [];
+  const ctx: ExpansionContext = {
+    importComponent: function* (name: string) {
+      const comp = components[name];
+      if (!comp) throw new Error(`Component not found: ${name}`);
+      return comp;
+    },
+    runModifierChain: function* (_modifiers: Modifier[], context: CodeBlockContext) {
+      execCalls.push(context.content);
+      return codeResult ?? { output: "ran\n", exitCode: 0, stderr: "" };
+    },
+  };
+  return { ctx, execCalls };
+}
+
+describe("component-declared output", () => {
+  it("renders only the <Output> region, suppressing documentation", function* () {
+    const comp = makeComponent(
+      "Warn",
+      "Docs heading.\n\n<Output>\nSHOWN\n</Output>\n\nMore docs.\n",
+    );
+    const ctx = makeCtx({ Warn: comp });
+    const output = yield* expand(scanSegments("<Warn />"), ctx);
+    expect(output).toContain("SHOWN");
+    expect(output).not.toContain("Docs heading");
+    expect(output).not.toContain("More docs");
+  });
+
+  it("without <Output> renders the complete body", function* () {
+    const comp = makeComponent("Doc", "Alpha then Beta.");
+    const ctx = makeCtx({ Doc: comp });
+    const output = yield* expand(scanSegments("<Doc />"), ctx);
+    expect(output).toContain("Alpha then Beta.");
+  });
+
+  it("concatenates multiple <Output> regions in document order", function* () {
+    const comp = makeComponent(
+      "Multi",
+      "<Output>ONE</Output>\n\nmiddle docs\n\n<Output>TWO</Output>\n",
+    );
+    const ctx = makeCtx({ Multi: comp });
+    const output = yield* expand(scanSegments("<Multi />"), ctx);
+    expect(output).not.toContain("middle docs");
+    expect(output.indexOf("ONE")).toBeGreaterThanOrEqual(0);
+    expect(output.indexOf("ONE")).toBeLessThan(output.indexOf("TWO"));
+  });
+
+  it("preserves markdown source inside <Output>, including a GitHub admonition", function* () {
+    const comp = makeComponent(
+      "Adm",
+      "docs\n\n<Output>\n> [!WARNING]\n> Careful now.\n</Output>\n",
+    );
+    const ctx = makeCtx({ Adm: comp });
+    const output = yield* expand(scanSegments("<Adm />"), ctx);
+    expect(output).toContain("> [!WARNING]");
+    expect(output).toContain("> Careful now.");
+    expect(output).not.toContain("docs");
+  });
+
+  it("treats <Output /> and <Output></Output> as equivalent empty output", function* () {
+    const selfClosing = makeComponent("A", "before\n\n<Output />\n\nafter");
+    const paired = makeComponent("B", "before\n\n<Output></Output>\n\nafter");
+    const ctx = makeCtx({ A: selfClosing, B: paired });
+    const a = yield* expand(scanSegments("<A />"), ctx);
+    const b = yield* expand(scanSegments("<B />"), ctx);
+    expect(a.trim()).toBe("");
+    expect(b.trim()).toBe("");
+  });
+
+  it("rejects props on <Output>", function* () {
+    const comp = makeComponent("Bad", '<Output foo="bar">x</Output>');
+    const ctx = makeCtx({ Bad: comp });
+    const output = yield* expand(scanSegments("<Bad />"), ctx);
+    expect(output).toContain("ERROR");
+    expect(output).toContain("accepts no props");
+  });
+
+  it("rejects expression props on <Output>", function* () {
+    const comp = makeComponent("Bad", "<Output when={x}>y</Output>");
+    const ctx = makeCtx({ Bad: comp });
+    const output = yield* expand(scanSegments("<Bad />"), ctx);
+    expect(output).toContain("ERROR");
+    expect(output).toContain("accepts no props");
+  });
+
+  it("projects caller content through <Content /> inside <Output>", function* () {
+    const comp = makeComponent("Wrap", "docs\n\n<Output>\n<Content />\n</Output>\n");
+    const ctx = makeCtx({ Wrap: comp });
+    const output = yield* expand(scanSegments("<Wrap>PROJECTED</Wrap>"), ctx);
+    expect(output).toContain("PROJECTED");
+    expect(output).not.toContain("docs");
+  });
+
+  it("lets an <Output> region read a binding recorded by preceding documentation", function* () {
+    const comp = makeComponent(
+      "Dep",
+      '<Capture as="msg">HELLO</Capture>\n\n<Output>msg={msg}</Output>',
+    );
+    const ctx = makeCtx({ Dep: comp });
+    const output = yield* expand(scanSegments("<Dep />"), ctx);
+    expect(output).toContain("msg=HELLO");
+  });
+
+  it("executes exec blocks outside <Output> but suppresses their output", function* () {
+    const comp = makeComponent("Ex", "```bash exec\nDOCRUN\n```\n\n<Output>ok</Output>\n");
+    const { ctx, execCalls } = recordingCtx({ Ex: comp });
+    const output = yield* expand(scanSegments("<Ex />"), ctx);
+    expect(execCalls.some((c) => c.includes("DOCRUN"))).toBe(true);
+    expect(output).toContain("ok");
+    expect(output).not.toContain("ran");
+  });
+
+  it("executes documentation after an <Output> region", function* () {
+    const comp = makeComponent("Post", "<Output>ok</Output>\n\n```bash exec\nAFTER\n```\n");
+    const { ctx, execCalls } = recordingCtx({ Post: comp });
+    const output = yield* expand(scanSegments("<Post />"), ctx);
+    expect(execCalls.some((c) => c.includes("AFTER"))).toBe(true);
+    expect(output).toContain("ok");
+  });
+
+  it("keeps errors inside an <Output> region as comments", function* () {
+    const comp = makeComponent("Err", "<Output>\n<Bogus />\n</Output>");
+    const ctx = makeCtx({ Err: comp });
+    const output = yield* expand(scanSegments("<Err />"), ctx);
+    expect(output).toContain("<!-- ERROR");
+    expect(output).toContain("Failed to import component Bogus");
+  });
+
+  it("keeps errors as comments when no <Output> is declared", function* () {
+    const comp = makeComponent("NoOut", "<Bogus />");
+    const ctx = makeCtx({ NoOut: comp });
+    const output = yield* expand(scanSegments("<NoOut />"), ctx);
+    expect(output).toContain("<!-- ERROR");
+  });
+
+  // --- Fail-fast in documentation ---
+
+  it("throws on a failing exec block in documentation", function* () {
+    const comp = makeComponent("Fail", "```bash exec\nboom\n```\n\n<Output>ok</Output>\n");
+    const ctx = makeCtx({ Fail: comp }, { output: "", exitCode: 1, stderr: "nope" });
+    let threw = false;
+    try {
+      yield* expand(scanSegments("<Fail />"), ctx);
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+
+  it("continues when a modifier handles the failure in documentation", function* () {
+    const comp = makeComponent("Handled", "```bash exec\nrecover\n```\n\n<Output>ok</Output>\n");
+    const ctx = makeCtx({ Handled: comp }, { output: "recovered\n", exitCode: 0, stderr: "" });
+    const output = yield* expand(scanSegments("<Handled />"), ctx);
+    expect(output).toContain("ok");
+  });
+
+  it("throws on a failure inside <Capture> documentation", function* () {
+    const comp = makeComponent(
+      "CapFail",
+      '<Capture as="x">\n<Bogus />\n</Capture>\n\n<Output>ok</Output>',
+    );
+    const ctx = makeCtx({ CapFail: comp });
+    let threw = false;
+    try {
+      yield* expand(scanSegments("<CapFail />"), ctx);
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+
+  // --- Consumer boundary: transported errors ---
+
+  it("throws when a child's Output error is consumed from parent documentation", function* () {
+    const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
+    const parent = makeComponent("P", "<Child />\n\n<Output>tail</Output>");
+    const ctx = makeCtx({ Child: child, P: parent });
+    let threw = false;
+    try {
+      yield* expand(scanSegments("<P />"), ctx);
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+
+  it("renders a child's Output error as a comment when consumed inside parent Output", function* () {
+    const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
+    const parent = makeComponent("P", "<Output>\n<Child />\n</Output>");
+    const ctx = makeCtx({ Child: child, P: parent });
+    const output = yield* expand(scanSegments("<P />"), ctx);
+    expect(output).toContain("<!-- ERROR");
+    expect(output).toContain("Failed to import component Bogus");
+  });
+
+  it("throws before storing an as= binding that captured a child's Output error", function* () {
+    const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
+    const parent = makeComponent("P", '<Child as="captured" />\n\n<Output>tail</Output>');
+    const ctx = makeCtx({ Child: child, P: parent });
+    let threw = false;
+    try {
+      yield* expand(scanSegments("<P />"), ctx);
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+
+  // --- Structural preflight ---
+
+  it("aggregates a nested <Output> into one diagnostic and runs no side effects", function* () {
+    const comp = makeComponent(
+      "Struct",
+      "```bash exec\nSIDE\n```\n\n<Wrapper>\n<Output>x</Output>\n</Wrapper>\n",
+    );
+    const { ctx, execCalls } = recordingCtx({ Struct: comp });
+    const output = yield* expand(scanSegments("<Struct />"), ctx);
+    expect(output).toContain("must be a direct top-level");
+    expect(execCalls).toHaveLength(0);
+  });
+
+  it("aggregates every misplaced <Output> into a single diagnostic", function* () {
+    const comp = makeComponent(
+      "Many",
+      "<A>\n<Output>one</Output>\n</A>\n\n<B>\n<Output>two</Output>\n</B>\n",
+    );
+    const ctx = makeCtx({ Many: comp });
+    const output = yield* expand(scanSegments("<Many />"), ctx);
+    const errorComments = output.match(/<!-- ERROR/g) ?? [];
+    expect(errorComments).toHaveLength(1);
+    expect(output).toContain("one");
+    expect(output).toContain("two");
+  });
+
+  it("diagnoses a nested <Output> inside <Show when={false}>", function* () {
+    const comp = makeComponent("Hidden", "<Show when={false}>\n<Output>hidden</Output>\n</Show>");
+    const ctx = makeCtx({ Hidden: comp });
+    const output = yield* expand(scanSegments("<Hidden />"), ctx);
+    expect(output).toContain("must be a direct top-level");
+  });
+
+  it("diagnoses a nested <Output> passed to a component that discards content", function* () {
+    const comp = makeComponent("Discard", "<NoContent>\n<Output>x</Output>\n</NoContent>");
+    const ctx = makeCtx({ Discard: comp });
+    const output = yield* expand(scanSegments("<Discard />"), ctx);
+    expect(output).toContain("must be a direct top-level");
+  });
+
+  it("throws a structural diagnostic when an invalid child is used from documentation", function* () {
+    const child = makeComponent("BadChild", "<Wrapper>\n<Output>x</Output>\n</Wrapper>");
+    const parent = makeComponent("P", "<BadChild />\n\n<Output>tail</Output>");
+    const ctx = makeCtx({ BadChild: child, P: parent });
+    let threw = false;
+    try {
+      yield* expand(scanSegments("<P />"), ctx);
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Prop validation (spec §5.5)
 // ---------------------------------------------------------------------------
diff --git a/core/tests/run-document.test.ts b/core/tests/run-document.test.ts
index d4fa1c7..737a34a 100644
--- a/core/tests/run-document.test.ts
+++ b/core/tests/run-document.test.ts
@@ -13,6 +13,7 @@ import { expect } from "@effectionx/bdd/expect";
 import { InMemoryStream } from "@executablemd/durable-streams";
 import { useStubFs, useFailingExec } from "@executablemd/runtime/test";
 import { API } from "@executablemd/runtime";
+import { forEach } from "@effectionx/stream-helpers";
 import type { Operation } from "effection";
 import { runDocument } from "../src/run-document.ts";
 import { collect } from "../src/collect.ts";
@@ -1002,3 +1003,126 @@ describe("runDocument", () => {
     expect(result).toContain("AFTER");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Component-declared output at the document level (spec §5.4, §6.9)
+// ---------------------------------------------------------------------------
+
+describe("component-declared output — document workflow", () => {
+  it("applies <Output> to an imported component invoked from a streaming root", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({
+      "README.md": "Intro paragraph.\n\n<Warn />\n",
+      "components/Warn.md": "Docs line.\n\n<Output>\nWARNING_SHOWN\n</Output>\n",
+    });
+    yield* useStubExec();
+    const output = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+    expect(output).toContain("Intro paragraph.");
+    expect(output).toContain("WARNING_SHOWN");
+    expect(output).not.toContain("Docs line");
+  });
+
+  it("applies <Output> to a root document the same way", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({ "README.md": "Root docs.\n\n<Output>\nROOT_SHOWN\n</Output>\n" });
+    const output = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+    expect(output).toContain("ROOT_SHOWN");
+    expect(output).not.toContain("Root docs");
+  });
+
+  it("buffers a root with <Output> into a single emission after success", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({ "README.md": "Root docs.\n\n<Output>\nROOT_SHOWN\n</Output>\n" });
+
+    const execution = yield* runDocument({ docPath: "README.md", stream });
+    const chunks: string[] = [];
+    const full = yield* forEach(function* (chunk: string) {
+      chunks.push(chunk);
+    }, execution.output);
+
+    expect(full).toContain("ROOT_SHOWN");
+    expect(chunks).toHaveLength(1);
+  });
+
+  it("emits no partial output when documentation fails in a buffered root", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({
+      "README.md": "<Output>\nSELECTED\n</Output>\n\n```bash exec\nfailing-command\n```\n",
+    });
+    yield* useFailingExec(1, "command not found");
+
+    const execution = yield* runDocument({ docPath: "README.md", stream });
+    const chunks: string[] = [];
+    yield* forEach(function* (chunk: string) {
+      chunks.push(chunk);
+    }, execution.output);
+
+    let threw = false;
+    try {
+      yield* execution;
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+    expect(chunks.join("")).not.toContain("SELECTED");
+  });
+
+  it("keeps per-segment streaming for roots without <Output>", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({
+      "README.md": "```bash exec\necho one\n```\n\n```bash exec\necho two\n```\n",
+    });
+    yield* useStubExec();
+
+    const execution = yield* runDocument({ docPath: "README.md", stream });
+    const chunks: string[] = [];
+    yield* forEach(function* (chunk: string) {
+      chunks.push(chunk);
+    }, execution.output);
+
+    expect(chunks.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("emits no output event for an empty buffered root <Output>", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({ "README.md": "Root docs.\n\n<Output />\n" });
+
+    const execution = yield* runDocument({ docPath: "README.md", stream });
+    const chunks: string[] = [];
+    const full = yield* forEach(function* (chunk: string) {
+      chunks.push(chunk);
+    }, execution.output);
+
+    expect(chunks).toHaveLength(0);
+    expect(full).toBe("");
+  });
+
+  it("replays a buffered root <Output> to the same result", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({ "README.md": "Root docs.\n\n<Output>\nROOT_SHOWN\n</Output>\n" });
+
+    const first = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+    const second = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+
+    expect(second).toBe(first);
+    expect(second).toContain("ROOT_SHOWN");
+  });
+
+  it("diagnoses a misplaced root <Output> and runs no body side effects", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({
+      "README.md": "```bash exec\nSIDE\n```\n\n<Wrapper>\n<Output>x</Output>\n</Wrapper>\n",
+    });
+    yield* useFailingExec(1, "should not run");
+
+    const result = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+
+    expect(result).toContain("must be a direct top-level");
+
+    const events = stream.snapshot();
+    const execEvents = events.flatMap((e) =>
+      e.type === "yield" && e.description.type === "exec" ? [e] : [],
+    );
+    expect(execEvents).toHaveLength(0);
+  });
+});
diff --git a/core/tests/smoke.test.ts b/core/tests/smoke.test.ts
index bd03c0d..d922c43 100644
--- a/core/tests/smoke.test.ts
+++ b/core/tests/smoke.test.ts
@@ -174,6 +174,14 @@ describe("smoke test", { sanitizeOps: false, sanitizeResources: false }, () => {
     // Instruction wraps Sample — response includes system prompt text
     expect(output).toContain("[response-from-instruction-stub|system:You are a helpful pirate.]");
 
+    // ----- Component-declared Output section -----
+    expect(output).toContain("§ Component-declared Output");
+    // The <Show> inside <Output> renders (its `when` binding was computed by
+    // preceding documentation).
+    expect(output).toContain("OUTPUTDEMO_SELECTED");
+    // The component's documentation prose is suppressed.
+    expect(output).not.toContain("OUTPUTDEMO_DOC_LEAK");
+
     // ----- Durability section -----
     expect(output).toContain("Run at:");
 
diff --git a/smoke-test/OutputDemo.md b/smoke-test/OutputDemo.md
new file mode 100644
index 0000000..17724be
--- /dev/null
+++ b/smoke-test/OutputDemo.md
@@ -0,0 +1,26 @@
+---
+title: Output Demo
+---
+
+# {meta.title}
+
+This paragraph is documentation. It explains how the component works but
+must never reach the consumer — OUTPUTDEMO_DOC_LEAK should not appear in the
+rendered output.
+
+```ts eval
+const ready = true;
+```
+
+The eval block above runs as documentation, before the `<Output>` region is
+evaluated, so `<Show>` below can depend on the `ready` binding it computed.
+
+<Output>
+
+<Show when={ready}>
+
+OUTPUTDEMO_SELECTED
+
+</Show>
+
+</Output>
diff --git a/smoke-test/README.md b/smoke-test/README.md
index 30a8b38..88dc3b3 100644
--- a/smoke-test/README.md
+++ b/smoke-test/README.md
@@ -448,6 +448,18 @@ the stale content hash and halts replay, forcing a fresh execution.
 
 </Section>
 
+<Section title="Component-declared Output">
+
+A component can declare which region of its body renders using `<Output>`.
+Everything outside the region is documentation that executes (its eval blocks
+run, its captures populate bindings) but never renders into the consumer.
+`OutputDemo` computes a binding in documentation, then renders a `<Show>`
+inside `<Output>` that depends on it.
+
+<OutputDemo />
+
+</Section>
+
 <Section title="Smoke Test Summary">
 
 This document exercises every feature of the system:
diff --git a/smoke-test/Show.md b/smoke-test/Show.md
new file mode 100644
index 0000000..cc67b19
--- /dev/null
+++ b/smoke-test/Show.md
@@ -0,0 +1,16 @@
+---
+inputs:
+  when:
+    type: boolean
+    required: true
+  fallback: ""
+---
+
+```ts eval
+if (when) {
+  return yield* renderChildren();
+}
+if (fallback) {
+  return fallback;
+}
+```
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index 47db9dc..5f7ab8b 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -1944,6 +1944,13 @@ The entry point treats the root document through the same import
 pipeline as any component. This gives it uniform resolution, parsing, and
 error handling.
 
+The root obeys the same `<Output>` rules as any component (§6.9): it is
+structurally validated before execution, and a root declaring a top-level
+`<Output>` renders only its declared regions. Because output selection requires
+the whole body, a root with `<Output>` is **fully buffered** — it executes to
+completion and emits only after success; a root without `<Output>` keeps the
+per-segment streaming path.
+
 ```typescript
 function* documentWorkflow(docPath: string): Workflow<string> {
   // Import root — same pipeline as any component.
@@ -1954,6 +1961,30 @@ function* documentWorkflow(docPath: string): Workflow<string> {
   // per-segment expansion calls (see §6.1 for details).
   const counter = createBlockCounter();
 
+  // Structural preflight (§6.9): a misplaced <Output> aborts before any body
+  // side effects; the aggregate diagnostic renders as a comment.
+  const placementError = validateOutputPlacement(root.bodySegments);
+  if (placementError) {
+    const text = renderSegment(placementError);
+    yield* ephemeral(output(text));
+    return text;
+  }
+
+  // A root declaring top-level <Output> buffers completely: execute the whole
+  // body, then emit the selected regions only after success. A documentation
+  // failure throws before any emit, so no partial output is produced. An empty
+  // buffered root emits no output event.
+  if (bodyHasOutput(root.bodySegments)) {
+    const expanded = yield* expandBody(
+      root.bodySegments, [], root.meta, {}, new Set(), ctx, counter, undefined,
+    );
+    const text = expanded.map(renderSegment).join("");
+    if (text) {
+      yield* ephemeral(output(text));
+    }
+    return text;
+  }
+
   // Per-root-segment emission loop — each root segment is expanded
   // independently and its output emitted through the Document Output Api (§9).
   // Root segments are sequential and independent in document order.
@@ -2048,6 +2079,15 @@ function* expandSegments(
       }
 
       case "component": {
+        if (segment.name === "Output") {
+          // Definition-owned <Output> is consumed by buildBody before it
+          // reaches here (§6.9). Reaching this branch means a misplaced or
+          // dynamically scanned <Output> — diagnose it under the ambient
+          // error policy via raise().
+          result.push(...(yield* raise(misplacedOutputError())));
+          break;
+        }
+
         if (segment.name === "Capture") {
           const asBinding = segment.props.as;
           if (typeof asBinding !== "string" || asBinding.length === 0) {
@@ -2105,7 +2145,15 @@ function* expandSegments(
           segment.children,
           hideSet,
         );
-        result.push(...expanded);
+        // Consumer boundary (§6.9): re-raise transported error segments under
+        // the ambient policy so documentation never appends a hidden error.
+        for (const s of expanded) {
+          if (s.type === "error") {
+            result.push(...(yield* raise(s)));
+          } else {
+            result.push(s);
+          }
+        }
         break;
       }
 
@@ -2130,14 +2178,18 @@ function* expandSegments(
         const chain = composeModifierChain(
           segment.modifiers, context, registry,
         );
+        // The modifier chain (middleware) runs first and gets the first
+        // opportunity to handle or normalize a failure. The result is then
+        // classified under the existing rules; a resulting error follows the
+        // ambient error policy via raise() (§6.9) — no separate exitCode path.
         const codeResult = yield* chain();
 
         if (codeResult.exitCode !== 0 && codeResult.output === "") {
-          result.push({
+          result.push(...(yield* raise({
             type: "error",
             message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
             source: segment.content,
-          });
+          })));
         } else if (codeResult.output !== "") {
           result.push({
             type: "execOutput",
@@ -2196,6 +2248,15 @@ function* expandComponent(
   // Import — single durable effect (resolve + read)
   const definition = yield* durableImportComponent(name);
 
+  // Structural preflight (§6.9): validate <Output> placement against the
+  // component's own source AST before any body side effects run. A
+  // structurally invalid component executes no eval, exec, Capture, or nested
+  // components — the aggregate diagnostic follows the ambient policy.
+  const placementError = validateOutputPlacement(definition.bodySegments);
+  if (placementError) {
+    return yield* raise(placementError);
+  }
+
   // Extract reserved props before validation.
   // `slot` and `as` are consumed by the expansion engine.
   const asBinding = props.as;
@@ -2212,21 +2273,6 @@ function* expandComponent(
     ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
     : contextEnv;
 
-  // Substitute raw children into <Content /> positions.
-  // Children are NOT pre-expanded — they expand in document order
-  // when the substituted body is expanded. This ensures code blocks
-  // before <Content /> (e.g., provider middleware installation) run
-  // before children's code blocks.
-  // Children segments are tagged with callerEvalEnv so expression
-  // props resolve in the caller's lexical scope (DEC-91).
-  const substituted = substituteContent(
-    definition.bodySegments,
-    children,
-    definition.meta,
-    validatedProps,
-    callerEvalEnv ?? undefined,
-  );
-
   // Recurse with augmented hide set.
   // Each component gets its own fresh binding environment so that
   // eval blocks within a component share bindings but don't leak
@@ -2245,14 +2291,22 @@ function* expandComponent(
   componentEnv.values.renderChildren = function* () { /* ... */ };
   componentEnv.values.render = function* (markdown) { /* ... */ };
 
+  // Expand the body via expandBody (§6.9): it substitutes <Content />, then
+  // renders only the declared <Output> regions (executing documentation for
+  // its side effects) when the definition declares output, or renders the
+  // whole body otherwise.
   const expanded = yield* EvalEnvCtx.with(
     componentEnv,
     function* () {
-      return yield* expandSegments(
-        substituted,
+      return yield* expandBody(
+        definition.bodySegments,
+        children,
         definition.meta,
         validatedProps,
         newHideSet,
+        ctx,
+        counter,
+        callerEvalEnv ?? undefined,
       );
     },
   );
@@ -2271,6 +2325,9 @@ function* expandComponent(
       ]);
     }
 
+    // Consumer boundary (§6.9): re-raise transported errors under the ambient
+    // policy so documentation never captures and hides an error comment.
+    yield* consume(expanded);
     const parentEnv = yield* ephemeral(EvalEnvCtx.expect());
     parentEnv.values[asBinding] = renderSegments(expanded);
     return [];
@@ -3166,6 +3223,103 @@ Every run allocates a current free port, starts the daemon, performs readiness
 polling and child operations, then terminates the daemon when the component
 closes. A previous diagnostic trace does not suppress any of these actions.
 
+### 6.9 Component-declared output: `<Output>`
+
+A component (or root document) declares which region of its body renders using
+an `<Output>…</Output>` boundary tag. Everything outside the declared regions
+is **documentation**: it executes for its side effects — eval and exec blocks
+run, `<Capture>` populates bindings, nested components run — but its rendered
+result never reaches the consumer. Without `<Output>`, the whole body renders,
+so existing components are unaffected.
+
+```markdown
+# Release Config Files
+
+The following files participate in the release process. (Documentation — it
+does not render into the consumer.)
+
+<Capture as="releaseConfigFiles">
+- .github/workflows/release.yml
+</Capture>
+
+```ts eval
+const releaseChanged = files.filter((p) => releaseConfigFiles.includes(`- ${p}`));
+```
+
+<Output>
+
+<Show when={releaseChanged.length > 0}>
+
+> [!WARNING]
+> Release configuration changed — update the release spec.
+
+</Show>
+
+</Output>
+```
+
+#### Placement is a source-level structural rule
+
+Only a **direct top-level** `<Output>` node is a valid declaration.
+`validateOutputPlacement` traverses the component's own parsed source AST —
+including unreachable or discarded children (inside `<Show when={false}>`,
+passed to a component that has no `<Content />`, nested inside another
+`<Output>`, or enclosed by anything that declines to render its children) — and
+reports every `<Output>` at depth > 0. All violations combine into **one
+aggregate `ErrorSegment`** advising that `<Output>` must be a direct top-level
+declaration and that conditional rendering uses `<Show>` inside `<Output>`.
+
+Structural validation runs **before** any body execution. A structurally
+invalid component or root executes no eval, exec, `<Capture>`, nested
+components, or other side effects. Placement is owned by the declaring
+component: child expansion cannot introduce, remove, promote, repair, or
+redefine it, and a caller-projected `<Output>` (a depth > 0 node in the
+caller's own AST) is diagnosed in the caller and never becomes the callee's
+declaration.
+
+#### Provenance and rendering
+
+Output policy is determined from the **definition body**, before `<Content />`
+substitution — never from the post-substitution array. `buildBody` walks the
+definition's top level in document order and produces ordered chunks: each
+top-level `<Output>` becomes a rendered region (its children with `<Content />`
+substituted one level in — `<Content />` belonging to unrelated nested
+components is untouched); everything else is documentation. `<Output>` accepts
+no props. `<Output />` and `<Output></Output>` are equivalent and contribute no
+content. Multiple regions concatenate in document order. A component invoked
+with `as="binding"` captures only its selected output regions; its
+documentation executes but is neither rendered nor captured.
+
+The root document obeys the same rules (§5.4). A root declaring top-level
+`<Output>` is **fully buffered**: it executes to completion and emits the
+selected regions only after success — a documentation failure produces no
+partial output, and an empty selection emits no output event. Roots without
+`<Output>` keep per-segment streaming. Buffering defers only the `output()`
+emission, not the durable execution, so replay is deterministic.
+
+#### Contextual error policy
+
+An `ErrorPolicy` (`"collect"` or `"throw"`) threads through expansion via
+`ErrorPolicyCtx` (unset defaults to `"collect"`). Inside a rendered region, and
+everywhere when no `<Output>` is declared, an `ErrorSegment` renders as an
+`<!-- ERROR -->` comment (`raise` under `"collect"`). While executing
+documentation, the first `ErrorSegment` **throws immediately** (`raise` under
+`"throw"`, a `DocumentationError`) so it propagates to be handled above. Output
+regions reset the policy to `"collect"`; documentation sets it to `"throw"`.
+The modifier chain runs first (middleware may normalize a failure); the
+existing result classification then decides whether an `ErrorSegment` results —
+there is no separate raw `exitCode` policy.
+
+Because a nested component can produce an `ErrorSegment` inside its **own**
+valid `<Output>` under `"collect"` and return it to a suppressed-documentation
+caller, every site that **consumes** a component's returned segments re-applies
+the ambient policy: the `expandSegments` component case and markdown `as=`
+capture route transported error segments through `raise`/`consume`, and the
+`renderChildren()` / `render()` / `useContent()` / function-component paths run
+under the ambient policy so transported errors re-raise before being flattened
+to strings. Producing an error inside a component's own Output (a comment) is
+thus distinct from consuming it from a parent documentation context (a throw).
+
 ---
 
 ## 7. Entry point
@@ -3799,6 +3953,18 @@ visible warning blocks, collect into a separate error report).
 | C29 | `<Capture select>` CSS extraction | `<Capture as="x" select="code[lang=json]">` with code fence child stores code block value only |
 | C30 | `<Capture select>` fallback | `select="code[lang=json]"` with no matching node stores full rendered content |
 | C31 | `<Capture select>` paragraph | `select="paragraph"` extracts paragraph text content |
+| C32 | `<Output>` selects region | Only the `<Output>` region renders; documentation outside is suppressed |
+| C33 | No `<Output>` | Whole body renders (backward compatible) |
+| C34 | Documentation executes | eval/exec/`<Capture>` outside `<Output>` run; a later `<Output>` reads their bindings; documentation after a region still runs |
+| C35 | Multiple `<Output>` regions | Concatenate in document order |
+| C36 | Markdown preserved in `<Output>` | A `> [!WARNING]` admonition survives intact |
+| C37 | Empty-tag parity | `<Output />` and `<Output></Output>` both contribute no content |
+| C38 | `<Output>` props rejected | Props/expression props on `<Output>` produce an ErrorSegment |
+| C39 | `<Content />` in `<Output>` | Caller content projects into a top-level `<Output>` region |
+| C40 | `as=` captures selected output | A component invoked with `as=` captures only its `<Output>` regions; documentation is neither rendered nor captured |
+| C41 | Structural placement | Nested/misplaced `<Output>` (including inside `<Show when={false}>` or a content-discarding component) produces one aggregate diagnostic and runs no body side effects |
+| C42 | Caller-projected `<Output>` inert | Projecting `<Output>` through `<Content />` neither activates nor alters the callee's policy |
+| C43 | Documentation fail-fast | A failure in documentation (direct, inside `<Capture>`, inside a nested component, or a transported error) throws; a modifier-handled failure continues; errors inside `<Output>` or with no `<Output>` remain comments |
 
 ### Tier D — Code execution and modifier middleware
 
@@ -3839,6 +4005,9 @@ visible warning blocks, collect into a separate error report).
 | E8 | `silent exec` in full document | Command runs, result journaled, output omitted |
 | E9 | `sample exec` in full document | Command + LLM both journaled, LLM response in output |
 | E10 | Unclosed bold across component boundary | `**text\n<Comp />\nmore` → healed bold in first segment, component expanded, `more` unaffected |
+| E11 | `<Output>` component vs. root consistency | An imported component and a root document apply `<Output>` identically; documentation is suppressed in both |
+| E12 | Root `<Output>` buffering | A root with `<Output>` emits once after success; a later documentation failure yields no partial output; an empty selection emits no event; replay reproduces the result |
+| E13 | `<Show>` inside `<Output>` (smoke) | `smoke-test/OutputDemo.md` renders the conditionally-selected region (its `when` binding computed by preceding documentation eval) while its documentation prose does not appear |
 
 ### Tier F — Markdown healing (remend)
 
@@ -4261,7 +4430,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 65 | Whitespace normalization is middleware, not post-processing | Stateful across calls; composes with other middleware; can be disabled via `--raw`; mutable closure state scoped per `useNormalizedOutput()` call |
 | 66 | Terminal formatting is middleware, not a separate renderer | Composes with normalization; conditional on TTY; disabled for piped output; uses `marked-terminal` with `async: false` |
 | 67 | Channel-based delivery, not direct `process.stdout.write` | Decouples production from consumption; enables buffered collection for piped output; consumer task lifetime tied to document run scope; `channel.close()` in `finally` block guarantees consumer exits cleanly |
-| 68 | Per-root-segment emission, not full-document batch | Enables streaming UX; root segments are sequential and independent; component-internal expansion remains recursive and buffered; `documentWorkflow` returns `""` — output already emitted via Api |
+| 68 | Per-root-segment emission for roots without `<Output>`; full buffering for roots that declare it | Streaming UX for the common case — root segments are sequential and independent, and component-internal expansion is recursive and buffered. A root declaring top-level `<Output>` (§6.9) buffers completely and emits the selected regions only after successful expansion, so a later documentation failure yields no partial output; an empty selection emits nothing |
 | 69 | `blockId` counter threaded through expansion context | Per-segment expansion resets `result.length`; mutable counter preserves unique diagnostic IDs; counter guarded by expansion scope cancellation |
 | 70 | `output()` wrapped in `ephemeral()` | Output emission is a non-durable side effect; journal records durable effects only; output text is derived from journaled expansion results; all middleware/side effects execute on the ephemeral side |
 | 71 | Middleware installation order: normalize outer, terminal inner, channel innermost | `scope.around` later-installed handlers wrap earlier ones; execution flows outer → inner: normalize → terminal → channel; install order is reverse of execution order; must be documented to prevent reordering |

From e47ac3f991594fc924d420cc659898d583bfea9e Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 15:52:18 -0400
Subject: [PATCH 2/9] =?UTF-8?q?review:=20fix=20=C2=A76.9=20nested=20fences?=
 =?UTF-8?q?;=20trim=20restating=20comments?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- spec §6.9: use a four-backtick outer markdown fence so the inner
  ```ts eval block renders inside one code block.
- expand.ts: drop JSDoc/comments that merely restate names/types/control
  flow (per AGENTS.md rule 4); keep the provenance and transported-error
  rationale.
---
 core/src/expand.ts           | 11 +----------
 specs/executable-mdx-spec.md |  4 ++--
 2 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/core/src/expand.ts b/core/src/expand.ts
index 26c61b8..124f38b 100644
--- a/core/src/expand.ts
+++ b/core/src/expand.ts
@@ -608,9 +608,6 @@ function* expandComponent(
     });
   };
 
-  // Expand the body through expandBody, which renders only the declared
-  // <Output> regions (executing documentation for side effects) when the
-  // definition declares output, and renders the whole body otherwise.
   const expanded = yield* EvalEnvCtx.with(componentEnv, function* () {
     if (childEvalScope) {
       return yield* EvalScopeCtx.with(childEvalScope, function* () {
@@ -1004,7 +1001,6 @@ export function stripSlotProp(segment: Segment): Segment {
 // Content slot substitution (spec §6.3)
 // ---------------------------------------------------------------------------
 
-/** Projects the caller's eval env onto substituted children. */
 type ProjectFn = (segments: Segment[]) => Segment[];
 
 /** Mutable flag so slot validation errors are emitted only once. */
@@ -1095,23 +1091,20 @@ function substituteContent(
 // Component-declared output: <Output> (spec §6.9)
 // ---------------------------------------------------------------------------
 
-/** A body chunk produced by buildBody: a rendered output region or documentation. */
 interface BodyChunk {
+  /** true = a rendered `<Output>` region; false = documentation (executed, not rendered). */
   output: boolean;
   segments: Segment[];
 }
 
-/** True when a top-level segment is an `<Output>` declaration. */
 function isTopLevelOutput(segment: Segment): boolean {
   return segment.type === "component" && segment.name === "Output";
 }
 
-/** True when the definition body declares at least one top-level `<Output>`. */
 export function bodyHasOutput(bodySegments: Segment[]): boolean {
   return bodySegments.some(isTopLevelOutput);
 }
 
-/** The diagnostic for a misplaced `<Output>` tag. */
 function misplacedOutputError(): ErrorSegment {
   return {
     type: "error",
@@ -1122,7 +1115,6 @@ function misplacedOutputError(): ErrorSegment {
   };
 }
 
-/** A short, stable preview of an `<Output>` region for aggregate diagnostics. */
 function previewOutput(segment: ComponentInvocation): string {
   const text = segment.children
     .filter((child): child is TextSegment => child.type === "text")
@@ -1177,7 +1169,6 @@ export function validateOutputPlacement(bodySegments: Segment[]): ErrorSegment |
   };
 }
 
-/** Validate that a top-level `<Output>` carries no props. */
 function validateOutputProps(segment: ComponentInvocation): ErrorSegment | undefined {
   const hasProps = Object.keys(segment.props).length > 0;
   const hasExpressions = Object.keys(segment.expressions).length > 0;
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index 5f7ab8b..633b4d2 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -3232,7 +3232,7 @@ run, `<Capture>` populates bindings, nested components run — but its rendered
 result never reaches the consumer. Without `<Output>`, the whole body renders,
 so existing components are unaffected.
 
-```markdown
+````markdown
 # Release Config Files
 
 The following files participate in the release process. (Documentation — it
@@ -3256,7 +3256,7 @@ const releaseChanged = files.filter((p) => releaseConfigFiles.includes(`- ${p}`)
 </Show>
 
 </Output>
-```
+````
 
 #### Placement is a source-level structural rule
 

From 92e35b56de92e3ad08f4d51aa728ca9e0799dd08 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 16:29:24 -0400
Subject: [PATCH 3/9] review: spec describes <Output> behavior, not
 implementation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Revert the source-shaped additions to the documentWorkflow, expandSegments,
and expandComponent pseudocode blocks, and rewrite §6.9 to state observable
behavior without private symbols (validateOutputPlacement, buildBody,
expandBody, ErrorPolicyCtx, raise, consume, DocumentationError) or internal
control flow. Keep the authoring example, the normative prose (placement,
definition-owned structure, execution order, error behavior, root buffering,
consistency, multiple regions, as= capture, empty-tag parity), and the
C32–C43 / E11–E13 conformance cases.
---
 deno.lock                    |   2 +
 specs/executable-mdx-spec.md | 207 +++++++++++++----------------------
 2 files changed, 80 insertions(+), 129 deletions(-)

diff --git a/deno.lock b/deno.lock
index fd8c702..358048b 100644
--- a/deno.lock
+++ b/deno.lock
@@ -74,8 +74,10 @@
     "npm:marked@^17.0.4": "17.0.4",
     "npm:mdast-util-to-string@4": "4.0.0",
     "npm:oxfmt@0.41": "0.41.0",
+    "npm:oxfmt@0.41.0": "0.41.0",
     "npm:oxlint-tsgolint@0.17": "0.17.4",
     "npm:oxlint@1": "1.56.0_oxlint-tsgolint@0.17.4",
+    "npm:oxlint@1.56.0": "1.56.0_oxlint-tsgolint@0.17.4",
     "npm:preact-render-to-string@^6.6.3": "6.7.0_preact@10.29.7",
     "npm:preact@^10.28.2": "10.29.7_preact-render-to-string@6.7.0",
     "npm:preact@^10.29.1": "10.29.7_preact-render-to-string@6.7.0",
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index 633b4d2..7b5ec25 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -1961,30 +1961,6 @@ function* documentWorkflow(docPath: string): Workflow<string> {
   // per-segment expansion calls (see §6.1 for details).
   const counter = createBlockCounter();
 
-  // Structural preflight (§6.9): a misplaced <Output> aborts before any body
-  // side effects; the aggregate diagnostic renders as a comment.
-  const placementError = validateOutputPlacement(root.bodySegments);
-  if (placementError) {
-    const text = renderSegment(placementError);
-    yield* ephemeral(output(text));
-    return text;
-  }
-
-  // A root declaring top-level <Output> buffers completely: execute the whole
-  // body, then emit the selected regions only after success. A documentation
-  // failure throws before any emit, so no partial output is produced. An empty
-  // buffered root emits no output event.
-  if (bodyHasOutput(root.bodySegments)) {
-    const expanded = yield* expandBody(
-      root.bodySegments, [], root.meta, {}, new Set(), ctx, counter, undefined,
-    );
-    const text = expanded.map(renderSegment).join("");
-    if (text) {
-      yield* ephemeral(output(text));
-    }
-    return text;
-  }
-
   // Per-root-segment emission loop — each root segment is expanded
   // independently and its output emitted through the Document Output Api (§9).
   // Root segments are sequential and independent in document order.
@@ -2079,15 +2055,6 @@ function* expandSegments(
       }
 
       case "component": {
-        if (segment.name === "Output") {
-          // Definition-owned <Output> is consumed by buildBody before it
-          // reaches here (§6.9). Reaching this branch means a misplaced or
-          // dynamically scanned <Output> — diagnose it under the ambient
-          // error policy via raise().
-          result.push(...(yield* raise(misplacedOutputError())));
-          break;
-        }
-
         if (segment.name === "Capture") {
           const asBinding = segment.props.as;
           if (typeof asBinding !== "string" || asBinding.length === 0) {
@@ -2145,15 +2112,7 @@ function* expandSegments(
           segment.children,
           hideSet,
         );
-        // Consumer boundary (§6.9): re-raise transported error segments under
-        // the ambient policy so documentation never appends a hidden error.
-        for (const s of expanded) {
-          if (s.type === "error") {
-            result.push(...(yield* raise(s)));
-          } else {
-            result.push(s);
-          }
-        }
+        result.push(...expanded);
         break;
       }
 
@@ -2178,18 +2137,14 @@ function* expandSegments(
         const chain = composeModifierChain(
           segment.modifiers, context, registry,
         );
-        // The modifier chain (middleware) runs first and gets the first
-        // opportunity to handle or normalize a failure. The result is then
-        // classified under the existing rules; a resulting error follows the
-        // ambient error policy via raise() (§6.9) — no separate exitCode path.
         const codeResult = yield* chain();
 
         if (codeResult.exitCode !== 0 && codeResult.output === "") {
-          result.push(...(yield* raise({
+          result.push({
             type: "error",
             message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
             source: segment.content,
-          })));
+          });
         } else if (codeResult.output !== "") {
           result.push({
             type: "execOutput",
@@ -2248,15 +2203,6 @@ function* expandComponent(
   // Import — single durable effect (resolve + read)
   const definition = yield* durableImportComponent(name);
 
-  // Structural preflight (§6.9): validate <Output> placement against the
-  // component's own source AST before any body side effects run. A
-  // structurally invalid component executes no eval, exec, Capture, or nested
-  // components — the aggregate diagnostic follows the ambient policy.
-  const placementError = validateOutputPlacement(definition.bodySegments);
-  if (placementError) {
-    return yield* raise(placementError);
-  }
-
   // Extract reserved props before validation.
   // `slot` and `as` are consumed by the expansion engine.
   const asBinding = props.as;
@@ -2273,6 +2219,21 @@ function* expandComponent(
     ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
     : contextEnv;
 
+  // Substitute raw children into <Content /> positions.
+  // Children are NOT pre-expanded — they expand in document order
+  // when the substituted body is expanded. This ensures code blocks
+  // before <Content /> (e.g., provider middleware installation) run
+  // before children's code blocks.
+  // Children segments are tagged with callerEvalEnv so expression
+  // props resolve in the caller's lexical scope (DEC-91).
+  const substituted = substituteContent(
+    definition.bodySegments,
+    children,
+    definition.meta,
+    validatedProps,
+    callerEvalEnv ?? undefined,
+  );
+
   // Recurse with augmented hide set.
   // Each component gets its own fresh binding environment so that
   // eval blocks within a component share bindings but don't leak
@@ -2291,22 +2252,14 @@ function* expandComponent(
   componentEnv.values.renderChildren = function* () { /* ... */ };
   componentEnv.values.render = function* (markdown) { /* ... */ };
 
-  // Expand the body via expandBody (§6.9): it substitutes <Content />, then
-  // renders only the declared <Output> regions (executing documentation for
-  // its side effects) when the definition declares output, or renders the
-  // whole body otherwise.
   const expanded = yield* EvalEnvCtx.with(
     componentEnv,
     function* () {
-      return yield* expandBody(
-        definition.bodySegments,
-        children,
+      return yield* expandSegments(
+        substituted,
         definition.meta,
         validatedProps,
         newHideSet,
-        ctx,
-        counter,
-        callerEvalEnv ?? undefined,
       );
     },
   );
@@ -2325,9 +2278,6 @@ function* expandComponent(
       ]);
     }
 
-    // Consumer boundary (§6.9): re-raise transported errors under the ambient
-    // policy so documentation never captures and hides an error comment.
-    yield* consume(expanded);
     const parentEnv = yield* ephemeral(EvalEnvCtx.expect());
     parentEnv.values[asBinding] = renderSegments(expanded);
     return [];
@@ -3258,67 +3208,66 @@ const releaseChanged = files.filter((p) => releaseConfigFiles.includes(`- ${p}`)
 </Output>
 ````
 
-#### Placement is a source-level structural rule
-
-Only a **direct top-level** `<Output>` node is a valid declaration.
-`validateOutputPlacement` traverses the component's own parsed source AST —
-including unreachable or discarded children (inside `<Show when={false}>`,
-passed to a component that has no `<Content />`, nested inside another
-`<Output>`, or enclosed by anything that declines to render its children) — and
-reports every `<Output>` at depth > 0. All violations combine into **one
-aggregate `ErrorSegment`** advising that `<Output>` must be a direct top-level
-declaration and that conditional rendering uses `<Show>` inside `<Output>`.
-
-Structural validation runs **before** any body execution. A structurally
-invalid component or root executes no eval, exec, `<Capture>`, nested
-components, or other side effects. Placement is owned by the declaring
-component: child expansion cannot introduce, remove, promote, repair, or
-redefine it, and a caller-projected `<Output>` (a depth > 0 node in the
-caller's own AST) is diagnosed in the caller and never becomes the callee's
+#### Placement
+
+Only a **direct top-level** `<Output>` is a valid declaration. Placement is
+checked against the component's (or root's) source structure, including regions
+that never render — content inside `<Show when={false}>`, content passed to a
+component that has no `<Content />`, an `<Output>` nested inside another
+`<Output>`, or the children of any component that declines to render them. An
+`<Output>` anywhere other than the top level is misplaced; all misplaced
+occurrences in a single component are reported together as one diagnostic that
+advises `<Output>` must be a direct top-level declaration and that conditional
+rendering uses `<Show>` inside `<Output>`.
+
+Placement is owned by the declaring component. Child expansion cannot
+introduce, remove, or redefine it, and an `<Output>` a caller passes as content
+is diagnosed against the caller's own structure — it never becomes the callee's
 declaration.
 
-#### Provenance and rendering
-
-Output policy is determined from the **definition body**, before `<Content />`
-substitution — never from the post-substitution array. `buildBody` walks the
-definition's top level in document order and produces ordered chunks: each
-top-level `<Output>` becomes a rendered region (its children with `<Content />`
-substituted one level in — `<Content />` belonging to unrelated nested
-components is untouched); everything else is documentation. `<Output>` accepts
-no props. `<Output />` and `<Output></Output>` are equivalent and contribute no
-content. Multiple regions concatenate in document order. A component invoked
-with `as="binding"` captures only its selected output regions; its
-documentation executes but is neither rendered nor captured.
-
-The root document obeys the same rules (§5.4). A root declaring top-level
-`<Output>` is **fully buffered**: it executes to completion and emits the
-selected regions only after success — a documentation failure produces no
-partial output, and an empty selection emits no output event. Roots without
-`<Output>` keep per-segment streaming. Buffering defers only the `output()`
-emission, not the durable execution, so replay is deterministic.
-
-#### Contextual error policy
-
-An `ErrorPolicy` (`"collect"` or `"throw"`) threads through expansion via
-`ErrorPolicyCtx` (unset defaults to `"collect"`). Inside a rendered region, and
-everywhere when no `<Output>` is declared, an `ErrorSegment` renders as an
-`<!-- ERROR -->` comment (`raise` under `"collect"`). While executing
-documentation, the first `ErrorSegment` **throws immediately** (`raise` under
-`"throw"`, a `DocumentationError`) so it propagates to be handled above. Output
-regions reset the policy to `"collect"`; documentation sets it to `"throw"`.
-The modifier chain runs first (middleware may normalize a failure); the
-existing result classification then decides whether an `ErrorSegment` results —
-there is no separate raw `exitCode` policy.
-
-Because a nested component can produce an `ErrorSegment` inside its **own**
-valid `<Output>` under `"collect"` and return it to a suppressed-documentation
-caller, every site that **consumes** a component's returned segments re-applies
-the ambient policy: the `expandSegments` component case and markdown `as=`
-capture route transported error segments through `raise`/`consume`, and the
-`renderChildren()` / `render()` / `useContent()` / function-component paths run
-under the ambient policy so transported errors re-raise before being flattened
-to strings. Producing an error inside a component's own Output (a comment) is
-thus distinct from consuming it from a parent documentation context (a throw).
+#### Definition-owned structure and rendering
+
+A component's output regions are fixed by its own source, independent of the
+content a caller projects through `<Content />`, so caller content can neither
+add an output region nor suppress the declared body. `<Content />` inside a
+top-level `<Output>` projects the caller's content into that region.
+`<Output>` accepts no props. `<Output />` and `<Output></Output>` are
+equivalent and contribute no rendered content. Multiple top-level `<Output>`
+regions render in document order and concatenate. A component invoked with
+`as="binding"` captures only its selected output; its documentation executes
+but is neither rendered nor captured.
+
+#### Execution order and error behavior
+
+Documentation and output regions execute in document order, so an output region
+can use bindings a preceding documentation block computed, and documentation
+after a region still runs. The required sequencing:
+
+- Structural placement is validated before any body content executes; a
+  structurally invalid component or root runs no eval, exec, `<Capture>`, or
+  nested components and produces only the diagnostic.
+- Documentation and output regions execute in document order.
+- The first error produced while executing documentation stops that body's
+  execution immediately and propagates to the caller.
+- An error produced while rendering an output region — or anywhere in a body
+  that declares no `<Output>` — retains normal `ErrorSegment` rendering (an
+  `<!-- ERROR -->` comment).
+- A root containing `<Output>` emits its selected output only after the whole
+  body completes successfully; a documentation failure yields no partial
+  output, and an empty selection emits nothing.
+
+An error a nested component renders inside its own output region is a normal
+comment when that component renders normally; but when that component is
+executed as a parent's documentation, the parent's documentation fail-fast
+applies and the error propagates rather than being hidden.
+
+#### Root and component consistency
+
+A root document obeys exactly the same rules as an imported component (§5.4).
+Because selecting output requires the whole body, a root that declares
+`<Output>` is buffered — executed to completion, then emitted once on success —
+while a root without `<Output>` keeps per-segment streaming. Buffering defers
+only when output is emitted, not what executes, so replay is deterministic.
 
 ---
 

From 99037e49e5622683e2f026f751d046ba9488e489 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 16:37:44 -0400
Subject: [PATCH 4/9] review: replace Output-affected reference blocks with
 behavioral prose
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The documentWorkflow (§5.4), segment-expansion (§6.1), and component-expansion
(§6.2) pseudocode blocks were implementation snapshots. Remove them and state
the externally significant behavior as normative prose: streaming vs. buffered
root emission, per-segment rewriting and error rendering, and cycle/depth
guards + placement-before-execution + as= capture. Cross-reference the
dedicated sections (§6.3 slots, §6.5 prop validation, §6.9 <Output>) instead of
duplicating them. Keep the authoring example and the C32–C43 / E11–E13 cases.
---
 specs/executable-mdx-spec.md | 341 +++++------------------------------
 1 file changed, 50 insertions(+), 291 deletions(-)

diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index 7b5ec25..f7292a0 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -1944,50 +1944,16 @@ The entry point treats the root document through the same import
 pipeline as any component. This gives it uniform resolution, parsing, and
 error handling.
 
-The root obeys the same `<Output>` rules as any component (§6.9): it is
-structurally validated before execution, and a root declaring a top-level
-`<Output>` renders only its declared regions. Because output selection requires
-the whole body, a root with `<Output>` is **fully buffered** — it executes to
-completion and emits only after success; a root without `<Output>` keeps the
-per-segment streaming path.
-
-```typescript
-function* documentWorkflow(docPath: string): Workflow<string> {
-  // Import root — same pipeline as any component.
-  // The host installs Resolve middleware that maps "__root__" → docPath
-  const root = yield* durableImportComponent("__root__");
-
-  // Mutable counter preserves deterministic blockIds across
-  // per-segment expansion calls (see §6.1 for details).
-  const counter = createBlockCounter();
-
-  // Per-root-segment emission loop — each root segment is expanded
-  // independently and its output emitted through the Document Output Api (§9).
-  // Root segments are sequential and independent in document order.
-  // Component-internal expansion remains recursive and buffered.
-  for (const segment of root.bodySegments) {
-    const expanded = yield* expandSegments(
-      [segment],
-      root.meta,
-      {},              // No props for root
-      new Set(),       // Empty hide set
-      ctx,
-      counter,
-    );
-
-    for (const resolved of expanded) {
-      const text = renderSegment(resolved);
-      if (text) {
-        yield* ephemeral(output(text));
-      }
-    }
-  }
-
-  // Return value is empty — output has already been emitted
-  // incrementally via the Output Api.
-  return "";
-}
-```
+The root obeys the same `<Output>` rules as any component (§6.9), and how its
+output is emitted depends on whether it declares one. Without `<Output>`, the
+root's top-level segments are expanded in document order and each segment's
+rendered text is emitted incrementally through the Document Output Api (§9) as
+it is produced. With `<Output>`, the whole body is expanded before anything is
+emitted; only the selected content is emitted, and only after the body has
+completed successfully — a failure while executing documentation produces no
+emission, and an empty selection emits nothing. A component invoked within the
+root expands recursively and its result is buffered into the surrounding
+output in both cases.
 
 ---
 
@@ -2032,260 +1998,53 @@ increments occur, preventing state leaks on abort.
 
 #### Algorithm
 
-```typescript
-function* expandSegments(
-  segments: Segment[],
-  parentMeta: Record<string, unknown>,
-  parentProps: Record<string, Json>,
-  hideSet: Set<string>,
-  ctx: ExpansionContext,
-  counter: BlockCounter,
-): Workflow<Segment[]> {
-  const result: Segment[] = [];
-
-  for (const segment of segments) {
-    switch (segment.type) {
-      case "text": {
-        // Heal incomplete markdown constructs at segment boundaries
-        const healed = healSegment(segment.content);
-        // Interpolate {meta.key} and {props.key} — runtime, no journal
-        const interpolated = interpolate(healed, parentMeta, parentProps);
-        result.push({ type: "text", content: interpolated });
-        break;
-      }
+Segment expansion rewrites a list of segments into rendered segments, in
+document order:
 
-      case "component": {
-        if (segment.name === "Capture") {
-          const asBinding = segment.props.as;
-          if (typeof asBinding !== "string" || asBinding.length === 0) {
-            result.push({
-              type: "error",
-              message: '<Capture> requires an "as" prop (non-empty string).',
-              source: "Capture",
-            });
-            break;
-          }
-          if (!isValidIdentifier(asBinding)) {
-            result.push({
-              type: "error",
-              message: `<Capture as="${asBinding}">: as must be a valid JavaScript identifier.`,
-              source: "Capture",
-            });
-            break;
-          }
-          if (segment.selfClosing || segment.children.length === 0) {
-            result.push({
-              type: "error",
-              message: '<Capture> must have content. Use <Capture as="x">...</Capture>.',
-              source: "Capture",
-            });
-            break;
-          }
-
-          // Capture expands in the current env/scope (no fresh boundary).
-          const expandedChildren = yield* expandSegments(
-            segment.children,
-            parentMeta,
-            parentProps,
-            hideSet,
-            ctx,
-            counter,
-          );
-          let captured = renderSegments(expandedChildren).replace(/\s+$/, "");
-
-          // If select prop is present, parse rendered content as markdown
-          // and apply CSS selector to extract matching node's text content.
-          // Falls back to full rendered content if no node matches.
-          // See §6.5 for selector syntax and node extraction rules.
-          if (segment.props.select is a non-empty string) {
-            captured = applyCssSelector(captured, segment.props.select);
-          }
-
-          const env = yield* ephemeral(EvalEnvCtx.expect());
-          env.values[asBinding] = captured;
-          break;
-        }
-
-        const expanded = yield* expandComponent(
-          segment.name,
-          segment.props,
-          segment.children,
-          hideSet,
-        );
-        result.push(...expanded);
-        break;
-      }
+- **Text** is healed at segment boundaries (§2.3), then interpolated for
+  `{meta.key}` / `{props.key}` (§6.4) and for eval bindings (§6.6).
+- **`<Capture>`** expands its children in the current scope and stores the
+  rendered result in the named binding — optionally narrowed by a `select`
+  prop (§6.5) — and itself renders nothing. `<Content />` is replaced by the
+  caller's projected children (§6.3).
+- **Any other component** is expanded (§6.2) and replaced by its result.
+- **Executable code blocks** run their modifier chain (§3.3); a block
+  contributes its emitted output, or an `ErrorSegment` when it fails with no
+  output.
 
-      case "codeBlock": {
-        // Interpolate eval bindings into content before the modifier chain.
-        // EvalEnvCtx may not be set (e.g., blocks outside component expansion),
-        // so we use .get() and fall back to the original content.
-        const evalEnv = yield* EvalEnvCtx.get();
-        const interpolatedContent = evalEnv
-          ? interpolateEvalBindings(segment.content, evalEnv.values)
-          : segment.content;
-
-        // Compose modifier chain from info string and run it.
-        // blockId uses counter.next() for deterministic IDs that
-        // survive per-segment expansion (see §6.1 Block ID counter).
-        const context: CodeBlockContext = {
-          language: segment.language,
-          content: interpolatedContent,
-          blockId: `eval:${ctx.componentName ?? "root"}:${counter.next()}`,
-          componentName: ctx.componentName,
-        };
-        const chain = composeModifierChain(
-          segment.modifiers, context, registry,
-        );
-        const codeResult = yield* chain();
-
-        if (codeResult.exitCode !== 0 && codeResult.output === "") {
-          result.push({
-            type: "error",
-            message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
-            source: segment.content,
-          });
-        } else if (codeResult.output !== "") {
-          result.push({
-            type: "execOutput",
-            command: segment.content,
-            result: {
-              exitCode: codeResult.exitCode,
-              stdout: codeResult.output,
-              stderr: codeResult.stderr,
-            },
-          });
-        }
-        break;
-      }
+Errors are represented as `ErrorSegment`s and render as HTML comments by
+default (§11.2). Deterministic `blockId` values come from the block counter
+above, so per-segment expansion produces stable diagnostic identifiers.
 
-      default:
-        result.push(segment);
-    }
-  }
+Where a component (or the root) declares `<Output>`, this same rewriting drives
+each of its regions, but only the content of declared output regions is
+retained; content outside them executes for its effects without rendering, and
+the first error produced while executing that non-rendered documentation stops
+the body immediately (§6.9).
 
-  return result;
-}
-```
-
-The modifier chain composition and handler registration are defined
-in §3.3. The expansion code above composes the chain from the info
-string and runs it via `composeModifierChain`.
+The modifier chain composition and handler registration are defined in §3.3.
 
 ### 6.2 Component expansion with cycle detection
 
-```typescript
-const MAX_EXPANSION_DEPTH = 64;
-
-function* expandComponent(
-  name: string,
-  props: Record<string, Json>,
-  children: Segment[],
-  hideSet: Set<string>,
-): Workflow<Segment[]> {
-  // Cycle detection — Prosser's algorithm
-  if (hideSet.has(name)) {
-    return [{
-      type: "error",
-      message: `Cycle detected: ${name} is already being expanded (hide set: ${[...hideSet].join(" → ")})`,
-      source: name,
-    }];
-  }
-
-  if (hideSet.size >= MAX_EXPANSION_DEPTH) {
-    return [{
-      type: "error",
-      message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
-      source: name,
-    }];
-  }
-
-  // Import — single durable effect (resolve + read)
-  const definition = yield* durableImportComponent(name);
-
-  // Extract reserved props before validation.
-  // `slot` and `as` are consumed by the expansion engine.
-  const asBinding = props.as;
-  const { slot: _slot, as: _as, ...propsForValidation } = props;
-
-  // Validate props against declared inputs
-  const validatedProps = validateProps(name, propsForValidation, definition.inputs);
-
-  // Capture the caller's eval env. For multi-level nesting, merge
-  // projectedEnv (from outer caller) with the current context env
-  // so ancestor bindings propagate through all levels (DEC-91, 92).
-  const contextEnv = yield* EvalEnvCtx.get();
-  const callerEvalEnv = projectedEnv
-    ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
-    : contextEnv;
-
-  // Substitute raw children into <Content /> positions.
-  // Children are NOT pre-expanded — they expand in document order
-  // when the substituted body is expanded. This ensures code blocks
-  // before <Content /> (e.g., provider middleware installation) run
-  // before children's code blocks.
-  // Children segments are tagged with callerEvalEnv so expression
-  // props resolve in the caller's lexical scope (DEC-91).
-  const substituted = substituteContent(
-    definition.bodySegments,
-    children,
-    definition.meta,
-    validatedProps,
-    callerEvalEnv ?? undefined,
-  );
-
-  // Recurse with augmented hide set.
-  // Each component gets its own fresh binding environment so that
-  // eval blocks within a component share bindings but don't leak
-  // into parent or sibling components. This is critical for the
-  // provider pattern (§6.6) where each provider has isolated
-  // port/URL bindings.
-  //
-  // Props are pre-populated into env.values (DEC-EX-09) so they
-  // are available as bare bindings in eval blocks.
-  const newHideSet = new Set([...hideSet, name]);
-  const componentEnv: EvalEnv = { values: { ...validatedProps } };
-
-  // Inject renderChildren() and render() closures (§4.8).
-  // These capture the expansion context so they work correctly
-  // when called from within evalScope.eval().
-  componentEnv.values.renderChildren = function* () { /* ... */ };
-  componentEnv.values.render = function* (markdown) { /* ... */ };
-
-  const expanded = yield* EvalEnvCtx.with(
-    componentEnv,
-    function* () {
-      return yield* expandSegments(
-        substituted,
-        definition.meta,
-        validatedProps,
-        newHideSet,
-      );
-    },
-  );
-
-  // Binding capture: route rendered output to parent env and suppress
-  // document output at the invocation site.
-  if (asBinding !== undefined) {
-    if (typeof asBinding !== "string" || asBinding.length === 0) {
-      throw new PropValidationError(name, [
-        'Prop "as" on <' + name + ' /> must be a non-empty string literal',
-      ]);
-    }
-    if (!isValidIdentifier(asBinding)) {
-      throw new PropValidationError(name, [
-        `Prop "as" on <${name} /> must be a valid JavaScript identifier`,
-      ]);
-    }
-
-    const parentEnv = yield* ephemeral(EvalEnvCtx.expect());
-    parentEnv.values[asBinding] = renderSegments(expanded);
-    return [];
-  }
-
-  return expanded;
-}
-```
+Expanding a component invocation proceeds as:
+
+- **Cycle and depth guards.** A component already being expanded on the active
+  expansion path, or an expansion nested beyond the maximum depth (64),
+  produces an `ErrorSegment` instead of expanding — preventing infinite and
+  runaway expansion.
+- **Import and props.** The component is imported (§5.3); the reserved `slot`
+  and `as` props are consumed by the engine and stripped before the remaining
+  props are validated against the declared inputs (§6.3.5, §6.5).
+- **Body expansion.** The caller's children are substituted into `<Content />`
+  positions (§6.3), and the body is expanded in a fresh binding environment
+  seeded with the validated props, exposing `renderChildren()` / `render()`
+  (§4.8) to eval blocks. Expression props resolve in the caller's scope. When
+  the component declares `<Output>`, its placement is validated before any body
+  content executes and only its declared regions render (§6.9).
+- **Capture (`as=`).** With `as="binding"`, the rendered result is written to
+  that binding in the caller's environment and nothing is emitted at the call
+  site — capturing only the selected output when the component declares
+  `<Output>`.
 
 Cycle detection and depth limiting are runtime operations — no journal
 entries. They are deterministic from the component dependency graph read in

From d89f6b2e77e5006f1374e50d43b9c5123a901a30 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 18:14:37 -0400
Subject: [PATCH 5/9] refactor: replace expansion context plumbing with
 ComponentApi
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

One public Component context API (backed by @effectionx/context-api)
replaces ExpansionContext and the raw operational context keys.
Context-dependent behavior installs as scope-local middleware; nested
providers override ancestors without leaking into siblings.

- component-api.ts: Component/ComponentApi plus direct operations
  (importComponent, applyModifiers, raise, env, evalScope, codeBlock,
  persistent, content) with missing-provider defaults.
- expand.ts: ctx parameter removed from all expansion functions;
  error policy becomes raise() middleware (documentation throws,
  Output installs a collecting provider that shadows it); consumer
  boundaries raise transported errors unconditionally.
- run-document.ts: document providers install at min before
  durableRun; root imports via importComponent("__root__"); journal
  shape unchanged (verified by replay/journal tests).
- modifiers/persist/daemon/eval-handler/content-context: read state
  through the operations; useCodeBlock/useContent stay as aliases.
- mod.ts: export the new public surface; drop CodeBlockCtx,
  EvalEnvCtx, EvalScopeCtx, EvalCtxKey, createEvalContext.
- tests: makeCtx/recordingCtx replaced with Component middleware
  helpers; new component-api.test.ts (defaults, missing-provider
  diagnostics, scoped overrides, nested precedence, persist flag,
  content dispatch) and a journal-shape integration test.
- specs: new §5.5 Component Api contract + observable scoping;
  raw-key sections restated behaviorally; DEC-012 records the
  architectural decision.
---
 core/mod.ts                           |  23 +-
 core/src/component-api.ts             | 102 ++++++
 core/src/content-context.ts           |  56 +--
 core/src/error-policy.ts              |  49 +--
 core/src/eval-context.ts              |  35 +-
 core/src/eval-env.ts                  |  49 +--
 core/src/eval-handler.ts              |  38 ++-
 core/src/expand.ts                    | 475 +++++++++++++-------------
 core/src/modifiers.ts                 |  58 ++--
 core/src/modifiers/daemon.ts          |  11 +-
 core/src/modifiers/persist.ts         |  25 +-
 core/src/run-document.ts              |  90 ++---
 core/tests/component-api.test.ts      | 214 ++++++++++++
 core/tests/daemon.test.ts             |  28 +-
 core/tests/eval-middleware.test.ts    |   2 +-
 core/tests/expand.test.ts             | 298 +++++++++-------
 core/tests/expression-props.test.ts   |  51 ---
 core/tests/heal.test.ts               |  59 ++--
 core/tests/named-slots.test.ts        | 175 +++++-----
 core/tests/run-document.test.ts       |  30 ++
 core/tests/text-interpolation.test.ts | 159 +++++----
 specs/decisions.md                    |  91 +++--
 specs/executable-mdx-spec.md          | 281 +++++++--------
 23 files changed, 1346 insertions(+), 1053 deletions(-)
 create mode 100644 core/src/component-api.ts
 create mode 100644 core/tests/component-api.test.ts

diff --git a/core/mod.ts b/core/mod.ts
index 7ed1784..0871a0b 100644
--- a/core/mod.ts
+++ b/core/mod.ts
@@ -39,17 +39,32 @@ export type {
   ModifierMiddleware,
   CodeBlockWorkflow,
 } from "./src/modifiers.ts";
-export { useCodeBlock, CodeBlockCtx } from "./src/modifiers.ts";
+export { useCodeBlock } from "./src/modifiers.ts";
+
+// ---------------------------------------------------------------------------
+// Component Api — contextual operations for component expansion
+// ---------------------------------------------------------------------------
+
+export type { ComponentApi } from "./src/component-api.ts";
+export {
+  Component,
+  importComponent,
+  applyModifiers,
+  raise,
+  env,
+  evalScope,
+  codeBlock,
+  persistent,
+  content,
+} from "./src/component-api.ts";
 
 // ---------------------------------------------------------------------------
 // Eval system (generator eval blocks)
 // ---------------------------------------------------------------------------
 
 export type { EvalEnv } from "./src/eval-env.ts";
-export { EvalEnvCtx, EvalScopeCtx } from "./src/eval-env.ts";
 
-export type { EvalContext } from "./src/eval-context.ts";
-export { EvalCtxKey, createEvalContext, compileBlock } from "./src/eval-context.ts";
+export { compileBlock } from "./src/eval-context.ts";
 
 // ---------------------------------------------------------------------------
 // executable.md Globals (for generated eval modules)
diff --git a/core/src/component-api.ts b/core/src/component-api.ts
new file mode 100644
index 0000000..3e82333
--- /dev/null
+++ b/core/src/component-api.ts
@@ -0,0 +1,102 @@
+/**
+ * Component Api — contextual operations for component expansion.
+ *
+ * One public Api replaces the former dependency container (ExpansionContext)
+ * and raw Effection context keys. Context-dependent behavior is installed as
+ * scope-local middleware via `Component.around(...)`:
+ *
+ * - Runtime implementations (document import, modifier execution, component
+ *   state) install at `{ at: "min" }`. Middleware installed in a nested scope
+ *   runs before inherited middleware, so a component that installs its own
+ *   `env` shadows its ancestors without leaking into siblings — install
+ *   inside `scoped()` for automatic removal.
+ * - Caller instrumentation and overrides wrap at the default `"max"`.
+ */
+
+import { createApi } from "@effectionx/context-api";
+import type { Operation } from "effection";
+import type { EvalScope } from "@effectionx/scope-eval";
+import type {
+  CodeBlockContext,
+  CodeBlockResult,
+  ComponentDefinition,
+  ErrorSegment,
+  FunctionComponentDefinition,
+  Modifier,
+} from "./types.ts";
+import type { EvalEnv } from "./eval-env.ts";
+
+export interface ComponentApi {
+  /** `"__root__"` imports the root document. */
+  importComponent(name: string): Operation<ComponentDefinition | FunctionComponentDefinition>;
+  applyModifiers(modifiers: Modifier[], block: CodeBlockContext): Operation<CodeBlockResult>;
+  /**
+   * Report an ErrorSegment under the ambient error policy. The default
+   * returns the segment for rendering; suppressed-documentation scopes
+   * install middleware that throws instead (spec §6.9).
+   */
+  raise(error: ErrorSegment): Operation<ErrorSegment>;
+  env(): Operation<EvalEnv | undefined>;
+  evalScope(): Operation<EvalScope | undefined>;
+  codeBlock(): Operation<CodeBlockContext>;
+  /** Whether the current block runs with persistent resource lifetime. */
+  persistent(): Operation<boolean>;
+  /** Render the invoking component's children (optionally a named slot). */
+  content(slot?: string): Operation<string>;
+}
+
+export const Component = createApi<ComponentApi>("Component", {
+  // deno-lint-ignore require-yield
+  *importComponent(name: string): Operation<ComponentDefinition | FunctionComponentDefinition> {
+    throw new Error(
+      `Component.importComponent("${name}") has no provider. Install one with ` +
+        `Component.around({ importComponent }, { at: "min" }) before expansion.`,
+    );
+  },
+  // deno-lint-ignore require-yield
+  *applyModifiers(_modifiers: Modifier[], block: CodeBlockContext): Operation<CodeBlockResult> {
+    throw new Error(
+      `Component.applyModifiers() has no provider for block "${block.blockId}". Install one ` +
+        `with Component.around({ applyModifiers }, { at: "min" }) before expansion.`,
+    );
+  },
+  // deno-lint-ignore require-yield
+  *raise(error: ErrorSegment): Operation<ErrorSegment> {
+    return error;
+  },
+  // deno-lint-ignore require-yield
+  *env(): Operation<EvalEnv | undefined> {
+    return undefined;
+  },
+  // deno-lint-ignore require-yield
+  *evalScope(): Operation<EvalScope | undefined> {
+    return undefined;
+  },
+  // deno-lint-ignore require-yield
+  *codeBlock(): Operation<CodeBlockContext> {
+    throw new Error(
+      "Component.codeBlock() has no provider: no code block is executing in this scope.",
+    );
+  },
+  // deno-lint-ignore require-yield
+  *persistent(): Operation<boolean> {
+    return false;
+  },
+  // deno-lint-ignore require-yield
+  *content(_slot?: string): Operation<string> {
+    throw new Error(
+      "Component.content() has no provider: not inside a function component invocation.",
+    );
+  },
+});
+
+export const {
+  importComponent,
+  applyModifiers,
+  raise,
+  env,
+  evalScope,
+  codeBlock,
+  persistent,
+  content,
+} = Component.operations;
diff --git a/core/src/content-context.ts b/core/src/content-context.ts
index 1480516..4aeff8b 100644
--- a/core/src/content-context.ts
+++ b/core/src/content-context.ts
@@ -1,62 +1,26 @@
 /**
- * Content context for function components.
- *
- * Provides `useContent()` — the function component equivalent of
- * `<Content />` in markdown components. The expansion engine sets
- * the content handle on the Effection scope before calling the
- * function component. Components that need rendered children call
- * `yield* useContent()` to retrieve them.
- *
- * Named slots are supported: `yield* useContent("header")` returns
- * the content for the "header" slot, matching `<Content slot="header" />`
- * in markdown components.
+ * useContent() — the function component equivalent of `<Content />` in
+ * markdown components. Ergonomic alias for the Component `content()`
+ * operation; the expansion engine installs the slot-rendering middleware
+ * around each function component invocation.
  */
 
-import { createContext } from "effection";
 import type { Operation } from "effection";
-import type { Segment } from "./types.ts";
-
-/**
- * Handle providing access to a component's children content.
- * Set on the Effection scope by the expansion engine.
- */
-export interface ContentHandle {
-  /** Render the default slot (children without a slot prop). */
-  renderDefault: () => Operation<string>;
-  /** Render a named slot. Returns empty string if the slot has no content. */
-  renderSlot: (name: string) => Operation<string>;
-  /** Raw child segments (all slots combined, for inspection). */
-  segments: Segment[];
-}
+import { content } from "./component-api.ts";
 
 /**
- * Effection context key for the content handle.
- */
-export const ContentCtx = createContext<ContentHandle>("content");
-
-/**
- * Render children content from the parent scope.
- *
- * The function component equivalent of `<Content />` in markdown components.
+ * Render children content from the invoking component.
  *
  * @param slotName - Optional slot name. If provided, renders only the
- *   content assigned to that slot. If omitted, renders the default slot
- *   (children without a `slot` prop).
- * @returns The rendered content as a string.
+ *   content assigned to that slot (matching `<Content slot="name" />`).
+ *   If omitted, renders the default slot.
  *
  * @example
  * ```ts
- * // Render default content (equivalent to <Content /> in .md)
- * const content = yield* useContent();
- *
- * // Render named slot (equivalent to <Content slot="header" /> in .md)
+ * const body = yield* useContent();
  * const header = yield* useContent("header");
  * ```
  */
 export function* useContent(slotName?: string): Operation<string> {
-  const handle = yield* ContentCtx.expect();
-  if (slotName !== undefined) {
-    return yield* handle.renderSlot(slotName);
-  }
-  return yield* handle.renderDefault();
+  return yield* content(slotName);
 }
diff --git a/core/src/error-policy.ts b/core/src/error-policy.ts
index 23ec243..96ae9bf 100644
--- a/core/src/error-policy.ts
+++ b/core/src/error-policy.ts
@@ -1,30 +1,16 @@
 /**
- * Contextual error policy for expansion (spec §6.9).
+ * Documentation failure marker (spec §6.9).
  *
- * Inside a rendered region — an `<Output>` region, or anywhere when no
- * `<Output>` is declared — an ErrorSegment renders as an HTML comment
- * ("collect"). While executing suppressed documentation, the first
- * ErrorSegment produced throws immediately ("throw") so it propagates to be
- * handled above.
+ * Error policy is contextual middleware on `Component.operations.raise`:
+ * suppressed documentation installs a throwing implementation, output
+ * regions install a collecting one that shadows it. DocumentationError is
+ * the internal throwable those middlewares use — generic error handling in
+ * the engine rethrows it instead of converting it into an ErrorSegment, so
+ * documentation fail-fast is never swallowed.
  */
 
-import { createContext } from "effection";
-import type { Operation } from "effection";
-import type { ErrorSegment, Segment } from "./types.ts";
+import type { ErrorSegment } from "./types.ts";
 
-export type ErrorPolicy = "collect" | "throw";
-
-/**
- * Effection context holding the ambient error policy. Unset defaults to
- * "collect" — today's behavior where ErrorSegments render as comments.
- */
-export const ErrorPolicyCtx = createContext<ErrorPolicy>("errorPolicy");
-
-/**
- * Thrown when an ErrorSegment is produced or transported into a suppressed
- * documentation region. Carries the offending segment so callers above can
- * inspect it.
- */
 export class DocumentationError extends Error {
   readonly segment: ErrorSegment;
 
@@ -34,22 +20,3 @@ export class DocumentationError extends Error {
     this.segment = segment;
   }
 }
-
-/** Read the ambient error policy, defaulting to "collect" when unset. */
-export function* currentErrorPolicy(): Operation<ErrorPolicy> {
-  const policy = yield* ErrorPolicyCtx.get();
-  return policy ?? "collect";
-}
-
-/**
- * Route an ErrorSegment through the ambient policy. Under "throw" it raises a
- * DocumentationError (fail-fast); under "collect" it returns the segment so
- * the caller renders it as a comment.
- */
-export function* raise(segment: ErrorSegment): Operation<Segment[]> {
-  const policy = yield* currentErrorPolicy();
-  if (policy === "throw") {
-    throw new DocumentationError(segment);
-  }
-  return [segment];
-}
diff --git a/core/src/eval-context.ts b/core/src/eval-context.ts
index 34034ea..56cf0ae 100644
--- a/core/src/eval-context.ts
+++ b/core/src/eval-context.ts
@@ -1,43 +1,10 @@
 /**
- * Eval block compilation context (spec §5).
+ * Eval block compilation (spec §5).
  */
 
-import { createContext as createEffectionContext } from "effection";
 import type { Operation } from "effection";
 import { compile as runtimeCompile } from "@executablemd/runtime";
 
-// ---------------------------------------------------------------------------
-// EvalContext — lightweight context for the eval system
-// ---------------------------------------------------------------------------
-
-/**
- * Eval context for document runs.
- *
- * In the Deno model, there is no VM context — eval blocks are compiled
- * into data: URI modules that import their dependencies. The EvalContext
- * exists as a marker that the eval system has been initialized.
- */
-export interface EvalContext {
-  /** Placeholder for future per-document eval configuration. */
-  initialized: true;
-}
-
-/**
- * Effection context key for the eval context.
- */
-export const EvalCtxKey = createEffectionContext<EvalContext>("evalContext");
-
-/**
- * Create an eval context for a document run.
- *
- * In the Deno model, this is lightweight — no VM sandbox creation.
- * The eval context is set on the Effection scope so eval blocks
- * can verify the eval system is initialized.
- */
-export function createEvalContext(_globals: Record<string, unknown> = {}): EvalContext {
-  return { initialized: true };
-}
-
 /**
  * Compile transformed source code into a generator function.
  *
diff --git a/core/src/eval-env.ts b/core/src/eval-env.ts
index 70b9660..0394958 100644
--- a/core/src/eval-env.ts
+++ b/core/src/eval-env.ts
@@ -1,30 +1,12 @@
 /**
- * Eval environment — shared binding environment and scope contexts
- * for generator eval blocks (spec generator-eval-spec.md §3.1–3.2).
+ * Eval environment — shared binding environment for generator eval blocks
+ * (spec generator-eval-spec.md §3.2).
  *
- * - EvalEnv: mutable record of bindings shared across eval blocks within a component
- * - EvalEnvCtx: Effection context for the current component's binding environment
- * - EvalScopeCtx: Effection context for the current component's eval scope
+ * The current environment and eval scope are delivered contextually via the
+ * Component Api (`Component.operations.env()` / `Component.operations.evalScope()`),
+ * installed as scope-local middleware by the expansion engine.
  */
 
-import { createContext } from "effection";
-import type { EvalScope } from "@effectionx/scope-eval";
-
-// ---------------------------------------------------------------------------
-// Persist flag (spec §7.1)
-// ---------------------------------------------------------------------------
-
-/**
- * When set to true on the scope, the eval handler will run the compiled
- * block inside the EvalScope's persistent child scope. Set by the
- * persist modifier, read by evalFactory.
- */
-export const PersistFlagCtx = createContext<boolean>("persistFlag");
-
-// ---------------------------------------------------------------------------
-// Binding environment (spec §3.2)
-// ---------------------------------------------------------------------------
-
 /**
  * Shared binding environment for eval blocks within a single component.
  *
@@ -35,24 +17,3 @@ export const PersistFlagCtx = createContext<boolean>("persistFlag");
 export interface EvalEnv {
   values: Record<string, unknown>;
 }
-
-/**
- * Effection context holding the current component's binding environment.
- *
- * Set via `EvalEnvCtx.with()` in the expansion engine when a component
- * begins expansion. Handlers access it via `ephemeral(EvalEnvCtx.expect())`.
- */
-export const EvalEnvCtx = createContext<EvalEnv>("evalEnv");
-
-// ---------------------------------------------------------------------------
-// Eval scope (spec §3.1)
-// ---------------------------------------------------------------------------
-
-/**
- * Effection context holding the current component's EvalScope.
- *
- * The EvalScope (from @effectionx/scope-eval) is created per component
- * and allows `persist` blocks to retain resources beyond block lifetime.
- * The scope is destroyed when component expansion completes.
- */
-export const EvalScopeCtx = createContext<EvalScope>("evalScope");
diff --git a/core/src/eval-handler.ts b/core/src/eval-handler.ts
index bf0f8b3..73344ec 100644
--- a/core/src/eval-handler.ts
+++ b/core/src/eval-handler.ts
@@ -4,7 +4,7 @@ import { unbox } from "@effectionx/scope-eval";
 import type { Operation } from "effection";
 import type { ModifierFactory } from "./modifiers.ts";
 import { useCodeBlock } from "./modifiers.ts";
-import { EvalEnvCtx, EvalScopeCtx, PersistFlagCtx } from "./eval-env.ts";
+import { env, evalScope, persistent } from "./component-api.ts";
 import { compileBlock } from "./eval-context.ts";
 import { transformBlock, serializeExports } from "./eval-transform.ts";
 
@@ -15,8 +15,13 @@ import { transformBlock, serializeExports } from "./eval-transform.ts";
 export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
   (function* () {
     const ctx = yield* useCodeBlock();
-    const env = yield* ephemeral(EvalEnvCtx.expect());
-    const persist = yield* ephemeral(PersistFlagCtx.get()) ?? false;
+    const evalEnv = yield* ephemeral(env());
+    if (!evalEnv) {
+      throw new Error(
+        `eval block "${ctx.blockId}" requires a binding environment; none is in scope.`,
+      );
+    }
+    const persist = yield* ephemeral(persistent());
 
     // Inject output() function into env so eval blocks can produce
     // rendered output. The function is a plain synchronous call:
@@ -26,13 +31,13 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
     // the journal. The output text itself is journaled alongside
     // exports as __output.
     const outputRef = { text: "" };
-    env.values.output = (text: string) => {
+    evalEnv.values.output = (text: string) => {
       outputRef.text = String(text);
     };
 
-    const transformed = transformBlock(ctx.content, ctx.blockId, Object.keys(env.values));
+    const transformed = transformBlock(ctx.content, ctx.blockId, Object.keys(evalEnv.values));
 
-    const bindings = serializeExports(env.values, transformed.imports);
+    const bindings = serializeExports(evalEnv.values, transformed.imports);
     const result = (yield createDurableOperation<Json>(
       {
         type: "eval",
@@ -41,7 +46,7 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
       },
       function* (): Operation<Json> {
         // Merge incoming bindings snapshot into env before execution
-        Object.assign(env.values, bindings);
+        Object.assign(evalEnv.values, bindings);
 
         // Compile the eval block via data: URI module import.
         // compileBlock is async (returns Operation) — it generates a
@@ -49,11 +54,16 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
         const fn = yield* compileBlock(transformed.code, transformed.userImports ?? []);
 
         if (persist) {
-          // Persist mode: run the compiled block inside evalScope.eval()
+          // Persist mode: run the compiled block inside the eval scope
           // so spawned resources are retained in the persistent EvalScope.
-          const evalScope = yield* EvalScopeCtx.expect();
-          const blockResult = yield* evalScope.eval(
-            () => fn(env.values) as unknown as Operation<unknown>,
+          const scope = yield* evalScope();
+          if (!scope) {
+            throw new Error(
+              `persist eval block "${ctx.blockId}" requires a component eval scope; none is in scope.`,
+            );
+          }
+          const blockResult = yield* scope.eval(
+            () => fn(evalEnv.values) as unknown as Operation<unknown>,
           );
           const returnValue = unbox(blockResult);
           if (!outputRef.text && returnValue != null) {
@@ -62,13 +72,13 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
         } else {
           // Normal mode: run the compiled block in the current scope.
           // Resources are torn down when this operation completes.
-          const returnValue = yield* fn(env.values) as unknown as Operation<unknown>;
+          const returnValue = yield* fn(evalEnv.values) as unknown as Operation<unknown>;
           if (!outputRef.text && returnValue != null) {
             outputRef.text = String(returnValue);
           }
         }
 
-        const exports = serializeExports(env.values, transformed.exports);
+        const exports = serializeExports(evalEnv.values, transformed.exports);
 
         if (outputRef.text) {
           (exports as Record<string, unknown>).__output = outputRef.text;
@@ -86,7 +96,7 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
       }
       // Remove __output from exports before assigning to env
       const { __output: _, ...exports } = restored;
-      Object.assign(env.values, exports);
+      Object.assign(evalEnv.values, exports);
     }
 
     return { output: outputRef.text, exitCode: 0, stderr: "" };
diff --git a/core/src/expand.ts b/core/src/expand.ts
index 124f38b..4de6cc6 100644
--- a/core/src/expand.ts
+++ b/core/src/expand.ts
@@ -13,10 +13,8 @@
  * middleware installation) execute before children's code blocks.
  */
 
-import { useScope } from "effection";
+import { scoped } from "effection";
 import type { Operation } from "effection";
-import { ContentCtx } from "./content-context.ts";
-import type { ContentHandle } from "./content-context.ts";
 import type {
   Segment,
   TextSegment,
@@ -26,14 +24,19 @@ import type {
   FunctionComponentDefinition,
   Json,
   CodeBlockContext,
-  CodeBlockResult,
-  Modifier,
 } from "./types.ts";
 import { interpolate } from "./interpolate.ts";
 import { interpolateEvalBindings } from "./eval-interpolate.ts";
-import { EvalEnvCtx, EvalScopeCtx } from "./eval-env.ts";
 import type { EvalEnv } from "./eval-env.ts";
-import { ErrorPolicyCtx, DocumentationError, currentErrorPolicy, raise } from "./error-policy.ts";
+import {
+  Component,
+  applyModifiers,
+  env,
+  evalScope,
+  importComponent,
+  raise,
+} from "./component-api.ts";
+import { DocumentationError } from "./error-policy.ts";
 import { useEvalScope, unbox } from "@effectionx/scope-eval";
 import type { EvalScope } from "@effectionx/scope-eval";
 import { validateProps } from "./validate.ts";
@@ -63,24 +66,32 @@ export function createBlockCounter(): BlockCounter {
 }
 
 // ---------------------------------------------------------------------------
-// Types for the expansion context
+// Scope-local providers — installed inside scoped() so nested components
+// override ancestors without leaking into siblings
 // ---------------------------------------------------------------------------
 
-export type ComponentImporter = (
-  name: string,
-) => Operation<ComponentDefinition | FunctionComponentDefinition>;
+function* provideEnv(value: EvalEnv): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *env(_args, _next) {
+        return value;
+      },
+    },
+    { at: "min" },
+  );
+}
 
-/**
- * Function that executes a modifier chain for a code block.
- */
-export type ModifierChainRunner = (
-  modifiers: Modifier[],
-  context: CodeBlockContext,
-) => Operation<CodeBlockResult>;
-
-export interface ExpansionContext {
-  importComponent: ComponentImporter;
-  runModifierChain: ModifierChainRunner;
+function* provideEvalScope(value: EvalScope): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *evalScope(_args, _next) {
+        return value;
+      },
+    },
+    { at: "min" },
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -93,6 +104,10 @@ const IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 /**
  * Expand an array of segments, resolving components and executing code blocks.
  *
+ * Component import, modifier execution, bindings, and error policy are all
+ * delivered contextually through the Component Api — install providers with
+ * `Component.around(..., { at: "min" })` before expanding.
+ *
  * @param counter - Optional block ID counter. If omitted, a local counter
  *   is created. For per-segment emission (§9), pass a shared counter so
  *   IDs are stable across calls.
@@ -102,7 +117,6 @@ export function* expandSegments(
   parentMeta: Record<string, unknown>,
   parentProps: Record<string, Json>,
   hideSet: Set<string>,
-  ctx: ExpansionContext,
   counter: BlockCounter = createBlockCounter(),
 ): Operation<Segment[]> {
   const result: Segment[] = [];
@@ -117,8 +131,8 @@ export function* expandSegments(
         const interpolated = interpolate(healed, parentMeta, parentProps);
         // Interpolate bare {name} refs from eval bindings (spec §6.4/§6.6).
         // Runs after meta/props interpolation so component contract takes
-        // precedence. Only runs when an EvalEnv is present on the scope.
-        const textEvalEnv = yield* EvalEnvCtx.get();
+        // precedence. Only runs when a binding environment is in scope.
+        const textEvalEnv = yield* env();
         const final = textEvalEnv
           ? interpolateEvalBindings(interpolated, textEvalEnv.values)
           : interpolated;
@@ -132,7 +146,7 @@ export function* expandSegments(
           // reaches here. Reaching this branch means a misplaced or
           // dynamically scanned <Output> (e.g. render(markdown) content) —
           // diagnose it defensively per the ambient policy.
-          result.push(...(yield* raise(misplacedOutputError())));
+          result.push(yield* raise(misplacedOutputError()));
           break;
         }
 
@@ -142,11 +156,10 @@ export function* expandSegments(
             parentMeta,
             parentProps,
             hideSet,
-            ctx,
             counter,
           );
           if (captureResult) {
-            result.push(...(yield* raise(captureResult)));
+            result.push(yield* raise(captureResult));
           }
           break;
         }
@@ -157,7 +170,6 @@ export function* expandSegments(
           segment.expressions,
           segment.children,
           hideSet,
-          ctx,
           counter,
           segment.projectedEnv,
         );
@@ -165,7 +177,7 @@ export function* expandSegments(
         // ambient policy before appending them (spec §6.9).
         for (const expandedSegment of expanded) {
           if (expandedSegment.type === "error") {
-            result.push(...(yield* raise(expandedSegment)));
+            result.push(yield* raise(expandedSegment));
           } else {
             result.push(expandedSegment);
           }
@@ -175,13 +187,13 @@ export function* expandSegments(
 
       case "codeBlock": {
         // Interpolate eval bindings into content before the modifier chain.
-        // EvalEnvCtx may not be set (e.g., blocks outside component expansion),
-        // so we use .get() and fall back to the original content.
+        // A binding environment may not be in scope (e.g., blocks outside
+        // component expansion) — fall back to the original content.
         //
         // Skip interpolation for eval blocks — they access bindings directly
         // via the env preamble (const { name } = env;). Interpolating would
         // mangle JS template literals like `${name}` into `$<value>`.
-        const evalEnv = yield* EvalEnvCtx.get();
+        const evalEnv = yield* env();
         const lastModifier = segment.modifiers[segment.modifiers.length - 1];
         const isEvalTerminal = lastModifier !== undefined && lastModifier.name === "eval";
         const interpolatedContent =
@@ -200,15 +212,15 @@ export function* expandSegments(
         };
 
         try {
-          const codeResult = yield* ctx.runModifierChain(segment.modifiers, context);
+          const codeResult = yield* applyModifiers(segment.modifiers, context);
 
           if (codeResult.exitCode !== 0 && codeResult.output === "") {
             result.push(
-              ...(yield* raise({
+              yield* raise({
                 type: "error",
                 message: `Command failed (exit ${codeResult.exitCode}): ${codeResult.stderr}`,
                 source: segment.content,
-              })),
+              }),
             );
           } else if (codeResult.output !== "") {
             result.push({
@@ -229,11 +241,11 @@ export function* expandSegments(
             throw error;
           }
           result.push(
-            ...(yield* raise({
+            yield* raise({
               type: "error",
               message: error instanceof Error ? error.message : String(error),
               source: segment.content,
-            })),
+            }),
           );
         }
         break;
@@ -243,7 +255,7 @@ export function* expandSegments(
         if (segment.type === "error") {
           // Pre-existing error segments (e.g. slot/substitution errors) follow
           // the ambient policy.
-          result.push(...(yield* raise(segment)));
+          result.push(yield* raise(segment));
         } else {
           result.push(segment);
         }
@@ -259,7 +271,6 @@ function* expandCapture(
   parentMeta: Record<string, unknown>,
   parentProps: Record<string, Json>,
   hideSet: Set<string>,
-  ctx: ExpansionContext,
   counter: BlockCounter,
 ): Operation<ErrorSegment | undefined> {
   if (segment.selfClosing || segment.children.length === 0) {
@@ -327,7 +338,6 @@ function* expandCapture(
     parentMeta,
     parentProps,
     hideSet,
-    ctx,
     counter,
   );
   const rendered = renderSegments(expandedChildren).replace(/\s+$/, "");
@@ -344,15 +354,15 @@ function* expandCapture(
     }
   }
 
-  const env = yield* EvalEnvCtx.get();
-  if (!env) {
+  const bindingEnv = yield* env();
+  if (!bindingEnv) {
     return {
       type: "error",
       message: "<Capture> requires an evaluation environment.",
       source: "Capture",
     };
   }
-  env.values[bindingName] = captured;
+  bindingEnv.values[bindingName] = captured;
   return undefined;
 }
 
@@ -366,39 +376,47 @@ function* expandComponent(
   expressions: Record<string, string>,
   children: Segment[],
   hideSet: Set<string>,
-  ctx: ExpansionContext,
   counter: BlockCounter,
   projectedEnv?: EvalEnv,
 ): Operation<Segment[]> {
   // Cycle detection — Prosser's algorithm
   if (hideSet.has(name)) {
-    return yield* raise({
-      type: "error",
-      message: `Cycle detected: ${name} is already being expanded (hide set: ${[...hideSet].join(" → ")})`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: `Cycle detected: ${name} is already being expanded (hide set: ${[...hideSet].join(" → ")})`,
+        source: name,
+      }),
+    ];
   }
 
   if (hideSet.size >= MAX_EXPANSION_DEPTH) {
-    return yield* raise({
-      type: "error",
-      message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
+        source: name,
+      }),
+    ];
   }
 
   let imported: ComponentDefinition | FunctionComponentDefinition;
   try {
-    imported = yield* ctx.importComponent(name);
+    imported = yield* importComponent(name);
   } catch (error) {
-    return yield* raise({
-      type: "error",
-      message:
-        error instanceof Error
-          ? `Failed to import component ${name}: ${error.message}`
-          : `Failed to import component ${name}: ${String(error)}`,
-      source: name,
-    });
+    if (error instanceof DocumentationError) {
+      throw error;
+    }
+    return [
+      yield* raise({
+        type: "error",
+        message:
+          error instanceof Error
+            ? `Failed to import component ${name}: ${error.message}`
+            : `Failed to import component ${name}: ${String(error)}`,
+        source: name,
+      }),
+    ];
   }
 
   // Function component: call the generator function directly
@@ -410,7 +428,6 @@ function* expandComponent(
       children,
       imported,
       hideSet,
-      ctx,
       counter,
       projectedEnv,
     );
@@ -424,7 +441,7 @@ function* expandComponent(
   // components, or other side effects.
   const placementError = validateOutputPlacement(definition.bodySegments);
   if (placementError) {
-    return yield* raise(placementError);
+    return [yield* raise(placementError)];
   }
 
   // Resolve eval expression props against env.values using the shared
@@ -434,19 +451,23 @@ function* expandComponent(
   try {
     resolvedProps = yield* resolveExpressionProps(props, expressions, name, projectedEnv);
   } catch (error) {
-    return yield* raise({
-      type: "error",
-      message: error instanceof Error ? error.message : String(error),
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        source: name,
+      }),
+    ];
   }
 
   if ("as" in expressions) {
-    return yield* raise({
-      type: "error",
-      message: `Prop "as" on <${name} /> must be a string literal.`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: `Prop "as" on <${name} /> must be a string literal.`,
+        source: name,
+      }),
+    ];
   }
 
   // Validate props against declared inputs.
@@ -464,11 +485,13 @@ function* expandComponent(
     const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps;
     validatedProps = validateProps(name, propsForValidation, definition.inputs);
   } catch (error) {
-    return yield* raise({
-      type: "error",
-      message: error instanceof Error ? error.message : String(error),
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        source: name,
+      }),
+    ];
   }
 
   // Capture the caller's eval environment before creating the component's
@@ -480,7 +503,7 @@ function* expandComponent(
   // the projectedEnv from the outer caller must be merged with the current
   // context env so that ancestor bindings propagate through all levels.
   // The current context env's bindings take precedence (innermost-wins).
-  const contextEnv = yield* EvalEnvCtx.get();
+  const contextEnv = yield* env();
   const callerEvalEnv = projectedEnv
     ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
     : contextEnv;
@@ -504,7 +527,7 @@ function* expandComponent(
   // By creating it via parentEvalScope.eval(), the child's spawned task
   // lives inside the parent's scope — Effection's scope prototype chain
   // ensures scope.reduce() walks child → parent when resolving middleware.
-  const parentEvalScope = yield* EvalScopeCtx.get();
+  const parentEvalScope = yield* evalScope();
   let childEvalScope: EvalScope | undefined = undefined;
   if (parentEvalScope) {
     const result = yield* parentEvalScope.eval(() => useEvalScope());
@@ -531,10 +554,9 @@ function* expandComponent(
   // their own child scopes off parentEvalScope, and ancestor
   // middleware is visible through Effection's scope prototype chain.
   //
-  // Both wrap their expandSegments call in EvalEnvCtx.with() and
-  // EvalScopeCtx.with() so the full expansion context is available
-  // regardless of which task the closure runs in (e.g., inside
-  // evalScope.eval()).
+  // Both install env/evalScope middleware inside a fresh scope so the full
+  // expansion context is available regardless of which task the closure
+  // runs in (e.g., inside evalScope.eval()).
   //
   // These are non-serializable (functions) so serializeExports silently
   // omits them from the journal.
@@ -546,82 +568,40 @@ function* expandComponent(
   // without triggering false cycle detection. True cycles in a component's
   // body are still caught because body expansion uses newHideSet.
   const capturedChildrenHideSet = hideSet;
-  const capturedCtx = ctx;
   const capturedParentEvalScope = parentEvalScope;
   // Children are caller-provided content. Use the caller's eval env so
   // expression props (e.g., {pr}) resolve against the scope where the
   // JSX was written, not the wrapping component's env. Falls back to
   const capturedCallerEnv = callerEvalEnv ?? componentEnv;
 
-  componentEnv.values.renderChildren = function* () {
-    return yield* EvalEnvCtx.with(capturedCallerEnv, function* () {
+  const renderInCallerScope = (segments: Segment[]) =>
+    scoped(function* () {
+      yield* provideEnv(capturedCallerEnv);
       if (capturedParentEvalScope) {
-        return yield* EvalScopeCtx.with(capturedParentEvalScope, function* () {
-          const expanded = yield* expandSegments(
-            children,
-            capturedMeta,
-            capturedProps,
-            capturedChildrenHideSet,
-            capturedCtx,
-            counter,
-          );
-          return renderSegments(expanded);
-        });
+        yield* provideEvalScope(capturedParentEvalScope);
       }
       const expanded = yield* expandSegments(
-        children,
+        segments,
         capturedMeta,
         capturedProps,
         capturedChildrenHideSet,
-        capturedCtx,
         counter,
       );
       return renderSegments(expanded);
     });
+
+  componentEnv.values.renderChildren = function* () {
+    return yield* renderInCallerScope(children);
   };
 
   componentEnv.values.render = function* (markdown: string) {
-    const segments = scanSegments(markdown);
-    return yield* EvalEnvCtx.with(capturedCallerEnv, function* () {
-      if (capturedParentEvalScope) {
-        return yield* EvalScopeCtx.with(capturedParentEvalScope, function* () {
-          const expanded = yield* expandSegments(
-            segments,
-            capturedMeta,
-            capturedProps,
-            capturedChildrenHideSet,
-            capturedCtx,
-            counter,
-          );
-          return renderSegments(expanded);
-        });
-      }
-      const expanded = yield* expandSegments(
-        segments,
-        capturedMeta,
-        capturedProps,
-        capturedChildrenHideSet,
-        capturedCtx,
-        counter,
-      );
-      return renderSegments(expanded);
-    });
+    return yield* renderInCallerScope(scanSegments(markdown));
   };
 
-  const expanded = yield* EvalEnvCtx.with(componentEnv, function* () {
+  const expanded = yield* scoped(function* () {
+    yield* provideEnv(componentEnv);
     if (childEvalScope) {
-      return yield* EvalScopeCtx.with(childEvalScope, function* () {
-        return yield* expandBody(
-          definition.bodySegments,
-          children,
-          definition.meta,
-          validatedProps,
-          newHideSet,
-          ctx,
-          counter,
-          callerEvalEnv ?? undefined,
-        );
-      });
+      yield* provideEvalScope(childEvalScope);
     }
     return yield* expandBody(
       definition.bodySegments,
@@ -629,25 +609,29 @@ function* expandComponent(
       definition.meta,
       validatedProps,
       newHideSet,
-      ctx,
       counter,
       callerEvalEnv ?? undefined,
     );
   });
 
   if (asBinding) {
-    const parentEnv = yield* EvalEnvCtx.get();
+    const parentEnv = yield* env();
     if (!parentEnv) {
-      return yield* raise({
-        type: "error",
-        message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
-        source: name,
-      });
+      return [
+        yield* raise({
+          type: "error",
+          message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
+          source: name,
+        }),
+      ];
+    }
+    // Consumer boundary (spec §6.9): raise transported errors unconditionally
+    // so documentation never captures and hides an error comment.
+    for (const capturedSegment of expanded) {
+      if (capturedSegment.type === "error") {
+        yield* raise(capturedSegment);
+      }
     }
-    // Consumer boundary (spec §6.9): re-raise transported errors under the
-    // ambient policy so documentation never captures and hides an error
-    // comment.
-    yield* consume(expanded);
     parentEnv.values[asBinding] = renderSegments(expanded);
     return [];
   }
@@ -673,16 +657,17 @@ function* expandFunctionComponent(
   children: Segment[],
   definition: FunctionComponentDefinition,
   hideSet: Set<string>,
-  ctx: ExpansionContext,
   counter: BlockCounter,
   projectedEnv?: EvalEnv,
 ): Operation<Segment[]> {
   if ("as" in expressions) {
-    return yield* raise({
-      type: "error",
-      message: `Prop "as" on <${name} /> must be a string literal.`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: `Prop "as" on <${name} /> must be a string literal.`,
+        source: name,
+      }),
+    ];
   }
 
   // Resolve expression props
@@ -690,21 +675,25 @@ function* expandFunctionComponent(
   try {
     resolvedProps = yield* resolveExpressionProps(props, expressions, name, projectedEnv);
   } catch (error) {
-    return yield* raise({
-      type: "error",
-      message: error instanceof Error ? error.message : String(error),
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        source: name,
+      }),
+    ];
   }
 
   // Strip slot prop before validation
   const asBindingResult = validateBindingName(resolvedProps.as);
   if (!asBindingResult.ok) {
-    return yield* raise({
-      type: "error",
-      message: `Prop "as" on <${name} /> ${asBindingResult.error}`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: `Prop "as" on <${name} /> ${asBindingResult.error}`,
+        source: name,
+      }),
+    ];
   }
   const asBinding = asBindingResult.value;
   const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps;
@@ -714,64 +703,71 @@ function* expandFunctionComponent(
   try {
     validatedProps = validateProps(name, propsForValidation, definition.inputs);
   } catch (error) {
-    return yield* raise({
-      type: "error",
-      message: error instanceof Error ? error.message : String(error),
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        source: name,
+      }),
+    ];
   }
 
-  // Set ContentCtx on the scope so the function component can
-  // access children via `yield* useContent()`. Supports named
-  // slots: `yield* useContent("header")`.
   const slots = partitionBySlot(children);
-  const scope = yield* useScope();
-
-  const contentHandle: ContentHandle = {
-    segments: children,
-    *renderDefault() {
-      const expanded = yield* expandSegments(slots.default, {}, {}, hideSet, ctx, counter);
-      return renderSegments(expanded);
-    },
-    *renderSlot(slotName: string) {
-      const slotChildren = (slots.named.get(slotName) ?? []).map(stripSlotProp);
-      if (slotChildren.length === 0) return "";
-      const expanded = yield* expandSegments(slotChildren, {}, {}, hideSet, ctx, counter);
-      return renderSegments(expanded);
-    },
-  };
-  scope.set(ContentCtx, contentHandle);
 
-  // Call the function component
+  // Call the function component with content middleware in scope so it can
+  // render children via `yield* useContent()` / `useContent("slot")`.
   try {
-    const output = yield* definition.fn(validatedProps);
+    const output = yield* scoped(function* () {
+      yield* Component.around(
+        {
+          *content([slotName], _next) {
+            if (slotName !== undefined) {
+              const slotChildren = (slots.named.get(slotName) ?? []).map(stripSlotProp);
+              if (slotChildren.length === 0) {
+                return "";
+              }
+              const expanded = yield* expandSegments(slotChildren, {}, {}, hideSet, counter);
+              return renderSegments(expanded);
+            }
+            const expanded = yield* expandSegments(slots.default, {}, {}, hideSet, counter);
+            return renderSegments(expanded);
+          },
+        },
+        { at: "min" },
+      );
+      return yield* definition.fn(validatedProps);
+    });
     if (asBinding) {
-      const parentEnv = yield* EvalEnvCtx.get();
+      const parentEnv = yield* env();
       if (!parentEnv) {
-        return yield* raise({
-          type: "error",
-          message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
-          source: name,
-        });
+        return [
+          yield* raise({
+            type: "error",
+            message: `Prop "as" on <${name} /> requires a parent evaluation environment.`,
+            source: name,
+          }),
+        ];
       }
       parentEnv.values[asBinding] = output;
       return [];
     }
     return [{ type: "text", content: output }];
   } catch (error) {
-    // A DocumentationError from a content-rendering path (renderDefault /
-    // useContent) is fail-fast — propagate it unchanged.
+    // A DocumentationError from a content-rendering path (useContent) is
+    // fail-fast — propagate it unchanged.
     if (error instanceof DocumentationError) {
       throw error;
     }
-    return yield* raise({
-      type: "error",
-      message:
-        error instanceof Error
-          ? `Function component ${name} error: ${error.message}`
-          : `Function component ${name} error: ${String(error)}`,
-      source: name,
-    });
+    return [
+      yield* raise({
+        type: "error",
+        message:
+          error instanceof Error
+            ? `Function component ${name} error: ${error.message}`
+            : `Function component ${name} error: ${String(error)}`,
+        source: name,
+      }),
+    ];
   }
 }
 
@@ -829,7 +825,7 @@ function* resolveExpressionProps(
     return resolved;
   }
 
-  const contextEnv = yield* EvalEnvCtx.get();
+  const contextEnv = yield* env();
 
   // For projected children (substituted via <Content />), merge the
   // caller's env (explicitEnv) with the wrapping component's env
@@ -1227,11 +1223,12 @@ function buildBody(
 /**
  * Expand a definition body (spec §6.9). Without a top-level `<Output>`, the
  * whole body renders (backward compatible). With `<Output>`, only the declared
- * regions render; documentation executes for its side effects under a "throw"
- * policy (fail-fast) and its rendered result is discarded; output regions run
- * under "collect" (errors render as comments). Regions and documentation run
- * in document order, so output can depend on bindings computed by preceding
- * documentation.
+ * regions render; documentation executes for its side effects under a throwing
+ * raise policy (fail-fast) and its rendered result is discarded; output
+ * regions install a collecting raise that shadows any inherited throwing
+ * middleware (innermost min runs first), so their errors render as comments.
+ * Regions and documentation run in document order, so output can depend on
+ * bindings computed by preceding documentation.
  */
 export function* expandBody(
   bodySegments: Segment[],
@@ -1239,13 +1236,12 @@ export function* expandBody(
   meta: Record<string, unknown>,
   props: Record<string, Json>,
   hideSet: Set<string>,
-  ctx: ExpansionContext,
   counter: BlockCounter,
   callerEnv: EvalEnv | undefined,
 ): Operation<Segment[]> {
   if (!bodyHasOutput(bodySegments)) {
     const substituted = substituteContent(bodySegments, children, meta, props, callerEnv);
-    return yield* expandSegments(substituted, meta, props, hideSet, ctx, counter);
+    return yield* expandSegments(substituted, meta, props, hideSet, counter);
   }
 
   const chunks = buildBody(bodySegments, children, meta, props, callerEnv);
@@ -1253,34 +1249,35 @@ export function* expandBody(
 
   for (const chunk of chunks) {
     if (chunk.output) {
-      const expanded = yield* ErrorPolicyCtx.with("collect", function* () {
-        return yield* expandSegments(chunk.segments, meta, props, hideSet, ctx, counter);
+      const expanded = yield* scoped(function* () {
+        yield* Component.around(
+          {
+            // deno-lint-ignore require-yield
+            *raise([error], _next) {
+              return error;
+            },
+          },
+          { at: "min" },
+        );
+        return yield* expandSegments(chunk.segments, meta, props, hideSet, counter);
       });
       output.push(...expanded);
     } else {
       // Documentation: execute for side effects, discard rendered output.
-      yield* ErrorPolicyCtx.with("throw", function* () {
-        return yield* expandSegments(chunk.segments, meta, props, hideSet, ctx, counter);
+      yield* scoped(function* () {
+        yield* Component.around(
+          {
+            // deno-lint-ignore require-yield
+            *raise([error], _next) {
+              throw new DocumentationError(error);
+            },
+          },
+          { at: "min" },
+        );
+        return yield* expandSegments(chunk.segments, meta, props, hideSet, counter);
       });
     }
   }
 
   return output;
 }
-
-/**
- * Consumer boundary (spec §6.9). When consuming a component's returned
- * segments in a documentation context, re-raise the first transported error
- * so it is never captured and hidden. Under "collect" it is a no-op.
- */
-function* consume(segments: Segment[]): Operation<void> {
-  const policy = yield* currentErrorPolicy();
-  if (policy !== "throw") {
-    return;
-  }
-  for (const segment of segments) {
-    if (segment.type === "error") {
-      throw new DocumentationError(segment);
-    }
-  }
-}
diff --git a/core/src/modifiers.ts b/core/src/modifiers.ts
index ebce5c8..82912f6 100644
--- a/core/src/modifiers.ts
+++ b/core/src/modifiers.ts
@@ -10,47 +10,24 @@
  * - The middleware signature is Middleware<[], CodeBlockWorkflow>
  */
 
-import { createContext } from "effection";
+import { scoped } from "effection";
 import type { Operation } from "effection";
 import { ephemeral } from "@executablemd/durable-streams";
 import type { Workflow } from "@executablemd/durable-streams";
 import type { Middleware } from "@effectionx/middleware";
 import { combine } from "@effectionx/middleware";
+import { Component, codeBlock } from "./component-api.ts";
 import type { CodeBlockContext, CodeBlockResult, Modifier } from "./types.ts";
 
-// ---------------------------------------------------------------------------
-// CodeBlock context — Effection scope-inherited value
-// ---------------------------------------------------------------------------
-
-/**
- * Effection Context holding the current code block's metadata.
- *
- * Set on the scope via `CodeBlockCtx.with()` before the modifier chain
- * runs. Handlers that need the code block info (language, content,
- * componentName) read it via `useCodeBlock()` instead of receiving it
- * as a parameter.
- */
-export const CodeBlockCtx = createContext<CodeBlockContext>("codeBlock");
-
 /**
- * Read the current code block context from the Effection scope.
+ * Read the current code block context.
  *
- * Returns a Workflow-compatible generator (bridged via `ephemeral`)
- * so it can be `yield*`'d inside modifier handlers that run within
- * durable workflows.
- *
- * @example
- * ```typescript
- * const myFactory: ModifierFactory = (_params) =>
- *   (_args, next) => function* () {
- *     const ctx = yield* useCodeBlock();
- *     console.log(ctx.language);
- *     return yield* next();
- *   }();
- * ```
+ * Ergonomic alias for the Component `codeBlock()` operation, bridged via
+ * `ephemeral` so it can be `yield*`'d inside modifier handlers that run
+ * within durable workflows.
  */
 export function useCodeBlock(): Workflow<CodeBlockContext> {
-  return ephemeral(CodeBlockCtx.expect());
+  return ephemeral(codeBlock());
 }
 
 // ---------------------------------------------------------------------------
@@ -125,9 +102,9 @@ export function createModifierRegistry(parent?: ModifierRegistry): ModifierRegis
  * leftmost modifier is the outermost wrapper. `combine` handles the
  * right-to-left reduction internally.
  *
- * The `context` parameter is made available to handlers via Effection's
- * `CodeBlockCtx.with()`, which sets the context on the scope for the
- * duration of the chain execution and restores it afterward.
+ * The `context` parameter is made available to handlers via scope-local
+ * `Component.operations.codeBlock()` middleware, installed for the
+ * duration of the chain execution and removed when its scope exits.
  */
 export function composeModifierChain(
   modifiers: Modifier[],
@@ -156,13 +133,22 @@ export function composeModifierChain(
   // Combine all middlewares into a single middleware
   const composed = combine(middlewares);
 
-  // Return a thunk that sets CodeBlockCtx for the duration of the
-  // chain via Context.with(), then runs the composed middleware.
+  // Return a thunk that provides the code block contextually for the
+  // duration of the chain, then runs the composed middleware.
   // The cast is safe because CodeBlockWorkflow yields DurableEffect
   // values which extend Effect — structurally compatible with Operation.
   return function* () {
     return yield* ephemeral(
-      CodeBlockCtx.with(context, function* () {
+      scoped(function* () {
+        yield* Component.around(
+          {
+            // deno-lint-ignore require-yield
+            *codeBlock(_args, _next) {
+              return context;
+            },
+          },
+          { at: "min" },
+        );
         return yield* composed([], terminal) as unknown as Operation<CodeBlockResult>;
       }),
     );
diff --git a/core/src/modifiers/daemon.ts b/core/src/modifiers/daemon.ts
index 1da0c31..39c61e9 100644
--- a/core/src/modifiers/daemon.ts
+++ b/core/src/modifiers/daemon.ts
@@ -15,7 +15,7 @@ import { ephemeral } from "@executablemd/durable-streams";
 import { daemon } from "@effectionx/process";
 import type { ModifierFactory } from "../modifiers.ts";
 import { useCodeBlock } from "../modifiers.ts";
-import { EvalScopeCtx } from "../eval-env.ts";
+import { evalScope } from "../component-api.ts";
 
 // ---------------------------------------------------------------------------
 // daemonFactory — terminal modifier (spec §3.3)
@@ -26,7 +26,7 @@ import { EvalScopeCtx } from "../eval-env.ts";
  *
  * Ignores `next` — this is the terminal handler (like `exec` and `eval`).
  * Reads code block metadata via useCodeBlock() and the eval scope via
- * EvalScopeCtx.
+ * Component.evalScope().
  *
  * The block's content (already interpolated with eval bindings by the
  * expansion engine) is used to build the subprocess command. The command
@@ -46,14 +46,17 @@ export const daemonFactory: ModifierFactory = (_params) => (_args, _next) =>
     // daemon produces no journal entry, so all its effects are ephemeral.
     const launchDaemon = {
       *[Symbol.iterator]() {
-        const evalScope = yield* EvalScopeCtx.expect();
+        const scope = yield* evalScope();
+        if (!scope) {
+          throw new Error("daemon requires a component eval scope; none is in scope.");
+        }
 
         // The block content is a raw shell command (e.g. the body of a
         // ```bash daemon exec``` block). Pass it directly to daemon()
         // with shell:true so @effectionx/process invokes the system
         // shell instead of splitting with shellwords — which would
         // mangle commands containing nested quotes.
-        yield* evalScope.eval(function* () {
+        yield* scope.eval(function* () {
           yield* daemon(ctx.content, { shell: true });
         });
       },
diff --git a/core/src/modifiers/persist.ts b/core/src/modifiers/persist.ts
index 1369058..07a52d2 100644
--- a/core/src/modifiers/persist.ts
+++ b/core/src/modifiers/persist.ts
@@ -8,16 +8,17 @@
  * evalScope.eval(), which retains spawned resources in the persistent
  * EvalScope until the component finishes expanding.
  *
- * Implementation: persist sets a context flag (PersistFlagCtx) that the
- * eval handler reads. The eval handler then runs fn(env) inside
+ * Implementation: persist installs Component.persistent() middleware that
+ * the eval handler reads. The eval handler then runs fn(env) inside
  * evalScope.eval() instead of directly. This avoids wrapping the entire
  * modifier chain (which includes durable effects that can't cross the
  * evalScope channel boundary).
  */
 
+import { scoped } from "effection";
 import { ephemeral } from "@executablemd/durable-streams";
 import type { ModifierFactory } from "../modifiers.ts";
-import { PersistFlagCtx } from "../eval-env.ts";
+import { Component } from "../component-api.ts";
 
 // ---------------------------------------------------------------------------
 // persistFactory (spec §7.1)
@@ -26,17 +27,23 @@ import { PersistFlagCtx } from "../eval-env.ts";
 /**
  * Wrapping modifier that marks a block for persistent resource lifetime.
  *
- * Sets PersistFlagCtx=true on the scope for the duration of the inner
- * chain. The eval handler reads this flag and routes the compiled block
+ * Makes Component.persistent() answer true for the duration of the inner
+ * chain. The eval handler reads this and routes the compiled block
  * execution through evalScope.eval() for resource retention.
  */
 export const persistFactory: ModifierFactory = (_params) => (_args, next) =>
   (function* () {
-    // Set the persist flag on the scope, then delegate to the inner chain.
-    // evalFactory will read this flag and route execution through
-    // evalScope.eval() for resource retention.
     return yield* ephemeral(
-      PersistFlagCtx.with(true, function* () {
+      scoped(function* () {
+        yield* Component.around(
+          {
+            // deno-lint-ignore require-yield
+            *persistent(_args, _next) {
+              return true;
+            },
+          },
+          { at: "min" },
+        );
         return yield* next() as unknown as import("effection").Operation<
           import("../types.ts").CodeBlockResult
         >;
diff --git a/core/src/run-document.ts b/core/src/run-document.ts
index ace6af4..1dd0776 100644
--- a/core/src/run-document.ts
+++ b/core/src/run-document.ts
@@ -8,7 +8,7 @@
  * See DEC-005 in specs/decisions.md.
  */
 
-import { useScope, spawn, createChannel, withResolvers, until } from "effection";
+import { scoped, spawn, createChannel, withResolvers, until } from "effection";
 import type { Operation, Stream } from "effection";
 import {
   durableRun,
@@ -26,8 +26,6 @@ import type {
   FunctionComponentDefinition,
   InputDefinition,
   ImportResult,
-  Modifier,
-  CodeBlockContext,
 } from "./types.ts";
 import { scanSegments } from "./scanner.ts";
 import { parseFrontmatter } from "./frontmatter.ts";
@@ -38,7 +36,7 @@ import {
   validateOutputPlacement,
   createBlockCounter,
 } from "./expand.ts";
-import type { ExpansionContext } from "./expand.ts";
+import { Component, importComponent } from "./component-api.ts";
 import { renderSegment } from "./render.ts";
 import { DocumentOutput } from "./api.ts";
 import {
@@ -47,12 +45,11 @@ import {
   createModifierRegistry,
   useCodeBlock,
 } from "./modifiers.ts";
-import type { ModifierFactory, ModifierRegistry } from "./modifiers.ts";
+import type { ModifierFactory } from "./modifiers.ts";
 import { evalFactory } from "./eval-handler.ts";
 import { persistFactory } from "./modifiers/persist.ts";
 import { timeoutFactory } from "./modifiers/timeout.ts";
 import { daemonFactory } from "./modifiers/daemon.ts";
-import { EvalEnvCtx, EvalScopeCtx } from "./eval-env.ts";
 import type { EvalEnv } from "./eval-env.ts";
 import { useEvalScope } from "@effectionx/scope-eval";
 import { Stdio } from "@effectionx/process";
@@ -252,45 +249,38 @@ const silentFactory: ModifierFactory = (_params) => (_args, next) =>
 // calls inside the expansion engine. See DEC-002.
 // ---------------------------------------------------------------------------
 
-function* documentWorkflow(
-  docPath: string,
-  searchPaths: string[],
-  modifierRegistry: ModifierRegistry,
-): Workflow<string> {
-  // Import root — same pipeline as any component
-  const root = yield* durableImportComponent("__root__", docPath, searchPaths);
+function* documentWorkflow(): Workflow<string> {
+  // Import root — same pipeline as any component. The provider middleware
+  // installed by runDocument maps "__root__" to the document path. The
+  // ephemeral() wrapper bridges typing only — the import inside remains a
+  // durable, journaled operation.
+  const root = yield* ephemeral(importComponent("__root__"));
 
   if (root.kind === "function") {
     throw new Error("Root document must be a markdown file, not a function component");
   }
 
-  const env: EvalEnv = { values: {} };
-
-  // Build the expansion context
-  const ctx: ExpansionContext = {
-    importComponent: function* (name: string) {
-      return yield* durableImportComponent(name, undefined, searchPaths);
-    },
-    runModifierChain: function* (modifiers: Modifier[], context: CodeBlockContext) {
-      const chain = composeModifierChain(modifiers, context, modifierRegistry);
-      return yield* chain();
-    },
-  };
+  const rootEnv: EvalEnv = { values: {} };
 
   // Per-root-segment emission loop (spec §9).
   // Mutable counter preserves deterministic blockIds across
   // per-segment expansion calls (see spec §6.1).
   const counter = createBlockCounter();
 
-  // EvalScopeCtx is already set on the scope by runDocument.
-  // EvalEnvCtx is scoped to the document expansion lifetime via
-  // Context.with() (spec §3.1). Resources spawned by `persist` blocks
-  // are retained in the eval scope until expansion completes, then
-  // torn down.
-  //
-  // The EvalEnvCtx.with() wraps the entire loop so all segments share
-  // the same binding environment.
-  const scopedExpansion: Operation<string> = EvalEnvCtx.with(env, function* () {
+  // The root binding environment is installed as scope-local middleware
+  // around the entire loop so all segments share it. Resources spawned by
+  // `persist` blocks are retained in the eval scope until expansion
+  // completes, then torn down.
+  const scopedExpansion: Operation<string> = scoped(function* () {
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *env(_args, _next) {
+          return rootEnv;
+        },
+      },
+      { at: "min" },
+    );
     // Structural preflight (spec §6.9): a root with misplaced <Output>
     // executes no body side effects; the aggregate diagnostic renders as a
     // comment (root policy is "collect").
@@ -312,7 +302,6 @@ function* documentWorkflow(
         root.meta,
         {},
         new Set(),
-        ctx,
         counter,
         undefined,
       );
@@ -328,7 +317,7 @@ function* documentWorkflow(
     const chunks: string[] = [];
 
     for (const segment of root.bodySegments) {
-      const expanded = yield* expandSegments([segment], root.meta, {}, new Set(), ctx, counter);
+      const expanded = yield* expandSegments([segment], root.meta, {}, new Set(), counter);
 
       for (const resolved of expanded) {
         const text = renderSegment(resolved);
@@ -437,7 +426,6 @@ export function* runDocument(options: RunDocumentOptions): Operation<DocumentExe
   const { operation, resolve, reject } = withResolvers<string>();
 
   yield* spawn(function* () {
-    const scope = yield* useScope();
     let emitted = false;
 
     // Install platform-appropriate compiler middleware
@@ -466,11 +454,35 @@ export function* runDocument(options: RunDocumentOptions): Operation<DocumentExe
     // Created in the same scope as durableRun so that DurableCtx
     // (set by durableRun) is visible to eval code that calls
     // renderChildren → importComponent → createDurableOperation.
-    scope.set(EvalScopeCtx, yield* useEvalScope());
+    const rootEvalScope = yield* useEvalScope();
+
+    // Install the document's runtime Component providers before durableRun
+    // so the workflow inherits them: component import, modifier execution,
+    // and the root eval scope.
+    yield* Component.around(
+      {
+        *importComponent([name], _next) {
+          return yield* durableImportComponent(
+            name,
+            name === "__root__" ? docPath : undefined,
+            componentDirs,
+          );
+        },
+        *applyModifiers([modifiers, context], _next) {
+          const chain = composeModifierChain(modifiers, context, registry);
+          return yield* chain();
+        },
+        // deno-lint-ignore require-yield
+        *evalScope(_args, _next) {
+          return rootEvalScope;
+        },
+      },
+      { at: "min" },
+    );
 
     // Run the durable workflow.
     try {
-      const output = yield* durableRun(() => documentWorkflow(docPath, componentDirs, registry), {
+      const output = yield* durableRun(() => documentWorkflow(), {
         stream,
       });
 
diff --git a/core/tests/component-api.test.ts b/core/tests/component-api.test.ts
new file mode 100644
index 0000000..746aa3b
--- /dev/null
+++ b/core/tests/component-api.test.ts
@@ -0,0 +1,214 @@
+/**
+ * Component Api tests — default operations, missing-provider diagnostics,
+ * scoped middleware overrides, and nested provider precedence.
+ */
+import { describe, it } from "@effectionx/bdd/node";
+import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
+import type { Operation } from "effection";
+import {
+  Component,
+  importComponent,
+  applyModifiers,
+  raise,
+  env,
+  evalScope,
+  codeBlock,
+  persistent,
+  content,
+} from "../src/component-api.ts";
+import { persistFactory } from "../src/modifiers/persist.ts";
+import type { ComponentDefinition, ErrorSegment } from "../src/types.ts";
+
+function stubComponent(name: string): ComponentDefinition {
+  return { kind: "markdown", name, path: `${name}.md`, meta: {}, inputs: {}, bodySegments: [] };
+}
+
+function* messageOf(operation: Operation<unknown>): Operation<string> {
+  try {
+    yield* operation;
+    return "";
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+describe("Component Api", () => {
+  // ----- Defaults -----
+
+  it("importComponent without a provider throws a missing-provider error", function* () {
+    const message = yield* messageOf(importComponent("Missing"));
+    expect(message).toContain('importComponent("Missing")');
+    expect(message).toContain("has no provider");
+  });
+
+  it("applyModifiers without a provider throws a missing-provider error", function* () {
+    const block = { language: "bash", content: "x", blockId: "test:0" };
+    const message = yield* messageOf(applyModifiers([{ name: "exec" }], block));
+    expect(message).toContain("applyModifiers");
+    expect(message).toContain("has no provider");
+  });
+
+  it("codeBlock without a provider throws a missing-provider error", function* () {
+    const message = yield* messageOf(codeBlock());
+    expect(message).toContain("codeBlock");
+    expect(message).toContain("has no provider");
+  });
+
+  it("content without a provider throws a missing-provider error", function* () {
+    const message = yield* messageOf(content());
+    expect(message).toContain("content");
+    expect(message).toContain("has no provider");
+  });
+
+  it("raise returns the supplied ErrorSegment by default", function* () {
+    const segment: ErrorSegment = { type: "error", message: "boom", source: "test" };
+    const returned = yield* raise(segment);
+    expect(returned).toBe(segment);
+  });
+
+  it("env and evalScope default to undefined; persistent defaults to false", function* () {
+    expect(yield* env()).toBe(undefined);
+    expect(yield* evalScope()).toBe(undefined);
+    expect(yield* persistent()).toBe(false);
+  });
+
+  // ----- Scoped overrides -----
+
+  it("a scoped max middleware wraps importComponent and is removed on scope exit", function* () {
+    const real = stubComponent("Real");
+    const aliased = stubComponent("Aliased");
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *importComponent([name], _next) {
+          if (name === "Real") {
+            return real;
+          }
+          throw new Error(`Component not found: ${name}`);
+        },
+      },
+      { at: "min" },
+    );
+
+    const inside = yield* scoped(function* () {
+      yield* Component.around({
+        *importComponent([name], next) {
+          if (name === "Alias") {
+            return aliased;
+          }
+          return yield* next(name);
+        },
+      });
+      return {
+        alias: yield* importComponent("Alias"),
+        delegated: yield* importComponent("Real"),
+      };
+    });
+    expect(inside.alias).toBe(aliased);
+    expect(inside.delegated).toBe(real);
+
+    // Outside the scope the alias middleware is gone.
+    const message = yield* messageOf(importComponent("Alias"));
+    expect(message).toContain("Component not found: Alias");
+  });
+
+  it("a scoped applyModifiers provider overrides an inherited one and is removed on exit", function* () {
+    const block = { language: "bash", content: "x", blockId: "test:0" };
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *applyModifiers(_args, _next) {
+          return { output: "outer\n", exitCode: 0, stderr: "" };
+        },
+      },
+      { at: "min" },
+    );
+
+    const inner = yield* scoped(function* () {
+      yield* Component.around(
+        {
+          // deno-lint-ignore require-yield
+          *applyModifiers(_args, _next) {
+            return { output: "inner\n", exitCode: 0, stderr: "" };
+          },
+        },
+        { at: "min" },
+      );
+      return yield* applyModifiers([], block);
+    });
+    expect(inner.output).toBe("inner\n");
+
+    const outer = yield* applyModifiers([], block);
+    expect(outer.output).toBe("outer\n");
+  });
+
+  // ----- Nested precedence without sibling leakage -----
+
+  it("nested env providers override ancestors without leaking into siblings", function* () {
+    const outerEnv = { values: { tag: "outer" } };
+    const innerEnv = { values: { tag: "inner" } };
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *env(_args, _next) {
+          return outerEnv;
+        },
+      },
+      { at: "min" },
+    );
+
+    const first = yield* scoped(function* () {
+      yield* Component.around(
+        {
+          // deno-lint-ignore require-yield
+          *env(_args, _next) {
+            return innerEnv;
+          },
+        },
+        { at: "min" },
+      );
+      return yield* env();
+    });
+    expect(first).toBe(innerEnv);
+
+    // A sibling scope sees the ancestor provider, not the first sibling's.
+    const second = yield* scoped(function* () {
+      return yield* env();
+    });
+    expect(second).toBe(outerEnv);
+  });
+
+  // ----- Persistent evaluation flag -----
+
+  it("persistent() is true inside the persist modifier chain and false outside", function* () {
+    let observed: boolean | undefined = undefined;
+    const middleware = persistFactory(undefined);
+    const terminal = function* () {
+      observed = yield* persistent();
+      return { output: "", exitCode: 0, stderr: "" };
+    };
+    yield* middleware([], terminal) as unknown as Operation<unknown>;
+    expect(observed).toBe(true);
+    expect(yield* persistent()).toBe(false);
+  });
+
+  // ----- Content provider dispatch -----
+
+  it("content(slot) dispatches through the installed provider", function* () {
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *content([slot], _next) {
+          if (slot !== undefined) {
+            return `slot:${slot}`;
+          }
+          return "default";
+        },
+      },
+      { at: "min" },
+    );
+    expect(yield* content()).toBe("default");
+    expect(yield* content("header")).toBe("slot:header");
+  });
+});
diff --git a/core/tests/daemon.test.ts b/core/tests/daemon.test.ts
index 208afef..25f2cc8 100644
--- a/core/tests/daemon.test.ts
+++ b/core/tests/daemon.test.ts
@@ -6,9 +6,10 @@
  */
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
 import { daemonFactory } from "../src/modifiers/daemon.ts";
 import { combine } from "@effectionx/middleware";
-import { CodeBlockCtx } from "../src/modifiers.ts";
+import { Component } from "../src/component-api.ts";
 import type { ModifierFactory, ModifierMiddleware } from "../src/modifiers.ts";
 import type { Operation } from "effection";
 
@@ -63,16 +64,14 @@ describe("Tier Q — Daemon modifier", () => {
     expect(factory.length).toBe(2);
   });
 
-  // Q10b: daemon without EvalScopeCtx throws a clear error
-  // When the daemon middleware runs in a scope where EvalScopeCtx
-  // is not set, EvalScopeCtx.expect() should throw.
-  it("Q10b: daemon without EvalScopeCtx throws clear error", function* () {
+  // Q10b: daemon without an eval scope in scope throws a clear error
+  it("Q10b: daemon without an eval scope throws clear error", function* () {
     const middleware = daemonFactory(undefined);
     const terminal = function* () {
       return { output: "", exitCode: 0, stderr: "" };
     };
 
-    // Provide CodeBlockCtx (required by useCodeBlock) but NOT EvalScopeCtx
+    // Provide the code block (required by useCodeBlock) but no eval scope
     const fakeContext = {
       language: "bash",
       content: "echo hello",
@@ -83,10 +82,16 @@ describe("Tier Q — Daemon modifier", () => {
     let errorMessage = "";
 
     try {
-      yield* CodeBlockCtx.with(fakeContext, function* () {
-        // The daemon middleware generator yields ephemeral operations.
-        // When it reaches EvalScopeCtx.expect() without the context set,
-        // it should throw.
+      yield* scoped(function* () {
+        yield* Component.around(
+          {
+            // deno-lint-ignore require-yield
+            *codeBlock(_args, _next) {
+              return fakeContext;
+            },
+          },
+          { at: "min" },
+        );
         yield* middleware([], terminal) as unknown as Operation<unknown>;
       });
     } catch (e) {
@@ -95,7 +100,6 @@ describe("Tier Q — Daemon modifier", () => {
     }
 
     expect(threw).toBe(true);
-    // The error should mention the missing context
-    expect(errorMessage.toLowerCase()).toMatch(/evalscope|context/);
+    expect(errorMessage).toContain("daemon requires a component eval scope");
   });
 });
diff --git a/core/tests/eval-middleware.test.ts b/core/tests/eval-middleware.test.ts
index abc1a67..2d3b01a 100644
--- a/core/tests/eval-middleware.test.ts
+++ b/core/tests/eval-middleware.test.ts
@@ -53,7 +53,7 @@ describe("Tier T3 — Middleware factory conformance", () => {
     expect(typeof middleware).toBe("function");
   });
 
-  // T28: EvalEnvCtx accessible pattern
+  // T28: binding environment accessible pattern
   it("T28: evalFactory creates a generator when called", function* () {
     const middleware = evalFactory(undefined);
     // Call the middleware with dummy args and next
diff --git a/core/tests/expand.test.ts b/core/tests/expand.test.ts
index 7af6920..0da4e82 100644
--- a/core/tests/expand.test.ts
+++ b/core/tests/expand.test.ts
@@ -1,21 +1,15 @@
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
 import { expandSegments } from "../src/expand.ts";
-import type { ExpansionContext } from "../src/expand.ts";
+import { Component } from "../src/component-api.ts";
 import { scanSegments } from "../src/scanner.ts";
 import { interpolate } from "../src/interpolate.ts";
 import { validateProps, PropValidationError } from "../src/validate.ts";
 import { renderSegments } from "../src/render.ts";
 import type { Operation } from "effection";
-import { EvalEnvCtx } from "../src/eval-env.ts";
-import type {
-  Segment,
-  ComponentDefinition,
-  Json,
-  CodeBlockResult,
-  Modifier,
-  CodeBlockContext,
-} from "../src/types.ts";
+import type { EvalEnv } from "../src/eval-env.ts";
+import type { Segment, ComponentDefinition, Json, CodeBlockResult } from "../src/types.ts";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -39,56 +33,78 @@ function makeComponent(
   };
 }
 
-function makeCtx(
+/** Install test component + modifier providers on the current scope. */
+function* useTestComponents(
   components: Record<string, ComponentDefinition>,
   codeResult?: CodeBlockResult,
-): ExpansionContext {
-  return {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], _context: CodeBlockContext) {
-      return (
-        codeResult ?? {
-          output: "mock output\n",
-          exitCode: 0,
-          stderr: "",
+): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *importComponent([name], _next) {
+        const comp = components[name];
+        if (!comp) {
+          throw new Error(`Component not found: ${name}`);
         }
-      );
+        return comp;
+      },
+      // deno-lint-ignore require-yield
+      *applyModifiers(_args, _next) {
+        return (
+          codeResult ?? {
+            output: "mock output\n",
+            exitCode: 0,
+            stderr: "",
+          }
+        );
+      },
     },
-  };
+    { at: "min" },
+  );
+}
+
+/** Install a binding environment on the current scope. */
+function* useTestEnv(testEnv: EvalEnv): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *env(_args, _next) {
+        return testEnv;
+      },
+    },
+    { at: "min" },
+  );
 }
 
 function expand(
   segments: Segment[],
-  ctx: ExpansionContext,
-  meta: Record<string, unknown> = {},
-  props: Record<string, Json> = {},
+  components: Record<string, ComponentDefinition>,
+  opts: {
+    meta?: Record<string, unknown>;
+    props?: Record<string, Json>;
+    codeResult?: CodeBlockResult;
+  } = {},
 ): Operation<string> {
-  function* op() {
-    return yield* EvalEnvCtx.with({ values: {} }, function* () {
-      const expanded = yield* expandSegments(segments, meta, props, new Set(), ctx);
-      return renderSegments(expanded);
-    });
-  }
-  return op() as unknown as Operation<string>;
+  return scoped(function* () {
+    yield* useTestComponents(components, opts.codeResult);
+    yield* useTestEnv({ values: {} });
+    const expanded = yield* expandSegments(segments, opts.meta ?? {}, opts.props ?? {}, new Set());
+    return renderSegments(expanded);
+  });
 }
 
 function expandWithEnv(
   segments: Segment[],
-  ctx: ExpansionContext,
+  components: Record<string, ComponentDefinition>,
+  codeResult?: CodeBlockResult,
 ): Operation<{ output: string; env: Record<string, unknown> }> {
-  function* op() {
-    const env = { values: {} as Record<string, unknown> };
-    const output = yield* EvalEnvCtx.with(env, function* () {
-      const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
-      return renderSegments(expanded);
-    });
-    return { output, env: env.values };
-  }
-  return op() as unknown as Operation<{ output: string; env: Record<string, unknown> }>;
+  return scoped(function* () {
+    const testEnv: EvalEnv = { values: {} };
+    yield* useTestComponents(components, codeResult);
+    yield* useTestEnv(testEnv);
+    const expanded = yield* expandSegments(segments, {}, {}, new Set());
+    return { output: renderSegments(expanded), env: testEnv.values };
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -99,7 +115,7 @@ describe("expansion", () => {
   // C1: Basic expansion
   it("C1: basic expansion — component body in output", function* () {
     const comp = makeComponent("Greeting", "Hello world!");
-    const ctx = makeCtx({ Greeting: comp });
+    const ctx = { Greeting: comp };
     const segments = scanSegments("<Greeting />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("Hello world!");
@@ -108,7 +124,7 @@ describe("expansion", () => {
   // C2: Content slot
   it("C2: content slot — children at <Content /> position", function* () {
     const comp = makeComponent("Wrap", "Before <Content /> After");
-    const ctx = makeCtx({ Wrap: comp });
+    const ctx = { Wrap: comp };
     const segments = scanSegments("<Wrap>middle</Wrap>");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("Before middle After");
@@ -118,7 +134,7 @@ describe("expansion", () => {
   it("C3: nested expansion — A contains B", function* () {
     const compB = makeComponent("B", "inner");
     const compA = makeComponent("A", "outer <B /> end");
-    const ctx = makeCtx({ A: compA, B: compB });
+    const ctx = { A: compA, B: compB };
     const segments = scanSegments("<A />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("outer inner end");
@@ -129,7 +145,7 @@ describe("expansion", () => {
     const compC = makeComponent("C", "leaf");
     const compB = makeComponent("B", "mid(<C />)");
     const compA = makeComponent("A", "top(<B />)");
-    const ctx = makeCtx({ A: compA, B: compB, C: compC });
+    const ctx = { A: compA, B: compB, C: compC };
     const segments = scanSegments("<A />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("top(mid(leaf))");
@@ -138,7 +154,7 @@ describe("expansion", () => {
   // C5: Direct cycle
   it("C5: direct cycle — A contains A → ErrorSegment", function* () {
     const compA = makeComponent("A", "start <A /> end");
-    const ctx = makeCtx({ A: compA });
+    const ctx = { A: compA };
     const segments = scanSegments("<A />");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -149,7 +165,7 @@ describe("expansion", () => {
   it("C6: mutual cycle — A→B→A → ErrorSegment", function* () {
     const compA = makeComponent("A", "a(<B />)");
     const compB = makeComponent("B", "b(<A />)");
-    const ctx = makeCtx({ A: compA, B: compB });
+    const ctx = { A: compA, B: compB };
     const segments = scanSegments("<A />");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -161,7 +177,7 @@ describe("expansion", () => {
     const comp = makeComponent("Page", "Title: {meta.title}", {
       meta: { title: "My Page" },
     });
-    const ctx = makeCtx({ Page: comp });
+    const ctx = { Page: comp };
     const segments = scanSegments("<Page />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("Title: My Page");
@@ -172,7 +188,7 @@ describe("expansion", () => {
     const comp = makeComponent("Greeting", "Hello, {props.name}!", {
       inputs: { name: { type: "string", required: true } },
     });
-    const ctx = makeCtx({ Greeting: comp });
+    const ctx = { Greeting: comp };
     const segments = scanSegments('<Greeting name="world" />');
     const output = yield* expand(segments, ctx);
     expect(output).toBe("Hello, world!");
@@ -181,7 +197,7 @@ describe("expansion", () => {
   // C10: Missing interpolation key → empty string
   it("C10: missing interpolation key → empty string", function* () {
     const comp = makeComponent("Comp", "value: {meta.nonexistent}");
-    const ctx = makeCtx({ Comp: comp });
+    const ctx = { Comp: comp };
     const segments = scanSegments("<Comp />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("value: ");
@@ -192,7 +208,7 @@ describe("expansion", () => {
     const comp = makeComponent("Comp", "host: {meta.config.db.host}", {
       meta: { config: { db: { host: "localhost" } } },
     });
-    const ctx = makeCtx({ Comp: comp });
+    const ctx = { Comp: comp };
     const segments = scanSegments("<Comp />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("host: localhost");
@@ -201,7 +217,7 @@ describe("expansion", () => {
   // C12: No Content slot — children silently discarded
   it("C12: no Content slot — children silently discarded", function* () {
     const comp = makeComponent("NoSlot", "fixed content");
-    const ctx = makeCtx({ NoSlot: comp });
+    const ctx = { NoSlot: comp };
     const segments = scanSegments("<NoSlot>ignored</NoSlot>");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("fixed content");
@@ -210,7 +226,7 @@ describe("expansion", () => {
   // C13: Multiple Content slots
   it("C13: multiple Content slots — each replaced with same children", function* () {
     const comp = makeComponent("Multi", "first: <Content /> second: <Content />");
-    const ctx = makeCtx({ Multi: comp });
+    const ctx = { Multi: comp };
     const segments = scanSegments("<Multi>stuff</Multi>");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("first: stuff second: stuff");
@@ -221,7 +237,7 @@ describe("expansion", () => {
     const comp = makeComponent("Greeting", "{props.greeting}, world!", {
       inputs: { greeting: { type: "string", default: "Hello" } },
     });
-    const ctx = makeCtx({ Greeting: comp });
+    const ctx = { Greeting: comp };
     const segments = scanSegments("<Greeting />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("Hello, world!");
@@ -230,7 +246,7 @@ describe("expansion", () => {
   // C20: No inputs, no props — valid
   it("C20: no inputs, no props — valid", function* () {
     const comp = makeComponent("Badge", "badge");
-    const ctx = makeCtx({ Badge: comp });
+    const ctx = { Badge: comp };
     const segments = scanSegments("<Badge />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("badge");
@@ -241,7 +257,7 @@ describe("expansion", () => {
     const comp = makeComponent("Comp", "val:{props.opt}", {
       inputs: { opt: { type: "string", required: false } },
     });
-    const ctx = makeCtx({ Comp: comp });
+    const ctx = { Comp: comp };
     const segments = scanSegments("<Comp />");
     const output = yield* expand(segments, ctx);
     expect(output).toBe("val:");
@@ -249,32 +265,47 @@ describe("expansion", () => {
 
   // Code block expansion
   it("code block expansion via modifier chain", function* () {
-    const ctx = makeCtx({}, { output: "hello\n", exitCode: 0, stderr: "" });
     const segments = scanSegments("```bash exec\necho hello\n```\n");
-    const output = yield* expand(segments, ctx);
+    const output = yield* expand(
+      segments,
+      {},
+      {
+        codeResult: { output: "hello\n", exitCode: 0, stderr: "" },
+      },
+    );
     expect(output).toBe("hello\n");
   });
 
   // Code block with non-zero exit
   it("code block with non-zero exit → error", function* () {
-    const ctx = makeCtx({}, { output: "", exitCode: 1, stderr: "not found" });
     const segments = scanSegments("```bash exec\nfoo\n```\n");
-    const output = yield* expand(segments, ctx);
+    const output = yield* expand(
+      segments,
+      {},
+      {
+        codeResult: { output: "", exitCode: 1, stderr: "not found" },
+      },
+    );
     expect(output).toContain("ERROR");
     expect(output).toContain("not found");
   });
 
   // Silent code block → no output
   it("silent code block produces no output", function* () {
-    const ctx = makeCtx({}, { output: "", exitCode: 0, stderr: "" });
     const segments = scanSegments("```bash silent exec\necho hello\n```\n");
-    const output = yield* expand(segments, ctx);
+    const output = yield* expand(
+      segments,
+      {},
+      {
+        codeResult: { output: "", exitCode: 0, stderr: "" },
+      },
+    );
     expect(output).toBe("");
   });
 
   it("captures component output with as", function* () {
     const comp = makeComponent("Greeting", "Hello world!");
-    const ctx = makeCtx({ Greeting: comp });
+    const ctx = { Greeting: comp };
     const segments = scanSegments('<Greeting as="saved" />');
     const { output, env } = yield* expandWithEnv(segments, ctx);
     expect(output).toBe("");
@@ -282,7 +313,7 @@ describe("expansion", () => {
   });
 
   it("Capture stores children output into env and stays silent", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="x">hello\n</Capture>');
     const { output, env } = yield* expandWithEnv(segments, ctx);
     expect(output).toBe("");
@@ -290,7 +321,7 @@ describe("expansion", () => {
   });
 
   it("Capture rejects expression as prop", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("<Capture as={name}>text</Capture>");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -298,7 +329,7 @@ describe("expansion", () => {
   });
 
   it("Capture rejects self-closing usage", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="x" />');
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -306,7 +337,7 @@ describe("expansion", () => {
   });
 
   it("Capture rejects extra props", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="x" slot="y">text</Capture>');
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -314,7 +345,7 @@ describe("expansion", () => {
   });
 
   it("Capture with select extracts code block by CSS selector", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments(
       '<Capture as="data" select="code[lang=json]">prose text\n\n```json\n{"key":"val"}\n```\n\nmore prose\n</Capture>',
     );
@@ -324,7 +355,7 @@ describe("expansion", () => {
   });
 
   it("Capture with select falls back to full content when no match", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments(
       '<Capture as="data" select="code[lang=json]">no code here\n</Capture>',
     );
@@ -334,7 +365,7 @@ describe("expansion", () => {
   });
 
   it("Capture with select extracts paragraph text", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="data" select="paragraph">Hello world\n</Capture>');
     const { output, env } = yield* expandWithEnv(segments, ctx);
     expect(output).toBe("");
@@ -342,7 +373,7 @@ describe("expansion", () => {
   });
 
   it("Capture accepts select alongside as without error", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="x" select="paragraph">text\n</Capture>');
     const output = yield* expand(segments, ctx);
     expect(output).not.toContain("ERROR");
@@ -350,7 +381,7 @@ describe("expansion", () => {
 
   it("component as rejects expression prop", function* () {
     const comp = makeComponent("Greeting", "Hello world!");
-    const ctx = makeCtx({ Greeting: comp });
+    const ctx = { Greeting: comp };
     const segments = scanSegments("<Greeting as={name} />");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("ERROR");
@@ -362,24 +393,38 @@ describe("expansion", () => {
 // Component-declared output — <Output> (spec §6.9)
 // ---------------------------------------------------------------------------
 
-/** ExpansionContext that records executed code-block contents. */
-function recordingCtx(
-  components: Record<string, ComponentDefinition>,
-  codeResult?: CodeBlockResult,
-): { ctx: ExpansionContext; execCalls: string[] } {
+/**
+ * Install a recording applyModifiers provider and return the captured
+ * code-block contents. Installed after useTestComponents in the same scope,
+ * so it wins (later-installed min middleware runs first).
+ */
+function* useRecordingModifiers(codeResult?: CodeBlockResult): Operation<string[]> {
   const execCalls: string[] = [];
-  const ctx: ExpansionContext = {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], context: CodeBlockContext) {
-      execCalls.push(context.content);
-      return codeResult ?? { output: "ran\n", exitCode: 0, stderr: "" };
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *applyModifiers([_modifiers, block], _next) {
+        execCalls.push(block.content);
+        return codeResult ?? { output: "ran\n", exitCode: 0, stderr: "" };
+      },
     },
-  };
-  return { ctx, execCalls };
+    { at: "min" },
+  );
+  return execCalls;
+}
+
+function recordingExpand(
+  segments: Segment[],
+  components: Record<string, ComponentDefinition>,
+  codeResult?: CodeBlockResult,
+): Operation<{ output: string; execCalls: string[] }> {
+  return scoped(function* () {
+    yield* useTestComponents(components);
+    const execCalls = yield* useRecordingModifiers(codeResult);
+    yield* useTestEnv({ values: {} });
+    const expanded = yield* expandSegments(segments, {}, {}, new Set());
+    return { output: renderSegments(expanded), execCalls };
+  });
 }
 
 describe("component-declared output", () => {
@@ -388,7 +433,7 @@ describe("component-declared output", () => {
       "Warn",
       "Docs heading.\n\n<Output>\nSHOWN\n</Output>\n\nMore docs.\n",
     );
-    const ctx = makeCtx({ Warn: comp });
+    const ctx = { Warn: comp };
     const output = yield* expand(scanSegments("<Warn />"), ctx);
     expect(output).toContain("SHOWN");
     expect(output).not.toContain("Docs heading");
@@ -397,7 +442,7 @@ describe("component-declared output", () => {
 
   it("without <Output> renders the complete body", function* () {
     const comp = makeComponent("Doc", "Alpha then Beta.");
-    const ctx = makeCtx({ Doc: comp });
+    const ctx = { Doc: comp };
     const output = yield* expand(scanSegments("<Doc />"), ctx);
     expect(output).toContain("Alpha then Beta.");
   });
@@ -407,7 +452,7 @@ describe("component-declared output", () => {
       "Multi",
       "<Output>ONE</Output>\n\nmiddle docs\n\n<Output>TWO</Output>\n",
     );
-    const ctx = makeCtx({ Multi: comp });
+    const ctx = { Multi: comp };
     const output = yield* expand(scanSegments("<Multi />"), ctx);
     expect(output).not.toContain("middle docs");
     expect(output.indexOf("ONE")).toBeGreaterThanOrEqual(0);
@@ -419,7 +464,7 @@ describe("component-declared output", () => {
       "Adm",
       "docs\n\n<Output>\n> [!WARNING]\n> Careful now.\n</Output>\n",
     );
-    const ctx = makeCtx({ Adm: comp });
+    const ctx = { Adm: comp };
     const output = yield* expand(scanSegments("<Adm />"), ctx);
     expect(output).toContain("> [!WARNING]");
     expect(output).toContain("> Careful now.");
@@ -429,7 +474,7 @@ describe("component-declared output", () => {
   it("treats <Output /> and <Output></Output> as equivalent empty output", function* () {
     const selfClosing = makeComponent("A", "before\n\n<Output />\n\nafter");
     const paired = makeComponent("B", "before\n\n<Output></Output>\n\nafter");
-    const ctx = makeCtx({ A: selfClosing, B: paired });
+    const ctx = { A: selfClosing, B: paired };
     const a = yield* expand(scanSegments("<A />"), ctx);
     const b = yield* expand(scanSegments("<B />"), ctx);
     expect(a.trim()).toBe("");
@@ -438,7 +483,7 @@ describe("component-declared output", () => {
 
   it("rejects props on <Output>", function* () {
     const comp = makeComponent("Bad", '<Output foo="bar">x</Output>');
-    const ctx = makeCtx({ Bad: comp });
+    const ctx = { Bad: comp };
     const output = yield* expand(scanSegments("<Bad />"), ctx);
     expect(output).toContain("ERROR");
     expect(output).toContain("accepts no props");
@@ -446,7 +491,7 @@ describe("component-declared output", () => {
 
   it("rejects expression props on <Output>", function* () {
     const comp = makeComponent("Bad", "<Output when={x}>y</Output>");
-    const ctx = makeCtx({ Bad: comp });
+    const ctx = { Bad: comp };
     const output = yield* expand(scanSegments("<Bad />"), ctx);
     expect(output).toContain("ERROR");
     expect(output).toContain("accepts no props");
@@ -454,7 +499,7 @@ describe("component-declared output", () => {
 
   it("projects caller content through <Content /> inside <Output>", function* () {
     const comp = makeComponent("Wrap", "docs\n\n<Output>\n<Content />\n</Output>\n");
-    const ctx = makeCtx({ Wrap: comp });
+    const ctx = { Wrap: comp };
     const output = yield* expand(scanSegments("<Wrap>PROJECTED</Wrap>"), ctx);
     expect(output).toContain("PROJECTED");
     expect(output).not.toContain("docs");
@@ -465,15 +510,14 @@ describe("component-declared output", () => {
       "Dep",
       '<Capture as="msg">HELLO</Capture>\n\n<Output>msg={msg}</Output>',
     );
-    const ctx = makeCtx({ Dep: comp });
+    const ctx = { Dep: comp };
     const output = yield* expand(scanSegments("<Dep />"), ctx);
     expect(output).toContain("msg=HELLO");
   });
 
   it("executes exec blocks outside <Output> but suppresses their output", function* () {
     const comp = makeComponent("Ex", "```bash exec\nDOCRUN\n```\n\n<Output>ok</Output>\n");
-    const { ctx, execCalls } = recordingCtx({ Ex: comp });
-    const output = yield* expand(scanSegments("<Ex />"), ctx);
+    const { output, execCalls } = yield* recordingExpand(scanSegments("<Ex />"), { Ex: comp });
     expect(execCalls.some((c) => c.includes("DOCRUN"))).toBe(true);
     expect(output).toContain("ok");
     expect(output).not.toContain("ran");
@@ -481,15 +525,14 @@ describe("component-declared output", () => {
 
   it("executes documentation after an <Output> region", function* () {
     const comp = makeComponent("Post", "<Output>ok</Output>\n\n```bash exec\nAFTER\n```\n");
-    const { ctx, execCalls } = recordingCtx({ Post: comp });
-    const output = yield* expand(scanSegments("<Post />"), ctx);
+    const { output, execCalls } = yield* recordingExpand(scanSegments("<Post />"), { Post: comp });
     expect(execCalls.some((c) => c.includes("AFTER"))).toBe(true);
     expect(output).toContain("ok");
   });
 
   it("keeps errors inside an <Output> region as comments", function* () {
     const comp = makeComponent("Err", "<Output>\n<Bogus />\n</Output>");
-    const ctx = makeCtx({ Err: comp });
+    const ctx = { Err: comp };
     const output = yield* expand(scanSegments("<Err />"), ctx);
     expect(output).toContain("<!-- ERROR");
     expect(output).toContain("Failed to import component Bogus");
@@ -497,7 +540,7 @@ describe("component-declared output", () => {
 
   it("keeps errors as comments when no <Output> is declared", function* () {
     const comp = makeComponent("NoOut", "<Bogus />");
-    const ctx = makeCtx({ NoOut: comp });
+    const ctx = { NoOut: comp };
     const output = yield* expand(scanSegments("<NoOut />"), ctx);
     expect(output).toContain("<!-- ERROR");
   });
@@ -506,10 +549,15 @@ describe("component-declared output", () => {
 
   it("throws on a failing exec block in documentation", function* () {
     const comp = makeComponent("Fail", "```bash exec\nboom\n```\n\n<Output>ok</Output>\n");
-    const ctx = makeCtx({ Fail: comp }, { output: "", exitCode: 1, stderr: "nope" });
     let threw = false;
     try {
-      yield* expand(scanSegments("<Fail />"), ctx);
+      yield* expand(
+        scanSegments("<Fail />"),
+        { Fail: comp },
+        {
+          codeResult: { output: "", exitCode: 1, stderr: "nope" },
+        },
+      );
     } catch {
       threw = true;
     }
@@ -518,8 +566,13 @@ describe("component-declared output", () => {
 
   it("continues when a modifier handles the failure in documentation", function* () {
     const comp = makeComponent("Handled", "```bash exec\nrecover\n```\n\n<Output>ok</Output>\n");
-    const ctx = makeCtx({ Handled: comp }, { output: "recovered\n", exitCode: 0, stderr: "" });
-    const output = yield* expand(scanSegments("<Handled />"), ctx);
+    const output = yield* expand(
+      scanSegments("<Handled />"),
+      { Handled: comp },
+      {
+        codeResult: { output: "recovered\n", exitCode: 0, stderr: "" },
+      },
+    );
     expect(output).toContain("ok");
   });
 
@@ -528,7 +581,7 @@ describe("component-declared output", () => {
       "CapFail",
       '<Capture as="x">\n<Bogus />\n</Capture>\n\n<Output>ok</Output>',
     );
-    const ctx = makeCtx({ CapFail: comp });
+    const ctx = { CapFail: comp };
     let threw = false;
     try {
       yield* expand(scanSegments("<CapFail />"), ctx);
@@ -543,7 +596,7 @@ describe("component-declared output", () => {
   it("throws when a child's Output error is consumed from parent documentation", function* () {
     const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
     const parent = makeComponent("P", "<Child />\n\n<Output>tail</Output>");
-    const ctx = makeCtx({ Child: child, P: parent });
+    const ctx = { Child: child, P: parent };
     let threw = false;
     try {
       yield* expand(scanSegments("<P />"), ctx);
@@ -556,7 +609,7 @@ describe("component-declared output", () => {
   it("renders a child's Output error as a comment when consumed inside parent Output", function* () {
     const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
     const parent = makeComponent("P", "<Output>\n<Child />\n</Output>");
-    const ctx = makeCtx({ Child: child, P: parent });
+    const ctx = { Child: child, P: parent };
     const output = yield* expand(scanSegments("<P />"), ctx);
     expect(output).toContain("<!-- ERROR");
     expect(output).toContain("Failed to import component Bogus");
@@ -565,7 +618,7 @@ describe("component-declared output", () => {
   it("throws before storing an as= binding that captured a child's Output error", function* () {
     const child = makeComponent("Child", "<Output>\n<Bogus />\n</Output>");
     const parent = makeComponent("P", '<Child as="captured" />\n\n<Output>tail</Output>');
-    const ctx = makeCtx({ Child: child, P: parent });
+    const ctx = { Child: child, P: parent };
     let threw = false;
     try {
       yield* expand(scanSegments("<P />"), ctx);
@@ -582,8 +635,9 @@ describe("component-declared output", () => {
       "Struct",
       "```bash exec\nSIDE\n```\n\n<Wrapper>\n<Output>x</Output>\n</Wrapper>\n",
     );
-    const { ctx, execCalls } = recordingCtx({ Struct: comp });
-    const output = yield* expand(scanSegments("<Struct />"), ctx);
+    const { output, execCalls } = yield* recordingExpand(scanSegments("<Struct />"), {
+      Struct: comp,
+    });
     expect(output).toContain("must be a direct top-level");
     expect(execCalls).toHaveLength(0);
   });
@@ -593,7 +647,7 @@ describe("component-declared output", () => {
       "Many",
       "<A>\n<Output>one</Output>\n</A>\n\n<B>\n<Output>two</Output>\n</B>\n",
     );
-    const ctx = makeCtx({ Many: comp });
+    const ctx = { Many: comp };
     const output = yield* expand(scanSegments("<Many />"), ctx);
     const errorComments = output.match(/<!-- ERROR/g) ?? [];
     expect(errorComments).toHaveLength(1);
@@ -603,14 +657,14 @@ describe("component-declared output", () => {
 
   it("diagnoses a nested <Output> inside <Show when={false}>", function* () {
     const comp = makeComponent("Hidden", "<Show when={false}>\n<Output>hidden</Output>\n</Show>");
-    const ctx = makeCtx({ Hidden: comp });
+    const ctx = { Hidden: comp };
     const output = yield* expand(scanSegments("<Hidden />"), ctx);
     expect(output).toContain("must be a direct top-level");
   });
 
   it("diagnoses a nested <Output> passed to a component that discards content", function* () {
     const comp = makeComponent("Discard", "<NoContent>\n<Output>x</Output>\n</NoContent>");
-    const ctx = makeCtx({ Discard: comp });
+    const ctx = { Discard: comp };
     const output = yield* expand(scanSegments("<Discard />"), ctx);
     expect(output).toContain("must be a direct top-level");
   });
@@ -618,7 +672,7 @@ describe("component-declared output", () => {
   it("throws a structural diagnostic when an invalid child is used from documentation", function* () {
     const child = makeComponent("BadChild", "<Wrapper>\n<Output>x</Output>\n</Wrapper>");
     const parent = makeComponent("P", "<BadChild />\n\n<Output>tail</Output>");
-    const ctx = makeCtx({ BadChild: child, P: parent });
+    const ctx = { BadChild: child, P: parent };
     let threw = false;
     try {
       yield* expand(scanSegments("<P />"), ctx);
diff --git a/core/tests/expression-props.test.ts b/core/tests/expression-props.test.ts
index cfe7d61..d47149e 100644
--- a/core/tests/expression-props.test.ts
+++ b/core/tests/expression-props.test.ts
@@ -8,20 +8,9 @@
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
 import { parseExpressionValue, scanSegments } from "../src/scanner.ts";
-import { expandSegments, createBlockCounter } from "../src/expand.ts";
-import type { ExpansionContext } from "../src/expand.ts";
-import { renderSegments } from "../src/render.ts";
 import { runDocument } from "../src/run-document.ts";
 import { collect } from "../src/collect.ts";
 import { InMemoryStream } from "@executablemd/durable-streams";
-import type {
-  Segment,
-  ComponentDefinition,
-  Json,
-  CodeBlockResult,
-  Modifier,
-  CodeBlockContext,
-} from "../src/types.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
@@ -30,46 +19,6 @@ import * as os from "node:os";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeComponent(
-  name: string,
-  body: string,
-  opts: {
-    meta?: Record<string, unknown>;
-    inputs?: Record<string, any>;
-  } = {},
-): ComponentDefinition {
-  return {
-    kind: "markdown",
-    name,
-    path: `components/${name}.md`,
-    meta: opts.meta ?? {},
-    inputs: opts.inputs ?? {},
-    bodySegments: scanSegments(body),
-  };
-}
-
-function makeCtx(
-  components: Record<string, ComponentDefinition>,
-  codeResult?: CodeBlockResult,
-): ExpansionContext {
-  return {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], _context: CodeBlockContext) {
-      return (
-        codeResult ?? {
-          output: "mock output\n",
-          exitCode: 0,
-          stderr: "",
-        }
-      );
-    },
-  };
-}
-
 function makeTempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), "expr-props-test-"));
 }
diff --git a/core/tests/heal.test.ts b/core/tests/heal.test.ts
index 1d9d60e..ef8ba87 100644
--- a/core/tests/heal.test.ts
+++ b/core/tests/heal.test.ts
@@ -1,19 +1,13 @@
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
 import { healSegment } from "../src/heal.ts";
 import { scanSegments } from "../src/scanner.ts";
 import { expandSegments } from "../src/expand.ts";
-import type { ExpansionContext } from "../src/expand.ts";
+import { Component } from "../src/component-api.ts";
 import { renderSegments } from "../src/render.ts";
 import type { Operation } from "effection";
-import type {
-  Segment,
-  ComponentDefinition,
-  TextSegment,
-  Json,
-  Modifier,
-  CodeBlockContext,
-} from "../src/types.ts";
+import type { Segment, ComponentDefinition, TextSegment, Json } from "../src/types.ts";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -37,19 +31,6 @@ function makeComponent(
   };
 }
 
-function makeCtx(components: Record<string, ComponentDefinition>): ExpansionContext {
-  return {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], _context: CodeBlockContext) {
-      return { output: "", exitCode: 0, stderr: "" };
-    },
-  };
-}
-
 /** Extract text segments from scan results. */
 function getTextSegments(input: string): string[] {
   return scanSegments(input)
@@ -57,18 +38,34 @@ function getTextSegments(input: string): string[] {
     .map((s) => s.content);
 }
 
-/** Expand segments and render to string — wraps generator in Operation. */
+/** Expand segments with test providers and render to string. */
 function expand(
   segments: Segment[],
-  ctx: ExpansionContext,
+  components: Record<string, ComponentDefinition>,
   meta: Record<string, unknown> = {},
   props: Record<string, Json> = {},
 ): Operation<string> {
-  function* op() {
-    const expanded = yield* expandSegments(segments, meta, props, new Set(), ctx);
+  return scoped(function* () {
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *importComponent([name], _next) {
+          const comp = components[name];
+          if (!comp) {
+            throw new Error(`Component not found: ${name}`);
+          }
+          return comp;
+        },
+        // deno-lint-ignore require-yield
+        *applyModifiers(_args, _next) {
+          return { output: "", exitCode: 0, stderr: "" };
+        },
+      },
+      { at: "min" },
+    );
+    const expanded = yield* expandSegments(segments, meta, props, new Set());
     return renderSegments(expanded);
-  }
-  return op() as unknown as Operation<string>;
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -254,7 +251,7 @@ describe("healSegment", () => {
     const comp = makeComponent("Comp", "{meta.title} world", {
       meta: { title: "**bold**" },
     });
-    const ctx = makeCtx({ Comp: comp });
+    const ctx = { Comp: comp };
     const segments = scanSegments("<Comp />");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("**bold**");
@@ -266,7 +263,7 @@ describe("healSegment", () => {
 
   it("F25: children with unclosed bold — healed before substitution", function* () {
     const comp = makeComponent("Wrap", "before <Content /> after");
-    const ctx = makeCtx({ Wrap: comp });
+    const ctx = { Wrap: comp };
     const segments = scanSegments("<Wrap>**hello</Wrap>");
     const output = yield* expand(segments, ctx);
     expect(output).toContain("**hello**");
@@ -276,7 +273,7 @@ describe("healSegment", () => {
 
   it("F26: component body segment healed independently", function* () {
     const comp = makeComponent("Wrap", "*intro\n<Content />");
-    const ctx = makeCtx({ Wrap: comp });
+    const ctx = { Wrap: comp };
     const segments = scanSegments("<Wrap>child</Wrap>");
     const output = yield* expand(segments, ctx);
     expect(output.includes("*intro*") || output.includes("*intro")).toBeTruthy();
diff --git a/core/tests/named-slots.test.ts b/core/tests/named-slots.test.ts
index 633c306..7bc3969 100644
--- a/core/tests/named-slots.test.ts
+++ b/core/tests/named-slots.test.ts
@@ -8,9 +8,11 @@
 
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
+import type { Operation } from "effection";
 import { partitionBySlot, stripSlotProp } from "../src/expand.ts";
-import { expandSegments, createBlockCounter } from "../src/expand.ts";
-import type { ExpansionContext } from "../src/expand.ts";
+import { expandSegments } from "../src/expand.ts";
+import { Component } from "../src/component-api.ts";
 import { scanSegments } from "../src/scanner.ts";
 import { renderSegments } from "../src/render.ts";
 import { parseFrontmatter } from "../src/frontmatter.ts";
@@ -18,14 +20,7 @@ import { validateProps } from "../src/validate.ts";
 import { runDocument } from "../src/run-document.ts";
 import { collect } from "../src/collect.ts";
 import { InMemoryStream } from "@executablemd/durable-streams";
-import type {
-  Segment,
-  ComponentDefinition,
-  Json,
-  CodeBlockResult,
-  Modifier,
-  CodeBlockContext,
-} from "../src/types.ts";
+import type { Segment, ComponentDefinition, Json, CodeBlockResult } from "../src/types.ts";
 
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -53,26 +48,44 @@ function makeComponent(
   };
 }
 
-function makeCtx(
+/** Install test component + modifier providers on the current scope. */
+function* useTestComponents(
   components: Record<string, ComponentDefinition>,
   codeResult?: CodeBlockResult,
-): ExpansionContext {
-  return {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], _context: CodeBlockContext) {
-      return (
-        codeResult ?? {
-          output: "mock output\n",
-          exitCode: 0,
-          stderr: "",
+): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *importComponent([name], _next) {
+        const comp = components[name];
+        if (!comp) {
+          throw new Error(`Component not found: ${name}`);
         }
-      );
+        return comp;
+      },
+      // deno-lint-ignore require-yield
+      *applyModifiers(_args, _next) {
+        return (
+          codeResult ?? {
+            output: "mock output\n",
+            exitCode: 0,
+            stderr: "",
+          }
+        );
+      },
     },
-  };
+    { at: "min" },
+  );
+}
+
+function expandAll(
+  segments: Segment[],
+  components: Record<string, ComponentDefinition>,
+): Operation<Segment[]> {
+  return scoped(function* () {
+    yield* useTestComponents(components);
+    return yield* expandSegments(segments, {}, {}, new Set());
+  });
 }
 
 /** Create a component segment for use in partition tests. */
@@ -262,9 +275,9 @@ describe("Tier NS-A — Slot partitioning", () => {
 describe("Tier NS-B — Content substitution", () => {
   it("NS-B1: backward compat — no slots anywhere", function* () {
     const layout = makeComponent("Layout", "before\n<Content />\nafter");
-    const ctx = makeCtx({ Layout: layout });
+    const ctx = { Layout: layout };
     const segments = scanSegments("<Layout>\nchild text\n</Layout>");
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("before");
     expect(output).toContain("child text");
@@ -273,9 +286,9 @@ describe("Tier NS-B — Content substitution", () => {
 
   it("NS-B2: named slot projection", function* () {
     const layout = makeComponent("Layout", '<Content slot="header" />\n---\n<Content />');
-    const ctx = makeCtx({ Layout: layout, Header: makeComponent("Header", "HEADER") });
+    const ctx = { Layout: layout, Header: makeComponent("Header", "HEADER") };
     const segments = scanSegments('<Layout>\n<Header slot="header" />\ndefault text\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("HEADER");
     expect(output).toContain("default text");
@@ -284,9 +297,9 @@ describe("Tier NS-B — Content substitution", () => {
   it("NS-B3: default slot projection", function* () {
     const layout = makeComponent("Layout", '<Content slot="nav" />\n---\n<Content />');
     const nav = makeComponent("Nav", "NAV");
-    const ctx = makeCtx({ Layout: layout, Nav: nav });
+    const ctx = { Layout: layout, Nav: nav };
     const segments = scanSegments('<Layout>\n<Nav slot="nav" />\ndefault text\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     // Default slot should only have "default text", not Nav
     expect(output).toContain("NAV");
@@ -296,9 +309,9 @@ describe("Tier NS-B — Content substitution", () => {
   it("NS-B4: named + default together", function* () {
     const layout = makeComponent("Layout", 'NAV: <Content slot="nav" />\nBODY: <Content />');
     const nav = makeComponent("Nav", "I-AM-NAV");
-    const ctx = makeCtx({ Layout: layout, Nav: nav });
+    const ctx = { Layout: layout, Nav: nav };
     const segments = scanSegments('<Layout>\n<Nav slot="nav" />\nbody content\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("I-AM-NAV");
     expect(output).toContain("body content");
@@ -306,9 +319,9 @@ describe("Tier NS-B — Content substitution", () => {
 
   it("NS-B5: missing named slot — empty expansion", function* () {
     const layout = makeComponent("Layout", '<Content slot="footer" />\n<Content />');
-    const ctx = makeCtx({ Layout: layout });
+    const ctx = { Layout: layout };
     const segments = scanSegments("<Layout>\nbody only\n</Layout>");
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("body only");
     expect(output).not.toContain("footer");
@@ -318,9 +331,9 @@ describe("Tier NS-B — Content substitution", () => {
     // Layout body has no <Content slot="extra" />, so the extra-slotted child is discarded
     const layout = makeComponent("Layout", "<Content />");
     const extra = makeComponent("Extra", "EXTRA");
-    const ctx = makeCtx({ Layout: layout, Extra: extra });
+    const ctx = { Layout: layout, Extra: extra };
     const segments = scanSegments('<Layout>\n<Extra slot="extra" />\nbody text\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("body text");
     expect(output).not.toContain("EXTRA");
@@ -332,9 +345,9 @@ describe("Tier NS-B — Content substitution", () => {
       'FIRST: <Content slot="header" />\nSECOND: <Content slot="header" />',
     );
     const header = makeComponent("Header", "H");
-    const ctx = makeCtx({ Layout: layout, Header: header });
+    const ctx = { Layout: layout, Header: header };
     const segments = scanSegments('<Layout>\n<Header slot="header" />\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     // Both projections should have the header content
     const matches = output.match(/H/g);
@@ -347,9 +360,9 @@ describe("Tier NS-B — Content substitution", () => {
     const widget = makeComponent("Widget", "WIDGET:{props.title}", {
       inputs: { title: { type: "string", required: true } },
     });
-    const ctx = makeCtx({ Layout: layout, Widget: widget });
+    const ctx = { Layout: layout, Widget: widget };
     const segments = scanSegments('<Layout>\n<Widget slot="main" title="Hello" />\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     // Should expand Widget with title prop, without PropValidationError for "slot"
     expect(output).toContain("WIDGET:");
@@ -366,9 +379,9 @@ describe("Tier NS-B — Content substitution", () => {
       },
     );
     const body = makeComponent("Body", "BODY-CONTENT");
-    const ctx = makeCtx({ Layout: layout, Body: body });
+    const ctx = { Layout: layout, Body: body };
     const segments = scanSegments('<Layout>\n<Body slot="body" />\ndefault content\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("Title: MyLayout");
     expect(output).toContain("BODY-CONTENT");
@@ -379,11 +392,11 @@ describe("Tier NS-B — Content substitution", () => {
     const layout = makeComponent("Layout", '<Content slot="items" />');
     const itemA = makeComponent("ItemA", "A");
     const itemB = makeComponent("ItemB", "B");
-    const ctx = makeCtx({ Layout: layout, ItemA: itemA, ItemB: itemB });
+    const ctx = { Layout: layout, ItemA: itemA, ItemB: itemB };
     const segments = scanSegments(
       '<Layout>\n<ItemA slot="items" />\n<ItemB slot="items" />\n</Layout>',
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("A");
     expect(output).toContain("B");
@@ -404,11 +417,11 @@ describe("Tier NS-C — Expansion integration", () => {
     );
     const header = makeComponent("Header", "HEADER-TEXT");
     const body = makeComponent("Body", "BODY-TEXT");
-    const ctx = makeCtx({ Report: report, Header: header, Body: body });
+    const ctx = { Report: report, Header: header, Body: body };
     const segments = scanSegments(
       '<Report>\n<Header slot="header" />\n<Body slot="body" />\ndefault text\n</Report>',
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("HEADER-TEXT");
     expect(output).toContain("BODY-TEXT");
@@ -422,9 +435,9 @@ describe("Tier NS-C — Expansion integration", () => {
     const layout = makeComponent("Layout", '<Content slot="main" />');
     const inner = makeComponent("Inner", "INNER-EXPANDED");
     const wrapper = makeComponent("Wrapper", "WRAP:<Content />");
-    const ctx = makeCtx({ Layout: layout, Wrapper: wrapper, Inner: inner });
+    const ctx = { Layout: layout, Wrapper: wrapper, Inner: inner };
     const segments = scanSegments('<Layout>\n<Wrapper slot="main"><Inner /></Wrapper>\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("WRAP:");
     expect(output).toContain("INNER-EXPANDED");
@@ -443,13 +456,13 @@ describe("Tier NS-C — Expansion integration", () => {
     const leftComp = makeComponent("Left", "L");
     const rightComp = makeComponent("Right", "R");
     const headComp = makeComponent("Head", "H");
-    const ctx = makeCtx({
+    const ctx = {
       Outer: outer,
       Inner: inner,
       Left: leftComp,
       Right: rightComp,
       Head: headComp,
-    });
+    };
     const segments = scanSegments(
       [
         "<Outer>",
@@ -461,7 +474,7 @@ describe("Tier NS-C — Expansion integration", () => {
         "</Outer>",
       ].join("\n"),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("OUTER-HEAD:");
     expect(output).toContain("H");
@@ -477,7 +490,7 @@ describe("Tier NS-C — Expansion integration", () => {
     const provider = makeComponent("Provider", "<Content />");
     const report = makeComponent("Report", 'HEAD:<Content slot="header" />\nBODY:<Content />');
     const header = makeComponent("Header", "H");
-    const ctx = makeCtx({ Provider: provider, Report: report, Header: header });
+    const ctx = { Provider: provider, Report: report, Header: header };
     const segments = scanSegments(
       [
         "<Provider>",
@@ -488,7 +501,7 @@ describe("Tier NS-C — Expansion integration", () => {
         "</Provider>",
       ].join("\n"),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("HEAD:");
     expect(output).toContain("H");
@@ -501,9 +514,9 @@ describe("Tier NS-C — Expansion integration", () => {
     const comp = makeComponent("Comp", "title={props.title}", {
       inputs: { title: { type: "string", required: true } },
     });
-    const ctx = makeCtx({ Layout: layout, Comp: comp });
+    const ctx = { Layout: layout, Comp: comp };
     const segments = scanSegments('<Layout>\n<Comp slot="main" title="Hello" />\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("title=Hello");
     expect(output).not.toContain("Unknown prop");
@@ -514,9 +527,9 @@ describe("Tier NS-C — Expansion integration", () => {
     // All children carry slot props — default <Content /> expands to nothing
     const layout = makeComponent("Layout", 'HEAD:<Content slot="header" />\nDEFAULT:<Content />');
     const header = makeComponent("Header", "H");
-    const ctx = makeCtx({ Layout: layout, Header: header });
+    const ctx = { Layout: layout, Header: header };
     const segments = scanSegments('<Layout>\n<Header slot="header" />\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("HEAD:");
     expect(output).toContain("H");
@@ -527,7 +540,7 @@ describe("Tier NS-C — Expansion integration", () => {
   it("NS-C7: Fragment passthrough", function* () {
     const layout = makeComponent("Layout", 'SLOT:<Content slot="header" />\nDEFAULT:<Content />');
     const fragment = makeComponent("Fragment", "<Content />");
-    const ctx = makeCtx({ Layout: layout, Fragment: fragment });
+    const ctx = { Layout: layout, Fragment: fragment };
     const segments = scanSegments(
       [
         "<Layout>",
@@ -538,7 +551,7 @@ describe("Tier NS-C — Expansion integration", () => {
         "</Layout>",
       ].join("\n"),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("raw text in header slot");
     expect(output).toContain("default text");
@@ -548,13 +561,13 @@ describe("Tier NS-C — Expansion integration", () => {
     const layout = makeComponent("Layout", '<Content slot="sidebar" />\n<Content />');
     const wrapper = makeComponent("Wrapper", "WRAP:<Content />");
     const nav = makeComponent("Nav", "NAV");
-    const ctx = makeCtx({ Layout: layout, Wrapper: wrapper, Nav: nav });
+    const ctx = { Layout: layout, Wrapper: wrapper, Nav: nav };
     const segments = scanSegments(
       ["<Layout>", '<Wrapper slot="sidebar"><Nav /></Wrapper>', "main content", "</Layout>"].join(
         "\n",
       ),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("WRAP:");
     expect(output).toContain("NAV");
@@ -564,7 +577,7 @@ describe("Tier NS-C — Expansion integration", () => {
   it("NS-C9: exec block in default slot", function* () {
     const layout = makeComponent("Layout", '<Content slot="header" />\n<Content />');
     const header = makeComponent("Header", "H");
-    const ctx = makeCtx({ Layout: layout, Header: header });
+    const ctx = { Layout: layout, Header: header };
     const segments = scanSegments(
       [
         "<Layout>",
@@ -577,7 +590,7 @@ describe("Tier NS-C — Expansion integration", () => {
         "</Layout>",
       ].join("\n"),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("H");
     expect(output).toContain("mock output");
@@ -586,9 +599,9 @@ describe("Tier NS-C — Expansion integration", () => {
   it("NS-C10: cycle detection unaffected", function* () {
     // A uses slots but A slot="x" where A's body references A → cycle
     const a = makeComponent("A", '<Content slot="x" />\n<A />');
-    const ctx = makeCtx({ A: a });
+    const ctx = { A: a };
     const segments = scanSegments('<A>\n<A slot="x" />\n</A>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("Cycle detected");
   });
@@ -616,10 +629,10 @@ describe("Tier NS-D — slot prop reservation", () => {
     const widget = makeComponent("Widget", "T:{props.title}", {
       inputs: { title: { type: "string", required: true } },
     });
-    const ctx = makeCtx({ Layout: layout, Widget: widget });
+    const ctx = { Layout: layout, Widget: widget };
     // <Widget slot="main" title="Hi" /> — slot is stripped before validation
     const segments = scanSegments('<Layout>\n<Widget slot="main" title="Hi" />\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("T:Hi");
     expect(output).not.toContain("ERROR");
@@ -629,9 +642,9 @@ describe("Tier NS-D — slot prop reservation", () => {
     // Content is special-cased — slot on Content should not cause validation error
     const comp = makeComponent("Comp", '<Content slot="header" />\n<Content />');
     const header = makeComponent("Header", "H");
-    const ctx = makeCtx({ Comp: comp, Header: header });
+    const ctx = { Comp: comp, Header: header };
     const segments = scanSegments('<Comp>\n<Header slot="header" />\nbody\n</Comp>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).not.toContain("ERROR");
     expect(output).toContain("H");
@@ -779,9 +792,9 @@ describe("Tier NS-F — Edge cases", () => {
   it("NS-F1: slot on self-closing component", function* () {
     const layout = makeComponent("Layout", '<Content slot="icon" />\n<Content />');
     const badge = makeComponent("Badge", "BADGE");
-    const ctx = makeCtx({ Layout: layout, Badge: badge });
+    const ctx = { Layout: layout, Badge: badge };
     const segments = scanSegments('<Layout>\n<Badge slot="icon" />\nbody\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("BADGE");
     expect(output).toContain("body");
@@ -791,9 +804,9 @@ describe("Tier NS-F — Edge cases", () => {
     const layout = makeComponent("Layout", '<Content slot="main" />');
     const card = makeComponent("Card", "CARD:<Content />");
     const text = makeComponent("Text", "TEXT");
-    const ctx = makeCtx({ Layout: layout, Card: card, Text: text });
+    const ctx = { Layout: layout, Card: card, Text: text };
     const segments = scanSegments('<Layout>\n<Card slot="main"><Text /></Card>\n</Layout>');
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("CARD:");
     expect(output).toContain("TEXT");
@@ -808,7 +821,7 @@ describe("Tier NS-F — Edge cases", () => {
     const c = makeComponent("C", "C");
     const d = makeComponent("D", "D");
     const h = makeComponent("H", "HEAD");
-    const ctx = makeCtx({ A: a, B: b, C: c, D: d, H: h });
+    const ctx = { A: a, B: b, C: c, D: d, H: h };
     const segments = scanSegments(
       [
         "<A>",
@@ -820,7 +833,7 @@ describe("Tier NS-F — Edge cases", () => {
         "</A>",
       ].join("\n"),
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("A-HEAD:");
     expect(output).toContain("HEAD");
@@ -845,11 +858,11 @@ describe("Tier NS-F — Edge cases", () => {
   it("NS-F5: body with only named Content slots — default children discarded", function* () {
     const layout = makeComponent("Layout", '<Content slot="a" />\n<Content slot="b" />');
     const a = makeComponent("A", "A-CONTENT");
-    const ctx = makeCtx({ Layout: layout, A: a });
+    const ctx = { Layout: layout, A: a };
     const segments = scanSegments(
       '<Layout>\n<A slot="a" />\ndefault text should be discarded\n</Layout>',
     );
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     expect(output).toContain("A-CONTENT");
     // Default text should be discarded since there's no <Content />
@@ -859,10 +872,10 @@ describe("Tier NS-F — Edge cases", () => {
   it("NS-F6: healing unaffected by slots", function* () {
     // Text goes to default slot — layout must have <Content /> for it
     const layout = makeComponent("Layout", '<Content slot="main" />\n<Content />');
-    const ctx = makeCtx({ Layout: layout });
+    const ctx = { Layout: layout };
     // Unclosed bold in text — text goes to default slot, healing runs on it
     const segments = scanSegments("<Layout>\n**unclosed bold\n</Layout>");
-    const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
+    const expanded = yield* expandAll(segments, ctx);
     const output = renderSegments(expanded);
     // Text should be healed — no dangling markers
     expect(output).toContain("unclosed bold");
diff --git a/core/tests/run-document.test.ts b/core/tests/run-document.test.ts
index 737a34a..7daec87 100644
--- a/core/tests/run-document.test.ts
+++ b/core/tests/run-document.test.ts
@@ -1004,6 +1004,36 @@ describe("runDocument", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Journal shape through Component Api dispatch
+// ---------------------------------------------------------------------------
+
+describe("Component Api dispatch — journal shape", () => {
+  it("import and exec journal entries keep their identities", function* () {
+    const stream = new InMemoryStream();
+    yield* useStubFs({
+      "README.md": "<Note />\n\n```bash exec\necho hi\n```\n",
+      "components/Note.md": "note!\n",
+    });
+    yield* useStubExec();
+
+    const output = yield* collect(yield* runDocument({ docPath: "README.md", stream }));
+    expect(output).toContain("note!");
+
+    const events = stream.snapshot();
+    const imports = events.flatMap((e) =>
+      e.type === "yield" && e.description.type === "import_component" ? [e.description.name] : [],
+    );
+    expect(imports).toContain("__root__");
+    expect(imports).toContain("Note");
+
+    const execs = events.flatMap((e) =>
+      e.type === "yield" && e.description.type === "exec" ? [e] : [],
+    );
+    expect(execs.length).toBe(1);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Component-declared output at the document level (spec §5.4, §6.9)
 // ---------------------------------------------------------------------------
diff --git a/core/tests/text-interpolation.test.ts b/core/tests/text-interpolation.test.ts
index ea41690..e73def4 100644
--- a/core/tests/text-interpolation.test.ts
+++ b/core/tests/text-interpolation.test.ts
@@ -7,21 +7,19 @@
  */
 import { describe, it } from "@effectionx/bdd/node";
 import { expect } from "@effectionx/bdd/expect";
+import { scoped } from "effection";
 import { expandSegments } from "../src/expand.ts";
-import type { ExpansionContext } from "../src/expand.ts";
+import { Component } from "../src/component-api.ts";
 import { scanSegments } from "../src/scanner.ts";
 import { renderSegments } from "../src/render.ts";
 import { interpolateEvalBindings } from "../src/eval-interpolate.ts";
 import type { Operation } from "effection";
-import { EvalEnvCtx } from "../src/eval-env.ts";
 import type {
   Segment,
   ComponentDefinition,
   InputDefinition,
   Json,
   CodeBlockResult,
-  Modifier,
-  CodeBlockContext,
 } from "../src/types.ts";
 
 // ---------------------------------------------------------------------------
@@ -46,61 +44,77 @@ function makeComponent(
   };
 }
 
-function makeCtx(
+/** Install test component + modifier providers on the current scope. */
+function* useTestComponents(
   components: Record<string, ComponentDefinition>,
   codeResult?: CodeBlockResult,
-): ExpansionContext {
-  return {
-    importComponent: function* (name: string) {
-      const comp = components[name];
-      if (!comp) throw new Error(`Component not found: ${name}`);
-      return comp;
-    },
-    runModifierChain: function* (_modifiers: Modifier[], _context: CodeBlockContext) {
-      return (
-        codeResult ?? {
-          output: "mock output\n",
-          exitCode: 0,
-          stderr: "",
+): Operation<void> {
+  yield* Component.around(
+    {
+      // deno-lint-ignore require-yield
+      *importComponent([name], _next) {
+        const comp = components[name];
+        if (!comp) {
+          throw new Error(`Component not found: ${name}`);
         }
-      );
+        return comp;
+      },
+      // deno-lint-ignore require-yield
+      *applyModifiers(_args, _next) {
+        return (
+          codeResult ?? {
+            output: "mock output\n",
+            exitCode: 0,
+            stderr: "",
+          }
+        );
+      },
     },
-  };
+    { at: "min" },
+  );
 }
 
 /**
- * Expand segments with a pre-populated EvalEnv.
+ * Expand segments with a pre-populated binding environment.
  */
 function expandWithBindings(
   segments: Segment[],
-  ctx: ExpansionContext,
+  components: Record<string, ComponentDefinition>,
   bindings: Record<string, unknown>,
   meta: Record<string, unknown> = {},
   props: Record<string, Json> = {},
 ): Operation<string> {
-  function* op() {
-    return yield* EvalEnvCtx.with({ values: bindings }, function* () {
-      const expanded = yield* expandSegments(segments, meta, props, new Set(), ctx);
-      return renderSegments(expanded);
-    });
-  }
-  return op() as unknown as Operation<string>;
+  return scoped(function* () {
+    yield* useTestComponents(components);
+    const testEnv = { values: bindings };
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *env(_args, _next) {
+          return testEnv;
+        },
+      },
+      { at: "min" },
+    );
+    const expanded = yield* expandSegments(segments, meta, props, new Set());
+    return renderSegments(expanded);
+  });
 }
 
 /**
- * Expand segments with no EvalEnv on the scope.
+ * Expand segments with no binding environment in scope.
  */
 function expandWithoutEnv(
   segments: Segment[],
-  ctx: ExpansionContext,
+  components: Record<string, ComponentDefinition>,
   meta: Record<string, unknown> = {},
   props: Record<string, Json> = {},
 ): Operation<string> {
-  function* op() {
-    const expanded = yield* expandSegments(segments, meta, props, new Set(), ctx);
+  return scoped(function* () {
+    yield* useTestComponents(components);
+    const expanded = yield* expandSegments(segments, meta, props, new Set());
     return renderSegments(expanded);
-  }
-  return op() as unknown as Operation<string>;
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -110,7 +124,7 @@ function expandWithoutEnv(
 describe("Text interpolation — eval bindings in text segments", () => {
   // TI1: Bare binding in text resolves
   it("TI1: bare binding in text resolves from env.values", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Server on port {port}.");
     const output = yield* expandWithBindings(segments, ctx, { port: 49821 });
     expect(output).toBe("Server on port 49821.");
@@ -118,7 +132,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI2: Bare binding with no env entry left verbatim
   it("TI2: bare binding with no env entry left verbatim", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Value is {unknown}.");
     const output = yield* expandWithBindings(segments, ctx, {});
     expect(output).toBe("Value is {unknown}.");
@@ -126,7 +140,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI3: {meta.title} still resolves in first pass
   it("TI3: {meta.title} still resolves in first pass", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Title: {meta.title}");
     const output = yield* expandWithBindings(
       segments,
@@ -139,7 +153,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI4: {props.name} still resolves in first pass
   it("TI4: {props.name} still resolves in first pass", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Hello, {props.name}!");
     const output = yield* expandWithBindings(
       segments,
@@ -153,7 +167,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI5: Both passes in same text
   it("TI5: both meta/props and eval bindings in same text", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("{meta.title} by {author}");
     const output = yield* expandWithBindings(
       segments,
@@ -166,7 +180,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI6: Eval binding does not shadow meta
   it("TI6: eval binding does not shadow meta (different syntax)", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("{meta.x} and {x}");
     const output = yield* expandWithBindings(
       segments,
@@ -179,7 +193,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI7: Non-string value coerced
   it("TI7: non-string value coerced via String()", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Count is {count}.");
     const output = yield* expandWithBindings(segments, ctx, { count: 42 });
     expect(output).toBe("Count is 42.");
@@ -187,7 +201,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI8: Object value produces [object Object]
   it("TI8: object value produces [object Object]", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Data: {obj}");
     const output = yield* expandWithBindings(segments, ctx, { obj: {} });
     expect(output).toBe("Data: [object Object]");
@@ -195,7 +209,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI9: No EvalEnv — second pass skipped
   it("TI9: no EvalEnv — bare {name} left verbatim", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Value is {name}.");
     const output = yield* expandWithoutEnv(segments, ctx);
     expect(output).toBe("Value is {name}.");
@@ -203,7 +217,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI10: Escaped braces not interpolated
   it("TI10: escaped braces not interpolated", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Literal: \\{name}");
     const output = yield* expandWithBindings(segments, ctx, {
       name: "resolved",
@@ -217,7 +231,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
     // (via expandComponent). Text from children expanded inside child's
     // scope should NOT see parent's bindings.
     const child = makeComponent("Child", "<Content />");
-    const ctx = makeCtx({ Child: child });
+    const ctx = { Child: child };
     const segments = scanSegments("<Child>text with {label}</Child>");
     // Parent env has 'label', but child gets a fresh env
     const output = yield* expandWithBindings(segments, ctx, {
@@ -229,23 +243,17 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI12: <Capture> text uses current env
   it("TI12: Capture text uses current component env", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments('<Capture as="captured">value is {port}\n</Capture>');
-    const env = { values: { port: 8080 } as Record<string, unknown> };
-    function* op() {
-      return yield* EvalEnvCtx.with(env, function* () {
-        const expanded = yield* expandSegments(segments, {}, {}, new Set(), ctx);
-        return renderSegments(expanded);
-      });
-    }
-    const output = yield* op() as unknown as Operation<string>;
+    const bindings: Record<string, unknown> = { port: 8080 };
+    const output = yield* expandWithBindings(segments, ctx, bindings);
     expect(output).toBe("");
-    expect(env.values["captured"]).toBe("value is 8080");
+    expect(bindings["captured"]).toBe("value is 8080");
   });
 
   // TI13: Multiple bindings in one text segment
   it("TI13: multiple bindings in one text segment", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("{host}:{port}");
     const output = yield* expandWithBindings(segments, ctx, {
       host: "127.0.0.1",
@@ -256,7 +264,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI14: Binding adjacent to meta ref
   it("TI14: binding adjacent to meta ref — both resolved", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("{meta.title}: {subtitle}");
     const output = yield* expandWithBindings(
       segments,
@@ -269,7 +277,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI15: Empty env.values — no crash
   it("TI15: empty env.values — bare refs left verbatim, no crash", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("Value is {name} and {other}.");
     const output = yield* expandWithBindings(segments, ctx, {});
     expect(output).toBe("Value is {name} and {other}.");
@@ -277,7 +285,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI17: Dotted path in text segment resolves nested property
   it("TI17: dotted path {pr.meta.title} resolves in text segment", function* () {
-    const ctx = makeCtx({});
+    const ctx = {};
     const segments = scanSegments("PR #{pr.meta.number}: {pr.meta.title}");
     const output = yield* expandWithBindings(segments, ctx, {
       pr: { meta: { number: "42", title: "feat: add feature" } },
@@ -287,20 +295,27 @@ describe("Text interpolation — eval bindings in text segments", () => {
 
   // TI16: Code blocks unchanged
   it("TI16: code block interpolation still works as before", function* () {
-    const capturedContext: CodeBlockContext[] = [];
-    const ctx: ExpansionContext = {
-      importComponent: function* () {
-        throw new Error("not needed");
-      },
-      runModifierChain: function* (_modifiers: Modifier[], context: CodeBlockContext) {
-        capturedContext.push(context);
-        return { output: "ok\n", exitCode: 0, stderr: "" };
-      },
-    };
+    const captured: string[] = [];
     const segments = scanSegments("```bash exec\necho {port}\n```\n");
-    yield* expandWithBindings(segments, ctx, { port: 8080 });
+    yield* scoped(function* () {
+      yield* Component.around(
+        {
+          // deno-lint-ignore require-yield
+          *applyModifiers([_modifiers, block], _next) {
+            captured.push(block.content);
+            return { output: "ok\n", exitCode: 0, stderr: "" };
+          },
+          // deno-lint-ignore require-yield
+          *env(_args, _next) {
+            return { values: { port: 8080 } };
+          },
+        },
+        { at: "min" },
+      );
+      return yield* expandSegments(segments, {}, {}, new Set());
+    });
     // The code block content should have been interpolated
-    expect(capturedContext[0].content).toBe("echo 8080\n");
+    expect(captured[0]).toBe("echo 8080\n");
   });
 });
 
diff --git a/specs/decisions.md b/specs/decisions.md
index 953657a..fc511de 100644
--- a/specs/decisions.md
+++ b/specs/decisions.md
@@ -174,9 +174,10 @@ Keep stream protocol integration in the execution boundary
 All other modules (scanner, frontmatter, expand, interpolate, validate,
 render) have zero dependency on the stream package.
 
-The expansion engine accepts abstract `ComponentImporter` and
-`ModifierChainRunner` functions — it doesn't know about durable effects.
-This was a good architectural decision that happened naturally.
+The expansion engine reaches import and modifier execution through the
+contextual Component Api (DEC-012) — it doesn't know about durable
+effects. The document's providers, installed by `run-document.ts`, are
+the only place expansion meets the stream protocol.
 
 ---
 
@@ -241,26 +242,19 @@ the factory is called with the parsed params from the info string
 conforms to `Middleware<[], ...>` — no arguments flow through `next`,
 params are captured in the factory closure.
 
-**3. Effection Context for code block metadata:**
+**3. Contextual delivery of code block metadata:**
 
-```typescript
-const CodeBlockCtx = createContext<CodeBlockContext>("codeBlock");
-function useCodeBlock(): Workflow<CodeBlockContext> {
-  return ephemeral(CodeBlockCtx.expect());
-}
-```
-
-`composeModifierChain` sets the context via `CodeBlockCtx.with()`,
-which scopes the value to the chain execution. Handlers that need the
+The block's `CodeBlockContext` is delivered through the Component Api
+(DEC-012): `composeModifierChain` installs a scope-local `codeBlock()`
+provider for the duration of the chain, and handlers that need the
 code block info (language, content, componentName) call `useCodeBlock()`
 instead of receiving it as a parameter. The `ephemeral()` bridge makes
 this work inside durable workflow generators (see DEC-001).
 
-### Why `CodeBlockCtx.with()` instead of `Context.set()`
+### Why a scope-local provider instead of `Context.set()`
 
-`Context.with(value, operation)` scopes the value to the operation's
-lifetime and restores the previous value when done. This is the correct
-primitive because:
+A provider installed inside the chain's own scope is removed when that
+scope exits. This is the correct primitive because:
 
 - Each code block gets its own context for the duration of its chain
 - No context leaks between code blocks
@@ -374,8 +368,8 @@ Components needed a way to capture their children's rendered output
 
 Closures injected into `env.values` at component expansion time. They
 capture the expansion context (meta, props, hide set, eval scope) and
-wrap their `expandSegments` calls in `EvalEnvCtx.with()` and
-`EvalScopeCtx.with()`.
+install the caller's binding environment and eval scope as scope-local
+Component providers (DEC-012) around their `expandSegments` calls.
 
 **Why closures, not an Api:** A Render Api would require middleware
 installation per component and add a new Api type to the system.
@@ -383,10 +377,11 @@ Closures are simpler — they're injected once during `expandComponent`
 and naturally capture all needed context. They're non-serializable,
 so `serializeExports` silently omits them from the journal.
 
-**Why context wrapping:** The closures may be called from inside
-`evalScope.eval()`, where the Effection context is different from
-the expansion context. Wrapping ensures `EvalEnvCtx` and `EvalScopeCtx`
-are correctly set regardless of the calling task.
+**Why provider installation inside the closure:** The closures may be
+called from inside `evalScope.eval()`, where the ambient scope differs
+from the expansion scope. Installing the providers at call time ensures
+the correct environment and eval scope are visible regardless of the
+calling task.
 
 ---
 
@@ -422,3 +417,53 @@ conversion preserves the distinction between "not provided" and "empty"
 for provider routing (providers check `context.model !== undefined`).
 
 ---
+
+## DEC-012: Component Api replaces dependency threading and raw operational contexts
+
+**Status:** Decided
+
+### Context
+
+Expansion originally received its dependencies through an
+`ExpansionContext` object (`importComponent`, `runModifierChain`)
+threaded as a parameter into every recursive expansion call, while the
+remaining operational state traveled through raw Effection context keys
+(`EvalEnvCtx`, `EvalScopeCtx`, `CodeBlockCtx`, `PersistFlagCtx`,
+`ContentCtx`, `ErrorPolicyCtx`). Two delivery mechanisms meant two
+override models: replacing an import strategy required constructing a
+new container at the call site, while overriding scope state required
+knowing which raw key to set — and neither surface was wrappable for
+instrumentation.
+
+### Decision
+
+One public Api — `Component` (`ComponentApi`) backed by
+`@effectionx/context-api` — carries every context-dependent operation:
+`importComponent`, `applyModifiers`, `raise`, `env`, `evalScope`,
+`codeBlock`, `persistent`, `content`. The `ctx` parameter is gone from
+the expansion signatures, and the raw operational keys are removed from
+the public surface. `useCodeBlock()` and `useContent()` remain as
+ergonomic aliases.
+
+**Why middleware at `min` for implementations:** middleware installed
+in a nested scope runs before inherited middleware, so a component's
+own `env`/`evalScope` providers shadow its ancestors' by
+short-circuiting — and installing inside `scoped()` removes them on
+exit, so siblings never observe each other's state. Runtime providers
+(document import, modifier execution, per-component state, error
+policy) all install at `min`.
+
+**Why `max` for instrumentation:** `max` middleware wraps outside every
+implementation, so tracing, mocking, and overrides can observe or
+transform calls without caring which `min` provider is active, and can
+delegate with `next(...)` or short-circuit.
+
+**Why defaults instead of mandatory providers:** operations with a
+sensible neutral value default to it (`raise` returns the segment,
+`env()`/`evalScope()` are undefined, `persistent()` is false), while
+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
+store durable runtime state, not overridable core operations.
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index f7292a0..a1b18b3 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -401,20 +401,14 @@ interface CodeBlockResult {
 }
 ```
 
-The code block context is delivered via Effection's `Context` — set
-on the scope via `CodeBlockCtx.with()` before the modifier chain
-runs. Handlers that need it read via `useCodeBlock()`:
-
-```typescript
-const CodeBlockCtx = createContext<CodeBlockContext>("codeBlock");
-
-function useCodeBlock(): Workflow<CodeBlockContext> {
-  return ephemeral(CodeBlockCtx.expect());
-}
-```
+The code block context is delivered contextually through the Component
+Api (§5.5): the chain runner provides it for the duration of the chain,
+and handlers that need it read `yield* useCodeBlock()` (an ergonomic
+alias for the `codeBlock()` operation). Outside a running chain,
+`codeBlock()` reports a clear missing-provider error.
 
 This follows the Effection convention: shared execution context
-lives on the scope and is accessed via context accessors, not
+lives on the scope and is accessed via contextual operations, not
 threaded through function parameters.
 
 #### Modifier factory and middleware types
@@ -498,8 +492,10 @@ optionally produce output via the `output()` function (see §4.7).
 export const evalFactory: ModifierFactory = (_params) =>
   (_args, _next) => (function* () {
     const ctx = yield* useCodeBlock();
-    const env = yield* ephemeral(EvalEnvCtx.expect());
-    const persist = yield* ephemeral(PersistFlagCtx.get()) ?? false;
+    // Contextual reads (§5.5), bridged with ephemeral() because this
+    // handler is Workflow-typed.
+    const evalEnv = yield* ephemeral(env());
+    const persist = yield* ephemeral(persistent());
 
     // Inject output() function into env so eval blocks can produce
     // rendered output. The mutable ref is block-local; serializeExports
@@ -507,32 +503,33 @@ export const evalFactory: ModifierFactory = (_params) =>
     // pollute the journal. The output text itself is journaled alongside
     // exports as __output.
     const outputRef = { text: "" };
-    env.values.output = (text: string) => { outputRef.text = String(text); };
+    evalEnv.values.output = (text: string) => { outputRef.text = String(text); };
 
     const transformed = transformBlock(
       ctx.content,
       ctx.blockId,
-      Object.keys(env.values),
+      Object.keys(evalEnv.values),
     );
 
-    const bindings = serializeExports(env.values, transformed.imports);
+    const bindings = serializeExports(evalEnv.values, transformed.imports);
     const result = yield createDurableOperation(
       { type: "eval", name: `eval:${ctx.blockId}`, language: ctx.language },
       function* () {
-        Object.assign(env.values, bindings);
+        Object.assign(evalEnv.values, bindings);
         const fn = yield* compileBlock(source, transformed.userImports ?? []);
 
         if (persist) {
-          const evalScope = yield* EvalScopeCtx.expect();
-          const blockResult = yield* evalScope.eval(
-            () => fn(env.values) as unknown as Operation<void>,
+          // The component eval scope is read contextually (§5.5).
+          const scope = yield* evalScope();
+          const blockResult = yield* scope.eval(
+            () => fn(evalEnv.values) as unknown as Operation<void>,
           );
           unbox(blockResult);
         } else {
-          yield* fn(env.values) as unknown as Operation<void>;
+          yield* fn(evalEnv.values) as unknown as Operation<void>;
         }
 
-        const exports = serializeExports(env.values, transformed.exports);
+        const exports = serializeExports(evalEnv.values, transformed.exports);
 
         // Record output text alongside exports.
         if (outputRef.text) {
@@ -551,7 +548,7 @@ export const evalFactory: ModifierFactory = (_params) =>
         outputRef.text = restored.__output;
       }
       const { __output: _, ...exports } = restored;
-      Object.assign(env.values, exports);
+      Object.assign(evalEnv.values, exports);
     }
 
     return { output: outputRef.text, exitCode: 0, stderr: "" };
@@ -599,7 +596,7 @@ export const daemonFactory: ModifierFactory = (_params) =>
     // daemon produces no journal entry, so all its effects are ephemeral.
     const launchDaemon = {
       *[Symbol.iterator]() {
-        const evalScope = yield* EvalScopeCtx.expect();
+        const scope = yield* evalScope();
 
         // ctx.content is already interpolated by the expansion engine
         // before the modifier chain runs — no interpolation needed here.
@@ -609,7 +606,7 @@ export const daemonFactory: ModifierFactory = (_params) =>
         // Fork into eval scope — lifetime tied to component expansion.
         // daemon() never resolves. If the process exits prematurely,
         // daemon() throws DaemonExitError, propagating to the eval scope.
-        yield* evalScope.eval(function* () {
+        yield* scope.eval(function* () {
           yield* daemon(commandStr);
         });
       },
@@ -659,20 +656,12 @@ block's compiled code runs via `evalScope.eval()`, retaining spawned
 resources for the lifetime of the component expansion. See §4.5 for
 the context flag pattern.
 
-`persist` itself does not call `evalScope.eval()` — it sets a context
-flag (`PersistFlagCtx`) that `evalFactory` reads to decide whether to
-route through the eval scope:
-
-```typescript
-export const persistFactory: ModifierFactory = (_params) =>
-  (_args, next) => (function* () {
-    return yield* ephemeral(
-      PersistFlagCtx.with(true, function* () {
-        return yield* next() as unknown as Operation<CodeBlockResult>;
-      }),
-    );
-  })();
-```
+`persist` itself does not call `evalScope.eval()` — it makes the
+contextual `persistent()` operation (§5.5) answer true for the duration
+of the inner chain, and `evalFactory` reads that to decide whether to
+route through the eval scope. The install is scope-local, so
+`persistent()` reverts to false as soon as the persist-wrapped chain
+completes.
 
 | Info string | Behavior |
 |---|---|
@@ -708,36 +697,11 @@ function parseDuration(s: string): number {
 When a code block is encountered during expansion, the modifier chain
 is composed using the reusable `combine()` primitive. Each factory is
 called with its parsed params to produce a middleware, then all
-middlewares are combined into a single chain. `CodeBlockCtx.with()`
-sets the context on the scope for the duration of the chain:
-
-```typescript
-function composeModifierChain(
-  modifiers: Modifier[],
-  context: CodeBlockContext,
-  registry: ModifierRegistry,
-): () => CodeBlockWorkflow {
-  const terminal = function* () {
-    throw new Error("No terminal modifier (exec/eval) in chain");
-  };
-
-  const middlewares = modifiers.map((mod) => {
-    const factory = registry.get(mod.name);
-    if (!factory) throw new Error(`Unknown modifier: ${mod.name}`);
-    return factory(mod.params);
-  });
-
-  const composed = combine(middlewares);
-
-  return function* () {
-    return yield* ephemeral(
-      CodeBlockCtx.with(context, function* () {
-        return yield* composed([], terminal);
-      }),
-    );
-  };
-}
-```
+middlewares are combined into a single chain. A missing factory or a
+chain with no terminal modifier is an error. While the chain runs, the
+block's `CodeBlockContext` is available to every handler through the
+contextual `codeBlock()` operation (§5.5), and it is gone when the
+chain completes.
 
 For ```` ```bash silent timeout[30s] exec ````:
 
@@ -1093,28 +1057,9 @@ function serializeExports(
 ### 4.2 Module compilation via data: URI
 
 Eval blocks are compiled into `data:` URI TypeScript modules and
-dynamically imported. Eval blocks can use standard `import`
-statements, resolved through Deno's import map.
-
-```typescript
-// src/eval-context.ts
-import { createContext as createEffectionContext, call } from "effection";
-import type { Operation } from "effection";
-
-export interface EvalContext {
-  initialized: true;
-}
-
-export const EvalCtxKey = createEffectionContext<EvalContext>("evalContext");
-
-export function createEvalContext(): EvalContext {
-  return { initialized: true };
-}
-```
-
-The `EvalContext` is a lightweight marker that the eval system has
-been initialized. APIs are provided as standard `import` statements
-in the generated module.
+dynamically imported (`compileBlock` in `src/eval-context.ts`,
+delegating to the platform compiler middleware). Eval blocks can use
+standard `import` statements, resolved through Deno's import map.
 
 #### Standard imports
 
@@ -1248,30 +1193,22 @@ Each run compiles and imports the current transformed source.
 export interface EvalEnv {
   values: Record<string, unknown>;
 }
-
-export const EvalEnvCtx = createContext<EvalEnv>("evalEnv");
 ```
 
 Created fresh at the start of component expansion. Each eval block reads
 bindings from `values` (via env preamble) and writes new bindings back
-(via env-write transforms). Handlers access it via
-`ephemeral(EvalEnvCtx.expect())`.
-
-The binding environment is scoped to the document expansion lifetime via
-`EvalEnvCtx.with()` — matching the same `Context.with()` pattern as
-`CodeBlockCtx.with()` in `composeModifierChain`.
+(via env-write transforms). The current environment is read contextually
+via the `env()` operation (§5.5); the expansion engine provides it
+scope-locally around each component body, so eval blocks within a
+component share bindings without leaking into parent or sibling
+components.
 
 ### 4.4 Eval scope and resource lifetime
 
 Each document gets a dedicated **eval scope** — an Effection scope whose
 lifetime matches the document's expansion. Resources spawned by `persist`
-blocks are retained in this scope until expansion completes.
-
-```typescript
-// src/eval-env.ts
-export const EvalScopeCtx = createContext<EvalScope>("evalScope");
-export const PersistFlagCtx = createContext<boolean>("persistFlag");
-```
+blocks are retained in this scope until expansion completes. The current
+eval scope is read contextually via the `evalScope()` operation (§5.5).
 
 The eval scope is created in `runDocument()` (§8.1) **before**
 `durableRun` via `resource(useEvalScope())`. This is critical:
@@ -1280,15 +1217,16 @@ reachable by the Effection scheduler — this only works when both sender
 and processor share an ancestor scope outside the durable execution
 boundary.
 
-#### The context flag pattern
+#### The persistent-flag pattern
 
 `persist` does not wrap the entire modifier chain in `evalScope.eval()`.
 That would hang because the durable effects in the workflow can't
 interact with the journal from within the eval scope's channel
 processor. Instead:
 
-1. `persist` sets `PersistFlagCtx = true` via `Context.with()`
-2. `evalFactory` reads `PersistFlagCtx` after compiling the block
+1. `persist` makes the contextual `persistent()` operation answer true
+   for the duration of the inner chain
+2. `evalFactory` reads `persistent()` after compiling the block
 3. When true, only the **compiled VM block** (`fn(env.values)`) runs
    inside `evalScope.eval()` — not the entire modifier chain
 4. Resources spawned during that execution are retained until the
@@ -1320,12 +1258,13 @@ run but are absent from the diagnostic trace.
 | File | Contents |
 |---|---|
 | `src/eval-transform.ts` | `transformBlock()`, `serializeExports()`, `isJson()`, `TransformResult` |
-| `src/eval-context.ts` | `createEvalContext()`, `compileBlock()` (data: URI), `EvalCtxKey`, `EvalContext` |
+| `src/component-api.ts` | `Component` Api + `ComponentApi` interface and the direct operations (`importComponent`, `applyModifiers`, `raise`, `env`, `evalScope`, `codeBlock`, `persistent`, `content`) — §5.5 |
+| `src/eval-context.ts` | `compileBlock()` (data: URI) |
 | `src/deno-compiler.ts` | `useDenoCompiler()` — data: URI compiler middleware for Deno; owns `STANDARD_IMPORTS` |
 | `src/temp-file-compiler.ts` | `useTempFileCompiler()` — temp-file compiler middleware for Node/Bun; owns `STANDARD_IMPORTS` |
-| `src/content-context.ts` | `ContentCtx`, `ContentHandle`, `useContent()` — content slot access for function components |
+| `src/content-context.ts` | `useContent()` — content slot access for function components |
 | `test-support/bdd.ts` | Deno-native BDD shim — wraps `@std/testing/bdd` with Effection test adapter |
-| `src/eval-env.ts` | `EvalEnv`, `EvalEnvCtx`, `EvalScopeCtx`, `PersistFlagCtx` |
+| `src/eval-env.ts` | `EvalEnv` |
 | `src/eval-handler.ts` | `evalFactory` |
 | `src/eval-interpolate.ts` | `interpolateEvalBindings()` — bare `{name}` substitution |
 | `src/modifiers/persist.ts` | `persistFactory` |
@@ -1456,10 +1395,10 @@ tree. Inner components create their own child scopes off
 `parentEvalScope`, and ancestor middleware is visible through
 Effection's scope prototype chain.
 
-Both wrap their `expandSegments` calls in `EvalEnvCtx.with()` and
-`EvalScopeCtx.with()` so the full expansion context is available
-regardless of which task the closure runs in (e.g., inside
-`evalScope.eval()`).
+Both install the caller's binding environment and eval scope as
+scope-local Component providers (§5.5) around their `expandSegments`
+calls, so the full expansion context is available regardless of which
+task the closure runs in (e.g., inside `evalScope.eval()`).
 
 #### Non-serializable
 
@@ -1656,9 +1595,10 @@ a named `export const inputs = { ... }`. This is equivalent to the
 export exists, the component accepts no props.
 
 **Children via `useContent()`.** Function components access children
-from the Effection scope, not from props. The expansion engine sets
-`ContentCtx` on the scope before calling the function. Components
-that need rendered children call `yield* useContent()`:
+contextually, not from props. The expansion engine installs a
+scope-local content provider (§5.5) around each function component
+invocation. Components that need rendered children call
+`yield* useContent()`:
 
 ```typescript
 // components/Card.ts
@@ -1679,17 +1619,9 @@ const header = yield* useContent("header");
 const body = yield* useContent();  // default slot
 ```
 
-**`ContentHandle` on the scope:**
-
-```typescript
-export interface ContentHandle {
-  renderDefault: () => Operation<string>;
-  renderSlot: (name: string) => Operation<string>;
-  segments: Segment[];
-}
-
-export const ContentCtx = createContext<ContentHandle>("content");
-```
+Calling `useContent()` outside a function component invocation reports
+a clear missing-provider error. The provider is removed when the
+invocation completes, so content never leaks into sibling expansions.
 
 **Resolution priority.** When both `Name.md` and `Name.ts` exist,
 the `.md` file wins. This ensures backward compatibility — existing
@@ -1955,6 +1887,53 @@ emission, and an empty selection emits nothing. A component invoked within the
 root expands recursively and its result is buffered into the surrounding
 output in both cases.
 
+### 5.5 The Component Api
+
+Expansion's context-dependent operations are exposed through one public
+Effection Api. `Component` is the Api value, `ComponentApi` its
+interface, and each operation is also exported directly:
+
+| Operation | Meaning | Without a provider |
+|---|---|---|
+| `importComponent(name)` | Resolve and import a component; `"__root__"` is the root document | throws a missing-provider error |
+| `applyModifiers(modifiers, block)` | Execute a code block through its modifier chain | throws a missing-provider error |
+| `raise(error)` | Report an `ErrorSegment` under the ambient error policy (§6.9) | returns the supplied segment |
+| `env()` | The current binding environment (§4.3) | `undefined` |
+| `evalScope()` | The current eval scope (§4.4) | `undefined` |
+| `codeBlock()` | The code block executing through the modifier chain (§3.3) | throws a missing-provider error |
+| `persistent()` | Whether the current block runs with persistent lifetime (§4.4) | `false` |
+| `content(slot?)` | Render the invoking component's children (§5.1, §6.3) | throws a missing-provider error |
+
+`useCodeBlock()` and `useContent()` remain as ergonomic aliases backed
+by `codeBlock()` and `content(slot?)`.
+
+**Providers are scope-local middleware.** Behavior is installed with
+`Component.around(middlewares, { at })` and lasts until the installing
+scope exits. Runtime implementations — the document's import and
+modifier providers, and every piece of per-component state — install at
+`{ at: "min" }`; caller instrumentation and overrides wrap at the
+default `"max"` and may delegate with `next(...)` or short-circuit by
+returning without calling it.
+
+**Observable scoping behavior:**
+
+- A provider installed in a nested scope takes precedence over an
+  ancestor's provider for the same operation, without calling `next`.
+  This is how each component's fresh binding environment and child eval
+  scope shadow the parent's during body expansion.
+- When the installing scope exits, its providers are gone — siblings
+  never observe each other's state. Caller-projected content, the
+  current code block, the persistent flag, and function-component
+  content all rely on this.
+- `runDocument` installs the document's `importComponent` /
+  `applyModifiers` / root `evalScope` providers before starting the
+  durable workflow, so the whole run inherits them; the journal shape
+  of import, exec, and eval effects is unchanged by contextual
+  dispatch.
+- Calls from `Workflow`-typed code bridge with `ephemeral()` (typing
+  only — a durable operation performed by a provider still journals);
+  calls from `Operation` code yield the operations directly.
+
 ---
 
 ## 6. Expansion
@@ -3095,13 +3074,15 @@ function* runDocument(options: RunDocumentOptions): Operation<DocumentExecution>
     });
     yield* useDirectoryResolver(componentDirs);
 
-    // Create eval context marker (§4.2)
-    const evalCtx = createEvalContext();
-    yield* EvalCtxKey.set(evalCtx);
-
-    // Create eval scope before the journaled document workflow (§4.4).
-    const evalScope = yield* resource(useEvalScope());
-    yield* EvalScopeCtx.set(evalScope);
+    // Create eval scope before the journaled document workflow (§4.4),
+    // then install the document's Component providers (§5.5) so the
+    // workflow inherits import, modifier execution, and the root eval
+    // scope contextually.
+    const rootEvalScope = yield* resource(useEvalScope());
+    yield* Component.around(
+      { importComponent, applyModifiers, evalScope: () => rootEvalScope },
+      { at: "min" },
+    );
 
     // Install built-in modifier handlers (exec, silent, sample, eval, persist, timeout)
     yield* useBuiltinModifiers();
@@ -3817,7 +3798,7 @@ visible warning blocks, collect into a separate error report).
 
 | # | Test | Verify |
 |---|------|--------|
-| H1 | Eval context creation | `createEvalContext()` returns `EvalContext` with `initialized: true` |
+| H1 | Missing-provider diagnostics | `importComponent`, `applyModifiers`, `codeBlock`, and `content` report clear missing-provider errors when no provider is installed |
 | H2 | Effection globals available | `sleep`, `spawn`, `createChannel` accessible in compiled block via standard imports |
 | H3 | executable.md globals available | `findFreePort`, `Sample`, `when` accessible in compiled block via `@executablemd/core` |
 | H5 | `compileBlock` returns generator function | `yield* compileBlock(code, [])` returns a callable generator function |
@@ -3831,7 +3812,7 @@ visible warning blocks, collect into a separate error report).
 |---|------|--------|
 | I1 | `eval` is terminal | `evalFactory` ignores `next` — never calls it |
 | I2 | `eval` returns empty output | `result.output === ""`, `exitCode === 0` |
-| I3 | `persist eval` composes | `persist` sets `PersistFlagCtx`, `eval` reads it |
+| I3 | `persist eval` composes | `persist` makes `persistent()` answer true, `eval` reads it |
 | I4 | `timeout=5s eval` composes | Timeout cancels after 5s if block hangs |
 | I5 | `timeout eval` default | Default timeout is 30s |
 | I6 | `persist timeout=10s eval` | Three modifiers compose: persist → timeout → eval |
@@ -3868,7 +3849,7 @@ visible warning blocks, collect into a separate error report).
 | L1 | `persist eval` retains spawned resource | Resource spawned in block survives block completion |
 | L2 | Non-persist eval tears down resource | Resource spawned in block torn down at block end |
 | L3 | Persist resource lifetime matches component | Resource torn down when component expansion completes |
-| L4 | PersistFlagCtx scoped to chain | Flag is `true` only during the persist-wrapped chain |
+| L4 | Persistent flag scoped to chain | `persistent()` is `true` only during the persist-wrapped chain |
 | L5 | Multiple persist blocks in one component | Each retains its own resources independently |
 | L6 | Persist on repeated run | Resource is created and retained again for the current component lifetime |
 | L7 | Persist flag does not leak to sibling blocks | Non-persist block after persist block → flag is false |
@@ -3917,7 +3898,7 @@ visible warning blocks, collect into a separate error report).
 | Q7 | Process terminated on parent cancellation | If parent scope cancelled, process terminated |
 | Q8 | Premature exit propagates as error | Process exits during expansion → `daemon()` throws → `ErrorSegment` in output |
 | Q9 | `{port}` interpolation in daemon content | Binding from preceding `eval` block substituted into command |
-| Q10 | `daemon` without eval scope | Missing `EvalScopeCtx` → clear error |
+| Q10 | `daemon` without eval scope | No eval scope in scope → clear error |
 | Q11 | Modifier chain: `bash daemon exec` | `daemon` is outermost terminal; `exec` present but never called |
 | Q12 | Repeated run: daemon starts and stops | Process is spawned and terminated again |
 | Q13 | Repeated run: current port used | Eval allocates a current port; daemon binds it |
@@ -4079,7 +4060,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 4 | `durableImportComponent` is a single journaled operation | Resolve + read in one `createDurableOperation`; one diagnostic journal entry per component |
 | 5 | Parsing is runtime | Deterministic from file content, no journal needed |
 | 6 | Info string modifiers are a middleware chain | `bash silent exec` — left-to-right wrapping, composable, extensible, compatible with all renderers |
-| 7 | Each modifier is a factory that returns `Middleware<[], CodeBlockWorkflow>` | Factory captures params in closure; context on Effection scope via `CodeBlockCtx.with()` + `useCodeBlock()`; aligns with Effection v4.1's `Middleware<TArgs, TReturn>` |
+| 7 | Each modifier is a factory that returns `Middleware<[], CodeBlockWorkflow>` | Factory captures params in closure; the block context is delivered contextually via `codeBlock()`/`useCodeBlock()` (§5.5); aligns with Effection v4.1's `Middleware<TArgs, TReturn>` |
 | 8 | `useModifier` registers handlers on the scope | Scope-inherited — child scopes can override parent handlers for their subtree |
 | 9 | `exec`/`eval` are terminal handlers, others are wrapping | Terminal handlers ignore `next`; wrapping handlers call `next()` and transform the result |
 | 10 | `sample` handler delegates to Sample Api via `durableSample` | Two layers: handler (part of modifier chain) and Api (LLM middleware) — each composable independently |
@@ -4095,13 +4076,13 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 22 | Components are semantic boundaries for markdown constructs | Bold, italic, links, code spans cannot span across a component or exec block — each text segment is healed independently |
 | 23 | Remend runs after scanning, before interpolation | Heals incomplete markdown in text segments; `htmlTags: false` required — boundary scanner owns JSX completeness, remend owns markdown completeness |
 | 24 | Healing is runtime, not journaled | Pure function of current text content; no journal entry |
-| 25 | `CodeBlockContext` delivered via Effection Context, not handler parameter | `CodeBlockCtx.with()` scopes the context to the chain execution; handlers read via `useCodeBlock()`; keeps middleware signature clean `Middleware<[], ...>` |
+| 25 | `CodeBlockContext` delivered contextually, not as a handler parameter | A scope-local `codeBlock()` provider covers exactly the chain execution; handlers read via `useCodeBlock()`; keeps middleware signature clean `Middleware<[], ...>` |
 | 26 | Reusable `Middleware<TArgs, TReturn>` primitive in `@effectionx/middleware` | Same type as Effection v4.1's Api middleware; `combine()` composes arrays; decoupled from modifier-specific types; originally `src/middleware.ts`, extracted to shared package |
 | 27 | `blockId` format: `eval:${componentName ?? "root"}:${index}` | Unique within a document run and stable enough to compare diagnostic traces |
 | 28 | Acorn + magic-string for source transform | Acorn provides reliable ES2024 parsing; magic-string preserves source positions for accurate source maps without rebuilding AST |
 | 29 | Execution mode auto-detected from AST | No modifier needed — `yield` in body → generator, `await` → async, neither → sync; mixed yield+await is a transform error |
 | 30 | `data:` URI module compilation for eval blocks | Eval blocks are compiled into `data:application/typescript,...` URI modules and dynamically imported via `yield* call(() => import(dataUri))`. APIs are standard `import` statements in the generated module, resolved through Deno's import map. `new Function()` is used for expression props (simpler than `data:` URI for single expressions, no module imports needed) |
-| 31 | `persist` uses a context flag, not direct wrapping | Wrapping the full modifier chain in `evalScope.eval()` hangs because durable effects can't interact with the journal from inside the eval scope's channel processor; instead `persist` sets `PersistFlagCtx`, and `evalFactory` routes only the compiled VM block through `evalScope.eval()` |
+| 31 | `persist` uses a contextual flag, not direct wrapping | Wrapping the full modifier chain in `evalScope.eval()` hangs because durable effects can't interact with the journal from inside the eval scope's channel processor; instead `persist` makes `persistent()` answer true, and `evalFactory` routes only the compiled VM block through `evalScope.eval()` |
 | 32 | `evalScope` created before the journaled workflow | The channel processor and eval sender share an ancestor scope |
 | 33 | Non-serializable bindings silently omitted from journal | Functions, class instances, and live objects remain in `env.values` during the current run but are absent from the diagnostic trace |
 | 34 | Eval blocks produce no rendered output by default | Eval blocks primarily exist for bindings and side effects. The `output()` function (§4.7) optionally produces rendered output; without it, result is `{ output: "", exitCode: 0, stderr: "" }` |
@@ -4116,17 +4097,17 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 43 | `when` (from `@effectionx/converge`) is the polling VM global | `when` is the exported name from the package; the sandbox already contains it; no rename or addition needed |
 | 44 | Provider lifecycle expressed as a component, not a `RunDocumentOptions` field | Scope boundary is visible in the document tree; composable — multiple providers nest naturally via structured concurrency; no framework-level lifecycle hooks required |
 | 45 | Readiness check is a separate `eval` block, not internal to `daemon` | Auditable — strategy visible in the document; replaceable — different daemons have different readiness signals; composable with `when`'s configurable backoff |
-| 46 | Sample middleware reads `baseUrl` from `env.values` | Avoids a dedicated inference server context key; `EvalEnvCtx` is already the shared state carrier for within-component coordination; scope-correct because `EvalEnvCtx` is set per component expansion |
-| 47 | Each component gets a fresh `EvalEnv` | `EvalEnvCtx.with()` wraps component expansion so eval blocks within a component share bindings but don't leak into parent or sibling components; critical for provider isolation |
+| 46 | Sample middleware reads `baseUrl` from `env.values` | Avoids a dedicated inference server context key; the binding environment is already the shared state carrier for within-component coordination; scope-correct because a fresh environment is provided per component expansion |
+| 47 | Each component gets a fresh `EvalEnv` | The component's environment is installed as a scope-local `env()` provider around body expansion, so eval blocks within a component share bindings but don't leak into parent or sibling components; critical for provider isolation |
 | 48 | `output()` is a plain function, not `yield*` | Output is a synchronous side effect (mutating a ref), not an Effection operation; making it a function keeps the API simple and avoids requiring generator context just to set output text |
 | 49 | `__output` stored alongside exports in journal | Avoids a separate journal entry; `__output` is extracted before merging into `env.values` to prevent namespace pollution |
 | 50 | `renderChildren`/`render` are closures in `env.values`, not an Api | A Render Api would require middleware installation per component; closures are simpler and capture the expansion context at the injection point; they are non-serializable and silently omitted from the journal |
-| 51 | `renderChildren`/`render` use `parentEvalScope` wrapped in `EvalEnvCtx.with()` + `EvalScopeCtx.with()` | Children are caller-provided content and expand in the caller's scope context; the component's `childEvalScope` sequential channel is for its own `persist eval` blocks, not for expanding caller content; children may create resources (nested components, daemons) but their lifecycle is bound by their place in the expansion tree; wrapping ensures the correct scope is visible regardless of which task the closure runs in |
+| 51 | `renderChildren`/`render` install the caller's environment and `parentEvalScope` as scope-local providers | Children are caller-provided content and expand in the caller's scope context; the component's `childEvalScope` sequential channel is for its own `persist eval` blocks, not for expanding caller content; children may create resources (nested components, daemons) but their lifecycle is bound by their place in the expansion tree; installing providers inside the closure ensures the correct context is visible regardless of which task it runs in |
 | 52 | `durableSample` routes through `EvalScope` | Sample Api middleware installed by `persist eval` blocks (e.g., `LlamafileProvider`'s `Sample.around()`) lives in the eval scope's task hierarchy; routing through `evalScope.eval()` ensures the middleware chain is found |
 | 53 | Sample component calls `Sample.operations.sample()` directly | The enclosing eval operation journals the complete block result |
 | 54 | Sample component props default to empty string, not undefined | `validateProps` omits optional props with no default from `env.values`, causing `ReferenceError` in eval blocks; empty-string defaults ensure the variables exist; `model \|\| undefined` converts empty to undefined for routing semantics |
 | 55 | `daemon()` uses `shell: true` | Matches `bash exec` block semantics — the same command string passed to `bash -c` is passed to the shell; handles shell expansions and PATH lookups correctly |
-| 56 | Provider installs its own middleware, not a global `useLlamafileSample()` | A single global handler installed before `runDocument()` would execute in the outer scope at call time, where `EvalEnvCtx` has no `baseUrl`; middleware must close over `baseUrl` and `model` at the moment the provider becomes active |
+| 56 | Provider installs its own middleware, not a global `useLlamafileSample()` | A single global handler installed before `runDocument()` would execute in the outer scope at call time, where the binding environment has no `baseUrl`; middleware must close over `baseUrl` and `model` at the moment the provider becomes active |
 | 57 | Routing key is `model`, not a separate `name` prop | Model identity is the natural key — it unifies "which server to route to" with "which model to request"; a separate `name` prop would require keeping two values in sync with no added expressiveness |
 | 58 | `context.model === undefined` routes to innermost provider | Omitting a model is the common case for single-provider documents; innermost-wins matches how middleware chains work — handlers installed later sit higher in the chain and are traversed first |
 | 59 | `callLlamafile()` is a standard import in generated eval modules | Provider components are markdown files — eval blocks are compiled into `data:` URI modules that import executable.md globals from `@executablemd/core`; functions like `callLlamafile`, `callOllama`, `callAnthropic`, `Sample`, `findFreePort`, and `useContent` are available via this import |
@@ -4145,7 +4126,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 72 | `channel.send()` must be `yield*`'d | Ensures backpressure and cancellation safety — no text "in flight" when scope tears down; without `yield*`, buffering issues or silent cancellation may occur |
 | 73 | `DocumentExecution` with `withResolvers` | Execution is both an `Operation<string>` (`yield*` for result) and has `.output` stream for chunks; errors surface through `yield* execution` via `withResolvers` `reject()`; eliminates `Result<string>` / `unbox` in consumer code |
 | 74 | Function components receive props directly, not wrapped | `function*(props)` not `function*({ props })` — eliminates unnecessary destructuring; props are already validated by the expansion engine before the function is called |
-| 75 | `useContent()` on Effection scope, not in function args | Decouples function components from the expansion engine's API surface; leaf components don't need to ignore an `expandChildren` parameter; Effection-idiomatic — same pattern as `EvalEnvCtx`, `EvalScopeCtx`; supports named slots via `useContent("header")` |
+| 75 | `useContent()` is contextual, not a function argument | Decouples function components from the expansion engine's API surface; leaf components don't need to ignore an `expandChildren` parameter; Effection-idiomatic — same contextual pattern as `env()`/`evalScope()`; supports named slots via `useContent("header")` |
 | 76 | `.md` wins over `.ts` in resolution | Backward compatibility — existing markdown components are not shadowed by TypeScript files added later; explicit — if both exist, the human-readable markdown is preferred |
 | 77 | Function component imported on every run | The current module must execute because functions are not serialized into a trace |
 | 78 | Internal durable-streams package | Provides journaling for the core runtime |

From 35ce801e4e0d1232d904076a315976b9b083d4ba Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 18:16:43 -0400
Subject: [PATCH 6/9] fix: bridge persistent() read with ephemeral() in
 Workflow-typed test terminal

CI typechecks the test files (deno task check + tsc); the persist test's
terminal is CodeBlockWorkflow-typed, so the contextual read crosses the
Workflow/Operation seam through ephemeral(), per the bridging rule.
---
 core/tests/component-api.test.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/core/tests/component-api.test.ts b/core/tests/component-api.test.ts
index 746aa3b..3c13bb0 100644
--- a/core/tests/component-api.test.ts
+++ b/core/tests/component-api.test.ts
@@ -17,6 +17,7 @@ import {
   persistent,
   content,
 } from "../src/component-api.ts";
+import { ephemeral } from "@executablemd/durable-streams";
 import { persistFactory } from "../src/modifiers/persist.ts";
 import type { ComponentDefinition, ErrorSegment } from "../src/types.ts";
 
@@ -184,8 +185,10 @@ describe("Component Api", () => {
   it("persistent() is true inside the persist modifier chain and false outside", function* () {
     let observed: boolean | undefined = undefined;
     const middleware = persistFactory(undefined);
+    // The terminal is Workflow-typed, so the contextual read bridges
+    // through ephemeral().
     const terminal = function* () {
-      observed = yield* persistent();
+      observed = yield* ephemeral(persistent());
       return { output: "", exitCode: 0, stderr: "" };
     };
     yield* middleware([], terminal) as unknown as Operation<unknown>;

From 804ae46bdf6ce5d6c79a8a99096095be8c096187 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 19:01:06 -0400
Subject: [PATCH 7/9] review: behavioral spec, missing coverage, stateless
 generators
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- spec: replace the evalFactory, daemonFactory, and runDocument
  provider-wiring implementation snapshots with observable-behavior
  prose (§5.5 carries the public contract; DEC-012 the rationale).
- tests: nested evalScope providers override ancestors without sibling
  leakage; function component renders default + named slot through
  useContent(slot); journal-shape test also asserts the eval entry
  identity (eval:eval:root:N).
- drop the new `as unknown as Operation` assertion in the persist test
  (plain yield* typechecks).
- types.ts: projectedEnv doc refers to the contextual env() operation.
- revert unrelated deno.lock exact-version aliases.
- rule 9 (AGENTS.md): delegating generator wrappers become plain
  functions returning the operation (useContent, provideEnv,
  provideEvalScope, test helpers).
---
 AGENTS.md                             |   4 +-
 core/src/content-context.ts           |   4 +-
 core/src/expand.ts                    |   8 +-
 core/src/types.ts                     |   8 +-
 core/tests/component-api.test.ts      |  36 ++++++-
 core/tests/expand.test.ts             |  50 ++++++++--
 core/tests/named-slots.test.ts        |   4 +-
 core/tests/run-document.test.ts       |  10 +-
 core/tests/text-interpolation.test.ts |   4 +-
 deno.lock                             |   2 -
 specs/executable-mdx-spec.md          | 130 +++++---------------------
 11 files changed, 126 insertions(+), 134 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 1d7cb95..66e94e2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -33,11 +33,13 @@ Do not commit if any check fails. Fix the issue first, then re-run all three.
 7. Do not use braceless `if` statements.
 8. Keep the release spec current — changes to the release configuration
    require changes to specs/release-process-spec.md to match.
+9. Prefer stateless generators - use a function when calling a function that
+   returns an operation; Do not do this function*(arg) { return yield* generator(arg) }
 
 ## PR Process
 
 1. Use .github/pull_request_template.md
-2. After PR is open, monitor PR for 
+2. After PR is open, monitor PR for
    1. CI failures
    2. Comments with feedback
    3. Integrate changes feedback appears
diff --git a/core/src/content-context.ts b/core/src/content-context.ts
index 4aeff8b..249c387 100644
--- a/core/src/content-context.ts
+++ b/core/src/content-context.ts
@@ -21,6 +21,6 @@ import { content } from "./component-api.ts";
  * const header = yield* useContent("header");
  * ```
  */
-export function* useContent(slotName?: string): Operation<string> {
-  return yield* content(slotName);
+export function useContent(slotName?: string): Operation<string> {
+  return content(slotName);
 }
diff --git a/core/src/expand.ts b/core/src/expand.ts
index 4de6cc6..477ea7d 100644
--- a/core/src/expand.ts
+++ b/core/src/expand.ts
@@ -70,8 +70,8 @@ export function createBlockCounter(): BlockCounter {
 // override ancestors without leaking into siblings
 // ---------------------------------------------------------------------------
 
-function* provideEnv(value: EvalEnv): Operation<void> {
-  yield* Component.around(
+function provideEnv(value: EvalEnv): Operation<void> {
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *env(_args, _next) {
@@ -82,8 +82,8 @@ function* provideEnv(value: EvalEnv): Operation<void> {
   );
 }
 
-function* provideEvalScope(value: EvalScope): Operation<void> {
-  yield* Component.around(
+function provideEvalScope(value: EvalScope): Operation<void> {
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *evalScope(_args, _next) {
diff --git a/core/src/types.ts b/core/src/types.ts
index 9dfc3aa..619dfe6 100644
--- a/core/src/types.ts
+++ b/core/src/types.ts
@@ -42,10 +42,10 @@ export interface ComponentInvocation {
   selfClosing: boolean;
   /**
    * When set, expression props resolve against this env instead of the
-   * current EvalEnvCtx. Used for projected children (substituted via
-   * `<Content />`) — they carry the caller's eval env so that expression
-   * props like `{pr}` resolve in the lexical scope where the JSX was
-   * written, not the wrapping component's scope.
+   * contextual `env()` binding environment. Used for projected children
+   * (substituted via `<Content />`) — they carry the caller's eval env so
+   * that expression props like `{pr}` resolve in the lexical scope where
+   * the JSX was written, not the wrapping component's scope.
    *
    * This field is NOT part of the parsed IR — it's set at expansion time
    * by substituteContent when projecting children into <Content /> slots.
diff --git a/core/tests/component-api.test.ts b/core/tests/component-api.test.ts
index 3c13bb0..54a0e1f 100644
--- a/core/tests/component-api.test.ts
+++ b/core/tests/component-api.test.ts
@@ -18,6 +18,7 @@ import {
   content,
 } from "../src/component-api.ts";
 import { ephemeral } from "@executablemd/durable-streams";
+import { useEvalScope } from "@effectionx/scope-eval";
 import { persistFactory } from "../src/modifiers/persist.ts";
 import type { ComponentDefinition, ErrorSegment } from "../src/types.ts";
 
@@ -180,6 +181,39 @@ describe("Component Api", () => {
     expect(second).toBe(outerEnv);
   });
 
+  it("nested evalScope providers override ancestors without leaking into siblings", function* () {
+    const outerScope = yield* useEvalScope();
+    const innerScope = yield* useEvalScope();
+    yield* Component.around(
+      {
+        // deno-lint-ignore require-yield
+        *evalScope(_args, _next) {
+          return outerScope;
+        },
+      },
+      { at: "min" },
+    );
+
+    const first = yield* scoped(function* () {
+      yield* Component.around(
+        {
+          // deno-lint-ignore require-yield
+          *evalScope(_args, _next) {
+            return innerScope;
+          },
+        },
+        { at: "min" },
+      );
+      return yield* evalScope();
+    });
+    expect(first).toBe(innerScope);
+
+    const second = yield* scoped(function* () {
+      return yield* evalScope();
+    });
+    expect(second).toBe(outerScope);
+  });
+
   // ----- Persistent evaluation flag -----
 
   it("persistent() is true inside the persist modifier chain and false outside", function* () {
@@ -191,7 +225,7 @@ describe("Component Api", () => {
       observed = yield* ephemeral(persistent());
       return { output: "", exitCode: 0, stderr: "" };
     };
-    yield* middleware([], terminal) as unknown as Operation<unknown>;
+    yield* middleware([], terminal);
     expect(observed).toBe(true);
     expect(yield* persistent()).toBe(false);
   });
diff --git a/core/tests/expand.test.ts b/core/tests/expand.test.ts
index 0da4e82..f04975c 100644
--- a/core/tests/expand.test.ts
+++ b/core/tests/expand.test.ts
@@ -8,8 +8,16 @@ import { interpolate } from "../src/interpolate.ts";
 import { validateProps, PropValidationError } from "../src/validate.ts";
 import { renderSegments } from "../src/render.ts";
 import type { Operation } from "effection";
+import { ephemeral } from "@executablemd/durable-streams";
+import { useContent } from "../src/content-context.ts";
 import type { EvalEnv } from "../src/eval-env.ts";
-import type { Segment, ComponentDefinition, Json, CodeBlockResult } from "../src/types.ts";
+import type {
+  Segment,
+  ComponentDefinition,
+  FunctionComponentDefinition,
+  Json,
+  CodeBlockResult,
+} from "../src/types.ts";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -34,11 +42,11 @@ function makeComponent(
 }
 
 /** Install test component + modifier providers on the current scope. */
-function* useTestComponents(
-  components: Record<string, ComponentDefinition>,
+function useTestComponents(
+  components: Record<string, ComponentDefinition | FunctionComponentDefinition>,
   codeResult?: CodeBlockResult,
 ): Operation<void> {
-  yield* Component.around(
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *importComponent([name], _next) {
@@ -64,8 +72,8 @@ function* useTestComponents(
 }
 
 /** Install a binding environment on the current scope. */
-function* useTestEnv(testEnv: EvalEnv): Operation<void> {
-  yield* Component.around(
+function useTestEnv(testEnv: EvalEnv): Operation<void> {
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *env(_args, _next) {
@@ -78,7 +86,7 @@ function* useTestEnv(testEnv: EvalEnv): Operation<void> {
 
 function expand(
   segments: Segment[],
-  components: Record<string, ComponentDefinition>,
+  components: Record<string, ComponentDefinition | FunctionComponentDefinition>,
   opts: {
     meta?: Record<string, unknown>;
     props?: Record<string, Json>;
@@ -95,7 +103,7 @@ function expand(
 
 function expandWithEnv(
   segments: Segment[],
-  components: Record<string, ComponentDefinition>,
+  components: Record<string, ComponentDefinition | FunctionComponentDefinition>,
   codeResult?: CodeBlockResult,
 ): Operation<{ output: string; env: Record<string, unknown> }> {
   return scoped(function* () {
@@ -415,7 +423,7 @@ function* useRecordingModifiers(codeResult?: CodeBlockResult): Operation<string[
 
 function recordingExpand(
   segments: Segment[],
-  components: Record<string, ComponentDefinition>,
+  components: Record<string, ComponentDefinition | FunctionComponentDefinition>,
   codeResult?: CodeBlockResult,
 ): Operation<{ output: string; execCalls: string[] }> {
   return scoped(function* () {
@@ -790,3 +798,27 @@ describe("interpolate", () => {
     expect(interpolate("\\{meta.title}", { title: "Hello" }, {})).toBe("{meta.title}");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Function-component content through the contextual content() operation
+// ---------------------------------------------------------------------------
+
+describe("function component content", () => {
+  it("renders default content and a named slot via useContent", function* () {
+    const card: FunctionComponentDefinition = {
+      kind: "function",
+      name: "Card",
+      path: "components/Card.ts",
+      inputs: {},
+      *fn(_props) {
+        const header = yield* ephemeral(useContent("header"));
+        const body = yield* ephemeral(useContent());
+        return `[${header.trim()}|${body.trim()}]`;
+      },
+    };
+    const note = makeComponent("Note", "HEADER");
+    const segments = scanSegments('<Card>\n<Note slot="header" />\nBODY\n</Card>');
+    const output = yield* expand(segments, { Card: card, Note: note });
+    expect(output).toBe("[HEADER|BODY]");
+  });
+});
diff --git a/core/tests/named-slots.test.ts b/core/tests/named-slots.test.ts
index 7bc3969..30c926c 100644
--- a/core/tests/named-slots.test.ts
+++ b/core/tests/named-slots.test.ts
@@ -49,11 +49,11 @@ function makeComponent(
 }
 
 /** Install test component + modifier providers on the current scope. */
-function* useTestComponents(
+function useTestComponents(
   components: Record<string, ComponentDefinition>,
   codeResult?: CodeBlockResult,
 ): Operation<void> {
-  yield* Component.around(
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *importComponent([name], _next) {
diff --git a/core/tests/run-document.test.ts b/core/tests/run-document.test.ts
index 7daec87..df92247 100644
--- a/core/tests/run-document.test.ts
+++ b/core/tests/run-document.test.ts
@@ -1009,10 +1009,10 @@ describe("runDocument", () => {
 // ---------------------------------------------------------------------------
 
 describe("Component Api dispatch — journal shape", () => {
-  it("import and exec journal entries keep their identities", function* () {
+  it("import, exec, and eval journal entries keep their identities", function* () {
     const stream = new InMemoryStream();
     yield* useStubFs({
-      "README.md": "<Note />\n\n```bash exec\necho hi\n```\n",
+      "README.md": "<Note />\n\n```bash exec\necho hi\n```\n\n```js eval\nconst x = 1;\n```\n",
       "components/Note.md": "note!\n",
     });
     yield* useStubExec();
@@ -1031,6 +1031,12 @@ describe("Component Api dispatch — journal shape", () => {
       e.type === "yield" && e.description.type === "exec" ? [e] : [],
     );
     expect(execs.length).toBe(1);
+
+    const evals = events.flatMap((e) =>
+      e.type === "yield" && e.description.type === "eval" ? [e.description.name] : [],
+    );
+    expect(evals.length).toBe(1);
+    expect(String(evals[0])).toMatch(/^eval:eval:root:\d+$/);
   });
 });
 
diff --git a/core/tests/text-interpolation.test.ts b/core/tests/text-interpolation.test.ts
index e73def4..cc3360b 100644
--- a/core/tests/text-interpolation.test.ts
+++ b/core/tests/text-interpolation.test.ts
@@ -45,11 +45,11 @@ function makeComponent(
 }
 
 /** Install test component + modifier providers on the current scope. */
-function* useTestComponents(
+function useTestComponents(
   components: Record<string, ComponentDefinition>,
   codeResult?: CodeBlockResult,
 ): Operation<void> {
-  yield* Component.around(
+  return Component.around(
     {
       // deno-lint-ignore require-yield
       *importComponent([name], _next) {
diff --git a/deno.lock b/deno.lock
index 358048b..fd8c702 100644
--- a/deno.lock
+++ b/deno.lock
@@ -74,10 +74,8 @@
     "npm:marked@^17.0.4": "17.0.4",
     "npm:mdast-util-to-string@4": "4.0.0",
     "npm:oxfmt@0.41": "0.41.0",
-    "npm:oxfmt@0.41.0": "0.41.0",
     "npm:oxlint-tsgolint@0.17": "0.17.4",
     "npm:oxlint@1": "1.56.0_oxlint-tsgolint@0.17.4",
-    "npm:oxlint@1.56.0": "1.56.0_oxlint-tsgolint@0.17.4",
     "npm:preact-render-to-string@^6.6.3": "6.7.0_preact@10.29.7",
     "npm:preact@^10.28.2": "10.29.7_preact-render-to-string@6.7.0",
     "npm:preact@^10.29.1": "10.29.7_preact-render-to-string@6.7.0",
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index a1b18b3..a1eacba 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -488,72 +488,20 @@ within a component via a binding environment (see §4).
 Eval blocks produce **no rendered output by default**. They can
 optionally produce output via the `output()` function (see §4.7).
 
-```typescript
-export const evalFactory: ModifierFactory = (_params) =>
-  (_args, _next) => (function* () {
-    const ctx = yield* useCodeBlock();
-    // Contextual reads (§5.5), bridged with ephemeral() because this
-    // handler is Workflow-typed.
-    const evalEnv = yield* ephemeral(env());
-    const persist = yield* ephemeral(persistent());
-
-    // Inject output() function into env so eval blocks can produce
-    // rendered output. The mutable ref is block-local; serializeExports
-    // silently omits non-JSON values (functions), so output won't
-    // pollute the journal. The output text itself is journaled alongside
-    // exports as __output.
-    const outputRef = { text: "" };
-    evalEnv.values.output = (text: string) => { outputRef.text = String(text); };
-
-    const transformed = transformBlock(
-      ctx.content,
-      ctx.blockId,
-      Object.keys(evalEnv.values),
-    );
-
-    const bindings = serializeExports(evalEnv.values, transformed.imports);
-    const result = yield createDurableOperation(
-      { type: "eval", name: `eval:${ctx.blockId}`, language: ctx.language },
-      function* () {
-        Object.assign(evalEnv.values, bindings);
-        const fn = yield* compileBlock(source, transformed.userImports ?? []);
-
-        if (persist) {
-          // The component eval scope is read contextually (§5.5).
-          const scope = yield* evalScope();
-          const blockResult = yield* scope.eval(
-            () => fn(evalEnv.values) as unknown as Operation<void>,
-          );
-          unbox(blockResult);
-        } else {
-          yield* fn(evalEnv.values) as unknown as Operation<void>;
-        }
-
-        const exports = serializeExports(evalEnv.values, transformed.exports);
-
-        // Record output text alongside exports.
-        if (outputRef.text) {
-          (exports as Record<string, unknown>).__output = outputRef.text;
-        }
-
-        return exports as unknown as Json;
-      },
-    );
-
-    // Merge serializable exports into the current environment.
-    if (result.value && typeof result.value === "object") {
-      const restored = result.value as Record<string, unknown>;
-      // Extract __output before merging into env
-      if (typeof restored.__output === "string") {
-        outputRef.text = restored.__output;
-      }
-      const { __output: _, ...exports } = restored;
-      Object.assign(evalEnv.values, exports);
-    }
-
-    return { output: outputRef.text, exitCode: 0, stderr: "" };
-  })();
-```
+Observable behavior of an `eval` block:
+
+- The block and its binding environment are read contextually (§5.5);
+  running an eval block without an environment in scope is a clear error.
+- Execution is journaled as one `eval` entry named after the block id.
+  The JSON-serializable exports (plus the `__output` text, §4.7) are
+  stored in the entry; on replay they are restored into the environment
+  without re-executing the block.
+- New bindings the block exports merge into the shared environment, so
+  later blocks in the same component can read them.
+- Under `persist`, only the compiled block runs inside the component
+  eval scope (§4.4), so resources it spawns outlive the block.
+- The block's rendered output is the `output()` text, or the coerced
+  return value when `output()` was not called (§4.7).
 
 **`daemon`** — spawns a long-running subprocess and immediately
 returns control to the document. The process is alive for the
@@ -585,38 +533,14 @@ and signals to readers that this block runs a command.
 | Lifetime | Until command exits | Until component scope closes |
 | Repeated-run behavior | Spawns a fresh subprocess every run | Spawns a fresh subprocess every run |
 
-```typescript
-import { daemon } from "@effectionx/process";
+Observable behavior of a `daemon` block:
 
-export const daemonFactory: ModifierFactory = (_params) =>
-  (_args, _next) => (function* () {
-    const ctx = yield* useCodeBlock();
-
-    // Bridge from Workflow (durable) to Operation (ephemeral) —
-    // daemon produces no journal entry, so all its effects are ephemeral.
-    const launchDaemon = {
-      *[Symbol.iterator]() {
-        const scope = yield* evalScope();
-
-        // ctx.content is already interpolated by the expansion engine
-        // before the modifier chain runs — no interpolation needed here.
-        const commandParts = buildCommand(ctx.language, ctx.content);
-        const commandStr = commandParts.join(" ");
-
-        // Fork into eval scope — lifetime tied to component expansion.
-        // daemon() never resolves. If the process exits prematurely,
-        // daemon() throws DaemonExitError, propagating to the eval scope.
-        yield* scope.eval(function* () {
-          yield* daemon(commandStr);
-        });
-      },
-    };
-    yield* ephemeral(launchDaemon);
-
-    // Control returns here immediately after the fork.
-    return { output: "", exitCode: 0, stderr: "" };
-  })();
-```
+- The block's command (its content, already interpolated by the
+  expansion engine) is forked into the component eval scope (§4.4);
+  running a daemon block without an eval scope in scope is a clear
+  error.
+- The block produces no journal entry and no rendered output — control
+  returns to the document immediately after the fork.
 
 **Process lifetime.** The forked task calls `daemon(command)` from
 `@effectionx/process`. `daemon` spawns the process and suspends
@@ -3074,15 +2998,11 @@ function* runDocument(options: RunDocumentOptions): Operation<DocumentExecution>
     });
     yield* useDirectoryResolver(componentDirs);
 
-    // Create eval scope before the journaled document workflow (§4.4),
-    // then install the document's Component providers (§5.5) so the
-    // workflow inherits import, modifier execution, and the root eval
-    // scope contextually.
+    // Create eval scope before the journaled document workflow (§4.4).
+    // The document's Component providers — import, modifier execution,
+    // and this eval scope — are installed here so the workflow inherits
+    // them contextually (§5.5).
     const rootEvalScope = yield* resource(useEvalScope());
-    yield* Component.around(
-      { importComponent, applyModifiers, evalScope: () => rootEvalScope },
-      { at: "min" },
-    );
 
     // Install built-in modifier handlers (exec, silent, sample, eval, persist, timeout)
     yield* useBuiltinModifiers();

From eb77e2da4961f57bfef506dcd2cecd1776cf3c54 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 19:17:14 -0400
Subject: [PATCH 8/9] review: value operations, errors.ts, inline-annotation
 cleanups
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Address the plannotator inline annotations:

- env, evalScope, and persistent become Component value operations —
  read without invocation (yield* env); providers are plain arrows
  returning the value (env: () => componentEnv). codeBlock/content
  stay functions (throwing defaults / slot argument).
- error-policy.ts renamed to errors.ts with the header trimmed;
  EvalEnv moves into types.ts and eval-env.ts is deleted.
- compileBlock and the renderChildren/render closures become stateless
  (rule 9); the dead DocumentationError guard on the import catch is
  removed; the new section separators in expand.ts are dropped; the
  pre-existing daemon.test cast is removed (plain yield* typechecks).
- min placement for providers and evalScope's home on Component stay
  as-is per review discussion (innermost-min-first is what lets nested
  components shadow ancestors; max remains free for wrapping
  middleware).
- spec: §5.5 documents the value-operation form; §4.3/§4.4 and the
  persist sections use the value notation; file table updated.
---
 core/mod.ts                           |  2 +-
 core/src/component-api.ts             | 23 +++-------
 core/src/error-policy.ts              | 22 ----------
 core/src/errors.ts                    | 16 +++++++
 core/src/eval-context.ts              |  4 +-
 core/src/eval-env.ts                  | 19 --------
 core/src/eval-handler.ts              |  6 +--
 core/src/expand.ts                    | 62 +++++++--------------------
 core/src/modifiers/daemon.ts          |  4 +-
 core/src/modifiers/persist.ts         | 14 ++----
 core/src/run-document.ts              | 17 ++------
 core/src/types.ts                     |  9 ++++
 core/tests/component-api.test.ts      | 60 ++++++--------------------
 core/tests/daemon.test.ts             |  2 +-
 core/tests/expand.test.ts             | 12 +-----
 core/tests/text-interpolation.test.ts | 15 +------
 specs/decisions.md                    |  2 +-
 specs/executable-mdx-spec.md          | 33 +++++++-------
 18 files changed, 99 insertions(+), 223 deletions(-)
 delete mode 100644 core/src/error-policy.ts
 create mode 100644 core/src/errors.ts
 delete mode 100644 core/src/eval-env.ts

diff --git a/core/mod.ts b/core/mod.ts
index 0871a0b..bbe4c5e 100644
--- a/core/mod.ts
+++ b/core/mod.ts
@@ -62,7 +62,7 @@ export {
 // Eval system (generator eval blocks)
 // ---------------------------------------------------------------------------
 
-export type { EvalEnv } from "./src/eval-env.ts";
+export type { EvalEnv } from "./src/types.ts";
 
 export { compileBlock } from "./src/eval-context.ts";
 
diff --git a/core/src/component-api.ts b/core/src/component-api.ts
index 3e82333..321263c 100644
--- a/core/src/component-api.ts
+++ b/core/src/component-api.ts
@@ -21,10 +21,10 @@ import type {
   CodeBlockResult,
   ComponentDefinition,
   ErrorSegment,
+  EvalEnv,
   FunctionComponentDefinition,
   Modifier,
 } from "./types.ts";
-import type { EvalEnv } from "./eval-env.ts";
 
 export interface ComponentApi {
   /** `"__root__"` imports the root document. */
@@ -36,11 +36,11 @@ export interface ComponentApi {
    * install middleware that throws instead (spec §6.9).
    */
   raise(error: ErrorSegment): Operation<ErrorSegment>;
-  env(): Operation<EvalEnv | undefined>;
-  evalScope(): Operation<EvalScope | undefined>;
+  env: EvalEnv | undefined;
+  evalScope: EvalScope | undefined;
   codeBlock(): Operation<CodeBlockContext>;
   /** Whether the current block runs with persistent resource lifetime. */
-  persistent(): Operation<boolean>;
+  persistent: boolean;
   /** Render the invoking component's children (optionally a named slot). */
   content(slot?: string): Operation<string>;
 }
@@ -64,24 +64,15 @@ export const Component = createApi<ComponentApi>("Component", {
   *raise(error: ErrorSegment): Operation<ErrorSegment> {
     return error;
   },
-  // deno-lint-ignore require-yield
-  *env(): Operation<EvalEnv | undefined> {
-    return undefined;
-  },
-  // deno-lint-ignore require-yield
-  *evalScope(): Operation<EvalScope | undefined> {
-    return undefined;
-  },
+  env: undefined,
+  evalScope: undefined,
   // deno-lint-ignore require-yield
   *codeBlock(): Operation<CodeBlockContext> {
     throw new Error(
       "Component.codeBlock() has no provider: no code block is executing in this scope.",
     );
   },
-  // deno-lint-ignore require-yield
-  *persistent(): Operation<boolean> {
-    return false;
-  },
+  persistent: false,
   // deno-lint-ignore require-yield
   *content(_slot?: string): Operation<string> {
     throw new Error(
diff --git a/core/src/error-policy.ts b/core/src/error-policy.ts
deleted file mode 100644
index 96ae9bf..0000000
--- a/core/src/error-policy.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Documentation failure marker (spec §6.9).
- *
- * Error policy is contextual middleware on `Component.operations.raise`:
- * suppressed documentation installs a throwing implementation, output
- * regions install a collecting one that shadows it. DocumentationError is
- * the internal throwable those middlewares use — generic error handling in
- * the engine rethrows it instead of converting it into an ErrorSegment, so
- * documentation fail-fast is never swallowed.
- */
-
-import type { ErrorSegment } from "./types.ts";
-
-export class DocumentationError extends Error {
-  readonly segment: ErrorSegment;
-
-  constructor(segment: ErrorSegment) {
-    super(segment.message);
-    this.name = "DocumentationError";
-    this.segment = segment;
-  }
-}
diff --git a/core/src/errors.ts b/core/src/errors.ts
new file mode 100644
index 0000000..92e51f7
--- /dev/null
+++ b/core/src/errors.ts
@@ -0,0 +1,16 @@
+import type { ErrorSegment } from "./types.ts";
+
+/**
+ * Thrown by suppressed-documentation raise middleware (spec §6.9). Generic
+ * catches in the engine rethrow it instead of converting it into an
+ * ErrorSegment, so documentation fail-fast is never swallowed.
+ */
+export class DocumentationError extends Error {
+  readonly segment: ErrorSegment;
+
+  constructor(segment: ErrorSegment) {
+    super(segment.message);
+    this.name = "DocumentationError";
+    this.segment = segment;
+  }
+}
diff --git a/core/src/eval-context.ts b/core/src/eval-context.ts
index 56cf0ae..0c77c83 100644
--- a/core/src/eval-context.ts
+++ b/core/src/eval-context.ts
@@ -11,9 +11,9 @@ import { compile as runtimeCompile } from "@executablemd/runtime";
  * Delegates to `@executablemd/runtime` so platform-specific
  * compilation can be provided via API.Compiler middleware.
  */
-export function* compileBlock(
+export function compileBlock(
   transformedBodyCode: string,
   userImports: string[],
 ): Operation<(env: Record<string, unknown>) => Generator<unknown, unknown, unknown>> {
-  return yield* runtimeCompile(transformedBodyCode, { imports: userImports });
+  return runtimeCompile(transformedBodyCode, { imports: userImports });
 }
diff --git a/core/src/eval-env.ts b/core/src/eval-env.ts
deleted file mode 100644
index 0394958..0000000
--- a/core/src/eval-env.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Eval environment — shared binding environment for generator eval blocks
- * (spec generator-eval-spec.md §3.2).
- *
- * The current environment and eval scope are delivered contextually via the
- * Component Api (`Component.operations.env()` / `Component.operations.evalScope()`),
- * installed as scope-local middleware by the expansion engine.
- */
-
-/**
- * Shared binding environment for eval blocks within a single component.
- *
- * Created fresh at the start of component expansion. Each eval block
- * reads bindings from `values` (via env preamble) and writes new
- * bindings back (via env-write transforms).
- */
-export interface EvalEnv {
-  values: Record<string, unknown>;
-}
diff --git a/core/src/eval-handler.ts b/core/src/eval-handler.ts
index 73344ec..c339ce6 100644
--- a/core/src/eval-handler.ts
+++ b/core/src/eval-handler.ts
@@ -15,13 +15,13 @@ import { transformBlock, serializeExports } from "./eval-transform.ts";
 export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
   (function* () {
     const ctx = yield* useCodeBlock();
-    const evalEnv = yield* ephemeral(env());
+    const evalEnv = yield* ephemeral(env);
     if (!evalEnv) {
       throw new Error(
         `eval block "${ctx.blockId}" requires a binding environment; none is in scope.`,
       );
     }
-    const persist = yield* ephemeral(persistent());
+    const persist = yield* ephemeral(persistent);
 
     // Inject output() function into env so eval blocks can produce
     // rendered output. The function is a plain synchronous call:
@@ -56,7 +56,7 @@ export const evalFactory: ModifierFactory = (_params) => (_args, _next) =>
         if (persist) {
           // Persist mode: run the compiled block inside the eval scope
           // so spawned resources are retained in the persistent EvalScope.
-          const scope = yield* evalScope();
+          const scope = yield* evalScope;
           if (!scope) {
             throw new Error(
               `persist eval block "${ctx.blockId}" requires a component eval scope; none is in scope.`,
diff --git a/core/src/expand.ts b/core/src/expand.ts
index 477ea7d..a98558a 100644
--- a/core/src/expand.ts
+++ b/core/src/expand.ts
@@ -21,13 +21,13 @@ import type {
   ErrorSegment,
   ComponentInvocation,
   ComponentDefinition,
+  EvalEnv,
   FunctionComponentDefinition,
   Json,
   CodeBlockContext,
 } from "./types.ts";
 import { interpolate } from "./interpolate.ts";
 import { interpolateEvalBindings } from "./eval-interpolate.ts";
-import type { EvalEnv } from "./eval-env.ts";
 import {
   Component,
   applyModifiers,
@@ -36,7 +36,7 @@ import {
   importComponent,
   raise,
 } from "./component-api.ts";
-import { DocumentationError } from "./error-policy.ts";
+import { DocumentationError } from "./errors.ts";
 import { useEvalScope, unbox } from "@effectionx/scope-eval";
 import type { EvalScope } from "@effectionx/scope-eval";
 import { validateProps } from "./validate.ts";
@@ -65,33 +65,14 @@ export function createBlockCounter(): BlockCounter {
   return { next: () => id++ };
 }
 
-// ---------------------------------------------------------------------------
-// Scope-local providers — installed inside scoped() so nested components
-// override ancestors without leaking into siblings
-// ---------------------------------------------------------------------------
-
+// Providers install at "min" inside scoped() so nested components override
+// ancestors (innermost min runs first) without leaking into siblings.
 function provideEnv(value: EvalEnv): Operation<void> {
-  return Component.around(
-    {
-      // deno-lint-ignore require-yield
-      *env(_args, _next) {
-        return value;
-      },
-    },
-    { at: "min" },
-  );
+  return Component.around({ env: () => value }, { at: "min" });
 }
 
 function provideEvalScope(value: EvalScope): Operation<void> {
-  return Component.around(
-    {
-      // deno-lint-ignore require-yield
-      *evalScope(_args, _next) {
-        return value;
-      },
-    },
-    { at: "min" },
-  );
+  return Component.around({ evalScope: () => value }, { at: "min" });
 }
 
 // ---------------------------------------------------------------------------
@@ -132,7 +113,7 @@ export function* expandSegments(
         // Interpolate bare {name} refs from eval bindings (spec §6.4/§6.6).
         // Runs after meta/props interpolation so component contract takes
         // precedence. Only runs when a binding environment is in scope.
-        const textEvalEnv = yield* env();
+        const textEvalEnv = yield* env;
         const final = textEvalEnv
           ? interpolateEvalBindings(interpolated, textEvalEnv.values)
           : interpolated;
@@ -193,7 +174,7 @@ export function* expandSegments(
         // Skip interpolation for eval blocks — they access bindings directly
         // via the env preamble (const { name } = env;). Interpolating would
         // mangle JS template literals like `${name}` into `$<value>`.
-        const evalEnv = yield* env();
+        const evalEnv = yield* env;
         const lastModifier = segment.modifiers[segment.modifiers.length - 1];
         const isEvalTerminal = lastModifier !== undefined && lastModifier.name === "eval";
         const interpolatedContent =
@@ -354,7 +335,7 @@ function* expandCapture(
     }
   }
 
-  const bindingEnv = yield* env();
+  const bindingEnv = yield* env;
   if (!bindingEnv) {
     return {
       type: "error",
@@ -404,9 +385,6 @@ function* expandComponent(
   try {
     imported = yield* importComponent(name);
   } catch (error) {
-    if (error instanceof DocumentationError) {
-      throw error;
-    }
     return [
       yield* raise({
         type: "error",
@@ -503,7 +481,7 @@ function* expandComponent(
   // the projectedEnv from the outer caller must be merged with the current
   // context env so that ancestor bindings propagate through all levels.
   // The current context env's bindings take precedence (innermost-wins).
-  const contextEnv = yield* env();
+  const contextEnv = yield* env;
   const callerEvalEnv = projectedEnv
     ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
     : contextEnv;
@@ -527,7 +505,7 @@ function* expandComponent(
   // By creating it via parentEvalScope.eval(), the child's spawned task
   // lives inside the parent's scope — Effection's scope prototype chain
   // ensures scope.reduce() walks child → parent when resolving middleware.
-  const parentEvalScope = yield* evalScope();
+  const parentEvalScope = yield* evalScope;
   let childEvalScope: EvalScope | undefined = undefined;
   if (parentEvalScope) {
     const result = yield* parentEvalScope.eval(() => useEvalScope());
@@ -590,13 +568,9 @@ function* expandComponent(
       return renderSegments(expanded);
     });
 
-  componentEnv.values.renderChildren = function* () {
-    return yield* renderInCallerScope(children);
-  };
+  componentEnv.values.renderChildren = () => renderInCallerScope(children);
 
-  componentEnv.values.render = function* (markdown: string) {
-    return yield* renderInCallerScope(scanSegments(markdown));
-  };
+  componentEnv.values.render = (markdown: string) => renderInCallerScope(scanSegments(markdown));
 
   const expanded = yield* scoped(function* () {
     yield* provideEnv(componentEnv);
@@ -615,7 +589,7 @@ function* expandComponent(
   });
 
   if (asBinding) {
-    const parentEnv = yield* env();
+    const parentEnv = yield* env;
     if (!parentEnv) {
       return [
         yield* raise({
@@ -738,7 +712,7 @@ function* expandFunctionComponent(
       return yield* definition.fn(validatedProps);
     });
     if (asBinding) {
-      const parentEnv = yield* env();
+      const parentEnv = yield* env;
       if (!parentEnv) {
         return [
           yield* raise({
@@ -825,7 +799,7 @@ function* resolveExpressionProps(
     return resolved;
   }
 
-  const contextEnv = yield* env();
+  const contextEnv = yield* env;
 
   // For projected children (substituted via <Content />), merge the
   // caller's env (explicitEnv) with the wrapping component's env
@@ -1083,10 +1057,6 @@ function substituteContent(
   return substituteSegmentList(bodySegments, slots, meta, props, project, state);
 }
 
-// ---------------------------------------------------------------------------
-// Component-declared output: <Output> (spec §6.9)
-// ---------------------------------------------------------------------------
-
 interface BodyChunk {
   /** true = a rendered `<Output>` region; false = documentation (executed, not rendered). */
   output: boolean;
diff --git a/core/src/modifiers/daemon.ts b/core/src/modifiers/daemon.ts
index 39c61e9..cebba24 100644
--- a/core/src/modifiers/daemon.ts
+++ b/core/src/modifiers/daemon.ts
@@ -26,7 +26,7 @@ import { evalScope } from "../component-api.ts";
  *
  * Ignores `next` — this is the terminal handler (like `exec` and `eval`).
  * Reads code block metadata via useCodeBlock() and the eval scope via
- * Component.evalScope().
+ * the contextual `evalScope` value.
  *
  * The block's content (already interpolated with eval bindings by the
  * expansion engine) is used to build the subprocess command. The command
@@ -46,7 +46,7 @@ export const daemonFactory: ModifierFactory = (_params) => (_args, _next) =>
     // daemon produces no journal entry, so all its effects are ephemeral.
     const launchDaemon = {
       *[Symbol.iterator]() {
-        const scope = yield* evalScope();
+        const scope = yield* evalScope;
         if (!scope) {
           throw new Error("daemon requires a component eval scope; none is in scope.");
         }
diff --git a/core/src/modifiers/persist.ts b/core/src/modifiers/persist.ts
index 07a52d2..23d62d9 100644
--- a/core/src/modifiers/persist.ts
+++ b/core/src/modifiers/persist.ts
@@ -8,7 +8,7 @@
  * evalScope.eval(), which retains spawned resources in the persistent
  * EvalScope until the component finishes expanding.
  *
- * Implementation: persist installs Component.persistent() middleware that
+ * Implementation: persist installs the contextual `persistent` value middleware that
  * the eval handler reads. The eval handler then runs fn(env) inside
  * evalScope.eval() instead of directly. This avoids wrapping the entire
  * modifier chain (which includes durable effects that can't cross the
@@ -27,7 +27,7 @@ import { Component } from "../component-api.ts";
 /**
  * Wrapping modifier that marks a block for persistent resource lifetime.
  *
- * Makes Component.persistent() answer true for the duration of the inner
+ * Makes the contextual `persistent` value answer true for the duration of the inner
  * chain. The eval handler reads this and routes the compiled block
  * execution through evalScope.eval() for resource retention.
  */
@@ -35,15 +35,7 @@ export const persistFactory: ModifierFactory = (_params) => (_args, next) =>
   (function* () {
     return yield* ephemeral(
       scoped(function* () {
-        yield* Component.around(
-          {
-            // deno-lint-ignore require-yield
-            *persistent(_args, _next) {
-              return true;
-            },
-          },
-          { at: "min" },
-        );
+        yield* Component.around({ persistent: () => true }, { at: "min" });
         return yield* next() as unknown as import("effection").Operation<
           import("../types.ts").CodeBlockResult
         >;
diff --git a/core/src/run-document.ts b/core/src/run-document.ts
index 1dd0776..ba2feb2 100644
--- a/core/src/run-document.ts
+++ b/core/src/run-document.ts
@@ -50,7 +50,7 @@ import { evalFactory } from "./eval-handler.ts";
 import { persistFactory } from "./modifiers/persist.ts";
 import { timeoutFactory } from "./modifiers/timeout.ts";
 import { daemonFactory } from "./modifiers/daemon.ts";
-import type { EvalEnv } from "./eval-env.ts";
+import type { EvalEnv } from "./types.ts";
 import { useEvalScope } from "@effectionx/scope-eval";
 import { Stdio } from "@effectionx/process";
 
@@ -272,15 +272,7 @@ function* documentWorkflow(): Workflow<string> {
   // `persist` blocks are retained in the eval scope until expansion
   // completes, then torn down.
   const scopedExpansion: Operation<string> = scoped(function* () {
-    yield* Component.around(
-      {
-        // deno-lint-ignore require-yield
-        *env(_args, _next) {
-          return rootEnv;
-        },
-      },
-      { at: "min" },
-    );
+    yield* Component.around({ env: () => rootEnv }, { at: "min" });
     // Structural preflight (spec §6.9): a root with misplaced <Output>
     // executes no body side effects; the aggregate diagnostic renders as a
     // comment (root policy is "collect").
@@ -472,10 +464,7 @@ export function* runDocument(options: RunDocumentOptions): Operation<DocumentExe
           const chain = composeModifierChain(modifiers, context, registry);
           return yield* chain();
         },
-        // deno-lint-ignore require-yield
-        *evalScope(_args, _next) {
-          return rootEvalScope;
-        },
+        evalScope: () => rootEvalScope,
       },
       { at: "min" },
     );
diff --git a/core/src/types.ts b/core/src/types.ts
index 619dfe6..534ae60 100644
--- a/core/src/types.ts
+++ b/core/src/types.ts
@@ -79,6 +79,15 @@ export interface ExecResult {
   stderr: string;
 }
 
+/**
+ * Shared binding environment for eval blocks within a single component
+ * (spec §4.3). Created fresh at the start of component expansion; read
+ * contextually via the Component `env` operation.
+ */
+export interface EvalEnv {
+  values: Record<string, unknown>;
+}
+
 // ---------------------------------------------------------------------------
 // Modifier system (spec §3.2–3.5)
 // ---------------------------------------------------------------------------
diff --git a/core/tests/component-api.test.ts b/core/tests/component-api.test.ts
index 54a0e1f..70fbdb5 100644
--- a/core/tests/component-api.test.ts
+++ b/core/tests/component-api.test.ts
@@ -70,9 +70,9 @@ describe("Component Api", () => {
   });
 
   it("env and evalScope default to undefined; persistent defaults to false", function* () {
-    expect(yield* env()).toBe(undefined);
-    expect(yield* evalScope()).toBe(undefined);
-    expect(yield* persistent()).toBe(false);
+    expect(yield* env).toBe(undefined);
+    expect(yield* evalScope).toBe(undefined);
+    expect(yield* persistent).toBe(false);
   });
 
   // ----- Scoped overrides -----
@@ -150,33 +150,17 @@ describe("Component Api", () => {
   it("nested env providers override ancestors without leaking into siblings", function* () {
     const outerEnv = { values: { tag: "outer" } };
     const innerEnv = { values: { tag: "inner" } };
-    yield* Component.around(
-      {
-        // deno-lint-ignore require-yield
-        *env(_args, _next) {
-          return outerEnv;
-        },
-      },
-      { at: "min" },
-    );
+    yield* Component.around({ env: () => outerEnv }, { at: "min" });
 
     const first = yield* scoped(function* () {
-      yield* Component.around(
-        {
-          // deno-lint-ignore require-yield
-          *env(_args, _next) {
-            return innerEnv;
-          },
-        },
-        { at: "min" },
-      );
-      return yield* env();
+      yield* Component.around({ env: () => innerEnv }, { at: "min" });
+      return yield* env;
     });
     expect(first).toBe(innerEnv);
 
     // A sibling scope sees the ancestor provider, not the first sibling's.
     const second = yield* scoped(function* () {
-      return yield* env();
+      return yield* env;
     });
     expect(second).toBe(outerEnv);
   });
@@ -184,50 +168,34 @@ describe("Component Api", () => {
   it("nested evalScope providers override ancestors without leaking into siblings", function* () {
     const outerScope = yield* useEvalScope();
     const innerScope = yield* useEvalScope();
-    yield* Component.around(
-      {
-        // deno-lint-ignore require-yield
-        *evalScope(_args, _next) {
-          return outerScope;
-        },
-      },
-      { at: "min" },
-    );
+    yield* Component.around({ evalScope: () => outerScope }, { at: "min" });
 
     const first = yield* scoped(function* () {
-      yield* Component.around(
-        {
-          // deno-lint-ignore require-yield
-          *evalScope(_args, _next) {
-            return innerScope;
-          },
-        },
-        { at: "min" },
-      );
-      return yield* evalScope();
+      yield* Component.around({ evalScope: () => innerScope }, { at: "min" });
+      return yield* evalScope;
     });
     expect(first).toBe(innerScope);
 
     const second = yield* scoped(function* () {
-      return yield* evalScope();
+      return yield* evalScope;
     });
     expect(second).toBe(outerScope);
   });
 
   // ----- Persistent evaluation flag -----
 
-  it("persistent() is true inside the persist modifier chain and false outside", function* () {
+  it("persistent is true inside the persist modifier chain and false outside", function* () {
     let observed: boolean | undefined = undefined;
     const middleware = persistFactory(undefined);
     // The terminal is Workflow-typed, so the contextual read bridges
     // through ephemeral().
     const terminal = function* () {
-      observed = yield* ephemeral(persistent());
+      observed = yield* ephemeral(persistent);
       return { output: "", exitCode: 0, stderr: "" };
     };
     yield* middleware([], terminal);
     expect(observed).toBe(true);
-    expect(yield* persistent()).toBe(false);
+    expect(yield* persistent).toBe(false);
   });
 
   // ----- Content provider dispatch -----
diff --git a/core/tests/daemon.test.ts b/core/tests/daemon.test.ts
index 25f2cc8..f955021 100644
--- a/core/tests/daemon.test.ts
+++ b/core/tests/daemon.test.ts
@@ -92,7 +92,7 @@ describe("Tier Q — Daemon modifier", () => {
           },
           { at: "min" },
         );
-        yield* middleware([], terminal) as unknown as Operation<unknown>;
+        yield* middleware([], terminal);
       });
     } catch (e) {
       threw = true;
diff --git a/core/tests/expand.test.ts b/core/tests/expand.test.ts
index f04975c..fd9b3cc 100644
--- a/core/tests/expand.test.ts
+++ b/core/tests/expand.test.ts
@@ -10,10 +10,10 @@ import { renderSegments } from "../src/render.ts";
 import type { Operation } from "effection";
 import { ephemeral } from "@executablemd/durable-streams";
 import { useContent } from "../src/content-context.ts";
-import type { EvalEnv } from "../src/eval-env.ts";
 import type {
   Segment,
   ComponentDefinition,
+  EvalEnv,
   FunctionComponentDefinition,
   Json,
   CodeBlockResult,
@@ -73,15 +73,7 @@ function useTestComponents(
 
 /** Install a binding environment on the current scope. */
 function useTestEnv(testEnv: EvalEnv): Operation<void> {
-  return Component.around(
-    {
-      // deno-lint-ignore require-yield
-      *env(_args, _next) {
-        return testEnv;
-      },
-    },
-    { at: "min" },
-  );
+  return Component.around({ env: () => testEnv }, { at: "min" });
 }
 
 function expand(
diff --git a/core/tests/text-interpolation.test.ts b/core/tests/text-interpolation.test.ts
index cc3360b..8bdf0cc 100644
--- a/core/tests/text-interpolation.test.ts
+++ b/core/tests/text-interpolation.test.ts
@@ -87,15 +87,7 @@ function expandWithBindings(
   return scoped(function* () {
     yield* useTestComponents(components);
     const testEnv = { values: bindings };
-    yield* Component.around(
-      {
-        // deno-lint-ignore require-yield
-        *env(_args, _next) {
-          return testEnv;
-        },
-      },
-      { at: "min" },
-    );
+    yield* Component.around({ env: () => testEnv }, { at: "min" });
     const expanded = yield* expandSegments(segments, meta, props, new Set());
     return renderSegments(expanded);
   });
@@ -305,10 +297,7 @@ describe("Text interpolation — eval bindings in text segments", () => {
             captured.push(block.content);
             return { output: "ok\n", exitCode: 0, stderr: "" };
           },
-          // deno-lint-ignore require-yield
-          *env(_args, _next) {
-            return { values: { port: 8080 } };
-          },
+          env: () => ({ values: { port: 8080 } }),
         },
         { at: "min" },
       );
diff --git a/specs/decisions.md b/specs/decisions.md
index fc511de..2acf57c 100644
--- a/specs/decisions.md
+++ b/specs/decisions.md
@@ -460,7 +460,7 @@ delegate with `next(...)` or short-circuit.
 
 **Why defaults instead of mandatory providers:** operations with a
 sensible neutral value default to it (`raise` returns the segment,
-`env()`/`evalScope()` are undefined, `persistent()` is false), while
+`env`/`evalScope` are undefined, `persistent` is false), while
 operations that cannot proceed without a provider (`importComponent`,
 `applyModifiers`, `codeBlock`, `content`) throw named missing-provider
 errors that identify the missing installation.
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index a1eacba..edc83c4 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -581,10 +581,10 @@ resources for the lifetime of the component expansion. See §4.5 for
 the context flag pattern.
 
 `persist` itself does not call `evalScope.eval()` — it makes the
-contextual `persistent()` operation (§5.5) answer true for the duration
+contextual `persistent` value (§5.5) answer true for the duration
 of the inner chain, and `evalFactory` reads that to decide whether to
 route through the eval scope. The install is scope-local, so
-`persistent()` reverts to false as soon as the persist-wrapped chain
+`persistent` reverts to false as soon as the persist-wrapped chain
 completes.
 
 | Info string | Behavior |
@@ -1113,7 +1113,7 @@ Each run compiles and imports the current transformed source.
 ### 4.3 Binding environment
 
 ```typescript
-// src/eval-env.ts
+// src/types.ts
 export interface EvalEnv {
   values: Record<string, unknown>;
 }
@@ -1122,7 +1122,7 @@ export interface EvalEnv {
 Created fresh at the start of component expansion. Each eval block reads
 bindings from `values` (via env preamble) and writes new bindings back
 (via env-write transforms). The current environment is read contextually
-via the `env()` operation (§5.5); the expansion engine provides it
+via the `env` value (§5.5); the expansion engine provides it
 scope-locally around each component body, so eval blocks within a
 component share bindings without leaking into parent or sibling
 components.
@@ -1132,7 +1132,7 @@ components.
 Each document gets a dedicated **eval scope** — an Effection scope whose
 lifetime matches the document's expansion. Resources spawned by `persist`
 blocks are retained in this scope until expansion completes. The current
-eval scope is read contextually via the `evalScope()` operation (§5.5).
+eval scope is read contextually via the `evalScope` value (§5.5).
 
 The eval scope is created in `runDocument()` (§8.1) **before**
 `durableRun` via `resource(useEvalScope())`. This is critical:
@@ -1148,9 +1148,9 @@ That would hang because the durable effects in the workflow can't
 interact with the journal from within the eval scope's channel
 processor. Instead:
 
-1. `persist` makes the contextual `persistent()` operation answer true
+1. `persist` makes the contextual `persistent` value answer true
    for the duration of the inner chain
-2. `evalFactory` reads `persistent()` after compiling the block
+2. `evalFactory` reads `persistent` after compiling the block
 3. When true, only the **compiled VM block** (`fn(env.values)`) runs
    inside `evalScope.eval()` — not the entire modifier chain
 4. Resources spawned during that execution are retained until the
@@ -1188,7 +1188,6 @@ run but are absent from the diagnostic trace.
 | `src/temp-file-compiler.ts` | `useTempFileCompiler()` — temp-file compiler middleware for Node/Bun; owns `STANDARD_IMPORTS` |
 | `src/content-context.ts` | `useContent()` — content slot access for function components |
 | `test-support/bdd.ts` | Deno-native BDD shim — wraps `@std/testing/bdd` with Effection test adapter |
-| `src/eval-env.ts` | `EvalEnv` |
 | `src/eval-handler.ts` | `evalFactory` |
 | `src/eval-interpolate.ts` | `interpolateEvalBindings()` — bare `{name}` substitution |
 | `src/modifiers/persist.ts` | `persistFactory` |
@@ -1822,12 +1821,14 @@ interface, and each operation is also exported directly:
 | `importComponent(name)` | Resolve and import a component; `"__root__"` is the root document | throws a missing-provider error |
 | `applyModifiers(modifiers, block)` | Execute a code block through its modifier chain | throws a missing-provider error |
 | `raise(error)` | Report an `ErrorSegment` under the ambient error policy (§6.9) | returns the supplied segment |
-| `env()` | The current binding environment (§4.3) | `undefined` |
-| `evalScope()` | The current eval scope (§4.4) | `undefined` |
+| `env` | The current binding environment (§4.3) | `undefined` |
+| `evalScope` | The current eval scope (§4.4) | `undefined` |
 | `codeBlock()` | The code block executing through the modifier chain (§3.3) | throws a missing-provider error |
-| `persistent()` | Whether the current block runs with persistent lifetime (§4.4) | `false` |
+| `persistent` | Whether the current block runs with persistent lifetime (§4.4) | `false` |
 | `content(slot?)` | Render the invoking component's children (§5.1, §6.3) | throws a missing-provider error |
 
+`env`, `evalScope`, and `persistent` are value operations — read without
+invocation (`yield* env`); a provider is middleware returning the value.
 `useCodeBlock()` and `useContent()` remain as ergonomic aliases backed
 by `codeBlock()` and `content(slot?)`.
 
@@ -3732,7 +3733,7 @@ visible warning blocks, collect into a separate error report).
 |---|------|--------|
 | I1 | `eval` is terminal | `evalFactory` ignores `next` — never calls it |
 | I2 | `eval` returns empty output | `result.output === ""`, `exitCode === 0` |
-| I3 | `persist eval` composes | `persist` makes `persistent()` answer true, `eval` reads it |
+| I3 | `persist eval` composes | `persist` makes `persistent` answer true, `eval` reads it |
 | I4 | `timeout=5s eval` composes | Timeout cancels after 5s if block hangs |
 | I5 | `timeout eval` default | Default timeout is 30s |
 | I6 | `persist timeout=10s eval` | Three modifiers compose: persist → timeout → eval |
@@ -3769,7 +3770,7 @@ visible warning blocks, collect into a separate error report).
 | L1 | `persist eval` retains spawned resource | Resource spawned in block survives block completion |
 | L2 | Non-persist eval tears down resource | Resource spawned in block torn down at block end |
 | L3 | Persist resource lifetime matches component | Resource torn down when component expansion completes |
-| L4 | Persistent flag scoped to chain | `persistent()` is `true` only during the persist-wrapped chain |
+| L4 | Persistent flag scoped to chain | `persistent` is `true` only during the persist-wrapped chain |
 | L5 | Multiple persist blocks in one component | Each retains its own resources independently |
 | L6 | Persist on repeated run | Resource is created and retained again for the current component lifetime |
 | L7 | Persist flag does not leak to sibling blocks | Non-persist block after persist block → flag is false |
@@ -4002,7 +4003,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 28 | Acorn + magic-string for source transform | Acorn provides reliable ES2024 parsing; magic-string preserves source positions for accurate source maps without rebuilding AST |
 | 29 | Execution mode auto-detected from AST | No modifier needed — `yield` in body → generator, `await` → async, neither → sync; mixed yield+await is a transform error |
 | 30 | `data:` URI module compilation for eval blocks | Eval blocks are compiled into `data:application/typescript,...` URI modules and dynamically imported via `yield* call(() => import(dataUri))`. APIs are standard `import` statements in the generated module, resolved through Deno's import map. `new Function()` is used for expression props (simpler than `data:` URI for single expressions, no module imports needed) |
-| 31 | `persist` uses a contextual flag, not direct wrapping | Wrapping the full modifier chain in `evalScope.eval()` hangs because durable effects can't interact with the journal from inside the eval scope's channel processor; instead `persist` makes `persistent()` answer true, and `evalFactory` routes only the compiled VM block through `evalScope.eval()` |
+| 31 | `persist` uses a contextual flag, not direct wrapping | Wrapping the full modifier chain in `evalScope.eval()` hangs because durable effects can't interact with the journal from inside the eval scope's channel processor; instead `persist` makes `persistent` answer true, and `evalFactory` routes only the compiled VM block through `evalScope.eval()` |
 | 32 | `evalScope` created before the journaled workflow | The channel processor and eval sender share an ancestor scope |
 | 33 | Non-serializable bindings silently omitted from journal | Functions, class instances, and live objects remain in `env.values` during the current run but are absent from the diagnostic trace |
 | 34 | Eval blocks produce no rendered output by default | Eval blocks primarily exist for bindings and side effects. The `output()` function (§4.7) optionally produces rendered output; without it, result is `{ output: "", exitCode: 0, stderr: "" }` |
@@ -4018,7 +4019,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 44 | Provider lifecycle expressed as a component, not a `RunDocumentOptions` field | Scope boundary is visible in the document tree; composable — multiple providers nest naturally via structured concurrency; no framework-level lifecycle hooks required |
 | 45 | Readiness check is a separate `eval` block, not internal to `daemon` | Auditable — strategy visible in the document; replaceable — different daemons have different readiness signals; composable with `when`'s configurable backoff |
 | 46 | Sample middleware reads `baseUrl` from `env.values` | Avoids a dedicated inference server context key; the binding environment is already the shared state carrier for within-component coordination; scope-correct because a fresh environment is provided per component expansion |
-| 47 | Each component gets a fresh `EvalEnv` | The component's environment is installed as a scope-local `env()` provider around body expansion, so eval blocks within a component share bindings but don't leak into parent or sibling components; critical for provider isolation |
+| 47 | Each component gets a fresh `EvalEnv` | The component's environment is installed as a scope-local `env` provider around body expansion, so eval blocks within a component share bindings but don't leak into parent or sibling components; critical for provider isolation |
 | 48 | `output()` is a plain function, not `yield*` | Output is a synchronous side effect (mutating a ref), not an Effection operation; making it a function keeps the API simple and avoids requiring generator context just to set output text |
 | 49 | `__output` stored alongside exports in journal | Avoids a separate journal entry; `__output` is extracted before merging into `env.values` to prevent namespace pollution |
 | 50 | `renderChildren`/`render` are closures in `env.values`, not an Api | A Render Api would require middleware installation per component; closures are simpler and capture the expansion context at the injection point; they are non-serializable and silently omitted from the journal |
@@ -4046,7 +4047,7 @@ must preserve the trace for diagnosis or remove it before starting a new run.
 | 72 | `channel.send()` must be `yield*`'d | Ensures backpressure and cancellation safety — no text "in flight" when scope tears down; without `yield*`, buffering issues or silent cancellation may occur |
 | 73 | `DocumentExecution` with `withResolvers` | Execution is both an `Operation<string>` (`yield*` for result) and has `.output` stream for chunks; errors surface through `yield* execution` via `withResolvers` `reject()`; eliminates `Result<string>` / `unbox` in consumer code |
 | 74 | Function components receive props directly, not wrapped | `function*(props)` not `function*({ props })` — eliminates unnecessary destructuring; props are already validated by the expansion engine before the function is called |
-| 75 | `useContent()` is contextual, not a function argument | Decouples function components from the expansion engine's API surface; leaf components don't need to ignore an `expandChildren` parameter; Effection-idiomatic — same contextual pattern as `env()`/`evalScope()`; supports named slots via `useContent("header")` |
+| 75 | `useContent()` is contextual, not a function argument | Decouples function components from the expansion engine's API surface; leaf components don't need to ignore an `expandChildren` parameter; Effection-idiomatic — same contextual pattern as `env`/`evalScope`; supports named slots via `useContent("header")` |
 | 76 | `.md` wins over `.ts` in resolution | Backward compatibility — existing markdown components are not shadowed by TypeScript files added later; explicit — if both exist, the human-readable markdown is preferred |
 | 77 | Function component imported on every run | The current module must execute because functions are not serialized into a trace |
 | 78 | Internal durable-streams package | Provides journaling for the core runtime |

From 7d07bd155ccd6b0fcf7d48f81a5a2a1d3b83dc77 Mon Sep 17 00:00:00 2001
From: Taras Mankovski <74687+taras@users.noreply.github.com>
Date: Sat, 18 Jul 2026 19:26:25 -0400
Subject: [PATCH 9/9] =?UTF-8?q?review:=20replace=20=C2=A78.1=20runDocument?=
 =?UTF-8?q?=20snapshot=20with=20behavioral=20documentation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The implementation-shaped block duplicated source and carried stale
details (sampleHandler, runtime, Resolve wiring, useBuiltinModifiers).
State the actual options (docPath, stream, componentDirs?, modifiers?),
the DocumentExecution contract (yield for full output, output stream of
emitted chunks with the full output as close value), the scope-local
runtime providers, and success/failure behavior. The §8.2 usage example
stays — it demonstrates the public API.
---
 deno.lock                    |   2 +
 specs/executable-mdx-spec.md | 129 ++++++++---------------------------
 2 files changed, 29 insertions(+), 102 deletions(-)

diff --git a/deno.lock b/deno.lock
index fd8c702..358048b 100644
--- a/deno.lock
+++ b/deno.lock
@@ -74,8 +74,10 @@
     "npm:marked@^17.0.4": "17.0.4",
     "npm:mdast-util-to-string@4": "4.0.0",
     "npm:oxfmt@0.41": "0.41.0",
+    "npm:oxfmt@0.41.0": "0.41.0",
     "npm:oxlint-tsgolint@0.17": "0.17.4",
     "npm:oxlint@1": "1.56.0_oxlint-tsgolint@0.17.4",
+    "npm:oxlint@1.56.0": "1.56.0_oxlint-tsgolint@0.17.4",
     "npm:preact-render-to-string@^6.6.3": "6.7.0_preact@10.29.7",
     "npm:preact@^10.28.2": "10.29.7_preact-render-to-string@6.7.0",
     "npm:preact@^10.29.1": "10.29.7_preact-render-to-string@6.7.0",
diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md
index edc83c4..5273e32 100644
--- a/specs/executable-mdx-spec.md
+++ b/specs/executable-mdx-spec.md
@@ -2938,108 +2938,33 @@ only when output is emitted, not what executes, so replay is deterministic.
 
 ### 8.1 `runDocument`
 
-```typescript
-interface RunDocumentOptions {
-  /** Path to the root markdown document. */
-  docPath: string;
-
-  /** Durable stream for journaling. */
-  stream: DurableStream;
-
-  /** Component search directories (default: ["./components", "./"]) */
-  componentDirs?: string[];
-
-  /** Custom modifier factories to register alongside built-ins. */
-  modifiers?: Record<string, ModifierFactory>;
-
-  /** Sample Api middleware for the `sample` modifier. */
-  sampleHandler?: SampleApi;
-}
-
-/**
- * A document execution handle. Yield it to get the full output string,
- * or consume `.output` for chunk-by-chunk streaming.
- */
-interface DocumentExecution extends Operation<string> {
-  /** Stream of output chunks emitted during execution. */
-  output: Stream<string, string>;
-}
-
-function* runDocument(options: RunDocumentOptions): Operation<DocumentExecution> {
-  const {
-    docPath,
-    stream,
-    runtime,
-    componentDirs = ["./components", "./"],
-    modifiers: customModifiers = {},
-  } = options;
-
-  // Completion signal — resolve/reject surface through yield* execution.
-  const { operation, resolve, reject } = withResolvers<string>();
-
-  // Create the output channel — internal to runDocument.
-  const channel = createChannel<string, string>();
-
-  // Spawn the execution scope. Runtime state lives inside this
-  // spawned task: runtime API middleware and eval scope,
-  // DocumentOutput→channel bridge. The channel and workflow share this scope;
-  // scope teardown cancels the producer and closes the channel.
-  yield* spawn(function* () {
-
-    // Install resolver middleware — maps __root__ to docPath,
-    // then falls through to directory resolver for components
-    const scope = yield* useScope();
-    scope.around(Resolve, {
-      *resolve([name], next): Operation<ResolveResult> {
-        if (name === "__root__") {
-          return { path: docPath };
-        }
-        return yield* next(name);
-      },
-    });
-    yield* useDirectoryResolver(componentDirs);
-
-    // Create eval scope before the journaled document workflow (§4.4).
-    // The document's Component providers — import, modifier execution,
-    // and this eval scope — are installed here so the workflow inherits
-    // them contextually (§5.5).
-    const rootEvalScope = yield* resource(useEvalScope());
-
-    // Install built-in modifier handlers (exec, silent, sample, eval, persist, timeout)
-    yield* useBuiltinModifiers();
-
-    // Install custom modifier handlers
-    for (const [name, factory] of Object.entries(customModifiers)) {
-      registry.set(name, factory);
-    }
-
-    // Channel delivery is the innermost DocumentOutput handler (installed first).
-    scope.around(DocumentOutput, {
-      *output([text]) {
-        yield* channel.send(text);
-      },
-    });
-
-    // Run the durable workflow. On completion, resolve with the
-    // stored output and close the channel; on failure, reject and close.
-    try {
-      const storedOutput = yield* durableRun(
-        () => documentWorkflow(docPath),
-        { stream },
-      );
-      channel.close(storedOutput);
-      resolve(storedOutput);
-    } catch (error) {
-      channel.close();
-      reject(error);
-    }
-  });
-
-  // Return the execution handle — caller can yield* it for the full
-  // output, or consume execution.output for streaming chunks.
-  return { ...operation, output: channel } as DocumentExecution;
-}
-```
+`runDocument(options)` executes a markdown document as a durable
+workflow and returns a `DocumentExecution` handle. Options:
+
+- `docPath` — path to the root markdown document
+- `stream` — the durable stream that journals the run
+- `componentDirs?` — component search directories (default:
+  `["components", "."]`)
+- `modifiers?` — custom modifier factories registered alongside the
+  built-ins (`exec`, `silent`, `eval`, `persist`, `timeout`, `daemon`)
+
+`DocumentExecution` is an `Operation<string>`: `yield* execution`
+completes with the document's full output. Its `output` property is a
+`Stream<string, string>` of the chunks emitted during execution
+(per-segment for streaming roots, one chunk for buffered `<Output>`
+roots — §5.4); the stream closes with the full output as its close
+value.
+
+Execution runs in its own scope. Before the durable workflow starts,
+`runDocument` installs the document's scope-local runtime providers —
+the platform compiler, the Component providers for import, modifier
+execution, and the root eval scope (§5.5), and the output→stream
+bridge — so nothing leaks onto the caller's scope and the whole run
+inherits them contextually.
+
+On successful completion, `yield* execution` returns the full output
+and the `output` stream closes with it. On failure, the stream closes
+and `yield* execution` throws the workflow error.
 
 ### 8.2 Usage from standalone code