@kernlang/test 3.4.0 → 3.4.2-canary.3.1.6b4cbb13

package/dist/index.js

@@ -1,4 +1,4 @@
-import { generateCoreNode, parseDocumentWithDiagnostics, validateSchema, validateSemantics } from '@kernlang/core';
+import { decompile, generateCoreNode, importTypeScript, parseDocumentWithDiagnostics, validateSchema, validateSemantics, } from '@kernlang/core';
 import { execFileSync } from 'child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { dirname, join, relative, resolve } from 'path';
@@ -16,7 +16,7 @@ const DISCOVERY_SKIP_DIRS = new Set([
 ]);
 const NATIVE_TEST_PRESETS = {
     apisafety: ['duplicateRoutes', 'emptyRoutes', 'unvalidatedRoutes', 'unguardedEffects', 'uncheckedRoutePathParams'],
-    coverage: ['untestedTransitions', 'untestedGuards'],
+    coverage: ['untestedTransitions', 'untestedGuards', 'untestedRoutes', 'untestedTools', 'untestedEffects'],
     effects: ['unguardedEffects', 'sensitiveEffectsRequireAuth', 'effectWithoutCleanup', 'unrecoveredAsync'],
     guard: ['invalidGuards', 'weakGuards', 'nonExhaustiveGuards'],
     machine: ['deadStates', 'duplicateTransitions'],
@@ -68,6 +68,30 @@ const NATIVE_KERN_TEST_RULES = [
         ruleId: 'runtime:behavior',
         description: 'Evaluate a constrained pure fn or derive assertion with scoped native test fixtures.',
     },
+    {
+        ruleId: 'runtime:route',
+        description: 'Evaluate a portable route workflow with request fixtures before backend code generation.',
+    },
+    {
+        ruleId: 'runtime:tool',
+        description: 'Evaluate a portable MCP tool workflow with input fixtures before backend code generation.',
+    },
+    {
+        ruleId: 'runtime:effect',
+        description: 'Evaluate a deterministic portable effect/recover workflow before backend code generation.',
+    },
+    {
+        ruleId: 'mock:called',
+        description: 'Assert how many times a scoped native effect mock was actually invoked.',
+    },
+    {
+        ruleId: 'import',
+        description: 'Assert that a TypeScript fixture imports to expected KERN source and optionally recompiles.',
+    },
+    {
+        ruleId: 'has:invariant',
+        description: 'Assert that an intentionally bad target KERN file contains the requested native invariant failure.',
+    },
     { ruleId: 'expect:unsupported', description: 'The expect assertion shape is not supported by native kern test.' },
     { ruleId: 'preset:unknown', description: 'The requested preset name is unknown.' },
     { ruleId: 'no:schemaviolations', description: 'The target KERN file has no schema violations.' },
@@ -174,6 +198,21 @@ const NATIVE_KERN_TEST_RULES = [
         description: 'Guards are covered by exhaustive or guard-preset assertions.',
         presets: ['coverage'],
     },
+    {
+        ruleId: 'no:untestedroutes',
+        description: 'Routes are covered by native route workflow assertions.',
+        presets: ['coverage'],
+    },
+    {
+        ruleId: 'no:untestedtools',
+        description: 'MCP tools are covered by native tool workflow assertions.',
+        presets: ['coverage'],
+    },
+    {
+        ruleId: 'no:untestedeffects',
+        description: 'Deterministic KERN effects are covered by native effect assertions.',
+        presets: ['coverage'],
+    },
 ];
 export function listNativeKernTestRules() {
     return NATIVE_KERN_TEST_RULES.map((rule) => ({
@@ -221,6 +260,24 @@ function exprPropToRuntimeSource(node, propName) {
     }
     return exprToString(value);
 }
+function rawPropToRuntimeSource(node, propName) {
+    const props = getProps(node);
+    const value = props[propName];
+    if (value === undefined || value === '')
+        return '';
+    const expr = exprToString(value);
+    return expr || String(value);
+}
+function stringLiteralOrExprPropToRuntimeSource(node, propName) {
+    const props = getProps(node);
+    const value = props[propName];
+    if (value === undefined || value === '')
+        return '';
+    if (value && typeof value === 'object' && '__expr' in value)
+        return exprToString(value);
+    const source = String(value);
+    return isJsStringLiteralSource(source) ? source : JSON.stringify(source);
+}
 function runtimeExpectedSource(node, propName) {
     const props = getProps(node);
     const value = props[propName];
@@ -312,6 +369,9 @@ function isAssertionConfigurationFailure(message) {
         message.startsWith('Runtime fn assertion ') ||
         message.startsWith('Runtime derive assertion ') ||
         message.startsWith('Runtime behavior assertion ') ||
+        message.startsWith('Runtime route assertion cannot ') ||
+        message.startsWith('Runtime tool assertion cannot ') ||
+        message.startsWith('Runtime effect assertion cannot ') ||
         message.startsWith('Node assertion requires ') ||
         message.startsWith('Node assertion count ') ||
         message === 'Unsupported native expect assertion.' ||
@@ -343,6 +403,9 @@ function grepMatches(options, result) {
 function invariantRuleId(value) {
     return `no:${normalizeInvariant(value) || 'unknown'}`;
 }
+function hasInvariantRuleId(value) {
+    return `has:${normalizeInvariant(value) || 'unknown'}`;
+}
 function presetRuleId(value) {
     return `preset:${normalizeInvariant(value) || 'unknown'}`;
 }
@@ -491,41 +554,119 @@ function runtimeFixtureBindings(node) {
         .map((fixture) => runtimeFixtureBinding(fixture))
         .filter((fixture) => fixture !== undefined);
 }
+function runtimeEffectMock(node, id) {
+    const props = getProps(node);
+    const effect = str(props.effect);
+    const returns = runtimeExpectedSource(node, 'returns');
+    const throws = props.throws === undefined ? undefined : String(props.throws || 'true');
+    if (!effect || (returns === undefined && throws === undefined))
+        return undefined;
+    return { id, effect, returns, throws, line: node.loc?.line, col: node.loc?.col };
+}
 function collectAssertions(testNode) {
     const suite = str(getProps(testNode).name) || 'unnamed test';
     const assertions = [];
-    function pushExpectation(node, path, fixtures) {
+    let mockId = 0;
+    const caseMergeProps = new Set([
+        'args',
+        'with',
+        'input',
+        'equals',
+        'returns',
+        'recovers',
+        'fallback',
+        'matches',
+        'throws',
+        'called',
+        'message',
+        'severity',
+    ]);
+    function runtimeEffectMocks(node) {
+        return getChildren(node, 'mock')
+            .map((mock) => runtimeEffectMock(mock, `mock:${mockId++}`))
+            .filter((mock) => mock !== undefined);
+    }
+    function testCaseRows(node, fixtures, mocks) {
+        return getChildren(node, 'case').map((caseNode, index) => {
+            const label = str(getProps(caseNode).name) || `case ${index + 1}`;
+            return {
+                node: caseNode,
+                fixtures: [...fixtures, ...runtimeFixtureBindings(caseNode)],
+                mocks: [...mocks, ...runtimeEffectMocks(caseNode)],
+                label,
+            };
+        });
+    }
+    function expectationForCase(expectNode, caseNode) {
+        const mergedProps = { ...getProps(expectNode) };
+        const quotedProps = new Set(expectNode.__quotedProps || []);
+        const caseQuotedProps = new Set(caseNode.__quotedProps || []);
+        for (const [key, value] of Object.entries(getProps(caseNode))) {
+            if (!caseMergeProps.has(key))
+                continue;
+            mergedProps[key] = value;
+            if (caseQuotedProps.has(key))
+                quotedProps.add(key);
+            else
+                quotedProps.delete(key);
+        }
+        return {
+            ...expectNode,
+            props: mergedProps,
+            __quotedProps: [...quotedProps],
+            loc: caseNode.loc || expectNode.loc,
+            children: (expectNode.children || []).filter((child) => child.type !== 'case'),
+        };
+    }
+    function pushExpectation(node, path, fixtures, mocks, cases = []) {
+        if (cases.length > 0) {
+            for (const testCase of cases) {
+                assertions.push({
+                    suite,
+                    caseName: [...path, testCase.label].join(' > '),
+                    node: expectationForCase(node, testCase.node),
+                    fixtures: testCase.fixtures,
+                    mocks: testCase.mocks,
+                });
+            }
+            return;
+        }
         assertions.push({
             suite,
             caseName: path.length > 0 ? path.join(' > ') : 'top-level',
             node,
             fixtures,
+            mocks,
         });
     }
-    function visit(node, path, fixtures) {
+    function visit(node, path, fixtures, mocks) {
         const scopedFixtures = [...fixtures, ...runtimeFixtureBindings(node)];
+        const scopedMocks = [...mocks, ...runtimeEffectMocks(node)];
         if (node.type === 'expect') {
-            pushExpectation(node, path, scopedFixtures);
+            pushExpectation(node, path, scopedFixtures, scopedMocks, testCaseRows(node, scopedFixtures, scopedMocks));
             return;
         }
         if (node.type === 'it') {
             const nextPath = [...path, str(getProps(node).name) || 'it'];
+            const scopedCases = testCaseRows(node, scopedFixtures, scopedMocks);
             for (const child of node.children || []) {
-                if (child.type === 'expect')
-                    pushExpectation(child, nextPath, scopedFixtures);
+                if (child.type === 'expect') {
+                    const expectCases = testCaseRows(child, scopedFixtures, scopedMocks);
+                    pushExpectation(child, nextPath, scopedFixtures, scopedMocks, expectCases.length > 0 ? expectCases : scopedCases);
+                }
             }
             return;
         }
         if (node.type === 'describe') {
             const nextPath = [...path, str(getProps(node).name) || 'describe'];
             for (const child of node.children || [])
-                visit(child, nextPath, scopedFixtures);
+                visit(child, nextPath, scopedFixtures, scopedMocks);
             return;
         }
         for (const child of node.children || [])
-            visit(child, path, scopedFixtures);
+            visit(child, path, scopedFixtures, scopedMocks);
     }
-    visit(testNode, [], []);
+    visit(testNode, [], [], []);
     return assertions;
 }
 function assertionLabel(node) {
@@ -544,15 +685,71 @@ function assertionLabel(node) {
     const to = str(props.to);
     const reaches = str(props.reaches);
     const no = str(props.no);
+    const has = str(props.has);
     const guard = str(props.guard);
     const expr = exprToString(props.expr);
     const fn = str(props.fn);
     const derive = str(props.derive);
+    const route = str(props.route);
+    const tool = str(props.tool);
+    const effect = str(props.effect);
+    const mock = str(props.mock);
+    const importAssertion = 'import' in props;
+    const importSource = importAssertionSourcePath(node);
+    const codegen = 'codegen' in props;
+    const decompileAssertion = 'decompile' in props;
+    const roundtrip = 'roundtrip' in props;
     const args = exprToString(props.args);
     const withValue = exprToString(props.with);
+    const input = exprToString(props.input);
     const equals = props.equals === undefined ? '' : exprToString(props.equals) || String(props.equals);
+    const returns = props.returns === undefined ? '' : exprToString(props.returns) || String(props.returns);
+    const fallback = props.fallback === undefined ? '' : exprToString(props.fallback) || String(props.fallback);
+    const recovers = props.recovers === undefined ? '' : String(props.recovers || 'true');
+    const contains = props.contains === undefined ? '' : String(props.contains);
+    const notContains = props.notContains === undefined ? '' : String(props.notContains);
     const matches = props.matches === undefined ? '' : String(props.matches);
+    const unmapped = props.unmapped === undefined ? '' : String(props.unmapped);
     const throws = props.throws === undefined ? '' : String(props.throws || 'true');
+    const called = props.called === undefined ? '' : String(props.called);
+    if (importAssertion) {
+        const parts = [`import${importSource ? ` ${importSource}` : ''}`];
+        if (contains)
+            parts.push(`contains ${contains}`);
+        if (notContains)
+            parts.push(`notContains ${notContains}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        if (roundtrip)
+            parts.push('roundtrip');
+        if (unmapped)
+            parts.push(`unmapped ${unmapped}`);
+        if (no === 'unmapped')
+            parts.push('no unmapped');
+        return parts.join(' ');
+    }
+    if (decompileAssertion) {
+        const parts = ['decompile'];
+        if (contains)
+            parts.push(`contains ${contains}`);
+        if (notContains)
+            parts.push(`notContains ${notContains}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        return parts.join(' ');
+    }
+    if (roundtrip)
+        return 'roundtrip';
+    if (codegen) {
+        const parts = ['codegen'];
+        if (contains)
+            parts.push(`contains ${contains}`);
+        if (notContains)
+            parts.push(`notContains ${notContains}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        return parts.join(' ');
+    }
     if (preset)
         return `preset ${preset}`;
     if (nodeType) {
@@ -569,6 +766,9 @@ function assertionLabel(node) {
     }
     if (no)
         return `${machine ? `machine ${machine} ` : ''}no ${no}`;
+    if (has) {
+        return `${machine ? `machine ${machine} ` : ''}has ${has}${count ? ` count ${count}` : ''}${matches ? ` matches ${matches}` : ''}`;
+    }
     if (guard)
         return `guard ${guard} exhaustive`;
     if (machine && transition) {
@@ -605,6 +805,60 @@ function assertionLabel(node) {
             parts.push(`throws ${throws}`);
         return parts.join(' ');
     }
+    if (route) {
+        const parts = [`route ${route}`];
+        if (withValue)
+            parts.push(`with ${withValue}`);
+        if (input)
+            parts.push(`input ${input}`);
+        if (returns)
+            parts.push(`returns ${returns}`);
+        if (equals)
+            parts.push(`equals ${equals}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        if (throws)
+            parts.push(`throws ${throws}`);
+        return parts.join(' ');
+    }
+    if (tool) {
+        const parts = [`tool ${tool}`];
+        if (withValue)
+            parts.push(`with ${withValue}`);
+        if (input)
+            parts.push(`input ${input}`);
+        if (returns)
+            parts.push(`returns ${returns}`);
+        if (equals)
+            parts.push(`equals ${equals}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        if (throws)
+            parts.push(`throws ${throws}`);
+        return parts.join(' ');
+    }
+    if (effect) {
+        const parts = [`effect ${effect}`];
+        if (returns)
+            parts.push(`returns ${returns}`);
+        if (recovers)
+            parts.push(`recovers ${recovers}`);
+        if (fallback)
+            parts.push(`fallback ${fallback}`);
+        if (equals)
+            parts.push(`equals ${equals}`);
+        if (matches)
+            parts.push(`matches ${matches}`);
+        if (throws)
+            parts.push(`throws ${throws}`);
+        return parts.join(' ');
+    }
+    if (mock) {
+        const parts = [`mock ${mock}`];
+        if (called)
+            parts.push(`called ${called}`);
+        return parts.join(' ');
+    }
     if (expr && equals)
         return `expr ${expr} equals ${equals}`;
     if (expr && matches)
@@ -1189,6 +1443,15 @@ function assertionCoversAnyInvariant(node, invariants) {
 function syntheticTarget(root) {
     return { file: '<coverage>', root, diagnostics: [], schemaViolations: [], semanticViolations: [] };
 }
+function testNodeContributesCoverage(node) {
+    const raw = getProps(node).coverage;
+    if (raw === undefined || raw === '')
+        return true;
+    if (raw === false)
+        return false;
+    const value = String(raw).toLowerCase();
+    return !['0', 'false', 'off', 'ignore', 'ignored', 'exclude', 'excluded', 'none'].includes(value);
+}
 function coveredTransitionsFromAssertion(root, assertion) {
     const props = getProps(assertion);
     const machineName = str(props.machine);
@@ -1244,12 +1507,9 @@ function findUntestedGuards(root, context) {
     const assertions = context?.assertions || [];
     if (assertions.some((assertion) => assertionCoversAnyInvariant(assertion.node, guardCoverageInvariants)))
         return [];
-    const explicitlyCovered = new Set(assertions.map((assertion) => str(getProps(assertion.node).guard)).filter(Boolean));
+    const covered = coveredGuardKeys(root, assertions);
     return collectNodes(root, 'guard')
-        .filter((guard) => {
-        const name = str(getProps(guard).name);
-        return !name || !explicitlyCovered.has(name);
-    })
+        .filter((guard) => !covered.has(runtimeGuardCoverageKey(guard)))
         .map((guard) => {
         const name = str(getProps(guard).name);
         return name
@@ -1257,6 +1517,153 @@ function findUntestedGuards(root, context) {
             : `unnamed guard at line ${guard.loc?.line ?? '?'}`;
     });
 }
+function coveredGuardKeys(root, assertions) {
+    const target = syntheticTarget(root);
+    const covered = new Set();
+    for (const assertion of assertions) {
+        const props = getProps(assertion.node);
+        const guardName = str(props.guard);
+        if (guardName) {
+            for (const guard of collectNodes(root, 'guard')) {
+                if (str(getProps(guard).name) === guardName)
+                    covered.add(runtimeGuardCoverageKey(guard));
+            }
+            continue;
+        }
+        const routeSpec = str(props.route);
+        if (routeSpec) {
+            const guardCalls = new Map();
+            const evaluated = evaluateRuntimeRoute(assertion.node, target, assertion.fixtures, assertion.mocks, new Map(), undefined, guardCalls);
+            if (evaluated.passed) {
+                for (const [key, count] of guardCalls)
+                    if (count > 0)
+                        covered.add(key);
+            }
+            continue;
+        }
+        const toolName = str(props.tool);
+        if (toolName) {
+            const guardCalls = new Map();
+            const evaluated = evaluateRuntimeTool(assertion.node, target, assertion.fixtures, assertion.mocks, new Map(), undefined, guardCalls);
+            if (evaluated.passed) {
+                for (const [key, count] of guardCalls)
+                    if (count > 0)
+                        covered.add(key);
+            }
+        }
+    }
+    return covered;
+}
+function coveredRouteLabels(root, assertions) {
+    const target = syntheticTarget(root);
+    const covered = new Set();
+    for (const assertion of assertions) {
+        const routeSpec = str(getProps(assertion.node).route);
+        if (!routeSpec)
+            continue;
+        const found = findRuntimeRoute(target, routeSpec);
+        if (!found.route)
+            continue;
+        const evaluated = evaluateRuntimeRoute(assertion.node, target, assertion.fixtures, assertion.mocks, new Map());
+        if (evaluated.passed)
+            covered.add(runtimeRouteLabel(found.route));
+    }
+    return covered;
+}
+function routeCoverage(root, assertions) {
+    const covered = coveredRouteLabels(root, assertions);
+    const routes = collectNodes(root, 'route');
+    const uncovered = routes
+        .filter((route) => !covered.has(runtimeRouteLabel(route)))
+        .map((route) => `route ${runtimeRouteLabel(route)} at line ${route.loc?.line ?? '?'}`);
+    return coverageMetric(routes.length, uncovered);
+}
+function findUntestedRoutes(root, context) {
+    return routeCoverage(root, context?.assertions || []).uncovered;
+}
+function coveredToolNames(root, assertions) {
+    const target = syntheticTarget(root);
+    const covered = new Set();
+    for (const assertion of assertions) {
+        const toolName = str(getProps(assertion.node).tool);
+        if (!toolName)
+            continue;
+        const found = findRuntimeTool(target, toolName);
+        if (!found.tool)
+            continue;
+        const evaluated = evaluateRuntimeTool(assertion.node, target, assertion.fixtures, assertion.mocks, new Map());
+        if (evaluated.passed)
+            covered.add(runtimeToolName(found.tool));
+    }
+    return covered;
+}
+function toolCoverage(root, assertions) {
+    const covered = coveredToolNames(root, assertions);
+    const tools = collectNodes(root, 'tool');
+    const uncovered = tools
+        .filter((tool) => !covered.has(runtimeToolName(tool)))
+        .map((tool) => `tool ${runtimeToolName(tool)} at line ${tool.loc?.line ?? '?'}`);
+    return coverageMetric(tools.length, uncovered);
+}
+function findUntestedTools(root, context) {
+    return toolCoverage(root, context?.assertions || []).uncovered;
+}
+function runtimeEffectNodes(root) {
+    return collectNodes(root, 'effect').filter((effect) => {
+        const name = str(getProps(effect).name);
+        return Boolean(name && getChildren(effect, 'trigger').length > 0);
+    });
+}
+function coveredEffectKeys(root, assertions) {
+    const target = syntheticTarget(root);
+    const covered = new Set();
+    for (const assertion of assertions) {
+        const props = getProps(assertion.node);
+        const effectName = str(props.effect);
+        if (effectName) {
+            const found = findRuntimeEffect(target, effectName);
+            if (!found.effect)
+                continue;
+            const evaluated = evaluateRuntimeEffect(assertion.node, target, assertion.fixtures, assertion.mocks, new Map());
+            if (evaluated.passed)
+                covered.add(runtimeEffectCoverageKey(found.effect));
+            continue;
+        }
+        const routeSpec = str(props.route);
+        if (routeSpec) {
+            const effectCalls = new Map();
+            const evaluated = evaluateRuntimeRoute(assertion.node, target, assertion.fixtures, assertion.mocks, new Map(), effectCalls);
+            if (evaluated.passed) {
+                for (const [key, count] of effectCalls)
+                    if (count > 0)
+                        covered.add(key);
+            }
+            continue;
+        }
+        const toolName = str(props.tool);
+        if (toolName) {
+            const effectCalls = new Map();
+            const evaluated = evaluateRuntimeTool(assertion.node, target, assertion.fixtures, assertion.mocks, new Map(), effectCalls);
+            if (evaluated.passed) {
+                for (const [key, count] of effectCalls)
+                    if (count > 0)
+                        covered.add(key);
+            }
+        }
+    }
+    return covered;
+}
+function effectCoverage(root, assertions) {
+    const covered = coveredEffectKeys(root, assertions);
+    const effects = runtimeEffectNodes(root);
+    const uncovered = effects
+        .filter((effect) => !covered.has(runtimeEffectCoverageKey(effect)))
+        .map((effect) => `effect ${runtimeEffectName(effect)} at line ${effect.loc?.line ?? '?'}`);
+    return coverageMetric(effects.length, uncovered);
+}
+function findUntestedEffects(root, context) {
+    return effectCoverage(root, context?.assertions || []).uncovered;
+}
 function coverageMetric(total, uncovered) {
     const covered = Math.max(0, total - uncovered.length);
     return {
@@ -1279,20 +1686,29 @@ function emptyCoverageSummary() {
         percent: 100,
         transitions: empty,
         guards: empty,
+        routes: empty,
+        tools: empty,
+        effects: empty,
         targets: [],
     };
 }
 function combineCoverageSummaries(summaries) {
     const transitions = combineCoverageMetrics(summaries.map((summary) => summary.transitions));
     const guards = combineCoverageMetrics(summaries.map((summary) => summary.guards));
-    const total = transitions.total + guards.total;
-    const covered = transitions.covered + guards.covered;
+    const routes = combineCoverageMetrics(summaries.map((summary) => summary.routes));
+    const tools = combineCoverageMetrics(summaries.map((summary) => summary.tools));
+    const effects = combineCoverageMetrics(summaries.map((summary) => summary.effects));
+    const total = transitions.total + guards.total + routes.total + tools.total + effects.total;
+    const covered = transitions.covered + guards.covered + routes.covered + tools.covered + effects.covered;
     return {
         total,
         covered,
         percent: total === 0 ? 100 : Math.round((covered / total) * 10000) / 100,
         transitions,
         guards,
+        routes,
+        tools,
+        effects,
         targets: summaries.flatMap((summary) => summary.targets),
     };
 }
@@ -1338,12 +1754,9 @@ function guardCoverage(root, assertions) {
     if (assertions.some((assertion) => assertionCoversAnyInvariant(assertion.node, guardCoverageInvariants))) {
         return coverageMetric(guards.length, []);
     }
-    const explicitlyCovered = new Set(assertions.map((assertion) => str(getProps(assertion.node).guard)).filter(Boolean));
+    const covered = coveredGuardKeys(root, assertions);
     const uncovered = guards
-        .filter((guard) => {
-        const name = str(getProps(guard).name);
-        return !name || !explicitlyCovered.has(name);
-    })
+        .filter((guard) => !covered.has(runtimeGuardCoverageKey(guard)))
         .map((guard) => {
         const name = str(getProps(guard).name);
         return name
@@ -1358,25 +1771,37 @@ function coverageForTarget(target, assertions) {
             file: target.file,
             transitions: coverageMetric(0, []),
             guards: coverageMetric(0, []),
+            routes: coverageMetric(0, []),
+            tools: coverageMetric(0, []),
+            effects: coverageMetric(0, []),
         };
     }
     return {
         file: target.file,
         transitions: machineTransitionCoverage(target.root, assertions),
         guards: guardCoverage(target.root, assertions),
+        routes: routeCoverage(target.root, assertions),
+        tools: toolCoverage(target.root, assertions),
+        effects: effectCoverage(target.root, assertions),
     };
 }
 function createCoverageSummary(targets) {
     const transitions = combineCoverageMetrics(targets.map((target) => target.transitions));
     const guards = combineCoverageMetrics(targets.map((target) => target.guards));
-    const total = transitions.total + guards.total;
-    const covered = transitions.covered + guards.covered;
+    const routes = combineCoverageMetrics(targets.map((target) => target.routes));
+    const tools = combineCoverageMetrics(targets.map((target) => target.tools));
+    const effects = combineCoverageMetrics(targets.map((target) => target.effects));
+    const total = transitions.total + guards.total + routes.total + tools.total + effects.total;
+    const covered = transitions.covered + guards.covered + routes.covered + tools.covered + effects.covered;
     return {
         total,
         covered,
         percent: total === 0 ? 100 : Math.round((covered / total) * 10000) / 100,
         transitions,
         guards,
+        routes,
+        tools,
+        effects,
         targets,
     };
 }
@@ -1395,128 +1820,1801 @@ function findCodegenErrors(root) {
     }
     return failures;
 }
-const RUNTIME_EXPR_TIMEOUT_MS = 100;
-const RUNTIME_ASYNC_PROCESS_TIMEOUT_MS = 1500;
-const RUNTIME_EXPR_UNSAFE_TOKEN = /\b(?:async|class|constructor|Date|delete|do|eval|fetch|for|Function|global|globalThis|import|new|process|prototype|require|setInterval|setTimeout|switch|this|throw|try|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
-const RUNTIME_FN_UNSAFE_TOKEN = /\b(?:class|constructor|Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
-function unsafeRuntimeExpressionReason(source, options = {}) {
-    if (source.length > 2000)
-        return 'expression is longer than 2000 characters';
-    if (/[\r\n;]/.test(source))
-        return 'multi-statement expressions are not supported';
-    const unsafeToken = source.match(RUNTIME_EXPR_UNSAFE_TOKEN)?.[0];
-    if (unsafeToken)
-        return `unsupported token '${unsafeToken}'`;
-    if (!options.allowAwait && /\bawait\b/.test(source))
-        return "unsupported token 'await'";
-    if (/(^|[^=!<>])=(?!=|>)/.test(source))
-        return 'assignment is not supported';
-    return undefined;
-}
-function unsafeRuntimeFunctionReason(source) {
-    if (source.length > 5000)
-        return 'function body is longer than 5000 characters';
-    const unsafeToken = source.match(RUNTIME_FN_UNSAFE_TOKEN)?.[0];
-    if (unsafeToken)
-        return `unsupported token '${unsafeToken}'`;
-    return undefined;
-}
-function isRuntimeBindingName(value) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
-}
-function runtimeBindingSource(node) {
-    if (node.type === 'const')
-        return { expr: exprPropToRuntimeSource(node, 'value'), kind: 'expr' };
-    if (node.type === 'derive' || node.type === 'let') {
-        return { expr: exprPropToRuntimeSource(node, 'value') || exprPropToRuntimeSource(node, 'expr'), kind: 'expr' };
-    }
-    if (node.type === 'fn')
-        return { expr: runtimeFunctionExpr(node), kind: 'fn' };
-    return undefined;
-}
-function runtimeParamNames(node) {
-    const names = [];
-    for (const param of getChildren(node, 'param')) {
-        const name = str(getProps(param).name);
-        if (name)
-            names.push(name);
+function generatedCoreSource(root) {
+    const chunks = [];
+    for (const node of codegenRoots(root)) {
+        try {
+            chunks.push(...generateCoreNode(node));
+        }
+        catch (error) {
+            return {
+                message: `${nodeLabel(node)} at line ${node.loc?.line ?? '?'}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
     }
-    if (names.length > 0)
-        return names;
-    return parseLegacyParamNames(str(getProps(node).params));
-}
-function runtimeFunctionExpr(node) {
-    const code = handlerText(node);
-    if (!code)
-        return '';
-    const params = runtimeParamNames(node);
-    if (!params.every(isRuntimeBindingName))
-        return '';
-    const asyncKw = isTruthy(getProps(node).async) ? 'async ' : '';
-    return `(${asyncKw}(${params.join(', ')}) => {\n${code.trim()}\n})`;
+    return { code: chunks.join('\n') };
 }
-function collectRuntimeBindings(root) {
-    const bindings = [];
-    function visit(node) {
-        if (node.type === 'const' || node.type === 'derive' || node.type === 'let' || node.type === 'fn') {
-            const name = str(getProps(node).name);
-            const binding = runtimeBindingSource(node);
-            if (name && binding?.expr) {
-                bindings.push({
-                    name,
-                    expr: binding.expr,
-                    kind: binding.kind,
-                    line: node.loc?.line,
-                });
-            }
+function decompiledCoreSource(root) {
+    const chunks = [];
+    for (const node of codegenRoots(root)) {
+        try {
+            chunks.push(decompile(node).code);
+        }
+        catch (error) {
+            return {
+                message: `${nodeLabel(node)} at line ${node.loc?.line ?? '?'}: ${error instanceof Error ? error.message : String(error)}`,
+            };
         }
-        for (const child of node.children || [])
-            visit(child);
     }
-    visit(root);
-    return bindings;
+    return { code: chunks.filter(Boolean).join('\n') };
 }
-function orderRuntimeBindings(bindings, entryExpr) {
-    const byName = new Map();
-    for (const binding of bindings) {
-        if (!isRuntimeBindingName(binding.name)) {
-            return { ordered: [], error: `invalid runtime binding name '${binding.name}' at line ${binding.line ?? '?'}` };
-        }
-        byName.set(binding.name, [...(byName.get(binding.name) || []), binding]);
+function evaluateSourceTextAssertion(node, source, label) {
+    const props = getProps(node);
+    const contains = str(props.contains);
+    const notContains = str(props.notContains);
+    const matches = str(props.matches);
+    if (!contains && !notContains && !matches) {
+        return { passed: false, message: `${label} assertion requires contains=, notContains=, or matches=` };
     }
-    const ordered = [];
-    const visiting = new Set();
-    const visited = new Set();
-    const stack = [];
-    function depsIn(source) {
-        return [...byName.keys()].filter((name) => new RegExp(`\\b${escapeRegExp(name)}\\b`).test(source));
+    if (contains && !source.includes(contains)) {
+        return { passed: false, message: `${label} does not contain ${JSON.stringify(contains)}` };
     }
-    function bindingFor(name) {
-        const candidates = byName.get(name) || [];
-        if (candidates.length <= 1)
-            return candidates[0];
-        const [first, ...rest] = candidates;
-        throw new Error(`duplicate runtime binding '${name}' at line ${rest[0].line ?? '?'} (first at line ${first.line ?? '?'})`);
+    if (notContains && source.includes(notContains)) {
+        return { passed: false, message: `${label} unexpectedly contains ${JSON.stringify(notContains)}` };
     }
-    function visit(name) {
-        if (visited.has(name))
-            return undefined;
-        if (visiting.has(name)) {
-            const start = stack.indexOf(name);
-            return `runtime binding cycle: ${[...stack.slice(start), name].join(' -> ')}`;
-        }
-        let binding;
+    if (matches) {
         try {
-            binding = bindingFor(name);
+            if (!new RegExp(matches).test(source))
+                return { passed: false, message: `${label} does not match /${matches}/` };
         }
-        catch (error) {
-            return error instanceof Error ? error.message : String(error);
+        catch {
+            return { passed: false, message: `Invalid ${label.toLowerCase()} matches regex: ${matches}` };
         }
-        if (!binding)
-            return undefined;
-        visiting.add(name);
-        stack.push(name);
+    }
+    return { passed: true };
+}
+function evaluateCodegenAssertion(node, target) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    if (!target.root)
+        return { passed: false, message: 'Target has no parsed KERN root' };
+    const generated = generatedCoreSource(target.root);
+    if (generated.message || generated.code === undefined) {
+        return { passed: false, message: `Target has codegen error: ${generated.message || 'unknown error'}` };
+    }
+    return evaluateSourceTextAssertion(node, generated.code, 'Generated code');
+}
+function evaluateDecompileAssertion(node, target) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    if (!target.root)
+        return { passed: false, message: 'Target has no parsed KERN root' };
+    const decompiled = decompiledCoreSource(target.root);
+    if (decompiled.message || decompiled.code === undefined) {
+        return { passed: false, message: `Target has decompile error: ${decompiled.message || 'unknown error'}` };
+    }
+    return evaluateSourceTextAssertion(node, decompiled.code, 'Decompiled KERN');
+}
+function evaluateRoundtripAssertion(_node, target) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    if (!target.root)
+        return { passed: false, message: 'Target has no parsed KERN root' };
+    const decompiled = decompiledCoreSource(target.root);
+    if (decompiled.message || decompiled.code === undefined) {
+        return { passed: false, message: `Target has decompile error: ${decompiled.message || 'unknown error'}` };
+    }
+    const reparsed = parseDocumentWithDiagnostics(decompiled.code);
+    const parseError = reparsed.diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (parseError) {
+        return {
+            passed: false,
+            message: `Decompiled KERN does not reparse at ${parseError.line}:${parseError.col}: ${parseError.message}`,
+        };
+    }
+    const schemaViolation = validateSchema(reparsed.root)[0];
+    if (schemaViolation) {
+        return {
+            passed: false,
+            message: `Decompiled KERN has schema violation at ${schemaViolation.line ?? 1}:${schemaViolation.col ?? 1}: ${schemaViolation.message}`,
+        };
+    }
+    const semanticViolation = validateSemantics(reparsed.root).filter((violation) => !isMultiSourceTransitionFalsePositive(violation, reparsed.root))[0];
+    if (semanticViolation) {
+        return {
+            passed: false,
+            message: `Decompiled KERN has semantic violation at ${semanticViolation.line ?? 1}:${semanticViolation.col ?? 1}: ${semanticViolation.message}`,
+        };
+    }
+    const originalGenerated = generatedCoreSource(target.root);
+    if (originalGenerated.message || originalGenerated.code === undefined) {
+        return { passed: false, message: `Target has codegen error: ${originalGenerated.message || 'unknown error'}` };
+    }
+    const roundtripGenerated = generatedCoreSource(reparsed.root);
+    if (roundtripGenerated.message || roundtripGenerated.code === undefined) {
+        return {
+            passed: false,
+            message: `Decompiled KERN has codegen error: ${roundtripGenerated.message || 'unknown error'}`,
+        };
+    }
+    if (originalGenerated.code !== roundtripGenerated.code) {
+        return { passed: false, message: 'Round-trip changed generated core code' };
+    }
+    return { passed: true };
+}
+function importAssertionSourcePath(node) {
+    const props = getProps(node);
+    const importValue = str(props.import);
+    if (importValue && importValue !== 'true')
+        return importValue;
+    return str(props.from) || '';
+}
+function resolveImportAssertionSource(node, context) {
+    const props = getProps(node);
+    const inlineSource = str(props.source);
+    if (inlineSource)
+        return { source: inlineSource, fileName: 'inline.ts' };
+    const sourcePath = importAssertionSourcePath(node);
+    if (!sourcePath)
+        return { message: 'Import assertion requires import=<ts-file> or from=<ts-file>' };
+    const baseDir = context?.testFile ? dirname(context.testFile) : process.cwd();
+    const fileName = resolve(baseDir, sourcePath);
+    try {
+        return { source: readFileSync(fileName, 'utf-8'), fileName };
+    }
+    catch (error) {
+        return {
+            message: `Could not read import source ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function evaluateImportedKernRoundtrip(kern, options = {}) {
+    const reparsed = parseDocumentWithDiagnostics(kern);
+    const parseError = reparsed.diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (parseError) {
+        return {
+            passed: false,
+            message: `Imported KERN does not reparse at ${parseError.line}:${parseError.col}: ${parseError.message}`,
+        };
+    }
+    const parseWarning = reparsed.diagnostics.find((diagnostic) => diagnostic.severity === 'warning');
+    if (parseWarning && !options.allowWarnings) {
+        return {
+            passed: false,
+            message: `Imported KERN has parser warning at ${parseWarning.line}:${parseWarning.col}: ${parseWarning.message}`,
+        };
+    }
+    const schemaViolation = validateSchema(reparsed.root)[0];
+    if (schemaViolation) {
+        return {
+            passed: false,
+            message: `Imported KERN has schema violation at ${schemaViolation.line ?? 1}:${schemaViolation.col ?? 1}: ${schemaViolation.message}`,
+        };
+    }
+    const semanticViolation = validateSemantics(reparsed.root).filter((violation) => !isMultiSourceTransitionFalsePositive(violation, reparsed.root))[0];
+    if (semanticViolation) {
+        return {
+            passed: false,
+            message: `Imported KERN has semantic violation at ${semanticViolation.line ?? 1}:${semanticViolation.col ?? 1}: ${semanticViolation.message}`,
+        };
+    }
+    const generated = generatedCoreSource(reparsed.root);
+    if (generated.message || generated.code === undefined) {
+        return { passed: false, message: `Imported KERN has codegen error: ${generated.message || 'unknown error'}` };
+    }
+    return { passed: true };
+}
+function formatImportUnmapped(unmapped) {
+    if (unmapped.length === 0)
+        return 'no unmapped TypeScript statements';
+    const shown = unmapped.slice(0, 5).join('; ');
+    const suffix = unmapped.length > 5 ? `; +${unmapped.length - 5} more` : '';
+    return `${unmapped.length} unmapped TypeScript statement(s): ${shown}${suffix}`;
+}
+function evaluateImportAssertion(node, context) {
+    const props = getProps(node);
+    const hasTextAssertion = 'contains' in props || 'notContains' in props || 'matches' in props;
+    const hasRoundtripAssertion = 'roundtrip' in props;
+    const hasUnmappedAssertion = 'unmapped' in props || str(props.no) === 'unmapped';
+    if (!hasTextAssertion && !hasRoundtripAssertion && !hasUnmappedAssertion) {
+        return {
+            passed: false,
+            message: 'Import assertion requires contains=, notContains=, matches=, roundtrip=true, unmapped=<count>, or no=unmapped',
+        };
+    }
+    const resolved = resolveImportAssertionSource(node, context);
+    if (resolved.message || resolved.source === undefined) {
+        return { passed: false, message: resolved.message || 'Could not resolve import source' };
+    }
+    let imported;
+    try {
+        imported = importTypeScript(resolved.source, resolved.fileName || 'input.ts');
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: `TypeScript import failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (str(props.no) === 'unmapped' && imported.unmapped.length > 0) {
+        return {
+            passed: false,
+            message: `Import expected no unmapped TypeScript, found ${formatImportUnmapped(imported.unmapped)}`,
+        };
+    }
+    if ('unmapped' in props) {
+        const expected = Number(props.unmapped);
+        if (!Number.isInteger(expected) || expected < 0) {
+            return { passed: false, message: 'Import assertion requires unmapped=<non-negative integer>' };
+        }
+        if (imported.unmapped.length !== expected) {
+            return {
+                passed: false,
+                message: `Import expected ${expected} unmapped TypeScript statement(s), found ${formatImportUnmapped(imported.unmapped)}`,
+            };
+        }
+    }
+    if (hasTextAssertion) {
+        const sourceAssertion = evaluateSourceTextAssertion(node, imported.kern, 'Imported KERN');
+        if (!sourceAssertion.passed)
+            return sourceAssertion;
+    }
+    if (hasRoundtripAssertion) {
+        const roundtrip = evaluateImportedKernRoundtrip(imported.kern, { allowWarnings: isTruthy(props.allowWarnings) });
+        if (!roundtrip.passed)
+            return roundtrip;
+    }
+    return { passed: true };
+}
+const RUNTIME_EXPR_TIMEOUT_MS = 100;
+const RUNTIME_ASYNC_PROCESS_TIMEOUT_MS = 1500;
+const RUNTIME_EXPR_UNSAFE_TOKEN = /\b(?:async|class|constructor|Date|delete|do|eval|fetch|for|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|throw|try|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
+const RUNTIME_FN_UNSAFE_TOKEN = /\b(?:class|constructor|Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|with|WebSocket|XMLHttpRequest|__proto__)\b/;
+const RUNTIME_CLASS_UNSAFE_TOKEN = /\b(?:Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|with|WebSocket|XMLHttpRequest|__proto__)\b/;
+const RUNTIME_NATIVE_BINDING_UNSAFE_TOKEN = /\b(?:class|constructor|Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|throw|try|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
+const RUNTIME_WORKFLOW_BINDING_UNSAFE_TOKEN = /\b(?:class|constructor|Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
+function unsafeRuntimeExpressionReason(source, options = {}) {
+    if (source.length > 2000)
+        return 'expression is longer than 2000 characters';
+    if (/[\r\n;]/.test(source))
+        return 'multi-statement expressions are not supported';
+    const unsafeToken = source.match(RUNTIME_EXPR_UNSAFE_TOKEN)?.[0];
+    if (unsafeToken)
+        return `unsupported token '${unsafeToken}'`;
+    if (!options.allowAwait && /\bawait\b/.test(source))
+        return "unsupported token 'await'";
+    if (/(^|[^=!<>])=(?!=|>)/.test(source))
+        return 'assignment is not supported';
+    return undefined;
+}
+function unsafeRuntimeFunctionReason(source) {
+    if (source.length > 5000)
+        return 'function body is longer than 5000 characters';
+    const unsafeToken = source.match(RUNTIME_FN_UNSAFE_TOKEN)?.[0];
+    if (unsafeToken)
+        return `unsupported token '${unsafeToken}'`;
+    return undefined;
+}
+function unsafeRuntimeClassReason(source) {
+    if (source.length > 10000)
+        return 'class body is longer than 10000 characters';
+    const unsafeToken = source.match(RUNTIME_CLASS_UNSAFE_TOKEN)?.[0];
+    if (unsafeToken)
+        return `unsupported token '${unsafeToken}'`;
+    return undefined;
+}
+function unsafeRuntimeNativeBindingReason(source) {
+    if (source.length > 5000)
+        return 'native binding expression is longer than 5000 characters';
+    const unsafeToken = source.match(RUNTIME_NATIVE_BINDING_UNSAFE_TOKEN)?.[0];
+    if (unsafeToken)
+        return `unsupported token '${unsafeToken}'`;
+    return undefined;
+}
+function unsafeRuntimeWorkflowReason(source) {
+    if (source.length > 10000)
+        return 'workflow expression is longer than 10000 characters';
+    const unsafeToken = source.match(RUNTIME_WORKFLOW_BINDING_UNSAFE_TOKEN)?.[0];
+    if (unsafeToken)
+        return `unsupported token '${unsafeToken}'`;
+    return undefined;
+}
+function isRuntimeBindingName(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}
+function transformRuntimeCodeSegments(source, transform) {
+    let output = '';
+    let segmentStart = 0;
+    let index = 0;
+    function flush(until) {
+        if (until > segmentStart)
+            output += transform(source.slice(segmentStart, until));
+    }
+    while (index < source.length) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (char === '/' && next === '/') {
+            flush(index);
+            const end = source.indexOf('\n', index + 2);
+            const commentEnd = end === -1 ? source.length : end;
+            output += source.slice(index, commentEnd);
+            index = commentEnd;
+            segmentStart = index;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            flush(index);
+            const end = source.indexOf('*/', index + 2);
+            const commentEnd = end === -1 ? source.length : end + 2;
+            output += source.slice(index, commentEnd);
+            index = commentEnd;
+            segmentStart = index;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            flush(index);
+            const quote = char;
+            let end = index + 1;
+            while (end < source.length) {
+                if (source[end] === '\\') {
+                    end += 2;
+                    continue;
+                }
+                if (source[end] === quote) {
+                    end += 1;
+                    break;
+                }
+                end += 1;
+            }
+            output += source.slice(index, end);
+            index = end;
+            segmentStart = index;
+            continue;
+        }
+        index += 1;
+    }
+    flush(source.length);
+    return output;
+}
+function runtimeJsSource(source) {
+    return transformRuntimeCodeSegments(source, (segment) => segment
+        .replace(/\s+as\s+(?:const|any|unknown|never|[A-Za-z_$][\w$]*(?:<[^;\n(){}=]*>)?(?:\[\])?(?:\s*\|\s*[A-Za-z_$][\w$]*(?:<[^;\n(){}=]*>)?(?:\[\])?)*)/g, '')
+        .replace(/\b(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*[^=;\n]+(?=\s*=)/g, '$1 $2')
+        .replace(/([,(]\s*[A-Za-z_$][\w$]*)\s*:\s*[^,)]+(?=\s*[,)]\s*=>)/g, '$1')
+        .replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*:\s*[^{]+{/g, 'function $1($2) {'));
+}
+function runtimeConstHandlerExpr(node) {
+    const code = runtimeJsSource(handlerText(node).trim());
+    if (!code)
+        return '';
+    if (/^\s*(?:return|const|let|var|if|for|while|try|throw)\b/.test(code) || /;\s*$/.test(code)) {
+        return `(() => {\n${code}\n})()`;
+    }
+    return `(${code})`;
+}
+function runtimeBindingSource(node) {
+    if (node.type === 'const') {
+        const value = exprPropToRuntimeSource(node, 'value');
+        if (value)
+            return { expr: runtimeJsSource(value), kind: 'expr' };
+        const handlerExpr = runtimeConstHandlerExpr(node);
+        if (handlerExpr)
+            return { expr: handlerExpr, kind: 'native' };
+        return { expr: '', kind: 'expr' };
+    }
+    if (node.type === 'derive' || node.type === 'let') {
+        return {
+            expr: runtimeJsSource(exprPropToRuntimeSource(node, 'value') || exprPropToRuntimeSource(node, 'expr')),
+            kind: 'expr',
+        };
+    }
+    if (node.type === 'fn')
+        return { expr: runtimeFunctionExpr(node), kind: 'fn' };
+    if (node.type === 'class')
+        return { expr: runtimeClassExpr(node), kind: 'class' };
+    if (node.type === 'mapLit')
+        return { expr: runtimeMapLitExpr(node), kind: 'native' };
+    if (node.type === 'setLit')
+        return { expr: runtimeSetLitExpr(node), kind: 'native' };
+    if (node.type === 'collect')
+        return { expr: runtimeCollectBindingExpr(node), kind: 'native' };
+    const arrayExpr = runtimeArrayBindingExpr(node);
+    if (arrayExpr !== undefined)
+        return { expr: arrayExpr, kind: 'native' };
+    return undefined;
+}
+function runtimeParamNames(node) {
+    const names = [];
+    for (const param of getChildren(node, 'param')) {
+        const name = str(getProps(param).name);
+        if (name)
+            names.push(name);
+    }
+    if (names.length > 0)
+        return names;
+    return parseLegacyParamNames(str(getProps(node).params));
+}
+function runtimeFunctionExpr(node) {
+    const code = runtimeJsSource(handlerText(node));
+    if (!code)
+        return '';
+    const params = runtimeParamNames(node);
+    if (!params.every(isRuntimeBindingName))
+        return '';
+    const asyncKw = isTruthy(getProps(node).async) ? 'async ' : '';
+    return `(${asyncKw}(${params.join(', ')}) => {\n${code.trim()}\n})`;
+}
+function runtimeHandlerLines(node, spaces = 4) {
+    const prefix = ' '.repeat(spaces);
+    const code = runtimeJsSource(handlerText(node).trim());
+    if (!code)
+        return [];
+    return code.split('\n').map((line) => `${prefix}${line}`);
+}
+function runtimeClassFieldInitializers(node) {
+    const lines = [];
+    for (const field of getChildren(node, 'field')) {
+        const props = getProps(field);
+        if (isTruthy(props.static))
+            continue;
+        const name = str(props.name);
+        if (!isRuntimeBindingName(name))
+            return [];
+        const value = exprPropToRuntimeSource(field, 'value') || rawPropToRuntimeSource(field, 'default');
+        if (value)
+            lines.push(`    this.${name} = (${value});`);
+    }
+    return lines;
+}
+function runtimeClassMethodLines(node) {
+    const props = getProps(node);
+    const name = str(props.name);
+    if (!isRuntimeBindingName(name))
+        return undefined;
+    const params = runtimeParamNames(node);
+    if (!params.every(isRuntimeBindingName))
+        return undefined;
+    const staticKw = isTruthy(props.static) ? 'static ' : '';
+    const asyncKw = isTruthy(props.async) || isTruthy(props.stream) ? 'async ' : '';
+    const star = isTruthy(props.stream) ? '*' : '';
+    const lines = [`  ${staticKw}${asyncKw}${star}${name}(${params.join(', ')}) {`];
+    lines.push(...runtimeHandlerLines(node));
+    lines.push('  }');
+    return lines;
+}
+function runtimeClassGetterLines(node) {
+    const props = getProps(node);
+    const name = str(props.name);
+    if (!isRuntimeBindingName(name))
+        return undefined;
+    const staticKw = isTruthy(props.static) ? 'static ' : '';
+    const lines = [`  ${staticKw}get ${name}() {`];
+    lines.push(...runtimeHandlerLines(node));
+    lines.push('  }');
+    return lines;
+}
+function runtimeClassSetterLines(node) {
+    const props = getProps(node);
+    const name = str(props.name);
+    if (!isRuntimeBindingName(name))
+        return undefined;
+    const params = runtimeParamNames(node);
+    if (!params.every(isRuntimeBindingName))
+        return undefined;
+    const param = params[0] || 'value';
+    const staticKw = isTruthy(props.static) ? 'static ' : '';
+    const lines = [`  ${staticKw}set ${name}(${param}) {`];
+    lines.push(...runtimeHandlerLines(node));
+    lines.push('  }');
+    return lines;
+}
+function runtimeClassExpr(node) {
+    const name = str(getProps(node).name);
+    if (!isRuntimeBindingName(name))
+        return '';
+    const ctorNode = getChildren(node, 'constructor')[0];
+    const ctorParams = ctorNode ? runtimeParamNames(ctorNode) : [];
+    if (!ctorParams.every(isRuntimeBindingName))
+        return '';
+    const fieldInitializers = runtimeClassFieldInitializers(node);
+    const lines = ['(class {'];
+    if (ctorNode || fieldInitializers.length > 0) {
+        lines.push(`  constructor(${ctorParams.join(', ')}) {`);
+        lines.push(...fieldInitializers);
+        if (ctorNode)
+            lines.push(...runtimeHandlerLines(ctorNode));
+        lines.push('  }');
+    }
+    for (const method of getChildren(node, 'method')) {
+        const methodLines = runtimeClassMethodLines(method);
+        if (!methodLines)
+            return '';
+        lines.push(...methodLines);
+    }
+    for (const getter of getChildren(node, 'getter')) {
+        const getterLines = runtimeClassGetterLines(getter);
+        if (!getterLines)
+            return '';
+        lines.push(...getterLines);
+    }
+    for (const setter of getChildren(node, 'setter')) {
+        const setterLines = runtimeClassSetterLines(setter);
+        if (!setterLines)
+            return '';
+        lines.push(...setterLines);
+    }
+    lines.push('})');
+    return lines.join('\n');
+}
+function runtimeValuePropSource(node, propName) {
+    return exprPropToRuntimeSource(node, propName) || rawPropToRuntimeSource(node, propName);
+}
+function runtimePortableSource(source) {
+    return source.replace(/\b([A-Za-z_$][A-Za-z0-9_$]*)\.result\b/g, '$1');
+}
+function runtimePortableValuePropSource(node, propName) {
+    const source = runtimeValuePropSource(node, propName);
+    return source ? runtimePortableSource(source) : '';
+}
+function runtimeMapLitExpr(node) {
+    const entries = [];
+    for (const entry of getChildren(node, 'mapEntry')) {
+        const key = runtimeValuePropSource(entry, 'key');
+        const value = runtimeValuePropSource(entry, 'value');
+        if (!key || !value)
+            return '';
+        entries.push(`[${key}, ${value}]`);
+    }
+    return `new Map([${entries.join(', ')}])`;
+}
+function runtimeSetLitExpr(node) {
+    const items = [];
+    for (const item of getChildren(node, 'setItem')) {
+        const value = runtimeValuePropSource(item, 'value');
+        if (!value)
+            return '';
+        items.push(value);
+    }
+    return `new Set([${items.join(', ')}])`;
+}
+function runtimeSyntheticName(node, prefix) {
+    const line = node.loc?.line ?? 0;
+    const col = node.loc?.col ?? 0;
+    return `__kern${prefix}_${line}_${col}`;
+}
+function runtimeDestructureBindings(node) {
+    const source = rawPropToRuntimeSource(node, 'source');
+    if (!source)
+        return [];
+    const bindings = [];
+    for (const child of node.children || []) {
+        const props = getProps(child);
+        const name = str(props.name);
+        if (!isRuntimeBindingName(name))
+            continue;
+        if (child.type === 'element') {
+            const rawIndex = str(props.index);
+            const index = rawIndex && /^-?\d+$/.test(rawIndex) ? rawIndex : String(bindings.length);
+            bindings.push({
+                name,
+                expr: `((${source})[${index}])`,
+                kind: 'native',
+                line: child.loc?.line,
+            });
+        }
+        if (child.type === 'binding') {
+            const key = str(props.key) || name;
+            const accessor = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+            bindings.push({
+                name,
+                expr: `((${source})${accessor})`,
+                kind: 'native',
+                line: child.loc?.line,
+            });
+        }
+    }
+    return bindings;
+}
+function runtimeNamedProp(node, propName, fallback) {
+    const value = str(getProps(node)[propName]);
+    return isRuntimeBindingName(value) ? value : fallback;
+}
+function runtimeArrayPredicateBindingExpr(node, method) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    const predicate = rawPropToRuntimeSource(node, 'where');
+    if (!collection || !predicate)
+        return '';
+    const item = runtimeNamedProp(node, 'item', 'item');
+    return `((${collection}).${method}((${item}) => ${predicate}))`;
+}
+function runtimeArrayProjectionBindingExpr(node, method) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    const body = rawPropToRuntimeSource(node, 'expr');
+    if (!collection || !body)
+        return '';
+    const item = runtimeNamedProp(node, 'item', 'item');
+    return `((${collection}).${method}((${item}) => ${body}))`;
+}
+function runtimeArrayValueLookupBindingExpr(node, method) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    const value = rawPropToRuntimeSource(node, 'value');
+    if (!collection || !value)
+        return '';
+    const from = rawPropToRuntimeSource(node, 'from');
+    const args = from ? `${value}, ${from}` : value;
+    return `((${collection}).${method}(${args}))`;
+}
+function runtimeCollectBindingExpr(node, options = {}) {
+    const source = options.portable ? runtimePortableSource : (value) => value;
+    const from = source(rawPropToRuntimeSource(node, 'from'));
+    if (!from)
+        return '';
+    const where = source(rawPropToRuntimeSource(node, 'where'));
+    const order = source(rawPropToRuntimeSource(node, 'order'));
+    const limit = source(rawPropToRuntimeSource(node, 'limit'));
+    let chain = `(${from})`;
+    if (where)
+        chain += `.filter((item) => ${where})`;
+    if (order)
+        chain += `.sort((a, b) => ${order})`;
+    if (limit)
+        chain += `.slice(0, ${limit})`;
+    return `(${chain})`;
+}
+function runtimePartitionBindings(node) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    const predicate = rawPropToRuntimeSource(node, 'where');
+    if (!collection || !predicate)
+        return [];
+    const passName = str(getProps(node).pass);
+    const failName = str(getProps(node).fail);
+    if (!isRuntimeBindingName(passName) || !isRuntimeBindingName(failName))
+        return [];
+    const item = runtimeNamedProp(node, 'item', 'item');
+    const pairName = `__kernPartition_${passName}_${failName}`;
+    const pairExpr = `((${collection}).reduce((acc, ${item}) => { (${predicate} ? acc[0] : acc[1]).push(${item}); return acc; }, [[], []]))`;
+    return [
+        {
+            name: pairName,
+            expr: pairExpr,
+            kind: 'native',
+            line: node.loc?.line,
+        },
+        {
+            name: passName,
+            expr: `${pairName}[0]`,
+            kind: 'native',
+            line: node.loc?.line,
+        },
+        {
+            name: failName,
+            expr: `${pairName}[1]`,
+            kind: 'native',
+            line: node.loc?.line,
+        },
+    ];
+}
+function runtimeRespondSource(node, options = {}) {
+    const props = getProps(node);
+    const status = typeof props.status === 'number' ? props.status : Number(str(props.status)) || undefined;
+    const valueSource = options.portable ? runtimePortableValuePropSource : runtimeValuePropSource;
+    const jsonSource = valueSource(node, 'json');
+    if (jsonSource)
+        return status && status !== 200 ? `({ status: ${status}, json: ${jsonSource} })` : jsonSource;
+    const textSource = valueSource(node, 'text');
+    if (textSource)
+        return status && status !== 200 ? `({ status: ${status}, text: ${textSource} })` : textSource;
+    const error = str(props.error);
+    if (error)
+        return `({ status: ${status || 500}, error: ${JSON.stringify(error)} })`;
+    const redirect = str(props.redirect);
+    if (redirect)
+        return `({ status: ${status || 302}, redirect: ${JSON.stringify(redirect)} })`;
+    return `({ status: ${status || 200} })`;
+}
+function runtimeScopedObject(names) {
+    const unique = [...new Set(names)].filter(isRuntimeBindingName);
+    if (unique.length === 0)
+        return 'undefined';
+    if (unique.length === 1)
+        return unique[0];
+    return `({ ${unique.join(', ')} })`;
+}
+function runtimeWorkflowHelperLines() {
+    return [
+        'const __kernGuardError = (name, message) => { const error = new Error(message); error.name = name; throw error; };',
+        'const __kernGuardSyncParam = (name, value) => {',
+        '  if (typeof params === "object" && params !== null) params[name] = value;',
+        '  if (typeof query === "object" && query !== null && name in query) query[name] = value;',
+        '  if (typeof body === "object" && body !== null && name in body) body[name] = value;',
+        '  if (typeof args === "object" && args !== null) args[name] = value;',
+        '};',
+        'const __kernNormalizePath = (value) => {',
+        '  const text = String(value || "");',
+        '  const absolute = text.startsWith("/") ? text : `/${text}`;',
+        '  const parts = [];',
+        '  for (const part of absolute.split("/")) {',
+        '    if (!part || part === ".") continue;',
+        '    if (part === "..") parts.pop();',
+        '    else parts.push(part);',
+        '  }',
+        '  return `/${parts.join("/")}`;',
+        '};',
+        'const __kernResolvePath = (value, base) => String(value).startsWith("/") ? __kernNormalizePath(value) : __kernNormalizePath(`${base || ""}/${value}`);',
+        'const __kernPathWithin = (candidate, roots) => roots.some((root) => candidate === root || candidate.startsWith(root.endsWith("/") ? root : `${root}/`));',
+        'const __kernByteLength = (value) => {',
+        '  const text = typeof value === "string" ? value : JSON.stringify(value);',
+        '  if (text == null) return 0;',
+        '  let bytes = 0;',
+        '  for (let i = 0; i < text.length; i++) {',
+        '    const code = text.charCodeAt(i);',
+        '    if (code < 0x80) bytes += 1;',
+        '    else if (code < 0x800) bytes += 2;',
+        '    else if (code >= 0xd800 && code <= 0xdbff) { bytes += 4; i++; }',
+        '    else bytes += 3;',
+        '  }',
+        '  return bytes;',
+        '};',
+        'const __kernUrlHost = (value) => {',
+        '  const match = String(value || "").match(/^[A-Za-z][A-Za-z0-9+.-]*:\\/\\/([^/?#]+)/);',
+        '  if (!match) return "";',
+        '  return match[1].split("@").pop().split(":")[0].toLowerCase();',
+        '};',
+    ];
+}
+function runtimeGuardTargetName(node, options) {
+    return guardParam(node) || options.targetParam || '';
+}
+function runtimeGuardListProp(node, ...propNames) {
+    const props = getProps(node);
+    for (const propName of propNames) {
+        const value = str(props[propName]);
+        if (value)
+            return parseList(value);
+    }
+    return [];
+}
+function runtimeGuardAssignLines(target, source) {
+    return [`${target} = ${source};`, `__kernGuardSyncParam(${JSON.stringify(target)}, ${target});`];
+}
+function runtimeGuardStatement(node, options = {}) {
+    const rawExpr = exprPropToRuntimeSource(node, 'expr') || rawPropToRuntimeSource(node, 'expr');
+    const expr = options.portable ? runtimePortableSource(rawExpr) : rawExpr;
+    const props = getProps(node);
+    const coverageLine = options.trackCoverage ? runtimeGuardCoverageCallLine(node) : undefined;
+    const withCoverage = (lines) => (coverageLine ? [coverageLine, ...lines] : lines);
+    if (expr) {
+        const fallback = str(props.else) || str(props.fallback);
+        const numericFallback = fallback && /^\d+$/.test(fallback) ? Number(fallback) : undefined;
+        const result = numericFallback !== undefined
+            ? `({ status: ${numericFallback} })`
+            : fallback
+                ? `({ error: ${JSON.stringify(fallback)} })`
+                : 'false';
+        return withCoverage([`if (!(${expr})) return (${result});`]);
+    }
+    if (!options.portable && !options.targetParam)
+        return [];
+    const kind = guardKind(node);
+    const target = runtimeGuardTargetName(node, options);
+    const lines = [];
+    if (kind === 'sanitize') {
+        if (!target || !isRuntimeBindingName(target))
+            return [];
+        const pattern = str(props.pattern) || '[\\x00-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]';
+        const replacement = str(props.replacement);
+        try {
+            new RegExp(pattern);
+            if (/([+*}])\s*\)\s*[+*{]/.test(pattern)) {
+                return withCoverage([
+                    `__kernGuardError("GuardConfigError", ${JSON.stringify(`Unsafe sanitize regex for ${target}: ${pattern}`)});`,
+                ]);
+            }
+        }
+        catch {
+            return withCoverage([
+                `__kernGuardError("GuardConfigError", ${JSON.stringify(`Invalid sanitize regex for ${target}: ${pattern}`)});`,
+            ]);
+        }
+        lines.push(`if (typeof ${target} === "string") {`);
+        for (const line of runtimeGuardAssignLines(target, `${target}.replace(new RegExp(${JSON.stringify(pattern)}, "g"), ${JSON.stringify(replacement)})`)) {
+            lines.push(`  ${line}`);
+        }
+        lines.push('}');
+        return withCoverage(lines);
+    }
+    if (kind === 'validate') {
+        if (!target || !isRuntimeBindingName(target))
+            return [];
+        const min = numericProp(props, 'min');
+        const max = numericProp(props, 'max');
+        if (min !== undefined) {
+            lines.push(`if (typeof ${target} === "number" ? ${target} < ${min} : String(${target}).length < ${min}) __kernGuardError("ValidationError", ${JSON.stringify(`${target} below minimum ${min}`)});`);
+        }
+        if (max !== undefined) {
+            lines.push(`if (typeof ${target} === "number" ? ${target} > ${max} : String(${target}).length > ${max}) __kernGuardError("ValidationError", ${JSON.stringify(`${target} above maximum ${max}`)});`);
+        }
+        const regex = str(props.regex) || str(props.pattern);
+        if (regex) {
+            try {
+                new RegExp(regex);
+                if (/([+*}])\s*\)\s*[+*{]/.test(regex)) {
+                    lines.push(`__kernGuardError("GuardConfigError", ${JSON.stringify(`Unsafe validate regex for ${target}: ${regex}`)});`);
+                }
+                else {
+                    lines.push(`if (typeof ${target} === "string" && !(new RegExp(${JSON.stringify(regex)})).test(${target})) __kernGuardError("ValidationError", ${JSON.stringify(`${target} does not match required pattern`)});`);
+                }
+            }
+            catch {
+                lines.push(`__kernGuardError("GuardConfigError", ${JSON.stringify(`Invalid validate regex for ${target}: ${regex}`)});`);
+            }
+        }
+        return withCoverage(lines);
+    }
+    if (kind === 'pathcontainment' || kind === 'pathcontainmentguard' || kind === 'path') {
+        if (!target || !isRuntimeBindingName(target))
+            return [];
+        const roots = runtimeGuardListProp(node, 'allowlist', 'allow', 'roots', 'root');
+        const base = str(props.baseDir) || str(props.base) || '/';
+        const rootList = roots.length > 0 ? roots : [base || '/'];
+        const rootsSource = `[${rootList.map((root) => JSON.stringify(root)).join(', ')}].map(__kernNormalizePath)`;
+        lines.push(`if (${target} == null || ${target} === "") __kernGuardError("PathContainmentError", ${JSON.stringify(`${target} is required for path containment check`)});`);
+        for (const line of runtimeGuardAssignLines(target, `__kernResolvePath(${target}, ${JSON.stringify(base)})`)) {
+            lines.push(line);
+        }
+        lines.push(`if (!__kernPathWithin(${target}, ${rootsSource})) __kernGuardError("PathContainmentError", ${JSON.stringify(`${target} escapes allowed directories`)});`);
+        return withCoverage(lines);
+    }
+    if (kind === 'sizelimit') {
+        if (!target || !isRuntimeBindingName(target))
+            return [];
+        const maxBytes = numericProp(props, 'maxBytes') ?? numericProp(props, 'max') ?? 1048576;
+        lines.push(`if (__kernByteLength(${target}) > ${maxBytes}) __kernGuardError("SizeLimitError", ${JSON.stringify(`${target} exceeds size limit of ${maxBytes} bytes`)});`);
+        return withCoverage(lines);
+    }
+    if (kind === 'auth') {
+        const tokenTarget = target && isRuntimeBindingName(target) ? target : '';
+        const header = str(props.header) || 'authorization';
+        const tokenExpr = tokenTarget
+            ? tokenTarget
+            : `(typeof headers === "object" && headers !== null ? (headers[${JSON.stringify(header)}] || headers[${JSON.stringify(header.toLowerCase())}] || headers.Authorization) : undefined) || (typeof params === "object" && params !== null ? (params.token || params.authorization) : undefined) || (typeof args === "object" && args !== null ? (args.token || args.authorization) : undefined)`;
+        lines.push(`if (!(${tokenExpr})) __kernGuardError("AuthError", ${JSON.stringify(`Authentication required${tokenTarget ? `: ${tokenTarget}` : ''}`)});`);
+        return withCoverage(lines);
+    }
+    if (kind === 'ratelimit') {
+        const maxRequests = numericProp(props, 'maxRequests') ?? numericProp(props, 'requests') ?? 1;
+        if (maxRequests <= 0) {
+            return withCoverage([`__kernGuardError("RateLimitError", "Rate limit maxRequests must be greater than 0");`]);
+        }
+        return withCoverage([]);
+    }
+    if (kind === 'urlallowlist' || kind === 'urlvalidation' || kind === 'hostallowlist' || kind === 'domainallowlist') {
+        if (!target || !isRuntimeBindingName(target))
+            return [];
+        const allowed = runtimeGuardListProp(node, 'allowlist', 'allow').map((entry) => entry.toLowerCase());
+        if (allowed.length === 0)
+            return [];
+        const allowedSource = `[${allowed.map((entry) => JSON.stringify(entry)).join(', ')}]`;
+        lines.push(`if (!${allowedSource}.includes(__kernUrlHost(${target}))) __kernGuardError("UrlAllowlistError", ${JSON.stringify(`${target} host is not allowlisted`)});`);
+        return withCoverage(lines);
+    }
+    return [];
+}
+function runtimeScopedChildProgram(children) {
+    const lines = [];
+    const names = [];
+    let hasReturn = false;
+    for (const child of children) {
+        if (child.type === 'respond') {
+            lines.push(`return (${runtimeRespondSource(child)});`);
+            hasReturn = true;
+            continue;
+        }
+        if (child.type === 'guard') {
+            lines.push(...runtimeGuardStatement(child));
+            continue;
+        }
+        if (child.type === 'destructure') {
+            for (const binding of runtimeDestructureBindings(child)) {
+                lines.push(`const ${binding.name} = (${binding.expr});`);
+                names.push(binding.name);
+            }
+            continue;
+        }
+        if (child.type === 'partition') {
+            const partitionBindings = runtimePartitionBindings(child);
+            for (const binding of partitionBindings) {
+                lines.push(`const ${binding.name} = (${binding.expr});`);
+                names.push(binding.name);
+            }
+            continue;
+        }
+        if (child.type === 'each') {
+            const expr = runtimeEachExecutionExpr(child);
+            if (expr)
+                lines.push(`(${expr});`);
+            continue;
+        }
+        const name = str(getProps(child).name);
+        const binding = runtimeBindingSource(child);
+        if (name && binding?.expr && isRuntimeBindingName(name)) {
+            lines.push(`const ${name} = (${binding.expr});`);
+            names.push(name);
+        }
+    }
+    return { lines, names, hasReturn };
+}
+function runtimeBranchBindingExpr(node, options = {}) {
+    const on = rawPropToRuntimeSource(node, 'on');
+    if (!on)
+        return '';
+    const lines = [`(${options.async ? 'async ' : ''}() => {`, `  const __branchValue = (${on});`];
+    const paths = getChildren(node, 'path');
+    for (let index = 0; index < paths.length; index++) {
+        const pathNode = paths[index];
+        const value = str(getProps(pathNode).value);
+        const program = runtimeScopedChildProgram(pathNode.children || []);
+        const keyword = index === 0 ? 'if' : 'else if';
+        lines.push(`  ${keyword} (__branchValue === ${JSON.stringify(value)}) {`);
+        for (const line of program.lines)
+            lines.push(`    ${line}`);
+        if (!program.hasReturn)
+            lines.push(`    return (${runtimeScopedObject(program.names)});`);
+        lines.push('  }');
+    }
+    lines.push('  return undefined;');
+    lines.push('})()');
+    return lines.join('\n');
+}
+function runtimeEachExecutionExpr(node, options = {}) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    const item = str(getProps(node).name) || 'item';
+    if (!collection || !isRuntimeBindingName(item))
+        return '';
+    const index = str(getProps(node).index);
+    if (index && !isRuntimeBindingName(index))
+        return '';
+    const program = runtimeScopedChildProgram(node.children || []);
+    const lines = [`(${options.async ? 'async ' : ''}() => {`, '  const __results = [];'];
+    if (index) {
+        lines.push(`  for (const [${index}, ${item}] of (${collection}).entries()) {`);
+    }
+    else {
+        lines.push(`  for (const ${item} of ${collection}) {`);
+    }
+    for (const line of program.lines)
+        lines.push(`    ${line}`);
+    lines.push(`    __results.push(${runtimeScopedObject(program.names)});`);
+    lines.push('  }');
+    lines.push('  return __results;');
+    lines.push('})()');
+    return lines.join('\n');
+}
+function runtimeEachExecutionBinding(node) {
+    const expr = runtimeEachExecutionExpr(node);
+    if (!expr)
+        return undefined;
+    return {
+        name: runtimeSyntheticName(node, 'Each'),
+        expr,
+        kind: 'native',
+        eager: true,
+        line: node.loc?.line,
+    };
+}
+function runtimeRouteMethod(node) {
+    return (str(getProps(node).method) || 'get').toLowerCase();
+}
+function runtimeRoutePath(node) {
+    return str(getProps(node).path);
+}
+function runtimeRouteLabel(node) {
+    return `${runtimeRouteMethod(node).toUpperCase()} ${runtimeRoutePath(node) || '<missing-path>'}`;
+}
+function parseRuntimeRouteSpec(spec) {
+    const trimmed = spec.trim();
+    const match = trimmed.match(/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s+(.+)$/i);
+    if (match)
+        return { method: match[1].toLowerCase(), path: match[2].trim() };
+    if (trimmed.startsWith('/'))
+        return { path: trimmed };
+    return { name: trimmed };
+}
+function findRuntimeRoute(target, spec) {
+    const parsed = parseRuntimeRouteSpec(spec);
+    const routes = collectNodes(target.root, 'route').filter((route) => {
+        const props = getProps(route);
+        if (parsed.name) {
+            return str(props.name) === parsed.name || runtimeRouteLabel(route) === parsed.name;
+        }
+        if (parsed.method && runtimeRouteMethod(route) !== parsed.method)
+            return false;
+        return !parsed.path || runtimeRoutePath(route) === parsed.path;
+    });
+    if (routes.length === 1)
+        return { route: routes[0] };
+    if (routes.length === 0)
+        return { message: `Runtime route assertion target not found: ${spec}` };
+    return { message: `Runtime route assertion target is ambiguous: ${spec}` };
+}
+function runtimeRoutePathParamNames(path) {
+    const names = [];
+    const matcher = /(?::|\{)([A-Za-z_$][A-Za-z0-9_$]*)(?:\})?/g;
+    let match;
+    while ((match = matcher.exec(path)))
+        names.push(match[1]);
+    return [...new Set(names)];
+}
+function runtimeRouteParamItems(route) {
+    const items = [];
+    for (const paramsNode of getChildren(route, 'params')) {
+        const rawItems = getProps(paramsNode).items;
+        if (!Array.isArray(rawItems))
+            continue;
+        for (const item of rawItems) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const itemProps = item;
+            const name = str(itemProps.name);
+            if (!name)
+                continue;
+            const defaultSource = itemProps.default === undefined ? undefined : String(itemProps.default);
+            items.push({ name, defaultSource });
+        }
+    }
+    return items;
+}
+function runtimeWorkflowKind(options) {
+    return options.kind || 'route';
+}
+function runtimeEffectName(node) {
+    return str(getProps(node).name) || 'effect';
+}
+function runtimeEffectCoverageKey(node) {
+    return `${runtimeEffectName(node)}:${node.loc?.line ?? '?'}`;
+}
+function runtimeGuardCoverageKey(node) {
+    return `${node.loc?.line ?? '?'}:${node.loc?.col ?? '?'}`;
+}
+function runtimeEffectTriggerSource(node, options = {}) {
+    const triggerNode = getChildren(node, 'trigger')[0];
+    if (!triggerNode)
+        return { message: `Runtime effect ${runtimeEffectName(node)} requires trigger expr={{...}}` };
+    const source = exprPropToRuntimeSource(triggerNode, 'expr');
+    if (!source) {
+        return {
+            message: `Runtime effect ${runtimeEffectName(node)} can only simulate trigger expr={{...}}; ` +
+                'query/url/call triggers need native mocks or a backend integration test.',
+        };
+    }
+    const portableSource = options.portable ? runtimePortableSource(source) : source;
+    const problem = unsafeRuntimeExpressionReason(portableSource, { allowAwait: true });
+    if (problem) {
+        return { message: `Runtime effect ${runtimeEffectName(node)} cannot execute trigger: ${problem}` };
+    }
+    return { source: portableSource };
+}
+function runtimeEffectRecoverFallbackSource(node, options = {}) {
+    const recoverNode = getChildren(node, 'recover')[0];
+    if (!recoverNode)
+        return 'null';
+    const source = runtimeValuePropSource(recoverNode, 'fallback') || 'null';
+    return options.portable ? runtimePortableSource(source) : source;
+}
+function findRuntimeEffectMock(mocks, effectName) {
+    const matches = (mocks || []).filter((mock) => mock.effect === effectName);
+    if (matches.length === 0)
+        return {};
+    if (matches.length === 1)
+        return { mock: matches[0] };
+    return { message: `Runtime effect ${effectName} has multiple scoped mocks` };
+}
+function runtimeEffectMockExecutionExpr(mock, options = {}) {
+    if (!isRuntimeBindingName(mock.effect))
+        return { message: `Runtime mock has invalid effect name: ${mock.effect}` };
+    if (mock.throws !== undefined) {
+        const rawName = mock.throws.trim() && mock.throws !== 'true' ? mock.throws.trim() : 'Error';
+        const message = rawName === 'Error' ? `Mocked effect ${mock.effect} failed` : rawName;
+        const lines = [
+            '(async () => {',
+            `  const __error = new Error(${JSON.stringify(message)});`,
+            `  __error.name = ${JSON.stringify(rawName)};`,
+            '  throw __error;',
+            '})()',
+        ];
+        return { expr: lines.join('\n') };
+    }
+    const source = options.portable ? runtimePortableSource(mock.returns || 'undefined') : mock.returns || 'undefined';
+    const problem = unsafeRuntimeExpressionReason(source, { allowAwait: true });
+    if (problem)
+        return { message: `Runtime mock effect ${mock.effect} cannot execute returns value: ${problem}` };
+    const lines = ['(async () => {', `  const __value = await (${source});`];
+    if (options.meta) {
+        lines.push('  return { result: __value, recovered: false, attempts: 0, mocked: true };');
+    }
+    else {
+        lines.push('  return __value;');
+    }
+    lines.push('})()');
+    return { expr: lines.join('\n') };
+}
+function recordRuntimeEffectMockCall(mock, mockCalls) {
+    if (!mockCalls)
+        return;
+    mockCalls.set(mock.id, (mockCalls.get(mock.id) || 0) + 1);
+}
+function markRuntimeEffectMockChecked(mock, checkedMocks) {
+    checkedMocks?.add(mock.id);
+}
+function runtimeEffectMockCallLine(mock) {
+    const id = JSON.stringify(mock.id);
+    return `__kernMockCalls[${id}] = (__kernMockCalls[${id}] || 0) + 1;`;
+}
+function runtimeEffectCoverageCallLine(effect) {
+    const key = JSON.stringify(runtimeEffectCoverageKey(effect));
+    return `__kernEffectCalls[${key}] = (__kernEffectCalls[${key}] || 0) + 1;`;
+}
+function runtimeGuardCoverageCallLine(guard) {
+    const key = JSON.stringify(runtimeGuardCoverageKey(guard));
+    return `__kernGuardCalls[${key}] = (__kernGuardCalls[${key}] || 0) + 1;`;
+}
+function mergeRuntimeEffectMockCalls(mockCalls, calls) {
+    if (!mockCalls || !calls || typeof calls !== 'object')
+        return;
+    for (const [id, count] of Object.entries(calls)) {
+        const numeric = Number(count);
+        if (!Number.isFinite(numeric) || numeric <= 0)
+            continue;
+        mockCalls.set(id, (mockCalls.get(id) || 0) + numeric);
+    }
+}
+function mergeRuntimeEffectCoverageCalls(effectCalls, calls) {
+    if (!effectCalls || !calls || typeof calls !== 'object')
+        return;
+    for (const [key, count] of Object.entries(calls)) {
+        const numeric = Number(count);
+        if (!Number.isFinite(numeric) || numeric <= 0)
+            continue;
+        effectCalls.set(key, (effectCalls.get(key) || 0) + numeric);
+    }
+}
+function mergeRuntimeGuardCoverageCalls(guardCalls, calls) {
+    if (!guardCalls || !calls || typeof calls !== 'object')
+        return;
+    for (const [key, count] of Object.entries(calls)) {
+        const numeric = Number(count);
+        if (!Number.isFinite(numeric) || numeric <= 0)
+            continue;
+        guardCalls.set(key, (guardCalls.get(key) || 0) + numeric);
+    }
+}
+function runtimeEffectExecutionExpr(node, options = {}) {
+    const name = runtimeEffectName(node);
+    if (!isRuntimeBindingName(name))
+        return { message: `Runtime effect has invalid name: ${name}` };
+    const trigger = runtimeEffectTriggerSource(node, options);
+    if (trigger.message || !trigger.source)
+        return { message: trigger.message || 'Runtime effect has no trigger' };
+    const recoverNode = getChildren(node, 'recover')[0];
+    const hasRecover = recoverNode !== undefined;
+    const fallbackSource = runtimeEffectRecoverFallbackSource(node, options);
+    const fallbackProblem = unsafeRuntimeExpressionReason(fallbackSource, { allowAwait: true });
+    if (fallbackProblem) {
+        return { message: `Runtime effect ${name} cannot execute fallback: ${fallbackProblem}` };
+    }
+    const rawRetry = recoverNode ? getProps(recoverNode).retry : undefined;
+    const retryCount = rawRetry === undefined || rawRetry === '' ? 0 : Number(rawRetry);
+    if (!Number.isInteger(retryCount) || retryCount < 0) {
+        return { message: `Runtime effect ${name} has invalid recover retry=${String(rawRetry)}` };
+    }
+    const attempts = hasRecover && retryCount > 0 ? retryCount : 1;
+    const result = (value, recovered) => options.meta ? `({ result: ${value}, recovered: ${recovered}, attempts: __attempts })` : value;
+    const lines = ['(async () => {', '  let __attempts = 0;'];
+    if (!hasRecover) {
+        lines.push('  __attempts++;');
+        lines.push(`  const __value = await (${trigger.source});`);
+        lines.push(`  return ${result('__value', false)};`);
+        lines.push('})()');
+        return { expr: lines.join('\n') };
+    }
+    lines.push(`  const __fallback = (${fallbackSource});`);
+    lines.push(`  for (let __attempt = 0; __attempt < ${attempts}; __attempt++) {`);
+    lines.push('    __attempts++;');
+    lines.push('    try {');
+    lines.push(`      const __value = await (${trigger.source});`);
+    lines.push(`      return ${result('__value', false)};`);
+    lines.push('    } catch (__error) {');
+    lines.push(`      if (__attempt === ${attempts - 1}) return ${result('__fallback', true)};`);
+    lines.push('    }');
+    lines.push('  }');
+    lines.push(`  return ${result('__fallback', true)};`);
+    lines.push('})()');
+    return { expr: lines.join('\n') };
+}
+function runtimeRouteRequestLines(route, inputSource) {
+    const lines = [
+        `const __request = ((${inputSource}) ?? {});`,
+        'let params = (__request.params ?? {});',
+        'let query = (__request.query ?? {});',
+        'let body = (__request.body ?? {});',
+        'let headers = (__request.headers ?? {});',
+    ];
+    const declared = new Set();
+    for (const name of runtimeRoutePathParamNames(runtimeRoutePath(route))) {
+        if (!isRuntimeBindingName(name))
+            return { lines: [], message: `Runtime route has invalid path param: ${name}` };
+        if (declared.has(name))
+            continue;
+        declared.add(name);
+        lines.push(`let ${name} = params[${JSON.stringify(name)}];`);
+        lines.push(`__kernGuardSyncParam(${JSON.stringify(name)}, ${name});`);
+    }
+    for (const item of runtimeRouteParamItems(route)) {
+        if (!isRuntimeBindingName(item.name)) {
+            return { lines: [], message: `Runtime route has invalid params entry: ${item.name}` };
+        }
+        if (declared.has(item.name))
+            continue;
+        declared.add(item.name);
+        const fallback = item.defaultSource ?? 'undefined';
+        const key = JSON.stringify(item.name);
+        lines.push(`let ${item.name} = query[${key}] ?? params[${key}] ?? (${fallback});`);
+        lines.push(`__kernGuardSyncParam(${key}, ${item.name});`);
+    }
+    return { lines };
+}
+function runtimeRouteChildProgram(children, options = {}) {
+    const lines = [];
+    const workflowKind = runtimeWorkflowKind(options);
+    for (const child of children) {
+        if (child.type === 'handler') {
+            const handler = runtimeWorkflowHandlerLines(child, workflowKind);
+            if (handler.message)
+                return handler;
+            lines.push(...handler.lines);
+            continue;
+        }
+        if (child.type === 'effect') {
+            const effectName = runtimeEffectName(child);
+            if (!isRuntimeBindingName(effectName)) {
+                return { lines: [], message: `Runtime ${workflowKind} effect has invalid name: ${effectName}` };
+            }
+            const scopedMock = findRuntimeEffectMock(options.mocks, effectName);
+            if (scopedMock.message)
+                return { lines: [], message: scopedMock.message };
+            if (scopedMock.mock) {
+                const mocked = runtimeEffectMockExecutionExpr(scopedMock.mock, { portable: true });
+                if (mocked.message || !mocked.expr) {
+                    return {
+                        lines: [],
+                        message: mocked.message || `Runtime ${workflowKind} mock effect ${effectName} cannot be simulated`,
+                    };
+                }
+                lines.push(runtimeEffectCoverageCallLine(child));
+                lines.push(runtimeEffectMockCallLine(scopedMock.mock));
+                lines.push(`const ${effectName} = await (${mocked.expr});`);
+                continue;
+            }
+            const effect = runtimeEffectExecutionExpr(child, { portable: true });
+            if (effect.message || !effect.expr) {
+                return {
+                    lines: [],
+                    message: effect.message || `Runtime ${workflowKind} effect ${effectName} cannot be simulated`,
+                };
+            }
+            lines.push(runtimeEffectCoverageCallLine(child));
+            lines.push(`const ${effectName} = await (${effect.expr});`);
+            continue;
+        }
+        if (child.type === 'respond') {
+            lines.push(`return (${runtimeRespondSource(child, { portable: true })});`);
+            continue;
+        }
+        if (child.type === 'guard') {
+            lines.push(...runtimeGuardStatement(child, { portable: true, trackCoverage: true }));
+            continue;
+        }
+        if (child.type === 'branch') {
+            const expr = runtimeRouteBranchExecutionExpr(child, options);
+            if (!expr)
+                continue;
+            const name = runtimeSyntheticName(child, 'BranchResult');
+            lines.push(`const ${name} = await (${expr});`);
+            lines.push(`if (${name} !== undefined) return ${name};`);
+            continue;
+        }
+        if (child.type === 'each') {
+            const expr = runtimeRouteEachExecutionExpr(child, options);
+            if (expr)
+                lines.push(`await (${expr});`);
+            continue;
+        }
+        if (child.type === 'destructure') {
+            for (const binding of runtimeDestructureBindings(child))
+                lines.push(`const ${binding.name} = (${binding.expr});`);
+            continue;
+        }
+        if (child.type === 'partition') {
+            for (const binding of runtimePartitionBindings(child))
+                lines.push(`const ${binding.name} = (${binding.expr});`);
+            continue;
+        }
+        const name = str(getProps(child).name);
+        const binding = child.type === 'collect'
+            ? { expr: runtimeCollectBindingExpr(child, { portable: true }), kind: 'native' }
+            : runtimeBindingSource(child);
+        if (name && binding?.expr && isRuntimeBindingName(name)) {
+            lines.push(`const ${name} = (${runtimePortableSource(binding.expr)});`);
+        }
+    }
+    lines.push('return undefined;');
+    return { lines };
+}
+function runtimeWorkflowHandlerLines(node, workflowKind) {
+    const code = str(getProps(node).code).trim();
+    if (!code)
+        return { lines: [] };
+    const problem = unsafeRuntimeWorkflowReason(code);
+    if (problem) {
+        return {
+            lines: [],
+            message: `Runtime ${workflowKind} assertion cannot execute handler: ${problem}`,
+        };
+    }
+    return { lines: code.split('\n') };
+}
+function runtimeRouteBranchExecutionExpr(node, options = {}) {
+    const on = runtimePortableSource(rawPropToRuntimeSource(node, 'on'));
+    if (!on)
+        return '';
+    const lines = ['(async () => {', `  const __branchValue = (${on});`];
+    const paths = getChildren(node, 'path');
+    for (let index = 0; index < paths.length; index++) {
+        const pathNode = paths[index];
+        const value = str(getProps(pathNode).value);
+        const program = runtimeRouteChildProgram(pathNode.children || [], options);
+        if (program.message)
+            return '';
+        const keyword = index === 0 ? 'if' : 'else if';
+        lines.push(`  ${keyword} (__branchValue === ${JSON.stringify(value)}) {`);
+        for (const line of program.lines)
+            lines.push(`    ${line}`);
+        lines.push('  }');
+    }
+    lines.push('  return undefined;');
+    lines.push('})()');
+    return lines.join('\n');
+}
+function runtimeRouteEachExecutionExpr(node, options = {}) {
+    const collection = runtimePortableSource(rawPropToRuntimeSource(node, 'in'));
+    const item = str(getProps(node).name) || 'item';
+    if (!collection || !isRuntimeBindingName(item))
+        return '';
+    const index = str(getProps(node).index);
+    if (index && !isRuntimeBindingName(index))
+        return '';
+    const program = runtimeRouteChildProgram(node.children || [], options);
+    if (program.message)
+        return '';
+    const lines = ['(async () => {', '  const __results = [];'];
+    if (index) {
+        lines.push(`  for (const [${index}, ${item}] of (${collection}).entries()) {`);
+    }
+    else {
+        lines.push(`  for (const ${item} of ${collection}) {`);
+    }
+    for (const line of program.lines)
+        lines.push(`    ${line}`);
+    lines.push('    __results.push(undefined);');
+    lines.push('  }');
+    lines.push('  return __results;');
+    lines.push('})()');
+    return lines.join('\n');
+}
+function runtimeRouteExecutionExpr(route, inputSource, options = {}) {
+    const request = runtimeRouteRequestLines(route, inputSource || '{}');
+    if (request.message)
+        return { message: request.message };
+    const program = runtimeRouteChildProgram(route.children || [], options);
+    if (program.message)
+        return { message: program.message };
+    const bodyLines = [...runtimeWorkflowHelperLines(), ...request.lines, ...program.lines];
+    const lines = ['(async () => {', '  const __kernMockCalls = Object.create(null);'];
+    lines.push('  const __kernEffectCalls = Object.create(null);');
+    lines.push('  const __kernGuardCalls = Object.create(null);');
+    if (options.probe) {
+        lines.push('  const __kernRunRoute = async () => {');
+        for (const line of bodyLines)
+            lines.push(`    ${line}`);
+        lines.push('  };');
+        lines.push('  try {');
+        lines.push('    const __kernValue = await __kernRunRoute();');
+        lines.push('    return { __kernRouteStatus: "returned", value: __kernValue, calls: __kernMockCalls, effects: __kernEffectCalls, guards: __kernGuardCalls };');
+        lines.push('  } catch (__kernError) {');
+        lines.push('    return {');
+        lines.push('      __kernRouteStatus: "thrown",');
+        lines.push('      error: {');
+        lines.push('        name: __kernError && __kernError.name ? String(__kernError.name) : "Error",');
+        lines.push('        message: __kernError && __kernError.message ? String(__kernError.message) : String(__kernError),');
+        lines.push('        stack: __kernError && __kernError.stack ? String(__kernError.stack) : undefined,');
+        lines.push('      },');
+        lines.push('      calls: __kernMockCalls,');
+        lines.push('      effects: __kernEffectCalls,');
+        lines.push('      guards: __kernGuardCalls,');
+        lines.push('    };');
+        lines.push('  }');
+    }
+    else {
+        for (const line of bodyLines)
+            lines.push(`  ${line}`);
+    }
+    lines.push('})()');
+    return { expr: lines.join('\n') };
+}
+function runtimeToolName(node) {
+    return str(getProps(node).name) || 'tool';
+}
+function findRuntimeTool(target, toolName) {
+    const tools = collectNodes(target.root, 'tool').filter((tool) => runtimeToolName(tool) === toolName);
+    if (tools.length === 1)
+        return { tool: tools[0] };
+    if (tools.length === 0)
+        return { message: `Runtime tool assertion target not found: ${toolName}` };
+    return { message: `Runtime tool assertion target is ambiguous: ${toolName}` };
+}
+function runtimeToolParamItems(tool) {
+    const items = [];
+    for (const param of getChildren(tool, 'param')) {
+        const name = str(getProps(param).name);
+        if (!name)
+            continue;
+        const defaultSource = runtimePortableValuePropSource(param, 'value') || runtimePortableValuePropSource(param, 'default');
+        items.push({ name, ...(defaultSource ? { defaultSource } : {}) });
+    }
+    return items;
+}
+function runtimeToolInputLines(tool, inputSource) {
+    const lines = [
+        `const __toolInput = ((${inputSource}) ?? {});`,
+        'let args = __toolInput;',
+        'let params = __toolInput;',
+    ];
+    const declared = new Set();
+    for (const item of runtimeToolParamItems(tool)) {
+        if (!isRuntimeBindingName(item.name)) {
+            return { lines: [], message: `Runtime tool has invalid param: ${item.name}` };
+        }
+        if (item.name === 'args' || item.name === 'params') {
+            return { lines: [], message: `Runtime tool param name is reserved for native context: ${item.name}` };
+        }
+        if (declared.has(item.name))
+            continue;
+        declared.add(item.name);
+        const fallback = item.defaultSource ?? 'undefined';
+        const key = JSON.stringify(item.name);
+        lines.push(`let ${item.name} = params[${key}] ?? (${fallback});`);
+        lines.push(`__kernGuardSyncParam(${key}, ${item.name});`);
+        const paramNode = paramNodeByName(tool, item.name);
+        for (const guard of paramNode ? getChildren(paramNode, 'guard') : []) {
+            lines.push(...runtimeGuardStatement(guard, { portable: true, targetParam: item.name, trackCoverage: true }));
+        }
+    }
+    return { lines };
+}
+function runtimeToolExecutionExpr(tool, inputSource, options = {}) {
+    const input = runtimeToolInputLines(tool, inputSource || '{}');
+    if (input.message)
+        return { message: input.message };
+    const program = runtimeRouteChildProgram(tool.children || [], { mocks: options.mocks, kind: 'tool' });
+    if (program.message)
+        return { message: program.message };
+    const bodyLines = [...runtimeWorkflowHelperLines(), ...input.lines, ...program.lines];
+    const lines = ['(async () => {', '  const __kernMockCalls = Object.create(null);'];
+    lines.push('  const __kernEffectCalls = Object.create(null);');
+    lines.push('  const __kernGuardCalls = Object.create(null);');
+    if (options.probe) {
+        lines.push('  const __kernRunTool = async () => {');
+        for (const line of bodyLines)
+            lines.push(`    ${line}`);
+        lines.push('  };');
+        lines.push('  try {');
+        lines.push('    const __kernValue = await __kernRunTool();');
+        lines.push('    return { __kernToolStatus: "returned", value: __kernValue, calls: __kernMockCalls, effects: __kernEffectCalls, guards: __kernGuardCalls };');
+        lines.push('  } catch (__kernError) {');
+        lines.push('    return {');
+        lines.push('      __kernToolStatus: "thrown",');
+        lines.push('      error: {');
+        lines.push('        name: __kernError && __kernError.name ? String(__kernError.name) : "Error",');
+        lines.push('        message: __kernError && __kernError.message ? String(__kernError.message) : String(__kernError),');
+        lines.push('        stack: __kernError && __kernError.stack ? String(__kernError.stack) : undefined,');
+        lines.push('      },');
+        lines.push('      calls: __kernMockCalls,');
+        lines.push('      effects: __kernEffectCalls,');
+        lines.push('      guards: __kernGuardCalls,');
+        lines.push('    };');
+        lines.push('  }');
+    }
+    else {
+        for (const line of bodyLines)
+            lines.push(`  ${line}`);
+    }
+    lines.push('})()');
+    return { expr: lines.join('\n') };
+}
+function runtimeArrayBindingExpr(node) {
+    const collection = rawPropToRuntimeSource(node, 'in');
+    switch (node.type) {
+        case 'filter':
+        case 'find':
+        case 'some':
+        case 'every':
+        case 'findIndex':
+            return runtimeArrayPredicateBindingExpr(node, node.type);
+        case 'map':
+        case 'flatMap':
+            return runtimeArrayProjectionBindingExpr(node, node.type);
+        case 'reduce': {
+            const body = rawPropToRuntimeSource(node, 'expr');
+            const initial = rawPropToRuntimeSource(node, 'initial');
+            if (!collection || !body || !initial)
+                return '';
+            const acc = runtimeNamedProp(node, 'acc', 'acc');
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((${collection}).reduce((${acc}, ${item}) => ${body}, ${initial}))`;
+        }
+        case 'slice': {
+            if (!collection)
+                return '';
+            const start = rawPropToRuntimeSource(node, 'start');
+            const end = rawPropToRuntimeSource(node, 'end');
+            const args = [];
+            if (start)
+                args.push(start);
+            if (end) {
+                if (!start)
+                    args.push('0');
+                args.push(end);
+            }
+            return `((${collection}).slice(${args.join(', ')}))`;
+        }
+        case 'flat': {
+            if (!collection)
+                return '';
+            const depth = rawPropToRuntimeSource(node, 'depth');
+            return `((${collection}).flat(${depth}))`;
+        }
+        case 'at': {
+            const index = rawPropToRuntimeSource(node, 'index');
+            return collection && index ? `((${collection}).at(${index}))` : '';
+        }
+        case 'sort': {
+            if (!collection)
+                return '';
+            const compare = rawPropToRuntimeSource(node, 'compare');
+            if (!compare)
+                return `([...(${collection})].sort())`;
+            const a = runtimeNamedProp(node, 'a', 'a');
+            const b = runtimeNamedProp(node, 'b', 'b');
+            return `([...(${collection})].sort((${a}, ${b}) => ${compare}))`;
+        }
+        case 'reverse':
+            return collection ? `([...(${collection})].reverse())` : '';
+        case 'join': {
+            if (!collection)
+                return '';
+            const separator = stringLiteralOrExprPropToRuntimeSource(node, 'separator');
+            return `((${collection}).join(${separator}))`;
+        }
+        case 'includes':
+        case 'indexOf':
+        case 'lastIndexOf':
+            return runtimeArrayValueLookupBindingExpr(node, node.type);
+        case 'concat': {
+            const withArg = rawPropToRuntimeSource(node, 'with');
+            return collection && withArg ? `((${collection}).concat(${withArg}))` : '';
+        }
+        case 'compact':
+            return collection ? `((${collection}).filter(Boolean))` : '';
+        case 'pluck': {
+            const prop = rawPropToRuntimeSource(node, 'prop');
+            if (!collection || !prop)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((${collection}).map((${item}) => ${item}.${prop}))`;
+        }
+        case 'unique':
+            return collection ? `((${collection}).filter((item, index, items) => items.indexOf(item) === index))` : '';
+        case 'uniqueBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((__seen) => (${collection}).filter((${item}) => { const __k = ${by}; if (__seen.has(__k)) return false; __seen.add(__k); return true; }))(new Set())`;
+        }
+        case 'groupBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((${collection}).reduce((acc, ${item}) => { const __k = ${by}; (acc[__k] ??= []).push(${item}); return acc; }, Object.create(null)))`;
+        }
+        case 'indexBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `(Object.fromEntries((${collection}).map((${item}) => [${by}, ${item}])))`;
+        }
+        case 'countBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((${collection}).reduce((acc, ${item}) => { const __k = ${by}; acc[__k] = (acc[__k] ?? 0) + 1; return acc; }, Object.create(null)))`;
+        }
+        case 'chunk': {
+            const size = rawPropToRuntimeSource(node, 'size');
+            return collection && size
+                ? `((__src, __n) => Array.from({ length: Math.ceil(__src.length / __n) }, (_, i) => __src.slice(i * __n, (i + 1) * __n)))((${collection}), (${size}))`
+                : '';
+        }
+        case 'zip': {
+            const right = rawPropToRuntimeSource(node, 'with');
+            if (!collection || !right)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            const indexName = runtimeNamedProp(node, 'index', '__i');
+            return `((__r) => (${collection}).map((${item}, ${indexName}) => [${item}, __r[${indexName}]]))((${right}))`;
+        }
+        case 'range': {
+            const end = rawPropToRuntimeSource(node, 'end');
+            if (!end)
+                return '';
+            const start = rawPropToRuntimeSource(node, 'start') || '0';
+            return `(Array.from({ length: (${end}) - (${start}) }, (_, i) => i + (${start})))`;
+        }
+        case 'take': {
+            const n = rawPropToRuntimeSource(node, 'n');
+            return collection && n ? `((${collection}).slice(0, ${n}))` : '';
+        }
+        case 'drop': {
+            const n = rawPropToRuntimeSource(node, 'n');
+            return collection && n ? `((${collection}).slice(${n}))` : '';
+        }
+        case 'min':
+            return collection
+                ? `((__src) => __src.length === 0 ? undefined : __src.reduce((__a, __b) => __b < __a ? __b : __a))((${collection}))`
+                : '';
+        case 'max':
+            return collection
+                ? `((__src) => __src.length === 0 ? undefined : __src.reduce((__a, __b) => __b > __a ? __b : __a))((${collection}))`
+                : '';
+        case 'minBy':
+        case 'maxBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            const op = node.type === 'minBy' ? '<' : '>';
+            return `((__src) => { if (__src.length === 0) return undefined; const __key = (${item}) => ${by}; return __src.reduce((__best, __cur) => __key(__cur) ${op} __key(__best) ? __cur : __best); })((${collection}))`;
+        }
+        case 'sum':
+            return collection ? `((${collection}).reduce((acc, n) => acc + n, 0))` : '';
+        case 'avg':
+            return collection
+                ? `((__src) => __src.length === 0 ? Number.NaN : __src.reduce((acc, n) => acc + n, 0) / __src.length)((${collection}))`
+                : '';
+        case 'sumBy': {
+            const by = rawPropToRuntimeSource(node, 'by');
+            if (!collection || !by)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((${collection}).reduce((acc, ${item}) => acc + (${by}), 0))`;
+        }
+        case 'intersect': {
+            const right = rawPropToRuntimeSource(node, 'with');
+            if (!collection || !right)
+                return '';
+            const item = runtimeNamedProp(node, 'item', 'item');
+            return `((__r) => (${collection}).filter((${item}) => __r.has(${item})))(new Set((${right})))`;
+        }
+        default:
+            return undefined;
+    }
+}
+function collectRuntimeBindings(root) {
+    const bindings = [];
+    function visit(node) {
+        if (node.type === 'route') {
+            return;
+        }
+        if (node.type === 'branch') {
+            const name = str(getProps(node).name);
+            const expr = runtimeBranchBindingExpr(node);
+            if (name && expr) {
+                bindings.push({
+                    name,
+                    expr,
+                    kind: 'native',
+                    line: node.loc?.line,
+                });
+            }
+            return;
+        }
+        if (node.type === 'each') {
+            const binding = runtimeEachExecutionBinding(node);
+            if (binding)
+                bindings.push(binding);
+            return;
+        }
+        if (node.type === 'destructure') {
+            bindings.push(...runtimeDestructureBindings(node));
+        }
+        if (node.type === 'partition') {
+            bindings.push(...runtimePartitionBindings(node));
+        }
+        const name = str(getProps(node).name);
+        const binding = runtimeBindingSource(node);
+        if (name && binding?.expr) {
+            bindings.push({
+                name,
+                expr: binding.expr,
+                kind: binding.kind,
+                line: node.loc?.line,
+            });
+        }
+        for (const child of node.children || [])
+            visit(child);
+    }
+    visit(root);
+    return bindings;
+}
+function orderRuntimeBindings(bindings, entryExpr) {
+    const byName = new Map();
+    for (const binding of bindings) {
+        if (!isRuntimeBindingName(binding.name)) {
+            return { ordered: [], error: `invalid runtime binding name '${binding.name}' at line ${binding.line ?? '?'}` };
+        }
+        byName.set(binding.name, [...(byName.get(binding.name) || []), binding]);
+    }
+    const ordered = [];
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    function depsIn(source) {
+        return [...byName.keys()].filter((name) => new RegExp(`\\b${escapeRegExp(name)}\\b`).test(source));
+    }
+    function bindingFor(name) {
+        const candidates = byName.get(name) || [];
+        if (candidates.length <= 1)
+            return candidates[0];
+        const [first, ...rest] = candidates;
+        throw new Error(`duplicate runtime binding '${name}' at line ${rest[0].line ?? '?'} (first at line ${first.line ?? '?'})`);
+    }
+    function visit(name) {
+        if (visited.has(name))
+            return undefined;
+        if (visiting.has(name)) {
+            const start = stack.indexOf(name);
+            return `runtime binding cycle: ${[...stack.slice(start), name].join(' -> ')}`;
+        }
+        let binding;
+        try {
+            binding = bindingFor(name);
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+        if (!binding)
+            return undefined;
+        visiting.add(name);
+        stack.push(name);
         for (const dep of depsIn(binding.expr)) {
+            if (dep === name && binding.kind === 'fn')
+                continue;
             const error = visit(dep);
             if (error)
                 return error;
@@ -1527,7 +3625,10 @@ function orderRuntimeBindings(bindings, entryExpr) {
         ordered.push(binding);
         return undefined;
     }
-    for (const name of depsIn(entryExpr)) {
+    const initialNames = new Set([...bindings.filter((binding) => binding.eager).map((binding) => binding.name)]);
+    for (const name of depsIn(entryExpr))
+        initialNames.add(name);
+    for (const name of initialNames) {
         const error = visit(name);
         if (error)
             return { ordered: [], error };
@@ -1540,12 +3641,14 @@ function runtimeContext() {
         Boolean,
         Error,
         JSON,
+        Map,
         Math,
         Number,
         Object,
         Promise,
         RangeError,
         ReferenceError,
+        Set,
         String,
         SyntaxError,
         TypeError,
@@ -1572,6 +3675,78 @@ function runtimeValuesEqual(actual, expected) {
         return false;
     }
 }
+function normalizeRuntimeDiffValue(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return value;
+    }
+}
+function runtimeValueKind(value) {
+    if (Array.isArray(value))
+        return 'array';
+    if (value === null)
+        return 'null';
+    return typeof value;
+}
+function runtimePathProperty(base, key) {
+    return /^[A-Za-z_$][\w$]*$/.test(key) ? `${base}.${key}` : `${base}[${JSON.stringify(key)}]`;
+}
+function firstRuntimeValueDifference(expected, actual, path = '$', depth = 0) {
+    if (runtimeValuesEqual(actual, expected))
+        return undefined;
+    if (depth > 16) {
+        return `at ${path}: expected ${formatRuntimeValue(expected)}, received ${formatRuntimeValue(actual)}`;
+    }
+    const expectedKind = runtimeValueKind(expected);
+    const actualKind = runtimeValueKind(actual);
+    if (expectedKind !== actualKind) {
+        return `at ${path}: expected ${expectedKind} ${formatRuntimeValue(expected)}, received ${actualKind} ${formatRuntimeValue(actual)}`;
+    }
+    if (Array.isArray(expected) && Array.isArray(actual)) {
+        const common = Math.min(expected.length, actual.length);
+        for (let i = 0; i < common; i++) {
+            const diff = firstRuntimeValueDifference(expected[i], actual[i], `${path}[${i}]`, depth + 1);
+            if (diff)
+                return diff;
+        }
+        if (expected.length > actual.length) {
+            return `at ${path}[${actual.length}]: missing item; expected ${formatRuntimeValue(expected[actual.length])}`;
+        }
+        return `at ${path}[${expected.length}]: unexpected item ${formatRuntimeValue(actual[expected.length])}`;
+    }
+    if (expected !== null &&
+        actual !== null &&
+        typeof expected === 'object' &&
+        typeof actual === 'object' &&
+        !Array.isArray(expected) &&
+        !Array.isArray(actual)) {
+        const expectedRecord = expected;
+        const actualRecord = actual;
+        const keys = [...new Set([...Object.keys(expectedRecord), ...Object.keys(actualRecord)])].sort();
+        for (const key of keys) {
+            const nextPath = runtimePathProperty(path, key);
+            if (!Object.hasOwn(actualRecord, key)) {
+                return `at ${nextPath}: missing property; expected ${formatRuntimeValue(expectedRecord[key])}`;
+            }
+            if (!Object.hasOwn(expectedRecord, key)) {
+                return `at ${nextPath}: unexpected property ${formatRuntimeValue(actualRecord[key])}`;
+            }
+            const diff = firstRuntimeValueDifference(expectedRecord[key], actualRecord[key], nextPath, depth + 1);
+            if (diff)
+                return diff;
+        }
+    }
+    return `at ${path}: expected ${formatRuntimeValue(expected)}, received ${formatRuntimeValue(actual)}`;
+}
+function runtimeMismatchMessage(label, expected, actual, context) {
+    const normalizedExpected = normalizeRuntimeDiffValue(expected);
+    const normalizedActual = normalizeRuntimeDiffValue(actual);
+    const diff = firstRuntimeValueDifference(normalizedExpected, normalizedActual) ||
+        `at $: expected ${formatRuntimeValue(normalizedExpected)}, received ${formatRuntimeValue(normalizedActual)}`;
+    return `${label} expected ${formatRuntimeValue(expected)}, received ${formatRuntimeValue(actual)}${context}\ndiff: ${diff}`;
+}
 function formatThrownRuntimeError(error) {
     if (error instanceof Error)
         return `${error.name}: ${error.message}`;
@@ -1587,6 +3762,12 @@ function runtimeExpressionContext(expr, fixtures) {
 function runtimeBindingUnsafeReason(binding) {
     if (binding.kind === 'fn')
         return unsafeRuntimeFunctionReason(binding.expr);
+    if (binding.kind === 'class')
+        return unsafeRuntimeClassReason(binding.expr);
+    if (binding.kind === 'workflow')
+        return unsafeRuntimeWorkflowReason(binding.expr);
+    if (binding.kind === 'native')
+        return unsafeRuntimeNativeBindingReason(binding.expr);
     return unsafeRuntimeExpressionReason(binding.expr);
 }
 function thrownRuntimeErrorMatches(error, expected) {
@@ -1686,12 +3867,14 @@ function runtimeContext() {
     Boolean,
     Error,
     JSON,
+    Map,
     Math,
     Number,
     Object,
     Promise,
     RangeError,
     ReferenceError,
+    Set,
     String,
     SyntaxError,
     TypeError,
@@ -1785,7 +3968,7 @@ function evaluateRuntimeThrows(node, target, declarations, expr, fixtures, label
     }
     return { passed: true };
 }
-function evaluateRuntimeSource(node, target, expr, fixtures = [], label = 'Runtime expr') {
+function evaluateRuntimeSource(node, target, expr, fixtures = [], label = 'Runtime expr', expectedPropName = 'equals') {
     const blocking = targetBlockingMessage(target);
     if (blocking)
         return { passed: false, message: blocking };
@@ -1793,7 +3976,9 @@ function evaluateRuntimeSource(node, target, expr, fixtures = [], label = 'Runti
     const trimmedExpr = expr.trim();
     if (!trimmedExpr)
         return { passed: false, message: `${label} assertion requires an executable expression` };
-    const expectedSource = runtimeExpectedSource(node, 'equals');
+    const expectedSource = runtimeExpectedSource(node, expectedPropName) ??
+        (expectedPropName === 'equals' ? undefined : runtimeExpectedSource(node, 'equals'));
+    const expectedLabel = expectedPropName !== 'equals' && expectedPropName in props ? expectedPropName : 'equals';
     const expressionSources = expectedSource ? [trimmedExpr, expectedSource] : [trimmedExpr];
     const declarations = buildRuntimeDeclarations(target, expressionSources, fixtures);
     if ('message' in declarations)
@@ -1814,7 +3999,7 @@ function evaluateRuntimeSource(node, target, expr, fixtures = [], label = 'Runti
         if (!expected.ok) {
             return {
                 passed: false,
-                message: `Runtime expr assertion cannot execute expected equals value: ${formatThrownRuntimeError(expected.error)}`,
+                message: `Runtime expr assertion cannot execute expected ${expectedLabel} value: ${formatThrownRuntimeError(expected.error)}`,
             };
         }
         return runtimeValuesEqual(actual.value, expected.value)
@@ -1822,7 +4007,7 @@ function evaluateRuntimeSource(node, target, expr, fixtures = [], label = 'Runti
             : {
                 passed: false,
                 message: str(props.message) ||
-                    `${label} expected ${formatRuntimeValue(expected.value)}, received ${formatRuntimeValue(actual.value)}${runtimeExpressionContext(trimmedExpr, fixtures)}`,
+                    runtimeMismatchMessage(label, expected.value, actual.value, runtimeExpressionContext(trimmedExpr, fixtures)),
             };
     }
     if ('matches' in props) {
@@ -1892,13 +4077,383 @@ function evaluateRuntimeBehavior(node, target, fixtures = []) {
             return { passed: false, message: call.message };
         return evaluateRuntimeSource(node, target, call.expr || '', fixtures, `Runtime fn ${fnName}`);
     }
-    if (deriveName) {
-        if (!targetHasNamedNode(target, 'derive', deriveName)) {
-            return { passed: false, message: `Runtime derive assertion target not found: ${deriveName}` };
-        }
-        return evaluateRuntimeSource(node, target, deriveName, fixtures, `Runtime derive ${deriveName}`);
+    if (deriveName) {
+        if (!targetHasNamedNode(target, 'derive', deriveName)) {
+            return { passed: false, message: `Runtime derive assertion target not found: ${deriveName}` };
+        }
+        return evaluateRuntimeSource(node, target, deriveName, fixtures, `Runtime derive ${deriveName}`);
+    }
+    return { passed: false, message: 'Runtime behavior assertion requires fn=<name> or derive=<name>' };
+}
+function evaluateRuntimeRoute(node, target, fixtures = [], mocks = [], mockCalls, effectCalls, guardCalls) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    const props = getProps(node);
+    const routeSpec = str(props.route);
+    if (!routeSpec)
+        return { passed: false, message: 'Runtime route assertion requires route="METHOD /path"' };
+    const found = findRuntimeRoute(target, routeSpec);
+    if (found.message || !found.route)
+        return { passed: false, message: found.message || 'Runtime route target not found' };
+    const inputSource = runtimeValuePropSource(node, 'with') || runtimeValuePropSource(node, 'input') || '{}';
+    const inputProblem = unsafeRuntimeExpressionReason(inputSource, { allowAwait: true });
+    if (inputProblem) {
+        return { passed: false, message: `Runtime route assertion cannot execute request input: ${inputProblem}` };
+    }
+    const routeExpr = runtimeRouteExecutionExpr(found.route, inputSource, { mocks, probe: true });
+    if (routeExpr.message || !routeExpr.expr) {
+        return { passed: false, message: routeExpr.message || 'Runtime route assertion cannot build route workflow' };
+    }
+    const routeBinding = {
+        name: runtimeSyntheticName(node, 'Route'),
+        expr: routeExpr.expr,
+        kind: 'workflow',
+        line: node.loc?.line,
+    };
+    const label = `Runtime route ${runtimeRouteLabel(found.route)}`;
+    const expectedSource = runtimeExpectedSource(node, 'returns') ?? runtimeExpectedSource(node, 'equals');
+    const expectedLabel = 'returns' in props ? 'returns' : 'equals';
+    const expressionSources = expectedSource ? [routeBinding.name, expectedSource] : [routeBinding.name];
+    const declarations = buildRuntimeDeclarations(target, expressionSources, [...fixtures, routeBinding]);
+    if ('message' in declarations)
+        return { passed: false, message: declarations.message };
+    const routeContext = runtimeExpressionContext(routeBinding.name, [...fixtures, routeBinding]);
+    const actual = runRuntimeExpression(target, declarations.source, routeBinding.name);
+    if (!actual.ok) {
+        return {
+            passed: false,
+            message: `${label} threw: ${actual.error instanceof Error ? actual.error.message : String(actual.error)}${routeContext}`,
+        };
+    }
+    const probe = actual.value;
+    if (!probe || typeof probe !== 'object' || typeof probe.__kernRouteStatus !== 'string') {
+        return { passed: false, message: `${label} returned an invalid runtime probe` };
+    }
+    mergeRuntimeEffectMockCalls(mockCalls, probe.calls);
+    mergeRuntimeEffectCoverageCalls(effectCalls, probe.effects);
+    mergeRuntimeGuardCoverageCalls(guardCalls, probe.guards);
+    if ('throws' in props) {
+        const expectedRaw = props.throws === true || props.throws === '' ? 'true' : String(props.throws ?? 'true');
+        if (probe.__kernRouteStatus !== 'thrown') {
+            return {
+                passed: false,
+                message: str(props.message) ||
+                    `${label} was expected to throw${expectedRaw && expectedRaw !== 'true' ? ` ${expectedRaw}` : ''}, but returned ${formatRuntimeValue(probe.value)}${routeContext}`,
+            };
+        }
+        const error = decodeRuntimeError(probe.error);
+        if (!thrownRuntimeErrorMatches(error, expectedRaw)) {
+            return {
+                passed: false,
+                message: str(props.message) ||
+                    `${label} threw ${formatThrownRuntimeError(error)}, expected ${expectedRaw}${routeContext}`,
+            };
+        }
+        return { passed: true };
+    }
+    if (probe.__kernRouteStatus === 'thrown') {
+        return {
+            passed: false,
+            message: `${label} threw: ${formatThrownRuntimeError(decodeRuntimeError(probe.error))}${routeContext}`,
+        };
+    }
+    if (expectedSource !== undefined) {
+        const expected = runRuntimeExpression(target, declarations.source, expectedSource);
+        if (!expected.ok) {
+            return {
+                passed: false,
+                message: `Runtime route assertion cannot execute expected ${expectedLabel} value: ${formatThrownRuntimeError(expected.error)}${routeContext}`,
+            };
+        }
+        return runtimeValuesEqual(probe.value, expected.value)
+            ? { passed: true }
+            : {
+                passed: false,
+                message: str(props.message) || runtimeMismatchMessage(label, expected.value, probe.value, routeContext),
+            };
+    }
+    if ('matches' in props) {
+        const pattern = runtimePatternValue(node, 'matches') || '';
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(String(probe.value))
+                ? { passed: true }
+                : {
+                    passed: false,
+                    message: str(props.message) ||
+                        `${label} value ${formatRuntimeValue(probe.value)} does not match /${pattern}/${routeContext}`,
+                };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                message: `Runtime route assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    return probe.value
+        ? { passed: true }
+        : { passed: false, message: str(props.message) || `${label} evaluated false${routeContext}` };
+}
+function evaluateRuntimeTool(node, target, fixtures = [], mocks = [], mockCalls, effectCalls, guardCalls) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    const props = getProps(node);
+    const toolName = str(props.tool);
+    if (!toolName)
+        return { passed: false, message: 'Runtime tool assertion requires tool=<name>' };
+    const found = findRuntimeTool(target, toolName);
+    if (found.message || !found.tool) {
+        return { passed: false, message: found.message || 'Runtime tool target not found' };
+    }
+    const inputSource = runtimeValuePropSource(node, 'with') || runtimeValuePropSource(node, 'input') || '{}';
+    const inputProblem = unsafeRuntimeExpressionReason(inputSource, { allowAwait: true });
+    if (inputProblem) {
+        return { passed: false, message: `Runtime tool assertion cannot execute input: ${inputProblem}` };
+    }
+    const toolExpr = runtimeToolExecutionExpr(found.tool, inputSource, { mocks, probe: true });
+    if (toolExpr.message || !toolExpr.expr) {
+        return { passed: false, message: toolExpr.message || 'Runtime tool assertion cannot build tool workflow' };
+    }
+    const toolBinding = {
+        name: runtimeSyntheticName(node, 'Tool'),
+        expr: toolExpr.expr,
+        kind: 'workflow',
+        line: node.loc?.line,
+    };
+    const label = `Runtime tool ${runtimeToolName(found.tool)}`;
+    const expectedSource = runtimeExpectedSource(node, 'returns') ?? runtimeExpectedSource(node, 'equals');
+    const expectedLabel = 'returns' in props ? 'returns' : 'equals';
+    const expressionSources = expectedSource ? [toolBinding.name, expectedSource] : [toolBinding.name];
+    const declarations = buildRuntimeDeclarations(target, expressionSources, [...fixtures, toolBinding]);
+    if ('message' in declarations)
+        return { passed: false, message: declarations.message };
+    const toolContext = runtimeExpressionContext(toolBinding.name, [...fixtures, toolBinding]);
+    const actual = runRuntimeExpression(target, declarations.source, toolBinding.name);
+    if (!actual.ok) {
+        return {
+            passed: false,
+            message: `${label} threw: ${actual.error instanceof Error ? actual.error.message : String(actual.error)}${toolContext}`,
+        };
+    }
+    const probe = actual.value;
+    if (!probe || typeof probe !== 'object' || typeof probe.__kernToolStatus !== 'string') {
+        return { passed: false, message: `${label} returned an invalid runtime probe` };
+    }
+    mergeRuntimeEffectMockCalls(mockCalls, probe.calls);
+    mergeRuntimeEffectCoverageCalls(effectCalls, probe.effects);
+    mergeRuntimeGuardCoverageCalls(guardCalls, probe.guards);
+    if ('throws' in props) {
+        const expectedRaw = props.throws === true || props.throws === '' ? 'true' : String(props.throws ?? 'true');
+        if (probe.__kernToolStatus !== 'thrown') {
+            return {
+                passed: false,
+                message: str(props.message) ||
+                    `${label} was expected to throw${expectedRaw && expectedRaw !== 'true' ? ` ${expectedRaw}` : ''}, but returned ${formatRuntimeValue(probe.value)}${toolContext}`,
+            };
+        }
+        const error = decodeRuntimeError(probe.error);
+        if (!thrownRuntimeErrorMatches(error, expectedRaw)) {
+            return {
+                passed: false,
+                message: str(props.message) ||
+                    `${label} threw ${formatThrownRuntimeError(error)}, expected ${expectedRaw}${toolContext}`,
+            };
+        }
+        return { passed: true };
+    }
+    if (probe.__kernToolStatus === 'thrown') {
+        return {
+            passed: false,
+            message: `${label} threw: ${formatThrownRuntimeError(decodeRuntimeError(probe.error))}${toolContext}`,
+        };
+    }
+    if (expectedSource !== undefined) {
+        const expected = runRuntimeExpression(target, declarations.source, expectedSource);
+        if (!expected.ok) {
+            return {
+                passed: false,
+                message: `Runtime tool assertion cannot execute expected ${expectedLabel} value: ${formatThrownRuntimeError(expected.error)}${toolContext}`,
+            };
+        }
+        return runtimeValuesEqual(probe.value, expected.value)
+            ? { passed: true }
+            : {
+                passed: false,
+                message: str(props.message) || runtimeMismatchMessage(label, expected.value, probe.value, toolContext),
+            };
+    }
+    if ('matches' in props) {
+        const pattern = runtimePatternValue(node, 'matches') || '';
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(String(probe.value))
+                ? { passed: true }
+                : {
+                    passed: false,
+                    message: str(props.message) ||
+                        `${label} value ${formatRuntimeValue(probe.value)} does not match /${pattern}/${toolContext}`,
+                };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                message: `Runtime tool assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    return probe.value
+        ? { passed: true }
+        : { passed: false, message: str(props.message) || `${label} evaluated false${toolContext}` };
+}
+function findRuntimeEffect(target, effectName) {
+    const effects = collectNodes(target.root, 'effect').filter((effect) => runtimeEffectName(effect) === effectName);
+    if (effects.length === 1)
+        return { effect: effects[0] };
+    if (effects.length === 0)
+        return { message: `Runtime effect assertion target not found: ${effectName}` };
+    return { message: `Runtime effect assertion target is ambiguous: ${effectName}` };
+}
+function runtimeEffectExpectedSource(node) {
+    const fallback = runtimeExpectedSource(node, 'fallback');
+    if (fallback !== undefined)
+        return { source: fallback, label: 'fallback' };
+    const returns = runtimeExpectedSource(node, 'returns');
+    if (returns !== undefined)
+        return { source: returns, label: 'returns' };
+    const equals = runtimeExpectedSource(node, 'equals');
+    if (equals !== undefined)
+        return { source: equals, label: 'equals' };
+    return {};
+}
+function evaluateRuntimeEffectRecovery(node, target, effect, fixtures, mocks = [], mockCalls) {
+    const props = getProps(node);
+    const effectName = runtimeEffectName(effect);
+    const scopedMock = findRuntimeEffectMock(mocks, effectName);
+    if (scopedMock.message)
+        return { passed: false, message: scopedMock.message };
+    const effectExpr = scopedMock.mock
+        ? runtimeEffectMockExecutionExpr(scopedMock.mock, { portable: true, meta: true })
+        : runtimeEffectExecutionExpr(effect, { portable: true, meta: true });
+    if (effectExpr.message || !effectExpr.expr) {
+        return { passed: false, message: effectExpr.message || `Runtime effect ${effectName} cannot be simulated` };
+    }
+    const effectBinding = {
+        name: runtimeSyntheticName(node, 'Effect'),
+        expr: effectExpr.expr,
+        kind: 'workflow',
+        line: node.loc?.line,
+    };
+    const expected = runtimeEffectExpectedSource(node);
+    const entryExprs = expected.source ? [effectBinding.name, expected.source] : [effectBinding.name];
+    const declarations = buildRuntimeDeclarations(target, entryExprs, [...fixtures, effectBinding]);
+    if ('message' in declarations)
+        return { passed: false, message: declarations.message };
+    const effectContext = runtimeExpressionContext(effectBinding.name, [...fixtures, effectBinding]);
+    const actual = runRuntimeExpression(target, declarations.source, effectBinding.name);
+    if (scopedMock.mock)
+        recordRuntimeEffectMockCall(scopedMock.mock, mockCalls);
+    if (!actual.ok) {
+        return {
+            passed: false,
+            message: `Runtime effect ${effectName} threw: ${formatThrownRuntimeError(actual.error)}`,
+        };
+    }
+    const meta = actual.value;
+    if (isTruthy(props.recovers) && meta.recovered !== true) {
+        return {
+            passed: false,
+            message: str(props.message) || `Runtime effect ${effectName} was expected to recover, but completed without recovery`,
+        };
+    }
+    if (expected.source !== undefined) {
+        const expectedResult = runRuntimeExpression(target, declarations.source, expected.source);
+        if (!expectedResult.ok) {
+            return {
+                passed: false,
+                message: `Runtime effect assertion cannot execute expected ${expected.label} value: ${formatThrownRuntimeError(expectedResult.error)}`,
+            };
+        }
+        return runtimeValuesEqual(meta.result, expectedResult.value)
+            ? { passed: true }
+            : {
+                passed: false,
+                message: str(props.message) ||
+                    runtimeMismatchMessage(`Runtime effect ${effectName}`, expectedResult.value, meta.result, effectContext),
+            };
+    }
+    return { passed: true };
+}
+function evaluateRuntimeEffect(node, target, fixtures = [], mocks = [], mockCalls) {
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { passed: false, message: blocking };
+    const props = getProps(node);
+    const effectName = str(props.effect);
+    if (!effectName)
+        return { passed: false, message: 'Runtime effect assertion requires effect=<name>' };
+    const found = findRuntimeEffect(target, effectName);
+    if (found.message || !found.effect) {
+        return { passed: false, message: found.message || 'Runtime effect target not found' };
+    }
+    if (isTruthy(props.recovers)) {
+        return evaluateRuntimeEffectRecovery(node, target, found.effect, fixtures, mocks, mockCalls);
+    }
+    const scopedMock = findRuntimeEffectMock(mocks, effectName);
+    if (scopedMock.message)
+        return { passed: false, message: scopedMock.message };
+    const effectExpr = scopedMock.mock
+        ? runtimeEffectMockExecutionExpr(scopedMock.mock, { portable: true })
+        : runtimeEffectExecutionExpr(found.effect, { portable: true });
+    if (effectExpr.message || !effectExpr.expr) {
+        return { passed: false, message: effectExpr.message || `Runtime effect ${effectName} cannot be simulated` };
+    }
+    const effectBinding = {
+        name: runtimeSyntheticName(node, 'Effect'),
+        expr: effectExpr.expr,
+        kind: 'workflow',
+        line: node.loc?.line,
+    };
+    const evaluated = evaluateRuntimeSource(node, target, effectBinding.name, [...fixtures, effectBinding], `Runtime effect ${effectName}`, 'returns');
+    if (scopedMock.mock && !isAssertionConfigurationFailure(evaluated.message)) {
+        recordRuntimeEffectMockCall(scopedMock.mock, mockCalls);
+    }
+    return evaluated;
+}
+function expectedMockCallCount(node) {
+    const raw = getProps(node).called;
+    const count = Number(raw);
+    if (raw === '' || !Number.isInteger(count) || count < 0) {
+        return { message: `Runtime mock call assertion requires called=<non-negative integer>, got ${String(raw)}` };
     }
-    return { passed: false, message: 'Runtime behavior assertion requires fn=<name> or derive=<name>' };
+    return { count };
+}
+function evaluateRuntimeMockCall(node, mocks = [], mockCalls, checkedMocks) {
+    const props = getProps(node);
+    const effectName = str(props.mock);
+    if (!effectName)
+        return { passed: false, message: 'Runtime mock call assertion requires mock=<effect>' };
+    if (!('called' in props))
+        return { passed: false, message: 'Runtime mock call assertion requires called=<count>' };
+    const expected = expectedMockCallCount(node);
+    if (expected.message || expected.count === undefined)
+        return { passed: false, message: expected.message };
+    const scopedMock = findRuntimeEffectMock(mocks, effectName);
+    if (scopedMock.message)
+        return { passed: false, message: scopedMock.message };
+    if (!scopedMock.mock)
+        return { passed: false, message: `Runtime mock assertion target not found: ${effectName}` };
+    markRuntimeEffectMockChecked(scopedMock.mock, checkedMocks);
+    const actual = mockCalls?.get(scopedMock.mock.id) || 0;
+    return actual === expected.count
+        ? { passed: true }
+        : {
+            passed: false,
+            message: str(props.message) ||
+                `Native effect mock effect=${effectName} expected called=${expected.count}, received called=${actual}`,
+        };
 }
 function nodeSearchText(node) {
     const props = getProps(node);
@@ -2341,12 +4896,235 @@ function evaluateNoInvariant(node, target, context) {
         return untested.length > 0
             ? {
                 passed: false,
-                message: `Found untested guards: ${untested.join('; ')}. Add expect guard=<name> exhaustive=true or a guard-wide assertion such as expect preset=guard.`,
+                message: `Found untested guards: ${untested.join('; ')}. Add expect guard=<name> exhaustive=true, a route/tool workflow assertion that executes the guard, or a guard-wide assertion such as expect preset=guard.`,
+            }
+            : { passed: true };
+    }
+    if (invariant === 'untestedroutes' || invariant === 'uncoveredroutes') {
+        const blocking = targetBlockingMessage(target);
+        if (blocking)
+            return { passed: false, message: blocking };
+        const untested = findUntestedRoutes(target.root, context);
+        return untested.length > 0
+            ? {
+                passed: false,
+                message: `Found untested routes: ${untested.join('; ')}. Add expect route="METHOD /path" assertions for each route.`,
+            }
+            : { passed: true };
+    }
+    if (invariant === 'untestedtools' || invariant === 'uncoveredtools') {
+        const blocking = targetBlockingMessage(target);
+        if (blocking)
+            return { passed: false, message: blocking };
+        const untested = findUntestedTools(target.root, context);
+        return untested.length > 0
+            ? {
+                passed: false,
+                message: `Found untested tools: ${untested.join('; ')}. Add expect tool=<name> assertions for each MCP tool.`,
+            }
+            : { passed: true };
+    }
+    if (invariant === 'untestedeffects' || invariant === 'uncoveredeffects') {
+        const blocking = targetBlockingMessage(target);
+        if (blocking)
+            return { passed: false, message: blocking };
+        const untested = findUntestedEffects(target.root, context);
+        return untested.length > 0
+            ? {
+                passed: false,
+                message: `Found untested effects: ${untested.join('; ')}. Add expect effect=<name> assertions for deterministic effects.`,
             }
             : { passed: true };
     }
     return { passed: false, message: `Unsupported native invariant: no=${str(getProps(node).no)}` };
 }
+function diagnosticFinding(file, issue) {
+    return `${file}:${issue.line ?? 1}:${issue.col ?? 1}: ${issue.message}`;
+}
+function nativeInvariantFindings(node, target, context) {
+    if (target.readError)
+        return { message: target.readError };
+    const props = getProps(node);
+    const invariant = normalizeInvariant(str(props.has) || str(props.no));
+    const machineName = str(props.machine) || undefined;
+    if (invariant === 'parseerrors') {
+        return {
+            findings: target.diagnostics
+                .filter((diagnostic) => diagnostic.severity === 'error')
+                .map((diagnostic) => diagnosticFinding(target.file, diagnostic)),
+        };
+    }
+    if (invariant === 'schemaviolations') {
+        return { findings: target.schemaViolations.map((violation) => diagnosticFinding(target.file, violation)) };
+    }
+    if (invariant === 'semanticviolations') {
+        return { findings: target.semanticViolations.map((violation) => diagnosticFinding(target.file, violation)) };
+    }
+    const blocking = targetBlockingMessage(target);
+    if (blocking)
+        return { message: blocking };
+    const root = target.root;
+    if (invariant === 'codegenerrors' || invariant === 'codegenerationerrors' || invariant === 'compileerrors') {
+        return { findings: findCodegenErrors(root) };
+    }
+    if (invariant === 'cycles' || invariant === 'derivecycles') {
+        return { findings: findDeriveCycles(root).map((cycle) => cycle.join(' -> ')) };
+    }
+    if (invariant === 'deadstates' || invariant === 'unreachablestates') {
+        return { findings: findUnreachableStates(root, machineName) };
+    }
+    if (invariant === 'duplicatetransitions') {
+        return { findings: findDuplicateTransitions(root, machineName) };
+    }
+    if (invariant === 'duplicateroutes') {
+        return { findings: findDuplicateRoutes(root) };
+    }
+    if (invariant === 'emptyroutes' || invariant === 'missingroutehandlers' || invariant === 'missingrouteresponses') {
+        return { findings: findEmptyRoutes(root) };
+    }
+    if (invariant === 'duplicatenames' || invariant === 'duplicatesiblingnames') {
+        return { findings: findDuplicateSiblingNames(root) };
+    }
+    if (invariant === 'weakguards' || invariant === 'guardwithoutelse' || invariant === 'guardswithoutelse') {
+        return { findings: findWeakGuards(root) };
+    }
+    if (invariant === 'nonexhaustiveguards' || invariant === 'guardexhaustiveness' || invariant === 'exhaustiveguards') {
+        return { findings: findNonExhaustiveGuards(root) };
+    }
+    if (invariant === 'unguardedeffects') {
+        return { findings: findUnguardedEffects(root) };
+    }
+    if (invariant === 'unvalidatedroutes' || invariant === 'unguardedmutatingroutes') {
+        return { findings: findUnvalidatedMutatingRoutes(root) };
+    }
+    if (invariant === 'rawhandlers' || invariant === 'handlerescapes') {
+        return { findings: findRawHandlerEscapes(root) };
+    }
+    if (invariant === 'invalidguards' || invariant === 'guardmisconfigurations') {
+        return { findings: findInvalidGuards(root) };
+    }
+    if (invariant === 'duplicateparams' || invariant === 'duplicateparameters') {
+        return { findings: findDuplicateParams(root) };
+    }
+    if (invariant === 'unguardedtoolparams' || invariant === 'unguardedrequiredparams') {
+        return { findings: findUnguardedRequiredToolParams(root) };
+    }
+    if (invariant === 'missingpathguards' || invariant === 'pathparamguards') {
+        return { findings: findMissingPathGuards(root) };
+    }
+    if (invariant === 'ssrfrisks' || invariant === 'ssrf') {
+        return { findings: findSsrfRisks(root) };
+    }
+    if (invariant === 'sensitiveeffectsrequireauth' || invariant === 'missingeffectauth' || invariant === 'missingauth') {
+        return { findings: findSensitiveEffectsWithoutAuth(root) };
+    }
+    if (invariant === 'uncheckedroutepathparams' || invariant === 'routepathparams') {
+        return { findings: findUncheckedRoutePathParams(root) };
+    }
+    if (invariant === 'effectwithoutcleanup' || invariant === 'effectcleanup') {
+        return { findings: findEffectsWithoutCleanup(root) };
+    }
+    if (invariant === 'unrecoveredasync' || invariant === 'asyncrecover') {
+        return { findings: findUnrecoveredAsync(root) };
+    }
+    if (invariant === 'untestedtransitions' || invariant === 'uncoveredtransitions') {
+        return { findings: findUntestedTransitions(root, context, machineName) };
+    }
+    if (invariant === 'untestedguards' || invariant === 'uncoveredguards') {
+        return { findings: findUntestedGuards(root, context) };
+    }
+    if (invariant === 'untestedroutes' || invariant === 'uncoveredroutes') {
+        return { findings: findUntestedRoutes(root, context) };
+    }
+    if (invariant === 'untestedtools' || invariant === 'uncoveredtools') {
+        return { findings: findUntestedTools(root, context) };
+    }
+    if (invariant === 'untestedeffects' || invariant === 'uncoveredeffects') {
+        return { findings: findUntestedEffects(root, context) };
+    }
+    const propName = 'has' in props ? 'has' : 'no';
+    return { message: `Unsupported native invariant: ${propName}=${str(props.has) || str(props.no)}` };
+}
+function evaluateHasInvariant(node, target, context) {
+    const props = getProps(node);
+    const invariant = str(props.has);
+    const normalized = normalizeInvariant(invariant);
+    const expectedCount = props.count === undefined || props.count === '' ? undefined : Number(props.count);
+    if (expectedCount !== undefined && (!Number.isInteger(expectedCount) || expectedCount < 0)) {
+        return {
+            passed: false,
+            message: `Native has assertion count must be a non-negative integer: ${String(props.count)}`,
+        };
+    }
+    if (expectedCount !== undefined) {
+        const collected = nativeInvariantFindings(node, target, context);
+        if (collected.message)
+            return { passed: false, message: collected.message };
+        const findings = collected.findings || [];
+        if (findings.length !== expectedCount) {
+            const details = findings.length > 0 ? `: ${findings.slice(0, 10).join('; ')}` : '';
+            const extra = findings.length > 10 ? `; +${findings.length - 10} more` : '';
+            return {
+                passed: false,
+                message: `Expected target to have ${invariant || '<missing>'} count ${expectedCount}, found ${findings.length}${details}${extra}`,
+            };
+        }
+        if ('matches' in props) {
+            const pattern = runtimePatternValue(node, 'matches') || '';
+            const message = findings.join('; ');
+            try {
+                const regex = new RegExp(pattern);
+                return regex.test(message)
+                    ? { passed: true }
+                    : {
+                        passed: false,
+                        message: `Expected ${invariant || '<missing>'} findings to match /${pattern}/, got: ${message || '<none>'}`,
+                    };
+            }
+            catch (error) {
+                return {
+                    passed: false,
+                    message: `Native has assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        return { passed: true };
+    }
+    if (!['parseerrors', 'schemaviolations', 'semanticviolations'].includes(normalized)) {
+        const blocking = targetBlockingMessage(target);
+        if (blocking)
+            return { passed: false, message: blocking };
+    }
+    const evaluated = evaluateNoInvariant(nodeWithProps(node, { ...props, no: invariant }), target, context);
+    if (isAssertionConfigurationFailure(evaluated.message)) {
+        return { passed: false, message: evaluated.message };
+    }
+    if (evaluated.passed) {
+        return {
+            passed: false,
+            message: `Expected target to have ${invariant || '<missing>'}, but none was found`,
+        };
+    }
+    if ('matches' in props) {
+        const pattern = runtimePatternValue(node, 'matches') || '';
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(evaluated.message || '')
+                ? { passed: true }
+                : {
+                    passed: false,
+                    message: `Expected ${invariant || '<missing>'} message to match /${pattern}/, got: ${evaluated.message || '<none>'}`,
+                };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                message: `Native has assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    return { passed: true };
+}
 function evaluateMachineReachability(node, target) {
     const blocking = targetBlockingMessage(target);
     if (blocking)
@@ -2558,6 +5336,54 @@ function evaluatePresetAssertion(node, target, context) {
 }
 function evaluateNativeAssertion(node, target, context) {
     const props = getProps(node);
+    if ('decompile' in props) {
+        const evaluated = evaluateDecompileAssertion(node, target);
+        return [
+            {
+                ruleId: 'decompile',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('import' in props) {
+        const evaluated = evaluateImportAssertion(node, context);
+        return [
+            {
+                ruleId: 'import',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('roundtrip' in props) {
+        const evaluated = evaluateRoundtripAssertion(node, target);
+        return [
+            {
+                ruleId: 'roundtrip',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('codegen' in props) {
+        const evaluated = evaluateCodegenAssertion(node, target);
+        return [
+            {
+                ruleId: 'codegen',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
     if ('preset' in props)
         return evaluatePresetAssertion(node, target, context);
     if ('node' in props) {
@@ -2584,6 +5410,18 @@ function evaluateNativeAssertion(node, target, context) {
             },
         ];
     }
+    if ('has' in props) {
+        const evaluated = evaluateHasInvariant(node, target, context);
+        return [
+            {
+                ruleId: hasInvariantRuleId(str(props.has)),
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
     if ('guard' in props) {
         const evaluated = evaluateGuardExhaustiveness(node, target);
         return [
@@ -2632,6 +5470,54 @@ function evaluateNativeAssertion(node, target, context) {
             },
         ];
     }
+    if ('route' in props) {
+        const evaluated = evaluateRuntimeRoute(node, target, context?.fixtures || [], context?.mocks || [], context?.mockCalls);
+        return [
+            {
+                ruleId: 'runtime:route',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('tool' in props) {
+        const evaluated = evaluateRuntimeTool(node, target, context?.fixtures || [], context?.mocks || [], context?.mockCalls);
+        return [
+            {
+                ruleId: 'runtime:tool',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('effect' in props) {
+        const evaluated = evaluateRuntimeEffect(node, target, context?.fixtures || [], context?.mocks || [], context?.mockCalls);
+        return [
+            {
+                ruleId: 'runtime:effect',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
+    if ('mock' in props || 'called' in props) {
+        const evaluated = evaluateRuntimeMockCall(node, context?.mocks || [], context?.mockCalls, context?.checkedMocks);
+        return [
+            {
+                ruleId: 'mock:called',
+                assertion: assertionLabel(node),
+                passed: evaluated.passed,
+                ...(isAssertionConfigurationFailure(evaluated.message) ? { severity: 'error' } : {}),
+                ...(evaluated.message ? { message: evaluated.message } : {}),
+            },
+        ];
+    }
     if ('expr' in props) {
         const evaluated = evaluateRuntimeExpression(node, target, context?.fixtures || []);
         return [
@@ -2710,6 +5596,8 @@ export function runNativeKernTests(file, options = {}) {
     const testDoc = loadKernDocument(inputPath);
     const results = [];
     const targetFiles = new Set();
+    const coverageExcludedTargetFiles = new Set();
+    const coverageIncludedTargetFiles = new Set();
     if (testDoc.readError) {
         results.push(issueResult(inputPath, testDoc.readError));
         return summarizeNativeTestRun(inputPath, targetFiles, results);
@@ -2727,7 +5615,10 @@ export function runNativeKernTests(file, options = {}) {
     const testNodes = collectNodes(testDoc.root, 'test');
     const targetCache = new Map([[inputPath, testDoc]]);
     const assertionsByTarget = new Map();
-    const summarize = () => summarizeNativeTestRun(inputPath, targetFiles, results, createCoverageSummary([...targetFiles].sort().map((targetFile) => {
+    const summarize = () => summarizeNativeTestRun(inputPath, targetFiles, results, createCoverageSummary([...targetFiles]
+        .sort()
+        .filter((targetFile) => !coverageExcludedTargetFiles.has(targetFile) || coverageIncludedTargetFiles.has(targetFile))
+        .map((targetFile) => {
         const target = targetCache.get(targetFile);
         return coverageForTarget(target || {
             file: targetFile,
@@ -2742,12 +5633,25 @@ export function runNativeKernTests(file, options = {}) {
         const targetProp = str(getProps(testNode).target);
         const targetPath = targetProp ? resolve(dirname(inputPath), targetProp) : inputPath;
         targetFiles.add(targetPath);
+        if (testNodeContributesCoverage(testNode)) {
+            coverageIncludedTargetFiles.add(targetPath);
+        }
+        else {
+            coverageExcludedTargetFiles.add(targetPath);
+        }
         let target = targetCache.get(targetPath);
         if (!target) {
             target = loadKernDocument(targetPath);
             targetCache.set(targetPath, target);
         }
         const assertions = collectAssertions(testNode);
+        const declaredMocks = new Map();
+        for (const assertion of assertions) {
+            for (const mock of assertion.mocks)
+                declaredMocks.set(mock.id, mock);
+        }
+        const mockCalls = new Map();
+        const checkedMocks = new Set();
         assertionsByTarget.set(targetPath, [...(assertionsByTarget.get(targetPath) || []), ...assertions]);
         if (assertions.length === 0) {
             results.push({
@@ -2765,7 +5669,14 @@ export function runNativeKernTests(file, options = {}) {
             continue;
         }
         for (const assertion of assertions) {
-            const context = { assertions, fixtures: assertion.fixtures };
+            const context = {
+                assertions,
+                testFile: inputPath,
+                fixtures: assertion.fixtures,
+                mocks: assertion.mocks,
+                mockCalls,
+                checkedMocks,
+            };
             const requestedSeverity = severityFromNode(assertion.node);
             for (const evaluated of evaluateNativeAssertion(assertion.node, target, context)) {
                 const severity = effectiveSeverity(requestedSeverity, evaluated);
@@ -2789,6 +5700,27 @@ export function runNativeKernTests(file, options = {}) {
                 }
             }
         }
+        for (const mock of declaredMocks.values()) {
+            if ((mockCalls.get(mock.id) || 0) > 0 || checkedMocks.has(mock.id))
+                continue;
+            const result = {
+                suite,
+                caseName: 'mock usage',
+                ruleId: 'mock:unused',
+                assertion: `mock effect ${mock.effect}`,
+                severity: 'error',
+                status: 'failed',
+                message: `Native effect mock effect=${mock.effect} was declared but never used`,
+                file: inputPath,
+                line: mock.line,
+                col: mock.col,
+            };
+            if (!grepMatches(options, result))
+                continue;
+            results.push(result);
+            if (options.bail)
+                return summarize();
+        }
     }
     return summarize();
 }
@@ -2934,17 +5866,22 @@ export function formatNativeKernTestCoverage(coverage) {
         `coverage ${coverage.covered}/${coverage.total} (${coverage.percent}%)`,
         coverageLine('transitions', coverage.transitions),
         coverageLine('guards', coverage.guards),
+        coverageLine('routes', coverage.routes),
+        coverageLine('tools', coverage.tools),
+        coverageLine('effects', coverage.effects),
     ];
-    const uncoveredTransitions = coverage.transitions.uncovered;
-    const uncoveredGuards = coverage.guards.uncovered;
-    if (uncoveredTransitions.length > 0) {
-        lines.push('uncovered transitions:');
-        for (const item of uncoveredTransitions)
-            lines.push(`  ${item}`);
-    }
-    if (uncoveredGuards.length > 0) {
-        lines.push('uncovered guards:');
-        for (const item of uncoveredGuards)
+    const uncoveredSections = [
+        ['transitions', coverage.transitions.uncovered],
+        ['guards', coverage.guards.uncovered],
+        ['routes', coverage.routes.uncovered],
+        ['tools', coverage.tools.uncovered],
+        ['effects', coverage.effects.uncovered],
+    ];
+    for (const [name, uncovered] of uncoveredSections) {
+        if (uncovered.length === 0)
+            continue;
+        lines.push(`uncovered ${name}:`);
+        for (const item of uncovered)
             lines.push(`  ${item}`);
     }
     return `${lines.join('\n')}\n`;
@@ -2955,8 +5892,10 @@ function formatNativeKernTestResult(result, summaryFile) {
         ? ` (${relative(process.cwd(), result.file || summaryFile)}:${result.line}:${result.col ?? 1})`
         : '';
     const lines = [`${marker} ${result.suite} > ${result.caseName}: ${result.assertion} [${result.ruleId}]${loc}`];
-    if (result.status !== 'passed' && result.message)
-        lines.push(`  ${result.message}`);
+    if (result.status !== 'passed' && result.message) {
+        for (const line of result.message.split('\n'))
+            lines.push(`  ${line}`);
+    }
     return lines;
 }
 export function formatNativeKernTestSummary(summary, options = {}) {