@kernlang/core 3.3.9 → 3.4.1

package/dist/capability-matrix.d.ts

@@ -0,0 +1,15 @@
+/** (target × feature × position) capability matrix.
+ *  Per-slice codegen declares which features compile in which contexts on which targets.
+ *  Populated incrementally as language evolution slices ship. */
+import type { KernTarget } from './config.js';
+export type FeaturePosition = 'top-level' | 'fn-body' | 'render' | 'template' | 'expression';
+export type Support = 'native' | 'lowered' | 'unsupported';
+export interface CapabilityEntry {
+    feature: string;
+    position: FeaturePosition;
+    support: Support;
+    note?: string;
+}
+export type CapabilityMatrix = Record<KernTarget, CapabilityEntry[]>;
+export declare const CAPABILITY_MATRIX: CapabilityMatrix;
+export declare function capabilitySupport(target: KernTarget, feature: string, position: FeaturePosition): Support;

package/dist/capability-matrix.js

@@ -0,0 +1,245 @@
+/** (target × feature × position) capability matrix.
+ *  Per-slice codegen declares which features compile in which contexts on which targets.
+ *  Populated incrementally as language evolution slices ship. */
+const TS_CORE_CAPABILITIES = [
+    { feature: 'literal-float', position: 'expression', support: 'native' },
+    { feature: 'literal-numeric-separator', position: 'expression', support: 'native' },
+    { feature: 'literal-bigint', position: 'expression', support: 'native' },
+    { feature: 'literal-hex', position: 'expression', support: 'native' },
+    { feature: 'literal-binary', position: 'expression', support: 'native' },
+    { feature: 'literal-octal', position: 'expression', support: 'native' },
+    {
+        feature: 'literal-string-single-quote',
+        position: 'expression',
+        support: 'lowered',
+        note: 'normalized to double-quote on output',
+    },
+    { feature: 'optional-chain', position: 'expression', support: 'native' },
+    { feature: 'nullish-coalesce', position: 'expression', support: 'native' },
+    { feature: 'spread', position: 'expression', support: 'native' },
+    { feature: 'template-literal', position: 'expression', support: 'native' },
+    // Slice 1j — const.value is emitted via ValueIR expression codegen on TS targets.
+    // Quoted strings round-trip through JSON.stringify; bare expressions canonicalize via emitExpression.
+    { feature: 'const-value-as-expression', position: 'top-level', support: 'native' },
+    // Slice 2a — tuple types via type.alias / field.type / fn.returns / fn.params,
+    // including optional, rest, labeled, nested, and empty forms. Routed through
+    // emitTypeAnnotation's bracket-balance pass; no new node type required.
+    { feature: 'tuple-type', position: 'top-level', support: 'native' },
+    // Slice 2b — `enum` node for numeric (values=A|B|C) and string-valued
+    // (member name=X value="..." children) enums; `const enum` form supported.
+    { feature: 'enum-type', position: 'top-level', support: 'native' },
+    // Slice 2c — `indexer` child node on interface, emits `[key: K]: V` index
+    // signature with optional `readonly` modifier.
+    { feature: 'index-signature', position: 'top-level', support: 'native' },
+    // Slice 2d — type guards (predicate return types: `value is T`, `asserts x is T`,
+    // `this is T`). Already supported today via fn.returns + emitTypeAnnotation
+    // passthrough; formalised with regression tests in slice 2d.
+    { feature: 'type-guard', position: 'top-level', support: 'native' },
+    // Slice 2e — function overloads via `overload` child node. Each overload
+    // emits a `function name(params): R;` line before the implementation.
+    { feature: 'function-overloads', position: 'top-level', support: 'native' },
+    // Slice 2f — generics: `generics="<T>"` / `<T extends Base>` / `<T = Default>` /
+    // `<K, V>` on type, interface, fn, class. Routed through emitTypeAnnotation
+    // (whitespace + bracket-balance).
+    { feature: 'generics', position: 'top-level', support: 'native' },
+    // Slice 2g — cross-`.kern` symbol resolution via `use path="..."` parent
+    // with `from name=X as=Y export=true` children. `.kern` paths translate to
+    // `.js` in the emitted TS import; `export=true` produces an additional
+    // `export { ... } from '...'` re-export line.
+    { feature: 'cross-kern-import', position: 'top-level', support: 'native' },
+    // Slice 3a — `let.value` extends iteration-scoped bindings to use the
+    // ValueIR-canonicalised native expression form (mirrors `const.value`
+    // from slice 1j). `expr=` remains as the rawExpr passthrough fallback.
+    { feature: 'let-native-value', position: 'top-level', support: 'native' },
+    // Slice 3b — `field.value` extends class/service/config field initializers
+    // to the ValueIR-canonicalised native form (mirrors slice 1j/3a). `default=`
+    // remains as the rawExpr passthrough fallback for back-compat with seeds
+    // that author bare-string defaults like `default=plan` for string-typed
+    // fields, where the legacy type-aware coercion still applies.
+    { feature: 'field-native-value', position: 'top-level', support: 'native' },
+    // Slice 3c — `param.value` extends fn/method/constructor parameter defaults
+    // to the ValueIR-canonicalised native form via structured `param` child
+    // nodes. Mirrors slice 1j/3a/3b. Legacy `params="..."` string with embedded
+    // defaults remains supported for back-compat. Importer + migrate-class-body
+    // emit `param` children all-or-nothing per signature, gated to skip
+    // signatures with optional/variadic/destructured params (those stay legacy).
+    { feature: 'param-native-value', position: 'top-level', support: 'native' },
+    // Slice 3d — `destructure` adds a native node for TS-style destructured
+    // const/let bindings: `const {a, b: rename} = obj` (object pattern with
+    // `binding` children) and `const [x, y] = arr` (array pattern with
+    // `element` children). For complex patterns (rest `...`, defaults `=v`,
+    // nested `{a:{b}}`), the importer falls back to `expr={{...}}` carrying
+    // the raw TS statement verbatim. Codegen, importer, and decompiler all
+    // round-trip simple patterns; complex patterns survive but stay opaque.
+    { feature: 'destructure-native', position: 'top-level', support: 'native' },
+    // Slice 3e — `mapLit`/`setLit` add native top-level nodes for Map/Set
+    // declarations: `mapLit name=cache type="Map<string,number>"` with
+    // `mapEntry key=k value=v` children emits `new Map([[k, v]])`; same for
+    // `setLit`/`setItem`. Complex shapes (computed keys, spread, conditional
+    // entries) fall through to legacy `const` with handler block. Inline
+    // Map/Set literals inside expression-typed props still use the
+    // `value={{ new Map([...]) }}` escape hatch — slice 3e is statement-level
+    // sugar only, not a parser-grammar extension.
+    { feature: 'maplit-setlit-native', position: 'top-level', support: 'native' },
+];
+const PY_CORE_CAPABILITIES = [
+    { feature: 'literal-float', position: 'expression', support: 'native' },
+    { feature: 'literal-numeric-separator', position: 'expression', support: 'native' },
+    {
+        feature: 'literal-bigint',
+        position: 'expression',
+        support: 'lowered',
+        note: 'Python int is arbitrary precision; n suffix dropped',
+    },
+    { feature: 'literal-hex', position: 'expression', support: 'native' },
+    { feature: 'literal-binary', position: 'expression', support: 'native' },
+    { feature: 'literal-octal', position: 'expression', support: 'native' },
+    { feature: 'literal-string-single-quote', position: 'expression', support: 'native' },
+    {
+        feature: 'optional-chain',
+        position: 'expression',
+        support: 'lowered',
+        note: 'lowered to (x if x is not None else None).y pattern',
+    },
+    {
+        feature: 'nullish-coalesce',
+        position: 'expression',
+        support: 'lowered',
+        note: 'lowered to x if x is not None else y',
+    },
+    { feature: 'spread', position: 'expression', support: 'lowered', note: 'lowered to *iter / **mapping' },
+    { feature: 'template-literal', position: 'expression', support: 'lowered', note: 'lowered to f-string' },
+    // Slice 1j — Python codegen has its own const path (FastAPI generator); ValueIR consumption is deferred.
+    {
+        feature: 'const-value-as-expression',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'Python const codegen has not yet been wired to ValueIR; bare values emit raw',
+    },
+    // Slice 2a — mapTsTypeToPython has no tuple branch yet, so a TS alias like
+    // `[string, number]` falls through unchanged and would emit invalid Python.
+    // Until lowering lands (`[T, U]` → `tuple[T, U]`), report unsupported so feature
+    // gates don't permit broken output.
+    {
+        feature: 'tuple-type',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'mapTsTypeToPython has no tuple branch; alias passthrough emits raw TS form',
+    },
+    // Slice 2b — Python has Enum class via `from enum import Enum`, but the
+    // FastAPI generator does not yet emit class-based enums for the `enum` node.
+    // Mark unsupported until that path lands; flipping to `lowered` requires a
+    // dedicated Python generator (would emit `class Status(str, Enum): ...`).
+    {
+        feature: 'enum-type',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen does not yet handle the enum node; would produce no output',
+    },
+    // Slice 2c — Python has dict[K, V] / TypedDict but the FastAPI generator
+    // does not yet emit either form from an `indexer` child. Mark unsupported.
+    {
+        feature: 'index-signature',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen does not yet handle indexer; would produce no output',
+    },
+    // Slice 2d — Python has `TypeGuard[T]` and `TypeIs[T]` (3.13+) from typing,
+    // but mapTsTypeToPython has no `value is T` / `asserts x is T` translation.
+    // Passthrough would emit invalid Python.
+    {
+        feature: 'type-guard',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'mapTsTypeToPython has no predicate-return-type branch (TypeGuard/TypeIs)',
+    },
+    // Slice 2e — Python has `@typing.overload` decorators, but the FastAPI
+    // generator does not yet emit @overload-decorated stubs from `overload`
+    // children.
+    {
+        feature: 'function-overloads',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen does not yet emit @typing.overload stubs',
+    },
+    // Slice 2f — Python has TypeVar / Generic[T] for parameterised types but
+    // the FastAPI generator does not yet emit `T = TypeVar("T")` / `class X(Generic[T])`.
+    {
+        feature: 'generics',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen does not yet emit TypeVar / Generic[T] declarations',
+    },
+    // Slice 2g — Python could in principle map `.kern → .py` via `from <module>
+    // import <name> as <alias>`, but the FastAPI generator has no such branch
+    // yet. Default to unsupported until the path is wired explicitly.
+    {
+        feature: 'cross-kern-import',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen does not yet translate `.kern` paths to Python `from x import y` syntax',
+    },
+    // Slice 3b — Python (FastAPI) field codegen reads `fp.default` directly
+    // and has no ValueIR pipeline yet, so `field.value` is unsupported until a
+    // dedicated Python emitter for canonicalised field initializers lands.
+    {
+        feature: 'field-native-value',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen has not been wired to ValueIR for field initializers; `value=` would emit raw',
+    },
+    // Slice 3c P2 follow-up (shipped) — FastAPI's 4 ad-hoc param parsers were
+    // consolidated behind `buildPythonParamList` in packages/fastapi/src/codegen-helpers.ts,
+    // which reads structured `param` children first (slice 3c+ canonical form)
+    // and falls back to legacy `params="..."` for back-compat. Optional `?`
+    // emits `Optional[T] = None`, variadic `...` emits `*args: T`, destructured
+    // `{a,b}` patterns are skipped (Python has no equivalent — caller unpacks
+    // in body).
+    {
+        feature: 'param-native-value',
+        position: 'top-level',
+        support: 'native',
+        note: 'FastAPI codegen wired through `buildPythonParamList` (slice 3c P2 follow-up); reads structured param children with value=/default=/optional=/variadic=',
+    },
+    // Slice 3d — Python has no native syntactic equivalent of TS object/array
+    // destructuring on `const`/`let`. FastAPI codegen would have to lower
+    // `destructure` to a sequence of bindings (`a = obj.a; b = obj.b`) which
+    // is a separate work item. Marked unsupported per slice 3b/3c precedent.
+    {
+        feature: 'destructure-native',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen has not been wired to lower `destructure` nodes; would need per-binding assignment lowering',
+    },
+    // Slice 3e — Python's `dict`/`set` literals are syntactically different
+    // from TS `Map`/`Set` and FastAPI codegen has not been wired to lower
+    // `mapLit`/`setLit` to either form. Marked unsupported per slice 3b/3c/3d
+    // precedent until a dedicated Python emitter exists.
+    {
+        feature: 'maplit-setlit-native',
+        position: 'top-level',
+        support: 'unsupported',
+        note: 'FastAPI codegen has not been wired to lower `mapLit`/`setLit` to Python `dict`/`set` literals',
+    },
+];
+export const CAPABILITY_MATRIX = {
+    auto: TS_CORE_CAPABILITIES,
+    lib: TS_CORE_CAPABILITIES,
+    nextjs: TS_CORE_CAPABILITIES,
+    tailwind: TS_CORE_CAPABILITIES,
+    web: TS_CORE_CAPABILITIES,
+    native: TS_CORE_CAPABILITIES,
+    express: TS_CORE_CAPABILITIES,
+    cli: TS_CORE_CAPABILITIES,
+    terminal: TS_CORE_CAPABILITIES,
+    ink: TS_CORE_CAPABILITIES,
+    vue: TS_CORE_CAPABILITIES,
+    nuxt: TS_CORE_CAPABILITIES,
+    fastapi: PY_CORE_CAPABILITIES,
+    mcp: TS_CORE_CAPABILITIES,
+};
+export function capabilitySupport(target, feature, position) {
+    const entries = CAPABILITY_MATRIX[target] ?? [];
+    return entries.find((e) => e.feature === feature && e.position === position)?.support ?? 'unsupported';
+}
+//# sourceMappingURL=capability-matrix.js.map

package/dist/capability-matrix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-matrix.js","sourceRoot":"","sources":["../src/capability-matrix.ts"],"names":[],"mappings":"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"}

package/dist/codegen/body-ts.d.ts

@@ -0,0 +1,68 @@
+/** Native KERN handler-body codegen — TypeScript target (slices 1–3).
+ *
+ *  Walks the children of a handler with `lang=kern` and emits a TypeScript
+ *  body string. Recognized statements:
+ *
+ *    - `let name=X value="EXPR"` — `const X = EXPR;` (slice 1)
+ *    - `return value="EXPR"` / bare `return` — `return EXPR;` (slice 1)
+ *    - `if cond="EXPR"` / sibling `else` — `if (EXPR) { … } else { … }` (slice 2c)
+ *
+ *  Statement-level propagation `?` lowers to the same hoisted shape that
+ *  slice 7 established for raw-body propagation:
+ *
+ *      const __k_t1 = await call();
+ *      if (__k_t1.kind === 'err') return __k_t1;
+ *      const u = __k_t1.value;
+ *
+ *  Slice 3 — symmetric `{ code, imports }` shape with the Python target so
+ *  body-emitter callers have a uniform signature regardless of language.
+ *  TS's KERN-stdlib lowerings don't currently demand any imports (`Math` is
+ *  global, `Set`/`Map` are global), so `imports` is typically empty. The
+ *  `BodyEmitOptions.symbolMap` parameter is currently unused on the TS
+ *  target — TS preserves the camelCase identifier shape end-to-end — but
+ *  is plumbed through for parity with the Python emitter (and for any
+ *  future TS-only renames such as reserved-word collision handling).
+ *
+ *  Slice scope:
+ *    - Result-flavored propagation only (`'err'` discriminant). Option
+ *      propagation in native bodies is deferred to slice 8 (typecheck-driven).
+ *    - `if` requires `cond="EXPR"`. `else` is a sibling node (no condition).
+ *      `else if` chains land in slice 3 — for slice 2c users nest `if` inside
+ *      the `else` branch.
+ *
+ *  `gensymCounter` is local to each emit call — every handler gets its own
+ *  fresh `__k_t1`, `__k_t2`, … sequence (same convention as slice 7).
+ *
+ *  Indentation: the recursive walk threads an `indent` string so nested
+ *  `if`/`else` branches indent correctly. The caller adds the leading indent
+ *  for the surrounding function body. */
+import type { IRNode } from '../types.js';
+/** Slice 3e — caller-provided options, parity with the Python body emitter.
+ *  `symbolMap` is currently unused on the TS target; reserved for future
+ *  use (e.g., reserved-word renames). */
+export interface BodyEmitOptions {
+    symbolMap?: Record<string, string>;
+}
+/** Slice 3e — public return shape, parity with the Python body emitter.
+ *  TS's KERN-stdlib lowerings don't currently demand any imports; the
+ *  `imports` set will typically be empty until a future slice introduces
+ *  TS-stdlib entries with `requires.ts` (e.g., a `node:crypto` import). */
+export interface BodyEmitResult {
+    code: string;
+    imports: Set<string>;
+}
+/** Emit the body of a native KERN handler as TypeScript source. Returns
+ *  the joined body text. Each top-level line is unindented; nested
+ *  branches indent by 2 spaces per level.
+ *
+ *  Legacy slice 1/2 signature — returns just the code string. Callers
+ *  that also need the import set (slice 3b parity with Python) should
+ *  use `emitNativeKernBodyTSWithImports`. */
+export declare function emitNativeKernBodyTS(handlerNode: IRNode, options?: BodyEmitOptions): string;
+/** Slice 3e — context-aware variant returning `{ code, imports }`.
+ *  TS's KERN-stdlib lowerings don't currently demand any imports; the
+ *  `imports` set will typically be empty until a future slice introduces
+ *  TS-stdlib entries with `requires.ts` (e.g., a `node:crypto` import).
+ *  Provided for symmetry with the Python target so generators that drive
+ *  both languages have a uniform call shape. */
+export declare function emitNativeKernBodyTSWithImports(handlerNode: IRNode, _options?: BodyEmitOptions): BodyEmitResult;

package/dist/codegen/body-ts.js

@@ -0,0 +1,214 @@
+/** Native KERN handler-body codegen — TypeScript target (slices 1–3).
+ *
+ *  Walks the children of a handler with `lang=kern` and emits a TypeScript
+ *  body string. Recognized statements:
+ *
+ *    - `let name=X value="EXPR"` — `const X = EXPR;` (slice 1)
+ *    - `return value="EXPR"` / bare `return` — `return EXPR;` (slice 1)
+ *    - `if cond="EXPR"` / sibling `else` — `if (EXPR) { … } else { … }` (slice 2c)
+ *
+ *  Statement-level propagation `?` lowers to the same hoisted shape that
+ *  slice 7 established for raw-body propagation:
+ *
+ *      const __k_t1 = await call();
+ *      if (__k_t1.kind === 'err') return __k_t1;
+ *      const u = __k_t1.value;
+ *
+ *  Slice 3 — symmetric `{ code, imports }` shape with the Python target so
+ *  body-emitter callers have a uniform signature regardless of language.
+ *  TS's KERN-stdlib lowerings don't currently demand any imports (`Math` is
+ *  global, `Set`/`Map` are global), so `imports` is typically empty. The
+ *  `BodyEmitOptions.symbolMap` parameter is currently unused on the TS
+ *  target — TS preserves the camelCase identifier shape end-to-end — but
+ *  is plumbed through for parity with the Python emitter (and for any
+ *  future TS-only renames such as reserved-word collision handling).
+ *
+ *  Slice scope:
+ *    - Result-flavored propagation only (`'err'` discriminant). Option
+ *      propagation in native bodies is deferred to slice 8 (typecheck-driven).
+ *    - `if` requires `cond="EXPR"`. `else` is a sibling node (no condition).
+ *      `else if` chains land in slice 3 — for slice 2c users nest `if` inside
+ *      the `else` branch.
+ *
+ *  `gensymCounter` is local to each emit call — every handler gets its own
+ *  fresh `__k_t1`, `__k_t2`, … sequence (same convention as slice 7).
+ *
+ *  Indentation: the recursive walk threads an `indent` string so nested
+ *  `if`/`else` branches indent correctly. The caller adds the leading indent
+ *  for the surrounding function body. */
+import { emitExpression } from '../codegen-expression.js';
+import { parseExpression } from '../parser-expression.js';
+const INDENT_STEP = '  ';
+/** Emit the body of a native KERN handler as TypeScript source. Returns
+ *  the joined body text. Each top-level line is unindented; nested
+ *  branches indent by 2 spaces per level.
+ *
+ *  Legacy slice 1/2 signature — returns just the code string. Callers
+ *  that also need the import set (slice 3b parity with Python) should
+ *  use `emitNativeKernBodyTSWithImports`. */
+export function emitNativeKernBodyTS(handlerNode, options) {
+    return emitNativeKernBodyTSWithImports(handlerNode, options).code;
+}
+/** Slice 3e — context-aware variant returning `{ code, imports }`.
+ *  TS's KERN-stdlib lowerings don't currently demand any imports; the
+ *  `imports` set will typically be empty until a future slice introduces
+ *  TS-stdlib entries with `requires.ts` (e.g., a `node:crypto` import).
+ *  Provided for symmetry with the Python target so generators that drive
+ *  both languages have a uniform call shape. */
+export function emitNativeKernBodyTSWithImports(handlerNode, _options) {
+    const ctx = { gensymCounter: 0, tryDepth: 0 };
+    const code = emitChildrenTS(handlerNode.children ?? [], ctx, '').join('\n');
+    return { code, imports: new Set() };
+}
+function emitChildrenTS(children, ctx, indent) {
+    const lines = [];
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.type === 'let') {
+            for (const line of emitLetTS(child, ctx))
+                lines.push(`${indent}${line}`);
+        }
+        else if (child.type === 'return') {
+            for (const line of emitReturnTS(child, ctx))
+                lines.push(`${indent}${line}`);
+        }
+        else if (child.type === 'if') {
+            const condRaw = String(child.props?.cond ?? '');
+            const condIR = parseExpression(condRaw);
+            // Slice-2 review fix: propagation `?` in an `if` condition has no
+            // sensible single-line lowering; reject early with a clear message
+            // pointing users at the let-bind workaround.
+            if (condIR.kind === 'propagate') {
+                throw new Error("Propagation '?' is not allowed in `if cond=` — bind the call to a `let` first, then test the bound name.");
+            }
+            lines.push(`${indent}if (${emitExpression(condIR)}) {`);
+            for (const sl of emitChildrenTS(child.children ?? [], ctx, indent + INDENT_STEP))
+                lines.push(sl);
+            const next = children[i + 1];
+            if (next && next.type === 'else') {
+                lines.push(`${indent}} else {`);
+                for (const el of emitChildrenTS(next.children ?? [], ctx, indent + INDENT_STEP))
+                    lines.push(el);
+                i++;
+            }
+            lines.push(`${indent}}`);
+        }
+        else if (child.type === 'else') {
+            // Slice-2 review fix: orphan `else` (without a preceding `if` sibling)
+            // is a structural error — silently dropping it produced confusing
+            // miscompiles. The `if` arm above consumes its paired `else` via i++,
+            // so reaching one here means it was orphaned.
+            throw new Error('`else` must immediately follow an `if` sibling. Found orphan `else` in handler body.');
+        }
+        else if (child.type === 'try') {
+            // Slice 4c — try/catch control flow.
+            // Slice 4c review fix (OpenCode + Gemini high): orphan `try` produces
+            // a syntactically-incomplete body. Both TS (no-catch try is legal but
+            // semantically wrong) and Python (SyntaxError) need a paired catch;
+            // require the sibling and fail loud if missing.
+            const next = children[i + 1];
+            if (!next || next.type !== 'catch') {
+                throw new Error('`try` must be immediately followed by a `catch` sibling. Found orphan `try` in handler body.');
+            }
+            lines.push(`${indent}try {`);
+            ctx.tryDepth++;
+            for (const sl of emitChildrenTS(child.children ?? [], ctx, indent + INDENT_STEP))
+                lines.push(sl);
+            ctx.tryDepth--;
+            const errName = String(next.props?.name ?? 'e');
+            lines.push(`${indent}} catch (${errName}) {`);
+            for (const cl of emitChildrenTS(next.children ?? [], ctx, indent + INDENT_STEP))
+                lines.push(cl);
+            i++;
+            lines.push(`${indent}}`);
+        }
+        else if (child.type === 'catch') {
+            throw new Error('`catch` must immediately follow a `try` sibling. Found orphan `catch` in handler body.');
+        }
+        else if (child.type === 'throw') {
+            // Slice 4c — throw statement.
+            for (const line of emitThrowTS(child, ctx))
+                lines.push(`${indent}${line}`);
+        }
+        else if (child.type === 'each') {
+            // Slice 4d — each loop.
+            // Slice 4c+4d review fix (Codex P1): the schema's `each` already
+            // declares `name` (binding) and `in` (iterable expression). The
+            // earlier slice-4d body-emit read `list`/`as` instead, which meant
+            // (a) schema-validated source `each name=x in=items` fell back to
+            // `for (const item of [])` (empty list, wrong binding) and
+            // (b) tests that used `list`/`as` failed schema validation.
+            // Read schema-compliant `name`/`in` first; accept legacy
+            // `list`/`as` as a fallback for tests that pre-date this fix.
+            const listRaw = String(child.props?.in ?? child.props?.list ?? '[]');
+            const asName = String(child.props?.name ?? child.props?.as ?? 'item');
+            const listIR = parseExpression(listRaw);
+            lines.push(`${indent}for (const ${asName} of ${emitExpression(listIR)}) {`);
+            for (const sl of emitChildrenTS(child.children ?? [], ctx, indent + INDENT_STEP))
+                lines.push(sl);
+            lines.push(`${indent}}`);
+        }
+        // Other child types fall through silently — slice 3 adds more.
+    }
+    return lines;
+}
+/** Slice 4c review fix (OpenCode + Gemini critical) — propagation `?`
+ *  inside a `try` block has no clean lowering. The hoisted err-branch
+ *  emits `return tmp` which exits the function entirely, BYPASSING the
+ *  enclosing `catch`. That's almost never what users mean — they wrote
+ *  `?` to flag a Result.err and (presumably) to let the catch handle
+ *  it. Reject at codegen with a let-bind hint. Same shape as
+ *  slice-2's reject-`?`-in-`if-cond` rule. */
+function rejectPropagationInsideTry(ctx) {
+    if (ctx.tryDepth > 0) {
+        throw new Error("Propagation '?' is not allowed inside a `try` block — `return` from the err branch exits the function and bypasses the enclosing `catch`. " +
+            'Bind the call to a `let` outside the try, then use `if x.kind === "err" throw new Error(...)` inside the try, OR use raw `lang=ts`/`lang=python` for the affected handler.');
+    }
+}
+function emitLetTS(node, ctx) {
+    const props = (node.props ?? {});
+    const name = String(props.name ?? '_');
+    const rawValue = props.value;
+    if (rawValue === undefined || rawValue === '') {
+        return [`const ${name} = undefined;`];
+    }
+    const valueIR = parseExpression(String(rawValue));
+    if (valueIR.kind === 'propagate' && valueIR.op === '?') {
+        rejectPropagationInsideTry(ctx);
+        const tmp = `__k_t${++ctx.gensymCounter}`;
+        const inner = emitExpression(valueIR.argument);
+        return [`const ${tmp} = ${inner};`, `if (${tmp}.kind === 'err') return ${tmp};`, `const ${name} = ${tmp}.value;`];
+    }
+    return [`const ${name} = ${emitExpression(valueIR)};`];
+}
+function emitReturnTS(node, ctx) {
+    const props = (node.props ?? {});
+    const rawValue = props.value;
+    if (rawValue === undefined || rawValue === '') {
+        return [`return;`];
+    }
+    const valueIR = parseExpression(String(rawValue));
+    if (valueIR.kind === 'propagate' && valueIR.op === '?') {
+        rejectPropagationInsideTry(ctx);
+        const tmp = `__k_t${++ctx.gensymCounter}`;
+        const inner = emitExpression(valueIR.argument);
+        return [`const ${tmp} = ${inner};`, `if (${tmp}.kind === 'err') return ${tmp};`, `return ${tmp}.value;`];
+    }
+    return [`return ${emitExpression(valueIR)};`];
+}
+function emitThrowTS(node, ctx) {
+    const props = (node.props ?? {});
+    const rawValue = props.value;
+    if (rawValue === undefined || rawValue === '') {
+        return [`throw new Error();`];
+    }
+    const valueIR = parseExpression(String(rawValue));
+    if (valueIR.kind === 'propagate' && valueIR.op === '?') {
+        rejectPropagationInsideTry(ctx);
+        const tmp = `__k_t${++ctx.gensymCounter}`;
+        const inner = emitExpression(valueIR.argument);
+        return [`const ${tmp} = ${inner};`, `if (${tmp}.kind === 'err') return ${tmp};`, `throw ${tmp}.value;`];
+    }
+    return [`throw ${emitExpression(valueIR)};`];
+}
+//# sourceMappingURL=body-ts.js.map

package/dist/codegen/body-ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-ts.js","sourceRoot":"","sources":["../../src/codegen/body-ts.ts"],"names":[],"mappings":"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"}

package/dist/codegen/data-layer.d.ts

@@ -3,7 +3,7 @@
  *
  * Extracted from codegen-core.ts for modular codegen architecture.
  */
-import type { IRNode } from '../types.js';
+import { type IRNode } from '../types.js';
 export declare function generateConfig(node: IRNode): string[];
 export declare function generateStore(node: IRNode): string[];
 export declare function generateRepository(node: IRNode): string[];