@kernlang/core 2.0.0 → 3.0.0

package/dist/codegen-core.js

@@ -7,6 +7,37 @@
  * Machine nodes are KERN's killer feature: 12 lines of KERN → 140+ lines of TS.
  */
 import { isTemplateNode, expandTemplateNode } from './template-engine.js';
+import { KernCodegenError } from './errors.js';
+// ── Evolved Generators (v4) ─────────────────────────────────────────────
+// Populated at startup by evolved-node-loader. Checked in generateCoreNode
+// before the default case, allowing graduated nodes to produce output.
+const _evolvedGenerators = new Map();
+const _evolvedTargetGenerators = new Map();
+/** Register an evolved generator (called at startup). */
+export function registerEvolvedGenerator(keyword, fn) {
+    _evolvedGenerators.set(keyword, fn);
+}
+/** Register a target-specific evolved generator (called at startup). */
+export function registerEvolvedTargetGenerator(keyword, target, fn) {
+    if (!_evolvedTargetGenerators.has(keyword)) {
+        _evolvedTargetGenerators.set(keyword, new Map());
+    }
+    _evolvedTargetGenerators.get(keyword).set(target, fn);
+}
+/** Unregister an evolved generator (for rollback/testing). */
+export function unregisterEvolvedGenerator(keyword) {
+    _evolvedGenerators.delete(keyword);
+    _evolvedTargetGenerators.delete(keyword);
+}
+/** Clear all evolved generators (for test isolation). */
+export function clearEvolvedGenerators() {
+    _evolvedGenerators.clear();
+    _evolvedTargetGenerators.clear();
+}
+/** Check if an evolved generator exists for a type. */
+export function hasEvolvedGenerator(type) {
+    return _evolvedGenerators.has(type);
+}
 // ── Helpers ──────────────────────────────────────────────────────────────
 function p(node) {
     return node.props || {};
@@ -73,6 +104,125 @@ export function generateInterface(node) {
     lines.push('}');
     return lines;
 }
+// ── Discriminated Union ──────────────────────────────────────────────────
+// union name=ContentSegment discriminant=type
+//   variant name=prose
+//     field name=text type=string
+//   variant name=code
+//     field name=language type=string
+//     field name=code type=string
+// → export type ContentSegment =
+//   | { type: 'prose'; text: string }
+//   | { type: 'code'; language: string; code: string };
+export function generateUnion(node) {
+    const props = p(node);
+    const name = props.name;
+    const discriminant = props.discriminant || 'type';
+    const exp = exportPrefix(node);
+    const variants = kids(node, 'variant');
+    if (variants.length === 0) {
+        return [`${exp}type ${name} = never;`];
+    }
+    const lines = [`${exp}type ${name} =`];
+    for (let i = 0; i < variants.length; i++) {
+        const vp = p(variants[i]);
+        const vname = vp.name;
+        const fields = kids(variants[i], 'field');
+        const fieldParts = [`${discriminant}: '${vname}'`];
+        for (const field of fields) {
+            const fp = p(field);
+            const opt = fp.optional === 'true' || fp.optional === true ? '?' : '';
+            fieldParts.push(`${fp.name}${opt}: ${fp.type}`);
+        }
+        const semi = i === variants.length - 1 ? ';' : '';
+        lines.push(`  | { ${fieldParts.join('; ')} }${semi}`);
+    }
+    return lines;
+}
+// ── Service (Class) ─────────────────────────────────────────────────────
+// service name=TokenTracker
+//   field name=entries type="TokenUsage[]" default="[]" private=true
+//   method name=record params="usage:TokenUsage" returns=void
+//     handler <<<
+//       this.entries.push(usage);
+//     >>>
+//   method name=getStats returns=SessionStats
+//     handler <<<
+//       return { ... };
+//     >>>
+// singleton name=tracker type=TokenTracker
+// → export class TokenTracker { ... }
+// → export const tracker = new TokenTracker();
+export function generateService(node) {
+    const props = p(node);
+    const name = props.name;
+    const impl = props.implements;
+    const exp = exportPrefix(node);
+    const lines = [];
+    const implClause = impl ? ` implements ${impl}` : '';
+    lines.push(`${exp}class ${name}${implClause} {`);
+    // Fields
+    for (const field of kids(node, 'field')) {
+        const fp = p(field);
+        const vis = fp.private === 'true' || fp.private === true ? 'private ' : '';
+        const readonly = fp.readonly === 'true' || fp.readonly === true ? 'readonly ' : '';
+        const typeAnnotation = fp.type ? `: ${fp.type}` : '';
+        const defaultVal = fp.default;
+        const init = defaultVal !== undefined ? ` = ${defaultVal}` : '';
+        lines.push(`  ${vis}${readonly}${fp.name}${typeAnnotation}${init};`);
+    }
+    // Constructor (if any constructor child exists)
+    const ctorNode = firstChild(node, 'constructor');
+    if (ctorNode) {
+        const ctorProps = p(ctorNode);
+        const ctorParams = ctorProps.params ? parseParamList(ctorProps.params) : '';
+        const ctorCode = handlerCode(ctorNode);
+        lines.push('');
+        lines.push(`  constructor(${ctorParams}) {`);
+        if (ctorCode) {
+            for (const line of ctorCode.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push('  }');
+    }
+    // Methods
+    for (const method of kids(node, 'method')) {
+        const mp = p(method);
+        const mname = mp.name;
+        const mparams = mp.params ? parseParamList(mp.params) : '';
+        const isAsync = mp.async === 'true' || mp.async === true;
+        const isStream = mp.stream === 'true' || mp.stream === true;
+        const isStatic = mp.static === 'true' || mp.static === true;
+        const vis = mp.private === 'true' || mp.private === true ? 'private ' : '';
+        const staticKw = isStatic ? 'static ' : '';
+        const star = isStream ? '*' : '';
+        const asyncKw = (isAsync || isStream) ? 'async ' : '';
+        const mcode = handlerCode(method);
+        // stream=true → AsyncGenerator return type
+        const mreturns = isStream
+            ? `: AsyncGenerator<${mp.returns || 'unknown'}>`
+            : mp.returns ? `: ${mp.returns}` : '';
+        lines.push('');
+        lines.push(`  ${vis}${staticKw}${asyncKw}${star}${mname}(${mparams})${mreturns} {`);
+        if (mcode) {
+            for (const line of mcode.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push('  }');
+    }
+    lines.push('}');
+    // Singleton instances
+    for (const singleton of kids(node, 'singleton')) {
+        const sp = p(singleton);
+        const sname = sp.name;
+        const stype = sp.type || name;
+        lines.push('');
+        lines.push(`${exp}const ${sname} = new ${stype}();`);
+    }
+    return lines;
+}
 // ── Function ─────────────────────────────────────────────────────────────
 // fn name=createPlan params="action:PlanAction,ws:WorkspaceSnapshot" returns=Plan
 //   handler <<<
@@ -84,20 +234,59 @@ export function generateFunction(node) {
     const params = props.params || '';
     const returns = props.returns;
     const isAsync = props.async === 'true' || props.async === true;
+    const isStream = props.stream === 'true' || props.stream === true;
     const exp = exportPrefix(node);
     const lines = [];
-    // Parse params: "action:PlanAction,ws:WorkspaceSnapshot" → "action: PlanAction, ws: WorkspaceSnapshot"
-    const paramList = params
-        ? params.split(',').map(s => {
-            const [pname, ...ptype] = s.split(':').map(t => t.trim());
-            return ptype.length > 0 ? `${pname}: ${ptype.join(':')}` : pname;
-        }).join(', ')
-        : '';
+    // Parse params: "action:PlanAction,ws:WorkspaceSnapshot,spread:number=8"
+    // → "action: PlanAction, ws: WorkspaceSnapshot, spread: number = 8"
+    const paramList = params ? parseParamList(params) : '';
+    // stream=true → async generator function
+    if (isStream) {
+        const yieldType = returns || 'unknown';
+        const retClause = `: AsyncGenerator<${yieldType}>`;
+        const code = handlerCode(node);
+        lines.push(`${exp}async function* ${name}(${paramList})${retClause} {`);
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`  ${line}`);
+            }
+        }
+        lines.push('}');
+        return lines;
+    }
     const retClause = returns ? `: ${returns}` : '';
     const asyncKw = isAsync ? 'async ' : '';
     const code = handlerCode(node);
+    // Gap 3: signal + cleanup support for async functions
+    const signalNode = firstChild(node, 'signal');
+    const cleanupNode = firstChild(node, 'cleanup');
+    const hasSignal = !!signalNode;
+    const hasCleanup = !!cleanupNode;
     lines.push(`${exp}${asyncKw}function ${name}(${paramList})${retClause} {`);
-    if (code) {
+    // Signal → AbortController setup
+    if (hasSignal) {
+        const signalName = p(signalNode).name || 'abort';
+        lines.push(`  const ${signalName} = new AbortController();`);
+    }
+    // Wrap body in try/finally if cleanup exists
+    if (hasCleanup) {
+        lines.push('  try {');
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push('  } finally {');
+        const cleanupCode = p(cleanupNode).code || '';
+        if (cleanupCode) {
+            const dedented = dedent(cleanupCode);
+            for (const line of dedented.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push('  }');
+    }
+    else if (code) {
         for (const line of code.split('\n')) {
             lines.push(`  ${line}`);
         }
@@ -261,6 +450,52 @@ export function generateMachine(node) {
     }
     return lines;
 }
+// ── Machine → useReducer (Ink target) ────────────────────────────────────
+// Additive: also emit a React useReducer hook wrapping the transition functions.
+// Called by transpiler-ink.ts when target=ink.
+export function generateMachineReducer(node) {
+    const props = p(node);
+    const name = props.name;
+    const exp = exportPrefix(node);
+    const lines = [];
+    // First emit the standard machine output
+    lines.push(...generateMachine(node));
+    // Collect states + transitions
+    const states = kids(node, 'state');
+    const stateNames = states.map(s => {
+        const sp = p(s);
+        return (sp.name || sp.value);
+    });
+    const initialState = states.find(s => p(s).initial === 'true' || p(s).initial === true);
+    const initialName = initialState ? (p(initialState).name || p(initialState).value) : stateNames[0];
+    const transitions = kids(node, 'transition');
+    const stateType = `${name}State`;
+    // Action type union
+    const actionNames = transitions.map(t => p(t).name);
+    lines.push(`${exp}type ${name}Action = ${actionNames.map(a => `'${a}'`).join(' | ')};`);
+    lines.push('');
+    // Reducer function
+    lines.push(`${exp}function ${name.charAt(0).toLowerCase() + name.slice(1)}Reducer(state: ${stateType}, action: ${name}Action): ${stateType} {`);
+    lines.push(`  const entity = { state };`);
+    lines.push(`  switch (action) {`);
+    for (const t of transitions) {
+        const tp = p(t);
+        const tname = tp.name;
+        const fnName = `${tname}${name}`;
+        lines.push(`    case '${tname}': return ${fnName}(entity).state;`);
+    }
+    lines.push(`    default: return state;`);
+    lines.push(`  }`);
+    lines.push('}');
+    lines.push('');
+    // useReducer hook
+    lines.push(`${exp}function use${name}Reducer() {`);
+    lines.push(`  const [state, dispatch] = useReducer(${name.charAt(0).toLowerCase() + name.slice(1)}Reducer, '${initialName}' as ${stateType});`);
+    lines.push(`  return { state, dispatch } as const;`);
+    lines.push('}');
+    lines.push('');
+    return lines;
+}
 // ── Config ───────────────────────────────────────────────────────────────
 // config name=AgonConfig
 //   field name=timeout type=number default=120
@@ -447,6 +682,147 @@ export function generateEvent(node) {
     lines.push(`${exp}type ${name}Callback = (event: ${name}) => void;`);
     return lines;
 }
+// ── On — generic event handler ────────────────────────────────────────────
+// on event=click handler=handleClick
+// on event=submit
+//   handler <<<
+//     e.preventDefault();
+//     await submitForm(data);
+//   >>>
+// on event=key key=Enter
+//   handler <<<
+//     processInput(buffer);
+//   >>>
+// on event=message
+//   handler <<<
+//     const data = JSON.parse(event.data);
+//     dispatch(data);
+//   >>>
+export function generateOn(node) {
+    const props = p(node);
+    const event = (props.event || props.name);
+    const handlerName = props.handler;
+    const key = props.key;
+    const code = handlerCode(node);
+    const exp = exportPrefix(node);
+    const lines = [];
+    if (handlerName && !code) {
+        // Reference to existing handler: on event=click handler=handleClick
+        lines.push(`${exp}const on${capitalize(event)} = ${handlerName};`);
+        return lines;
+    }
+    // Determine event parameter type (plain DOM types — target-agnostic)
+    const paramType = event === 'key' || event === 'keydown' || event === 'keyup' ? 'e: KeyboardEvent'
+        : event === 'message' ? 'event: MessageEvent'
+            : event === 'submit' ? 'e: SubmitEvent'
+                : event === 'click' ? 'e: MouseEvent'
+                    : event === 'change' ? 'e: Event'
+                        : event === 'focus' || event === 'blur' ? 'e: FocusEvent'
+                            : event === 'drag' || event === 'drop' ? 'e: DragEvent'
+                                : event === 'scroll' ? 'e: Event'
+                                    : event === 'resize' ? 'e: UIEvent'
+                                        : event === 'connect' || event === 'disconnect' ? 'ws: WebSocket'
+                                            : event === 'error' ? 'error: Error'
+                                                : `e: Event`;
+    const fnName = handlerName || `handle${capitalize(event)}`;
+    const isAsync = props.async === 'true' || props.async === true;
+    const asyncKw = isAsync ? 'async ' : '';
+    // Key filter guard
+    const keyGuard = key ? `  if (key !== '${key}') return;\n` : '';
+    lines.push(`${exp}${asyncKw}function ${fnName}(${paramType}) {`);
+    if (keyGuard)
+        lines.push(keyGuard.trimEnd());
+    if (code) {
+        for (const line of code.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+// ── WebSocket — bidirectional communication ──────────────────────────────
+// websocket path=/ws
+//   on event=connect
+//     handler <<<ws.send(JSON.stringify({ type: 'hello' }));>>>
+//   on event=message
+//     handler <<<
+//       const data = JSON.parse(event.data);
+//       broadcast(data);
+//     >>>
+//   on event=disconnect
+//     handler <<<console.log('client disconnected');>>>
+export function generateWebSocket(node) {
+    const props = p(node);
+    const path = (props.path || '/ws');
+    const name = props.name || 'ws';
+    const exp = exportPrefix(node);
+    const lines = [];
+    const onNodes = kids(node, 'on');
+    const connectHandler = onNodes.find(n => {
+        const e = (p(n).event || p(n).name);
+        return e === 'connect' || e === 'connection';
+    });
+    const messageHandler = onNodes.find(n => {
+        const e = (p(n).event || p(n).name);
+        return e === 'message';
+    });
+    const disconnectHandler = onNodes.find(n => {
+        const e = (p(n).event || p(n).name);
+        return e === 'disconnect' || e === 'close';
+    });
+    const errorHandler = onNodes.find(n => {
+        const e = (p(n).event || p(n).name);
+        return e === 'error';
+    });
+    lines.push(`${exp}function setup${capitalize(name)}(wss: WebSocketServer) {`);
+    lines.push(`  wss.on('connection', (ws, req) => {`);
+    lines.push(`    const path = req.url || '${path}';`);
+    if (connectHandler) {
+        const code = handlerCode(connectHandler);
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+    }
+    lines.push('');
+    lines.push(`    ws.on('message', (raw) => {`);
+    if (messageHandler) {
+        const code = handlerCode(messageHandler);
+        lines.push(`      const data = JSON.parse(raw.toString());`);
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`      ${line}`);
+            }
+        }
+    }
+    lines.push(`    });`);
+    if (errorHandler) {
+        lines.push('');
+        lines.push(`    ws.on('error', (error) => {`);
+        const code = handlerCode(errorHandler);
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`      ${line}`);
+            }
+        }
+        lines.push(`    });`);
+    }
+    lines.push('');
+    lines.push(`    ws.on('close', () => {`);
+    if (disconnectHandler) {
+        const code = handlerCode(disconnectHandler);
+        if (code) {
+            for (const line of code.split('\n')) {
+                lines.push(`      ${line}`);
+            }
+        }
+    }
+    lines.push(`    });`);
+    lines.push(`  });`);
+    lines.push('}');
+    return lines;
+}
 // ── Module ───────────────────────────────────────────────────────────────
 // module name=@agon/core
 //   export from="./plan.js" names="createPlan,advanceStep"
@@ -462,15 +838,35 @@ export function generateModule(node) {
         const names = ep.names;
         const typeNames = ep.types;
         const star = ep.star === 'true' || ep.star === true;
+        const defaultExport = ep.default;
+        // export * from './foo.js'
         if (from && !names && !typeNames && star) {
             lines.push(`export * from '${from}';`);
         }
+        // export { a, b } from './foo.js'
         if (from && names) {
             lines.push(`export { ${names.split(',').map(s => s.trim()).join(', ')} } from '${from}';`);
         }
+        // export type { A, B } from './types.js'
         if (from && typeNames) {
             lines.push(`export type { ${typeNames.split(',').map(s => s.trim()).join(', ')} } from '${from}';`);
         }
+        // export default foo
+        if (defaultExport && !from) {
+            lines.push(`export default ${defaultExport};`);
+        }
+        // export default from './foo.js' (re-export default)
+        if (defaultExport && from) {
+            lines.push(`export { default as ${defaultExport} } from '${from}';`);
+        }
+        // export { a, b } (no from — local re-export)
+        if (!from && names && !defaultExport) {
+            lines.push(`export { ${names.split(',').map(s => s.trim()).join(', ')} };`);
+        }
+        // export type { A, B } (no from — local type re-export)
+        if (!from && typeNames && !defaultExport) {
+            lines.push(`export type { ${typeNames.split(',').map(s => s.trim()).join(', ')} };`);
+        }
     }
     // Inline child definitions
     for (const child of kids(node)) {
@@ -543,15 +939,72 @@ export function generateConst(node) {
     return [`${exp}const ${name}${typeAnnotation};`];
 }
 // ── Shared Helpers (exported for @kernlang/react) ────────────────────────────
-/** Parse "name:Type,name2:Type2" → "name: Type, name2: Type2" */
+/** Parse "name:Type,name2:Type2,spread:number=8" → "name: Type, name2: Type2, spread: number = 8"
+ *  Supports default values via = after the type. */
 export function parseParamList(params) {
     if (!params)
         return '';
-    return params.split(',').map(s => {
-        const [pname, ...ptype] = s.split(':').map(t => t.trim());
-        return ptype.length > 0 ? `${pname}: ${ptype.join(':')}` : pname;
+    return splitParamsRespectingDepth(params).map(s => {
+        const trimmed = s.trim();
+        // Split name from type:default — find the first ':'
+        const colonIdx = trimmed.indexOf(':');
+        if (colonIdx === -1)
+            return trimmed;
+        const pname = trimmed.slice(0, colonIdx).trim();
+        const rest = trimmed.slice(colonIdx + 1).trim();
+        // Split type from default value — find '=' not inside angle brackets or parens
+        const eqIdx = findDefaultSeparator(rest);
+        if (eqIdx === -1) {
+            return `${pname}: ${rest}`;
+        }
+        const ptype = rest.slice(0, eqIdx).trim();
+        const pdefault = rest.slice(eqIdx + 1).trim();
+        return `${pname}: ${ptype} = ${pdefault}`;
     }).join(', ');
 }
+/** Split param string on commas while respecting <>, (), {} depth.
+ *  Handles => (arrow) without decrementing depth. */
+function splitParamsRespectingDepth(s) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '<' || ch === '(' || ch === '{')
+            depth++;
+        else if ((ch === '>' || ch === ')' || ch === '}') && depth > 0)
+            depth--;
+        if (ch === ',' && depth === 0) {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        parts.push(current);
+    return parts;
+}
+/** Find the index of '=' that separates type from default value,
+ *  skipping '=' inside arrow functions (=>), generics, or parens. */
+function findDefaultSeparator(rest) {
+    let depth = 0;
+    for (let i = 0; i < rest.length; i++) {
+        const ch = rest[i];
+        if (ch === '<' || ch === '(' || ch === '{')
+            depth++;
+        else if (ch === '>' || ch === ')' || ch === '}')
+            depth--;
+        else if (ch === '=' && depth === 0) {
+            // Skip '=>' (arrow function in type)
+            if (rest[i + 1] === '>')
+                continue;
+            return i;
+        }
+    }
+    return -1;
+}
 export function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
@@ -575,7 +1028,7 @@ export function capitalize(s) {
 //     handler <<<
 //       trackSearch(query);
 //     >>>
-//   returns names="products:data?.products,isLoading,handleFilter,cacheKey"
+//   returns names="articles:data?.articles,isLoading,handleFilter,cacheKey"
 export function generateHook(node) {
     const props = p(node);
     const name = props.name;
@@ -706,26 +1159,722 @@ export function generateHook(node) {
     }
     return lines;
 }
+// ── Reason & Confidence Annotations ──────────────────────────────────────
+export function emitReasonAnnotations(node) {
+    const reasonNode = firstChild(node, 'reason');
+    const evidenceNode = firstChild(node, 'evidence');
+    const needsNodes = kids(node, 'needs');
+    const confidence = p(node).confidence;
+    if (!reasonNode && !evidenceNode && !confidence && needsNodes.length === 0)
+        return [];
+    const lines = ['/**'];
+    if (confidence)
+        lines.push(` * @confidence ${confidence}`);
+    if (reasonNode) {
+        const rp = p(reasonNode);
+        lines.push(` * @reason ${rp.because || ''}`);
+        if (rp.basis)
+            lines.push(` * @basis ${rp.basis}`);
+        if (rp.survives)
+            lines.push(` * @survives ${rp.survives}`);
+    }
+    if (evidenceNode) {
+        const ep = p(evidenceNode);
+        const parts = [`source=${ep.source}`];
+        if (ep.method)
+            parts.push(`method=${ep.method}`);
+        if (ep.authority)
+            parts.push(`authority=${ep.authority}`);
+        lines.push(` * @evidence ${parts.join(', ')}`);
+    }
+    for (const needsNode of needsNodes) {
+        const np = p(needsNode);
+        const desc = np.what || np.description || '';
+        const wouldRaise = np['would-raise-to'];
+        const tag = wouldRaise ? `${desc} (would raise to ${wouldRaise})` : desc;
+        lines.push(` * @needs ${tag}`);
+    }
+    lines.push(' */');
+    return lines;
+}
+/** Emit a TODO comment for nodes with low literal confidence (< 0.5). */
+export function emitLowConfidenceTodo(node, confidence) {
+    if (!confidence)
+        return [];
+    const val = parseFloat(confidence);
+    if (isNaN(val) || val >= 0.5 || confidence.includes(':'))
+        return [];
+    const name = p(node).name || node.type;
+    return [`// TODO(low-confidence): ${name} confidence=${confidence}`];
+}
+// ── Ground Layer: derive ─────────────────────────────────────────────────
+// derive name=loudness expr={{average(stems)}} type=number deps="stems"
+// → export const loudness: number = average(stems);
+export function generateDerive(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const expr = props.expr;
+    const constType = props.type;
+    const exp = exportPrefix(node);
+    const typeAnnotation = constType ? `: ${constType}` : '';
+    return [...todo, ...annotations, `${exp}const ${name}${typeAnnotation} = ${expr};`];
+}
+// ── Ground Layer: transform ──────────────────────────────────────────────
+// transform name=limitStems target="track.stems" via="limit(4)" type="Stem[]"
+// → export const limitStems: Stem[] = limit(track.stems, 4);
+export function generateTransform(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const target = props.target;
+    const via = props.via;
+    const constType = props.type;
+    const exp = exportPrefix(node);
+    const code = handlerCode(node);
+    const typeAnnotation = constType ? `: ${constType}` : '';
+    if (code) {
+        // Handler block form — generate a function
+        const lines = [...todo, ...annotations];
+        lines.push(`${exp}function ${name}(state: unknown)${typeAnnotation} {`);
+        for (const line of code.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+        lines.push('}');
+        return lines;
+    }
+    if (target && via) {
+        return [...todo, ...annotations, `${exp}const ${name}${typeAnnotation} = ${via.replace(/\(/, `(${target}, `).replace(/, \)/, ')')};`];
+    }
+    if (via) {
+        return [...todo, ...annotations, `${exp}const ${name}${typeAnnotation} = ${via};`];
+    }
+    return [...todo, ...annotations, `${exp}const ${name}${typeAnnotation};`];
+}
+// ── Ground Layer: action ─────────────────────────────────────────────────
+// action name=notifyOwner idempotent=true reversible=true
+//   handler <<<await email.send(track.owner, 'processed');>>>
+export function generateAction(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const idempotent = props.idempotent === 'true' || props.idempotent === true;
+    const reversible = props.reversible === 'true' || props.reversible === true;
+    const params = props.params || '';
+    const returns = props.returns;
+    const exp = exportPrefix(node);
+    const code = handlerCode(node);
+    const lines = [...todo, ...annotations];
+    // JSDoc for action metadata
+    const metaParts = [];
+    if (idempotent)
+        metaParts.push('idempotent=true');
+    if (reversible)
+        metaParts.push('reversible=true');
+    if (metaParts.length > 0) {
+        lines.push(`/** @action ${metaParts.join(' ')} */`);
+    }
+    const paramList = params ? parseParamList(params) : '';
+    const retClause = returns ? `: Promise<${returns}>` : ': Promise<void>';
+    lines.push(`${exp}async function ${name}(${paramList})${retClause} {`);
+    if (code) {
+        for (const line of code.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: guard (extended — already in NODE_TYPES) ───────────────
+// guard name=published expr={{track.status == "published"}} else=403
+export function generateGuard(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name || 'guard';
+    const expr = props.expr;
+    const elseCode = props.else;
+    const lines = [...todo, ...annotations];
+    if (elseCode && /^\d+$/.test(elseCode)) {
+        lines.push(`if (!(${expr})) { throw new HttpError(${elseCode}, 'Guard: ${name}'); }`);
+    }
+    else if (elseCode) {
+        lines.push(`if (!(${expr})) { ${elseCode}; }`);
+    }
+    else {
+        lines.push(`if (!(${expr})) { throw new Error('Guard failed: ${name}'); }`);
+    }
+    return lines;
+}
+// ── Ground Layer: assume ─────────────────────────────────────────────────
+// assume expr={{track.owner == $auth.user}} scope=request evidence="route-signing" fallback="throw AuthError()"
+export function generateAssume(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const expr = props.expr;
+    const scope = props.scope || 'request';
+    const evidence = props.evidence;
+    const fallback = props.fallback;
+    if (!evidence)
+        throw new KernCodegenError('assume requires evidence prop', node);
+    if (!fallback)
+        throw new KernCodegenError('assume requires fallback prop', node);
+    const lines = [...todo, ...annotations];
+    lines.push(`/** @assume ${expr} @scope ${scope} @evidence ${evidence} */`);
+    lines.push(`if (process.env.NODE_ENV !== 'production') {`);
+    lines.push(`  if (!(${expr})) { ${fallback}; }`);
+    lines.push(`}`);
+    return lines;
+}
+// ── Ground Layer: invariant ──────────────────────────────────────────────
+// invariant name=stemLimit expr={{visible_stems <= policy.max_stems($auth.tier)}}
+export function generateInvariant(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name || 'invariant';
+    const expr = props.expr;
+    const lines = [...todo, ...annotations];
+    lines.push(`console.assert(${expr}, 'Invariant: ${name}');`);
+    return lines;
+}
+// ── Ground Layer: each (ground-layer, not inside parallel) ───────────────
+// each name=stem in="track.stems"
+//   derive name=normalized expr={{normalize(stem.amplitude)}}
+export function generateEach(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name || 'item';
+    const collection = props.in;
+    const index = props.index;
+    const lines = [...todo, ...annotations];
+    if (index) {
+        lines.push(`for (const [${index}, ${name}] of (${collection}).entries()) {`);
+    }
+    else {
+        lines.push(`for (const ${name} of ${collection}) {`);
+    }
+    for (const child of kids(node)) {
+        const childLines = generateCoreNode(child);
+        for (const line of childLines) {
+            lines.push(`  ${line}`);
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: collect ────────────────────────────────────────────────
+// collect name=overThreshold from="track.stems" where={{measure(stem.loudness) > threshold}} limit=10
+export function generateCollect(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const from = props.from;
+    const where = props.where;
+    const limit = props.limit;
+    const order = props.order;
+    const exp = exportPrefix(node);
+    let chain = from;
+    if (where)
+        chain += `.filter(item => ${where})`;
+    if (order)
+        chain += `.sort((a, b) => ${order})`;
+    if (limit)
+        chain += `.slice(0, ${limit})`;
+    return [...todo, ...annotations, `${exp}const ${name} = ${chain};`];
+}
+// ── Ground Layer: branch / path ──────────────────────────────────────────
+// branch name=tierRoute on="user.tier"
+//   path value="free"
+//     derive name=maxStems expr={{4}} type=number
+export function generateBranch(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name || 'branch';
+    const on = props.on;
+    const paths = kids(node, 'path');
+    const lines = [...todo, ...annotations];
+    lines.push(`/** branch: ${name} */`);
+    lines.push(`switch (${on}) {`);
+    for (const pathNode of paths) {
+        const pp = p(pathNode);
+        const value = pp.value;
+        lines.push(`  case '${value}': {`);
+        for (const child of kids(pathNode)) {
+            const childLines = generateCoreNode(child);
+            for (const line of childLines) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push(`    break;`);
+        lines.push(`  }`);
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: resolve / candidate / discriminator ────────────────────
+// resolve name=normStrategy
+//   candidate name=aggressive
+//     handler <<<return aggressiveNormalize(signal);>>>
+//   discriminator method=benchmark metric="snr"
+//     handler <<<...>>>
+export function generateResolve(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const candidates = kids(node, 'candidate');
+    const discriminator = firstChild(node, 'discriminator');
+    if (!discriminator)
+        throw new KernCodegenError('resolve requires discriminator', node);
+    const lines = [...todo, ...annotations];
+    const dp = p(discriminator);
+    const method = dp.method || 'select';
+    const metric = dp.metric || '';
+    // Candidate array
+    lines.push(`/** resolve: ${name} */`);
+    lines.push(`const _${name}_candidates = [`);
+    for (const c of candidates) {
+        const cp = p(c);
+        const cname = cp.name;
+        const code = handlerCode(c);
+        lines.push(`  { name: '${cname}', fn: (signal: unknown) => { ${code.trim()} } },`);
+    }
+    lines.push(`];`);
+    lines.push('');
+    // Resolver function
+    const discCode = handlerCode(discriminator);
+    lines.push(`async function resolve${capitalize(name)}(signal: unknown): Promise<unknown> {`);
+    lines.push(`  const candidates = _${name}_candidates;`);
+    lines.push(`  // discriminator: ${method}(${metric})`);
+    if (discCode) {
+        for (const line of discCode.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+    }
+    lines.push(`  return candidates[winnerIdx].fn(signal);`);
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: expect ─────────────────────────────────────────────────
+// expect name=clipRate expr={{clip_flags_rate}} within="0.02..0.08"
+export function generateExpect(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name || 'expected';
+    const expr = props.expr;
+    const within = props.within;
+    const max = props.max;
+    const min = props.min;
+    const lines = [...todo, ...annotations];
+    lines.push(`if (process.env.NODE_ENV !== 'production') {`);
+    lines.push(`  const _${name} = ${expr};`);
+    if (within) {
+        const [lo, hi] = within.split('..');
+        lines.push(`  console.assert(_${name} >= ${lo} && _${name} <= ${hi}, 'Expected ${name} in [${lo}, ${hi}], got ' + _${name});`);
+    }
+    else if (min && max) {
+        lines.push(`  console.assert(_${name} >= ${min} && _${name} <= ${max}, 'Expected ${name} in [${min}, ${max}], got ' + _${name});`);
+    }
+    else if (max) {
+        lines.push(`  console.assert(_${name} <= ${max}, 'Expected ${name} <= ${max}, got ' + _${name});`);
+    }
+    else if (min) {
+        lines.push(`  console.assert(_${name} >= ${min}, 'Expected ${name} >= ${min}, got ' + _${name});`);
+    }
+    else {
+        lines.push(`  console.assert(_${name} != null, 'Expected ${name} to be defined');`);
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: recover / strategy ─────────────────────────────────────
+// recover name=paymentFlow
+//   strategy name=retry max=3 delay=1000
+//   strategy name=fallback
+//     handler <<<throw new PaymentError('All recovery exhausted');>>>
+export function generateRecover(node) {
+    const annotations = emitReasonAnnotations(node);
+    const conf = p(node).confidence;
+    const todo = emitLowConfidenceTodo(node, conf);
+    const props = p(node);
+    const name = props.name;
+    const strategies = kids(node, 'strategy');
+    const hasFallback = strategies.some(s => p(s).name === 'fallback');
+    if (!hasFallback)
+        throw new KernCodegenError('recover requires a fallback strategy', node);
+    const lines = [...todo, ...annotations];
+    lines.push(`/** recover: ${name} */`);
+    lines.push(`async function ${name}WithRecovery<T>(fn: () => Promise<T>): Promise<T> {`);
+    for (const strategy of strategies) {
+        const sp = p(strategy);
+        const sname = sp.name;
+        const code = handlerCode(strategy);
+        if (sname === 'retry') {
+            const max = Number(sp.max) || 3;
+            const delay = Number(sp.delay) || 1000;
+            lines.push(`  // strategy: retry (max=${max}, delay=${delay}ms)`);
+            lines.push(`  for (let _attempt = 0; _attempt < ${max}; _attempt++) {`);
+            lines.push(`    try { return await fn(); }`);
+            lines.push(`    catch { if (_attempt < ${max - 1}) await new Promise(r => setTimeout(r, ${delay})); }`);
+            lines.push(`  }`);
+        }
+        else if (sname === 'fallback') {
+            lines.push(`  // strategy: fallback (terminal)`);
+            if (code) {
+                for (const line of code.split('\n')) {
+                    lines.push(`  ${line}`);
+                }
+            }
+            else {
+                lines.push(`  throw new Error('All recovery strategies exhausted for ${name}');`);
+            }
+        }
+        else {
+            // compensate, degrade, or custom
+            lines.push(`  // strategy: ${sname}`);
+            lines.push(`  try {`);
+            if (code) {
+                for (const line of code.split('\n')) {
+                    lines.push(`    ${line}`);
+                }
+            }
+            lines.push(`  } catch {}`);
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Ground Layer: pattern / apply ────────────────────────────────────────
+// pattern → registerTemplate() alias (handled by template engine)
+// apply → expandTemplateNode() alias
+export function generatePattern(node) {
+    // pattern nodes are registered as templates — no direct output
+    return [];
+}
+export function generateApply(node) {
+    // apply nodes expand the referenced pattern
+    const props = p(node);
+    const patternName = props.pattern;
+    if (!patternName)
+        return [];
+    // Delegate to template expansion with the pattern name as node type
+    const syntheticNode = { ...node, type: patternName };
+    if (isTemplateNode(patternName)) {
+        return expandTemplateNode(syntheticNode);
+    }
+    return [`// apply: pattern '${patternName}' not found`];
+}
+// ── Conditional ──────────────────────────────────────────────────────────
+// conditional if=isPro
+//   text value="Pro features unlocked"
+// → {isPro && (<>..children..</>)}
+export function generateConditional(node) {
+    const props = p(node);
+    const rawCondition = props.if;
+    // Handle expression objects: { __expr: true, code: 'loading' }
+    const condition = rawCondition && typeof rawCondition === 'object' && rawCondition.__expr
+        ? rawCondition.code
+        : rawCondition;
+    if (!condition)
+        return [`// conditional: missing 'if' prop`];
+    const childLines = [];
+    for (const child of kids(node)) {
+        childLines.push(...generateCoreNode(child));
+    }
+    if (childLines.length === 0) {
+        return [`{${condition} && null}`];
+    }
+    if (childLines.length === 1) {
+        return [`{${condition} && (${childLines[0].trim()})}`];
+    }
+    return [
+        `{${condition} && (`,
+        `  <>`,
+        ...childLines.map(l => `    ${l}`),
+        `  </>`,
+        `)}`,
+    ];
+}
+// ── Select ───────────────────────────────────────────────────────────────
+// select name=status value=current placeholder="Choose"
+//   option value=active label="Active"
+//   option value=pending label="Pending"
+export function generateSelect(node) {
+    const props = p(node);
+    const name = props.name || 'select';
+    const value = props.value;
+    const placeholder = props.placeholder;
+    const onChange = props.onChange;
+    const attrs = [`name="${name}"`];
+    if (value)
+        attrs.push(`value={${value}}`);
+    if (onChange)
+        attrs.push(`onChange={${onChange}}`);
+    // Event handlers like onChange require 'use client' in React/Next.js
+    const lines = onChange ? [`{/* kern:use-client */}`] : [];
+    lines.push(`<select ${attrs.join(' ')}>`);
+    if (placeholder) {
+        lines.push(`  <option value="" disabled>${placeholder}</option>`);
+    }
+    for (const opt of kids(node, 'option')) {
+        const op = p(opt);
+        const optValue = op.value || '';
+        const optLabel = op.label || optValue;
+        lines.push(`  <option value="${optValue}">${optLabel}</option>`);
+    }
+    lines.push(`</select>`);
+    return lines;
+}
+// ── Model ────────────────────────────────────────────────────────────────
+// model name=User table=users
+//   column name=id type=uuid primary=true
+//   column name=email type=string unique=true index=true
+//   relation name=posts target=Post kind=one-to-many cascade=delete
+export function generateModel(node) {
+    const props = p(node);
+    const name = props.name;
+    const table = props.table;
+    const exp = exportPrefix(node);
+    const lines = [];
+    // Generate TypeScript interface
+    lines.push(`${exp}interface ${name} {`);
+    for (const col of kids(node, 'column')) {
+        const cp = p(col);
+        const colName = cp.name;
+        const colType = mapColumnType(cp.type);
+        const opt = cp.optional === 'true' || cp.optional === true ? '?' : '';
+        lines.push(`  ${colName}${opt}: ${colType};`);
+    }
+    for (const rel of kids(node, 'relation')) {
+        const rp = p(rel);
+        const relName = rp.name;
+        const target = rp.target;
+        const kind = rp.kind || 'one-to-many';
+        const relType = kind.includes('many') ? `${target}[]` : target;
+        lines.push(`  ${relName}?: ${relType};`);
+    }
+    lines.push('}');
+    // Prisma-hint comment
+    if (table) {
+        lines.push('');
+        lines.push(`// Prisma: @@map("${table}")`);
+    }
+    return lines;
+}
+function mapColumnType(kernType) {
+    const typeMap = {
+        uuid: 'string', string: 'string', text: 'string',
+        int: 'number', integer: 'number', float: 'number', decimal: 'number',
+        boolean: 'boolean', bool: 'boolean',
+        date: 'Date', datetime: 'Date', timestamp: 'Date',
+        json: 'Record<string, unknown>',
+    };
+    return typeMap[kernType] || kernType;
+}
+// ── Repository ───────────────────────────────────────────────────────────
+// repository name=UserRepo model=User
+//   method name=findByEmail params="email:string" returns="User|null"
+//     handler <<<return this.findOne({ email });>>>
+export function generateRepository(node) {
+    const props = p(node);
+    const name = props.name;
+    const model = props.model;
+    const exp = exportPrefix(node);
+    const lines = [];
+    lines.push(`${exp}class ${name} {`);
+    if (model) {
+        lines.push(`  constructor(private readonly model: typeof ${model}) {}`);
+        lines.push('');
+    }
+    for (const method of kids(node, 'method')) {
+        const mp = p(method);
+        const mname = mp.name;
+        const mparams = mp.params ? parseParamList(mp.params) : '';
+        const isAsync = mp.async === 'true' || mp.async === true;
+        const asyncKw = isAsync ? 'async ' : '';
+        const mreturns = mp.returns ? `: ${mp.returns}` : '';
+        const mcode = handlerCode(method);
+        lines.push(`  ${asyncKw}${mname}(${mparams})${mreturns} {`);
+        if (mcode) {
+            for (const line of mcode.split('\n')) {
+                lines.push(`    ${line}`);
+            }
+        }
+        lines.push('  }');
+        lines.push('');
+    }
+    lines.push('}');
+    return lines;
+}
+// ── Dependency ───────────────────────────────────────────────────────────
+// dependency name=authService scope=singleton
+//   inject name=db from=database
+//   inject name=repo type=UserRepository with=db
+//   returns AuthService with=repo
+export function generateDependency(node) {
+    const props = p(node);
+    const name = props.name;
+    const scope = props.scope || 'transient';
+    const exp = exportPrefix(node);
+    const lines = [];
+    const injects = kids(node, 'inject');
+    const returnsNode = firstChild(node, 'returns');
+    const returnsType = returnsNode ? (p(returnsNode).name || p(returnsNode).type || 'unknown') : 'unknown';
+    if (scope === 'singleton') {
+        lines.push(`let _${name}Instance: ${returnsType} | null = null;`);
+        lines.push('');
+    }
+    lines.push(`${exp}function create${name[0].toUpperCase()}${name.slice(1)}(): ${returnsType} {`);
+    if (scope === 'singleton') {
+        lines.push(`  if (_${name}Instance) return _${name}Instance;`);
+    }
+    for (const inj of injects) {
+        const ip = p(inj);
+        const injName = ip.name;
+        const injType = ip.type;
+        const injFrom = ip.from;
+        const injWith = ip.with;
+        if (injFrom) {
+            lines.push(`  const ${injName} = ${injFrom};`);
+        }
+        else if (injType && injWith) {
+            lines.push(`  const ${injName} = new ${injType}(${injWith});`);
+        }
+        else if (injType) {
+            lines.push(`  const ${injName} = new ${injType}();`);
+        }
+    }
+    const returnsWith = returnsNode ? p(returnsNode).with : undefined;
+    if (returnsWith) {
+        lines.push(`  const instance = new ${returnsType}(${returnsWith});`);
+    }
+    else {
+        lines.push(`  const instance = new ${returnsType}();`);
+    }
+    if (scope === 'singleton') {
+        lines.push(`  _${name}Instance = instance;`);
+    }
+    lines.push(`  return instance;`);
+    lines.push('}');
+    return lines;
+}
+// ── Cache ────────────────────────────────────────────────────────────────
+// cache name=userCache backend=redis prefix="user:" ttl=3600
+//   entry name=profile key="user:{id}"
+//     strategy read-through
+//   invalidate on=userUpdate tags="user:{id}"
+export function generateCache(node) {
+    const props = p(node);
+    const name = props.name;
+    const backend = props.backend || 'memory';
+    const prefix = props.prefix || '';
+    const ttl = props.ttl;
+    const exp = exportPrefix(node);
+    const lines = [];
+    lines.push(`${exp}const ${name} = {`);
+    lines.push(`  prefix: '${prefix}',`);
+    if (ttl)
+        lines.push(`  ttl: ${ttl},`);
+    lines.push(`  backend: '${backend}',`);
+    lines.push('');
+    // Entry methods
+    for (const entry of kids(node, 'entry')) {
+        const ep = p(entry);
+        const entryName = ep.name;
+        const key = ep.key || entryName;
+        const strategyNode = firstChild(entry, 'strategy');
+        const strategy = strategyNode ? (p(strategyNode).name || 'cache-aside') : 'cache-aside';
+        lines.push(`  async get${entryName[0].toUpperCase()}${entryName.slice(1)}(id: string) {`);
+        lines.push(`    const key = \`${prefix}${key.replace(/\{id\}/g, '${id}')}\`;`);
+        if (strategy === 'read-through') {
+            lines.push(`    // read-through: check cache, fetch if miss, populate cache`);
+        }
+        lines.push(`    return ${backend === 'redis' ? `await redis.get(key)` : `cache.get(key)`};`);
+        lines.push(`  },`);
+        lines.push('');
+    }
+    // Invalidation methods
+    for (const inv of kids(node, 'invalidate')) {
+        const ip = p(inv);
+        const on = ip.on || 'update';
+        const tags = ip.tags || '';
+        lines.push(`  async invalidateOn${on[0].toUpperCase()}${on.slice(1)}(id: string) {`);
+        const invalidateKey = tags
+            ? `\`${prefix}${tags.replace(/\{id\}/g, '${id}')}\``
+            : `\`${prefix}\${id}\``;
+        lines.push(`    const key = ${invalidateKey};`);
+        lines.push(`    ${backend === 'redis' ? `await redis.del(key)` : `cache.delete(key)`};`);
+        lines.push(`  },`);
+        lines.push('');
+    }
+    lines.push('} as const;');
+    return lines;
+}
 // ── Dispatcher ───────────────────────────────────────────────────────────
 export const CORE_NODE_TYPES = new Set([
     'type', 'interface', 'field', 'fn',
+    'union', 'variant',
+    'service', 'method', 'singleton', 'constructor',
     'machine', 'transition',
     'error', 'module', 'export',
     'config', 'store',
     'test', 'describe', 'it',
     'event', 'import', 'const',
     'hook',
+    'on', 'websocket',
     'template', 'slot', 'body',
+    // Async extensions
+    'signal', 'cleanup',
+    // Ground layer
+    'derive', 'transform', 'action', 'guard', 'assume', 'invariant',
+    'each', 'collect', 'branch', 'path',
+    'resolve', 'candidate', 'discriminator',
+    'expect', 'recover', 'strategy',
+    'pattern', 'apply',
+    // Reason layer
+    'reason', 'evidence',
+    // Confidence layer
+    'needs',
+    // Backend data layer (graduated nodes)
+    'model', 'column', 'relation',
+    'repository',
+    'dependency', 'inject',
+    'cache', 'entry', 'invalidate',
+    // UI controls (graduated nodes)
+    'conditional',
+    'select', 'option',
 ]);
 /** Check if a node type is a core language construct. */
 export function isCoreNode(type) {
     return CORE_NODE_TYPES.has(type);
 }
 /** Generate TypeScript for any core language node. */
-export function generateCoreNode(node) {
+export function generateCoreNode(node, target) {
     switch (node.type) {
         case 'type': return generateType(node);
         case 'interface': return generateInterface(node);
+        case 'union': return generateUnion(node);
+        case 'service': return generateService(node);
         case 'fn': return generateFunction(node);
         case 'machine': return generateMachine(node);
         case 'error': return generateError(node);
@@ -737,15 +1886,67 @@ export function generateCoreNode(node) {
         case 'import': return generateImport(node);
         case 'const': return generateConst(node);
         case 'hook': return generateHook(node);
-        // Template definitions produce no output
+        case 'on': return generateOn(node);
+        case 'websocket': return generateWebSocket(node);
+        // Ground layer
+        case 'derive': return generateDerive(node);
+        case 'transform': return generateTransform(node);
+        case 'action': return generateAction(node);
+        case 'guard': return generateGuard(node);
+        case 'assume': return generateAssume(node);
+        case 'invariant': return generateInvariant(node);
+        case 'each': return generateEach(node);
+        case 'collect': return generateCollect(node);
+        case 'branch': return generateBranch(node);
+        case 'resolve': return generateResolve(node);
+        case 'expect': return generateExpect(node);
+        case 'recover': return generateRecover(node);
+        case 'pattern': return generatePattern(node);
+        case 'apply': return generateApply(node);
+        // Template / structural definitions produce no output
         case 'template': return [];
         case 'slot': return [];
         case 'body': return [];
-        default:
+        case 'path': return [];
+        case 'candidate': return [];
+        case 'discriminator': return [];
+        case 'strategy': return [];
+        case 'reason': return [];
+        case 'evidence': return [];
+        case 'needs': return [];
+        // Graduated nodes — backend data layer
+        case 'model': return generateModel(node);
+        case 'repository': return generateRepository(node);
+        case 'dependency': return generateDependency(node);
+        case 'cache': return generateCache(node);
+        // Graduated nodes — UI controls
+        case 'conditional': return generateConditional(node);
+        case 'select': return generateSelect(node);
+        // Structural children consumed by parents
+        case 'variant': return [];
+        case 'method': return [];
+        case 'singleton': return [];
+        case 'constructor': return [];
+        case 'signal': return [];
+        case 'cleanup': return [];
+        case 'column': return [];
+        case 'relation': return [];
+        case 'inject': return [];
+        case 'entry': return [];
+        case 'invalidate': return [];
+        case 'option': return [];
+        default: {
+            // Check evolved generators (v4) — target-specific first, then default
+            const targetMap = target ? _evolvedTargetGenerators.get(node.type) : undefined;
+            const targetGen = targetMap && target ? targetMap.get(target) : undefined;
+            const evolvedGen = targetGen || _evolvedGenerators.get(node.type);
+            if (evolvedGen)
+                return evolvedGen(node);
             // Check if this is a template instance
             if (isTemplateNode(node.type))
                 return expandTemplateNode(node);
             return [];
+        }
     }
 }
 //# sourceMappingURL=codegen-core.js.map