@jxsuite/schema 1.0.0 → 1.2.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

@@ -54,9 +54,15 @@ export const projectConfigSchema = {
       additionalProperties: { type: "string" },
       description:
         "Named media breakpoints following CSS @custom-media convention. " +
-        "Available in all component style objects.",
+        "Available in all component style objects. Declaring a pure color-scheme " +
+        'query (e.g. "--dark": "(prefers-color-scheme: dark)") additionally opts the ' +
+        "site into the forced-scheme contract: @--dark style blocks are dual-emitted " +
+        "so a data-color-scheme attribute on <html> overrides the OS preference, " +
+        "color-scheme is declared on :root, and a pre-paint script restores the " +
+        "visitor's persisted choice (spec §9.5).",
       examples: [
         {
+          "--dark": "(prefers-color-scheme: dark)",
           "--lg": "(min-width: 1024px)",
           "--md": "(min-width: 768px)",
           "--sm": "(min-width: 640px)",
@@ -110,7 +116,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,13 +2,14 @@
   "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"
   },
   "description": "JSON Schema 2020-12 meta-schema generator for Jx documents",
   "exports": {
     ".": "./src/schema.ts",
+    "./asset-paths": "./src/asset-paths.ts",
     "./extension-registry": "./src/extension-registry.ts",
     "./format-registry": "./src/format-registry.ts",
     "./project-schemas": "./src/project-schemas.ts",
@@ -49,7 +50,7 @@
     "upgrade": "bunx npm-check-updates -u && bun install"
   },
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "devDependencies": {
     "json-schema-to-ts": "^3.1.1"
   }

package/project-schema.json

@@ -131,9 +131,10 @@
       "additionalProperties": {
         "type": "string"
       },
-      "description": "Named media breakpoints following CSS @custom-media convention. Available in all component style objects.",
+      "description": "Named media breakpoints following CSS @custom-media convention. Available in all component style objects. Declaring a pure color-scheme query (e.g. \"--dark\": \"(prefers-color-scheme: dark)\") additionally opts the site into the forced-scheme contract: @--dark style blocks are dual-emitted so a data-color-scheme attribute on <html> overrides the OS preference, color-scheme is declared on :root, and a pre-paint script restores the visitor's persisted choice (spec §9.5).",
       "examples": [
         {
+          "--dark": "(prefers-color-scheme: dark)",
           "--lg": "(min-width: 1024px)",
           "--md": "(min-width: 768px)",
           "--sm": "(min-width: 640px)"
@@ -193,7 +194,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"
@@ -21723,7 +22034,7 @@
       "additionalProperties": {
         "type": "string"
       },
-      "description": "Named media breakpoints following CSS @custom-media convention. Keys use the CSS custom property -- prefix.",
+      "description": "Named media breakpoints following CSS @custom-media convention. Keys use the CSS custom property -- prefix. Pure color-scheme queries (e.g. \"--dark\": \"(prefers-color-scheme: dark)\") are dual-emitted so a data-color-scheme attribute on the root element forces the scheme regardless of the OS preference (spec §9.5).",
       "examples": [
         {
           "--dark": "(prefers-color-scheme: dark)",

package/schemas/document.paths.schema.json

@@ -3,4 +3,4 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "description": "Default $paths-value union for documents. Per-project entry documents override this resource with the union of extension-contributed paths shapes.",
   "title": "Jx Document Paths Union"
-}
+}

package/schemas/project.core.schema.json

@@ -41,10 +41,7 @@
         },
         "service": {
           "description": "How images are optimized: \"build\" runs Sharp at build time; \"cloudflare\" emits /cdn-cgi/image transform URLs served by Cloudflare Image Transformations (requires the feature to be enabled on the serving zone).",
-          "enum": [
-            "build",
-            "cloudflare"
-          ],
+          "enum": ["build", "cloudflare"],
           "type": "string"
         },
         "sizes": {
@@ -88,20 +85,11 @@
           "type": "array"
         },
         "type": {
-          "enum": [
-            "string",
-            "number",
-            "integer",
-            "boolean",
-            "array",
-            "object"
-          ],
+          "enum": ["string", "number", "integer", "boolean", "array", "object"],
           "type": "string"
         }
       },
-      "required": [
-        "type"
-      ],
+      "required": ["type"],
       "type": "object"
     },
     "RelationshipRef": {
@@ -115,9 +103,7 @@
           "type": "string"
         }
       },
-      "required": [
-        "$ref"
-      ],
+      "required": ["$ref"],
       "type": "object"
     }
   },
@@ -140,9 +126,7 @@
                 "type": "string"
               }
             },
-            "required": [
-              "$ref"
-            ],
+            "required": ["$ref"],
             "type": "object"
           },
           {
@@ -192,9 +176,10 @@
       "additionalProperties": {
         "type": "string"
       },
-      "description": "Named media breakpoints following CSS @custom-media convention. Available in all component style objects.",
+      "description": "Named media breakpoints following CSS @custom-media convention. Available in all component style objects. Declaring a pure color-scheme query (e.g. \"--dark\": \"(prefers-color-scheme: dark)\") additionally opts the site into the forced-scheme contract: @--dark style blocks are dual-emitted so a data-color-scheme attribute on <html> overrides the OS preference, color-scheme is declared on :root, and a pre-paint script restores the visitor's persisted choice (spec §9.5).",
       "examples": [
         {
+          "--dark": "(prefers-color-scheme: dark)",
           "--lg": "(min-width: 1024px)",
           "--md": "(min-width: 768px)",
           "--sm": "(min-width: 640px)"
@@ -211,13 +196,7 @@
       "properties": {
         "adapter": {
           "description": "Platform adapter for deployment-specific output.",
-          "enum": [
-            "static",
-            "cloudflare-pages",
-            "cloudflare-workers",
-            "node",
-            "bun"
-          ],
+          "enum": ["static", "cloudflare-pages", "cloudflare-workers", "node", "bun"],
           "type": "string"
         },
         "deploy": {
@@ -239,26 +218,17 @@
             },
             "provider": {
               "description": "Hosting provider the project is connected to.",
-              "enum": [
-                "cloudflare-pages"
-              ],
+              "enum": ["cloudflare-pages"],
               "type": "string"
             }
           },
-          "required": [
-            "provider",
-            "accountId",
-            "projectName"
-          ],
+          "required": ["provider", "accountId", "projectName"],
           "type": "object"
         },
         "format": {
           "default": "directory",
-          "description": "Output format.",
-          "enum": [
-            "directory",
-            "single"
-          ],
+          "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"
         },
         "outDir": {
@@ -274,11 +244,7 @@
         "trailingSlash": {
           "default": "always",
           "description": "Trailing slash behavior for generated URLs.",
-          "enum": [
-            "always",
-            "never",
-            "ignore"
-          ],
+          "enum": ["always", "never", "ignore"],
           "type": "string"
         }
       },
@@ -307,9 +273,7 @@
         "layout": {
           "default": null,
           "description": "Default layout file path applied to all pages. Set to null to render pages without a layout.",
-          "examples": [
-            "./layouts/base.json"
-          ],
+          "examples": ["./layouts/base.json"],
           "oneOf": [
             {
               "type": "string"
@@ -324,11 +288,7 @@
     },
     "extensions": {
       "description": "Extension packages: bare package names (resolved project-first through the package exports map) or relative paths. Each must export jx-extension.json.",
-      "examples": [
-        [
-          "@jxsuite/parser"
-        ]
-      ],
+      "examples": [["@jxsuite/parser"]],
       "items": {
         "type": "string"
       },
@@ -339,20 +299,12 @@
       "properties": {
         "defaultLocale": {
           "description": "Default locale code.",
-          "examples": [
-            "en"
-          ],
+          "examples": ["en"],
           "type": "string"
         },
         "locales": {
           "description": "Available locale codes.",
-          "examples": [
-            [
-              "en",
-              "fr",
-              "de"
-            ]
-          ],
+          "examples": [["en", "fr", "de"]],
           "items": {
             "type": "string"
           },
@@ -360,10 +312,7 @@
         },
         "routing": {
           "description": "Locale routing strategy.",
-          "enum": [
-            "prefix-except-default",
-            "prefix-always"
-          ],
+          "enum": ["prefix-except-default", "prefix-always"],
           "type": "string"
         }
       },
@@ -388,10 +337,7 @@
     "name": {
       "default": "Jx Site",
       "description": "Human-readable project name.",
-      "examples": [
-        "My Portfolio",
-        "Jx Example Site"
-      ],
+      "examples": ["My Portfolio", "Jx Example Site"],
       "type": "string"
     },
     "redirects": {
@@ -429,13 +375,10 @@
     },
     "url": {
       "description": "Production URL of the deployed site.",
-      "examples": [
-        "https://example.com",
-        "https://jxsuite.com"
-      ],
+      "examples": ["https://example.com", "https://jxsuite.com"],
       "type": "string"
     }
   },
   "title": "Jx Project Core",
   "type": "object"
-}
+}

package/schemas/project.fields.schema.json

@@ -11,4 +11,4 @@
   ],
   "description": "Default field-schema union for section entry schemas: the core field shape plus relationship references. Per-project entry documents override this resource with the effective union. See specs/extensions.md §5.3.",
   "title": "Jx Project Field Union"
-}
+}

package/src/asset-paths.ts

@@ -0,0 +1,42 @@
+/**
+ * Deterministic mapping from Function-def `$src` module specifiers to bundled asset URLs. Shared
+ * between the compiler's sidecar bundler (which writes the bundle) and extension `lower()`
+ * implementations (which emit the URL into client code) so neither needs to depend on the other.
+ *
+ * The mapping is intentionally hash-free: the same specifier always yields the same URL, letting
+ * lowered defs reference bundles the compiler produces later in the build. Distinct specifiers that
+ * collide on a slug are rejected by the bundler at build time.
+ */
+
+/** Prefix for npm package specifiers in `$src` (spec §12): `npm:<pkg>[/subpath]`. */
+export const NPM_SPECIFIER_PREFIX = "npm:";
+
+/** URL directory (under the site root) where bundled sidecars are written. */
+export const SIDECAR_ASSET_DIR = "/assets/";
+
+/** True when a `$src` specifier names an npm package rather than a project file. */
+export function isNpmSpecifier(specifier: string): boolean {
+  return specifier.startsWith(NPM_SPECIFIER_PREFIX);
+}
+
+/**
+ * Map a Function-def `$src` specifier to its bundled asset URL.
+ *
+ * `npm:@jxsuite/search/client` → `/assets/jxsuite-search-client.js` `./lib/search-helpers.ts` →
+ * `/assets/lib-search-helpers.js`
+ */
+export function sidecarAssetPath(specifier: string): string {
+  let base = specifier;
+  if (isNpmSpecifier(base)) {
+    base = base.slice(NPM_SPECIFIER_PREFIX.length);
+  }
+  base = base
+    .replace(/^\.\//, "")
+    .replace(/\.(js|ts|mjs|mts)$/, "")
+    .replaceAll("@", "")
+    .replaceAll(/[/\\]+/g, "-")
+    .replaceAll(/[^\w.-]/g, "-")
+    .replaceAll(/-+/g, "-")
+    .replaceAll(/^-|-$/g, "");
+  return `${SIDECAR_ASSET_DIR}${base}.js`;
+}

package/src/extension-registry.ts

@@ -151,6 +151,11 @@ export class ExtensionRegistry {
     return this.#classes.find((e) => e.capabilities.resolvePaths?.discriminator === key);
   }
 
+  /** Classes declaring an `emit` capability (build-time asset emission), in declaration order. */
+  emitters(): FormatEntry[] {
+    return this.#classes.filter((e) => e.capabilities.emit !== undefined);
+  }
+
   /** Server-mount classes, sorted by `server.order` (ascending; default 100), then name. */
   serverMounts(): FormatEntry[] {
     return this.#classes

package/src/format-registry.ts

@@ -21,14 +21,16 @@ export const FORMAT_CAPABILITIES: readonly FormatCapability[] = [
 
 /**
  * All well-known static capability roles across admission blocks (specs/extensions.md §8): format
- * roles plus project-section (`projectData`, `resolvePaths`), compile-away (`lower`), server-mount
- * (`mount`), and connector (`dialect`, `deploySchema`, `bindings`, `testConnection`) roles.
+ * roles plus project-section (`projectData`, `resolvePaths`), compile-away (`lower`), build-time
+ * asset emission (`emit`), server-mount (`mount`), and connector (`dialect`, `deploySchema`,
+ * `bindings`, `testConnection`) roles.
  */
 export type ExtensionCapability =
   | FormatCapability
   | "projectData"
   | "resolvePaths"
   | "lower"
+  | "emit"
   | "mount"
   | "dialect"
   | "deploySchema"
@@ -40,6 +42,7 @@ export const EXTENSION_CAPABILITIES: readonly ExtensionCapability[] = [
   "projectData",
   "resolvePaths",
   "lower",
+  "emit",
   "mount",
   "dialect",
   "deploySchema",

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: {
@@ -327,7 +338,10 @@ export async function generateSchema() {
         additionalProperties: { type: "string" },
         description:
           "Named media breakpoints following CSS @custom-media convention. " +
-          "Keys use the CSS custom property -- prefix.",
+          "Keys use the CSS custom property -- prefix. Pure color-scheme queries " +
+          '(e.g. "--dark": "(prefers-color-scheme: dark)") are dual-emitted so a ' +
+          "data-color-scheme attribute on the root element forces the scheme " +
+          "regardless of the OS preference (spec §9.5).",
         examples: [
           {
             "--dark": "(prefers-color-scheme: dark)",
@@ -663,6 +677,30 @@ async function runSchemaCli() {
     writeFileSync(resolve(schemaDir, "schemas", "project.fields.schema.json"), fieldsStr, "utf8");
     writeFileSync(resolve(schemaDir, "schemas", "document.paths.schema.json"), pathsStr, "utf8");
     writeFileSync(resolve(schemaDir, "extension-manifest.schema.json"), manifestStr, "utf8");
+    // The schemas/ fragments are oxfmt-managed (unlike packages/schema/*.json, which .oxfmtrc
+    // Ignores), so emit them formatted — otherwise every `bun run generate:schema` reintroduces
+    // Raw-stringify formatting and dirties the tree. This is a dev-hygiene step only: the JSON
+    // Above is already written and valid, and oxfmt just prettifies it (e.g. collapsing short enum
+    // Arrays onto one line). Inside a sandboxed/offline build (e.g. `nix build`) oxfmt exits
+    // Non-zero with no diagnostic output, so treat a failure as non-fatal and keep the valid JSON
+    // Rather than aborting the build over cosmetic formatting.
+    const fmt = Bun.spawnSync(
+      [
+        "bunx",
+        "oxfmt",
+        resolve(schemaDir, "schemas", "project.core.schema.json"),
+        resolve(schemaDir, "schemas", "project.fields.schema.json"),
+        resolve(schemaDir, "schemas", "document.paths.schema.json"),
+      ],
+      { cwd: schemaDir },
+    );
+    if (fmt.exitCode !== 0) {
+      const detail =
+        fmt.stderr.toString() ||
+        fmt.stdout.toString() ||
+        `exit ${fmt.exitCode ?? "null"}${fmt.signalCode ? `, signal ${fmt.signalCode}` : ""}`;
+      console.error(`Warning: skipped oxfmt reformat of generated schemas (${detail})`);
+    }
     console.error("Generated:");
     console.error("  schema.json (component)");
     console.error("  project-schema.json");

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. */