@spintax/core 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -3,6 +3,131 @@
 All notable changes to `@spintax/core` are documented here. This project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.10.0 — 2026-09-19
+
+### Fixed
+
+- **No space between a punctuation mark and the quote or bracket that closes it.** The spacing passes
+  put their space after `.!?` and `,;:` whenever the next character was not a space, a digit, a tag or
+  the end — so a closing quote or bracket got one in front of it: `"Is it audited? ", the figure`,
+  `He called it "the best. "`, `She said "yes, " and left`, `«Как дела? », и ушёл`, `(really? )`,
+  `(apples, pears, etc. )`. Found in a landing lead that quotes a question-shaped keyword; every engine
+  in the family did the same. Now no space goes between the mark and a closer, and what follows the
+  closer is left as written. `)` and `]` always close (a stray `]` stays literal). A quote is read by
+  what follows its run, because its shape says nothing — `“` opens English and closes German, `"` and `'`
+  do both: whitespace, the end, a tag, the end of a tag (`title="Really?">`), `.,;:!?…`, `)`, `]` or a
+  dash make it a closer. Anything else keeps the space it always got — a word or a number
+  (`Is it?"Next"` → `Is it? "Next"`), `(`, `$`, a shielded value. The accepted cost: an opening quote
+  glued to the mark whose text starts with a follower (`is it?"—no"`, `is it?"<em>yes</em>"`) reads as a
+  closer and loses that space. Both PHP engines take the same rule.
+
+### Corpus
+
+Nineteen new cases in `render-postprocess.json`, every expectation taken from both PHP engines with the
+rule applied: the reported shapes (`postprocess/closing-quote-after-question`, `closing-quote-before-space`,
+`closing-typographic-quote-after-exclamation`, `closing-single-quote`), the rest of the class
+(`closing-quote-after-period-at-end-of-text`, `closing-quote-after-comma`, `closing-guillemet-ru`,
+`closing-quote-ends-attribute`, `closing-bracket`, `closing-square-bracket`, `closing-quote-before-tag`,
+`closing-run-of-nested-quotes`, `bracket-always-closes`), `closing-quote-followers` and
+`closing-reversed-quotes-and-more-followers` (between them every quote as a closer and every follower),
+the cost `glued-opener-before-a-follower-reads-as-closer`, and three guards —
+`opening-quote-after-sentence-keeps-space` (a quote or a run of quotes before a letter or a digit still
+opens), `quote-before-anything-else-keeps-its-space` (`(`, `$`) and `quote-before-shielded-value-opens`.
+
+### Notes
+
+**The list names what follows a CLOSING quote.** The first version of the rule excluded instead — any
+quote run not followed by a letter, a digit or a placeholder closed. That also took the space from an
+opening quote glued to the mark before `(`, `$` or an emoji (`is it?"(really)"`), which the old rule had
+repaired (found by the Codex gate, as were the attribute case and the stray `]`). A list changes output
+only where the quote is known to close, and an unnamed shape keeps the old output. Left as it was: a
+bracket that arrives through `neutralize()` is a sentinel during this stage and is restored after it, so a
+neutralized `[sic.]` still renders `[sic. ]`.
+
+**Verified.** 143 968 generated post-process inputs — random soup over letters, digits, whitespace,
+`.,;:!?…`, every quote and bracket, tags and shieldable values, plus an exhaustive grid of mark × quote run
+× follower — through this engine and both patched PHP engines: identical everywhere. The three agreed
+before the change as well, and every one of the 66 988 outputs that moved differs from the old output only
+by a deleted space between a mark and a closer. Thirty control mutations, one per character of the rule —
+each quote dropped, each follower dropped (including whitespace, the end, a tag, `/>` and `>`), `)` or `]`
+no longer closing, the comma pass left alone, and the first version's letter-or-digit rule — each turn the
+differential red (363 to 25 905 inputs) and fail at least one fixture. Cost unchanged here and in PHP:
+200 000 marks before 200 000 quotes take single-digit milliseconds in all three.
+
+## 0.9.0 — 2026-09-17
+
+### Changed, visibly
+
+- **A TLD is a label in ONE case (#79).** The bare-domain and email shields took any `word.Word` for a
+  domain, so a sentence glued to the next one kept its missing space and its lower-case start:
+  `kept compact.Game categories`, `конец.Начало`. On a production host's stored content that shape was
+  a sentence start 369 times in 56 tenants and a domain never. Now a TLD is all lower case or all upper
+  case — letters without case (CJK, Arabic, Thai) fit either — so those sentences get their space and
+  their capital, while `example.com`, `ASP.NET`, `info@Example.COM`, `ПРИМЕР.РФ`, `例子.中国` and a punycode
+  TLD in any case stay whole. The accepted cost: a Title-case second half reads as a sentence too —
+  `Yandex.Money` renders `Yandex. Money`, and `info@example.Com` is no longer shielded as an email. Both
+  PHP engines take the same rule.
+
+### Fixed
+
+- **A titlecase letter after a block tag stays as PHP leaves it.** The plugin writes that capitalizer
+  `/ui`, and PCRE2 does not fold a Unicode property, so its `\p{Ll}` stays lower case only. This engine
+  read `\p{Ll}` under JavaScript's `i`, which takes every cased letter, and `<p>Dživot</p>` became
+  `<p>DŽivot</p>`. Found by the post-process differential once its alphabet held a titlecase digraph; as
+  old as the capitalizer.
+
+### Corpus
+
+Nine new cases in `render-postprocess.json`, every expectation taken from both PHP engines with the rule
+applied: `postprocess/title-case-tld-is-a-sentence` (`compact.Game`), `postprocess/mixed-case-tld-is-not-a-domain`
+(`cOM` — one case means the whole label), `postprocess/title-case-email-tld-is-not-shielded` (the cost,
+pinned so nobody files it), the negatives `postprocess/uppercase-tld-is-a-domain`,
+`postprocess/uppercase-email-domain-is-shielded`, `postprocess/caseless-script-tld-is-a-domain`,
+`postprocess/uppercase-punycode-tld-is-a-domain` and `postprocess/punycode-tld-folds-long-s-and-kelvin`, and
+`postprocess/titlecase-letter-after-block-tag-is-kept`. `postprocess/glued-cyrillic-sentence-is-a-domain`
+becomes `postprocess/glued-cyrillic-sentence-is-spaced`: it pinned the reading before #79, and its note said
+deciding #79 would move it.
+
+### Notes
+
+**One JavaScript trap behind both.** Under `i`, a JavaScript `\p{Ll}` matches capitals and a `\p{Lu}`
+matches lower case; PCRE2 leaves a property alone under `/i`. PHP can also switch `i` off for one
+alternative with `(?-i:…)`, which JavaScript has only from ES2025 — Node 24, not the Node 18–22 this engine
+still supports. So the domain
+patterns carry no `i` and spell out the one part that is caseless, the punycode prefix and class — U+017F
+and U+212A included, as PCRE2's caseless `[a-z]` takes them.
+
+**Verified.** 24 000 generated post-process inputs — the earlier alphabet with caseless scripts, mixed-case
+TLDs and a titlecase digraph added, plus dotted chains whose TLD candidate is lower, upper, title, mixed or
+caseless, in prose and in emails — through both PHP engines with the rule applied: they agree with each other
+everywhere, this engine differs on none but the recorded final `trim`, and 0.8.0 on 4 552. Control mutations:
+`i` restored on either shield, the caseless letters dropped from one branch or both, the any-case TLD restored,
+U+017F and U+212A dropped from the punycode class — each turns the suite red. The last one first looked
+output-equivalent here, because a lower-case `xn--` prefix always has a one-case letter reading from the same
+start; a mixed-case prefix has none (`site.xN--ſA`, found by the Codex gate), and
+`postprocess/punycode-tld-folds-long-s-and-kelvin` pins it. Post-process cost is unchanged — 1 000 prose calls
+18 ms against 19, HTML blocks 27 against 26, a 756 KB shield-heavy text 147 ms against 154.
+
+**The PHP engines skip what they cannot shield.** Rejecting `Game` made `a.a.…a.Game` — one domain from its
+first start before — a chain PCRE retried from every label: 2 000 one-character labels (about 4 KB) took 48 ms where they had taken
+0.7 (found by the Codex gate). Both PHP shields now take a run or a chain they cannot shield and
+`(*SKIP)(*FAIL)` past it — the skips this engine's scanners already prove output-neutral — which also
+removes the older retry on a chain whose last label is too short to be a TLD: 2 000 labels, 39 ms before,
+0.1 ms now. Ordinary text costs 2–4 % more there. JavaScript has no backtracking verbs, which is why this
+engine's shields are scanners.
+
+**The two costs bounded by the source are gone** — 0.8.0's notes recorded them as left alone.
+`validate()` formatted a capped circular-reference message by walking the rest of the cycle again for each
+of its names: one cycle of 8 000 names took 6 s, now 68 ms, because the route lengths are measured once for
+all names. `render()` ordered `#def`s by rescanning every pending name each round and handed every roll a
+fresh copy of the map of rolled values: a 1 600-definition chain took 1.6 s and 6 400 independent
+definitions 4.1 s, now 6 ms and 24 ms. The order is counted round by round in source order, and every roll
+reads one map that grows by each rolled value, dropping the truthiness a conditional cached for it after
+each write. Output is byte-identical over 3 000 generated definition-graph documents — chains, cycles with
+tails long enough for a capped message, shadowed globals, outranked definitions, conditionals on definition
+names — through `validate`, `analyze` and five renders, with three control mutations caught first: a round
+left unsorted, the truthiness cache kept across a write, a route one name longer.
+
 ## 0.8.0 — 2026-09-13
 
 Two defects found by the ports while they mirrored 0.7.0, both places where this engine read a

package/dist/index.cjs

@@ -1100,11 +1100,12 @@ function checkVariableReferences(text, idx, known, out) {
     refsOf.set(name, refs);
   }
   const { reaches: reachesCycle, via } = namesThatReachACycle(defs, refsOf);
+  const lengths = routeLengths(via);
   for (const name of defs.keys()) {
     if (!reachesCycle.has(name)) continue;
     out.push(err(
       "variable.circular-reference",
-      `Circular variable reference: ${cyclePath(name, via)}.`,
+      `Circular variable reference: ${cyclePath(name, via, lengths)}.`,
       { ...defPos.get(name) ?? somewhere, data: { name } }
     ));
   }
@@ -1164,7 +1165,7 @@ function namesThatReachACycle(defs, refsOf) {
   return { reaches, via };
 }
 var CYCLE_PATH_LIMIT = 8;
-function cyclePath(name, via) {
+function cyclePath(name, via, lengths) {
   const seen = /* @__PURE__ */ new Set([name]);
   const shown = [name];
   let current = name;
@@ -1176,16 +1177,7 @@ function cyclePath(name, via) {
       return shown.join(" \u2192 ");
     }
     if (shown.length >= CYCLE_PATH_LIMIT) {
-      let more = 0;
-      let walk2 = next;
-      while (!seen.has(walk2)) {
-        seen.add(walk2);
-        more += 1;
-        const step = via.get(walk2);
-        if (step === void 0) break;
-        walk2 = step;
-      }
-      return `${shown.join(" \u2192 ")} \u2192 \u2026 (${more} more)`;
+      return `${shown.join(" \u2192 ")} \u2192 \u2026 (${lengths.get(name) - shown.length} more)`;
     }
     seen.add(next);
     shown.push(next);
@@ -1193,6 +1185,33 @@ function cyclePath(name, via) {
   }
   return shown.join(" \u2192 ");
 }
+function routeLengths(via) {
+  const lengths = /* @__PURE__ */ new Map();
+  for (const start of via.keys()) {
+    if (lengths.has(start)) continue;
+    const walk2 = [];
+    const onWalk = /* @__PURE__ */ new Map();
+    let node = start;
+    while (node !== void 0 && !lengths.has(node) && !onWalk.has(node)) {
+      onWalk.set(node, walk2.length);
+      walk2.push(node);
+      node = via.get(node);
+    }
+    let tailEnd = walk2.length;
+    let length = node === void 0 ? 0 : lengths.get(node) ?? 0;
+    if (node !== void 0 && onWalk.has(node)) {
+      const from = onWalk.get(node);
+      length = walk2.length - from;
+      for (let k = from; k < walk2.length; k += 1) lengths.set(walk2[k], length);
+      tailEnd = from;
+    }
+    for (let k = tailEnd - 1; k >= 0; k -= 1) {
+      length += 1;
+      lengths.set(walk2[k], length);
+    }
+  }
+  return lengths;
+}
 function checkIncludeTargets(text, idx, known, out) {
   const set = new Set(known);
   INCLUDE_RE.lastIndex = 0;
@@ -1444,42 +1463,61 @@ function rollDefinitions(defDefs, vars, context, opts) {
     if (name in definitions && !outranked.has(name)) continue;
     aliases[name] = value;
   }
+  const visible = nameMap(vars);
   for (const name of orderDefinitions(definitions, aliases)) {
     if (outranked.has(name)) continue;
-    const value = definitions[name] ?? "";
-    rolled[name] = renderNodes(parseSequence(value), { ...opts, vars: nameMap(vars, rolled) });
+    const value = renderNodes(parseSequence(definitions[name] ?? ""), { ...opts, vars: visible });
+    rolled[name] = value;
+    visible[name] = value;
+    truthinessByVars.delete(visible);
   }
   return rolled;
 }
 function orderDefinitions(defDefs, aliases) {
   const names = Object.keys(defDefs);
-  const blocked = /* @__PURE__ */ new Map();
+  const position = new Map(names.map((name, i) => [name, i]));
+  const unplaced = /* @__PURE__ */ new Map();
+  const waitingOn = /* @__PURE__ */ new Map();
   for (const name of names) {
-    const reached = referencedNames(defDefs[name] ?? "", aliases);
-    blocked.set(name, new Set(names.filter((candidate) => reached.has(candidate))));
+    let count = 0;
+    for (const dep of referencedNames(defDefs[name] ?? "", aliases)) {
+      if (dep === name || !position.has(dep)) continue;
+      count += 1;
+      const waiting = waitingOn.get(dep);
+      if (waiting === void 0) waitingOn.set(dep, [name]);
+      else waiting.push(name);
+    }
+    unplaced.set(name, count);
   }
   const ordered = [];
-  let pending = names;
-  while (pending.length > 0) {
-    const ready = pending.filter((name) => {
-      const deps = blocked.get(name);
-      return !deps || ![...deps].some((dep) => dep !== name && pending.includes(dep));
-    });
-    if (ready.length === 0) return [...ordered, ...pending];
-    ordered.push(...ready);
-    pending = pending.filter((name) => !ready.includes(name));
+  let round = names.filter((name) => unplaced.get(name) === 0);
+  while (round.length > 0) {
+    const next = [];
+    for (const name of round) {
+      ordered.push(name);
+      for (const waiting of waitingOn.get(name) ?? []) {
+        const left = unplaced.get(waiting) - 1;
+        unplaced.set(waiting, left);
+        if (left === 0) next.push(waiting);
+      }
+    }
+    round = next.sort((a, b) => position.get(a) - position.get(b));
+  }
+  if (ordered.length < names.length) {
+    const placed = new Set(ordered);
+    for (const name of names) if (!placed.has(name)) ordered.push(name);
   }
   return ordered;
 }
 function referencedNames(value, aliases) {
   const seen = /* @__PURE__ */ new Set();
   const queue = directReferences(value);
-  while (queue.length > 0) {
-    const name = queue.shift();
+  for (let i = 0; i < queue.length; i += 1) {
+    const name = queue[i];
     if (seen.has(name)) continue;
     seen.add(name);
     const alias = aliases[name];
-    if (alias !== void 0) queue.push(...directReferences(alias));
+    if (alias !== void 0) for (const ref of directReferences(alias)) queue.push(ref);
   }
   return seen;
 }
@@ -1819,13 +1857,17 @@ var WS = UCP_SPACE;
 var S = `[${WS}]`;
 var AFTER_NON_WORD = `(?<![${UCP_WORD}])`;
 var WORD_BOUNDARY = `(?:(?<=[${UCP_WORD}])(?![${UCP_WORD}])|(?<![${UCP_WORD}])(?=[${UCP_WORD}]))`;
-var LABEL = "(?:xn--)?[\\p{L}\\p{N}]+(?:-[\\p{L}\\p{N}]+)*";
-var DOMAIN_PART = `(?:${LABEL}\\.)+(?:xn--[a-z0-9\\-]{2,59}|[\\p{L}][\\p{L}\\p{N}-]{1,62})`;
+var XN = "[xX][nN]--";
+var LABEL = `(?:${XN})?[\\p{L}\\p{N}]+(?:-[\\p{L}\\p{N}]+)*`;
+var TLD_LOWER = "\\p{Ll}\\p{Lm}\\p{Lo}";
+var TLD_UPPER = "\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}";
+var TLD = `(?:${XN}[a-zA-Z0-9\\-\\u017F\\u212A]{2,59}|[${TLD_LOWER}][${TLD_LOWER}\\p{N}-]{1,62}|[${TLD_UPPER}][${TLD_UPPER}\\p{N}-]{1,62})`;
+var DOMAIN_PART = `(?:${LABEL}\\.)+${TLD}`;
 var URI_BODY = `[^\\x00${WS}<>"')\\]]`;
 var URI_RE = new RegExp(`(?:(?:https?|ftp):\\/\\/|(?:mailto|tel):)${URI_BODY}+`, "giu");
 var MAILTEL_PREFIX_RE = /^(?:mailto|tel):/iu;
-var DOMAIN_AT_RE = new RegExp(`${DOMAIN_PART}${WORD_BOUNDARY}`, "iuy");
-var DOMAIN_SCAN_RE = new RegExp(`${AFTER_NON_WORD}(?:(${DOMAIN_PART}${WORD_BOUNDARY})|(?:${LABEL}\\.)*${LABEL})`, "giu");
+var DOMAIN_AT_RE = new RegExp(`${DOMAIN_PART}${WORD_BOUNDARY}`, "uy");
+var DOMAIN_SCAN_RE = new RegExp(`${AFTER_NON_WORD}(?:(${DOMAIN_PART}${WORD_BOUNDARY})|(?:${LABEL}\\.)*${LABEL})`, "gu");
 var DECIMAL_RE = /\b\d+\.\d+\b/gu;
 var MULTI_ABBR_RE = new RegExp(`${AFTER_NON_WORD}(?:\\p{L}{1,2}\\.${S}*){2,}`, "gu");
 var SINGLE_ABBR_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:${SINGLE_ABBREVS.join("|")})\\.(?=${S}|$|<)`, "giu");
@@ -1869,9 +1911,11 @@ function trailingPunctuationStart(value) {
 }
 var SENTENCE_OPENERS = "\xBF\xA1";
 var LEAD = `(?:<[^>]+>|[${SENTENCE_OPENERS}]|${S})*`;
+var QUOTES = `"'\xAB\xBB\u2039\u203A\u201C\u201D\u2018\u2019`;
+var CLOSER = `[)\\]]|[${QUOTES}]+(?=${S}|$|<|\\/?>|[.,;:!?\u2026)\\]\u2014\u2013])`;
 var SPACE_BEFORE_PUNCT_RE = new RegExp(`(?<!${S})${S}+([,;:!?.])`, "gu");
-var SPACE_AFTER_COMMA_RE = new RegExp(`([,;:])(?!\\p{Nd})(?!${S}|$|<)`, "gu");
-var SPACE_AFTER_SENTENCE_RE = new RegExp(`(?<![.!?])([.!?]+)(?![.!?])(?!\\p{Nd})(?!${S}|$|<)`, "gu");
+var SPACE_AFTER_COMMA_RE = new RegExp(`([,;:])(?!\\p{Nd})(?!${S}|$|<|${CLOSER})`, "gu");
+var SPACE_AFTER_SENTENCE_RE = new RegExp(`(?<![.!?])([.!?]+)(?![.!?])(?!\\p{Nd})(?!${S}|$|<|${CLOSER})`, "gu");
 var SPACE_AFTER_OPENER_RE = new RegExp(`([${SENTENCE_OPENERS}])${S}+`, "gu");
 var CAP_FIRST_RE = new RegExp(`^(${LEAD})(\\p{Ll})`, "u");
 var up = (ch) => ch.toUpperCase();
@@ -1894,7 +1938,6 @@ function indexLeads(text) {
   return { leadEnd };
 }
 var LOWER_RE = /^\p{Ll}/u;
-var LOWER_CASELESS_RE = /^\p{Ll}/iu;
 var BLOCK_TAG_NAME_RE = /<\/?(?:p|h[1-6]|li|blockquote|div|td|th)/iuy;
 var SENTENCE_END_SCAN_RE = new RegExp(`[.!?${String.fromCharCode(8230)}]`, "g");
 var LEAD_WALK = 32;
@@ -2023,7 +2066,7 @@ function postProcess(input) {
   text = text.replace(CAP_FIRST_RE, (_m, lead, ch) => lead + up(ch));
   const leadContext = { leads: null };
   text = capitalizeAfter(text, LOWER_RE, afterSentenceEnd, leadContext);
-  text = capitalizeAfter(text, LOWER_CASELESS_RE, afterBlockTag(), leadContext);
+  text = capitalizeAfter(text, LOWER_RE, afterBlockTag(), leadContext);
   text = capitalizeAfter(text, LOWER_RE, afterLineBreak, leadContext);
   return restore(text, input, placeholders).trim();
 }