@jxsuite/schema 1.0.0 → 1.1.0

package/defs/expression-node.schema.ts

@@ -1,9 +1,10 @@
 export const expressionPointerSchema = {
   additionalProperties: false,
-  description: "A JSON Pointer $ref operand within an expression node.",
+  description:
+    "A JSON Pointer $ref operand within an expression node. $args/<name> resolves a named formula's parameter (callable entries only).",
   properties: {
     $ref: {
-      pattern: "^(\\$map/|\\$reduce/|event#/|#/|parent#/|window#/|document#/)",
+      pattern: "^(\\$map/|\\$reduce/|\\$args/|event#/|#/|parent#/|window#/|document#/)",
       type: "string",
     },
   },
@@ -18,8 +19,14 @@ export const expressionLiteralSchema = {
     { type: "boolean" },
     { type: "null" },
     { items: { $ref: "#/$defs/ExpressionOperand" }, type: "array" },
+    {
+      description:
+        "Plain-object literal (e.g. an Intl options bag). Objects carrying $ref or operator keys are pointers/nodes, never literals.",
+      not: { anyOf: [{ required: ["$ref"] }, { required: ["operator"] }] },
+      type: "object",
+    },
   ],
-  description: "A non-reactive operand: scalar or array of operands.",
+  description: "A non-reactive operand: scalar, plain-object literal, or array of operands.",
 } as const;
 
 export const expressionOperandSchema = {
@@ -34,7 +41,47 @@ export const expressionOperandSchema = {
 
 export const unaryOperatorSchema = { enum: ["!", "-"] } as const;
 export const binaryOperatorSchema = {
-  enum: ["+", "-", "*", "/", "%", "===", "!==", "<", "<=", ">", ">=", "&&", "||"],
+  enum: ["+", "-", "*", "/", "%", "===", "!==", "<", "<=", ">", ">=", "&&", "||", "??"],
+} as const;
+export const conditionalOperatorSchema = { const: "?:" } as const;
+export const switchOperatorSchema = { const: "switch" } as const;
+export const callOperatorSchema = { const: "call" } as const;
+export const pureMethodSchema = {
+  description:
+    "A genuine pure String.prototype / Array.prototype / Number.prototype method (spec §19.4d). The ES2023 change-by-copy family (toSorted, toReversed, toSpliced, with) stands in where mutation would otherwise occur. Receiver in target; value carries the argument (bare scalar) or argument list (array).",
+  enum: [
+    "includes",
+    "indexOf",
+    "lastIndexOf",
+    "join",
+    "slice",
+    "concat",
+    "at",
+    "flat",
+    "toSorted",
+    "toReversed",
+    "toSpliced",
+    "with",
+    "toUpperCase",
+    "toLowerCase",
+    "trim",
+    "trimStart",
+    "trimEnd",
+    "split",
+    "startsWith",
+    "endsWith",
+    "padStart",
+    "padEnd",
+    "replaceAll",
+    "repeat",
+    "charAt",
+    "normalize",
+    "toLocaleUpperCase",
+    "toLocaleLowerCase",
+    "toFixed",
+    "toPrecision",
+    "toLocaleString",
+  ],
 } as const;
 export const assignmentOperatorSchema = { enum: ["=", "+=", "-=", "*=", "/="] } as const;
 export const noArgMethodSchema = { enum: ["pop", "shift"] } as const;
@@ -99,24 +146,80 @@ export const expressionNodeSchema = {
     {
       properties: {
         operator: { $ref: "#/$defs/ReduceMethod" },
-        target: { $ref: "#/$defs/ExpressionPointer" },
+        target: {
+          anyOf: [{ $ref: "#/$defs/ExpressionPointer" }, { $ref: "#/$defs/ExpressionNode" }],
+        },
         value: { $ref: "#/$defs/ExpressionNode" },
       },
       required: ["operator", "value", "initial"],
-      title: "reduce — pure fold; per-item expression in value, seed in initial",
+      title: "reduce — pure fold over a pointer or derived array; seed in initial",
     },
     {
       not: { required: ["initial"] },
       properties: {
         operator: { $ref: "#/$defs/MapFilterMethod" },
-        target: { $ref: "#/$defs/ExpressionPointer" },
+        target: {
+          anyOf: [{ $ref: "#/$defs/ExpressionPointer" }, { $ref: "#/$defs/ExpressionNode" }],
+        },
         value: { $ref: "#/$defs/ExpressionNode" },
       },
       required: ["operator", "value"],
-      title: "map / filter — pure; per-item expression in value, no initial",
+      title: "map / filter — pure over a pointer or derived array; per-item expression in value",
+    },
+    {
+      description:
+        "The ECMAScript conditional (ternary) operator, pure: target is the test, value the consequent, initial the alternate (the reduce precedent for repurposing initial). Chain else-if by nesting another ?: node in initial.",
+      properties: { operator: { $ref: "#/$defs/ConditionalOperator" } },
+      required: ["operator", "value", "initial"],
+      title: "?: — pure conditional; test in target, consequent in value, alternate in initial",
+    },
+    {
+      description:
+        "Value-keyed multiway selection, pure: target is the discriminant (matched against case keys by its string form, like element-level $switch), cases maps matched values to result operands, default is the operand when no case matches (result is undefined without it). Condition-chain branching composes from nested ?: nodes instead.",
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      properties: {
+        cases: {
+          additionalProperties: { $ref: "#/$defs/ExpressionOperand" },
+          type: "object",
+        },
+        default: { $ref: "#/$defs/ExpressionOperand" },
+        operator: { $ref: "#/$defs/SwitchOperator" },
+      },
+      required: ["operator", "cases"],
+      title:
+        "switch — pure value-keyed selection; discriminant in target, results in cases/default",
+    },
+    {
+      description:
+        "A pure standard-library method call: target is the receiver (any operand — never mutated; change-by-copy names replace the mutating originals), value the optional argument (bare scalar) or argument list (array). A missing receiver or method yields undefined, matching null-safe path reads.",
+      not: { required: ["initial"] },
+      properties: { operator: { $ref: "#/$defs/PureMethod" } },
+      required: ["operator"],
+      title: "Pure method — genuine prototype methods; receiver in target, args in value",
+    },
+    {
+      description:
+        "Invoke a callable, pure in formula position: target is the callee pointer — a named formula entry (#/state/…) or a blessed pure global via window#/ (Math.*, JSON.*, Object.keys/values/entries, and the Intl helpers Intl/formatNumber, Intl/formatDate, Intl/formatRelativeTime) — and value is the positional argument list (the splice args-in-value precedent). Argument order follows the callee's declared parameters.",
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/CallOperator" },
+        target: { $ref: "#/$defs/ExpressionPointer" },
+        value: { items: { $ref: "#/$defs/ExpressionOperand" }, type: "array" },
+      },
+      required: ["operator"],
+      title: "call — invoke a named formula or blessed global; callee in target, args in value",
     },
   ],
   properties: {
+    cases: {
+      additionalProperties: { $ref: "#/$defs/ExpressionOperand" },
+      description: "switch only: matched discriminant value (string form) → result operand.",
+      type: "object",
+    },
+    default: {
+      $ref: "#/$defs/ExpressionOperand",
+      description: "switch only: result operand when no case key matches.",
+    },
     initial: { $ref: "#/$defs/ExpressionOperand" },
     operator: { type: "string" },
     target: { $ref: "#/$defs/ExpressionOperand" },
@@ -129,11 +232,17 @@ export const expressionNodeSchema = {
 export const expressionEntrySchema = {
   additionalProperties: false,
   description:
-    "A declarative expression entry (Shape 5). Used as a state entry or inline event handler.",
+    "A declarative expression entry (Shape 5). Used as a state entry or inline event handler. With parameters it is a named formula: a pure, reusable computation invoked via the call operator, its parameters resolved through $args/<name> refs in the body.",
   properties: {
     $description: { type: "string" },
     $expression: { $ref: "#/$defs/ExpressionNode" },
     $title: { type: "string" },
+    parameters: {
+      description:
+        "Named-formula parameters (CEM convention, as on Function entries): bare names or CEM parameter objects. Present ⇒ the entry is callable, not a computed value.",
+      items: { anyOf: [{ type: "string" }, { $ref: "#/$defs/CemParameter" }] },
+      type: "array",
+    },
   },
   required: ["$expression"],
   type: "object",

package/defs/function-def.schema.ts

@@ -16,13 +16,18 @@ export const functionDefSchema = {
       type: "string",
     },
     body: {
-      description: "Inline function body string. First implicit parameter is state.",
+      description:
+        "Inline function body: an opaque JS source string (first implicit parameter is state), or a structured statement array (spec §20) — explicit structured function declaration, analyzable by tooling and editable visually. The escalation ladder within the shape is structured statements → JS string.",
       examples: [
         "state.count++",
         'state.items.push({ id: Date.now(), text: "", done: false })',
         'return state.score >= 90 ? "gold" : "silver"',
+        [
+          { operator: "push", target: { $ref: "#/state/cart" }, value: 1 },
+          { dispatchEvent: "cart-changed", detail: { $ref: "#/state/cart" } },
+        ],
       ],
-      type: "string",
+      oneOf: [{ type: "string" }, { $ref: "#/$defs/StatementList" }],
     },
     description: { type: "string" },
     emits: {

package/defs/index.ts

@@ -34,6 +34,7 @@ export {
 // State shapes
 export { typedStateDefSchema } from "./typed-state-def.schema";
 export { functionDefSchema } from "./function-def.schema";
+export { statementSchema, statementListSchema } from "./statement.schema";
 export { externalClassDefSchema, BUILT_IN_PROTOTYPES } from "./external-class-def.schema";
 export { pureTypeDefSchema } from "./pure-type-def.schema";
 
@@ -46,6 +47,10 @@ export {
   expressionEntrySchema,
   unaryOperatorSchema,
   binaryOperatorSchema,
+  conditionalOperatorSchema,
+  switchOperatorSchema,
+  callOperatorSchema,
+  pureMethodSchema,
   assignmentOperatorSchema,
   noArgMethodSchema,
   oneArgMethodSchema,

package/defs/project-config.schema.ts

@@ -110,7 +110,8 @@ export const projectConfigSchema = {
         },
         format: {
           default: "directory",
-          description: "Output format.",
+          description:
+            "Reserved; currently unused. Accepted for forward compatibility with single-file output (desktop single-file mode) — the build emits per-route directories regardless.",
           enum: ["directory", "single"],
           type: "string",
         },

package/defs/statement.schema.ts

@@ -0,0 +1,65 @@
+// oxlint-disable unicorn/no-thenable -- `then` is the JSON Schema conditional keyword (spec §20), not a promise
+/**
+ * Statement schema (spec §20) — structured function bodies.
+ *
+ * A Function entry's `body` may be a JSON array of statements instead of an opaque JS source
+ * string: explicit structured function declaration, mirroring ESTree's `BlockStatement.body =
+ * Statement[]`. Every statement kind reuses a web-platform name: bare expression nodes (§19), the
+ * JSON Schema 2020-12 `if`/`then`/`else` keyword triple, the element-level `$switch`/`cases`
+ * convention in statement position, and WHATWG's `dispatchEvent` with `CustomEventInit` members.
+ */
+
+export const statementSchema = {
+  description:
+    "One statement of a structured function body. Either a bare expression node in statement position (a mutation like =/push, or a call — its result discarded unless captured by an assignment), an if/then/else branch (JSON Schema conditional keywords; if holds a pure expression, then/else hold statement lists), a $switch multiway branch (discriminant matched by string form against cases keys, like element-level $switch), or a dispatchEvent statement (WHATWG DOM: dispatches a CustomEvent from the handler's current target, with CustomEventInit members detail/bubbles/composed).",
+  oneOf: [
+    { $ref: "#/$defs/ExpressionNode" },
+    {
+      additionalProperties: false,
+      properties: {
+        else: { items: { $ref: "#/$defs/Statement" }, type: "array" },
+        if: { $ref: "#/$defs/ExpressionOperand" },
+        then: { items: { $ref: "#/$defs/Statement" }, type: "array" },
+      },
+      required: ["if", "then"],
+      title: "if / then / else — conditional branch (JSON Schema keyword triple)",
+      type: "object",
+    },
+    {
+      additionalProperties: false,
+      properties: {
+        $switch: { $ref: "#/$defs/ExpressionOperand" },
+        cases: {
+          additionalProperties: { items: { $ref: "#/$defs/Statement" }, type: "array" },
+          type: "object",
+        },
+        default: { items: { $ref: "#/$defs/Statement" }, type: "array" },
+      },
+      required: ["$switch", "cases"],
+      title: "$switch / cases — multiway branch (element-level convention, ECMA switch semantics)",
+      type: "object",
+    },
+    {
+      additionalProperties: false,
+      properties: {
+        bubbles: { type: "boolean" },
+        composed: { type: "boolean" },
+        detail: { $ref: "#/$defs/ExpressionOperand" },
+        dispatchEvent: {
+          description: "The CustomEvent type to dispatch (WHATWG DOM dispatchEvent).",
+          type: "string",
+        },
+      },
+      required: ["dispatchEvent"],
+      title: "dispatchEvent — emit a CustomEvent (WHATWG naming, CustomEventInit members)",
+      type: "object",
+    },
+  ],
+} as const;
+
+export const statementListSchema = {
+  description:
+    "A structured function body: statements executed sequentially (one yielding a promise is awaited before the next, per ECMA async/await semantics).",
+  items: { $ref: "#/$defs/Statement" },
+  type: "array",
+} as const;

package/package.json

@@ -2,7 +2,7 @@
   "dependencies": {
     "@webref/css": "^8.7.0",
     "@webref/elements": "^2.7.1",
-    "@webref/idl": "^3.81.3",
+    "@webref/idl": "^3.82.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },
@@ -49,7 +49,7 @@
     "upgrade": "bunx npm-check-updates -u && bun install"
   },
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "devDependencies": {
     "json-schema-to-ts": "^3.1.1"
   }

package/project-schema.json

@@ -193,7 +193,7 @@
         },
         "format": {
           "default": "directory",
-          "description": "Output format.",
+          "description": "Reserved; currently unused. Accepted for forward compatibility with single-file output (desktop single-file mode) — the build emits per-route directories regardless.",
           "enum": [
             "directory",
             "single"

package/schema.json

@@ -224,13 +224,35 @@
           "type": "string"
         },
         "body": {
-          "description": "Inline function body string. First implicit parameter is state.",
+          "description": "Inline function body: an opaque JS source string (first implicit parameter is state), or a structured statement array (spec §20) — explicit structured function declaration, analyzable by tooling and editable visually. The escalation ladder within the shape is structured statements → JS string.",
           "examples": [
             "state.count++",
             "state.items.push({ id: Date.now(), text: \"\", done: false })",
-            "return state.score >= 90 ? \"gold\" : \"silver\""
+            "return state.score >= 90 ? \"gold\" : \"silver\"",
+            [
+              {
+                "operator": "push",
+                "target": {
+                  "$ref": "#/state/cart"
+                },
+                "value": 1
+              },
+              {
+                "dispatchEvent": "cart-changed",
+                "detail": {
+                  "$ref": "#/state/cart"
+                }
+              }
+            ]
           ],
-          "type": "string"
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "$ref": "#/$defs/StatementList"
+            }
+          ]
         },
         "description": {
           "type": "string"
@@ -951,10 +973,10 @@
     },
     "ExpressionPointer": {
       "additionalProperties": false,
-      "description": "A JSON Pointer $ref operand within an expression node.",
+      "description": "A JSON Pointer $ref operand within an expression node. $args/<name> resolves a named formula's parameter (callable entries only).",
       "properties": {
         "$ref": {
-          "pattern": "^(\\$map/|\\$reduce/|event#/|#/|parent#/|window#/|document#/)",
+          "pattern": "^(\\$map/|\\$reduce/|\\$args/|event#/|#/|parent#/|window#/|document#/)",
           "type": "string"
         }
       },
@@ -985,9 +1007,27 @@
             "$ref": "#/$defs/ExpressionOperand"
           },
           "type": "array"
+        },
+        {
+          "description": "Plain-object literal (e.g. an Intl options bag). Objects carrying $ref or operator keys are pointers/nodes, never literals.",
+          "not": {
+            "anyOf": [
+              {
+                "required": [
+                  "$ref"
+                ]
+              },
+              {
+                "required": [
+                  "operator"
+                ]
+              }
+            ]
+          },
+          "type": "object"
         }
       ],
-      "description": "A non-reactive operand: scalar or array of operands."
+      "description": "A non-reactive operand: scalar, plain-object literal, or array of operands."
     },
     "ExpressionOperand": {
       "anyOf": [
@@ -1023,7 +1063,53 @@
         ">",
         ">=",
         "&&",
-        "||"
+        "||",
+        "??"
+      ]
+    },
+    "ConditionalOperator": {
+      "const": "?:"
+    },
+    "SwitchOperator": {
+      "const": "switch"
+    },
+    "CallOperator": {
+      "const": "call"
+    },
+    "PureMethod": {
+      "description": "A genuine pure String.prototype / Array.prototype / Number.prototype method (spec §19.4d). The ES2023 change-by-copy family (toSorted, toReversed, toSpliced, with) stands in where mutation would otherwise occur. Receiver in target; value carries the argument (bare scalar) or argument list (array).",
+      "enum": [
+        "includes",
+        "indexOf",
+        "lastIndexOf",
+        "join",
+        "slice",
+        "concat",
+        "at",
+        "flat",
+        "toSorted",
+        "toReversed",
+        "toSpliced",
+        "with",
+        "toUpperCase",
+        "toLowerCase",
+        "trim",
+        "trimStart",
+        "trimEnd",
+        "split",
+        "startsWith",
+        "endsWith",
+        "padStart",
+        "padEnd",
+        "replaceAll",
+        "repeat",
+        "charAt",
+        "normalize",
+        "toLocaleUpperCase",
+        "toLocaleLowerCase",
+        "toFixed",
+        "toPrecision",
+        "toLocaleString"
       ]
     },
     "AssignmentOperator": {
@@ -1206,7 +1292,14 @@
               "$ref": "#/$defs/ReduceMethod"
             },
             "target": {
-              "$ref": "#/$defs/ExpressionPointer"
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/ExpressionPointer"
+                },
+                {
+                  "$ref": "#/$defs/ExpressionNode"
+                }
+              ]
             },
             "value": {
               "$ref": "#/$defs/ExpressionNode"
@@ -1217,7 +1310,7 @@
             "value",
             "initial"
           ],
-          "title": "reduce — pure fold; per-item expression in value, seed in initial"
+          "title": "reduce — pure fold over a pointer or derived array; seed in initial"
         },
         {
           "not": {
@@ -1230,7 +1323,14 @@
               "$ref": "#/$defs/MapFilterMethod"
             },
             "target": {
-              "$ref": "#/$defs/ExpressionPointer"
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/ExpressionPointer"
+                },
+                {
+                  "$ref": "#/$defs/ExpressionNode"
+                }
+              ]
             },
             "value": {
               "$ref": "#/$defs/ExpressionNode"
@@ -1240,10 +1340,114 @@
             "operator",
             "value"
           ],
-          "title": "map / filter — pure; per-item expression in value, no initial"
+          "title": "map / filter — pure over a pointer or derived array; per-item expression in value"
+        },
+        {
+          "description": "The ECMAScript conditional (ternary) operator, pure: target is the test, value the consequent, initial the alternate (the reduce precedent for repurposing initial). Chain else-if by nesting another ?: node in initial.",
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/ConditionalOperator"
+            }
+          },
+          "required": [
+            "operator",
+            "value",
+            "initial"
+          ],
+          "title": "?: — pure conditional; test in target, consequent in value, alternate in initial"
+        },
+        {
+          "description": "Value-keyed multiway selection, pure: target is the discriminant (matched against case keys by its string form, like element-level $switch), cases maps matched values to result operands, default is the operand when no case matches (result is undefined without it). Condition-chain branching composes from nested ?: nodes instead.",
+          "not": {
+            "anyOf": [
+              {
+                "required": [
+                  "value"
+                ]
+              },
+              {
+                "required": [
+                  "initial"
+                ]
+              }
+            ]
+          },
+          "properties": {
+            "cases": {
+              "additionalProperties": {
+                "$ref": "#/$defs/ExpressionOperand"
+              },
+              "type": "object"
+            },
+            "default": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "operator": {
+              "$ref": "#/$defs/SwitchOperator"
+            }
+          },
+          "required": [
+            "operator",
+            "cases"
+          ],
+          "title": "switch — pure value-keyed selection; discriminant in target, results in cases/default"
+        },
+        {
+          "description": "A pure standard-library method call: target is the receiver (any operand — never mutated; change-by-copy names replace the mutating originals), value the optional argument (bare scalar) or argument list (array). A missing receiver or method yields undefined, matching null-safe path reads.",
+          "not": {
+            "required": [
+              "initial"
+            ]
+          },
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/PureMethod"
+            }
+          },
+          "required": [
+            "operator"
+          ],
+          "title": "Pure method — genuine prototype methods; receiver in target, args in value"
+        },
+        {
+          "description": "Invoke a callable, pure in formula position: target is the callee pointer — a named formula entry (#/state/…) or a blessed pure global via window#/ (Math.*, JSON.*, Object.keys/values/entries, and the Intl helpers Intl/formatNumber, Intl/formatDate, Intl/formatRelativeTime) — and value is the positional argument list (the splice args-in-value precedent). Argument order follows the callee's declared parameters.",
+          "not": {
+            "required": [
+              "initial"
+            ]
+          },
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/CallOperator"
+            },
+            "target": {
+              "$ref": "#/$defs/ExpressionPointer"
+            },
+            "value": {
+              "items": {
+                "$ref": "#/$defs/ExpressionOperand"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "operator"
+          ],
+          "title": "call — invoke a named formula or blessed global; callee in target, args in value"
         }
       ],
       "properties": {
+        "cases": {
+          "additionalProperties": {
+            "$ref": "#/$defs/ExpressionOperand"
+          },
+          "description": "switch only: matched discriminant value (string form) → result operand.",
+          "type": "object"
+        },
+        "default": {
+          "$ref": "#/$defs/ExpressionOperand",
+          "description": "switch only: result operand when no case key matches."
+        },
         "initial": {
           "$ref": "#/$defs/ExpressionOperand"
         },
@@ -1265,7 +1469,7 @@
     },
     "ExpressionEntry": {
       "additionalProperties": false,
-      "description": "A declarative expression entry (Shape 5). Used as a state entry or inline event handler.",
+      "description": "A declarative expression entry (Shape 5). Used as a state entry or inline event handler. With parameters it is a named formula: a pure, reusable computation invoked via the call operator, its parameters resolved through $args/<name> refs in the body.",
       "properties": {
         "$description": {
           "type": "string"
@@ -1275,6 +1479,20 @@
         },
         "$title": {
           "type": "string"
+        },
+        "parameters": {
+          "description": "Named-formula parameters (CEM convention, as on Function entries): bare names or CEM parameter objects. Present ⇒ the entry is callable, not a computed value.",
+          "items": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "$ref": "#/$defs/CemParameter"
+              }
+            ]
+          },
+          "type": "array"
         }
       },
       "required": [
@@ -1282,6 +1500,99 @@
       ],
       "type": "object"
     },
+    "Statement": {
+      "description": "One statement of a structured function body. Either a bare expression node in statement position (a mutation like =/push, or a call — its result discarded unless captured by an assignment), an if/then/else branch (JSON Schema conditional keywords; if holds a pure expression, then/else hold statement lists), a $switch multiway branch (discriminant matched by string form against cases keys, like element-level $switch), or a dispatchEvent statement (WHATWG DOM: dispatches a CustomEvent from the handler's current target, with CustomEventInit members detail/bubbles/composed).",
+      "oneOf": [
+        {
+          "$ref": "#/$defs/ExpressionNode"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "else": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            },
+            "if": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "then": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "if",
+            "then"
+          ],
+          "title": "if / then / else — conditional branch (JSON Schema keyword triple)",
+          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "$switch": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "cases": {
+              "additionalProperties": {
+                "items": {
+                  "$ref": "#/$defs/Statement"
+                },
+                "type": "array"
+              },
+              "type": "object"
+            },
+            "default": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "$switch",
+            "cases"
+          ],
+          "title": "$switch / cases — multiway branch (element-level convention, ECMA switch semantics)",
+          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "bubbles": {
+              "type": "boolean"
+            },
+            "composed": {
+              "type": "boolean"
+            },
+            "detail": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "dispatchEvent": {
+              "description": "The CustomEvent type to dispatch (WHATWG DOM dispatchEvent).",
+              "type": "string"
+            }
+          },
+          "required": [
+            "dispatchEvent"
+          ],
+          "title": "dispatchEvent — emit a CustomEvent (WHATWG naming, CustomEventInit members)",
+          "type": "object"
+        }
+      ]
+    },
+    "StatementList": {
+      "description": "A structured function body: statements executed sequentially (one yielding a promise is awaited before the next, per ECMA async/await semantics).",
+      "items": {
+        "$ref": "#/$defs/Statement"
+      },
+      "type": "array"
+    },
     "ElementDef": {
       "additionalProperties": {
         "$ref": "#/$defs/ElementPropertyValue"

package/schemas/project.core.schema.json

@@ -254,7 +254,7 @@
         },
         "format": {
           "default": "directory",
-          "description": "Output format.",
+          "description": "Reserved; currently unused. Accepted for forward compatibility with single-file output (desktop single-file mode) — the build emits per-route directories regardless.",
           "enum": [
             "directory",
             "single"

package/src/guards.ts

@@ -19,6 +19,7 @@ import type {
   JxPrototypeDef,
   JxRef,
   JxServerFnDef,
+  JxStatement,
   JxStateObject,
   JxStyle,
 } from "../types";
@@ -49,6 +50,26 @@ export function isExpressionDef(value: unknown): value is JxExpressionDef {
   return isJsonObject(value) && isJsonObject(value.$expression);
 }
 
+/**
+ * Shape 5 with `parameters`: a named formula — a pure, reusable computation invoked via the `call`
+ * operator rather than lowered to a computed value.
+ */
+export function isNamedFormulaDef(
+  value: unknown,
+): value is JxExpressionDef & { parameters: unknown[] } {
+  return isExpressionDef(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
+}
+
+/**
+ * Shape 4 with a structured body: a Function entry whose `body` is a statement array (spec §20)
+ * rather than opaque JS source.
+ */
+export function hasStructuredBody(
+  value: unknown,
+): value is JxFunctionDef & { body: JxStatement[] } {
+  return isFunctionDef(value) && Array.isArray(value.body);
+}
+
 /** A non-Function `$prototype` instance (Request, Storage, ContentCollection, classes, …). */
 export function isPrototypeDef(value: unknown): value is JxPrototypeDef {
   return (

package/src/schema.ts

@@ -58,11 +58,14 @@ import {
 } from "../defs/element-def.schema";
 import { typedStateDefSchema } from "../defs/typed-state-def.schema";
 import { functionDefSchema } from "../defs/function-def.schema";
+import { statementListSchema, statementSchema } from "../defs/statement.schema";
 import { externalClassDefSchema } from "../defs/external-class-def.schema";
 import { pureTypeDefSchema } from "../defs/pure-type-def.schema";
 import {
   assignmentOperatorSchema,
   binaryOperatorSchema,
+  callOperatorSchema,
+  conditionalOperatorSchema,
   expressionEntrySchema,
   expressionLiteralSchema,
   expressionNodeSchema,
@@ -71,8 +74,10 @@ import {
   mapFilterMethodSchema,
   noArgMethodSchema,
   oneArgMethodSchema,
+  pureMethodSchema,
   reduceMethodSchema,
   spliceMethodSchema,
+  switchOperatorSchema,
   unaryOperatorSchema,
 } from "../defs/expression-node.schema";
 import {
@@ -218,6 +223,10 @@ export async function generateSchema() {
       ExpressionOperand: expressionOperandSchema,
       UnaryOperator: unaryOperatorSchema,
       BinaryOperator: binaryOperatorSchema,
+      ConditionalOperator: conditionalOperatorSchema,
+      SwitchOperator: switchOperatorSchema,
+      CallOperator: callOperatorSchema,
+      PureMethod: pureMethodSchema,
       AssignmentOperator: assignmentOperatorSchema,
       NoArgMethod: noArgMethodSchema,
       OneArgMethod: oneArgMethodSchema,
@@ -226,6 +235,8 @@ export async function generateSchema() {
       MapFilterMethod: mapFilterMethodSchema,
       ExpressionNode: expressionNodeSchema,
       ExpressionEntry: expressionEntrySchema,
+      Statement: statementSchema,
+      StatementList: statementListSchema,
 
       // Element defs — with webref data injected
       ElementDef: {

package/types.ts

@@ -88,18 +88,29 @@ export type JxExpressionOperand =
   | number
   | boolean
   | null
-  | JxExpressionOperand[];
+  | JxExpressionOperand[]
+  // Plain-object literal (e.g. an Intl options bag); $ref/operator shapes are the members above.
+  | Record<string, JsonValue>;
 
 export interface JxExpressionNode {
   operator: string;
   target: JxExpressionOperand;
   value?: JxExpressionOperand;
   initial?: JxExpressionOperand;
+  /** `switch` only: matched discriminant value (string form) → result operand. */
+  cases?: Record<string, JxExpressionOperand>;
+  /** `switch` only: result operand when no case key matches. */
+  default?: JxExpressionOperand;
 }
 
 /** A state entry (or event binding) whose value is computed from a declarative expression. */
 export interface JxExpressionDef {
   $expression: JxExpressionNode;
+  /**
+   * Named-formula parameters (CEM convention, as on Function entries). Present ⇒ the entry is a
+   * callable formula invoked via the `call` operator, with `$args/<name>` refs in its body.
+   */
+  parameters?: (string | CemParameter)[];
   [key: string]: unknown;
 }
 
@@ -108,11 +119,50 @@ export interface JxExpressionDef {
 // Detection algorithm in buildScope(). Use the guards in `@jxsuite/schema/guards`
 // To discriminate.
 
+// ─── Statement Model (spec §20) ─────────────────────────────────────────────────
+// Structured function bodies: `body` as a statement array instead of opaque JS source,
+// Mirroring ESTree's BlockStatement.body = Statement[].
+
+/** An `{ if, then, else }` branch — the JSON Schema 2020-12 conditional keyword triple. */
+export interface JxIfStatement {
+  if: JxExpressionOperand;
+  then: JxStatement[];
+  else?: JxStatement[];
+}
+
+/** A `{ $switch, cases }` multiway branch in statement position (element-level convention). */
+export interface JxSwitchStatement {
+  $switch: JxExpressionOperand;
+  cases: Record<string, JxStatement[]>;
+  default?: JxStatement[];
+}
+
+/** A WHATWG `dispatchEvent` statement: emits a CustomEvent with CustomEventInit members. */
+export interface JxDispatchStatement {
+  dispatchEvent: string;
+  detail?: JxExpressionOperand;
+  bubbles?: boolean;
+  composed?: boolean;
+}
+
+/**
+ * One statement of a structured function body: a bare expression node in statement position
+ * (mutation or `call`), a branch, a multiway branch, or an event dispatch.
+ */
+export type JxStatement =
+  | JxExpressionNode
+  | JxIfStatement
+  | JxSwitchStatement
+  | JxDispatchStatement;
+
 /** A function declaration: inline `body` or external `$src`/`$export`. */
 export interface JxFunctionDef {
   $prototype: "Function";
-  /** Inline function body. The reactive scope is the implicit first parameter. */
-  body?: string;
+  /**
+   * Inline function body: opaque JS source (the reactive scope is the implicit first parameter) or
+   * a structured statement array (spec §20).
+   */
+  body?: string | JxStatement[];
   /** Parameters after the implicit scope parameter: bare names or CEM parameter objects. */
   parameters?: (string | CemParameter)[];
   /** Explicit function name; defaults to the state key. */