@executablemd/testing 0.3.1 → 0.4.0

package/esm/{testing/npm/src/src → src}/assertions.js

@@ -46,18 +46,12 @@ function requireRegExp(value) {
     }
     throw new AssertionError("match assertions require a RegExp through the expected prop — use expected={/pattern/}");
 }
-// ---------------------------------------------------------------------------
-// Live expression evaluation
-// ---------------------------------------------------------------------------
 const IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-function evaluateExpression(expression, values) {
+export function evaluateExpression(expression, values) {
     const names = Object.keys(values).filter((name) => IDENTIFIER_RE.test(name));
     const fn = new Function(...names, `return (${expression});`);
     return fn(...names.map((name) => values[name]));
 }
-// ---------------------------------------------------------------------------
-// Guarded value formatting — runs only AFTER the assertion outcome is fixed
-// ---------------------------------------------------------------------------
 function safeFormat(value) {
     try {
         if (typeof value === "string") {
@@ -81,9 +75,6 @@ function safeFormat(value) {
         }
     }
 }
-// ---------------------------------------------------------------------------
-// Diagnostic-carrying assertion error
-// ---------------------------------------------------------------------------
 /**
  * An assertion failure enriched with its Markdown diagnostic. Still an
  * `AssertionError`, so containment and classification treat it as the
@@ -100,9 +91,6 @@ export class AssertionDiagnostic extends AssertionError {
         this.cause = cause;
     }
 }
-// ---------------------------------------------------------------------------
-// expandAssertion
-// ---------------------------------------------------------------------------
 const KIND_PROPS = {
     "unary-truthy": { allowed: ["expr", "msg"], required: ["expr"] },
     "unary-exists": { allowed: ["actual", "msg"], required: ["actual"] },
@@ -111,9 +99,20 @@ const KIND_PROPS = {
     match: { allowed: ["actual", "expected", "msg"], required: ["actual", "expected"] },
     numeric: { allowed: ["actual", "expected", "msg"], required: ["actual", "expected"] },
 };
-function validationError(name, message) {
+export function validationError(name, message) {
     return { type: "error", message: `<${name}> ${message}`, source: name };
 }
+// Outside a test the throw would abort before the segment could render, so
+// emit the visible diagnostic first.
+export function* failVisiblyThenThrow(name, msg, detail, failure) {
+    const diagnostic = buildDiagnostic(name, "failed", msg, detail, failure);
+    const visible = (yield* testing) || (yield* verbose);
+    const inTestScope = yield* inTest;
+    if (visible && !inTestScope) {
+        yield* DocumentOutput.operations.output(diagnostic);
+    }
+    throw new AssertionDiagnostic(failure, diagnostic, detail);
+}
 /**
  * Expand one assertion component: validate props, resolve raw values, run the
  * @std/assert function, then build the diagnostic. Returns diagnostic text on
@@ -215,15 +214,7 @@ export function* expandAssertion(assertion, invocation, ctx) {
         }
     }
     if (failure) {
-        const diagnostic = buildDiagnostic(assertion.name, "failed", values.msg, detail, failure);
-        const visible = (yield* testing) || (yield* verbose);
-        const inTestScope = yield* inTest;
-        if (visible && !inTestScope) {
-            // Outside a test the throw below aborts expansion before the segment
-            // could render — emit the diagnostic directly so it reaches the output.
-            yield* DocumentOutput.operations.output(diagnostic);
-        }
-        throw new AssertionDiagnostic(failure, diagnostic, detail);
+        yield* failVisiblyThenThrow(assertion.name, values.msg, detail, failure);
     }
     const visible = (yield* testing) || (yield* verbose);
     if (!visible) {
@@ -231,7 +222,7 @@ export function* expandAssertion(assertion, invocation, ctx) {
     }
     return [{ type: "text", content: buildDiagnostic(assertion.name, "passed", values.msg, detail) }];
 }
-function buildDiagnostic(name, outcome, msg, detail, failure) {
+export function buildDiagnostic(name, outcome, msg, detail, failure) {
     const icon = outcome === "passed" ? "✅" : "❌";
     const lines = [`> ${icon} **${name}** ${outcome}${msg ? ` — ${msg}` : ""}`];
     if (detail.actual !== undefined) {

package/esm/{testing/npm/src/src → src}/handlers.js

@@ -9,13 +9,10 @@ import { ensure, scoped, spawn, suspend, withResolvers } from "effection";
 import { timebox } from "@effectionx/timebox";
 import { unbox, useEvalScope } from "@effectionx/scope-eval";
 import { AssertionError } from "../deps/jsr.io/@std/assert/1.0.19/mod.js";
-import { Component, env, evalScope } from "@executablemd/core";
-import { Test, boundary, inTest, record, testing } from "./test-api.js";
-import { AssertionDiagnostic, expandAssertion } from "./assertions.js";
+import { Component, env, evalScope, validateBindingName } from "@executablemd/core";
+import { Test, boundary, inTest, record, testing, verbose } from "./test-api.js";
+import { AssertionDiagnostic, buildDiagnostic, evaluateExpression, expandAssertion, failVisiblyThenThrow, validationError, } from "./assertions.js";
 import { persistBoundaryOutcome, persistTestResult } from "./journal.js";
-// ---------------------------------------------------------------------------
-// Contained-failure carriers
-// ---------------------------------------------------------------------------
 /** An ErrorSegment raised anywhere inside a test body. */
 class RaisedSegmentError extends Error {
     name = "RaisedSegmentError";
@@ -25,6 +22,14 @@ class RaisedSegmentError extends Error {
         this.segment = segment;
     }
 }
+class CapturedRaise extends Error {
+    name = "CapturedRaise";
+    segment;
+    constructor(segment) {
+        super(segment.message);
+        this.segment = segment;
+    }
+}
 /** A failure while dismantling an established test scope or lease. */
 class TeardownError extends Error {
     name = "TeardownError";
@@ -188,11 +193,136 @@ export function createTestHandlers(options) {
         }
         return testOutput;
     }
-    return { expandTesting, expandTest, expandAssertion };
+    function* expandAssertThrows(invocation, ctx) {
+        for (const propName of [
+            ...Object.keys(invocation.props),
+            ...Object.keys(invocation.expressions),
+        ]) {
+            if (propName !== "message" && propName !== "as") {
+                return [
+                    validationError("AssertThrows", `does not accept a "${propName}" prop (allowed: message, as).`),
+                ];
+            }
+        }
+        if (!("message" in invocation.props) && !("message" in invocation.expressions)) {
+            return [validationError("AssertThrows", 'requires a "message" prop.')];
+        }
+        if ("as" in invocation.expressions) {
+            return [
+                validationError("AssertThrows", 'the "as" prop must be a string literal, not an expression.'),
+            ];
+        }
+        const currentEnv = yield* env;
+        const merged = {
+            ...(ctx.projectedEnv?.values ?? {}),
+            ...(currentEnv?.values ?? {}),
+        };
+        let matcher;
+        if ("message" in invocation.expressions) {
+            let evaluated;
+            try {
+                evaluated = evaluateExpression(invocation.expressions["message"], merged);
+            }
+            catch (error) {
+                return [
+                    validationError("AssertThrows", `failed to evaluate the "message" expression: ${error instanceof Error ? error.message : String(error)}`),
+                ];
+            }
+            if (typeof evaluated === "string" || evaluated instanceof RegExp) {
+                matcher = evaluated;
+            }
+            else {
+                return [
+                    validationError("AssertThrows", `the "message" expression must evaluate to a string or RegExp, got ${typeof evaluated}.`),
+                ];
+            }
+        }
+        else {
+            const literal = invocation.props["message"];
+            if (typeof literal !== "string") {
+                return [validationError("AssertThrows", 'the "message" prop must be a string.')];
+            }
+            matcher = literal;
+        }
+        let binding;
+        if ("as" in invocation.props) {
+            if (!currentEnv) {
+                return [
+                    validationError("AssertThrows", 'binding with "as" requires an eval scope in context.'),
+                ];
+            }
+            const parsed = validateBindingName(invocation.props["as"]);
+            if (!parsed.ok) {
+                return [validationError("AssertThrows", `the "as" prop ${parsed.error}`)];
+            }
+            if (parsed.value === undefined) {
+                return [validationError("AssertThrows", 'the "as" prop must be a non-empty string.')];
+            }
+            binding = parsed.value;
+        }
+        // Install a scope-local raise interceptor and expand the body. Inside a
+        // <Test> the enclosing interceptor is installed in an outer scope, and
+        // outer middleware runs first (see @effectionx/context-api ordering), so
+        // it throws RaisedSegmentError before this hook is reached; outside a test
+        // this hook is the only interceptor and throws CapturedRaise. Catching
+        // both makes capture behave identically inside and outside <Test>. The
+        // first raised error stops expansion, so later children never execute.
+        let captured;
+        try {
+            yield* scoped(function* () {
+                yield* Component.around({
+                    // deno-lint-ignore require-yield
+                    *raise([segment]) {
+                        throw new CapturedRaise(segment);
+                    },
+                });
+                yield* ctx.expand(invocation.children);
+            });
+        }
+        catch (error) {
+            if (error instanceof CapturedRaise || error instanceof RaisedSegmentError) {
+                captured = error.segment;
+            }
+            else {
+                throw error;
+            }
+        }
+        if (!captured) {
+            yield* failAssertThrows(matcher, undefined);
+        }
+        else if (!matchesMessage(matcher, captured.message)) {
+            yield* failAssertThrows(matcher, captured.message);
+        }
+        if (binding !== undefined && currentEnv) {
+            currentEnv.values[binding] = captured;
+        }
+        const visible = (yield* testing) || (yield* verbose);
+        if (!visible) {
+            return [];
+        }
+        return [
+            {
+                type: "text",
+                content: buildDiagnostic("AssertThrows", "passed", describeMatcher(matcher), {}),
+            },
+        ];
+    }
+    return { expandTesting, expandTest, expandAssertion, expandAssertThrows };
+}
+function* failAssertThrows(matcher, actual) {
+    const expected = describeMatcher(matcher);
+    const failure = new AssertionError(actual === undefined
+        ? `AssertThrows: expected the body to raise an error matching ${expected}, but none was raised`
+        : `AssertThrows: raised error ${JSON.stringify(actual)} did not match ${expected}`);
+    yield* failVisiblyThenThrow("AssertThrows", undefined, { expected, actual: actual ?? "(none)" }, failure);
+    throw failure;
+}
+function matchesMessage(matcher, message) {
+    return matcher instanceof RegExp ? matcher.test(message) : message.includes(matcher);
+}
+function describeMatcher(matcher) {
+    return matcher instanceof RegExp ? String(matcher) : `substring ${JSON.stringify(matcher)}`;
 }
-// ---------------------------------------------------------------------------
-// Result classification and diagnostics
-// ---------------------------------------------------------------------------
 function formatLocation(invocation) {
     const position = invocation.position;
     if (!position) {

package/esm/{testing/npm/src/src → src}/vocabulary.js

@@ -39,6 +39,9 @@ export function* installHandlers(handlers, options) {
             if (invocation.name === "Test") {
                 return { segments: yield* handlers.expandTest(invocation, ctx) };
             }
+            if (invocation.name === "AssertThrows") {
+                return { segments: yield* handlers.expandAssertThrows(invocation, ctx) };
+            }
             const assertion = ASSERTIONS.get(invocation.name);
             if (assertion) {
                 return { segments: yield* handlers.expandAssertion(assertion, invocation, ctx) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executablemd/testing",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Testing vocabulary for executable.md documents: <Testing>, <Test>, and assertion components.",
   "homepage": "https://executable.md",
   "repository": {
@@ -26,8 +26,8 @@
     "@effectionx/context-api": "0.6.0",
     "@effectionx/scope-eval": "0.1.3",
     "@effectionx/timebox": "0.4.3",
-    "@executablemd/core": "^0.3.1",
-    "@executablemd/durable-streams": "^0.3.1",
+    "@executablemd/core": "^0.4.0",
+    "@executablemd/durable-streams": "^0.4.0",
     "effection": "4.1.0-alpha.7",
     "@std/assert": "npm:@jsr/std__assert@^1.0.17"
   },

package/types/src/assertions.d.ts

@@ -13,7 +13,7 @@
  */
 import { AssertionError } from "../deps/jsr.io/@std/assert/1.0.19/mod.js";
 import type { Operation } from "effection";
-import type { ComponentInvocation, InvocationContext, Segment } from "@executablemd/core";
+import type { ComponentInvocation, ErrorSegment, InvocationContext, Segment } from "@executablemd/core";
 type AssertionKind = "unary-truthy" | "unary-exists" | "binary-eq" | "string-includes" | "match" | "numeric";
 export interface AssertionEntry {
     name: string;
@@ -29,6 +29,7 @@ interface ResolvedValues {
     msg?: string;
 }
 export declare const ASSERTIONS: Map<string, AssertionEntry>;
+export declare function evaluateExpression(expression: string, values: Record<string, unknown>): unknown;
 /**
  * An assertion failure enriched with its Markdown diagnostic. Still an
  * `AssertionError`, so containment and classification treat it as the
@@ -46,10 +47,19 @@ export declare class AssertionDiagnostic extends AssertionError {
         expected?: string;
     });
 }
+export declare function validationError(name: string, message: string): ErrorSegment;
+export declare function failVisiblyThenThrow(name: string, msg: string | undefined, detail: {
+    actual?: string;
+    expected?: string;
+}, failure: Error): Operation<never>;
 /**
  * Expand one assertion component: validate props, resolve raw values, run the
  * @std/assert function, then build the diagnostic. Returns diagnostic text on
  * a visible pass; throws `AssertionDiagnostic` on failure.
  */
 export declare function expandAssertion(assertion: AssertionEntry, invocation: ComponentInvocation, ctx: InvocationContext): Operation<Segment[]>;
+export declare function buildDiagnostic(name: string, outcome: "passed" | "failed", msg: string | undefined, detail: {
+    actual?: string;
+    expected?: string;
+}, failure?: Error): string;
 export {};

package/types/src/handlers.d.ts

@@ -12,6 +12,7 @@ export interface TestHandlers {
     expandTesting(invocation: ComponentInvocation, ctx: InvocationContext): Operation<Segment[]>;
     expandTest(invocation: ComponentInvocation, ctx: InvocationContext): Operation<Segment[]>;
     expandAssertion(assertion: AssertionEntry, invocation: ComponentInvocation, ctx: InvocationContext): Operation<Segment[]>;
+    expandAssertThrows(invocation: ComponentInvocation, ctx: InvocationContext): Operation<Segment[]>;
 }
 export declare function createTestHandlers(options: {
     timeoutMs: number;

package/esm/core/mod.js

@@ -1,55 +0,0 @@
-/**
- * Executable MDX — public API.
- *
- * Treats markdown documents as durable workflows: text is emitted immediately,
- * component references are resolved and expanded recursively, and code blocks
- * marked as executable are run via durableExec.
- */
-export { ephemeral } from "@executablemd/durable-streams";
-export { healSegment } from "./src/heal.ts";
-export { combine } from "@effectionx/middleware";
-export { useCodeBlock } from "./src/modifiers.ts";
-export { Component, importComponent, applyModifiers, raise, env, evalScope, expandInvocation, codeBlock, persistent, content, } from "./src/component-api.ts";
-// ---------------------------------------------------------------------------
-// Rendering
-// ---------------------------------------------------------------------------
-export { renderSegments } from "./src/render.ts";
-// ---------------------------------------------------------------------------
-// Replay-safe stream
-// ---------------------------------------------------------------------------
-export { createReplayStream } from "./src/replay-stream.ts";
-export { compileBlock } from "./src/eval-context.ts";
-// ---------------------------------------------------------------------------
-// executable.md Globals (for generated eval modules)
-// ---------------------------------------------------------------------------
-export { useContent } from "./src/content-context.ts";
-export { Sample } from "./src/sample-api.ts";
-export { evalFactory } from "./src/eval-handler.ts";
-export { persistFactory } from "./src/modifiers/persist.ts";
-export { timeoutFactory, parseDuration } from "./src/modifiers/timeout.ts";
-export { daemonFactory } from "./src/modifiers/daemon.ts";
-// ---------------------------------------------------------------------------
-// Eval binding interpolation
-// ---------------------------------------------------------------------------
-export { interpolateEvalBindings } from "./src/eval-interpolate.ts";
-// ---------------------------------------------------------------------------
-// Port allocation
-// ---------------------------------------------------------------------------
-export { findFreePort } from "@executablemd/runtime";
-export { transformBlock, serializeExports, isJson } from "./src/eval-transform.ts";
-// ---------------------------------------------------------------------------
-// Output Api & middleware
-// ---------------------------------------------------------------------------
-export { DocumentOutput } from "./src/api.ts";
-export { useNormalizedOutput } from "./src/output/normalize.ts";
-export { useTerminalOutput } from "./src/output/terminal.ts";
-// ---------------------------------------------------------------------------
-// Document runner
-// ---------------------------------------------------------------------------
-export { execute, Execution } from "./src/execute.ts";
-export { useDenoCompiler } from "./src/deno-compiler.ts";
-export { useTempFileCompiler } from "./src/temp-file-compiler.ts";
-// ---------------------------------------------------------------------------
-// Stream consumption
-// ---------------------------------------------------------------------------
-export { collect } from "./src/collect.ts";

package/esm/core/src/api.js

@@ -1,31 +0,0 @@
-/**
- * Document Output Api — Effection Api for streaming document output (spec §9).
- *
- * A single Api with one operation: `output`. The core handler is a no-op.
- * Behavior comes from middleware installed via `yield* DocumentOutput.around(...)`
- * and channel delivery.
- *
- * Call sites use `DocumentOutput.operations.output(text)` inside `yield* ephemeral(...)`.
- */
-import { createApi } from "@effectionx/context-api";
-/**
- * The Document Output Api instance.
- *
- * Usage in middleware:
- * ```js
- * yield* DocumentOutput.around({
- *   *output([text], next) {
- *     const transformed = transform(text);
- *     yield* next(transformed);
- *   },
- * });
- * ```
- *
- * Usage in the emission loop:
- * ```js
- * yield* ephemeral(DocumentOutput.operations.output(text));
- * ```
- */
-export const DocumentOutput = createApi("DocumentOutput", {
-    *output(_text) { },
-});

package/esm/core/src/collect.js

@@ -1,24 +0,0 @@
-/**
- * collect — wait for a document execution to complete and return the output.
- *
- * Convenience wrapper that unwraps the completion `Result<string>`:
- * the output string on `Ok`, a throw on `Err`.
- *
- * ```ts
- * const output = yield* collect(yield* execute(options));
- * ```
- */
-/**
- * Wait for a document execution to complete and return the full output.
- * Throws the failure when the execution completed with `Err`.
- *
- * @param execution - A `DocumentExecution` as returned by `execute`.
- * @returns The full output string.
- */
-export function* collect(execution) {
-    const result = yield* execution;
-    if (!result.ok) {
-        throw result.error;
-    }
-    return result.value;
-}

package/esm/core/src/component-api.js

@@ -1,47 +0,0 @@
-/**
- * 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";
-export const Component = createApi("Component", {
-    // deno-lint-ignore require-yield
-    *importComponent(name) {
-        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, block) {
-        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) {
-        return error;
-    },
-    env: undefined,
-    evalScope: undefined,
-    // deno-lint-ignore require-yield
-    *expandInvocation() {
-        return undefined;
-    },
-    // deno-lint-ignore require-yield
-    *codeBlock() {
-        throw new Error("Component.codeBlock() has no provider: no code block is executing in this scope.");
-    },
-    persistent: false,
-    // deno-lint-ignore require-yield
-    *content(_slot) {
-        throw new Error("Component.content() has no provider: not inside a function component invocation.");
-    },
-});
-export const { importComponent, applyModifiers, raise, env, evalScope, expandInvocation, codeBlock, persistent, content, } = Component.operations;

package/esm/core/src/content-context.js

@@ -1,23 +0,0 @@
-/**
- * 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 { content } from "./component-api.ts";
-/**
- * Render children content from the invoking component.
- *
- * @param slotName - Optional slot name. If provided, renders only the
- *   content assigned to that slot (matching `<Content slot="name" />`).
- *   If omitted, renders the default slot.
- *
- * @example
- * ```ts
- * const body = yield* useContent();
- * const header = yield* useContent("header");
- * ```
- */
-export function useContent(slotName) {
-    return content(slotName);
-}

package/esm/core/src/deno-compiler.js

@@ -1,51 +0,0 @@
-/**
- * Deno-specific eval block compiler middleware.
- *
- * Compiles eval block source into generator functions via data: URIs.
- * Standard imports (Effection, executable.md APIs) are captured in the middleware
- * closure — they are not part of the Compiler API interface.
- *
- * Install via `yield* useDenoCompiler()` inside a document execution
- * scope before any eval blocks are processed.
- */
-import { call } from "effection";
-import { API } from "@executablemd/runtime";
-// STANDARD_IMPORTS below resolve at runtime from generated eval modules;
-// without these static anchors, `deno compile --exclude-unused-npm` prunes
-// the packages from the binary and every eval block using them fails.
-import "@effectionx/converge";
-import "@effectionx/fetch";
-/**
- * Standard import statements prepended to every generated eval module.
- * Captured in the middleware closure — not exposed on the public API.
- */
-const STANDARD_IMPORTS = [
-    'import { sleep, spawn, call, resource, useScope, createChannel, each, suspend, createSignal } from "effection";',
-    'import { when } from "@effectionx/converge";',
-    'import { fetch } from "@effectionx/fetch";',
-    'import { useContent, Sample } from "@executablemd/core";',
-    'import { findFreePort } from "@executablemd/runtime";',
-];
-/**
- * Install the Deno data: URI compiler as middleware on the current scope.
- *
- * Must be called inside an Effection scope (e.g., inside `execute`'s
- * spawned task) before any eval blocks execute.
- */
-export function* useDenoCompiler() {
-    yield* API.Compiler.around({
-        *compile([source, options], next) {
-            void next; // terminal middleware — does not delegate
-            const userImports = options?.imports ?? [];
-            const allImports = [...STANDARD_IMPORTS, ...userImports];
-            const importLines = allImports.join("\n");
-            const moduleSource = [importLines, `export default function*(env) {`, source, `}`].join("\n");
-            const dataUri = `data:application/typescript,${encodeURIComponent(moduleSource)}`;
-            const mod = yield* call(() => import(dataUri));
-            if (typeof mod.default !== "function") {
-                throw new Error(`useDenoCompiler: expected default export to be a generator function, got ${typeof mod.default}`);
-            }
-            return mod.default;
-        },
-    });
-}

package/esm/core/src/errors.js

@@ -1,13 +0,0 @@
-/**
- * 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 {
-    segment;
-    constructor(segment) {
-        super(segment.message);
-        this.name = "DocumentationError";
-        this.segment = segment;
-    }
-}

package/esm/core/src/eval-context.js

@@ -1,13 +0,0 @@
-/**
- * Eval block compilation (spec §5).
- */
-import { compile as runtimeCompile } from "@executablemd/runtime";
-/**
- * Compile transformed source code into a generator function.
- *
- * Delegates to `@executablemd/runtime` so platform-specific
- * compilation can be provided via API.Compiler middleware.
- */
-export function compileBlock(transformedBodyCode, userImports) {
-    return runtimeCompile(transformedBodyCode, { imports: userImports });
-}