@jarenjs/json 0.9.2 → 0.34.0

package/schemas/geojson.schema.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jarenjs.dev/schemas/geojson",
+  "title": "GeoJSON (RFC 7946)",
+  "description": "Structural grammar of GeoJSON objects per RFC 7946. This artifact is deliberately PORTABLE: it uses only plain draft-neutral JSON Schema keywords and no Jaren extension, so any validator can consume it. It therefore stops exactly where JSON Schema stops - it CANNOT express that a linear ring is closed (first position equal to last) or that rings follow the right-hand rule (exterior counter-clockwise, holes clockwise), because neither is a structural property. Those two invariants are among the commonest defects in real GeoJSON, and geojson.jaren.schema.json adds them through the $query keyword. Coordinates are longitude, latitude, in that order, in WGS 84 decimal degrees: RFC 7946 removed alternative coordinate reference systems, so there is no crs member to validate.",
+  "allOf": [
+    { "$ref": "#/$defs/geoJsonObject" }
+  ],
+  "$defs": {
+    "geoJsonObject": {
+      "description": "Any GeoJSON object: a geometry, a Feature, or a FeatureCollection.",
+      "oneOf": [
+        { "$ref": "#/$defs/geometry" },
+        { "$ref": "#/$defs/feature" },
+        { "$ref": "#/$defs/featureCollection" }
+      ]
+    },
+    "geometry": {
+      "description": "One of the seven geometry types of RFC 7946 section 3.1.",
+      "oneOf": [
+        { "$ref": "#/$defs/point" },
+        { "$ref": "#/$defs/multiPoint" },
+        { "$ref": "#/$defs/lineString" },
+        { "$ref": "#/$defs/multiLineString" },
+        { "$ref": "#/$defs/polygon" },
+        { "$ref": "#/$defs/multiPolygon" },
+        { "$ref": "#/$defs/geometryCollection" }
+      ]
+    },
+    "position": {
+      "description": "A position: longitude, latitude, and optionally altitude, in that order (RFC 7946 section 3.1.1). Longitude and latitude are bounded because the coordinate reference system is fixed to WGS 84.",
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 3,
+      "prefixItems": [
+        { "type": "number", "minimum": -180, "maximum": 180 },
+        { "type": "number", "minimum": -90, "maximum": 90 }
+      ],
+      "items": { "type": "number" }
+    },
+    "linearRing": {
+      "description": "A closed LineString of four or more positions. JSON Schema can require the count but NOT that the first and last positions are equal, which is why this artifact alone cannot fully validate a polygon.",
+      "type": "array",
+      "minItems": 4,
+      "items": { "$ref": "#/$defs/position" }
+    },
+    "bbox": {
+      "description": "All axes of the most south-westerly position followed by all axes of the more north-easterly one (RFC 7946 section 5): four numbers in two dimensions, six in three.",
+      "type": "array",
+      "oneOf": [
+        { "minItems": 4, "maxItems": 4 },
+        { "minItems": 6, "maxItems": 6 }
+      ],
+      "items": { "type": "number" }
+    },
+    "point": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "Point" },
+        "coordinates": { "$ref": "#/$defs/position" },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "multiPoint": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "MultiPoint" },
+        "coordinates": { "type": "array", "items": { "$ref": "#/$defs/position" } },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "lineString": {
+      "description": "Two or more positions (RFC 7946 section 3.1.4).",
+      "type": "object",
+      "properties": {
+        "type": { "const": "LineString" },
+        "coordinates": {
+          "type": "array",
+          "minItems": 2,
+          "items": { "$ref": "#/$defs/position" }
+        },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "multiLineString": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "MultiLineString" },
+        "coordinates": {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "items": { "$ref": "#/$defs/position" }
+          }
+        },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "polygon": {
+      "description": "An array of linear rings: the exterior ring first, then holes (RFC 7946 section 3.1.6). Ring closure and the right-hand rule are NOT checked here - see this schema's description.",
+      "type": "object",
+      "properties": {
+        "type": { "const": "Polygon" },
+        "coordinates": { "type": "array", "items": { "$ref": "#/$defs/linearRing" } },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "multiPolygon": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "MultiPolygon" },
+        "coordinates": {
+          "type": "array",
+          "items": { "type": "array", "items": { "$ref": "#/$defs/linearRing" } }
+        },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "coordinates"],
+      "additionalProperties": false
+    },
+    "geometryCollection": {
+      "description": "A heterogeneous collection of geometries. RFC 7946 section 3.1.8 advises against nesting one inside another.",
+      "type": "object",
+      "properties": {
+        "type": { "const": "GeometryCollection" },
+        "geometries": { "type": "array", "items": { "$ref": "#/$defs/geometry" } },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "geometries"],
+      "additionalProperties": false
+    },
+    "feature": {
+      "description": "A geometry with properties. Both members are REQUIRED and both are nullable (RFC 7946 section 3.2).",
+      "type": "object",
+      "properties": {
+        "type": { "const": "Feature" },
+        "geometry": {
+          "oneOf": [
+            { "type": "null" },
+            { "$ref": "#/$defs/geometry" }
+          ]
+        },
+        "properties": { "type": ["object", "null"] },
+        "id": { "type": ["string", "number"] },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "geometry", "properties"],
+      "additionalProperties": false
+    },
+    "featureCollection": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "FeatureCollection" },
+        "features": { "type": "array", "items": { "$ref": "#/$defs/feature" } },
+        "bbox": { "$ref": "#/$defs/bbox" }
+      },
+      "required": ["type", "features"],
+      "additionalProperties": false
+    }
+  }
+}

package/schemas/jaren-jslt.authoring.schema.json

@@ -0,0 +1,142 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jarenjs.dev/schemas/jaren-jslt/0.1/authoring",
+  "title": "Jaren JSLT format 0.1 (authoring profile)",
+  "description": "Authoring profile of the canonical grammar: the document SHAPE only, with queryDocument left open. Constrains decoding on small models, where the full grammar does not decode at all. It is deliberately WEAKER than the canonical schema - a document valid here may be nonsense - so the engine compiler is the gate that makes it safe, and generated documents must be compiled before use.",
+  "allOf": [
+    {
+      "$ref": "#/$defs/stylesheetDocument"
+    }
+  ],
+  "$defs": {
+    "stylesheetDocument": {
+      "description": "A JSLT stylesheet is either a bare array of rules or the versioned envelope object.",
+      "anyOf": [
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/rule"
+          }
+        },
+        {
+          "$ref": "#/$defs/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": "#/$defs/rule"
+          }
+        },
+        "unmatched": {
+          "$ref": "#/$defs/dispositionValue"
+        },
+        "modes": {
+          "$ref": "#/$defs/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": "#/$defs/matchSpec"
+        },
+        "mode": {
+          "type": "string"
+        },
+        "priority": {
+          "type": "number"
+        },
+        "body": {
+          "$ref": "#/$defs/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.",
+      "anyOf": [
+        {
+          "type": "string",
+          "description": "(LLM profile: the 'json-path' format assertion is relaxed here; the canonical schema enforces it)"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string",
+              "description": "(LLM profile: the 'json-path' format assertion is relaxed here; the canonical schema enforces it)"
+            },
+            "schema": {
+              "$ref": "#/$defs/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": "#/$defs/modeConfig"
+      }
+    },
+    "modeConfig": {
+      "type": "object",
+      "properties": {
+        "unmatched": {
+          "$ref": "#/$defs/dispositionValue"
+        }
+      },
+      "required": [
+        "unmatched"
+      ],
+      "additionalProperties": false
+    },
+    "queryDocument": {
+      "description": "A jaren-query expression: a JSONPath string starting with \"$\", a literal, or a one-member operator object such as {\"$sum\": \"$.prices[*]\"} or {\"$sub\": [\"$a\", \"$b\"]}. Any JSON value decodes here; the engine compiler is the authority for whether it is a legal expression."
+    },
+    "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)."
+    }
+  }
+}

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

@@ -220,9 +220,10 @@
       "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).",
+      "description": "A variable-rooted path: '$name' with name matching [A-Za-z_][A-Za-z0-9_]*, optionally followed by RFC 9535 segments. The pattern checks the head; the json-path-segments format asserts the full segment grammar where format assertion is enabled (the compiler enforces it either way, JQ0004).",
       "type": "string",
-      "pattern": "^\\$[A-Za-z_][A-Za-z0-9_]*($|[.\\[])"
+      "pattern": "^\\$[A-Za-z_][A-Za-z0-9_]*($|[.\\[])",
+      "format": "json-path-segments"
     },
     "arrayConstructor": {
       "description": "An array in expression position constructs an array; element results are concatenated per XQuery sequence flattening.",
@@ -243,6 +244,9 @@
         {
           "$ref": "#/definitions/mapPhrase"
         },
+        {
+          "$ref": "#/definitions/callPhrase"
+        },
         {
           "$ref": "#/definitions/flworPhrase"
         },
@@ -270,6 +274,12 @@
         {
           "$ref": "#/definitions/stringJoinPhrase"
         },
+        {
+          "$ref": "#/definitions/geohashPhrase"
+        },
+        {
+          "$ref": "#/definitions/ternaryOperatorPhrase"
+        },
         {
           "$ref": "#/definitions/replacePhrase"
         },
@@ -328,9 +338,12 @@
       "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.",
+      "description": "FLWOR phrase. Clauses apply in the fixed semantic order $fold, $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 $fold/$for/$let. With $fold the phrase evaluates to the final accumulator instead of the collected $return sequence.",
       "type": "object",
       "properties": {
+        "$fold": {
+          "$ref": "#/definitions/foldBinding"
+        },
         "$for": {
           "$ref": "#/definitions/forBindings"
         },
@@ -369,6 +382,11 @@
           "required": [
             "$let"
           ]
+        },
+        {
+          "required": [
+            "$fold"
+          ]
         }
       ],
       "additionalProperties": false
@@ -378,7 +396,7 @@
       "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.",
+      "description": "Iteration bindings: variable name to source expression or extended $in 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": {
@@ -399,7 +417,7 @@
       ]
     },
     "extendedForBinding": {
-      "description": "Extended $for binding: iterates $in and binds $at to the 0-based (D6) position variable.",
+      "description": "Extended $for binding. $in is the source; $at binds the 0-based (D6) position variable; $allowing-empty emits one tuple with the variable bound to the empty sequence (position -1) when the source yields no tuple; $window with $size, and optionally $step, iterates tumbling or sliding windows instead of items. Only $in is structurally required: the compiler rejects $size/$step without $window, and $window without $size (JQ0003).",
       "type": "object",
       "properties": {
         "$in": {
@@ -407,11 +425,27 @@
         },
         "$at": {
           "$ref": "#/definitions/variableName"
+        },
+        "$allowing-empty": {
+          "type": "boolean"
+        },
+        "$window": {
+          "enum": [
+            "tumbling",
+            "sliding"
+          ]
+        },
+        "$size": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "$step": {
+          "type": "integer",
+          "minimum": 1
         }
       },
       "required": [
-        "$in",
-        "$at"
+        "$in"
       ],
       "additionalProperties": false
     },
@@ -469,7 +503,7 @@
       ]
     },
     "orderByKeySpec": {
-      "description": "Explicit order key: direction defaults to 'asc', empty-sequence placement to 'least'.",
+      "description": "Explicit order key: direction defaults to 'asc', empty-sequence placement to 'least'. A $collation names a registered pure compare function (options.collations, JQ0010) applied to string keys; the default stays code-point order.",
       "type": "object",
       "properties": {
         "$key": {
@@ -486,6 +520,10 @@
             "least",
             "greatest"
           ]
+        },
+        "$collation": {
+          "type": "string",
+          "minLength": 1
         }
       },
       "required": [
@@ -548,6 +586,8 @@
           "$sort",
           "$head",
           "$tail",
+          "$entries",
+          "$from-entries",
           "$upper",
           "$lower",
           "$string-length",
@@ -560,7 +600,28 @@
           "$is-boolean",
           "$is-null",
           "$is-array",
-          "$is-object"
+          "$is-object",
+          "$is-date",
+          "$is-time",
+          "$is-datetime",
+          "$is-duration",
+          "$year",
+          "$month",
+          "$day",
+          "$hours",
+          "$minutes",
+          "$seconds",
+          "$offset",
+          "$epoch",
+          "$datetime",
+          "$week",
+          "$week-year",
+          "$quarter",
+          "$weekday",
+          "$bbox",
+          "$area",
+          "$length",
+          "$centroid"
         ]
       },
       "additionalProperties": {
@@ -594,6 +655,12 @@
           "$index-of",
           "$range",
           "$get",
+          "$start-of",
+          "$end-of",
+          "$date-format",
+          "$distance",
+          "$within",
+          "$bbox-intersects",
           "$default"
         ]
       },
@@ -645,7 +712,7 @@
       }
     },
     "conditionalArityOperatorPhrase": {
-      "description": "Operators taking two or three operand expressions: $if [cond, then, else?], $substring [str, start, len?], $subsequence [seq, start, len?].",
+      "description": "Operators taking two or three operand expressions: $if [cond, then, else?], $substring [str, start, len?], $subsequence [seq, start, len?], $date-add / $date-sub [date, duration] or [date, amount, unit].",
       "type": "object",
       "minProperties": 1,
       "maxProperties": 1,
@@ -653,7 +720,9 @@
         "enum": [
           "$if",
           "$substring",
-          "$subsequence"
+          "$subsequence",
+          "$date-add",
+          "$date-sub"
         ]
       },
       "additionalProperties": {
@@ -771,6 +840,78 @@
         "$apply"
       ],
       "additionalProperties": false
+    },
+    "callPhrase": {
+      "description": "A registered trusted host function call: ['name', ...argument expressions]. The name must be registered at compile time (options.functions, JQ0010); sequences cross the boundary as arrays, a returned undefined is the empty sequence, a throwing function is JQ2010.",
+      "type": "object",
+      "properties": {
+        "$call": {
+          "type": "array",
+          "minItems": 1,
+          "items": [
+            {
+              "type": "string",
+              "minLength": 1
+            }
+          ],
+          "additionalItems": {
+            "$ref": "#/definitions/expression"
+          }
+        }
+      },
+      "required": [
+        "$call"
+      ],
+      "additionalProperties": false
+    },
+    "foldBinding": {
+      "description": "The $fold accumulator: exactly one variable name mapped to the accumulator's initial value, evaluated once in the enclosing scope before the tuple stream starts. $return then names the accumulator's next value per surviving tuple.",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/expression"
+      }
+    },
+    "ternaryOperatorPhrase": {
+      "description": "Operators whose value is an array of exactly three operand expressions: $date-diff [from, to, unit].",
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 1,
+      "propertyNames": {
+        "enum": [
+          "$date-diff"
+        ]
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/expression"
+        },
+        "minItems": 3,
+        "maxItems": 3
+      }
+    },
+    "geohashPhrase": {
+      "description": "$geohash [value] or [value, precision]: a GeoJSON value as a base-32 cell string. Precision is an integer from 1 to 12 (default 9); a value that is not a bare position is represented by its centroid.",
+      "type": "object",
+      "properties": {
+        "$geohash": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/expression"
+          },
+          "minItems": 1,
+          "maxItems": 2
+        }
+      },
+      "required": [
+        "$geohash"
+      ],
+      "additionalProperties": false
     }
   }
 }