@spintax/core 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -3,6 +3,80 @@
 All notable changes to `@spintax/core` are documented here. This project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 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");
@@ -1894,7 +1936,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 +2064,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();
 }