@particle-academy/fancy-conformance 0.14.0 → 0.15.0

package/VERSION

@@ -1 +1 @@
-0.14.0
+0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@particle-academy/fancy-conformance",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Shared cross-language conformance fixtures for the Fancy suite. One contract, N implementations, and a single table that every implementation asserts in its own CI \u2014 so 'parity' is a test result rather than a claim. Ships the fixture data itself, so a Rust, Go or Python runner can consume it without a JavaScript toolchain.",
   "repository": {
     "type": "git",

package/suites/expr/evaluate/cases.json

@@ -1243,6 +1243,192 @@
         "ok": false
       },
       "notes": "Sandboxing is a security property, not a style preference: these expressions arrive from end users and from agents, over the wire. No calls, no host reach, in any implementation."
+    },
+    {
+      "id": "0901-array-length",
+      "title": "`.length` counts an array.",
+      "since": "0.15.0",
+      "tags": [
+        "expr",
+        "length"
+      ],
+      "input": {
+        "expression": "in.items.length",
+        "context": {
+          "in": {
+            "content": "hello",
+            "count": 3,
+            "deal_id": "D-1",
+            "transcript": null,
+            "items": [
+              1,
+              2
+            ],
+            "empty": [],
+            "obj": {},
+            "flag": true,
+            "zero": 0,
+            "blank": ""
+          },
+          "user": {
+            "name": "Ada"
+          }
+        }
+      },
+      "expected": {
+        "ok": true,
+        "value": 2
+      },
+      "notes": "The one pseudo-property, and it is load-bearing: `[]` is TRUTHY (0301), so without `.length` a consumer has no way to ask whether a collection is empty. The grammar would assert that an array which exists is a value and then leave nobody able to test the thing they care about."
+    },
+    {
+      "id": "0902-empty-array-length",
+      "title": "An empty array has length 0 while still being truthy.",
+      "since": "0.15.0",
+      "tags": [
+        "expr",
+        "length"
+      ],
+      "input": {
+        "expression": "in.empty.length",
+        "context": {
+          "in": {
+            "content": "hello",
+            "count": 3,
+            "deal_id": "D-1",
+            "transcript": null,
+            "items": [
+              1,
+              2
+            ],
+            "empty": [],
+            "obj": {},
+            "flag": true,
+            "zero": 0,
+            "blank": ""
+          },
+          "user": {
+            "name": "Ada"
+          }
+        }
+      },
+      "expected": {
+        "ok": true,
+        "value": 0
+      },
+      "notes": "The pair that makes the truthiness decision coherent: truthy AND countable. An implementation that made [] falsy would pass this row and fail 0301."
+    },
+    {
+      "id": "0903-string-length",
+      "title": "`.length` counts a string.",
+      "since": "0.15.0",
+      "tags": [
+        "expr",
+        "length"
+      ],
+      "input": {
+        "expression": "in.content.length",
+        "context": {
+          "in": {
+            "content": "hello",
+            "count": 3,
+            "deal_id": "D-1",
+            "transcript": null,
+            "items": [
+              1,
+              2
+            ],
+            "empty": [],
+            "obj": {},
+            "flag": true,
+            "zero": 0,
+            "blank": ""
+          },
+          "user": {
+            "name": "Ada"
+          }
+        }
+      },
+      "expected": {
+        "ok": true,
+        "value": 5
+      }
+    },
+    {
+      "id": "0904-object-has-no-length",
+      "title": "An object has NO `.length`.",
+      "since": "0.15.0",
+      "tags": [
+        "expr",
+        "length",
+        "deliberate"
+      ],
+      "input": {
+        "expression": "in.obj.length",
+        "context": {
+          "in": {
+            "content": "hello",
+            "count": 3,
+            "deal_id": "D-1",
+            "transcript": null,
+            "items": [
+              1,
+              2
+            ],
+            "empty": [],
+            "obj": {},
+            "flag": true,
+            "zero": 0,
+            "blank": ""
+          },
+          "user": {
+            "name": "Ada"
+          }
+        }
+      },
+      "expected": {
+        "ok": true,
+        "value": null
+      },
+      "notes": "Deliberate. There is no count three languages would agree on for an object, and an object used as a collection is rare enough not to justify inventing one. Null here is the ordinary absent-path answer, not a special case."
+    },
+    {
+      "id": "0905-length-is-not-host-reach",
+      "title": "No other host property is reachable.",
+      "since": "0.15.0",
+      "tags": [
+        "expr",
+        "length",
+        "sandbox"
+      ],
+      "input": {
+        "expression": "in.items.constructor",
+        "context": {
+          "in": {
+            "content": "hello",
+            "count": 3,
+            "deal_id": "D-1",
+            "transcript": null,
+            "items": [
+              1,
+              2
+            ],
+            "empty": [],
+            "obj": {},
+            "flag": true,
+            "zero": 0,
+            "blank": ""
+          },
+          "user": {
+            "name": "Ada"
+          }
+        }
+      },
+      "expected": {
+        "ok": true,
+        "value": null
+      },
+      "notes": "`.length` is a computed count, not an opening. Nothing else on the prototype chain resolves -- these expressions arrive from end users and from agents, over the wire."
     }
   ]
 }

package/suites/expr/evaluate/manifest.json

@@ -11,9 +11,21 @@
     "reference": "node",
     "referenceNote": "No implementation exists yet in any language. This table is written FIRST and every implementation is built against it, which is the whole argument for owning the grammar rather than adopting three libraries that disagree.",
     "implementations": [
-      { "language": "node", "package": "@particle-academy/fancy-expr", "symbol": "evaluate" },
-      { "language": "php", "package": "particle-academy/fancy-expr", "symbol": "FancyExpr\\Expr::evaluate" },
-      { "language": "python", "package": "fancy-expr", "symbol": "fancy_expr.evaluate" }
+      {
+        "language": "node",
+        "package": "@particle-academy/fancy-expr",
+        "symbol": "evaluate"
+      },
+      {
+        "language": "php",
+        "package": "particle-academy/fancy-expr",
+        "symbol": "FancyExpr\\Expr::evaluate"
+      },
+      {
+        "language": "python",
+        "package": "fancy-expr",
+        "symbol": "fancy_expr.evaluate"
+      }
     ]
   },
   "notes": [
@@ -23,6 +35,7 @@
     "`==` AND `===` ARE THE SAME OPERATOR (0501-0503), and neither coerces. Both spellings are accepted because authors write both. Two equality operators that differ subtly is a language that generates bug reports, and there are three runtimes to keep in step.",
     "`&&` AND `||` RETURN THE OPERAND, NOT A BOOLEAN (0401-0404). That is what makes `in.transcript || in.content` a useful fallback rather than merely `true` — and the reported production case wrote exactly that shape.",
     "MALFORMED EXPRESSIONS FAIL (0801-0805) and never return null. A null there would be indistinguishable from an absent path, which is the defect being removed. 0805 pins that a function call does not parse: sandboxing is a security property here, not a style preference, because these expressions arrive from end users and from agents over the wire.",
-    "This suite needs DISCRIMINATION PROBES before it can claim more than drift-guarding — deliberately-wrong evaluators that must each fail an exact set of ids. Notably: one that uses native truthiness (must fail 0301/0302), one that coerces on `==` (must fail 0503), and one that returns booleans from `&&`/`||` (must fail 0401/0403/0404). Not yet written; recorded so a green tick is not read as the stronger claim."
+    "This suite needs DISCRIMINATION PROBES before it can claim more than drift-guarding — deliberately-wrong evaluators that must each fail an exact set of ids. Notably: one that uses native truthiness (must fail 0301/0302), one that coerces on `==` (must fail 0503), and one that returns booleans from `&&`/`||` (must fail 0401/0403/0404). Not yet written; recorded so a green tick is not read as the stronger claim.",
+    "`.length` (0901-0905) IS the one pseudo-property, and it is load-bearing rather than convenient. Because `[]` is TRUTHY, a consumer with no `.length` would have no way to ask whether a collection is EMPTY -- the grammar would assert that an array which exists is a value and then leave nobody able to test the thing they care about. It is a computed count, not host reach: nothing is called and no prototype is walked, and 0905 pins that nothing else on the chain resolves. Objects deliberately have none (0904), since no count would survive three languages. These rows were added after writing the reference implementation's discrimination tests found the SPEC contradicting the CODE -- the truthiness rule was justified with `.length` while `.length` returned null."
   ]
 }