@executablemd/testing 0.3.1 → 0.4.1

package/esm/core/src/expand.js

@@ -1,988 +0,0 @@
-/**
- * Expansion engine (spec §5).
- *
- * Term-rewriting process: each component invocation is replaced by the
- * component's body, with <Content /> (and <Content slot="name" />)
- * substituted by the invocation's children and {meta.key}/{props.key}
- * resolved.
- *
- * Top-down expansion with raw child substitution: children are
- * substituted into the component body as raw (unexpanded) segments,
- * then the entire substituted body is expanded in document order.
- * This ensures code blocks before <Content /> (e.g., provider
- * middleware installation) execute before children's code blocks.
- */
-import { scoped } from "effection";
-import { interpolate } from "./interpolate.ts";
-import { interpolateEvalBindings } from "./eval-interpolate.ts";
-import { Component, applyModifiers, env, evalScope, expandInvocation, importComponent, raise, } from "./component-api.ts";
-import { DocumentationError } from "./errors.ts";
-import { useEvalScope, unbox } from "@effectionx/scope-eval";
-import { validateProps } from "./validate.ts";
-import { healSegment } from "./heal.ts";
-import { scanSegments } from "./scanner.ts";
-import { renderSegments } from "./render.ts";
-import { remark } from "remark";
-import { select as cssSelect } from "unist-util-select";
-import { toString as mdastToString } from "mdast-util-to-string";
-export function createBlockCounter() {
-    let id = 0;
-    return { next: () => id++ };
-}
-// Providers install at "min" inside scoped() so nested components override
-// ancestors (innermost min runs first) without leaking into siblings.
-function provideEnv(value) {
-    return Component.around({ env: () => value }, { at: "min" });
-}
-function provideEvalScope(value) {
-    return Component.around({ evalScope: () => value }, { at: "min" });
-}
-// ---------------------------------------------------------------------------
-// Expansion algorithm (spec §5.1)
-// ---------------------------------------------------------------------------
-const MAX_EXPANSION_DEPTH = 64;
-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.
- */
-export function* expandSegments(segments, parentMeta, parentProps, hideSet, counter = createBlockCounter()) {
-    const result = [];
-    for (const segment of segments) {
-        switch (segment.type) {
-            case "text": {
-                // Heal incomplete markdown constructs at segment boundaries (spec §2.3)
-                // Runs synchronously — no yield, no journal entry
-                const healed = healSegment(segment.content);
-                // Interpolate {meta.key} and {props.key} — runtime, no journal
-                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 a binding environment is in scope.
-                const textEvalEnv = yield* env;
-                const final = textEvalEnv
-                    ? interpolateEvalBindings(interpolated, textEvalEnv.values)
-                    : interpolated;
-                result.push({ type: "text", content: final });
-                break;
-            }
-            case "component": {
-                // Extension hook: an installed vocabulary may claim this invocation
-                // before built-in expansion. Returned error segments follow the
-                // ambient raise policy, like any component-produced error.
-                const handling = yield* expandInvocation(segment, {
-                    meta: parentMeta,
-                    props: parentProps,
-                    projectedEnv: segment.projectedEnv,
-                    expand: (segments) => expandSegments(segments, parentMeta, parentProps, hideSet, counter),
-                });
-                if (handling) {
-                    for (const handled of handling.segments) {
-                        if (handled.type === "error") {
-                            result.push(yield* raise(handled));
-                        }
-                        else {
-                            result.push(handled);
-                        }
-                    }
-                    break;
-                }
-                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, parentMeta, parentProps, hideSet, counter);
-                    if (captureResult) {
-                        result.push(yield* raise(captureResult));
-                    }
-                    break;
-                }
-                const expanded = yield* expandComponent(segment.name, segment.props, segment.expressions, segment.children, hideSet, counter, segment.projectedEnv);
-                // 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;
-            }
-            case "codeBlock": {
-                // Interpolate eval bindings into content before the modifier chain.
-                // 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* env;
-                const lastModifier = segment.modifiers[segment.modifiers.length - 1];
-                const isEvalTerminal = lastModifier !== undefined && lastModifier.name === "eval";
-                const interpolatedContent = evalEnv && !isEvalTerminal
-                    ? 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 spec §6.1 Block ID counter).
-                const context = {
-                    language: segment.language,
-                    content: interpolatedContent,
-                    blockId: `eval:${parentMeta["componentName"] ?? "root"}:${counter.next()}`,
-                    componentName: parentMeta["componentName"],
-                };
-                try {
-                    const codeResult = yield* applyModifiers(segment.modifiers, context);
-                    if (codeResult.exitCode !== 0 && codeResult.output === "") {
-                        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",
-                            command: segment.content,
-                            result: {
-                                exitCode: codeResult.exitCode,
-                                stdout: codeResult.output,
-                                stderr: codeResult.stderr,
-                            },
-                        });
-                    }
-                    // If output is empty and exit code is 0, nothing added (e.g., silent)
-                }
-                catch (error) {
-                    // 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: {
-                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);
-                }
-            }
-        }
-    }
-    return result;
-}
-function* expandCapture(segment, parentMeta, parentProps, hideSet, counter) {
-    if (segment.selfClosing || segment.children.length === 0) {
-        return {
-            type: "error",
-            message: '<Capture> must have content. Use <Capture as="x">...</Capture>.',
-            source: "Capture",
-        };
-    }
-    const propNames = Object.keys(segment.props);
-    if (propNames.some((name) => name !== "as" && name !== "select")) {
-        return {
-            type: "error",
-            message: '<Capture> only accepts "as" and "select" props.',
-            source: "Capture",
-        };
-    }
-    const expressionNames = Object.keys(segment.expressions);
-    if (expressionNames.length > 0) {
-        if (expressionNames.includes("as")) {
-            return {
-                type: "error",
-                message: '<Capture as={...}> is invalid: "as" must be a string literal.',
-                source: "Capture",
-            };
-        }
-        if (!expressionNames.every((n) => n === "select")) {
-            return {
-                type: "error",
-                message: '<Capture> only accepts "as" and "select" props.',
-                source: "Capture",
-            };
-        }
-    }
-    if (segment.props.as === undefined) {
-        return {
-            type: "error",
-            message: '<Capture> requires an "as" prop (non-empty string).',
-            source: "Capture",
-        };
-    }
-    const asBinding = validateBindingName(segment.props.as);
-    if (!asBinding.ok) {
-        return {
-            type: "error",
-            message: asBinding.error,
-            source: "Capture",
-        };
-    }
-    const bindingName = asBinding.value;
-    if (bindingName === undefined) {
-        return {
-            type: "error",
-            message: '<Capture> requires an "as" prop (non-empty string).',
-            source: "Capture",
-        };
-    }
-    const expandedChildren = yield* expandSegments(segment.children, parentMeta, parentProps, hideSet, counter);
-    const rendered = renderSegments(expandedChildren).replace(/\s+$/, "");
-    // Apply CSS selector if select prop is present (spec §6.5)
-    let captured = rendered;
-    const selectProp = segment.props.select;
-    if (typeof selectProp === "string" && selectProp.length > 0) {
-        const tree = remark().parse(captured);
-        // deno-lint-ignore no-explicit-any
-        const node = cssSelect(selectProp, tree);
-        if (node) {
-            captured = "value" in node ? String(node.value) : mdastToString(node);
-        }
-    }
-    const bindingEnv = yield* env;
-    if (!bindingEnv) {
-        return {
-            type: "error",
-            message: "<Capture> requires an evaluation environment.",
-            source: "Capture",
-        };
-    }
-    bindingEnv.values[bindingName] = captured;
-    return undefined;
-}
-// ---------------------------------------------------------------------------
-// Component expansion with cycle detection (spec §5.2)
-// ---------------------------------------------------------------------------
-function* expandComponent(name, props, expressions, children, hideSet, counter, projectedEnv) {
-    // 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,
-            }),
-        ];
-    }
-    if (hideSet.size >= MAX_EXPANSION_DEPTH) {
-        return [
-            yield* raise({
-                type: "error",
-                message: `Maximum expansion depth (${MAX_EXPANSION_DEPTH}) exceeded`,
-                source: name,
-            }),
-        ];
-    }
-    let imported;
-    try {
-        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,
-            }),
-        ];
-    }
-    // Function component: call the generator function directly
-    if (imported.kind === "function") {
-        return yield* expandFunctionComponent(name, props, expressions, children, imported, hideSet, counter, projectedEnv);
-    }
-    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).
-    let resolvedProps;
-    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,
-            }),
-        ];
-    }
-    if ("as" in expressions) {
-        return [
-            yield* raise({
-                type: "error",
-                message: `Prop "as" on <${name} /> must be a string literal.`,
-                source: name,
-            }),
-        ];
-    }
-    // Validate props against declared inputs.
-    // Strip the `slot` prop before validation — it is consumed by the
-    // expansion engine for slot assignment, not forwarded to the child.
-    let validatedProps;
-    let asBinding;
-    try {
-        const binding = validateBindingName(resolvedProps.as);
-        if (!binding.ok) {
-            throw new Error(`Prop "as" on <${name} /> ${binding.error}`);
-        }
-        asBinding = binding.value;
-        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,
-            }),
-        ];
-    }
-    // Capture the caller's eval environment before creating the component's
-    // own env. Children are caller-provided content — expression props like
-    // {pr} should resolve against the scope where the JSX was written, not
-    // the component that renders <Content />.
-    //
-    // For multi-level nesting (Root → Provider → Instruction → ReviewBody),
-    // 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 callerEvalEnv = projectedEnv
-        ? { values: { ...projectedEnv.values, ...(contextEnv?.values ?? {}) } }
-        : contextEnv;
-    // 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 where each provider has isolated port/URL bindings.
-    //
-    // Each component also gets its own EvalScope, created as a child of
-    // the parent component's eval scope. This ensures that middleware
-    // installed via `persist eval` blocks (e.g., Sample.around()) is
-    // scoped to the component. Nested providers produce a scope chain
-    // where innermost middleware runs first (innermost-wins), and
-    // next() delegates to the parent scope's middleware.
-    const newHideSet = new Set([...hideSet, name]);
-    const componentEnv = { values: { ...validatedProps } };
-    // Create per-component eval scope as a child of the parent eval scope.
-    // 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;
-    let childEvalScope = undefined;
-    if (parentEvalScope) {
-        const result = yield* parentEvalScope.eval(() => useEvalScope());
-        childEvalScope = unbox(result);
-    }
-    // Inject render closures into the component's binding environment.
-    // These are generator functions that eval blocks can yield* to render
-    // content within the current expansion context.
-    //
-    // renderChildren() — expands and renders this component's children.
-    // render(markdown) — scans, expands, and renders arbitrary markdown.
-    //
-    // Both use parentEvalScope, not childEvalScope. Children are
-    // caller-provided content — they expand in the caller's scope
-    // context. The component's childEvalScope and its sequential
-    // channel are for the component's own persist eval blocks
-    // (middleware installation, etc.), not for expanding caller content.
-    //
-    // Children may contain operations that create resources (nested
-    // components, persist eval blocks, daemons), but those resources
-    // are scoped to the expansion — their lifecycle is bound by their
-    // place in the structured concurrency tree. Inner components create
-    // their own child scopes off parentEvalScope, and ancestor
-    // middleware is visible through Effection's scope prototype chain.
-    //
-    // 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.
-    const capturedMeta = definition.meta;
-    const capturedProps = validatedProps;
-    // Children are caller-provided content, not the component's own body.
-    // Use the parent's hide set (without the current component name) so
-    // that caller-provided children can reference the same component name
-    // without triggering false cycle detection. True cycles in a component's
-    // body are still caught because body expansion uses newHideSet.
-    const capturedChildrenHideSet = hideSet;
-    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;
-    const renderInCallerScope = (segments) => scoped(function* () {
-        yield* provideEnv(capturedCallerEnv);
-        if (capturedParentEvalScope) {
-            yield* provideEvalScope(capturedParentEvalScope);
-        }
-        const expanded = yield* expandSegments(segments, capturedMeta, capturedProps, capturedChildrenHideSet, counter);
-        return renderSegments(expanded);
-    });
-    componentEnv.values.renderChildren = () => renderInCallerScope(children);
-    componentEnv.values.render = (markdown) => renderInCallerScope(scanSegments(markdown));
-    const expanded = yield* scoped(function* () {
-        yield* provideEnv(componentEnv);
-        if (childEvalScope) {
-            yield* provideEvalScope(childEvalScope);
-        }
-        return yield* expandBody(definition.bodySegments, children, definition.meta, validatedProps, newHideSet, counter, callerEvalEnv ?? undefined);
-    });
-    if (asBinding) {
-        const parentEnv = yield* env;
-        if (!parentEnv) {
-            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);
-            }
-        }
-        parentEnv.values[asBinding] = renderSegments(expanded);
-        return [];
-    }
-    return expanded;
-}
-// ---------------------------------------------------------------------------
-// Function component expansion (spec §5.3)
-// ---------------------------------------------------------------------------
-/**
- * Expand a function component (.ts file).
- *
- * Function components are generator functions that return a rendered
- * string. They receive validated props, raw child segments, and an
- * `expandChildren` helper that renders children.
- */
-function* expandFunctionComponent(name, props, expressions, children, definition, hideSet, counter, projectedEnv) {
-    if ("as" in expressions) {
-        return [
-            yield* raise({
-                type: "error",
-                message: `Prop "as" on <${name} /> must be a string literal.`,
-                source: name,
-            }),
-        ];
-    }
-    // Resolve expression props
-    let resolvedProps;
-    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,
-            }),
-        ];
-    }
-    // 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,
-            }),
-        ];
-    }
-    const asBinding = asBindingResult.value;
-    const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps;
-    // Validate props
-    let validatedProps;
-    try {
-        validatedProps = validateProps(name, propsForValidation, definition.inputs);
-    }
-    catch (error) {
-        return [
-            yield* raise({
-                type: "error",
-                message: error instanceof Error ? error.message : String(error),
-                source: name,
-            }),
-        ];
-    }
-    const slots = partitionBySlot(children);
-    // Call the function component with content middleware in scope so it can
-    // render children via `yield* useContent()` / `useContent("slot")`.
-    try {
-        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* env;
-            if (!parentEnv) {
-                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 (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,
-            }),
-        ];
-    }
-}
-function validateBindingName(value) {
-    if (value === undefined) {
-        return { ok: true };
-    }
-    if (typeof value !== "string") {
-        return { ok: false, error: "must be a non-empty string literal." };
-    }
-    if (value.length === 0) {
-        return { ok: false, error: "must be non-empty." };
-    }
-    if (!IDENTIFIER_RE.test(value)) {
-        return {
-            ok: false,
-            error: `must be a valid JavaScript identifier. Got: "${value}"`,
-        };
-    }
-    return { ok: true, value };
-}
-// ---------------------------------------------------------------------------
-// Expression prop evaluation (spec §5.1)
-// ---------------------------------------------------------------------------
-/**
- * Resolve eval expression props against env.values using the shared VM
- * context. Merges resolved values into the props record.
- *
- * Expression props are stored as raw expression text in the
- * `expressions` field of `ComponentInvocation`. At expansion time,
- * they are evaluated as JavaScript using `new Function()` with
- * `env.values` destructured into scope.
- *
- * Errors are thrown (not ErrorSegments), consistent with PropValidationError.
- *
- * Uses `new Function()` instead of `node:vm` — Deno's permission model
- * provides the security boundary. The expression text comes from the
- * document author (trusted), and results must pass serialization check.
- */
-function* resolveExpressionProps(props, expressions, componentName, explicitEnv) {
-    // Start with already-resolved props
-    const resolved = { ...props };
-    // Nothing to evaluate
-    if (Object.keys(expressions).length === 0) {
-        return resolved;
-    }
-    const contextEnv = yield* env;
-    // For projected children (substituted via <Content />), merge the
-    // caller's env (explicitEnv) with the wrapping component's env
-    // (contextEnv). The component's env takes priority because its eval
-    // blocks run before <Content /> and may define bindings that children
-    // reference. The caller's env provides fallback bindings from the
-    const evalEnv = explicitEnv && contextEnv
-        ? { values: { ...explicitEnv.values, ...contextEnv.values } }
-        : (contextEnv ?? explicitEnv);
-    if (!evalEnv) {
-        const names = Object.keys(expressions).join(", ");
-        throw new Error(`Expression props (${names}) on <${componentName} /> cannot be ` +
-            `resolved: no eval context available. Expression props require ` +
-            `a preceding eval block that defines the referenced bindings.`);
-    }
-    const envKeys = Object.keys(evalEnv.values);
-    const envValues = envKeys.map((k) => evalEnv.values[k]);
-    for (const [propName, expression] of Object.entries(expressions)) {
-        try {
-            // Evaluate expression with env.values destructured into scope
-            // via new Function() parameter injection.
-            const fn = new Function(...envKeys, `return (${expression})`);
-            const result = fn(...envValues);
-            if (typeof result === "function" || typeof result === "undefined") {
-                throw new Error(`Expression prop "${propName}" on <${componentName} /> evaluated ` +
-                    `to a non-serializable value (${typeof result}). Props must be ` +
-                    `JSON-serializable.`);
-            }
-            let serialized;
-            try {
-                serialized = JSON.parse(JSON.stringify(result));
-            }
-            catch {
-                throw new Error(`Expression prop "${propName}" on <${componentName} /> evaluated ` +
-                    `to a non-serializable value (${typeof result}). Props must be ` +
-                    `JSON-serializable.`);
-            }
-            resolved[propName] = serialized;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("non-serializable")) {
-                throw error;
-            }
-            throw new Error(`Failed to evaluate expression prop "${propName}={${expression}}" ` +
-                `on <${componentName} />: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return resolved;
-}
-// ---------------------------------------------------------------------------
-// Named slot support (spec §6.3)
-// ---------------------------------------------------------------------------
-/**
- * Slot name validation pattern: must start with a letter, followed by
- * letters, digits, underscores, or hyphens.
- */
-const SLOT_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-/**
- * Validate a slot name. Returns an ErrorSegment if invalid, undefined if ok.
- */
-function validateSlotName(name, source) {
-    if (name === "") {
-        return {
-            type: "error",
-            message: "Invalid slot name: slot name must not be empty",
-            source,
-        };
-    }
-    if (!SLOT_NAME_RE.test(name)) {
-        return {
-            type: "error",
-            message: `Invalid slot name "${name}": must match [a-zA-Z][a-zA-Z0-9_-]*`,
-            source,
-        };
-    }
-    return undefined;
-}
-/**
- * Slot assignment: returns the slot name if the segment is a component
- * invocation with a `slot` prop, undefined otherwise.
- *
- * Only ComponentInvocation segments can carry a `slot` prop. Text
- * segments and code blocks are always default-slot content.
- */
-function getSlotAssignment(segment) {
-    if (segment.type === "component" && segment.props.slot !== undefined) {
-        return String(segment.props.slot);
-    }
-    return undefined;
-}
-/**
- * Partition children into slot buckets. Only ComponentInvocation segments
- * with a `slot` prop are assigned to named slots. Everything else goes
- * to the default slot.
- *
- * Invalid slot names produce ErrorSegments in the `errors` array.
- */
-export function partitionBySlot(children) {
-    const named = new Map();
-    const defaultSlot = [];
-    const errors = [];
-    for (const child of children) {
-        const slotName = getSlotAssignment(child);
-        if (slotName !== undefined) {
-            const error = validateSlotName(slotName, `slot="${slotName}"`);
-            if (error) {
-                errors.push(error);
-                continue;
-            }
-            let bucket = named.get(slotName);
-            if (!bucket) {
-                bucket = [];
-                named.set(slotName, bucket);
-            }
-            bucket.push(child);
-        }
-        else {
-            defaultSlot.push(child);
-        }
-    }
-    return { default: defaultSlot, named, errors };
-}
-/**
- * Strip the `slot` prop from a segment. Returns a shallow clone with
- * `slot` removed from props. Non-component segments pass through unchanged.
- */
-export function stripSlotProp(segment) {
-    if (segment.type === "component" && "slot" in segment.props) {
-        const { slot: _, ...rest } = segment.props;
-        return { ...segment, props: rest };
-    }
-    return segment;
-}
-/**
- * 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) {
-    const project = (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, slots, meta, props, project, state) {
-    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.
- * Also interpolates {meta.key} and {props.key} in text segments.
- *
- * When no `slot` props are present anywhere, this behaves identically
- * to the original single-slot substituteContent.
- */
-function substituteContent(bodySegments, children, meta, props, callerEnv) {
-    const slots = partitionBySlot(children);
-    const state = { errorsEmitted: false };
-    const project = makeProjectFn(callerEnv);
-    return substituteSegmentList(bodySegments, slots, meta, props, project, state);
-}
-function isTopLevelOutput(segment) {
-    return segment.type === "component" && segment.name === "Output";
-}
-export function bodyHasOutput(bodySegments) {
-    return bodySegments.some(isTopLevelOutput);
-}
-function misplacedOutputError() {
-    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",
-    };
-}
-function previewOutput(segment) {
-    const text = segment.children
-        .filter((child) => 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) {
-    const violations = [];
-    const walk = (segments, depth) => {
-        for (const segment of segments) {
-            if (segment.type !== "component") {
-                continue;
-            }
-            if (segment.name === "Output" && depth > 0) {
-                violations.push(previewOutput(segment));
-            }
-            walk(segment.children, depth + 1);
-        }
-    };
-    walk(bodySegments, 0);
-    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",
-    };
-}
-function validateOutputProps(segment) {
-    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, children, meta, props, callerEnv) {
-    const slots = partitionBySlot(children);
-    const state = { errorsEmitted: false };
-    const project = makeProjectFn(callerEnv);
-    const chunks = [];
-    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;
-            }
-            const outputSegments = substituteSegmentList(segment.children, slots, meta, props, project, state);
-            chunks.push({ output: true, segments: outputSegments });
-            continue;
-        }
-        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 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, children, meta, props, hideSet, counter, callerEnv) {
-    if (!bodyHasOutput(bodySegments)) {
-        const substituted = substituteContent(bodySegments, children, meta, props, callerEnv);
-        return yield* expandSegments(substituted, meta, props, hideSet, counter);
-    }
-    const chunks = buildBody(bodySegments, children, meta, props, callerEnv);
-    const output = [];
-    for (const chunk of chunks) {
-        if (chunk.output) {
-            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* 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;
-}