@kernlang/core 3.3.8 → 3.4.0

package/dist/schema.js

@@ -29,24 +29,46 @@ export const NODE_SCHEMAS = {
         },
     },
     type: {
-        description: 'TypeScript type alias — union of string literals or alias to another type',
+        description: 'TypeScript type alias — union of string literals, or alias to another type (including tuple types like [string, number]). Use generics="<T>" for parameterised aliases.',
         example: 'type name=Status values="active|inactive|banned"',
         props: {
             name: { required: true, kind: 'identifier' },
             values: { kind: 'string' },
             alias: { kind: 'rawExpr' },
+            generics: { kind: 'rawExpr' },
             export: { kind: 'boolean' },
         },
     },
     interface: {
-        description: 'TypeScript interface with typed fields',
+        description: 'TypeScript interface with typed fields. Use generics="<T>" for parameterised interfaces.',
         example: 'interface name=User export=true\n  field name=id type=string\n  field name=email type=string',
         props: {
             name: { required: true, kind: 'identifier' },
             extends: { kind: 'typeAnnotation' },
+            generics: { kind: 'rawExpr' },
             export: { kind: 'boolean' },
         },
-        allowedChildren: ['field'],
+        allowedChildren: ['field', 'indexer'],
+    },
+    indexer: {
+        description: 'Index signature for an interface — [keyName: keyType]: type',
+        example: 'indexer keyName=key keyType=string type=Value',
+        props: {
+            keyName: { kind: 'identifier' },
+            keyType: { required: true, kind: 'typeAnnotation' },
+            type: { required: true, kind: 'typeAnnotation' },
+            readonly: { kind: 'boolean' },
+        },
+    },
+    overload: {
+        description: 'Function overload signature — declared as a child of fn. Each overload emits a TS overload declaration before the implementation signature.',
+        example: 'overload params="a:number,b:number" returns=number',
+        props: {
+            params: { kind: 'string' },
+            returns: { kind: 'typeAnnotation' },
+            generics: { kind: 'rawExpr' },
+        },
+        allowedChildren: ['param'],
     },
     union: {
         description: 'Discriminated union type with variants, each having their own fields',
@@ -55,9 +77,33 @@ export const NODE_SCHEMAS = {
             name: { required: true, kind: 'identifier' },
             discriminant: { required: true, kind: 'identifier' },
             export: { kind: 'boolean' },
+            // Slice 4 — `kind=result|option` opts the union into the Result/Option
+            // shape (see docs/language/result-option-spec.md). Default (unspecified)
+            // is a regular discriminated union, identical to the slice 3 behaviour.
+            // Validated by parser-validate-union-kind.ts.
+            kind: { kind: 'string' },
         },
         allowedChildren: ['variant'],
     },
+    enum: {
+        description: 'TypeScript enum — numeric (auto-incremented) via values="A|B|C", or string-valued via member children',
+        example: 'enum name=Status values="Pending|Active|Done"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            values: { kind: 'string' },
+            const: { kind: 'boolean' },
+            export: { kind: 'boolean' },
+        },
+        allowedChildren: ['member'],
+    },
+    member: {
+        description: 'Enum member with explicit value (for string-valued or computed enums)',
+        example: 'member name=Up value="UP"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            value: { kind: 'expression' },
+        },
+    },
     variant: {
         description: 'A case within a discriminated union. Use name= for inline variants with fields, or type= to reference an existing interface.',
         example: 'variant name=circle\n  field name=radius type=number',
@@ -74,6 +120,12 @@ export const NODE_SCHEMAS = {
             name: { required: true, kind: 'identifier' },
             type: { kind: 'typeAnnotation' },
             optional: { kind: 'boolean' },
+            // Slice 3b — `value` is the native ValueIR-canonicalised initializer;
+            // `default` remains as the rawExpr passthrough escape hatch. `value`
+            // takes precedence when both are set. Either marks the field as having
+            // an initializer (which makes the interface-side property optional in
+            // config emit).
+            value: { kind: 'expression' },
             default: { kind: 'rawExpr' },
             private: { kind: 'boolean' },
             readonly: { kind: 'boolean' },
@@ -86,6 +138,7 @@ export const NODE_SCHEMAS = {
         props: {
             name: { required: true, kind: 'identifier' },
             implements: { kind: 'typeAnnotation' },
+            generics: { kind: 'rawExpr' },
             export: { kind: 'boolean' },
         },
         allowedChildren: ['field', 'method', 'constructor', 'singleton', 'getter', 'setter'],
@@ -98,6 +151,7 @@ export const NODE_SCHEMAS = {
             extends: { kind: 'typeAnnotation' },
             implements: { kind: 'typeAnnotation' },
             abstract: { kind: 'boolean' },
+            generics: { kind: 'rawExpr' },
             export: { kind: 'boolean' },
         },
         allowedChildren: ['field', 'method', 'constructor', 'singleton', 'getter', 'setter'],
@@ -113,8 +167,9 @@ export const NODE_SCHEMAS = {
             stream: { kind: 'boolean' },
             private: { kind: 'boolean' },
             static: { kind: 'boolean' },
+            generics: { kind: 'rawExpr' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'param'],
     },
     getter: {
         description: 'A getter accessor within a class or service — emits `get name(): T { body }`.',
@@ -136,7 +191,7 @@ export const NODE_SCHEMAS = {
             private: { kind: 'boolean' },
             static: { kind: 'boolean' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'param'],
     },
     fn: {
         description: 'Standalone function — the most common code unit in KERN',
@@ -149,8 +204,12 @@ export const NODE_SCHEMAS = {
             stream: { kind: 'boolean' },
             export: { kind: 'boolean' },
             expr: { kind: 'rawExpr' },
+            generics: { kind: 'rawExpr' },
+            // Slice 6 — effects=pure declares the body has no observable side effects.
+            // Validated by parser-validate-effects.ts; see docs/language/effects-pure-spec.md.
+            effects: { kind: 'string' },
         },
-        allowedChildren: ['handler', 'signal', 'cleanup'],
+        allowedChildren: ['handler', 'signal', 'cleanup', 'overload', 'param'],
     },
     machine: {
         description: 'State machine with states and guarded transitions — 12 lines of KERN generates 140+ lines of TypeScript',
@@ -193,7 +252,7 @@ export const NODE_SCHEMAS = {
             params: { kind: 'string' },
             guard: { kind: 'rawExpr' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'param'],
     },
     error: {
         description: 'Custom error class extending a base error, with typed fields',
@@ -231,8 +290,9 @@ export const NODE_SCHEMAS = {
         example: 'test name="AuthService"\n  describe name="login"\n    it name="rejects invalid email"',
         props: {
             name: { required: true, kind: 'string' },
+            target: { kind: 'string' },
         },
-        allowedChildren: ['describe', 'it', 'handler'],
+        allowedChildren: ['describe', 'it', 'expect', 'fixture', 'handler'],
     },
     event: {
         description: 'Typed event with payload type children',
@@ -253,17 +313,101 @@ export const NODE_SCHEMAS = {
             types: { kind: 'boolean' },
         },
     },
+    use: {
+        description: 'Cross-`.kern` symbol resolution. Parent of `from` children — one per imported binding. Compositional shape mirrors enum/member, class/method.',
+        example: 'use path="./helper.kern"\n  from name=foo\n  from name=bar as=baz',
+        props: {
+            path: { required: true, kind: 'importPath' },
+        },
+        allowedChildren: ['from'],
+    },
+    from: {
+        description: 'Single binding in a `use` block. `as=` aliases the local name; `export=true` re-exports.',
+        example: 'from name=foo as=bar export=true',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            as: { kind: 'identifier' },
+            export: { kind: 'boolean' },
+        },
+    },
     const: {
         description: 'Constant declaration with optional type and value or handler body',
         example: 'const name=MAX_RETRIES type=number value=3 export=true',
         props: {
             name: { required: true, kind: 'identifier' },
             type: { kind: 'typeAnnotation' },
-            value: { kind: 'rawExpr' },
+            value: { kind: 'expression' },
             export: { kind: 'boolean' },
         },
         allowedChildren: ['handler'],
     },
+    destructure: {
+        description: 'Native destructuring statement — emits `const {a,b} = expr;` (object pattern with `binding` children) or `const [x,y] = expr;` (array pattern with `element` children). For complex patterns (rest `...`, defaults `=v`, nested `{a:{b}}`), use the `expr={{...}}` escape hatch which carries the raw TS statement verbatim. Slice 3d.',
+        example: 'destructure kind=const source=user\n  binding name=id\n  binding name=email key=mail',
+        props: {
+            kind: { kind: 'string' },
+            source: { kind: 'expression' },
+            type: { kind: 'typeAnnotation' },
+            export: { kind: 'boolean' },
+            expr: { kind: 'rawExpr' },
+        },
+        allowedChildren: ['binding', 'element'],
+    },
+    binding: {
+        description: 'Object-destructuring binding inside a `destructure` parent. `name` is the local binding; `key` is the optional property key when renaming, e.g. `{a: foo}` → `binding name=foo key=a`. Slice 3d.',
+        example: 'binding name=foo key=a',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            key: { kind: 'identifier' },
+        },
+    },
+    element: {
+        description: 'Array-destructuring element inside a `destructure` parent. `index` is the ordered position (zero-based). Slice 3d.',
+        example: 'element name=first index=0',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            index: { kind: 'string' },
+        },
+    },
+    mapLit: {
+        description: 'Native Map<K,V> literal — emits `const name: Type = new Map([[k1, v1], [k2, v2]]);` from `mapEntry` children. For complex shapes (computed keys, conditional entries, spread), use the `expr={{...}}` escape hatch which carries the raw TS statement verbatim. Slice 3e.',
+        example: 'mapLit name=cache type="Map<string, number>"\n  mapEntry key="foo" value=1\n  mapEntry key="bar" value=2',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            type: { kind: 'typeAnnotation' },
+            kind: { kind: 'string' },
+            export: { kind: 'boolean' },
+            expr: { kind: 'rawExpr' },
+        },
+        allowedChildren: ['mapEntry'],
+    },
+    mapEntry: {
+        description: 'Map-literal entry inside a `mapLit` parent. `key` and `value` are both expression-typed and ValueIR-canonicalised. Slice 3e.',
+        example: 'mapEntry key="foo" value=1',
+        props: {
+            key: { required: true, kind: 'expression' },
+            value: { required: true, kind: 'expression' },
+        },
+    },
+    setLit: {
+        description: 'Native Set<T> literal — emits `const name: Type = new Set([v1, v2]);` from `setItem` children. For complex shapes (conditional members, spread), use the `expr={{...}}` escape hatch which carries the raw TS statement verbatim. Slice 3e.',
+        example: 'setLit name=allowed type="Set<string>"\n  setItem value="admin"\n  setItem value="user"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            type: { kind: 'typeAnnotation' },
+            kind: { kind: 'string' },
+            export: { kind: 'boolean' },
+            expr: { kind: 'rawExpr' },
+        },
+        allowedChildren: ['setItem'],
+    },
+    setItem: {
+        description: 'Set-literal item inside a `setLit` parent. `value` is expression-typed and ValueIR-canonicalised. Slice 3e.',
+        example: 'setItem value="admin"',
+        props: {
+            value: { required: true, kind: 'expression' },
+        },
+    },
     on: {
         description: 'Event listener — binds a handler to a named event',
         example: 'on event=click handler=handleClick',
@@ -293,10 +437,12 @@ export const NODE_SCHEMAS = {
             expr: { required: true, kind: 'rawExpr' },
             type: { kind: 'typeAnnotation' },
             export: { kind: 'boolean' },
+            // Slice 6 — see fn schema above.
+            effects: { kind: 'string' },
         },
     },
     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. Set `return=true` to emit `return \\`...\\`;` inside a `fn` body (in which case `name` must be omitted).',
+        description: 'Formatted string — declarative template literal. The `template` body is emitted verbatim between backticks, so `${expr}` placeholders interpolate normally. Three positional modes: (1) binding form `fmt name=X template=...` emits `const X = \\`...\\`;` at the current scope; (2) return form `fmt return=true template=...` emits `return \\`...\\`;` inside a `fn` body (name must be omitted); (3) inline-JSX form `fmt template=...` (no name, no return=true) appears as a direct child of `render`/`group` and emits `{\\`...\\`}` as a JSX expression — use this to replace handler-wrapped `{\\`${x} files\\`}` text inside composed renders.',
         example: 'fmt name=label template="${count} files over ${totalMb.toFixed(1)} MB"',
         props: {
             name: { required: false, kind: 'identifier' },
@@ -322,6 +468,31 @@ export const NODE_SCHEMAS = {
         },
         allowedChildren: ['handler', 'recover'],
     },
+    try: {
+        description: 'Declarative async orchestration — a sequential try/catch where each `step name=X await="expr"` child lowers to `const X = await (expr);`. Step bindings are in scope for later steps and the optional `handler` body (post-steps), but NOT inside the `catch` block — JS `const` declared inside a `try` block is not visible to `catch` (use closure-scoped `derive`/`local` if the catch needs to reference earlier values). Use this instead of a raw handler to express the "fetch → parse → store, fall back on error" shape declaratively.',
+        example: 'try name=loadUser\n  step name=res await="fetch(`/api/users/${id}`)"\n  step name=body await="res.json()"\n  handler <<<\n    setUser(body);\n  >>>\n  catch name=err\n    handler <<<\n      setUser(null);\n    >>>',
+        props: {
+            name: { kind: 'identifier' },
+        },
+        allowedChildren: ['step', 'handler', 'catch'],
+    },
+    step: {
+        description: 'Sequential awaited step inside a `try` block — `step name=X await="expr"` emits `const X = await (expr);` in order with its siblings. Must be a direct child of `try`. Earlier step names are in scope for later ones.',
+        example: 'step name=res await="fetch(url)"',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            await: { required: true, kind: 'rawExpr' },
+            type: { kind: 'typeAnnotation' },
+        },
+    },
+    catch: {
+        description: 'Catch clause of a `try` block — binds the thrown value to `name` (default `e`) and runs its `handler` body. Must be a direct child of `try`. Without a `catch`, a `try` still surrounds its steps + handler but any rejection propagates unchanged.',
+        example: 'catch name=err\n  handler <<<\n    setError(err);\n  >>>',
+        props: {
+            name: { kind: 'identifier' },
+        },
+        allowedChildren: ['handler'],
+    },
     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"',
@@ -833,7 +1004,7 @@ export const NODE_SCHEMAS = {
             reversible: { kind: 'boolean' },
             export: { kind: 'boolean' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'param'],
     },
     actionRegistry: {
         description: 'Calls an imported registration function with a map of string-keyed async action handlers. Emits `target({ key: async (...) => body, ... })` directly — no IIFE wrapper.',
@@ -853,6 +1024,9 @@ export const NODE_SCHEMAS = {
             confidence: { kind: 'number' },
             kind: { kind: 'identifier' },
             type: { kind: 'identifier' },
+            covers: { kind: 'string' },
+            over: { kind: 'identifier' },
+            union: { kind: 'identifier' },
             param: { kind: 'identifier' },
             field: { kind: 'identifier' },
             target: { kind: 'identifier' },
@@ -911,11 +1085,12 @@ export const NODE_SCHEMAS = {
         // 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"',
+        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. Provide either `value=` (native expression form, ValueIR-canonicalised — slice 3a) or `expr=` (raw passthrough escape hatch).',
+        example: 'let name=idx value=i+1',
         props: {
             name: { required: true, kind: 'identifier' },
-            expr: { required: true, kind: 'rawExpr' },
+            value: { kind: 'expression' },
+            expr: { kind: 'rawExpr' },
             type: { kind: 'typeAnnotation' },
         },
     },
@@ -1016,7 +1191,7 @@ export const NODE_SCHEMAS = {
             params: { kind: 'string' },
             returns: { kind: 'typeAnnotation' },
         },
-        allowedChildren: ['handler', 'memo', 'callback', 'ref', 'effect'],
+        allowedChildren: ['handler', 'memo', 'callback', 'ref', 'effect', 'param'],
     },
     effect: {
         description: 'React useEffect — side effect with dependency tracking',
@@ -1305,18 +1480,42 @@ export const NODE_SCHEMAS = {
         allowedChildren: ['param', 'handler', 'description', 'guard'],
     },
     param: {
-        description: 'Parameter definition for a tool, resource, or prompt — name, type, required, default, and description',
+        description: 'Parameter definition. Used in two contexts: (a) MCP tool/resource/prompt params (description/required/min/max apply); (b) fn/method/constructor/etc. parameter defaults via slice 3c — value flows through ValueIR canonicalisation (mirrors slice 1j const.value, 3a let.value, 3b field.value).',
         example: 'param name=query type=string required=true description="Search query"',
         props: {
-            name: { required: true, kind: 'identifier' },
-            type: { kind: 'identifier' },
+            // Slice 3c-extension #3: `name` is required UNLESS the param carries
+            // `binding`/`element` destructure children — destructured params encode
+            // the LHS pattern in the children, not in `name`. The required-OR-children
+            // invariant lives in `checkCrossProps` so `validateSchema` accepts both
+            // forms. Keeping the schema-level `required: true` here would reject the
+            // canonical destructured form emitted by the importer.
+            name: { kind: 'identifier' },
+            type: { kind: 'typeAnnotation' },
+            value: { kind: 'expression' },
             required: { kind: 'boolean' },
+            // Slice 3c-extension: TS-style optional `?` on the LHS, distinct from MCP
+            // `required`. When `optional=true`, codegen emits `name?: type` (with the
+            // `?` inside the parameter list) so callers may omit the argument.
+            optional: { kind: 'boolean' },
+            // Slice 3c-extension: TS-style variadic `...rest`. When `variadic=true`,
+            // codegen prepends `...` to the parameter name; the type should be an
+            // array (e.g. `string[]`). Variadic params can't have defaults — that's
+            // user error and TS will surface it at the call site.
+            variadic: { kind: 'boolean' },
             default: { kind: 'rawExpr' },
             description: { kind: 'string' },
             min: { kind: 'number' },
             max: { kind: 'number' },
         },
-        allowedChildren: ['guard', 'description'],
+        // Slice 3c-extension #3: TS-style destructured params via slice 3d's
+        // `binding` (object pattern) / `element` (array pattern) children. When
+        // present, codegen uses the pattern as the LHS instead of `name`, e.g.
+        //   param type="Point"
+        //     binding name=x
+        //     binding name=y
+        // → `{x, y}: Point`. Same node types as slice 3d destructure — no new
+        // node types needed. `name=` is omitted on destructured params.
+        allowedChildren: ['guard', 'description', 'binding', 'element'],
     },
     prompt: {
         description: 'MCP prompt template — a reusable system prompt exposed to AI agents',
@@ -1570,6 +1769,8 @@ export const NODE_SCHEMAS = {
         props: {
             name: { required: true, kind: 'identifier' },
             deps: { kind: 'string' },
+            // Slice 6 — see fn schema above.
+            effects: { kind: 'string' },
         },
         allowedChildren: ['handler'],
     },
@@ -1582,7 +1783,7 @@ export const NODE_SCHEMAS = {
             deps: { kind: 'string' },
             async: { kind: 'boolean' },
         },
-        allowedChildren: ['handler'],
+        allowedChildren: ['handler', 'param'],
     },
     ref: {
         description: 'React useRef — mutable ref object that persists across renders',
@@ -1626,7 +1827,7 @@ export const NODE_SCHEMAS = {
         props: {
             wrapper: { kind: 'string' },
         },
-        allowedChildren: ['handler', 'each', 'conditional', 'local', 'group'],
+        allowedChildren: ['handler', 'each', 'conditional', 'local', 'group', 'fmt'],
     },
     group: {
         description: 'Nested JSX wrapper — emits an inner tag around a subset of a `render` block\'s children. `group` carries its own `wrapper="<Tag attrs>"` prop (required) and may hold `each`, `conditional`, `handler`, or further nested `group` children. Use it to build multi-level JSX trees (e.g. `<Box><Header /><Box paddingLeft>…</Box></Box>`) without dropping into a raw handler. Must appear as a direct or transitive child of `render`.',
@@ -1634,7 +1835,7 @@ export const NODE_SCHEMAS = {
         props: {
             wrapper: { required: true, kind: 'string' },
         },
-        allowedChildren: ['handler', 'each', 'conditional', 'group'],
+        allowedChildren: ['handler', 'each', 'conditional', 'group', 'fmt'],
     },
     template: {
         description: 'Reusable template with named slots — defines a composable layout pattern',
@@ -1936,8 +2137,11 @@ export const NODE_SCHEMAS = {
     constructor: {
         description: 'Constructor for a service — runs on instantiation',
         example: 'constructor params="size:number"\n  handler <<<\n    this.data = new Map();\n  >>>',
-        props: { params: { kind: 'string' } },
-        allowedChildren: ['handler'],
+        props: {
+            params: { kind: 'string' },
+            generics: { kind: 'rawExpr' },
+        },
+        allowedChildren: ['handler', 'param'],
     },
     cleanup: {
         description: 'Cleanup handler — runs on teardown (useEffect return, signal dispose)',
@@ -1959,13 +2163,13 @@ export const NODE_SCHEMAS = {
         description: 'Test suite — groups related test cases',
         example: 'describe name="UserService"\n  it name="creates a user"\n    handler <<<\n      expect(createUser()).toBeDefined();\n    >>>',
         props: { name: { required: true, kind: 'string' } },
-        allowedChildren: ['it', 'describe', 'handler'],
+        allowedChildren: ['it', 'describe', 'expect', 'fixture', 'handler'],
     },
     it: {
         description: 'Test case — single test assertion',
         example: 'it name="returns 200 on success"\n  handler <<<\n    expect(res.status).toBe(200);\n  >>>',
         props: { name: { required: true, kind: 'string' } },
-        allowedChildren: ['handler'],
+        allowedChildren: ['expect', 'fixture', 'handler'],
     },
     // Ground layer — semantic reasoning
     path: {
@@ -2003,9 +2207,55 @@ export const NODE_SCHEMAS = {
         props: { fn: { kind: 'identifier' }, to: { kind: 'rawExpr' } },
     },
     expect: {
-        description: 'Assertion — declare an expected condition at runtime',
-        example: 'expect expr={{items.length > 0}} message="Items must not be empty"',
-        props: { expr: { required: true, kind: 'rawExpr' }, message: { kind: 'string' } },
+        description: 'Assertion — declare an expected runtime condition or KERN structural invariant',
+        example: 'expect expr={{items.length > 0}} message="Items must not be empty"\nexpect machine=Order reaches=paid via=confirm,capture\nexpect machine=Order transition=capture from=confirmed to=paid\nexpect node=interface name=User child=field count=3\nexpect no=deriveCycles',
+        props: {
+            expr: { kind: 'rawExpr' },
+            fn: { kind: 'identifier' },
+            derive: { kind: 'identifier' },
+            args: { kind: 'rawExpr' },
+            with: { kind: 'rawExpr' },
+            equals: { kind: 'rawExpr' },
+            matches: { kind: 'string' },
+            throws: { kind: 'string' },
+            message: { kind: 'string' },
+            preset: { kind: 'identifier' },
+            severity: { kind: 'identifier' },
+            node: { kind: 'identifier' },
+            name: { kind: 'string' },
+            within: { kind: 'string' },
+            child: { kind: 'identifier' },
+            childName: { kind: 'string' },
+            prop: { kind: 'identifier' },
+            is: { kind: 'string' },
+            count: { kind: 'number' },
+            machine: { kind: 'identifier' },
+            transition: { kind: 'identifier' },
+            from: { kind: 'identifier' },
+            to: { kind: 'identifier' },
+            guarded: { kind: 'boolean' },
+            reaches: { kind: 'identifier' },
+            through: { kind: 'string' },
+            avoid: { kind: 'string' },
+            avoids: { kind: 'string' },
+            maxSteps: { kind: 'number' },
+            via: { kind: 'string' },
+            no: { kind: 'identifier' },
+            guard: { kind: 'identifier' },
+            exhaustive: { kind: 'boolean' },
+            over: { kind: 'identifier' },
+            union: { kind: 'identifier' },
+            covers: { kind: 'string' },
+        },
+    },
+    fixture: {
+        description: 'Native test fixture — named runtime data available to scoped expect assertions',
+        example: 'fixture name=paidOrder value={{({ id: "ord_1", status: "paid" })}}',
+        props: {
+            name: { required: true, kind: 'identifier' },
+            value: { kind: 'rawExpr' },
+            expr: { kind: 'rawExpr' },
+        },
     },
     recover: {
         description: 'Recovery handler — runs when a parent node fails',
@@ -2099,24 +2349,129 @@ function checkCrossProps(node, violations) {
             col: node.loc?.col,
         });
     }
-    if (node.type === 'fmt') {
-        const returnMode = isTruthyProp(props.return);
-        if (returnMode && 'name' in props) {
+    if (node.type === 'param') {
+        // Slice 3c-extension #3: `param` requires `name=` UNLESS it carries
+        // `binding`/`element` destructure children — destructured params encode
+        // the LHS pattern in the children. Replaces the old prop-level
+        // `required: true` constraint which rejected the canonical destructured
+        // form emitted by importer/decompiler.
+        const hasName = 'name' in props;
+        const hasDestructure = (node.children ?? []).some((c) => c.type === 'binding' || c.type === 'element');
+        if (!hasName && !hasDestructure) {
             violations.push({
-                nodeType: 'fmt',
-                message: "'fmt' with return=true must not carry a 'name' prop (return-position emits `return \\`...\\`;`)",
+                nodeType: 'param',
+                message: "'param' requires either 'name' or destructure children ('binding'/'element')",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+    }
+    if (node.type === 'expect') {
+        const hasRuntimeAssertion = 'expr' in props;
+        const hasRuntimeBehavior = 'fn' in props || 'derive' in props;
+        const hasPreset = 'preset' in props;
+        const hasNodeShape = 'node' in props;
+        const hasNegativeInvariant = 'no' in props;
+        const hasGuardExhaustiveness = 'guard' in props;
+        const hasMachineTransition = 'transition' in props;
+        const hasMachineReachability = 'reaches' in props || ('machine' in props && !hasNegativeInvariant && !hasMachineTransition);
+        if (!hasRuntimeAssertion &&
+            !hasRuntimeBehavior &&
+            !hasPreset &&
+            !hasNodeShape &&
+            !hasMachineTransition &&
+            !hasMachineReachability &&
+            !hasNegativeInvariant &&
+            !hasGuardExhaustiveness) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' requires 'expr', 'fn', 'derive', 'preset', 'node', 'machine' reachability, machine transition, 'no', or 'guard'",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if ('fn' in props && 'derive' in props) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine fn=<name> and derive=<name>",
                 line: node.loc?.line,
                 col: node.loc?.col,
             });
         }
-        if (!returnMode && !('name' in props)) {
+        if (hasRuntimeBehavior && hasRuntimeAssertion) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine fn/derive behavioral assertions with expr={{...}}",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasMachineTransition && !('machine' in props)) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' machine transition assertions require machine=<name>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasMachineTransition && 'reaches' in props) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine machine transition assertions with reaches=<state>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasMachineReachability && (!('machine' in props) || !('reaches' in props))) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' machine reachability requires both 'machine' and 'reaches'",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasGuardExhaustiveness && props.exhaustive !== true && props.exhaustive !== 'true') {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' guard assertions require exhaustive=true",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+    }
+    if (node.type === 'fixture') {
+        const hasValue = 'value' in props;
+        const hasExpr = 'expr' in props;
+        if (!hasValue && !hasExpr) {
+            violations.push({
+                nodeType: 'fixture',
+                message: "'fixture' requires either value={{...}} or expr={{...}}",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasValue && hasExpr) {
+            violations.push({
+                nodeType: 'fixture',
+                message: "'fixture' must not combine value={{...}} and expr={{...}}",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+    }
+    if (node.type === 'fmt') {
+        const returnMode = isTruthyProp(props.return);
+        if (returnMode && 'name' in props) {
             violations.push({
                 nodeType: 'fmt',
-                message: "'fmt' requires a 'name' prop for binding form, or 'return=true' for return-position form",
+                message: "'fmt' with return=true must not carry a 'name' prop (return-position emits `return \\`...\\`;`)",
                 line: node.loc?.line,
                 col: node.loc?.col,
             });
         }
+        // Neither `name` nor `return=true` selects the inline-JSX form; that form
+        // is only valid inside `render`/`group` — the positional check lives in
+        // the semantic validator, which has ancestry context.
     }
 }
 function isTruthyProp(raw) {
@@ -2171,7 +2526,18 @@ export function exportSchemaJSON(runtime) {
         styleShorthands: { ...STYLE_SHORTHANDS },
         valueShorthands: { ...VALUE_SHORTHANDS },
         multilineBlockTypes: [...rt.multilineBlockTypes],
-        propKinds: ['identifier', 'typeAnnotation', 'importPath', 'rawExpr', 'rawBlock', 'string', 'boolean', 'number'],
+        propKinds: [
+            'identifier',
+            'typeAnnotation',
+            'importPath',
+            'rawExpr',
+            'rawBlock',
+            'string',
+            'boolean',
+            'number',
+            'expression',
+            'regex',
+        ],
         ...(evolvedTypes.length > 0 ? { evolvedTypes } : {}),
     };
 }