@kernlang/core 3.3.4 → 3.3.6

package/dist/schema.js

@@ -184,12 +184,14 @@ export const NODE_SCHEMAS = {
         },
     },
     transition: {
-        description: 'A guarded transition between machine states, with optional handler',
-        example: 'transition name=confirm from=pending to=confirmed\n  handler <<<\n    await notifyUser()\n  >>>',
+        description: 'A guarded transition between machine states, with optional typed payload and/or guard predicate. `params` uses the same comma-separated typed list shape as `fn` (e.g. "prompt:string,chatId:string") — those parameters enter the emitted transition function signature and are in scope inside the handler and the guard. `guard` is a raw JS boolean expression evaluated AFTER the from-state check; when falsy the transition throws `<Machine>GuardError(\'<transition>\', entity.state)`.',
+        example: 'transition name=submit from=idle to=running params="prompt:string,chatId:string" guard="entity.turnsLeft > 0"\n  handler <<<\n    await notifyUser(prompt)\n  >>>',
         props: {
             name: { required: true, kind: 'identifier' },
             from: { required: true, kind: 'string' },
             to: { required: true, kind: 'identifier' },
+            params: { kind: 'string' },
+            guard: { kind: 'rawExpr' },
         },
         allowedChildren: ['handler'],
     },
@@ -271,7 +273,7 @@ export const NODE_SCHEMAS = {
             key: { kind: 'string' },
             async: { kind: 'boolean' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'set'],
     },
     websocket: {
         description: 'WebSocket server endpoint with event handlers',
@@ -293,6 +295,518 @@ export const NODE_SCHEMAS = {
             export: { kind: 'boolean' },
         },
     },
+    fmt: {
+        description: 'Formatted string binding — declarative template literal. The `template` body is emitted verbatim between backticks, so `${expr}` placeholders interpolate normally. Use this instead of dropping into a handler just to build an interpolated string.',
+        example: 'fmt name=label template="${count} files over ${totalMb.toFixed(1)} MB"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            template: { required: true, kind: 'string' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    set: {
+        description: 'Declarative state update — inside an `on` event block, `set name=count to="count + 1"` lowers to `setCount(count + 1);`. The setter name follows React useState convention (`set` + capitalized state name). Lets authors skip a handler block when all they need is to mutate a piece of state.',
+        example: 'on event=click\n  set name=count to="count + 1"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            to: { required: true, kind: 'rawExpr' },
+        },
+    },
+    async: {
+        description: 'Declarative async block — a named async unit that runs its `handler` body once, optionally wrapped by a `recover` child that delegates to the existing `recover`/`strategy` machinery. Reuses `generateRecover` verbatim, so fallback/retry semantics match the rest of the ground layer. The emitted code is a statement (IIFE when no recover, wrapped call when recover is present) so it can be spliced inside any statement context.',
+        example: 'async name=loadUser\n  handler <<<\n    const res = await fetch(`/api/users/${id}`);\n    setUser(await res.json());\n  >>>\n  recover\n    strategy name=fallback\n      handler <<<\n        setUser(null);\n      >>>',
+        props: {
+            name: { kind: 'identifier' },
+        },
+        allowedChildren: ['handler', 'recover'],
+    },
+    filter: {
+        description: 'Declarative `.filter` binding — `filter name=active in=items where="item.active"` lowers to `const active = items.filter(item => item.active);`. Use `item=x` to rename the per-item binding.',
+        example: 'filter name=active in=items where="item.active"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    find: {
+        description: "Declarative `.find` binding — `find name=admin in=users where=\"item.role === 'admin'\"` lowers to `const admin = users.find(item => item.role === 'admin');`. Use `item=x` to rename the per-item binding.",
+        example: 'find name=admin in=users item=u where="u.role === \'admin\'"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    some: {
+        description: 'Declarative `.some` binding — `some name=hasError in=results where="!item.ok"` lowers to `const hasError = results.some(item => !item.ok);`.',
+        example: 'some name=hasError in=results where="!item.ok"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    every: {
+        description: 'Declarative `.every` binding — `every name=allDone in=tasks where="item.done"` lowers to `const allDone = tasks.every(item => item.done);`.',
+        example: 'every name=allDone in=tasks where="item.done"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    reduce: {
+        description: 'Declarative `.reduce` binding — two bound names (accumulator + item). `reduce name=total in=items initial="0" expr="acc + item.value"` lowers to `const total = items.reduce((acc, item) => acc + item.value, 0);`. Override the binding names with `acc=` and `item=`.',
+        example: 'reduce name=total in=items initial="0" expr="acc + item.value"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            acc: { kind: 'identifier' },
+            item: { kind: 'identifier' },
+            initial: { required: true, kind: 'rawExpr' },
+            expr: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    flatMap: {
+        description: 'Declarative `.flatMap` binding — `flatMap name=tags in=posts expr="item.tags"` lowers to `const tags = posts.flatMap(item => item.tags);`. Use `item=` to rename the per-item binding. `expr` is the arrow body (an array or iterable), not a predicate.',
+        example: 'flatMap name=tags in=posts expr="item.tags"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            expr: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    slice: {
+        description: 'Declarative `.slice` binding — `slice name=first5 in=items start=0 end=5` lowers to `const first5 = items.slice(0, 5);`. `start` and `end` default to undefined (JS semantics: a bare `.slice()` copies the whole array).',
+        example: 'slice name=first5 in=items start=0 end=5',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            start: { kind: 'rawExpr' },
+            end: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    map: {
+        description: 'Declarative `.map` binding — `map name=names in=users expr="item.name"` lowers to `const names = users.map(item => item.name);`. Sibling to `each` (JSX iteration form); use `map` for data-transformation bindings. `expr` is the arrow body.',
+        example: 'map name=names in=users expr="item.name"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            expr: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    findIndex: {
+        description: 'Declarative `.findIndex` binding — `findIndex name=pos in=users where="item.active"` lowers to `const pos = users.findIndex(item => item.active);`. Returns a number; add `type=number` when the binding is exported.',
+        example: 'findIndex name=pos in=users where="item.active"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    flat: {
+        description: 'Declarative `.flat` binding — `flat name=flattened in=nested depth=2` lowers to `const flattened = nested.flat(2);`. Omit `depth` for the default depth of 1.',
+        example: 'flat name=flattened in=nested depth=2',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            depth: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    at: {
+        description: 'Declarative `.at` binding — `at name=last in=items index=-1` lowers to `const last = items.at(-1);`. Supports negative indices for tail access.',
+        example: 'at name=last in=items index=-1',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            index: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    sort: {
+        description: 'Declarative immutable sort — `sort name=sorted in=items compare="a.age - b.age"` lowers to `const sorted = [...items].sort((a, b) => a.age - b.age);`. Source collection is never mutated. Omit `compare` for lexicographic sort. Rename bindings with `a=` / `b=`.',
+        example: 'sort name=sorted in=items compare="a.age - b.age"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            a: { kind: 'identifier' },
+            b: { kind: 'identifier' },
+            compare: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    reverse: {
+        description: 'Declarative immutable reverse — `reverse name=reversed in=items` lowers to `const reversed = [...items].reverse();`. Source collection is never mutated.',
+        example: 'reverse name=reversed in=items',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    join: {
+        description: 'Declarative `.join` binding — `join name=csv in=fields separator=","` lowers to `const csv = fields.join(\',\');`. Omit `separator` for the default (`,`). The separator is emitted as a quoted string literal unless wrapped as `{{ expr }}`.',
+        example: 'join name=csv in=fields separator=","',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            separator: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    includes: {
+        description: "Declarative `.includes` binding — `includes name=hasError in=errors value=\"'fatal'\"` lowers to `const hasError = errors.includes('fatal');`. `value` is a raw expression — quote string literals inside it.",
+        example: 'includes name=hasError in=errors value="\'fatal\'"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            value: { required: true, kind: 'rawExpr' },
+            from: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    indexOf: {
+        description: 'Declarative `.indexOf` binding — `indexOf name=pos in=items value=target` lowers to `const pos = items.indexOf(target);`. `value` is a raw expression.',
+        example: 'indexOf name=pos in=items value=target',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            value: { required: true, kind: 'rawExpr' },
+            from: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    lastIndexOf: {
+        description: 'Declarative `.lastIndexOf` binding — `lastIndexOf name=pos in=items value=target` lowers to `const pos = items.lastIndexOf(target);`. `value` is a raw expression.',
+        example: 'lastIndexOf name=pos in=items value=target',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            value: { required: true, kind: 'rawExpr' },
+            from: { kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    concat: {
+        description: 'Declarative `.concat` binding — `concat name=all in=items with="a, b"` lowers to `const all = items.concat(a, b);`. `with` is a raw expression injected directly — supports a single arg or comma-separated spread.',
+        example: 'concat name=all in=items with=other',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            with: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    forEach: {
+        description: 'Declarative `.forEach` statement — `forEach in=items` with a `handler <<<>>>` child lowers to `items.forEach((item) => { handler-body });`. No binding (no `name`, no `const`). Distinct from `each` (JSX composition) and `map` (value binding). Use `item=` / `index=` to rename the parameters.',
+        example: 'forEach in=items\n  handler <<<\n    doSomething(item);\n  >>>',
+        props: {
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            index: { kind: 'identifier' },
+        },
+        allowedChildren: ['handler'],
+    },
+    compact: {
+        description: 'Declarative `.filter(Boolean)` binding — `compact name=truthy in=items` lowers to `const truthy = items.filter(Boolean);`. Named primitive for the common "drop falsy values" pattern (36 sites in agon).',
+        example: 'compact name=truthy in=items',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    pluck: {
+        description: 'Declarative property-extraction map — `pluck name=names in=users prop=name` lowers to `const names = users.map(item => item.name);`. `prop=` is a raw identifier path (e.g. `prop=user.profile.name` emits `item.user.profile.name`). Use `map` when the projection is not a property access.',
+        example: 'pluck name=names in=users prop=name',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            prop: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    unique: {
+        description: 'Declarative dedupe — `unique name=distinct in=items` lowers to `const distinct = [...new Set(items)];`. Uses JS `Set` identity (triple-equals on primitives, reference equality on objects). For key-based dedup of object arrays, use `uniqueBy`.',
+        example: 'unique name=distinct in=items',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    uniqueBy: {
+        description: 'Key-based dedup (first-wins, matches Lodash uniqBy) — `uniqueBy name=distinct in=users by="item.id"` emits a Set+filter form.',
+        example: 'uniqueBy name=distinct in=users by="item.id"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    groupBy: {
+        description: 'Partition an array into buckets by a key selector. Emits a reduce-based form (compatible with ES2022) — does not depend on `Object.groupBy` (ES2024).',
+        example: 'groupBy name=byType in=items by="item.type"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    partition: {
+        description: 'Split an array into two by a predicate — single-pass reduce. Emits `const [pass, fail] = ...`. Both `pass` and `fail` prop names are required.',
+        example: 'partition pass=active fail=inactive in=users where="item.active"',
+        props: {
+            name: { kind: 'identifier' },
+            pass: { required: true, kind: 'identifier' },
+            fail: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    indexBy: {
+        description: 'Array → keyed record via selector. `indexBy name=byId in=users by="item.id"` lowers to `Object.fromEntries(users.map(...))`. Collisions are last-write-wins.',
+        example: 'indexBy name=byId in=users by="item.id"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    countBy: {
+        description: 'Count occurrences by key. `countBy name=counts in=items by="item.type"` lowers to a reduce with `Object.create(null)` accumulator (prototype-pollution safe).',
+        example: 'countBy name=counts in=items by="item.type"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    chunk: {
+        description: 'Split into fixed-size chunks. `chunk name=batches in=items size=10`.',
+        example: 'chunk name=batches in=items size=10',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            size: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    zip: {
+        description: 'Pair two arrays element-wise. `zip name=pairs in=items with=other`. Short-side wins — extra right-hand elements are dropped.',
+        example: 'zip name=pairs in=items with=other',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            with: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            index: { kind: 'identifier' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    range: {
+        description: 'Generate a numeric range. `range name=nums end=10` → `[0..9]`. `range name=nums start=5 end=10` → `[5..9]`. No `step` in v1.',
+        example: 'range name=nums end=10',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            start: { kind: 'rawExpr' },
+            end: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    take: {
+        description: 'First N elements. Alias for `slice(0, n)` but named for intent clarity.',
+        example: 'take name=first5 in=items n=5',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            n: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    drop: {
+        description: 'Drop first N elements. Alias for `slice(n)` but named for intent clarity.',
+        example: 'drop name=tail in=items n=5',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            n: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    min: {
+        description: 'Scalar min on a number array. Returns `undefined` on empty. Reduce-based — no stack-overflow risk on huge arrays.',
+        example: 'min name=lowest in=values',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    max: {
+        description: 'Scalar max on a number array. Returns `undefined` on empty. Reduce-based — no stack-overflow risk on huge arrays.',
+        example: 'max name=highest in=values',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    minBy: {
+        description: 'Find the element with the minimum key. `minBy name=youngest in=users by="item.age"`. Returns `undefined` on empty.',
+        example: 'minBy name=youngest in=users by="item.age"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    maxBy: {
+        description: 'Find the element with the maximum key. `maxBy name=oldest in=users by="item.age"`. Returns `undefined` on empty.',
+        example: 'maxBy name=oldest in=users by="item.age"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    sum: {
+        description: 'Sum of a number array. Returns `0` on empty (additive identity).',
+        example: 'sum name=total in=prices',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    sumBy: {
+        description: 'Sum via key selector. `sumBy name=totalCost in=items by="item.price * item.qty"`.',
+        example: 'sumBy name=totalCost in=items by="item.price * item.qty"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            by: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    avg: {
+        description: 'Mean of a number array. Returns `NaN` on empty (Lodash parity — preserves the "no data" signal).',
+        example: 'avg name=mean in=prices',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    intersect: {
+        description: 'Set intersection of two arrays. `intersect name=shared in=a with=b`. O(N+M) via a Set.',
+        example: 'intersect name=shared in=a with=b',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            with: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    findLast: {
+        description: 'ES2023 counterpart to `find` — iterate from the end. `findLast name=lastActive in=users where="item.active"`.',
+        example: 'findLast name=lastActive in=users where="item.active"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
+    findLastIndex: {
+        description: 'ES2023 counterpart to `findIndex` — iterate from the end. `findLastIndex name=pos in=users where="item.active"`.',
+        example: 'findLastIndex name=pos in=users where="item.active"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            in: { required: true, kind: 'rawExpr' },
+            item: { kind: 'identifier' },
+            where: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+        },
+    },
     transform: {
         description: 'Data transformation pipeline — maps target through a via function or handler',
         example: 'transform name=normalized target=rawData via=normalize type=NormalizedData',
@@ -383,12 +897,34 @@ export const NODE_SCHEMAS = {
         },
     },
     each: {
-        description: 'Iteration — renders children for each item in a collection (target-agnostic loop)',
-        example: 'each name=item in=items index=i',
+        description: 'Iteration — renders children for each item in a collection. Inside a render block emits `items.map(...)` with auto-key; elsewhere emits `for...of`. `let` children become iteration-scoped `const` bindings inside the callback (hook-safe, unlike `derive`).',
+        example: 'each name=f in=files index=i key="f.path"\n  let name=isSel expr="focused && i === selIdx"\n  handler <<<\n    <Text bold={isSel}>{f.path}</Text>\n  >>>',
         props: {
             name: { required: true, kind: 'identifier' },
             in: { required: true, kind: 'rawExpr' },
             index: { kind: 'identifier' },
+            key: { kind: 'rawExpr' },
+        },
+        // Intentionally unrestricted — statement-form `each` composes with `derive`,
+        // `transform`, etc. in fn/handler contexts. The `let` node is constrained
+        // separately via the `let-must-be-inside-each` semantic rule.
+    },
+    let: {
+        description: 'Iteration-scoped binding — emits a plain `const` inside the containing `each` callback. Use for values that depend on the iteration variable or index. Unlike `derive` (which compiles to `useMemo` and violates Rules of Hooks inside `.map`), `let` is hook-safe by construction.',
+        example: 'let name=idx expr="start + i"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            expr: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+        },
+    },
+    local: {
+        description: 'Render-scope binding — emits `const name = expr;` at the top of the enclosing screen function, before its JSX return. Use for shared pre-compute that multiple sibling `each`/`conditional`/`handler` nodes inside the same `render` block read. Expression-only (no handler body) — drop to an explicit `derive` / `memo` above the render if a hook or imperative body is needed. Direct child of `render` only.',
+        example: 'render wrapper="<Box paddingX={1}>"\n  local name=visible expr="items.slice(start, start + pageSize)"\n  each name=item in=visible\n    handler <<< <Text>{item.label}</Text> >>>',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            expr: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
         },
     },
     collect: {
@@ -626,11 +1162,26 @@ export const NODE_SCHEMAS = {
         },
     },
     conditional: {
-        description: 'Conditional rendering — shows children when if-expression is truthy',
-        example: 'conditional if="user !== null"',
+        description: 'Conditional rendering — shows the `then` branch when if-expression is truthy. Inside a `render` block the branch JSX goes in a `handler <<<>>>` child; optional `elseif` / `else` children provide alternative branches.',
+        example: 'conditional if="loading"\n  handler <<<\n    <Spinner />\n  >>>\n  elseif expr="error"\n    handler <<<\n      <Error msg={error} />\n    >>>\n  else\n    handler <<<\n      <Content />\n    >>>',
         props: {
             if: { required: true, kind: 'rawExpr' },
         },
+        // No allowedChildren: conditional must remain permissive because
+        // `generateConditional` also wraps arbitrary core nodes when used outside
+        // a render block (e.g. `conditional if=isAdmin` with `type`/`config` kids).
+    },
+    elseif: {
+        description: 'Alternative branch inside a `conditional` — matched when the preceding branches are falsy and `expr` is truthy.',
+        example: 'elseif expr="error"\n  handler <<<\n    <Error msg={error} />\n  >>>',
+        props: {
+            expr: { required: true, kind: 'rawExpr' },
+        },
+    },
+    else: {
+        description: 'Fallback branch inside a `conditional` — rendered when no preceding branch matched.',
+        example: 'else\n  handler <<<\n    <Content />\n  >>>',
+        props: {},
     },
     // ── Express / Backend nodes ───────────────────────────────────────────
     server: {
@@ -660,6 +1211,7 @@ export const NODE_SCHEMAS = {
             'error',
             'guard',
             'derive',
+            'fmt',
             'branch',
             'each',
             'collect',
@@ -939,9 +1491,12 @@ export const NODE_SCHEMAS = {
         example: 'fetch name=posts url="/api/posts" options="{ next: { revalidate: 60 } }"',
         props: {
             name: { required: true, kind: 'identifier' },
-            url: { required: true, kind: 'rawExpr' },
+            // When a `handler <<<>>>` child is provided the handler body is the loader,
+            // so `url` becomes irrelevant and is no longer required.
+            url: { kind: 'rawExpr' },
             options: { kind: 'rawExpr' },
         },
+        allowedChildren: ['handler'],
     },
     generateMetadata: {
         description: 'Next.js generateMetadata export — async function for dynamic page metadata',
@@ -1065,10 +1620,12 @@ export const NODE_SCHEMAS = {
         },
     },
     render: {
-        description: 'Render function — JSX output block for a component or hook',
-        example: 'render\n  handler <<<\n    return <div>{children}</div>\n  >>>',
-        props: {},
-        allowedChildren: ['handler'],
+        description: 'Render function — JSX output block for a component or hook. Accepts a raw `handler` block OR declarative KERN children (`each`, `conditional`, `local`) that compose into a JSX tree. Optional `wrapper="<Tag attrs>"` prop emits that tag as the outer element around the composed children (replaces the default `<>...</>` Fragment). `local` children emit `const name = expr;` bindings at the enclosing screen-function scope before the return — use them for shared pre-compute that multiple sibling `each`/`conditional`/`handler` nodes read.',
+        example: 'render wrapper="<Box paddingX={1}>"\n  local name=visible expr="items.slice(start, start + pageSize)"\n  each name=item in=visible\n    handler <<< <Text>{item.label}</Text> >>>',
+        props: {
+            wrapper: { kind: 'string' },
+        },
+        allowedChildren: ['handler', 'each', 'conditional', 'local'],
     },
     template: {
         description: 'Reusable template with named slots — defines a composable layout pattern',