@spintax/core 0.6.1 → 0.7.0

package/dist/index.d.cts

@@ -21,8 +21,12 @@
  * 2 — `ParsedAst` gained `defDefs`. An `Ast` cached by an older version carries no `#def` map, so
  * rendering it would silently drop every definition; the version guard turns that into an
  * `AstVersionError` instead.
+ *
+ * 3 — `EnumerationNode` and `PermutationNode` gained `raw`, the body a direct `%var%` reference
+ * is spliced into at render time. An `Ast` cached by version 2 carries no `raw`, so rendering it
+ * would silently keep a pipe-joined value as ONE option — the defect 0.7.0 fixed.
  */
-declare const AST_VERSION = 2;
+declare const AST_VERSION = 3;
 /** Opaque public handle (re-exported as `Ast` from the package index). */
 interface Ast {
     readonly astVersion: typeof AST_VERSION;
@@ -42,6 +46,10 @@ interface Ast {
  *   - conditionals test truthiness against the raw var map; plurals resolve the
  *     count (vars already expanded) then pick the bucket, lenient fullwidth
  *     fallback (Stage 6d, after vars).
+ *   - a `%var%` that sits DIRECTLY in an enumeration/permutation body is spliced as
+ *     TEXT and the construct re-read (spliceConstruct, 0.7.0): a `|` inside such a
+ *     value separates options, exactly as in the plugin, whose expansion runs before
+ *     any bracket is read. Every other construct keeps the tree it was parsed into.
  *   - #include (post-tree string pass) and post-process are later PRs.
  *
  * RNG note: cross-engine RNG-sequence parity is a non-goal (§3.2). Enumerations

package/dist/index.d.ts

@@ -21,8 +21,12 @@
  * 2 — `ParsedAst` gained `defDefs`. An `Ast` cached by an older version carries no `#def` map, so
  * rendering it would silently drop every definition; the version guard turns that into an
  * `AstVersionError` instead.
+ *
+ * 3 — `EnumerationNode` and `PermutationNode` gained `raw`, the body a direct `%var%` reference
+ * is spliced into at render time. An `Ast` cached by version 2 carries no `raw`, so rendering it
+ * would silently keep a pipe-joined value as ONE option — the defect 0.7.0 fixed.
  */
-declare const AST_VERSION = 2;
+declare const AST_VERSION = 3;
 /** Opaque public handle (re-exported as `Ast` from the package index). */
 interface Ast {
     readonly astVersion: typeof AST_VERSION;
@@ -42,6 +46,10 @@ interface Ast {
  *   - conditionals test truthiness against the raw var map; plurals resolve the
  *     count (vars already expanded) then pick the bucket, lenient fullwidth
  *     fallback (Stage 6d, after vars).
+ *   - a `%var%` that sits DIRECTLY in an enumeration/permutation body is spliced as
+ *     TEXT and the construct re-read (spliceConstruct, 0.7.0): a `|` inside such a
+ *     value separates options, exactly as in the plugin, whose expansion runs before
+ *     any bracket is read. Every other construct keeps the tree it was parsed into.
  *   - #include (post-tree string pass) and post-process are later PRs.
  *
  * RNG note: cross-engine RNG-sequence parity is a non-goal (§3.2). Enumerations

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/internal/ast.ts
-var AST_VERSION = 2;
+var AST_VERSION = 3;
 function walk(nodes, visit) {
   const stack = [{ list: nodes, i: 0 }];
   while (stack.length > 0) {
@@ -185,19 +185,31 @@ function planBraceConstruct(content) {
   }
   return {
     texts: splitTopLevel(content),
-    build: (children) => ({ type: "enumeration", options: children })
+    build: (children) => hasDirectReference(children) ? { type: "enumeration", options: children, raw: content } : { type: "enumeration", options: children }
   };
 }
+function hasDirectReference(lists) {
+  const stack = [...lists];
+  while (stack.length > 0) {
+    const list = stack.pop();
+    for (const node of list) {
+      if (node.type === "variable") return true;
+      if (node.type === "conditional") stack.push(node.then, node.else);
+    }
+  }
+  return false;
+}
+var REFERENCE_RE = /%\w+%/u;
 function planPermutation(rawInner) {
   const { config, content } = extractPermutationConfig(rawInner);
   const { texts, separators } = permutationElements(splitTopLevel(content));
+  const separatorHasRef = REFERENCE_RE.test(config.sep) || config.lastsep !== null && REFERENCE_RE.test(config.lastsep) || separators.some((sep) => sep !== null && REFERENCE_RE.test(sep));
   return {
     texts,
-    build: (children) => ({
-      type: "permutation",
-      config,
-      options: children.map((nodes, i) => ({ nodes, separator: separators[i] ?? null }))
-    })
+    build: (children) => {
+      const options = children.map((nodes, i) => ({ nodes, separator: separators[i] ?? null }));
+      return separatorHasRef || hasDirectReference(children) ? { type: "permutation", config, options, raw: rawInner } : { type: "permutation", config, options };
+    }
   };
 }
 function recognizeConditional(text, contentStart, contentEnd) {
@@ -1086,7 +1098,7 @@ function renderNode(node, opts) {
     case "variable":
       return resolveVariable(node.name, opts);
     case "enumeration":
-      return renderEnumeration(node.options, opts);
+      return renderEnumeration(node, opts);
     case "permutation":
       return renderPermutation(node, opts);
     case "conditional":
@@ -1100,15 +1112,20 @@ function randomInt(rng, min, max) {
 }
 function resolveVariable(name, opts) {
   const value = opts.vars[name.toLowerCase()];
-  if (value === void 0) return `%${name}%`;
-  if (opts.depth >= MAX_VARIABLE_DEPTH || !/[{[%]/u.test(value)) return value;
+  if (value === void 0 || opts.frozen === true) return `%${name}%`;
   if (opts.budget.left <= 0) return `%${name}%`;
   opts.budget.left -= value.length;
+  if (opts.depth >= MAX_VARIABLE_DEPTH || !/[{[%]/u.test(value)) return value;
   return renderNodes(parseSequence(value), { ...opts, depth: opts.depth + 1 });
 }
-function expandVarsOnly(text, opts) {
+function passesLeft(opts) {
+  return Math.max(1, MAX_VARIABLE_DEPTH - opts.depth + 1);
+}
+function expandVarsFixpoint(text, opts, passes) {
+  if (opts.frozen === true) return { text, changed: false, converged: true };
   let out = text;
-  for (let i = 0; i < MAX_VARIABLE_DEPTH; i += 1) {
+  let changedAny = false;
+  for (let i = 0; i < passes; i += 1) {
     let changed = false;
     out = out.replace(/%(\w+)%/gu, (m, name) => {
       const value = opts.vars[name.toLowerCase()];
@@ -1118,9 +1135,10 @@ function expandVarsOnly(text, opts) {
       changed = true;
       return value;
     });
-    if (!changed) break;
+    if (!changed) return { text: out, changed: changedAny, converged: true };
+    changedAny = true;
   }
-  return out;
+  return { text: out, changed: changedAny, converged: false };
 }
 function conditionalTakesThen(name, inverted, opts) {
   const value = opts.vars[name.toLowerCase()];
@@ -1131,7 +1149,7 @@ function renderConditional(node, opts) {
   const truthy = conditionalTakesThen(node.name, node.inverted, opts);
   return { lists: [truthy ? node.then : node.else], done: [], assemble: (parts) => parts[0] ?? "" };
 }
-function resolveCountConditionals(text, opts) {
+function resolveConditionalsInText(text, opts) {
   if (!text.includes("{?")) return text;
   const close = matchBraces(text);
   const out = [];
@@ -1178,8 +1196,11 @@ function matchBraces(text) {
   return close;
 }
 function renderPlural(node, opts) {
-  const countRaw = resolveCountConditionals(expandVarsOnly(node.countRaw, opts), opts);
-  const formsRaw = expandVarsOnly(node.formsRaw, opts);
+  const passes = passesLeft(opts);
+  const countPass = expandVarsFixpoint(node.countRaw, opts, passes);
+  const formsPass = expandVarsFixpoint(node.formsRaw, opts, passes);
+  const countRaw = resolveConditionalsInText(countPass.text, opts);
+  const formsRaw = formsPass.text;
   const base = normalizeBaseLang(opts.locale);
   const report = (issue) => opts.onPluralError?.(issue);
   if (/[{}[\]]/u.test(formsRaw)) {
@@ -1214,6 +1235,7 @@ function renderPlural(node, opts) {
     return fullwidthVerbatim(countRaw, formsRaw);
   }
   const picked = pluralFor(base, Number.parseInt(count, 10), forms);
+  if (!formsPass.converged) return renderNodes(parseSequence(picked), { ...opts, frozen: true });
   return { lists: [parseSequence(picked)], done: [], assemble: (parts) => parts[0] ?? "" };
 }
 function rawConstruct(countRaw, formsRaw) {
@@ -1222,13 +1244,27 @@ function rawConstruct(countRaw, formsRaw) {
 function fullwidthVerbatim(countRaw, formsRaw) {
   return rawConstruct(countRaw, formsRaw).replace(/\{/gu, "\uFF5B").replace(/\}/gu, "\uFF5D");
 }
-function renderEnumeration(options, opts) {
+function renderEnumeration(node, opts) {
+  const spliced = node.raw === void 0 ? null : spliceConstruct(node.raw, "{", "}", opts);
+  if (spliced !== null) return spliced;
+  const { options } = node;
   if (options.length === 0) return "";
   const picked = options[randomInt(opts.rng, 0, options.length - 1)];
   if (!picked) return "";
   return { lists: [picked], done: [], assemble: (parts) => parts[0] ?? "" };
 }
+function spliceConstruct(raw, open, close, opts) {
+  if (opts.frozen === true) return null;
+  const expanded = expandVarsFixpoint(resolveConditionalsInText(raw, opts), opts, passesLeft(opts));
+  const body = resolveConditionalsInText(expanded.text, opts);
+  if (body === raw) return null;
+  const nodes = parseSequence(open + body + close);
+  if (!expanded.converged) return renderNodes(nodes, { ...opts, frozen: true });
+  return { lists: [nodes], done: [], assemble: (parts) => parts[0] ?? "" };
+}
 function renderPermutation(node, opts) {
+  const spliced = node.raw === void 0 ? null : spliceConstruct(node.raw, "[", "]", opts);
+  if (spliced !== null) return spliced;
   if (node.options.length === 0) return "";
   return {
     lists: node.options.map((o) => o.nodes),