@particle-academy/fancy-conformance 0.0.0 → 0.2.0

package/suites/shared/satisfies-range/manifest.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../../../schema/suite-manifest.schema.json",
+  "suite": "shared/satisfies-range",
+  "title": "Minimal semver range matching",
+  "since": "0.1.0",
+  "caseFormat": "table",
+  "cases": "cases.json",
+  "contract": {
+    "function": "satisfiesRange(version: string, range: string): boolean",
+    "summary": "Does a concrete version satisfy a manifest's declared range?",
+    "implementations": [
+      { "language": "node", "package": "@particle-academy/fancy-ui-cli", "symbol": "satisfiesRange" },
+      { "language": "node", "package": "@particle-academy/fancy-flow", "symbol": "satisfiesRange" },
+      { "language": "php", "package": "particle-academy/fancy-flow-php", "symbol": "NodeManifest::satisfiesRange" }
+    ]
+  },
+  "notes": [
+    "This suite is the one promoted verbatim from code that already existed, because it is the proof the method works. Three independent implementations of this function have NOT drifted, and the only thing they do differently from the suite's other triplicated contracts is that each carries this identical table in its own CI.",
+    "Two rows deliberately disagree with standard semver. They are tagged `non-standard` and a fourth implementation reaching for a stock semver library will fail exactly those two. That is the intended outcome: the disagreement should be a red build, not a discovery."
+  ]
+}

package/suites/shared/strings/cases.json

@@ -0,0 +1,293 @@
+{
+  "$schema": "../../../schema/case-table.schema.json",
+  "suite": "shared/strings",
+  "cases": [
+    {
+      "id": "0001-ascii-baseline",
+      "title": "ASCII baseline — markers segment as expected",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "regression"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "plain **bold** and `code` end"
+      },
+      "expected": [
+        {
+          "text": "plain ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "bold",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": " and ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "code",
+          "b": false,
+          "i": false,
+          "code": true
+        },
+        {
+          "text": " end",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "The control. If this row fails, the implementation is broken generally rather than on Unicode specifically, and the rows below tell you nothing."
+    },
+    {
+      "id": "0002-cjk-heading-text",
+      "title": "CJK text around bold markers",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "cjk"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "CJK 日本語の見出し **強調** です"
+      },
+      "expected": [
+        {
+          "text": "CJK 日本語の見出し ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "強調",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": " です",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "Multi-byte in UTF-8, single code unit in UTF-16. A byte-indexing implementation is safe here only because UTF-8 is self-synchronising — no continuation byte can collide with an ASCII marker."
+    },
+    {
+      "id": "0003-accented-latin",
+      "title": "Accented Latin around bold and code",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "latin1-supplement"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "café **bold** and naïve `code`"
+      },
+      "expected": [
+        {
+          "text": "café ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "bold",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": " and naïve ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "code",
+          "b": false,
+          "i": false,
+          "code": true
+        }
+      ]
+    },
+    {
+      "id": "0004-emoji-surrogate",
+      "title": "Emoji (astral plane) around bold markers",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "emoji",
+        "surrogate"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "emoji 🎉 **bold** end"
+      },
+      "expected": [
+        {
+          "text": "emoji 🎉 ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "bold",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": " end",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "A surrogate PAIR in UTF-16, so the JS loop visits it as two separate iterations and reassembles it by appending both halves in order. Rust cannot inherit this: slicing &str at a non-char boundary panics rather than producing half a character."
+    },
+    {
+      "id": "0005-combining-mark",
+      "title": "Combining mark is not split from its base",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "combining"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "á combining **mark** here"
+      },
+      "expected": [
+        {
+          "text": "á combining ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "mark",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": " here",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "U+0301 is a separate scalar value from its base letter. An implementation that segments by grapheme cluster rather than scalar will produce the same TEXT here but must not reorder or drop the mark."
+    },
+    {
+      "id": "0006-marker-adjacent-cjk",
+      "title": "Bold markers directly adjacent to CJK, no spaces",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "cjk",
+        "edge"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "日本語**強調**日本語"
+      },
+      "expected": [
+        {
+          "text": "日本語",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "強調",
+          "b": true,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "日本語",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "No ASCII whitespace anywhere near the markers. This is the row that fails first if an implementation looks backward or forward one BYTE to decide whether a marker is word-adjacent."
+    },
+    {
+      "id": "0007-emoji-inside-code",
+      "title": "Emoji and accents inside a code span",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "emoji",
+        "code-span"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "x `🎉 café` y"
+      },
+      "expected": [
+        {
+          "text": "x ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "🎉 café",
+          "b": false,
+          "i": false,
+          "code": true
+        },
+        {
+          "text": " y",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "Code spans are copied out by index rather than scanned character by character, so this exercises the slice path instead of the append path."
+    },
+    {
+      "id": "0008-unclosed-code",
+      "title": "Unclosed code span swallows the rest, including non-ASCII",
+      "since": "0.1.0",
+      "tags": [
+        "tokenize",
+        "edge",
+        "fail-open"
+      ],
+      "fn": "tokenizeInlineMarkdown",
+      "input": {
+        "text": "trailing `unclosed 日本語"
+      },
+      "expected": [
+        {
+          "text": "trailing ",
+          "b": false,
+          "i": false,
+          "code": false
+        },
+        {
+          "text": "`unclosed 日本語",
+          "b": false,
+          "i": false,
+          "code": false
+        }
+      ],
+      "notes": "An unterminated backtick falls through as literal text rather than erroring. The remainder is taken as one slice to end-of-string, so a byte-indexed implementation must land on a char boundary."
+    }
+  ]
+}

package/suites/shared/strings/manifest.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "../../../schema/suite-manifest.schema.json",
+  "suite": "shared/strings",
+  "title": "String indexing across scripts — inline markdown segmentation",
+  "since": "0.1.0",
+  "caseFormat": "table",
+  "cases": "cases.json",
+  "contract": {
+    "function": "tokenizeInlineMarkdown(text: string) -> InlineRun[]",
+    "summary": "Split one paragraph of inline markdown into styled runs. Chosen as this suite's probe because it is the smallest shipped function in the suite that indexes into a string character by character AND slices it by offset — the two operations that behave differently in every language.",
+    "runShape": { "text": "string", "b": "bool", "i": "bool", "code": "bool" },
+    "reference": "php",
+    "referenceNote": "particle-academy/dark-slide's Helpers\\MarkdownInline::tokenize. Goldens were generated by running it, then cross-checked against the TypeScript port before being written down.",
+    "implementations": [
+      { "language": "php", "package": "particle-academy/dark-slide", "symbol": "Helpers\\MarkdownInline::tokenize" },
+      { "language": "node", "package": "@particle-academy/dark-slide-js", "symbol": "MarkdownInline.tokenize" }
+    ]
+  },
+  "notes": [
+    "PHP indexes these strings by BYTE and the TypeScript port by UTF-16 CODE UNIT, and they do not disagree — verified across CJK, emoji, combining marks and accented Latin. Both loops only ever compare ASCII markers and cut at those positions, and neither a UTF-8 continuation byte nor a UTF-16 surrogate can collide with ASCII. UTF-8 is self-synchronising, which is exactly the property that makes byte-indexing safe here.",
+    "The agreement is INCIDENTAL, not designed, which is the entire reason this suite exists. Rust cannot inherit it — slicing a &str at a non-char boundary panics — and a well-meant tidy to mb_substr or Array.from on either existing side would change the output with nothing to catch it.",
+    "Recommendation for a new implementation: iterate Unicode SCALAR VALUES (Rust `chars()`, Go `range` over a string, Python's native str). Do not iterate bytes, and do not assume one index step is one visible character."
+  ]
+}