@kernlang/core 3.1.2 → 3.1.4

package/dist/codegen-core.js

@@ -8,103 +8,62 @@
  */
 import { isTemplateNode, expandTemplateNode } from './template-engine.js';
 import { KernCodegenError } from './errors.js';
+import { defaultRuntime } from './runtime.js';
+// Re-export emitters and helpers from extracted modules for backward compatibility.
+// All existing `import { emitIdentifier } from './codegen-core.js'` paths continue to work.
+export { emitIdentifier, emitStringLiteral, emitPath, emitTemplateSafe, emitTypeAnnotation, emitImportSpecifier } from './codegen/emitters.js';
+export { getProps, getChildren, getFirstChild, getStyles, getPseudoStyles, getThemeRefs, dedent, cssPropertyName, handlerCode, exportPrefix, capitalize, parseParamList, emitReasonAnnotations, emitLowConfidenceTodo } from './codegen/helpers.js';
+// Import for local use within this file
+import { emitIdentifier, emitStringLiteral, emitPath, emitTemplateSafe, emitTypeAnnotation, emitImportSpecifier } from './codegen/emitters.js';
+import { getProps, getChildren, getFirstChild, dedent, handlerCode, exportPrefix, capitalize, parseParamList, emitReasonAnnotations, emitLowConfidenceTodo } from './codegen/helpers.js';
+// ── Safe Emitters & Helpers ───────────────────────────────────────────────
+// Implementations extracted to codegen/emitters.ts and codegen/helpers.ts.
+// Re-exported above for backward compatibility.
+// (emitter implementations in codegen/emitters.ts)
+// (emitTypeAnnotation, emitImportSpecifier implementations in codegen/emitters.ts)
 // ── 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();
+// Evolved generators now live in defaultRuntime. These functions delegate for backward compatibility.
 /** Register an evolved generator (called at startup). */
 export function registerEvolvedGenerator(keyword, fn) {
-    _evolvedGenerators.set(keyword, fn);
+    defaultRuntime.registerEvolvedGenerator(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);
+    defaultRuntime.registerEvolvedTargetGenerator(keyword, target, fn);
 }
 /** Unregister an evolved generator (for rollback/testing). */
 export function unregisterEvolvedGenerator(keyword) {
-    _evolvedGenerators.delete(keyword);
-    _evolvedTargetGenerators.delete(keyword);
+    defaultRuntime.unregisterEvolvedGenerator(keyword);
 }
 /** Clear all evolved generators (for test isolation). */
 export function clearEvolvedGenerators() {
-    _evolvedGenerators.clear();
-    _evolvedTargetGenerators.clear();
+    defaultRuntime.clearEvolvedGenerators();
 }
 /** Check if an evolved generator exists for a type. */
 export function hasEvolvedGenerator(type) {
-    return _evolvedGenerators.has(type);
+    return defaultRuntime.hasEvolvedGenerator(type);
 }
 // ── Shared IR node helpers ───────────────────────────────────────────────
-// These are used by every transpiler. Exported for reuse.
-/** Extract props from an IR node. */
-export function getProps(node) {
-    return node.props || {};
-}
-/** Get children, optionally filtered by type. */
-export function getChildren(node, type) {
-    const c = node.children || [];
-    return type ? c.filter(n => n.type === type) : c;
-}
-/** Get first child of a given type. */
-export function getFirstChild(node, type) {
-    return getChildren(node, type)[0];
-}
-/** Extract styles from node props. */
-export function getStyles(node) {
-    return getProps(node).styles || {};
-}
-/** Extract pseudo-styles from node props. */
-export function getPseudoStyles(node) {
-    return getProps(node).pseudoStyles || {};
-}
-/** Extract theme refs from node props. */
-export function getThemeRefs(node) {
-    return getProps(node).themeRefs || [];
-}
-/** Strip common leading whitespace from multiline handler code. */
-export function dedent(code) {
-    const lines = code.split('\n');
-    const nonEmpty = lines.filter(l => l.trim().length > 0);
-    if (nonEmpty.length === 0)
-        return code;
-    const min = Math.min(...nonEmpty.map(l => l.match(/^(\s*)/)?.[1].length ?? 0));
-    return lines.map(l => l.slice(min)).join('\n');
-}
-/** Convert camelCase to kebab-case for CSS property names. */
-export function cssPropertyName(camel) {
-    return camel.replace(/([A-Z])/g, '-$1').toLowerCase();
-}
-/** Extract handler code from a node (finds handler child, dedents). */
-export function handlerCode(node) {
-    const handler = getFirstChild(node, 'handler');
-    if (!handler)
-        return '';
-    const raw = getProps(handler).code || '';
-    return dedent(raw);
-}
-// Internal aliases for backward compat within this file
+// Implementations extracted to codegen/helpers.ts. Re-exported above.
+// Internal aliases for local use within this file
 const p = getProps;
 const kids = getChildren;
 const firstChild = getFirstChild;
-export function exportPrefix(node) {
-    return p(node).export === 'false' ? '' : 'export ';
-}
 // ── Type Alias ───────────────────────────────────────────────────────────
 // type name=PlanState values="draft|approved|running|paused|completed|failed|cancelled"
 // → export type PlanState = 'draft' | 'approved' | 'running' | ...;
 export function generateType(node) {
-    const { name, values, alias } = p(node);
+    const { name: rawName, values, alias } = p(node);
+    const name = emitIdentifier(rawName, 'UnknownType', node);
     const exp = exportPrefix(node);
     if (values) {
-        const members = values.split('|').map(v => `'${v.trim()}'`).join(' | ');
+        const members = values.split('|').map(v => `'${emitTemplateSafe(v.trim())}'`).join(' | ');
         return [`${exp}type ${name} = ${members};`];
     }
     if (alias) {
-        return [`${exp}type ${name} = ${alias};`];
+        return [`${exp}type ${name} = ${emitTypeAnnotation(alias, 'unknown', node)};`];
     }
     return [`${exp}type ${name} = unknown;`];
 }
@@ -116,15 +75,16 @@ export function generateType(node) {
 //   field name=engineId type=string optional=true
 export function generateInterface(node) {
     const props = p(node);
-    const name = props.name;
-    const ext = props.extends ? ` extends ${props.extends}` : '';
+    const name = emitIdentifier(props.name, 'UnknownInterface', node);
+    const ext = props.extends ? ` extends ${emitTypeAnnotation(props.extends, 'unknown', node)}` : '';
     const exp = exportPrefix(node);
     const lines = [];
     lines.push(`${exp}interface ${name}${ext} {`);
     for (const field of kids(node, 'field')) {
         const fp = p(field);
+        const fieldName = emitIdentifier(fp.name, 'field', field);
         const opt = fp.optional === 'true' || fp.optional === true ? '?' : '';
-        lines.push(`  ${fp.name}${opt}: ${fp.type};`);
+        lines.push(`  ${fieldName}${opt}: ${emitTypeAnnotation(fp.type, 'unknown', field)};`);
     }
     lines.push('}');
     return lines;
@@ -141,8 +101,8 @@ export function generateInterface(node) {
 //   | { type: 'code'; language: string; code: string };
 export function generateUnion(node) {
     const props = p(node);
-    const name = props.name;
-    const discriminant = props.discriminant || 'type';
+    const name = emitIdentifier(props.name, 'UnknownUnion', node);
+    const discriminant = emitIdentifier(props.discriminant, 'type', node);
     const exp = exportPrefix(node);
     const variants = kids(node, 'variant');
     if (variants.length === 0) {
@@ -151,13 +111,13 @@ export function generateUnion(node) {
     const lines = [`${exp}type ${name} =`];
     for (let i = 0; i < variants.length; i++) {
         const vp = p(variants[i]);
-        const vname = vp.name;
+        const vname = emitIdentifier(vp.name, 'variant', variants[i]);
         const fields = kids(variants[i], 'field');
-        const fieldParts = [`${discriminant}: '${vname}'`];
+        const fieldParts = [`${discriminant}: '${emitTemplateSafe(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}`);
+            fieldParts.push(`${emitIdentifier(fp.name, 'field', field)}${opt}: ${emitTypeAnnotation(fp.type, 'unknown', field)}`);
         }
         const semi = i === variants.length - 1 ? ';' : '';
         lines.push(`  | { ${fieldParts.join('; ')} }${semi}`);
@@ -180,21 +140,23 @@ export function generateUnion(node) {
 // → export const tracker = new TokenTracker();
 export function generateService(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownService', node);
     const impl = props.implements;
     const exp = exportPrefix(node);
     const lines = [];
-    const implClause = impl ? ` implements ${impl}` : '';
+    const implClause = impl ? ` implements ${emitTypeAnnotation(impl, 'unknown', node)}` : '';
     lines.push(`${exp}class ${name}${implClause} {`);
     // Fields
     for (const field of kids(node, 'field')) {
         const fp = p(field);
+        const fieldName = emitIdentifier(fp.name, 'field', 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 typeAnnotation = fp.type ? `: ${emitTypeAnnotation(fp.type, 'unknown', field)}` : '';
         const defaultVal = fp.default;
+        // default values are by-design raw code (escape hatch) — documented, not sanitized
         const init = defaultVal !== undefined ? ` = ${defaultVal}` : '';
-        lines.push(`  ${vis}${readonly}${fp.name}${typeAnnotation}${init};`);
+        lines.push(`  ${vis}${readonly}${fieldName}${typeAnnotation}${init};`);
     }
     // Constructor (if any constructor child exists)
     const ctorNode = firstChild(node, 'constructor');
@@ -214,7 +176,7 @@ export function generateService(node) {
     // Methods
     for (const method of kids(node, 'method')) {
         const mp = p(method);
-        const mname = mp.name;
+        const mname = emitIdentifier(mp.name, 'method', method);
         const mparams = mp.params ? parseParamList(mp.params) : '';
         const isAsync = mp.async === 'true' || mp.async === true;
         const isStream = mp.stream === 'true' || mp.stream === true;
@@ -226,8 +188,8 @@ export function generateService(node) {
         const mcode = handlerCode(method);
         // stream=true → AsyncGenerator return type
         const mreturns = isStream
-            ? `: AsyncGenerator<${mp.returns || 'unknown'}>`
-            : mp.returns ? `: ${mp.returns}` : '';
+            ? `: AsyncGenerator<${emitTypeAnnotation(mp.returns, 'unknown', method)}>`
+            : mp.returns ? `: ${emitTypeAnnotation(mp.returns, 'unknown', method)}` : '';
         lines.push('');
         lines.push(`  ${vis}${staticKw}${asyncKw}${star}${mname}(${mparams})${mreturns} {`);
         if (mcode) {
@@ -241,8 +203,8 @@ export function generateService(node) {
     // Singleton instances
     for (const singleton of kids(node, 'singleton')) {
         const sp = p(singleton);
-        const sname = sp.name;
-        const stype = sp.type || name;
+        const sname = emitIdentifier(sp.name, 'instance', singleton);
+        const stype = emitIdentifier(sp.type, name, singleton);
         lines.push('');
         lines.push(`${exp}const ${sname} = new ${stype}();`);
     }
@@ -255,7 +217,7 @@ export function generateService(node) {
 //   >>>
 export function generateFunction(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'unknownFn', node);
     const params = props.params || '';
     const returns = props.returns;
     const isAsync = props.async === 'true' || props.async === true;
@@ -267,7 +229,7 @@ export function generateFunction(node) {
     const paramList = params ? parseParamList(params) : '';
     // stream=true → async generator function
     if (isStream) {
-        const yieldType = returns || 'unknown';
+        const yieldType = emitTypeAnnotation(returns, 'unknown', node);
         const retClause = `: AsyncGenerator<${yieldType}>`;
         const code = handlerCode(node);
         lines.push(`${exp}async function* ${name}(${paramList})${retClause} {`);
@@ -279,7 +241,7 @@ export function generateFunction(node) {
         lines.push('}');
         return lines;
     }
-    const retClause = returns ? `: ${returns}` : '';
+    const retClause = returns ? `: ${emitTypeAnnotation(returns, 'unknown', node)}` : '';
     const asyncKw = isAsync ? 'async ' : '';
     const code = handlerCode(node);
     // Gap 3: signal + cleanup support for async functions
@@ -290,7 +252,7 @@ export function generateFunction(node) {
     lines.push(`${exp}${asyncKw}function ${name}(${paramList})${retClause} {`);
     // Signal → AbortController setup
     if (hasSignal) {
-        const signalName = p(signalNode).name || 'abort';
+        const signalName = emitIdentifier(p(signalNode).name, 'abort', signalNode);
         lines.push(`  const ${signalName} = new AbortController();`);
     }
     // Wrap body in try/finally if cleanup exists
@@ -327,8 +289,8 @@ export function generateFunction(node) {
 //   message "Invalid plan state: expected ${expected}, got ${actual}"
 export function generateError(node) {
     const props = p(node);
-    const name = props.name;
-    const ext = props.extends || 'Error';
+    const name = emitIdentifier(props.name, 'UnknownError', node);
+    const ext = emitIdentifier(props.extends, 'Error', node);
     const message = props.message;
     const exp = exportPrefix(node);
     const fields = kids(node, 'field');
@@ -344,11 +306,13 @@ export function generateError(node) {
             const opt = fp.optional === 'true' || fp.optional === true ? '?' : '';
             const isMessage = fp.name === 'message';
             // 'message' param is not readonly — it's passed to super
+            const fName = emitIdentifier(fp.name, 'field', field);
+            const fType = emitTypeAnnotation(fp.type, 'unknown', field);
             if (isMessage) {
-                lines.push(`    ${fp.name}${opt}: ${fp.type},`);
+                lines.push(`    ${fName}${opt}: ${fType},`);
             }
             else {
-                lines.push(`    public readonly ${fp.name}${opt}: ${fp.type},`);
+                lines.push(`    public readonly ${fName}${opt}: ${fType},`);
             }
         }
         lines.push(`  ) {`);
@@ -412,18 +376,18 @@ export function generateError(node) {
 //   - approvePlan(), startPlan(), cancelPlan(), failPlan() functions
 export function generateMachine(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownMachine', node);
     const exp = exportPrefix(node);
     const lines = [];
     // Collect states
     const states = kids(node, 'state');
     const stateNames = states.map(s => {
         const sp = p(s);
-        return (sp.name || sp.value);
+        return emitIdentifier((sp.name || sp.value), 'state', s);
     });
     // State type
     const stateType = `${name}State`;
-    lines.push(`${exp}type ${stateType} = ${stateNames.map(s => `'${s}'`).join(' | ')};`);
+    lines.push(`${exp}type ${stateType} = ${stateNames.map(s => `'${emitTemplateSafe(s)}'`).join(' | ')};`);
     lines.push('');
     // Error class
     const errorName = `${name}StateError`;
@@ -442,7 +406,7 @@ export function generateMachine(node) {
     const transitions = kids(node, 'transition');
     for (const t of transitions) {
         const tp = p(t);
-        const tname = tp.name;
+        const tname = emitIdentifier(tp.name, 'transition', t);
         const from = tp.from;
         const to = tp.to;
         const fromStates = from.split('|').map(s => s.trim());
@@ -480,7 +444,7 @@ export function generateMachine(node) {
 // Called by transpiler-ink.ts when target=ink.
 export function generateMachineReducer(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownMachine', node);
     const exp = exportPrefix(node);
     const lines = [];
     // First emit the standard machine output
@@ -496,7 +460,7 @@ export function generateMachineReducer(node) {
     const transitions = kids(node, 'transition');
     const stateType = `${name}State`;
     // Action type union
-    const actionNames = transitions.map(t => p(t).name);
+    const actionNames = transitions.map(t => emitIdentifier(p(t).name, 'action', t));
     lines.push(`${exp}type ${name}Action = ${actionNames.map(a => `'${a}'`).join(' | ')};`);
     lines.push('');
     // Reducer function
@@ -505,9 +469,9 @@ export function generateMachineReducer(node) {
     lines.push(`  switch (action) {`);
     for (const t of transitions) {
         const tp = p(t);
-        const tname = tp.name;
+        const tname = emitIdentifier(tp.name, 'action', t);
         const fnName = `${tname}${name}`;
-        lines.push(`    case '${tname}': return ${fnName}(entity).state;`);
+        lines.push(`    case '${emitTemplateSafe(tname)}': return ${fnName}(entity).state;`);
     }
     lines.push(`    default: return state;`);
     lines.push(`  }`);
@@ -527,7 +491,7 @@ export function generateMachineReducer(node) {
 //   field name=approvalLevel type=ApprovalLevel default="plan"
 export function generateConfig(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'Config', node);
     const exp = exportPrefix(node);
     const fields = kids(node, 'field');
     const lines = [];
@@ -535,8 +499,9 @@ export function generateConfig(node) {
     lines.push(`${exp}interface ${name} {`);
     for (const field of fields) {
         const fp = p(field);
+        const fieldName = emitIdentifier(fp.name, 'field', field);
         const opt = fp.default !== undefined ? '?' : '';
-        lines.push(`  ${fp.name}${opt}: ${fp.type};`);
+        lines.push(`  ${fieldName}${opt}: ${emitTypeAnnotation(fp.type, 'unknown', field)};`);
     }
     lines.push('}');
     lines.push('');
@@ -544,7 +509,8 @@ export function generateConfig(node) {
     lines.push(`${exp}const DEFAULT_${name.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase()}: Required<${name}> = {`);
     for (const field of fields) {
         const fp = p(field);
-        const ftype = fp.type;
+        const fieldName = emitIdentifier(fp.name, 'field', field);
+        const ftype = emitTypeAnnotation(fp.type, 'unknown', field);
         let def = fp.default;
         if (def === undefined) {
             if (ftype === 'number')
@@ -557,9 +523,9 @@ export function generateConfig(node) {
                 def = "''";
         }
         else if (ftype === 'string' || (!['number', 'boolean'].includes(ftype) && !ftype.endsWith('[]') && !def.startsWith("'") && !def.startsWith('"'))) {
-            def = `'${def}'`;
+            def = emitStringLiteral(def);
         }
-        lines.push(`  ${fp.name}: ${def},`);
+        lines.push(`  ${fieldName}: ${def},`);
     }
     lines.push('};');
     return lines;
@@ -569,16 +535,17 @@ export function generateConfig(node) {
 //   model Plan
 export function generateStore(node) {
     const props = p(node);
-    const name = props.name;
-    const storePath = props.path || '~/.data';
-    const key = props.key || 'id';
-    const model = props.model || 'unknown';
+    const name = emitIdentifier(props.name, 'Store', node);
+    const rawPath = props.path || '~/.data';
+    const key = emitIdentifier(props.key, 'id', node);
+    const model = emitIdentifier(props.model, 'unknown', node);
     const exp = exportPrefix(node);
     const lines = [];
     const dirConst = `${name.toUpperCase()}_DIR`;
-    const resolvedPath = storePath.startsWith('~/')
-        ? `join(homedir(), '${storePath.slice(2)}')`
-        : `'${storePath}'`;
+    // Validate path before interpolation — blocks injection + traversal via storePath
+    const resolvedPath = rawPath.startsWith('~/')
+        ? `join(homedir(), ${emitPath(rawPath.slice(2), node)})`
+        : emitPath(rawPath, node);
     lines.push(`import { readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';`);
     lines.push(`import { join, resolve } from 'node:path';`);
     lines.push(`import { homedir } from 'node:os';`);
@@ -591,6 +558,7 @@ export function generateStore(node) {
     lines.push('');
     lines.push(`function safe${name}Path(id: string): string {`);
     lines.push(`  const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, '');`);
+    lines.push(`  if (!sanitized) throw new Error(\`Invalid ID: \${id}\`);`);
     lines.push(`  const full = resolve(${dirConst}, \`\${sanitized}.json\`);`);
     lines.push(`  if (!full.startsWith(resolve(${dirConst}))) throw new Error(\`Invalid ID: \${id}\`);`);
     lines.push(`  return full;`);
@@ -603,17 +571,18 @@ export function generateStore(node) {
     lines.push('');
     lines.push(`${exp}function load${name}(id: string): ${model} | null {`);
     lines.push(`  try { return JSON.parse(readFileSync(safe${name}Path(id), 'utf-8')) as ${model}; }`);
-    lines.push(`  catch { return null; }`);
+    lines.push(`  catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null; throw e; }`);
     lines.push('}');
     lines.push('');
     lines.push(`${exp}function list${name}s(limit = 20): ${model}[] {`);
     lines.push(`  ensure${name}Dir();`);
-    lines.push(`  try {`);
-    lines.push(`    return readdirSync(${dirConst}).filter(f => f.endsWith('.json'))`);
-    lines.push(`      .map(f => JSON.parse(readFileSync(join(${dirConst}, f), 'utf-8')) as ${model})`);
-    lines.push(`      .sort((a: any, b: any) => (b.updatedAt || '').localeCompare(a.updatedAt || ''))`);
-    lines.push(`      .slice(0, limit);`);
-    lines.push(`  } catch { return []; }`);
+    lines.push(`  const files = readdirSync(${dirConst}).filter(f => f.endsWith('.json'));`);
+    lines.push(`  const items: ${model}[] = [];`);
+    lines.push(`  for (const f of files) {`);
+    lines.push(`    try { items.push(JSON.parse(readFileSync(join(${dirConst}, f), 'utf-8')) as ${model}); }`);
+    lines.push(`    catch { /* skip corrupt files */ }`);
+    lines.push(`  }`);
+    lines.push(`  return items.sort((a: any, b: any) => (b.updatedAt || '').localeCompare(a.updatedAt || '')).slice(0, limit);`);
     lines.push('}');
     lines.push('');
     lines.push(`${exp}function delete${name}(id: string): boolean {`);
@@ -631,7 +600,7 @@ export function generateStore(node) {
 //       >>>
 export function generateTest(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitTemplateSafe(props.name || 'UnknownTest');
     const lines = [];
     lines.push(`import { describe, it, expect } from 'vitest';`);
     lines.push('');
@@ -644,10 +613,10 @@ export function generateTest(node) {
     }
     lines.push(`describe('${name}', () => {`);
     for (const desc of kids(node, 'describe')) {
-        const dname = p(desc).name;
+        const dname = emitTemplateSafe(p(desc).name || 'describe');
         lines.push(`  describe('${dname}', () => {`);
         for (const test of kids(desc, 'it')) {
-            const tname = p(test).name;
+            const tname = emitTemplateSafe(p(test).name || 'test');
             const code = handlerCode(test);
             lines.push(`    it('${tname}', () => {`);
             if (code) {
@@ -660,7 +629,7 @@ export function generateTest(node) {
     }
     // Top-level it blocks
     for (const test of kids(node, 'it')) {
-        const tname = p(test).name;
+        const tname = emitTemplateSafe(p(test).name || 'test');
         const code = handlerCode(test);
         lines.push(`  it('${tname}', () => {`);
         if (code) {
@@ -679,12 +648,12 @@ export function generateTest(node) {
 //   type name="winner:determined" data="{ winner: string, bestScore: number }"
 export function generateEvent(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownEvent', node);
     const exp = exportPrefix(node);
     const types = kids(node, 'type');
     const lines = [];
     // Event type union
-    lines.push(`${exp}type ${name}Type = ${types.map(t => `'${(p(t).name || p(t).value)}'`).join(' | ')};`);
+    lines.push(`${exp}type ${name}Type = ${types.map(t => `'${emitTemplateSafe((p(t).name || p(t).value))}'`).join(' | ')};`);
     lines.push('');
     // Event interface
     lines.push(`${exp}interface ${name} {`);
@@ -697,8 +666,8 @@ export function generateEvent(node) {
     lines.push(`${exp}interface ${name}Map {`);
     for (const t of types) {
         const tp = p(t);
-        const tname = (tp.name || tp.value);
-        const data = tp.data || 'Record<string, unknown>';
+        const tname = emitTemplateSafe((tp.name || tp.value));
+        const data = emitTypeAnnotation(tp.data, 'Record<string, unknown>', t);
         lines.push(`  '${tname}': ${data};`);
     }
     lines.push('}');
@@ -853,44 +822,47 @@ export function generateWebSocket(node) {
 //   export from="./plan.js" names="createPlan,advanceStep"
 export function generateModule(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitTemplateSafe(props.name || 'unknown');
     const lines = [];
     lines.push(`// ── Module: ${name} ──`);
     lines.push('');
     for (const exp of kids(node, 'export')) {
         const ep = p(exp);
-        const from = ep.from;
-        const names = ep.names;
-        const typeNames = ep.types;
+        const rawFrom = ep.from;
+        const safeFrom = rawFrom ? emitImportSpecifier(rawFrom, exp) : '';
+        const rawNames = ep.names;
+        const safeNames = rawNames ? rawNames.split(',').map(s => emitIdentifier(s.trim(), 'export', exp)).join(', ') : '';
+        const rawTypeNames = ep.types;
+        const safeTypeNames = rawTypeNames ? rawTypeNames.split(',').map(s => emitIdentifier(s.trim(), 'export', exp)).join(', ') : '';
         const star = ep.star === 'true' || ep.star === true;
-        const defaultExport = ep.default;
+        const safeDefault = ep.default ? emitIdentifier(ep.default, 'default', exp) : '';
         // export * from './foo.js'
-        if (from && !names && !typeNames && star) {
-            lines.push(`export * from '${from}';`);
+        if (safeFrom && !safeNames && !safeTypeNames && star) {
+            lines.push(`export * from '${safeFrom}';`);
         }
         // export { a, b } from './foo.js'
-        if (from && names) {
-            lines.push(`export { ${names.split(',').map(s => s.trim()).join(', ')} } from '${from}';`);
+        if (safeFrom && safeNames) {
+            lines.push(`export { ${safeNames} } from '${safeFrom}';`);
         }
         // export type { A, B } from './types.js'
-        if (from && typeNames) {
-            lines.push(`export type { ${typeNames.split(',').map(s => s.trim()).join(', ')} } from '${from}';`);
+        if (safeFrom && safeTypeNames) {
+            lines.push(`export type { ${safeTypeNames} } from '${safeFrom}';`);
         }
         // export default foo
-        if (defaultExport && !from) {
-            lines.push(`export default ${defaultExport};`);
+        if (safeDefault && !safeFrom) {
+            lines.push(`export default ${safeDefault};`);
         }
         // export default from './foo.js' (re-export default)
-        if (defaultExport && from) {
-            lines.push(`export { default as ${defaultExport} } from '${from}';`);
+        if (safeDefault && safeFrom) {
+            lines.push(`export { default as ${safeDefault} } from '${safeFrom}';`);
         }
         // export { a, b } (no from — local re-export)
-        if (!from && names && !defaultExport) {
-            lines.push(`export { ${names.split(',').map(s => s.trim()).join(', ')} };`);
+        if (!safeFrom && safeNames && !safeDefault) {
+            lines.push(`export { ${safeNames} };`);
         }
         // 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(', ')} };`);
+        if (!safeFrom && safeTypeNames && !safeDefault) {
+            lines.push(`export type { ${safeTypeNames} };`);
         }
     }
     // Inline child definitions
@@ -922,21 +894,23 @@ export function generateImport(node) {
     const isTypeOnly = props.types === 'true' || props.types === true;
     if (!from)
         return [];
+    const safePath = emitImportSpecifier(from, node);
     const typeKw = isTypeOnly ? 'type ' : '';
+    const safeDefault = defaultImport ? emitIdentifier(defaultImport, 'default', node) : '';
     const namedList = names
-        ? names.split(',').map(s => s.trim()).join(', ')
+        ? names.split(',').map(s => emitIdentifier(s.trim(), 'import', node)).join(', ')
         : '';
-    if (defaultImport && namedList) {
-        return [`import ${typeKw}${defaultImport}, { ${namedList} } from '${from}';`];
+    if (safeDefault && namedList) {
+        return [`import ${typeKw}${safeDefault}, { ${namedList} } from '${safePath}';`];
     }
-    if (defaultImport) {
-        return [`import ${typeKw}${defaultImport} from '${from}';`];
+    if (safeDefault) {
+        return [`import ${typeKw}${safeDefault} from '${safePath}';`];
     }
     if (namedList) {
-        return [`import ${typeKw}{ ${namedList} } from '${from}';`];
+        return [`import ${typeKw}{ ${namedList} } from '${safePath}';`];
     }
     // Side-effect import
-    return [`import '${from}';`];
+    return [`import '${safePath}';`];
 }
 // ── Const ───────────────────────────────────────────────────────────────
 // const name=AGON_HOME type=string
@@ -949,12 +923,12 @@ export function generateImport(node) {
 // → export const DEFAULT_WEIGHTS: ScoreWeights = { pass: 50 };
 export function generateConst(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'unknownConst', node);
     const constType = props.type;
     const value = props.value;
     const exp = exportPrefix(node);
     const code = handlerCode(node);
-    const typeAnnotation = constType ? `: ${constType}` : '';
+    const typeAnnotation = constType ? `: ${emitTypeAnnotation(constType, 'unknown', node)}` : '';
     if (code) {
         return [`${exp}const ${name}${typeAnnotation} = ${code.trim()};`];
     }
@@ -963,125 +937,9 @@ export function generateConst(node) {
     }
     return [`${exp}const ${name}${typeAnnotation};`];
 }
-// ── Shared Helpers (exported for @kernlang/react) ────────────────────────────
-/** 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 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);
-}
-// Hook codegen moved to @kernlang/react (generateHook in codegen-react.ts)
-// ── 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}`];
-}
+// ── Shared Helpers ───────────────────────────────────────────────────────
+// parseParamList, capitalize, emitReasonAnnotations, emitLowConfidenceTodo
+// implementations extracted to codegen/helpers.ts. Re-exported at top of file.
 // ── Ground Layer: derive ─────────────────────────────────────────────────
 // derive name=loudness expr={{average(stems)}} type=number deps="stems"
 // → export const loudness: number = average(stems);
@@ -1090,11 +948,12 @@ export function generateDerive(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'derived', node);
+    // expr is by-design raw code (escape hatch)
     const expr = props.expr;
     const constType = props.type;
     const exp = exportPrefix(node);
-    const typeAnnotation = constType ? `: ${constType}` : '';
+    const typeAnnotation = constType ? `: ${emitTypeAnnotation(constType, 'unknown', node)}` : '';
     return [...todo, ...annotations, `${exp}const ${name}${typeAnnotation} = ${expr};`];
 }
 // ── Ground Layer: transform ──────────────────────────────────────────────
@@ -1105,13 +964,14 @@ export function generateTransform(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'transform', node);
+    // target and via are by-design raw code (escape hatches)
     const target = props.target;
     const via = props.via;
     const constType = props.type;
     const exp = exportPrefix(node);
     const code = handlerCode(node);
-    const typeAnnotation = constType ? `: ${constType}` : '';
+    const typeAnnotation = constType ? `: ${emitTypeAnnotation(constType, 'unknown', node)}` : '';
     if (code) {
         // Handler block form — generate a function
         const lines = [...todo, ...annotations];
@@ -1138,7 +998,7 @@ export function generateAction(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'action', node);
     const idempotent = props.idempotent === 'true' || props.idempotent === true;
     const reversible = props.reversible === 'true' || props.reversible === true;
     const params = props.params || '';
@@ -1156,7 +1016,7 @@ export function generateAction(node) {
         lines.push(`/** @action ${metaParts.join(' ')} */`);
     }
     const paramList = params ? parseParamList(params) : '';
-    const retClause = returns ? `: Promise<${returns}>` : ': Promise<void>';
+    const retClause = returns ? `: Promise<${emitTypeAnnotation(returns, 'void', node)}>` : ': Promise<void>';
     lines.push(`${exp}async function ${name}(${paramList})${retClause} {`);
     if (code) {
         for (const line of code.split('\n')) {
@@ -1257,7 +1117,7 @@ export function generateCollect(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'collected', node);
     const from = props.from;
     const where = props.where;
     const limit = props.limit;
@@ -1314,7 +1174,7 @@ export function generateResolve(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'resolver', node);
     const candidates = kids(node, 'candidate');
     const discriminator = firstChild(node, 'discriminator');
     if (!discriminator)
@@ -1328,7 +1188,7 @@ export function generateResolve(node) {
     lines.push(`const _${name}_candidates = [`);
     for (const c of candidates) {
         const cp = p(c);
-        const cname = cp.name;
+        const cname = emitIdentifier(cp.name, 'candidate', c);
         const code = handlerCode(c);
         lines.push(`  { name: '${cname}', fn: (signal: unknown) => { ${code.trim()} } },`);
     }
@@ -1392,7 +1252,7 @@ export function generateRecover(node) {
     const conf = p(node).confidence;
     const todo = emitLowConfidenceTodo(node, conf);
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'recovery', node);
     const strategies = kids(node, 'strategy');
     const hasFallback = strategies.some(s => p(s).name === 'fallback');
     if (!hasFallback)
@@ -1402,7 +1262,7 @@ export function generateRecover(node) {
     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 sname = emitIdentifier(sp.name, 'strategy', strategy);
         const code = handlerCode(strategy);
         if (sname === 'retry') {
             const max = Number(sp.max) || 3;
@@ -1446,16 +1306,16 @@ export function generatePattern(node) {
     // pattern nodes are registered as templates — no direct output
     return [];
 }
-export function generateApply(node) {
+export function generateApply(node, _depth = 0) {
     // 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
+    // Delegate to template expansion — propagate depth to prevent infinite recursion
     const syntheticNode = { ...node, type: patternName };
     if (isTemplateNode(patternName)) {
-        return expandTemplateNode(syntheticNode);
+        return expandTemplateNode(syntheticNode, _depth + 1);
     }
     return [`// apply: pattern '${patternName}' not found`];
 }
@@ -1509,12 +1369,12 @@ export function generateSelect(node) {
     const lines = onChange ? [`{/* kern:use-client */}`] : [];
     lines.push(`<select ${attrs.join(' ')}>`);
     if (placeholder) {
-        lines.push(`  <option value="" disabled>${placeholder}</option>`);
+        lines.push(`  <option value="" disabled>${emitTemplateSafe(placeholder)}</option>`);
     }
     for (const opt of kids(node, 'option')) {
         const op = p(opt);
-        const optValue = op.value || '';
-        const optLabel = op.label || optValue;
+        const optValue = emitTemplateSafe(op.value || '');
+        const optLabel = emitTemplateSafe(op.label || op.value || '');
         lines.push(`  <option value="${optValue}">${optLabel}</option>`);
     }
     lines.push(`</select>`);
@@ -1527,7 +1387,7 @@ export function generateSelect(node) {
 //   relation name=posts target=Post kind=one-to-many cascade=delete
 export function generateModel(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownModel', node);
     const table = props.table;
     const exp = exportPrefix(node);
     const lines = [];
@@ -1535,14 +1395,14 @@ export function generateModel(node) {
     lines.push(`${exp}interface ${name} {`);
     for (const col of kids(node, 'column')) {
         const cp = p(col);
-        const colName = cp.name;
+        const colName = emitIdentifier(cp.name, 'column', col);
         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 relName = emitIdentifier(rp.name, 'relation', rel);
         const target = rp.target;
         const kind = rp.kind || 'one-to-many';
         const relType = kind.includes('many') ? `${target}[]` : target;
@@ -1572,7 +1432,7 @@ function mapColumnType(kernType) {
 //     handler <<<return this.findOne({ email });>>>
 export function generateRepository(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'UnknownRepo', node);
     const model = props.model;
     const exp = exportPrefix(node);
     const lines = [];
@@ -1583,11 +1443,11 @@ export function generateRepository(node) {
     }
     for (const method of kids(node, 'method')) {
         const mp = p(method);
-        const mname = mp.name;
+        const mname = emitIdentifier(mp.name, 'method', method);
         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 mreturns = mp.returns ? `: ${emitTypeAnnotation(mp.returns, 'unknown', method)}` : '';
         const mcode = handlerCode(method);
         lines.push(`  ${asyncKw}${mname}(${mparams})${mreturns} {`);
         if (mcode) {
@@ -1608,7 +1468,7 @@ export function generateRepository(node) {
 //   returns AuthService with=repo
 export function generateDependency(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'unknownDep', node);
     const scope = props.scope || 'transient';
     const exp = exportPrefix(node);
     const lines = [];
@@ -1625,7 +1485,7 @@ export function generateDependency(node) {
     }
     for (const inj of injects) {
         const ip = p(inj);
-        const injName = ip.name;
+        const injName = emitIdentifier(ip.name, 'dep', inj);
         const injType = ip.type;
         const injFrom = ip.from;
         const injWith = ip.with;
@@ -1660,7 +1520,7 @@ export function generateDependency(node) {
 //   invalidate on=userUpdate tags="user:{id}"
 export function generateCache(node) {
     const props = p(node);
-    const name = props.name;
+    const name = emitIdentifier(props.name, 'unknownCache', node);
     const backend = props.backend || 'memory';
     const prefix = props.prefix || '';
     const ttl = props.ttl;
@@ -1675,7 +1535,7 @@ export function generateCache(node) {
     // Entry methods
     for (const entry of kids(node, 'entry')) {
         const ep = p(entry);
-        const entryName = ep.name;
+        const entryName = emitIdentifier(ep.name, 'entry', entry);
         const key = ep.key || entryName;
         const strategyNode = firstChild(entry, 'strategy');
         const strategy = strategyNode ? (p(strategyNode).name || 'cache-aside') : 'cache-aside';
@@ -1744,7 +1604,8 @@ export function isCoreNode(type) {
     return CORE_NODE_TYPES.has(type);
 }
 /** Generate TypeScript for any core language node. */
-export function generateCoreNode(node, target) {
+export function generateCoreNode(node, target, runtime) {
+    const rt = runtime ?? defaultRuntime;
     switch (node.type) {
         case 'type': return generateType(node);
         case 'interface': return generateInterface(node);
@@ -1812,14 +1673,14 @@ export function generateCoreNode(node, target) {
         case 'option': return [];
         default: {
             // Check evolved generators (v4) — target-specific first, then default
-            const targetMap = target ? _evolvedTargetGenerators.get(node.type) : undefined;
+            const targetMap = target ? rt.evolvedTargetGenerators.get(node.type) : undefined;
             const targetGen = targetMap && target ? targetMap.get(target) : undefined;
-            const evolvedGen = targetGen || _evolvedGenerators.get(node.type);
+            const evolvedGen = targetGen || rt.evolvedGenerators.get(node.type);
             if (evolvedGen)
                 return evolvedGen(node);
             // Check if this is a template instance
-            if (isTemplateNode(node.type))
-                return expandTemplateNode(node);
+            if (isTemplateNode(node.type, rt))
+                return expandTemplateNode(node, 0, rt);
             return [];
         }
     }