dsh-cait 1.1.3 → 1.1.6

package/lib/analysis.js

@@ -0,0 +1,88 @@
+import { countWords } from './store-utils.js'
+import { normalizeText } from './similarity.js'
+
+/**
+ * Translation leverage is a quoting aid, not an accounting system. We keep the
+ * buckets aligned with the TM match bands the workbench already shows so a
+ * project manager can explain every number from the same lookup result.
+ */
+export const MATCH_BUCKETS = ['ice', 'exact', 'fuzzy85', 'fuzzy70', 'new']
+
+export function classifyLeverage(match) {
+  if (!match) return 'new'
+  if (match.contextMatch === 'ice' || match.percent >= 101) return 'ice'
+  if (match.exact) return 'exact'
+  if (match.percent >= 85) return 'fuzzy85'
+  if (match.percent >= 70) return 'fuzzy70'
+  return 'new'
+}
+
+export const analysisMethods = {
+  analyzeDocument({ documentId } = {}) {
+    const doc = this.requireDocument(documentId)
+    const buckets = { ice: 0, exact: 0, fuzzy85: 0, fuzzy70: 0, new: 0 }
+    const duplicateMap = new Map()
+    let words = 0
+    let characters = 0
+    let translated = 0
+    let confirmed = 0
+
+    for (let index = 0; index < doc.segments.length; index += 1) {
+      const segment = doc.segments[index]
+      const source = String(segment.source ?? '')
+      words += countWords(source)
+      characters += Array.from(source).length
+      if (String(segment.target ?? '').trim()) translated += 1
+      if (segment.confirmedAt) confirmed += 1
+      const key = normalizeText(source)
+      if (key) duplicateMap.set(key, (duplicateMap.get(key) || 0) + 1)
+
+      const result = this.lookupTM({
+        query: source,
+        threshold: 0.7,
+        limit: 1,
+        documentId: doc.id,
+        index,
+      })
+      const bucket = classifyLeverage(result.matches[0])
+      buckets[bucket] += 1
+    }
+
+    const total = doc.segments.length
+    const duplicateGroups = Array.from(duplicateMap.values()).filter((count) => count > 1)
+    const duplicateSegments = duplicateGroups.reduce((sum, count) => sum + count, 0)
+    const matched = buckets.ice + buckets.exact + buckets.fuzzy85 + buckets.fuzzy70
+    const weighted =
+      buckets.ice * 1.01 +
+      buckets.exact +
+      buckets.fuzzy85 * 0.9 +
+      buckets.fuzzy70 * 0.75
+    const percent = (value) => (total ? Math.round((value / total) * 1000) / 10 : 0)
+
+    return {
+      documentId: doc.id,
+      name: doc.name,
+      sourceLang: doc.sourceLang,
+      targetLang: doc.targetLang,
+      segments: total,
+      words,
+      characters,
+      translated,
+      confirmed,
+      duplicates: {
+        groups: duplicateGroups.length,
+        segments: duplicateSegments,
+      },
+      buckets,
+      matched: {
+        segments: matched,
+        percent: percent(matched),
+      },
+      leverage: {
+        weighted: total ? Math.round((weighted / total) * 1000) / 10 : 0,
+        percent: percent(weighted),
+      },
+      generatedAt: new Date().toISOString(),
+    }
+  },
+}

package/lib/api.js

@@ -10,16 +10,32 @@ const MUTATIONS = new Set([
   'openDocument',
   'closeDocument',
   'importFile',
+  'applyXliffReview',
   'importTmx',
   'loadDemo',
   'selectSegment',
   'saveDraft',
+  'replaceInDocument',
+  'undoReplace',
+  'addSegmentNote',
+  'updateSegmentNote',
+  'deleteSegmentNote',
+  'setSegmentLocked',
+  'mergeSegments',
+  'splitSegment',
+  'clearUnconfirmedTranslations',
   'adoptSuggestion',
   'proposeTranslation',
   'writeAlignment',
   'propagateDocument',
   'addGlossaryEntries',
   'preTranslate',
+  'setBrief',
+  'setDocumentResources',
+  'mergeTmLibraries',
+  'dedupeTmLibrary',
+  'pruneTmLibrary',
+  'unconfirmSegment',
   'confirmSegments',
   'confirmSegment',
   'moveSegment',
@@ -111,10 +127,22 @@ function createHandlers(store) {
     openDocument: (params) => store.openDocument(params),
     closeDocument: (params) => store.closeDocument(params),
     importFile: (params) => store.importFile(params),
+    applyXliffReview: (params) => store.applyXliffReview(params),
     importTmx: (params) => store.importTmx(params),
     loadDemo: () => store.loadDemo(),
     selectSegment: (params) => store.selectSegment(params),
     saveDraft: (params) => store.saveDraft(params),
+    replaceInDocument: (params) => store.replaceInDocument(params),
+    undoReplace: (params) => store.undoReplace(params),
+    notesForSegment: (params) => store.notesForSegment(params),
+    addSegmentNote: (params) => store.addSegmentNote(params),
+    updateSegmentNote: (params) => store.updateSegmentNote(params),
+    deleteSegmentNote: (params) => store.deleteSegmentNote(params),
+    setSegmentLocked: (params) => store.setSegmentLocked(params),
+    mergeSegments: (params) => store.mergeSegments(params),
+    splitSegment: (params) => store.splitSegment(params),
+    getClearUnconfirmedPreview: (params) => store.clearUnconfirmedTranslations({ ...params, confirm: false }),
+    clearUnconfirmedTranslations: confirmDangerous((params) => store.clearUnconfirmedTranslations({ ...params, confirm: true })),
     adoptSuggestion: (params) => store.adoptSuggestion(params),
     proposeTranslation: (params) => store.proposeTranslation(params),
     writeAlignment: (params) => store.writeAlignment(params),
@@ -127,6 +155,18 @@ function createHandlers(store) {
     preTranslate: (params) => store.preTranslate(params),
     confirmSegments: (params) => store.confirmSegmentsForTool(params),
     getQaReport: (params) => store.getQaReport(params),
+    reviewDocument: (params) => store.reviewDocument(params),
+    analyzeDocument: (params) => store.analyzeDocument(params),
+    tmMaintenancePreview: (params) => store.tmMaintenancePreview(params),
+    mergeTmLibraries: confirmDangerous((params) => store.mergeTmLibraries({ ...params, confirm: true })),
+    dedupeTmLibrary: confirmDangerous((params) => store.dedupeTmLibrary({ ...params, confirm: true })),
+    pruneTmLibrary: confirmDangerous((params) => store.pruneTmLibrary({ ...params, confirm: true })),
+    getBrief: (params) => store.getBrief(params),
+    setBrief: (params) => store.setBrief(params),
+    setDocumentResources: (params) => store.setDocumentResources(params),
+    contextForTool: (params) => store.contextForTool(params),
+    concordance: (params) => store.concordance(params),
+    unconfirmSegment: (params) => store.unconfirmSegment(params),
     confirmSegment: (params) => store.confirmSegment(params),
     moveSegment: (params) => store.moveSegment(params),
 

package/lib/brief.js

@@ -0,0 +1,275 @@
+import { CatError } from './errors.js'
+import { canonicalLanguage, cleanText, clampInt, normalizeSegmentState, now } from './store-utils.js'
+
+/**
+ * A document brief is deliberately small: the facts a translator would ask
+ * before starting. Project-level metadata (client, deadline, billing) belongs
+ * to the project layer in 1.1.5, not to every document.
+ */
+export const BRIEF_FIELDS = ['domain', 'audience', 'tone', 'notes', 'doNotTranslate', 'styleSample']
+
+const BRIEF_LIMITS = {
+  domain: 120,
+  audience: 200,
+  tone: 200,
+  notes: 2000,
+  doNotTranslate: 2000,
+  styleSample: 4000,
+}
+
+const BRIEF_LABELS = {
+  domain: 'Domain',
+  audience: 'Audience',
+  tone: 'Tone',
+  notes: 'Notes',
+  doNotTranslate: 'Do not translate',
+  styleSample: 'Style sample',
+}
+
+export function cleanBriefValue(field, value) {
+  const limit = BRIEF_LIMITS[field]
+  if (!limit) return ''
+  return String(value ?? '')
+    .replace(/\r\n?/g, '\n')
+    .trim()
+    .slice(0, limit)
+}
+
+/** Keep only known, non-empty fields. Used for new and restored documents. */
+export function normalizeBrief(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const brief = {}
+  for (const field of BRIEF_FIELDS) {
+    const text = cleanBriefValue(field, value[field])
+    if (text) brief[field] = text
+  }
+  if (!Object.keys(brief).length) return null
+  if (typeof value.updatedAt === 'string' && value.updatedAt) brief.updatedAt = value.updatedAt
+  return brief
+}
+
+function clip(text, max) {
+  const value = String(text ?? '')
+  return value.length > max ? `${value.slice(0, max)}…` : value
+}
+
+/** The prompt block shared by single-segment MT and batch MT. */
+export function briefPromptBlock(brief) {
+  if (!brief) return ''
+  const rows = []
+  for (const field of BRIEF_FIELDS) {
+    if (!brief[field]) continue
+    rows.push(`- ${BRIEF_LABELS[field]}: ${clip(brief[field], field === 'styleSample' ? 800 : 400)}`)
+  }
+  return rows.length ? `Document brief:\n${rows.join('\n')}\n` : ''
+}
+
+/** Bounded neighbours for prompts and the context tool. */
+export function neighborContext(doc, index, { before = 2, after = 2 } = {}) {
+  const total = doc.segments.length
+  const safeIndex = clampInt(index, 0, total - 1, 0)
+  const beforeCount = clampInt(before, 0, 5, 2)
+  const afterCount = clampInt(after, 0, 5, 2)
+  const start = Math.max(0, safeIndex - beforeCount)
+  const end = Math.min(total, safeIndex + afterCount + 1)
+  const view = (segment, at) => ({
+    index: at,
+    source: segment.source,
+    target: segment.target || '',
+    status: segment.status,
+  })
+  return {
+    before: doc.segments.slice(start, safeIndex).map((segment, offset) => view(segment, start + offset)),
+    after: doc.segments.slice(safeIndex + 1, end).map((segment, offset) => view(segment, safeIndex + 1 + offset)),
+  }
+}
+
+export function contextPromptBlock(doc, index) {
+  const { before, after } = neighborContext(doc, index)
+  if (!before.length && !after.length) return ''
+  const lines = ['Surrounding segments (for context only, do not translate them):']
+  for (const item of before) lines.push(`[previous] ${clip(item.source, 500)}`)
+  for (const item of after) lines.push(`[next] ${clip(item.source, 500)}`)
+  return `${lines.join('\n')}\n`
+}
+
+export const briefMethods = {
+  getBrief({ documentId } = {}) {
+    const doc = this.requireDocument(documentId)
+    return {
+      documentId: doc.id,
+      brief: doc.brief ? { ...doc.brief } : null,
+    }
+  },
+
+  /**
+   * Merge a patch into the document brief. Empty strings clear a field; an
+   * explicit null or `clear: true` removes the whole brief. A failed strict
+   * persist rolls the previous brief back.
+   */
+  setBrief({ documentId, brief, clear = false } = {}) {
+    const doc = this.requireDocument(documentId)
+    const previous = doc.brief
+    const previousUpdatedAt = doc.updatedAt
+    if (clear === true || brief === null) {
+      delete doc.brief
+    } else {
+      if (!brief || typeof brief !== 'object' || Array.isArray(brief)) {
+        throw new CatError('INVALID_BRIEF', 'brief 必须是对象。')
+      }
+      const next = { ...(doc.brief || {}) }
+      for (const field of BRIEF_FIELDS) {
+        if (!Object.prototype.hasOwnProperty.call(brief, field)) continue
+        const text = cleanBriefValue(field, brief[field])
+        if (text) next[field] = text
+        else delete next[field]
+      }
+      delete next.updatedAt
+      if (Object.keys(next).length) {
+        next.updatedAt = now()
+        doc.brief = next
+      } else {
+        delete doc.brief
+      }
+    }
+    doc.updatedAt = now()
+    this.touch()
+    try {
+      this.persist({ strict: true })
+    } catch (error) {
+      if (previous === undefined) delete doc.brief
+      else doc.brief = previous
+      doc.updatedAt = previousUpdatedAt
+      throw error
+    }
+    return { documentId: doc.id, brief: doc.brief ? { ...doc.brief } : null }
+  },
+
+  /**
+   * Everything an agent needs before translating or reviewing one segment:
+   * the brief, the segment, and a bounded window of its neighbours.
+   */
+  contextForTool({ documentId, index, before = 2, after = 2 } = {}) {
+    const doc = this.requireDocument(documentId)
+    const at = index === undefined || index === null ? doc.cursor : index
+    if (!Number.isInteger(at)) throw new CatError('SEGMENT_OUT_OF_RANGE', `句段索引不是整数: ${at}`)
+    const segment = this.findSegment(doc, at)
+    const window = neighborContext(doc, at, { before, after })
+    const paragraphCount =
+      doc.segments.reduce(
+        (max, item) => Math.max(max, Number.isInteger(item.paragraph) ? item.paragraph : 0),
+        0,
+      ) + 1
+    return {
+      document: {
+        id: doc.id,
+        name: doc.name,
+        sourceLang: doc.sourceLang,
+        targetLang: doc.targetLang,
+        total: doc.segments.length,
+        cursor: doc.cursor,
+      },
+      paragraph: {
+        index: Number.isInteger(segment.paragraph) ? segment.paragraph : 0,
+        count: paragraphCount,
+        // Paragraph headings are ordinary segments in CAIT; showing the
+        // document name is the one stable title every format provides.
+        title: doc.name,
+      },
+      brief: doc.brief ? { ...doc.brief } : null,
+      segment: {
+        index: at,
+        uid: segment.uid,
+        id: segment.id,
+        source: segment.source,
+        target: segment.target || '',
+        status: segment.status,
+        origin: segment.origin,
+        paragraph: segment.paragraph,
+      },
+      before: window.before,
+      after: window.after,
+    }
+  },
+
+  /** Substring search over every mounted TM entry, not just the active pair. */
+  concordance({ query, sourceLang, targetLang, limit = 20, documentId } = {}) {
+    const text = String(query ?? '').trim()
+    if (!text) throw new CatError('EMPTY_QUERY', '请输入要检索的词或短语。')
+    if (text.length > 200) throw new CatError('QUERY_TOO_LONG', '检索词最多 200 个字符。')
+    const doc = documentId ? this.requireDocument(documentId) : null
+    const src = sourceLang ? canonicalLanguage(sourceLang) : doc?.sourceLang || ''
+    const tgt = targetLang ? canonicalLanguage(targetLang) : doc?.targetLang || ''
+    const mounted = new Set(this.mounts.tmIds)
+    const needle = text.toLowerCase()
+    const max = clampInt(limit, 1, 50, 20)
+    const matches = []
+    for (const entry of this.tm) {
+      if (!mounted.has(entry.tmId)) continue
+      if (src && entry.sourceLang !== src) continue
+      if (tgt && entry.targetLang !== tgt) continue
+      if (!entry.source.toLowerCase().includes(needle) && !entry.target.toLowerCase().includes(needle)) {
+        continue
+      }
+      matches.push(entry)
+    }
+    matches.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+    const libraries = new Map(this.tmLibraries.map((library) => [library.tmId, library.name]))
+    return {
+      query: text,
+      total: matches.length,
+      entries: matches.slice(0, max).map((entry) => ({
+        source: entry.source,
+        target: entry.target,
+        sourceLang: entry.sourceLang,
+        targetLang: entry.targetLang,
+        context: entry.context || null,
+        tmId: entry.tmId,
+        library: libraries.get(entry.tmId) || entry.tmId,
+        updatedAt: entry.updatedAt,
+      })),
+    }
+  },
+
+  /**
+   * Revoke a confirmation without touching TM. TM is a reusable asset, and
+   * mainstream CAT tools also keep it when a segment is unconfirmed; a later
+   * confirmation updates the same entry.
+   */
+  unconfirmSegment({ documentId, index } = {}) {
+    const doc = this.requireDocument(documentId)
+    const at = index === undefined || index === null ? doc.cursor : index
+    if (!Number.isInteger(at)) throw new CatError('SEGMENT_OUT_OF_RANGE', `句段索引不是整数: ${at}`)
+    const segment = this.findSegment(doc, at)
+    if (segment.locked) throw new CatError('SEGMENT_LOCKED', '该句段已锁定，请先解锁再撤销确认。')
+    // Older stores may carry status=confirmed without a confirmedAt stamp.
+    if (segment.status !== 'confirmed' && !segment.confirmedAt) {
+      throw new CatError('NOT_CONFIRMED', '该句段还没有确认，不能撤销确认。', 409)
+    }
+    const previous = {
+      confirmedAt: segment.confirmedAt,
+      origin: segment.origin,
+      status: segment.status,
+      updatedAt: segment.updatedAt,
+    }
+    segment.confirmedAt = null
+    if (!segment.origin) segment.origin = 'manual'
+    segment.updatedAt = now()
+    normalizeSegmentState(segment)
+    doc.cursor = at
+    doc.updatedAt = now()
+    this.touch()
+    try {
+      this.persist({ strict: true })
+    } catch (error) {
+      Object.assign(segment, previous)
+      throw error
+    }
+    return {
+      segment: this.segmentView(segment, at),
+      progress: this.progress(doc),
+      documentId: doc.id,
+      index: at,
+    }
+  },
+}

package/lib/docx.js

@@ -389,4 +389,35 @@ export function buildDocxFromText(paragraphs) {
   ])
 }
 
+export function buildBilingualDocx(segments, { includeStatus = false, title = '' } = {}) {
+  const columns = includeStatus ? 3 : 2
+  const width = Math.floor(9000 / columns)
+  const cell = (text, shaded = false) => {
+    const paragraphs = String(text ?? '')
+      .split(/\r?\n/)
+      .map((line) => `<w:p><w:r><w:t xml:space="preserve">${escapeXml(line)}</w:t></w:r></w:p>`)
+      .join('')
+    const shade = shaded ? '<w:shd w:val="clear" w:color="auto" w:fill="F2F2F2"/>' : ''
+    return `<w:tc><w:tcPr><w:tcW w:w="${width}" w:type="dxa"/>${shade}</w:tcPr>${paragraphs}</w:tc>`
+  }
+  const header = `<w:tr><w:trPr><w:tblHeader/></w:trPr>${cell('Source', true)}${cell('Target', true)}${includeStatus ? cell('Status', true) : ''}</w:tr>`
+  const body = segments
+    .map(
+      (segment) =>
+        `<w:tr>${cell(segment.source)}${cell(segment.target || '')}${includeStatus ? cell(segment.status || '') : ''}</w:tr>`,
+    )
+    .join('')
+  const titleXml = title
+    ? `<w:p><w:r><w:rPr><w:b/><w:sz w:val="28"/></w:rPr><w:t xml:space="preserve">${escapeXml(title)}</w:t></w:r></w:p>`
+    : ''
+  const document = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${titleXml}<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/><w:tblBorders><w:top w:val="single" w:sz="4"/><w:left w:val="single" w:sz="4"/><w:bottom w:val="single" w:sz="4"/><w:right w:val="single" w:sz="4"/><w:insideH w:val="single" w:sz="4"/><w:insideV w:val="single" w:sz="4"/></w:tblBorders></w:tblPr><w:tblGrid>${Array.from({ length: columns }, () => `<w:gridCol w:w="${width}"/>`).join('')}</w:tblGrid>${header}${body}</w:tbl><w:sectPr><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440"/></w:sectPr></w:body></w:document>`
+  const contentTypes = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/></Types>`
+  const rels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>`
+  return writeZip([
+    { name: '[Content_Types].xml', data: Buffer.from(contentTypes, 'utf8') },
+    { name: '_rels/.rels', data: Buffer.from(rels, 'utf8') },
+    { name: 'word/document.xml', data: Buffer.from(document, 'utf8') },
+  ])
+}
+
 export { readZipEntries, writeZip }

package/lib/formats.js

@@ -577,6 +577,9 @@ function parseXliffUnit(body, attrs, format, tokens) {
   const targetMatch = body.match(/<(?:[\w.-]+:)?target\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?target>/i)
     ?? body.match(/<(?:[\w.-]+:)?target\b[^>]*\/>/i)
   const target = targetMatch ? extractInline(targetMatch[1] ?? '').text : ''
+  const targetTag = body.match(/<(?:[\w.-]+:)?target\b([^>]*)>/i)
+  const targetState = targetTag?.[1] ? readXmlAttr(targetTag[1], 'state') : ''
+  const caitUid = readXmlAttr(attrs, 'x-cait-uid')
   tokens.push(...source.tokens)
   return {
     source: source.text,
@@ -585,6 +588,8 @@ function parseXliffUnit(body, attrs, format, tokens) {
     meta: {
       format,
       xliffId: readXmlAttr(attrs, 'id'),
+      ...(caitUid ? { caitUid } : {}),
+      ...(targetState ? { targetState } : {}),
       ...(source.tokens.length ? { inline: source.tokens } : {}),
     },
   }
@@ -661,6 +666,38 @@ export function buildXliff(doc) {
   ].join('\n')
 }
 
+export function buildXliffReview(doc) {
+  const units = doc.segments.map((segment, index) => {
+    const id = String(segment.uid || segment.meta?.xliffId || index + 1)
+    const tokens = Array.isArray(segment.meta?.inline) ? segment.meta.inline : []
+    const target = completeInline(segment.target || '', tokens)
+    const state = segment.confirmedAt ? 'final' : segment.target ? 'translated' : 'new'
+    const note = segment.confirmedAt
+      ? 'confirmed'
+      : segment.origin
+        ? `origin: ${segment.origin}`
+        : ''
+    return [
+      `      <trans-unit id="${escapeXml(id)}" x-cait-uid="${escapeXml(segment.uid || id)}">`,
+      `        <source xml:lang="${escapeXml(doc.sourceLang)}">${renderInline(segment.source, tokens)}</source>`,
+      `        <target xml:lang="${escapeXml(doc.targetLang)}" state="${state}">${renderInline(target, tokens)}</target>`,
+      ...(note ? [`        <note from="cait">${escapeXml(note)}</note>`] : []),
+      '      </trans-unit>',
+    ].join('\n')
+  })
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<xliff version="1.2">',
+    `  <file source-language="${escapeXml(doc.sourceLang)}" target-language="${escapeXml(doc.targetLang)}" datatype="plaintext" original="${escapeXml(doc.name)}">`,
+    '    <body>',
+    ...units,
+    '    </body>',
+    '  </file>',
+    '</xliff>',
+    '',
+  ].join('\n')
+}
+
 export function buildXliff2(doc) {
   const units = doc.segments.map((segment, index) => {
     const id = String(segment.meta?.xliffId || index + 1)

package/lib/glossary.js

@@ -3,13 +3,16 @@ import { DEFAULT_GLOSSARY_ID, DEFAULT_GLOSSARY_NAME, MAX_SEGMENTS, canonicalLang
 import { normalizeText } from './similarity.js'
 
 export const glossaryMethods = {
-  findGlossaryHits(text, sourceLang) {
+  findGlossaryHits(text, sourceLang, documentId) {
     const haystack = String(text ?? '')
     if (!haystack) return []
     const lower = haystack.toLowerCase()
     const lang = sourceLang ? canonicalLanguage(sourceLang) : ''
     const hits = []
-    const mountedGlossary = new Set(this.mounts.glossaryIds)
+    const scopedDoc = documentId ? this.requireDocument(documentId) : null
+    const mountedGlossary = new Set(
+      scopedDoc ? this.effectiveGlossaryIds(scopedDoc) : this.mounts.glossaryIds,
+    )
 
     for (const entry of this.glossary) {
       if (!mountedGlossary.has(entry.glossaryId || DEFAULT_GLOSSARY_ID)) continue
@@ -29,6 +32,8 @@ export const glossaryMethods = {
         term: entry.source,
         target: entry.target,
         note: entry.note || '',
+        forbidden: Boolean(entry.forbidden),
+        preferred: Boolean(entry.preferred),
         count,
       })
     }
@@ -36,7 +41,7 @@ export const glossaryMethods = {
     return hits.sort((a, b) => b.term.length - a.term.length)
   }
 ,
-  addGlossary({ source, target, note, sourceLang, caseSensitive, glossaryId } = {}) {
+  addGlossary({ source, target, note, sourceLang, caseSensitive, forbidden, preferred, glossaryId } = {}) {
     const term = cleanText(source, '术语')
     const translation = cleanText(target, '术语译文')
     if (!term || !translation) throw new CatError('EMPTY_TERM', '术语和译文都不能为空。')
@@ -53,6 +58,8 @@ export const glossaryMethods = {
       existing.target = translation
       existing.note = String(note ?? '').trim()
       existing.caseSensitive = Boolean(caseSensitive)
+      existing.forbidden = Boolean(forbidden)
+      existing.preferred = Boolean(preferred)
       existing.updatedAt = now()
       this.touch()
       this.persist()
@@ -66,6 +73,8 @@ export const glossaryMethods = {
       note: String(note ?? '').trim(),
       sourceLang: lang,
       caseSensitive: Boolean(caseSensitive),
+      forbidden: Boolean(forbidden),
+      preferred: Boolean(preferred),
       createdAt: now(),
       updatedAt: now(),
     }
@@ -75,7 +84,7 @@ export const glossaryMethods = {
     return { entry: { ...entry }, created: true }
   }
 ,
-  updateGlossary({ id, source, target, note, caseSensitive } = {}) {
+  updateGlossary({ id, source, target, note, caseSensitive, forbidden, preferred } = {}) {
     const entry = this.glossary.find((item) => item.id === id)
     if (!entry) throw new CatError('TERM_NOT_FOUND', '术语不存在。', 404)
     // The library page manages every library, mounted or not; only the target
@@ -93,6 +102,9 @@ export const glossaryMethods = {
     }
     if (note !== undefined) entry.note = String(note ?? '').trim()
     if (caseSensitive !== undefined) entry.caseSensitive = Boolean(caseSensitive)
+    if (forbidden !== undefined) entry.forbidden = Boolean(forbidden)
+    if (preferred !== undefined) entry.preferred = Boolean(preferred)
+    if (entry.forbidden) entry.preferred = false
     entry.updatedAt = now()
     this.touch()
     this.persist()
@@ -129,6 +141,8 @@ export const glossaryMethods = {
       if (existing) {
         existing.target = String(item.target).trim()
         existing.note = String(item.note ?? '').trim()
+        existing.forbidden = Boolean(item.forbidden)
+        existing.preferred = Boolean(item.preferred) && !existing.forbidden
         existing.updatedAt = now()
         updated += 1
       } else {
@@ -140,6 +154,8 @@ export const glossaryMethods = {
           note: String(item.note ?? '').trim(),
           sourceLang: lang,
           caseSensitive: Boolean(item.caseSensitive),
+          forbidden: Boolean(item.forbidden),
+          preferred: Boolean(item.preferred) && !item.forbidden,
           createdAt: now(),
           updatedAt: now(),
         })