@jarenjs/json 0.9.2

package/schemas/jaren-jslt.draft-07.schema.json

@@ -0,0 +1,776 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://jarenjs.dev/schemas/jaren-jslt/0.1/draft-07",
+  "title": "Jaren JSLT format 0.1",
+  "description": "Structural grammar of Jaren JSLT stylesheet documents (see packages/json/docs/JSLT-FORMAT.md). Rule bodies mechanically reuse the committed Jaren JSON Query grammar plus the body-local $apply phrase; the query schema itself is unchanged. This schema enforces document shapes, closed vocabularies, path syntax when format assertion is enabled, and structurally expressible body rules. The compiler remains authoritative for JT0xxx rules JSON Schema cannot express: conflict-rank semantics, reserved root/path externals, compileTypeTest hook requirements, schema-literal compilation, and the literal-string second position of a two-item $apply argument list. Authored in a draft-neutral keyword subset; the draft-07 twin is a mechanical derivation.",
+  "allOf": [
+    {
+      "$ref": "#/definitions/stylesheetDocument"
+    }
+  ],
+  "definitions": {
+    "stylesheetDocument": {
+      "description": "A JSLT stylesheet is either a bare array of rules or the versioned envelope object.",
+      "oneOf": [
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/rule"
+          }
+        },
+        {
+          "$ref": "#/definitions/stylesheetEnvelope"
+        }
+      ]
+    },
+    "stylesheetEnvelope": {
+      "description": "Versioned stylesheet envelope. Unknown members are rejected; per-mode declarations only override unmatched disposition.",
+      "type": "object",
+      "properties": {
+        "$jslt": {
+          "const": "0.1"
+        },
+        "rules": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/rule"
+          }
+        },
+        "unmatched": {
+          "$ref": "#/definitions/dispositionValue"
+        },
+        "modes": {
+          "$ref": "#/definitions/modesMap"
+        }
+      },
+      "required": [
+        "$jslt",
+        "rules"
+      ],
+      "additionalProperties": false
+    },
+    "rule": {
+      "description": "One closed template rule. The compiler is authoritative for rank ordering, reserved external bindings, hook availability, and body runtime semantics (JT0xxx/JT2xxx).",
+      "type": "object",
+      "properties": {
+        "match": {
+          "$ref": "#/definitions/matchSpec"
+        },
+        "mode": {
+          "type": "string"
+        },
+        "priority": {
+          "type": "number"
+        },
+        "body": {
+          "$ref": "#/definitions/queryDocument"
+        }
+      },
+      "required": [
+        "body"
+      ],
+      "additionalProperties": false
+    },
+    "matchSpec": {
+      "description": "A positional RFC 9535 JSONPath match, a shape match using an annotation-only JSON Schema literal, or both conditions in one closed object.",
+      "oneOf": [
+        {
+          "type": "string",
+          "format": "json-path"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string",
+              "format": "json-path"
+            },
+            "schema": {
+              "$ref": "#/definitions/schemaLiteral"
+            }
+          },
+          "anyOf": [
+            {
+              "required": [
+                "path"
+              ]
+            },
+            {
+              "required": [
+                "schema"
+              ]
+            }
+          ],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "dispositionValue": {
+      "description": "Built-in behavior for unmatched values: share unchanged subtrees, rebuild fresh containers, or raise JT2003.",
+      "enum": [
+        "share",
+        "fresh",
+        "error"
+      ]
+    },
+    "modesMap": {
+      "description": "Mode name to unmatched-disposition override. Modes need not otherwise be declared.",
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/modeConfig"
+      }
+    },
+    "modeConfig": {
+      "type": "object",
+      "properties": {
+        "unmatched": {
+          "$ref": "#/definitions/dispositionValue"
+        }
+      },
+      "required": [
+        "unmatched"
+      ],
+      "additionalProperties": false
+    },
+    "queryDocument": {
+      "description": "A query document is either the version envelope or a bare expression (a bare RFC 9535 JSONPath string is the degenerate query).",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/versionEnvelope"
+        },
+        {
+          "$ref": "#/definitions/expression"
+        }
+      ]
+    },
+    "versionEnvelope": {
+      "description": "Top-level version envelope. Only recognized at the top level of a query document.",
+      "type": "object",
+      "properties": {
+        "$query": {
+          "const": "0.1"
+        },
+        "$expr": {
+          "$ref": "#/definitions/expression"
+        }
+      },
+      "required": [
+        "$query",
+        "$expr"
+      ],
+      "additionalProperties": false
+    },
+    "expression": {
+      "description": "Any expression per the encoding rules: scalars are literals, strings split on the leading '$', arrays are array constructors, objects partition into map constructors (no $-prefixed key) and operator phrases (all keys $-prefixed).",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/scalarLiteral"
+        },
+        {
+          "$ref": "#/definitions/stringExpression"
+        },
+        {
+          "$ref": "#/definitions/arrayConstructor"
+        },
+        {
+          "$ref": "#/definitions/objectExpression"
+        }
+      ]
+    },
+    "scalarLiteral": {
+      "description": "Numbers, booleans and null are literal items.",
+      "type": [
+        "null",
+        "boolean",
+        "number"
+      ]
+    },
+    "stringExpression": {
+      "description": "Rule 2: a string starting with '$' is a query expression ('$$' escapes a literal); any other string is a literal.",
+      "type": "string",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/literalString"
+        },
+        {
+          "$ref": "#/definitions/escapedStringLiteral"
+        },
+        {
+          "$ref": "#/definitions/absolutePathString"
+        },
+        {
+          "$ref": "#/definitions/variablePathString"
+        }
+      ]
+    },
+    "literalString": {
+      "description": "A string that does not start with '$' denotes itself.",
+      "type": "string",
+      "pattern": "^([^$]|$)"
+    },
+    "escapedStringLiteral": {
+      "description": "A string starting with '$$' denotes the literal string with one leading '$' dropped.",
+      "type": "string",
+      "pattern": "^\\$\\$"
+    },
+    "absolutePathString": {
+      "description": "An absolute RFC 9535 JSONPath query rooted at the input document: '$' alone or starting '$.', '$[' or '$..'. The json-path format asserts the full RFC 9535 grammar where format assertion is enabled (format is annotation-only by default from draft 2020-12).",
+      "type": "string",
+      "pattern": "^\\$($|[.\\[])",
+      "format": "json-path"
+    },
+    "variablePathString": {
+      "description": "A variable-rooted path: '$name' with name matching [A-Za-z_][A-Za-z0-9_]*, optionally followed by RFC 9535 segments. Only the head is pattern-checked; the full segment grammar is enforced by the compiler (JQ0004).",
+      "type": "string",
+      "pattern": "^\\$[A-Za-z_][A-Za-z0-9_]*($|[.\\[])"
+    },
+    "arrayConstructor": {
+      "description": "An array in expression position constructs an array; element results are concatenated per XQuery sequence flattening.",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/expression"
+      }
+    },
+    "objectExpression": {
+      "description": "Rule 1: objects partition by $-prefixed keys. A mixed object matches neither branch and is invalid (JQ0001).",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/mapConstructor"
+        },
+        {
+          "$ref": "#/definitions/constPhrase"
+        },
+        {
+          "$ref": "#/definitions/mapPhrase"
+        },
+        {
+          "$ref": "#/definitions/flworPhrase"
+        },
+        {
+          "$ref": "#/definitions/somePhrase"
+        },
+        {
+          "$ref": "#/definitions/everyPhrase"
+        },
+        {
+          "$ref": "#/definitions/unaryOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/binaryOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/variadicOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/nonEmptyVariadicOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/conditionalArityOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/stringJoinPhrase"
+        },
+        {
+          "$ref": "#/definitions/replacePhrase"
+        },
+        {
+          "$ref": "#/definitions/schemaOperatorPhrase"
+        },
+        {
+          "$ref": "#/definitions/applyPhrase"
+        }
+      ]
+    },
+    "mapConstructor": {
+      "description": "An object with no $-prefixed key: keys are literal member names, values are expressions. Use $map or $const for member names that start with '$'.",
+      "type": "object",
+      "patternProperties": {
+        "^\\$": false
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/expression"
+      }
+    },
+    "constPhrase": {
+      "description": "Quote: the value is returned verbatim, nothing inside is evaluated.",
+      "type": "object",
+      "properties": {
+        "$const": true
+      },
+      "required": [
+        "$const"
+      ],
+      "additionalProperties": false
+    },
+    "mapPhrase": {
+      "description": "General map constructor for computed keys or keys starting with '$'. Each entry is a [keyExpr, valueExpr] pair; keyExpr must evaluate to a single string at runtime (JQ2004); later pairs win on duplicate keys.",
+      "type": "object",
+      "properties": {
+        "$map": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/mapEntry"
+          }
+        }
+      },
+      "required": [
+        "$map"
+      ],
+      "additionalProperties": false
+    },
+    "mapEntry": {
+      "description": "One [keyExpr, valueExpr] pair of a $map phrase.",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/expression"
+      },
+      "minItems": 2,
+      "maxItems": 2
+    },
+    "flworPhrase": {
+      "description": "FLWOR phrase. Clauses apply in the fixed semantic order $for, $let, $as, $where, $groupby, $orderby, $count, $return regardless of JSON key order (D7); interleavings are expressed by nesting phrases. $return is required, plus at least one of $for/$let.",
+      "type": "object",
+      "properties": {
+        "$for": {
+          "$ref": "#/definitions/forBindings"
+        },
+        "$let": {
+          "$ref": "#/definitions/bindingMap"
+        },
+        "$as": {
+          "$ref": "#/definitions/asClause"
+        },
+        "$where": {
+          "$ref": "#/definitions/expression"
+        },
+        "$groupby": {
+          "$ref": "#/definitions/bindingMap"
+        },
+        "$orderby": {
+          "$ref": "#/definitions/orderBySpec"
+        },
+        "$count": {
+          "$ref": "#/definitions/variableName"
+        },
+        "$return": {
+          "$ref": "#/definitions/expression"
+        }
+      },
+      "required": [
+        "$return"
+      ],
+      "anyOf": [
+        {
+          "required": [
+            "$for"
+          ]
+        },
+        {
+          "required": [
+            "$let"
+          ]
+        }
+      ],
+      "additionalProperties": false
+    },
+    "variableName": {
+      "type": "string",
+      "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+    },
+    "forBindings": {
+      "description": "Iteration bindings: variable name to source expression or extended {$in, $at} binding. Bindings nest left-to-right in document key order and may be correlated; key-order-hostile producers should nest phrases instead.",
+      "type": "object",
+      "minProperties": 1,
+      "propertyNames": {
+        "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/forSource"
+      }
+    },
+    "forSource": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/expression"
+        },
+        {
+          "$ref": "#/definitions/extendedForBinding"
+        }
+      ]
+    },
+    "extendedForBinding": {
+      "description": "Extended $for binding: iterates $in and binds $at to the 0-based (D6) position variable.",
+      "type": "object",
+      "properties": {
+        "$in": {
+          "$ref": "#/definitions/expression"
+        },
+        "$at": {
+          "$ref": "#/definitions/variableName"
+        }
+      },
+      "required": [
+        "$in",
+        "$at"
+      ],
+      "additionalProperties": false
+    },
+    "bindingMap": {
+      "description": "Variable name to expression map, used by $let, $groupby and quantifier bindings.",
+      "type": "object",
+      "minProperties": 1,
+      "propertyNames": {
+        "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/expression"
+      }
+    },
+    "orderBySpec": {
+      "description": "A single key spec or a major-to-minor list of key specs. An array value is by specification ALWAYS a list of key specs, so the single form excludes arrays; write a single array-constructor key as {\"$key\": [...]}.",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/singleOrderByKey"
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/orderByKey"
+          },
+          "minItems": 1
+        }
+      ]
+    },
+    "singleOrderByKey": {
+      "description": "A key spec in non-list position: any non-array expression, or the explicit {$key, $dir, $empty} form.",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/scalarLiteral"
+        },
+        {
+          "$ref": "#/definitions/stringExpression"
+        },
+        {
+          "$ref": "#/definitions/objectExpression"
+        },
+        {
+          "$ref": "#/definitions/orderByKeySpec"
+        }
+      ]
+    },
+    "orderByKey": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/expression"
+        },
+        {
+          "$ref": "#/definitions/orderByKeySpec"
+        }
+      ]
+    },
+    "orderByKeySpec": {
+      "description": "Explicit order key: direction defaults to 'asc', empty-sequence placement to 'least'.",
+      "type": "object",
+      "properties": {
+        "$key": {
+          "$ref": "#/definitions/expression"
+        },
+        "$dir": {
+          "enum": [
+            "asc",
+            "desc"
+          ]
+        },
+        "$empty": {
+          "enum": [
+            "least",
+            "greatest"
+          ]
+        }
+      },
+      "required": [
+        "$key"
+      ],
+      "additionalProperties": false
+    },
+    "somePhrase": {
+      "description": "Existential quantifier: true iff some binding tuple satisfies the EBV of $satisfies; short-circuits.",
+      "type": "object",
+      "properties": {
+        "$some": {
+          "$ref": "#/definitions/bindingMap"
+        },
+        "$satisfies": {
+          "$ref": "#/definitions/expression"
+        }
+      },
+      "required": [
+        "$some",
+        "$satisfies"
+      ],
+      "additionalProperties": false
+    },
+    "everyPhrase": {
+      "description": "Universal quantifier: true iff every binding tuple satisfies the EBV of $satisfies; short-circuits.",
+      "type": "object",
+      "properties": {
+        "$every": {
+          "$ref": "#/definitions/bindingMap"
+        },
+        "$satisfies": {
+          "$ref": "#/definitions/expression"
+        }
+      },
+      "required": [
+        "$every",
+        "$satisfies"
+      ],
+      "additionalProperties": false
+    },
+    "unaryOperatorPhrase": {
+      "description": "Operators whose value is a single operand expression.",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$exists",
+          "$empty",
+          "$not",
+          "$neg",
+          "$count",
+          "$sum",
+          "$avg",
+          "$min",
+          "$max",
+          "$distinct",
+          "$reverse",
+          "$sort",
+          "$head",
+          "$tail",
+          "$upper",
+          "$lower",
+          "$string-length",
+          "$normalize-space",
+          "$string",
+          "$number",
+          "$boolean",
+          "$is-string",
+          "$is-number",
+          "$is-boolean",
+          "$is-null",
+          "$is-array",
+          "$is-object"
+        ]
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/expression"
+      }
+    },
+    "binaryOperatorPhrase": {
+      "description": "Operators whose value is an array of exactly two operand expressions.",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$eq",
+          "$ne",
+          "$lt",
+          "$le",
+          "$gt",
+          "$ge",
+          "$add",
+          "$sub",
+          "$mul",
+          "$div",
+          "$idiv",
+          "$mod",
+          "$contains",
+          "$starts-with",
+          "$ends-with",
+          "$match",
+          "$search",
+          "$index-of",
+          "$range",
+          "$get",
+          "$default"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/expression"
+        },
+        "minItems": 2,
+        "maxItems": 2
+      }
+    },
+    "variadicOperatorPhrase": {
+      "description": "Variadic operators accepting zero or more operand expressions.",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$seq",
+          "$concat"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/expression"
+        }
+      }
+    },
+    "nonEmptyVariadicOperatorPhrase": {
+      "description": "Variadic operators requiring at least one operand expression.",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$and",
+          "$or",
+          "$coalesce"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/expression"
+        },
+        "minItems": 1
+      }
+    },
+    "conditionalArityOperatorPhrase": {
+      "description": "Operators taking two or three operand expressions: $if [cond, then, else?], $substring [str, start, len?], $subsequence [seq, start, len?].",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$if",
+          "$substring",
+          "$subsequence"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/expression"
+        },
+        "minItems": 2,
+        "maxItems": 3
+      }
+    },
+    "stringJoinPhrase": {
+      "description": "$string-join [seq, separator?]: one or two operand expressions.",
+      "type": "object",
+      "properties": {
+        "$string-join": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/expression"
+          },
+          "minItems": 1,
+          "maxItems": 2
+        }
+      },
+      "required": [
+        "$string-join"
+      ],
+      "additionalProperties": false
+    },
+    "replacePhrase": {
+      "description": "$replace [input, pattern, replacement]: exactly three operand expressions (I-Regexp has no flags argument, D5).",
+      "type": "object",
+      "properties": {
+        "$replace": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/expression"
+          },
+          "minItems": 3,
+          "maxItems": 3
+        }
+      },
+      "required": [
+        "$replace"
+      ],
+      "additionalProperties": false
+    },
+    "schemaLiteral": {
+      "description": "A JSON Schema literal, taken verbatim - never interpreted as a query expression, so JSON Schema's $-prefixed keywords ($ref, $defs, ...) do not collide with Rule 1. Deliberately unconstrained (a true schema is draft-neutral by definition): embedded schemas are not meta-validated by this artifact; the consumer's type-test compiler is authoritative (JQ0009)."
+    },
+    "schemaOperatorPhrase": {
+      "description": "Schema operators $valid/$assert: [expr, schema] - exactly two elements, an operand expression and a verbatim JSON Schema literal. Tuple validation is outside the draft-neutral subset, so both positions validate uniformly as schema literals here; the operand position is normalized as an ordinary expression by the compiler (JQ0xxx).",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$valid",
+          "$assert"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/schemaLiteral"
+        },
+        "minItems": 2,
+        "maxItems": 2
+      }
+    },
+    "asClause": {
+      "description": "The $as clause: variable-name to JSON Schema literal members, applied per tuple after $for/$let binding and before $where. Each name must be bound by the same phrase's $for (including $at names) or $let - a compiler rule (JQ0005); each binding validates per item at runtime (JQ2008).",
+      "type": "object",
+      "minProperties": 1,
+      "propertyNames": {
+        "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/schemaLiteral"
+      }
+    },
+    "applyPhrase": {
+      "description": "JSLT body-only $apply phrase. A non-array value is any expression except an array constructor. An array value is the argument list [selector] or [selector, mode]. The draft-neutral subset has no positional-array keyword, so the compiler remains authoritative that a two-item list's second item is a literal string (JT0007 wrapping JQ0003).",
+      "type": "object",
+      "properties": {
+        "$apply": {
+          "oneOf": [
+            {
+              "description": "Bare selector form: any non-array expression.",
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/scalarLiteral"
+                },
+                {
+                  "$ref": "#/definitions/stringExpression"
+                },
+                {
+                  "$ref": "#/definitions/objectExpression"
+                }
+              ]
+            },
+            {
+              "description": "Argument-list form: [selector] or [selector, mode]. Items are expressions uniformly for draft neutrality; the compiler enforces the literal-string mode position.",
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/expression"
+              },
+              "minItems": 1,
+              "maxItems": 2
+            }
+          ]
+        }
+      },
+      "required": [
+        "$apply"
+      ],
+      "additionalProperties": false
+    }
+  }
+}