dsh-muv-table 0.2.9 → 0.2.11

package/lib/initvar-parser.js

@@ -1,6 +1,6 @@
 // MUV Initvar parser: converts YAML-like indented initvar text to nested objects.
-// Format: 2-space indentation, `键: 值` pairs. Supports nested objects and inline
-// lists (comma-separated values wrapped in [ ]).
+// Format: 2-space indentation, `键: 值` pairs. Supports nested objects, `- item`
+// lists, and inline lists (comma-separated values wrapped in [ ]).
 
 /**
  * Parse an initvar text block into a nested object.
@@ -8,9 +8,12 @@
  * @returns {object} Parsed nested object
  */
 export function parseInitvar(text) {
-  const lines = text.split(/\r?\n/)
+  const lines = String(text ?? '').split(/\r?\n/)
   const root = {}
-  const stack = [{ obj: root, indent: -1 }]
+  // Each frame remembers the key that opened it and the object that holds it, so
+  // a frame created as an assumed-empty object can still be turned into an array
+  // once its contents turn out to be `- item` lines.
+  const stack = [{ obj: root, indent: -1, key: null, parent: null, list: false }]
 
   for (const rawLine of lines) {
     const line = rawLine.trimEnd()
@@ -19,16 +22,55 @@ export function parseInitvar(text) {
     const indent = line.length - line.trimStart().length
     const trimmed = line.trim()
 
+    // A `- item` line is a list entry, not a `键: 值` pair. It used to be dropped
+    // outright (`colonIdx === -1` → continue), which silently emptied every list
+    // a card declares the way 苍玄界 does:
+    //
+    //     最近互动记录: 
+    //        - 因为想吃灵鹤被{{user}}抓包，目前心虚加不知所措。
+    //
+    // The key before it looks like an empty value, so the entry belongs to the
+    // innermost *pending* key: that key was optimistically created as `{}` and is
+    // now revealed to be an array. Checked before the stack pop because a list is
+    // allowed to sit at the same indent as its own key.
+    const itemMatch = /^-(?:\s+(.*))?$/.exec(trimmed)
+    if (itemMatch) {
+      const frame = stack[stack.length - 1]
+      if (frame.key !== null && !frame.list && Object.keys(frame.obj).length === 0) {
+        const arr = []
+        frame.parent[frame.key] = arr
+        frame.obj = arr
+        frame.list = true
+      }
+      // No pending key above us means a stray item with nowhere to go; dropping
+      // it is the same behaviour this line always had.
+      if (frame.list) frame.obj.push(parseValue((itemMatch[1] ?? '').trim()))
+      continue
+    }
+
     // Pop stack until we find the right parent
     while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
       stack.pop()
     }
 
-    const parent = stack[stack.length - 1].obj
+    const parentFrame = stack[stack.length - 1]
+    const parent = parentFrame.obj
     const colonIdx = trimmed.indexOf(':')
 
     if (colonIdx === -1) {
-      // Value-only line (continuation or list item)
+      // Value-only line (continuation) — not representable in this format, and
+      // dropped exactly as before. Inside a list there are no keys at all, so the
+      // raw line is kept as an item rather than vanishing.
+      if (parentFrame.list) parent.push(trimmed)
+      continue
+    }
+
+    // A `键: 值` line under a list is not a key either (`- a` followed by an
+    // indented `x: 1` is a list of objects, which this format cannot express).
+    // Keeping the text as an item preserves the content; writing it as a property
+    // of an array would be silently lost by JSON.stringify.
+    if (parentFrame.list) {
+      parent.push(trimmed)
       continue
     }
 
@@ -36,10 +78,10 @@ export function parseInitvar(text) {
     const value = trimmed.slice(colonIdx + 1).trim()
 
     if (value === '') {
-      // Nested object start
+      // Nested object start — may still turn out to be a list (see above).
       const newObj = {}
       parent[key] = newObj
-      stack.push({ obj: newObj, indent })
+      stack.push({ obj: newObj, indent, key, parent, list: false })
     } else {
       // Leaf value
       parent[key] = parseValue(value)
@@ -52,12 +94,14 @@ export function parseInitvar(text) {
 /**
  * Parse a leaf value string to appropriate type.
  * @param {string} val
- * @returns {string|number|boolean}
+ * @returns {string|number|boolean|Array}
  */
 function parseValue(val) {
   // Empty string
   if (val === '""' || val === "''") return ''
   if (val === '{}') return '{}'
+  // Empty list — serialized that way so it does not come back as `{}`.
+  if (val === '[]') return []
 
   // Number
   if (/^-?\d+(\.\d+)?$/.test(val)) {
@@ -82,7 +126,16 @@ export function serializeInitvar(obj, depth = 0) {
   let result = ''
 
   for (const [key, value] of Object.entries(obj)) {
-    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    if (Array.isArray(value)) {
+      // Lists are written the way the cards write them (`键:` then `  - item`), so
+      // a parsed list survives a round trip instead of collapsing into "a,b".
+      if (value.length === 0) {
+        result += `${indent}${key}: []\n`
+      } else {
+        result += `${indent}${key}:\n`
+        for (const item of value) result += `${indent}  - ${formatValue(item)}\n`
+      }
+    } else if (value !== null && typeof value === 'object') {
       result += `${indent}${key}:\n`
       result += serializeInitvar(value, depth + 1)
     } else {
@@ -97,5 +150,10 @@ function formatValue(val) {
   if (val === null || val === undefined) return ''
   if (typeof val === 'boolean') return val ? 'true' : 'false'
   if (typeof val === 'number') return String(val)
+  // An empty string must stay quoted. Written bare (`键: `) the line looks like
+  // the start of a nested object, so 苍玄界's `在场角色: ""` came back as `{}`
+  // the next time the block was read — a silent type flip. The cards quote it
+  // themselves; this just keeps that convention on the way out.
+  if (val === '') return '""'
   return String(val)
 }

package/lib/muv-parser.js

@@ -17,6 +17,142 @@ import { parseInitvar } from './initvar-parser.js'
 // as well park it in description/scenario, so all three are scanned.
 const VARIABLE_TEXT_FIELDS = ['first_mes', 'description', 'scenario']
 
+/** Arrays only — a malformed card may carry an object where a list belongs. */
+function asArray(value) {
+  return Array.isArray(value) ? value : []
+}
+
+/**
+ * Every text blob of a card that might hold `<initvar>` / `<VariableInsert>`.
+ *
+ * Besides the obvious greeting fields, two more sources carry these blocks in
+ * the field and used to be skipped entirely:
+ *
+ *  - world book entries (`character_book.entries[].content`) — `[initvar]变量初始化勿开`
+ *    is a world-book entry, not a greeting, in the cards that use this shape;
+ *  - `tavern_helper` scripts, whose source often contains the same block.
+ *
+ * The list is ordered by preference and grouped, so a caller can ask for "the
+ * greeting-level sources first" without hardcoding field names again.
+ * @param {object} data - the card's `data` object
+ * @returns {Array<{group: string, where: string, text: string}>}
+ */
+function variableTextCandidates(data) {
+  const out = []
+  if (!data || typeof data !== 'object') return out
+
+  const push = (group, where, text) => {
+    if (typeof text === 'string') out.push({ group, where, text })
+  }
+
+  for (const field of VARIABLE_TEXT_FIELDS) push('field', field, data[field])
+  for (const greeting of asArray(data.alternate_greetings)) {
+    push('greeting', 'alternate_greetings', greeting)
+  }
+  for (const entry of asArray(data.character_book?.entries)) {
+    push('worldbook', 'character_book:' + String(entry?.comment || ''), entry?.content)
+  }
+  for (const script of asArray(data.extensions?.tavern_helper?.scripts)) {
+    push('script', 'tavern_helper:' + String(script?.name || ''), script?.content)
+  }
+  return out
+}
+
+/** All texts belonging to the given candidate groups, in candidate order. */
+function textsInGroups(candidates, ...groups) {
+  return candidates.filter(c => groups.includes(c.group)).map(c => c.text)
+}
+
+/**
+ * World-book entries that hold a **bare** initvar block — no `<initvar>` tag at all.
+ *
+ * `异世界农场` keeps its entire variable tree in an entry whose comment is
+ * `[initvar]变量初始化勿开` and whose content is plain YAML:
+ *
+ *     时间:
+ *       日期: '05-20'
+ *       星期: 周日
+ *     …
+ *
+ * Because there is no tag, the tag-based scan can never reach it and the card
+ * reported `schemas: 0` even though the whole tree was sitting in the world book.
+ *
+ * The prefix must be exactly `[initvar]`. The sibling conventions are **documents,
+ * not data** and reading them as YAML would build a junk table:
+ *
+ *  - `[mvu_update]变量输出格式` / `[mvu_update]变量更新规则` — how to emit updates
+ *    (苍玄界 and 异世界农场 both carry these);
+ *  - `[mvu_plot]…` — illustration prompts.
+ *
+ * @param {object} data - the card's `data` object
+ * @returns {Array<{comment: string, content: string}>}
+ */
+function worldbookInitvarEntries(data) {
+  const out = []
+  for (const entry of asArray(data?.character_book?.entries)) {
+    if (!/^\s*\[initvar\]/i.test(String(entry?.comment || ''))) continue
+    if (typeof entry?.content === 'string') out.push({ comment: String(entry.comment), content: entry.content })
+  }
+  return out
+}
+
+/**
+ * Does this text read as a YAML **mapping of variables**, rather than prose or a
+ * document that happens to mention keys?
+ *
+ * `parseInitvar` never fails — it drops what it cannot use and returns whatever is
+ * left, so "it parsed" is not evidence. This is the actual shape test used to decide
+ * whether a `[initvar]`-marked entry is data:
+ *
+ *  - blanks and `# comment` lines are ignored;
+ *  - `键:` / `键: 值` lines count as keys;
+ *  - `- item` lines count as list content belonging to the nearest key;
+ *  - **any other line means this is not a variable mapping** → reject.
+ *
+ * That last rule is what keeps a prose document out: Chinese prose uses the full-width
+ * `：`, so a sentence like `变量初始化格式说明：…` produces no key line at all, and a
+ * paragraph next to a stray `键:` line is still rejected (one foreign line is enough).
+ * @param {string} text
+ * @returns {boolean}
+ */
+function looksLikeInitvarMapping(text) {
+  let keys = 0
+  for (const rawLine of String(text ?? '').split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+    if (/^-(?:\s|$)/.test(line)) continue
+    if (/^[^:\s#][^:]*:(\s|$)/.test(line)) { keys++; continue }
+    return false
+  }
+  return keys > 0
+}
+
+/** The first `<initvar>` block in a list of texts, or null. */
+function firstInitvarBlock(texts) {
+  for (const text of texts) {
+    const match = text.match(/<initvar>([\s\S]*?)<\/initvar>/i)
+    if (match) return { raw: match[1].trim(), parsed: parseInitvar(match[1]) }
+  }
+  return null
+}
+
+/**
+ * A card's variable data, whichever spec shape it uses.
+ *
+ * Spec-v2 cards wrap every field in `data`; spec-v1 (flat) cards put the same
+ * fields at the top level. Reading only `data` made a flat card — one
+ * `findJsonMatch` happily found by name — parse as `{name:'Unnamed'}` with 0
+ * fields, i.e. the library file was located and then thrown away.
+ * @param {object} cardJson
+ * @returns {object}
+ */
+function cardData(cardJson) {
+  if (!cardJson || typeof cardJson !== 'object') return {}
+  const inner = cardJson.data
+  if (inner && typeof inner === 'object' && !Array.isArray(inner)) return inner
+  return cardJson
+}
+
 /**
  * Drop a collection's `$template` placeholder.
  *
@@ -46,15 +182,7 @@ export function stripPlaceholderEntries(data) {
 export function extractVariableInsert(data) {
   if (!data || typeof data !== 'object') return null
 
-  const candidates = []
-  for (const field of VARIABLE_TEXT_FIELDS) {
-    if (typeof data[field] === 'string') candidates.push(data[field])
-  }
-  for (const greeting of data.alternate_greetings || []) {
-    if (typeof greeting === 'string') candidates.push(greeting)
-  }
-
-  for (const text of candidates) {
+  for (const { text } of variableTextCandidates(data)) {
     const match = text.match(/<VariableInsert>([\s\S]*?)<\/VariableInsert>/i)
     if (!match) continue
     const raw = match[1].trim()
@@ -65,6 +193,9 @@ export function extractVariableInsert(data) {
       }
     } catch (_) {
       // Not JSON — keep looking; another block might be the real one.
+      // World-book entries and helper scripts routinely *quote* the tags in
+      // prose (「必须使用 `<VariableInsert>`」) or inside a fenced code block, and
+      // those examples are never valid JSON, so this is the common case there.
     }
   }
   return null
@@ -73,11 +204,15 @@ export function extractVariableInsert(data) {
 /**
  * Parse a MUV character card JSON and extract schema + variable data.
  * @param {object} cardJson - The full character card JSON
- * @returns {{ name: string, schemas: object[], initvarData: object, zodSource: string }}
+ * @returns {{ name: string, schemas: object[], initvarData: object, zodSource: string,
+ *   schemaSource: 'initvar'|'variable-insert'|'worldbook-initvar'|'none' }}
+ *   `schemaSource` names the source the variable tree was read from ('none' when the
+ *   card carries none), so a reader can tell a real tree from the heuristic fallback.
  */
 export function parseMuvCard(cardJson) {
-  const data = cardJson?.data || {}
-  const name = data.name || cardJson?.name || 'Unnamed'
+  const data = cardData(cardJson)
+  const name = data.name || cardJson?.data?.name || cardJson?.name || 'Unnamed'
+  const candidates = variableTextCandidates(data)
   const tavernHelper = data.extensions?.tavern_helper
 
   // Extract Zod schema source (for reference)
@@ -87,18 +222,17 @@ export function parseMuvCard(cardJson) {
   // （`z.object({...})` / `registerMvuSchema`）其实是 MUV 最主流的 schema 载体，
   // 读不到就等于整张卡的变量表建不出来。
   // 现在按「名字含 zod」或「内容像 Zod schema」两条线索找，兼容各种命名。
-  const scripts = tavernHelper?.scripts || []
+  // `scripts` 不一定是数组（畸形卡），先归一化再找，否则这里会先抛 TypeError。
+  const scripts = asArray(tavernHelper?.scripts)
   const zodScript = scripts.find(s => /zod/i.test(String(s?.name || '')))
     || scripts.find(s => /z\.object\s*\(|registerMvuSchema|Mvu\.|z\.string\s*\(|prefault\s*\(/.test(String(s?.content || '')))
   const zodSource = zodScript?.content || ''
 
   // Extract initvar blocks from alternate_greetings
-  const greetings = data.alternate_greetings || []
   const initvarBlocks = []
 
-  for (const greeting of greetings) {
-    if (typeof greeting !== 'string') continue
-    const match = greeting.match(/<initvar>([\s\S]*?)<\/initvar>/i)
+  for (const text of textsInGroups(candidates, 'greeting')) {
+    const match = text.match(/<initvar>([\s\S]*?)<\/initvar>/i)
     if (match) {
       initvarBlocks.push({
         raw: match[1].trim(),
@@ -109,24 +243,19 @@ export function parseMuvCard(cardJson) {
 
   // An <initvar> may live in the opening greeting instead. Only consulted when
   // alternate_greetings had none, so a card that already worked keeps reading
-  // from exactly the same place it used to.
+  // from exactly the same place it used to. (`scenario` is included here for the
+  // same reason `<VariableInsert>` already scans it — the two paths were
+  // asymmetric.)
   if (initvarBlocks.length === 0) {
-    for (const text of [data.first_mes, data.description]) {
-      if (typeof text !== 'string') continue
-      const match = text.match(/<initvar>([\s\S]*?)<\/initvar>/i)
-      if (match) {
-        initvarBlocks.push({
-          raw: match[1].trim(),
-          parsed: parseInitvar(match[1])
-        })
-        break
-      }
-    }
+    const hit = firstInitvarBlock(textsInGroups(candidates, 'field'))
+    if (hit) initvarBlocks.push(hit)
   }
 
   // Use the first initvar block as default data
   let initvarData = initvarBlocks.length > 0 ? initvarBlocks[0].parsed : {}
   let initvarRaw = initvarBlocks.map(b => b.raw)
+  /** Where the variable tree came from — see `schemaSource` in the return value. */
+  let schemaSource = initvarRaw.length > 0 ? 'initvar' : 'none'
 
   // No <initvar> anywhere → fall back to the community <VariableInsert> shape.
   if (initvarRaw.length === 0) {
@@ -134,6 +263,52 @@ export function parseMuvCard(cardJson) {
     if (inserted) {
       initvarData = inserted.data
       initvarRaw = [inserted.raw]
+      schemaSource = 'variable-insert'
+    }
+  }
+
+  // Still nothing → the block may only exist in the world book or in a
+  // tavern_helper script. This is deliberately the last resort, after
+  // <VariableInsert>: those two sources are full of *quoted examples* of the
+  // syntax, and an example is far more likely to be a bare `<initvar>` skeleton
+  // (which parses into junk but never throws) than a usable JSON tree.
+  if (initvarRaw.length === 0) {
+    const hit = firstInitvarBlock(textsInGroups(candidates, 'worldbook', 'script'))
+    if (hit) {
+      initvarData = hit.parsed
+      initvarRaw = [hit.raw]
+      schemaSource = 'initvar'
+    }
+  }
+
+  // Last of the last resorts: a world-book entry marked `[initvar]…` whose content is
+  // bare YAML with no tag at all (see worldbookInitvarEntries). Four gates:
+  //
+  //   ① only after every source above came up empty — a card that already parses from
+  //      a greeting must not change where it reads from (native `<initvar>` wins);
+  //   ② the content must actually read as a YAML mapping (looksLikeInitvarMapping),
+  //      not as prose/documentation;
+  //   ③ the caller is told where the tree came from via `schemaSource`, so this
+  //      heuristic is visible in the API response instead of being silent;
+  //   ④ the parsed mapping must be non-empty.
+  //
+  // **`enabled` is deliberately not part of the filter.** The entry this fix exists for
+  // — 异世界农场's `[initvar]变量初始化勿开` — is itself `enabled: false`, and its
+  // comment literally says 「勿开」(do not enable). That is the convention, not an
+  // accident: authors keep the variable tree in a *disabled* entry so it is never
+  // injected into the prompt, while tooling can still read it. Skipping disabled
+  // entries would make this whole fallback a no-op on the only card that needs it
+  // (measured: repro-wb-initvar.mjs). What keeps junk out is the exact `[initvar]`
+  // marker plus gate ② — a disabled entry *without* that marker is never read.
+  if (initvarRaw.length === 0) {
+    for (const entry of worldbookInitvarEntries(data)) {
+      if (!looksLikeInitvarMapping(entry.content)) continue
+      const parsed = parseInitvar(entry.content)
+      if (!parsed || typeof parsed !== 'object' || Object.keys(parsed).length === 0) continue
+      initvarData = parsed
+      initvarRaw = [String(entry.content).trim()]
+      schemaSource = 'worldbook-initvar'
+      break
     }
   }
 
@@ -145,7 +320,8 @@ export function parseMuvCard(cardJson) {
     schemas,
     initvarData,
     initvarBlocks: initvarRaw,
-    zodSource
+    zodSource,
+    schemaSource
   }
 }
 
@@ -180,6 +356,19 @@ function inferSchemaFromData(data, name = '') {
         description: '',
         children: []
       })
+    } else if (Array.isArray(value)) {
+      // A `- item` list. The panel edits one row per field, so the items are
+      // joined with newlines for display; `initvarData` keeps the real array and
+      // serializeInitvar writes it back as `- item` lines. Without this branch a
+      // list fell into the `String(value)` case and showed up as "a,b".
+      fields.push({
+        name: key,
+        type: 'string',
+        defaultValue: value.map(v => (v === null || v === undefined) ? '' : String(v)).join('\n'),
+        description: '',
+        children: [],
+        isList: true
+      })
     } else {
       fields.push({
         name: key,

package/lib/panel.html

@@ -46,6 +46,15 @@ body { font-family: 'Segoe UI', 'Noto Sans SC', system-ui, sans-serif; backgroun
 </div>
 <script>
 let state = { cardName: '', schemas: [], initvarData: {}, edits: {}, generatedBlock: '' }
+// Where the variable tree was read from, shown next to the card name. `worldbook-initvar`
+// is the only *heuristic* source (a world-book entry marked `[initvar]` with bare YAML
+// and no tag), so it has to be visible — otherwise a wrong guess looks exactly like a
+// card that genuinely declares its variables.
+const SOURCE_LABEL = { 'initvar': '<initvar> 块', 'variable-insert': '<VariableInsert>', 'worldbook-initvar': '世界书 [initvar] 条目', 'none': '' }
+function badgeText(d) {
+  const label = SOURCE_LABEL[d.schemaSource]
+  return d.name + (label ? ' · ' + label : '')
+}
 function handleDrop(e) { e.preventDefault(); const f = e.dataTransfer.files[0]; if (f) loadFile(f) }
 function handleFile(e) { const f = e.target.files[0]; if (f) loadFile(f) }
 function loadFile(f) { const r = new FileReader(); r.onload = () => { try { parseCard(JSON.parse(r.result)) } catch(err) { alert('JSON error: '+err.message) } }; r.readAsText(f) }
@@ -55,7 +64,7 @@ async function parseCard(json) {
     const r = await fetch('/api/muv-table/parse-card', { method:'POST', headers:{'content-type':'application/json'}, body:JSON.stringify(json) })
     const d = await r.json(); if (!d.ok) throw new Error(d.error)
     state = { cardName: d.name, schemas: d.schemas, initvarData: d.initvarData, edits: {}, generatedBlock: '' }
-    document.getElementById('badge').style.display = 'inline'; document.getElementById('badge').textContent = d.name
+    document.getElementById('badge').style.display = 'inline'; document.getElementById('badge').textContent = badgeText(d)
     document.getElementById('btnGenerate').style.display = 'inline-block'
     renderTable()
   } catch(e) { document.getElementById('main').innerHTML = '<div style="padding:12px;color:var(--danger)">⚠ '+e.message+'</div>' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-muv-table",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "MUV 变量表格编辑器 —— 树形变量面板、宏测试浮窗（random/pick/roll）、骰子快捷栏、pick 缓存管理；支持直接读取 SillyTavern PNG 角色卡（含正则脚本、世界书、变量表）。dsh-muv-engine 的伴生插件",
   "type": "module",
   "main": "lib/index.js",
@@ -10,7 +10,7 @@
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },
-  "files": ["lib", "cordis.patch.yml", "CHANGELOG.md", "README.md", "test-png-card.mjs"],
+  "files": ["lib", "cordis.patch.yml", "CHANGELOG.md", "README.md", "test-png-card.mjs", "test-muv-parser.mjs", "test-preset-resolve.mjs"],
   "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "muv", "magvarupdate", "tavern", "variable-table"],
   "license": "PolyForm-Noncommercial-Copyleft-1.0.0",
   "dsh": {