@particle-academy/fancy-conformance 0.22.1 → 0.23.0

package/README.md

@@ -1,5 +1,7 @@
 # fancy-conformance
 
+[![Fancified](art/fancified.svg)](https://particle.academy)
+
 Shared cross-language conformance fixtures for the [Fancy](https://ui.particle.academy) suite.
 
 One contract, N implementations, and a single fixture table that **every**

package/VERSION

@@ -1 +1 @@
-0.22.1
+0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@particle-academy/fancy-conformance",
-  "version": "0.22.1",
+  "version": "0.23.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 — 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/shared/expr/cases.json

@@ -181,6 +181,75 @@
       "fn": "truthy",
       "input": { "value": "no thanks" },
       "expected": true
+    },
+    {
+      "id": "0021-several-references-interpolate-each",
+      "title": "A template that starts with `{{` and ends with `}}` but holds two references interpolates both",
+      "since": "0.23.0",
+      "tags": ["evaluate", "regression"],
+      "fn": "evaluateExpression",
+      "input": {
+        "template": "{{ in.text }} --- {{ user.transcript }}",
+        "context": { "in": { "text": "SUMMARY" }, "user": { "transcript": "TRANSCRIPT" } }
+      },
+      "expected": "SUMMARY --- TRANSCRIPT",
+      "notes": "fancy-flow-php#16. Every runtime used to read this as ONE whole expression whose path was `in.text }} --- {{ user.transcript`, because the whole-string test only asked whether the trimmed template starts with `{{` and ends with `}}`. That path never resolves, so the template returned null and a document node wrote nothing, with both references individually valid. It was documented as a deliberate corner in all four runtimes, so no row here could see it. Golden from fancy-flow-php 0.52.2; 0.52.1 returns null."
+    },
+    {
+      "id": "0022-several-references-across-newlines",
+      "title": "A multi-line template with a reference on its first and last line interpolates, trailing newline kept",
+      "since": "0.23.0",
+      "tags": ["evaluate", "regression"],
+      "fn": "evaluateExpression",
+      "input": {
+        "template": "{{ in.text }}\n\n---\n\n## Original\n\n{{ user.transcript }}\n",
+        "context": { "in": { "text": "SUMMARY" }, "user": { "transcript": "TRANSCRIPT" } }
+      },
+      "expected": "SUMMARY\n\n---\n\n## Original\n\nTRANSCRIPT\n",
+      "notes": "The production shape from #16: a prompt or document template whose first and last lines are references. Two things are pinned. The whole-string test runs on the TRIMMED template, so a trailing newline does not protect it from the old corner; and the interpolation runs on the UNTRIMMED template, so the newline survives. A port that interpolated the trimmed string would drop it."
+    },
+    {
+      "id": "0023-adjacent-references-are-two-references",
+      "title": "`{{ a }}{{ b }}` is two references, interpolated as text",
+      "since": "0.23.0",
+      "tags": ["evaluate", "regression", "stringify"],
+      "fn": "evaluateExpression",
+      "input": { "template": "{{ a }}{{ b }}", "context": { "a": 1, "b": 2 } },
+      "expected": "12",
+      "notes": "The corner the runtimes' own docs used to name as deliberate: one path, `a }}{{ b`, that resolved to null. The golden is the STRING \"12\" — two numbers interpolated as text, not added and not typed."
+    },
+    {
+      "id": "0024-padded-single-expression-keeps-type",
+      "title": "Exactly one expression, with surrounding whitespace, still returns the typed value",
+      "since": "0.23.0",
+      "tags": ["evaluate", "types"],
+      "fn": "evaluateExpression",
+      "input": { "template": " {{ a }} ", "context": { "a": 1, "b": 2 } },
+      "expected": 1,
+      "notes": "The other side of 0021-0023. The fix narrows the whole-string branch; it must not remove it. A port that 'fixed' #16 by always interpolating passes 0021-0023 and fails this row and 0001."
+    },
+    {
+      "id": "0025-one-unresolved-reference-of-several-interpolates-empty",
+      "title": "When one of several references does not resolve, the others still interpolate",
+      "since": "0.23.0",
+      "tags": ["evaluate", "regression"],
+      "fn": "evaluateExpression",
+      "input": {
+        "template": "{{ in.text }} / {{ in.nope }}",
+        "context": { "in": { "text": "SUMMARY" } }
+      },
+      "expected": "SUMMARY / ",
+      "notes": "The unresolved-path policy applies PER REFERENCE, not to the template. This table models only the default policy (an unresolved reference interpolates to empty); the contract takes no policy argument and fancy-flow-rs has none. Under Keep the golden is \"SUMMARY / {{ in.nope }}\" and under Throw evaluation throws; those are pinned in each runtime's own suite (fancy-flow-php TemplateWithSeveralReferencesTest and its TypeScript and Python ports). Before #16 this returned null."
+    },
+    {
+      "id": "0026-an-inner-opening-brace-is-not-one-expression",
+      "title": "A template whose inner text holds `{{` is not a single expression either",
+      "since": "0.23.0",
+      "tags": ["evaluate", "regression"],
+      "fn": "evaluateExpression",
+      "input": { "template": "{{ a {{ b }}", "context": { "a": 1, "b": 2 } },
+      "expected": "",
+      "notes": "The rule has TWO conditions: the inner text may contain neither `}}` nor `{{`. 0021-0023 all contain `}}`, so a port that checked only that half would pass them and still read this template as one path. It fails here instead: the whole-string branch returns null, and the golden is the empty STRING. The template is malformed, and the value is simply what the scan does with it (the first `{{` pairs with the first `}}`, giving the path `a {{ b`, which does not resolve). This row pins the rule, not that reading."
     }
   ]
 }

package/suites/shared/expr/manifest.json

@@ -10,13 +10,17 @@
     "summary": "Resolve a dot-path template against an executor's inputs, and decide branch truthiness. Deliberately NOT a general expression language: dot-paths only, no arithmetic, comparisons or calls.",
     "implementations": [
       { "language": "php", "package": "particle-academy/fancy-flow-php", "symbol": "FancyFlow\\Nodes\\Support\\Expr" },
-      { "language": "node", "package": "@particle-academy/fancy-flow", "symbol": "evaluateExpression / truthy" }
+      { "language": "node", "package": "@particle-academy/fancy-flow", "symbol": "evaluateExpression / truthy" },
+      { "language": "python", "package": "fancy-flow", "symbol": "fancy_flow.nodes.support.expr.evaluate / truthy" },
+      { "language": "rust", "package": "fancy-flow", "symbol": "fancy_flow::nodes::support::expr::evaluate / truthy" }
     ]
   },
   "notes": [
     "This suite exists because of what conformance could NOT catch. `Expr` shipped in PHP with no TypeScript twin at all, and a fixture table compares two implementations — it is structurally unable to report a MISSING one. The gap surfaced only when someone asked for editor autocomplete over a grammar and the grammar turned out to live on one side.",
     "`truthy` is where the two languages disagree by default, so those rows carry the weight. `\"0\"`, `\"false\"` and `[]` are all truthy in JavaScript and falsy here; a branch node reading a form value or a JSON body hits every one of them. An implementation that forwards to native truthiness fails cases 0013-0015 and nothing else, which is exactly the signal wanted.",
     "Case 0008 pins that a missing path interpolates to an empty string rather than the text \"null\" — the difference between a quietly-blank message and one that ships the word null to a customer.",
-    "fancy-flow's own `runFlow` does not call this. The PHP runtime resolves expressions inside its executors; the JS runtime hands config to the host's executor verbatim, and every host that uses `{{ }}` today already resolves it itself. Turning it on inside `runFlow` would interpolate a second time over values those hosts had already substituted. The TS side is therefore an opt-in export, and this suite pins its SEMANTICS, not where it is called from."
+    "fancy-flow's own `runFlow` does not call this. The PHP runtime resolves expressions inside its executors; the JS runtime hands config to the host's executor verbatim, and every host that uses `{{ }}` today already resolves it itself. Turning it on inside `runFlow` would interpolate a second time over values those hosts had already substituted. The TS side is therefore an opt-in export, and this suite pins its SEMANTICS, not where it is called from.",
+    "A WHOLE-STRING EXPRESSION IS EXACTLY ONE `{{ }}` (0021-0026, since 0.23.0). Until fancy-flow-php 0.52.2 every runtime asked only whether the trimmed template starts with `{{` and ends with `}}`, so `{{ in.text }} --- {{ user.transcript }}` became one path that never resolves and the template returned null (fancy-flow-php#16, hit in production). All four runtimes documented it as a deliberate corner and reproduced it faithfully, and a table compares runtimes with each other: agreement on a bug reads as parity. The rule now is that the inner text may contain neither `}}` nor `{{`; anything else interpolates each reference. A runtime still carrying the corner fails 0021, 0022, 0023, 0025 and 0026 and nothing else; one that checks only `}}` fails 0026 alone; one that drops the typed branch altogether fails 0001, 0007 and 0024. `tests/discrimination-shared-expr.test.ts` asserts those exact sets.",
+    "THIS TABLE MODELS ONLY THE DEFAULT UNRESOLVED-PATH POLICY. The contract takes no policy argument, and fancy-flow-rs has no policy at all. PHP, TypeScript and Python also offer Keep (the `{{ }}` text stays) and Throw; each pins those in its own suite, including for 0025's partly unresolved template."
   ]
 }