@kernlang/core 3.3.9 → 3.4.1

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,10 @@ 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' },
+            coverage: { kind: 'boolean' },
         },
-        allowedChildren: ['describe', 'it', 'handler'],
+        allowedChildren: ['describe', 'it', 'expect', 'fixture', 'mock', 'handler'],
     },
     event: {
         description: 'Typed event with payload type children',
@@ -253,17 +314,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,6 +438,8 @@ 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: {
@@ -858,7 +1005,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.',
@@ -878,6 +1025,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' },
@@ -936,11 +1086,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' },
         },
     },
@@ -1041,7 +1192,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',
@@ -1051,7 +1202,7 @@ export const NODE_SCHEMAS = {
             deps: { kind: 'string' },
             once: { kind: 'boolean' },
         },
-        allowedChildren: ['prop', 'handler', 'cleanup'],
+        allowedChildren: ['prop', 'handler', 'cleanup', 'trigger', 'recover'],
     },
     // ── Web / UI node types ──────────────────────────────────────────────
     page: {
@@ -1318,7 +1469,22 @@ export const NODE_SCHEMAS = {
         props: {
             name: { required: true, kind: 'identifier' },
         },
-        allowedChildren: ['param', 'handler', 'description', 'guard', 'sampling', 'elicitation'],
+        allowedChildren: [
+            'param',
+            'handler',
+            'description',
+            'guard',
+            'sampling',
+            'elicitation',
+            'derive',
+            'effect',
+            'respond',
+            'branch',
+            'each',
+            'collect',
+            'destructure',
+            'partition',
+        ],
     },
     resource: {
         description: 'MCP resource — a data source exposed to AI agents via URI. Use {variables} for templated URIs.',
@@ -1330,18 +1496,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',
@@ -1508,6 +1698,10 @@ export const NODE_SCHEMAS = {
             kind: { kind: 'identifier' },
             on: { kind: 'string' },
             from: { kind: 'string' },
+            expr: { kind: 'rawExpr' },
+            query: { kind: 'string' },
+            url: { kind: 'string' },
+            call: { kind: 'rawExpr' },
         },
         allowedChildren: ['handler'],
     },
@@ -1595,6 +1789,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'],
     },
@@ -1607,7 +1803,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',
@@ -1961,8 +2157,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)',
@@ -1984,13 +2183,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', 'mock', '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', 'case', 'fixture', 'mock', 'handler'],
     },
     // Ground layer — semantic reasoning
     path: {
@@ -2028,14 +2227,110 @@ 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 route="GET /api/users" with={{({ query: { role: "admin" } })}} returns={{adminUsers}}\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' },
+            route: { kind: 'string' },
+            tool: { kind: 'identifier' },
+            effect: { kind: 'identifier' },
+            mock: { kind: 'identifier' },
+            called: { kind: 'number' },
+            import: { kind: 'string' },
+            source: { kind: 'string' },
+            unmapped: { kind: 'number' },
+            allowWarnings: { kind: 'boolean' },
+            args: { kind: 'rawExpr' },
+            with: { kind: 'rawExpr' },
+            input: { kind: 'rawExpr' },
+            equals: { kind: 'rawExpr' },
+            returns: { kind: 'rawExpr' },
+            recovers: { kind: 'boolean' },
+            fallback: { kind: 'rawExpr' },
+            codegen: { kind: 'boolean' },
+            decompile: { kind: 'boolean' },
+            roundtrip: { kind: 'boolean' },
+            contains: { kind: 'string' },
+            notContains: { kind: 'string' },
+            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' },
+        },
+    },
+    case: {
+        description: 'Native test table row — supplies input and expected output for a parent expect assertion',
+        example: 'case name=admin with={{({ query: { role: "admin" } })}} returns={{adminUsers}}\nexpect route="GET /api/users"',
+        props: {
+            name: { kind: 'string' },
+            args: { kind: 'rawExpr' },
+            with: { kind: 'rawExpr' },
+            input: { kind: 'rawExpr' },
+            equals: { kind: 'rawExpr' },
+            returns: { kind: 'rawExpr' },
+            recovers: { kind: 'boolean' },
+            fallback: { kind: 'rawExpr' },
+            matches: { kind: 'string' },
+            throws: { kind: 'string' },
+            called: { kind: 'number' },
+            message: { kind: 'string' },
+            severity: { kind: 'identifier' },
+        },
+        allowedChildren: ['fixture', 'mock'],
+    },
+    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' },
+        },
+    },
+    mock: {
+        description: 'Native test mock — replaces a scoped KERN effect with deterministic runtime data',
+        example: 'mock effect=fetchUsers returns={{users}}\nmock effect=fetchUsers throws=NetworkError',
+        props: {
+            effect: { required: true, kind: 'identifier' },
+            returns: { kind: 'rawExpr' },
+            throws: { kind: 'string' },
+        },
     },
     recover: {
         description: 'Recovery handler — runs when a parent node fails',
         example: 'recover\n  handler <<<\n    return fallbackValue;\n  >>>',
-        props: {},
+        props: {
+            retry: { kind: 'number' },
+            fallback: { kind: 'rawExpr' },
+        },
         allowedChildren: ['handler'],
     },
     strategy: {
@@ -2124,6 +2419,232 @@ function checkCrossProps(node, violations) {
             col: node.loc?.col,
         });
     }
+    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: '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 hasRuntimeWorkflow = 'route' in props || 'tool' in props || 'effect' in props;
+        const hasMockCallAssertion = 'mock' in props || 'called' in props;
+        const hasCodegenAssertion = 'codegen' in props;
+        const hasDecompileAssertion = 'decompile' in props;
+        const hasImportAssertion = 'import' in props;
+        const hasRoundtripAssertion = 'roundtrip' in props;
+        const hasPreset = 'preset' in props;
+        const hasNodeShape = 'node' in props;
+        const hasNegativeInvariant = 'no' in props;
+        const hasPositiveInvariant = 'has' in props;
+        const hasGuardExhaustiveness = 'guard' in props;
+        const hasMachineTransition = 'transition' in props;
+        const hasMachineReachability = 'reaches' in props ||
+            ('machine' in props && !hasNegativeInvariant && !hasPositiveInvariant && !hasMachineTransition);
+        if (!hasRuntimeAssertion &&
+            !hasRuntimeBehavior &&
+            !hasRuntimeWorkflow &&
+            !hasMockCallAssertion &&
+            !hasCodegenAssertion &&
+            !hasDecompileAssertion &&
+            !hasImportAssertion &&
+            !hasRoundtripAssertion &&
+            !hasPreset &&
+            !hasNodeShape &&
+            !hasMachineTransition &&
+            !hasMachineReachability &&
+            !hasNegativeInvariant &&
+            !hasPositiveInvariant &&
+            !hasGuardExhaustiveness) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' requires 'expr', 'fn', 'derive', 'route', 'tool', 'effect', 'mock' call count, 'codegen', 'decompile', 'import', 'roundtrip', 'preset', 'node', 'machine' reachability, machine transition, 'no', 'has', or 'guard'",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasCodegenAssertion && !('contains' in props) && !('notContains' in props) && !('matches' in props)) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect codegen' requires contains=, notContains=, or matches=",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasDecompileAssertion && !('contains' in props) && !('notContains' in props) && !('matches' in props)) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect decompile' requires contains=, notContains=, or matches=",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasImportAssertion) {
+            const importValue = props.import === undefined ? '' : String(props.import);
+            const hasPath = (importValue !== '' && importValue !== 'true') || 'from' in props || 'source' in props;
+            const hasTextAssertion = 'contains' in props || 'notContains' in props || 'matches' in props;
+            const hasUnmappedAssertion = 'unmapped' in props || props.no === 'unmapped';
+            if (!hasPath) {
+                violations.push({
+                    nodeType: 'expect',
+                    message: "'expect import' requires import=<ts-file>, from=<ts-file>, or source=<typescript>",
+                    line: node.loc?.line,
+                    col: node.loc?.col,
+                });
+            }
+            if (!hasTextAssertion && !hasRoundtripAssertion && !hasUnmappedAssertion) {
+                violations.push({
+                    nodeType: 'expect',
+                    message: "'expect import' requires contains=, notContains=, matches=, roundtrip=true, unmapped=<count>, or no=unmapped",
+                    line: node.loc?.line,
+                    col: node.loc?.col,
+                });
+            }
+        }
+        if (hasNegativeInvariant && hasPositiveInvariant) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine no=<invariant> and has=<invariant>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (Number('fn' in props) +
+            Number('derive' in props) +
+            Number('route' in props) +
+            Number('tool' in props) +
+            Number('effect' in props) +
+            Number('mock' in props) >
+            1) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine fn=<name>, derive=<name>, route=<spec>, tool=<name>, effect=<name>, and mock=<name>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if ((hasRuntimeBehavior || hasRuntimeWorkflow || hasMockCallAssertion) && hasRuntimeAssertion) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' cannot combine fn/derive/route/tool/effect/mock behavioral assertions with expr={{...}}",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasMockCallAssertion && (!('mock' in props) || !('called' in props))) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' mock call assertions require both mock=<effect> and called=<count>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if ('called' in props) {
+            const rawCalled = props.called;
+            const called = Number(props.called);
+            if (rawCalled === '' || !Number.isInteger(called) || called < 0) {
+                violations.push({
+                    nodeType: 'expect',
+                    message: "'expect' mock call assertions require called=<non-negative integer>",
+                    line: node.loc?.line,
+                    col: node.loc?.col,
+                });
+            }
+        }
+        if (hasMockCallAssertion &&
+            ['args', 'with', 'input', 'equals', 'returns', 'recovers', 'fallback', 'matches', 'throws'].some((prop) => prop in props)) {
+            violations.push({
+                nodeType: 'expect',
+                message: "'expect' mock call assertions cannot combine with runtime value/result props",
+                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 === 'mock') {
+        const hasReturns = 'returns' in props;
+        const hasThrows = 'throws' in props;
+        if (!hasReturns && !hasThrows) {
+            violations.push({
+                nodeType: 'mock',
+                message: "'mock' requires either returns={{...}} or throws=<ErrorName>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+        if (hasReturns && hasThrows) {
+            violations.push({
+                nodeType: 'mock',
+                message: "'mock' must not combine returns={{...}} and throws=<ErrorName>",
+                line: node.loc?.line,
+                col: node.loc?.col,
+            });
+        }
+    }
     if (node.type === 'fmt') {
         const returnMode = isTruthyProp(props.return);
         if (returnMode && 'name' in props) {
@@ -2191,7 +2712,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 } : {}),
     };
 }