dravoice 0.1.2 → 0.1.4

package/src/v2/analyzers/discourse.js

@@ -1,63 +1,69 @@
-import { rate, topItems } from "../text-utils.js";
-
-const TRANSITIONS = {
-  additive: /\b(also|and|another|again|plus)\b/i,
-  contrast: /\b(but|however|although|yet|instead|still)\b/i,
-  causal: /\b(because|so|therefore|since|as a result)\b/i,
-  temporal: /\b(then|before|after|while|when|first|second|later)\b/i,
-  example: /\b(for example|such as|including|like)\b/i,
-  conclusion: /\b(so|therefore|finally|in the end|the lesson)\b/i,
-};
-
-export function analyzeDiscourse(documents) {
-  const sentences = documents.flatMap((document) => document.sentences);
-  const labels = sentences.map((sentence) => transitionLabel(sentence.text));
-  const nonPlainLabels = labels.filter((label) => label !== "plain");
-  const transitionRates = {};
-  for (const key of Object.keys(TRANSITIONS)) {
-    transitionRates[key] = rate(labels.filter((label) => label === key).length, sentences.length, 2);
-  }
-
-  return {
-    family: "discourse",
-    confidence: sentences.length >= 12 ? "medium" : "low",
-    features: {
-      transitionRates,
-      transitionSequence: labels.slice(0, 12),
-      transitionBigrams: topItems(sequenceNgrams(labels, 2), 12),
-      transitionTrigrams: topItems(sequenceNgrams(labels, 3), 12),
-      sentenceCallbacks: callbackRate(sentences),
-    },
-    examples: topItems(nonPlainLabels, 5).map((item) => item.value),
-    warnings: sentences.length < 12 ? ["Discourse confidence is limited because the corpus has fewer than 12 sentences."] : [],
-    revisionHandles: ["Compare how sentences turn, contrast, explain, and return to earlier ideas."],
-  };
-}
-
-export function transitionLabel(text) {
-  for (const [label, pattern] of Object.entries(TRANSITIONS)) {
-    if (pattern.test(text)) {
-      return label;
-    }
-  }
-  return "plain";
-}
-
-function callbackRate(sentences) {
-  let callbacks = 0;
-  for (let index = 1; index < sentences.length; index += 1) {
-    const previous = new Set(sentences[index - 1].tokens.filter((word) => word.length > 3));
-    if (sentences[index].tokens.some((word) => previous.has(word))) {
-      callbacks += 1;
-    }
-  }
-  return rate(callbacks, Math.max(1, sentences.length - 1), 2);
-}
-
-function sequenceNgrams(values, size) {
-  const result = [];
-  for (let index = 0; index <= values.length - size; index += 1) {
-    result.push(values.slice(index, index + size).join(" -> "));
-  }
-  return result;
-}
+import { rate, topItems } from "../text-utils.js";
+
+const TRANSITIONS = {
+  contrast: /^(?:but|however|although|yet|instead|still)\b/i,
+  causal: /^(?:because|so|therefore|since|as a result)\b/i,
+  conclusion: /^(?:therefore|finally|in the end|the lesson)\b/i,
+  temporal: /^(?:then|before|after|while|when|first|second|later)\b/i,
+  example: /^(?:for example|such as|including)\b/i,
+  additive: /^(?:also|another|again|plus|and)\b/i,
+};
+
+export function analyzeDiscourse(documents) {
+  const sentences = documents.flatMap((document) => document.sentences);
+  const labels = sentences.map((sentence) => transitionLabel(sentence.text));
+  const nonPlainLabels = labels.filter((label) => label !== "plain");
+  const transitionRates = {};
+  for (const key of Object.keys(TRANSITIONS)) {
+    transitionRates[key] = rate(labels.filter((label) => label === key).length, sentences.length, 2);
+  }
+
+  return {
+    family: "discourse",
+    confidence: sentences.length >= 12 ? "medium" : "low",
+    features: {
+      transitionRates,
+      transitionSequence: labels.slice(0, 12),
+      transitionBigrams: topItems(sequenceNgrams(labels, 2), 12),
+      transitionTrigrams: topItems(sequenceNgrams(labels, 3), 12),
+      sentenceCallbacks: callbackRate(sentences),
+    },
+    examples: topItems(nonPlainLabels, 5).map((item) => item.value),
+    warnings: sentences.length < 12 ? ["Discourse confidence is limited because the corpus has fewer than 12 sentences."] : [],
+    revisionHandles: ["Compare how sentences turn, contrast, explain, and return to earlier ideas."],
+  };
+}
+
+export function transitionLabel(text) {
+  const normalized = String(text ?? "");
+  for (const [label, pattern] of Object.entries(TRANSITIONS)) {
+    if (pattern.test(normalized) || embeddedTransitionPattern(pattern).test(normalized)) {
+      return label;
+    }
+  }
+  return "plain";
+}
+
+function embeddedTransitionPattern(pattern) {
+  const source = pattern.source.replace(/^\^\(\?:/, "(?:");
+  return new RegExp(`[.;:,]\\s+${source}`, pattern.flags);
+}
+
+function callbackRate(sentences) {
+  let callbacks = 0;
+  for (let index = 1; index < sentences.length; index += 1) {
+    const previous = new Set(sentences[index - 1].tokens.filter((word) => word.length > 3));
+    if (sentences[index].tokens.some((word) => previous.has(word))) {
+      callbacks += 1;
+    }
+  }
+  return rate(callbacks, Math.max(1, sentences.length - 1), 2);
+}
+
+function sequenceNgrams(values, size) {
+  const result = [];
+  for (let index = 0; index <= values.length - size; index += 1) {
+    result.push(values.slice(index, index + size).join(" -> "));
+  }
+  return result;
+}

package/src/v2/analyzers/evidence.js

@@ -1,82 +1,82 @@
-import { rate, topItems } from "../text-utils.js";
-
-const EVIDENCE_PATTERNS = {
-  date: /\b\d{1,2}:\d{2}\s?(?:am|pm)?\b|\b20\d{2}-\d{2}-\d{2}\b|\b(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i,
-  number: /\b\d+(?:\.\d+)?\b/,
-  quote: /"[^"]+"|'[^']+'|^>/,
-  url: /https?:\/\/\S+/i,
-  citation: /\[[^\]]+\]\([^)]+\)|\([A-Z][A-Za-z]+,\s*\d{4}\)/,
-  sourceAttribution: /\b(according to|reported|observed|noted|recorded|quoted|interviewed|surveyed|field notes said|data shows|study found|the memo|the log|the report)\b/i,
-  sensory: /\b(cold|warm|hot|cool|quiet|loud|bright|dark|red|blue|green|rough|smooth|sharp|soft|smelled|smell|scent|tasted|heard|sound|noise|flashed|visible|physical|rain|metal|smoke)\b/i,
-  specificExample: /\b(for example|for instance|such as|including|included|includes|sample|case in point|specifically|in one case)\b/i,
-};
-
-const ABSTRACT_CLAIM_RE = /\b(always|never|everyone|everything|nothing|best|better|worse|important|obvious|clearly|should|must|need to|have to|all|none|every)\b/i;
-
-export function analyzeEvidence(documents) {
-  const documentResults = documents.map(documentEvidence);
-  const sentenceCount = documentResults.reduce((sum, item) => sum + item.sentenceCount, 0);
-  const evidenceSentenceCount = documentResults.reduce((sum, item) => sum + item.evidenceSentenceCount, 0);
-  const claimSentenceCount = documentResults.reduce((sum, item) => sum + item.claimSentenceCount, 0);
-  const supportedClaimCount = documentResults.reduce((sum, item) => sum + item.supportedClaimCount, 0);
-  const unsupportedClaimCount = documentResults.reduce((sum, item) => sum + item.unsupportedClaimCount, 0);
-  const typeValues = documentResults.flatMap((item) => item.typeValues);
-
-  return {
-    family: "evidence",
-    confidence: sentenceCount >= 12 ? "medium" : "low",
-    features: {
-      sentenceCount,
-      evidenceSentenceCount,
-      evidenceSentenceRate: rate(evidenceSentenceCount, sentenceCount, 2),
-      claimSentenceCount,
-      claimSentenceRate: rate(claimSentenceCount, sentenceCount, 2),
-      supportedClaimRate: rate(supportedClaimCount, Math.max(1, claimSentenceCount), 2),
-      unsupportedClaimRate: rate(unsupportedClaimCount, Math.max(1, claimSentenceCount), 2),
-      evidenceTypes: topItems(typeValues, 8),
-    },
-    examples: topItems(typeValues, 4).map((item) => `${item.value}: ${item.count}`),
-    warnings: sentenceCount < 12 ? ["Evidence confidence is limited because the corpus has fewer than 12 sentences."] : [],
-    revisionHandles: ["Compare how broad claims are supported by concrete scenes, numbers, quotes, citations, or examples."],
-  };
-}
-
-function documentEvidence(document) {
-  const sentences = document.sentences;
-  const sentenceEvidenceTypes = sentences.map((sentence) => evidenceTypes(sentence.text));
-  const evidenceSentences = sentences.filter((_, index) => sentenceEvidenceTypes[index].length > 0);
-  const claimIndexes = sentences
-    .map((sentence, index) => ({ sentence, index }))
-    .filter(({ sentence }) => ABSTRACT_CLAIM_RE.test(sentence.text))
-    .map(({ index }) => index);
-  const supportedClaimIndexes = claimIndexes.filter((index) => hasNearbyEvidence(sentenceEvidenceTypes, index));
-  return {
-    sentenceCount: sentences.length,
-    evidenceSentenceCount: evidenceSentences.length,
-    claimSentenceCount: claimIndexes.length,
-    supportedClaimCount: supportedClaimIndexes.length,
-    unsupportedClaimCount: claimIndexes.length - supportedClaimIndexes.length,
-    typeValues: evidenceSentences.flatMap((sentence) => evidenceTypes(sentence.text)),
-  };
-}
-
-function hasNearbyEvidence(sentenceEvidenceTypes, claimIndex) {
-  const start = Math.max(0, claimIndex - 2);
-  const end = Math.min(sentenceEvidenceTypes.length - 1, claimIndex + 2);
-  for (let index = start; index <= end; index += 1) {
-    if (sentenceEvidenceTypes[index].length > 0) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export function evidenceTypes(text) {
-  return Object.entries(EVIDENCE_PATTERNS)
-    .filter(([, pattern]) => pattern.test(text))
-    .map(([type]) => type);
-}
-
-export function isAbstractClaim(text) {
-  return ABSTRACT_CLAIM_RE.test(text);
-}
+import { rate, topItems } from "../text-utils.js";
+
+const EVIDENCE_PATTERNS = {
+  date: /\b\d{1,2}:\d{2}\s?(?:am|pm)?\b|\b20\d{2}-\d{2}-\d{2}\b|\b(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b|\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\s+\d{1,2},?\s+\d{4}\b/i,
+  number: /\b\d+(?:\.\d+)?\b/,
+  quote: /"[^"]+"|'[^']+'|^>/,
+  url: /https?:\/\/\S+/i,
+  citation: /\[[^\]]+\]\([^)]+\)|\[\^[^\]]+\]|\([A-Z][A-Za-z]+,\s*\d{4}\)/,
+  sourceAttribution: /\b(according to|reported|observed|noted|recorded|quoted|interviewed|surveyed|field notes said|data shows|study found|the memo|the log|the report|source:|internal memo)\b/i,
+  sensory: /\b(cold|warm|hot|cool|quiet|loud|bright|dark|red|blue|green|rough|smooth|sharp|soft|smelled|smell|scent|tasted|heard|sound|noise|flashed|visible|physical|rain|metal|smoke)\b/i,
+  specificExample: /\b(for example|for instance|such as|including|included|includes|sample|case in point|specifically|in one case)\b/i,
+};
+
+const ABSTRACT_CLAIM_RE = /\b(always|never|everyone|everything|nothing|best|better|worse|important|obvious|clearly|should|must|need to|have to|all|none|every)\b/i;
+
+export function analyzeEvidence(documents) {
+  const documentResults = documents.map(documentEvidence);
+  const sentenceCount = documentResults.reduce((sum, item) => sum + item.sentenceCount, 0);
+  const evidenceSentenceCount = documentResults.reduce((sum, item) => sum + item.evidenceSentenceCount, 0);
+  const claimSentenceCount = documentResults.reduce((sum, item) => sum + item.claimSentenceCount, 0);
+  const supportedClaimCount = documentResults.reduce((sum, item) => sum + item.supportedClaimCount, 0);
+  const unsupportedClaimCount = documentResults.reduce((sum, item) => sum + item.unsupportedClaimCount, 0);
+  const typeValues = documentResults.flatMap((item) => item.typeValues);
+
+  return {
+    family: "evidence",
+    confidence: sentenceCount >= 12 ? "medium" : "low",
+    features: {
+      sentenceCount,
+      evidenceSentenceCount,
+      evidenceSentenceRate: rate(evidenceSentenceCount, sentenceCount, 2),
+      claimSentenceCount,
+      claimSentenceRate: rate(claimSentenceCount, sentenceCount, 2),
+      supportedClaimRate: rate(supportedClaimCount, Math.max(1, claimSentenceCount), 2),
+      unsupportedClaimRate: rate(unsupportedClaimCount, Math.max(1, claimSentenceCount), 2),
+      evidenceTypes: topItems(typeValues, 8),
+    },
+    examples: topItems(typeValues, 4).map((item) => `${item.value}: ${item.count}`),
+    warnings: sentenceCount < 12 ? ["Evidence confidence is limited because the corpus has fewer than 12 sentences."] : [],
+    revisionHandles: ["Compare how broad claims are supported by concrete scenes, numbers, quotes, citations, or examples."],
+  };
+}
+
+function documentEvidence(document) {
+  const sentences = document.sentences;
+  const sentenceEvidenceTypes = sentences.map((sentence) => evidenceTypes(sentence.text));
+  const evidenceSentences = sentences.filter((_, index) => sentenceEvidenceTypes[index].length > 0);
+  const claimIndexes = sentences
+    .map((sentence, index) => ({ sentence, index }))
+    .filter(({ sentence }) => ABSTRACT_CLAIM_RE.test(sentence.text))
+    .map(({ index }) => index);
+  const supportedClaimIndexes = claimIndexes.filter((index) => hasNearbyEvidence(sentenceEvidenceTypes, index));
+  return {
+    sentenceCount: sentences.length,
+    evidenceSentenceCount: evidenceSentences.length,
+    claimSentenceCount: claimIndexes.length,
+    supportedClaimCount: supportedClaimIndexes.length,
+    unsupportedClaimCount: claimIndexes.length - supportedClaimIndexes.length,
+    typeValues: evidenceSentences.flatMap((sentence) => evidenceTypes(sentence.text)),
+  };
+}
+
+function hasNearbyEvidence(sentenceEvidenceTypes, claimIndex) {
+  const start = Math.max(0, claimIndex - 2);
+  const end = Math.min(sentenceEvidenceTypes.length - 1, claimIndex + 2);
+  for (let index = start; index <= end; index += 1) {
+    if (sentenceEvidenceTypes[index].length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function evidenceTypes(text) {
+  return Object.entries(EVIDENCE_PATTERNS)
+    .filter(([, pattern]) => pattern.test(text))
+    .map(([type]) => type);
+}
+
+export function isAbstractClaim(text) {
+  return ABSTRACT_CLAIM_RE.test(text);
+}

package/src/v2/analyzers/lexical.js

@@ -1,114 +1,114 @@
-import {
-  FUNCTION_WORDS,
-  characterNgrams,
-  contentWords,
-  distribution,
-  normalizeText,
-  rate,
-  tokenizeWords,
-  topItems,
-} from "../text-utils.js";
-
-export function analyzeLexical(documents) {
-  const text = documents.map((document) => document.text).join("\n\n");
-  const words = tokenizeWords(text);
-  const content = contentWords(text);
-  const sentences = documents.flatMap((document) => document.sentences);
-  const functionWordSet = new Set(FUNCTION_WORDS);
-
-  return {
-    family: "lexical",
-    confidence: confidenceFor(words.length),
-    features: {
-      wordCount: words.length,
-      contentWordCount: content.length,
-      vocabularyRichness: {
-        uniqueContentWords: new Set(content).size,
-        contentTypeTokenRatio: rate(new Set(content).size, content.length, 3),
-      },
-      wordLength: distribution(words.map((word) => word.length)),
-      functionWords: topItems(words.filter((word) => functionWordSet.has(word)), 24),
-      functionWordBigrams: topItems(tokenNgrams(words.filter((word) => functionWordSet.has(word)), 2), 36),
-      characterTrigrams: topItems(characterNgrams(text, 3), 24),
-      maskedCharacterFourgrams: topItems(maskedCharacterNgrams(text, 4), 48),
-      repeatedMotifs: topItems(content, 16).filter((item) => item.count > 1),
-      sentenceInitialTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens[0], functionWordSet)), 16),
-      sentenceFinalTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens.at(-1), functionWordSet)), 16),
-      punctuationNgrams: topItems(punctuationNgrams(text, 3), 16),
-      punctuation: {
-        commaRate: rate(count(text, /,/g), sentences.length, 2),
-        semicolonRate: rate(count(text, /;/g), sentences.length, 2),
-        colonRate: rate(count(text, /:/g), sentences.length, 2),
-        questionRate: rate(count(text, /\?/g), sentences.length, 2),
-        dashRate: rate(count(text, /--|-/g), sentences.length, 2),
-      },
-    },
-    examples: topItems(content, 5).map((item) => item.value),
-    warnings: words.length < 200 ? ["Lexical confidence is limited because the corpus has fewer than 200 words."] : [],
-    revisionHandles: ["Compare function words, vocabulary richness, motifs, and punctuation habits."],
-  };
-}
-
-function boundaryToken(word, functionWordSet) {
-  if (!word) {
-    return null;
-  }
-  if (functionWordSet.has(word)) {
-    return word;
-  }
-  if (/^\d+$/.test(word)) {
-    return "<number>";
-  }
-  return "<content>";
-}
-
-function tokenNgrams(tokens, size) {
-  const grams = [];
-  for (let index = 0; index <= tokens.length - size; index += 1) {
-    grams.push(tokens.slice(index, index + size).join(" "));
-  }
-  return grams;
-}
-
-function maskedCharacterNgrams(text, size) {
-  const functionWordSet = new Set(FUNCTION_WORDS);
-  const masked = normalizeText(text)
-    .replace(/\p{L}[\p{L}\p{N}'-]*|\p{N}+/gu, (word) => {
-      const normalized = word.toLowerCase().replace(/'s$/, "");
-      if (functionWordSet.has(normalized)) {
-        return normalized;
-      }
-      if (/^\p{N}+$/u.test(normalized)) {
-        return "@";
-      }
-      return "#";
-    })
-    .replace(/\s+/g, " ");
-  const grams = [];
-  for (let index = 0; index <= masked.length - size; index += 1) {
-    const gram = masked.slice(index, index + size);
-    if (gram.trim()) {
-      grams.push(gram);
-    }
-  }
-  return grams;
-}
-
-function punctuationNgrams(text, size) {
-  const marks = Array.from(String(text ?? "").matchAll(/[.,;:!?-]/g)).map((match) => match[0]);
-  return tokenNgrams(marks, size);
-}
-
-function confidenceFor(wordCount) {
-  if (wordCount >= 2000) {
-    return "high";
-  }
-  if (wordCount >= 120) {
-    return "medium";
-  }
-  return "low";
-}
-
-function count(text, pattern) {
-  return Array.from(text.matchAll(pattern)).length;
-}
+import {
+  FUNCTION_WORDS,
+  characterNgrams,
+  contentWords,
+  distribution,
+  normalizeText,
+  rate,
+  tokenizeWords,
+  topItems,
+} from "../text-utils.js";
+
+export function analyzeLexical(documents) {
+  const text = documents.map((document) => document.text).join("\n\n");
+  const words = tokenizeWords(text);
+  const content = contentWords(text);
+  const sentences = documents.flatMap((document) => document.sentences);
+  const functionWordSet = new Set(FUNCTION_WORDS);
+
+  return {
+    family: "lexical",
+    confidence: confidenceFor(words.length),
+    features: {
+      wordCount: words.length,
+      contentWordCount: content.length,
+      vocabularyRichness: {
+        uniqueContentWords: new Set(content).size,
+        contentTypeTokenRatio: rate(new Set(content).size, content.length, 3),
+      },
+      wordLength: distribution(words.map((word) => word.length)),
+      functionWords: topItems(words.filter((word) => functionWordSet.has(word)), 24),
+      functionWordBigrams: topItems(tokenNgrams(words.filter((word) => functionWordSet.has(word)), 2), 36),
+      characterTrigrams: topItems(characterNgrams(text, 3), 24),
+      maskedCharacterFourgrams: topItems(maskedCharacterNgrams(text, 4), 48),
+      repeatedMotifs: topItems(content, 16).filter((item) => item.count > 1),
+      sentenceInitialTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens[0], functionWordSet)), 16),
+      sentenceFinalTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens.at(-1), functionWordSet)), 16),
+      punctuationNgrams: topItems(punctuationNgrams(text, 3), 16),
+      punctuation: {
+        commaRate: rate(count(text, /,/g), sentences.length, 2),
+        semicolonRate: rate(count(text, /;/g), sentences.length, 2),
+        colonRate: rate(count(text, /:/g), sentences.length, 2),
+        questionRate: rate(count(text, /\?/g), sentences.length, 2),
+        dashRate: rate(count(text, /--|-/g), sentences.length, 2),
+      },
+    },
+    examples: topItems(content, 5).map((item) => item.value),
+    warnings: words.length < 200 ? ["Lexical confidence is limited because the corpus has fewer than 200 words."] : [],
+    revisionHandles: ["Compare function words, vocabulary richness, motifs, and punctuation habits."],
+  };
+}
+
+function boundaryToken(word, functionWordSet) {
+  if (!word) {
+    return null;
+  }
+  if (functionWordSet.has(word)) {
+    return word;
+  }
+  if (/^\d+$/.test(word)) {
+    return "<number>";
+  }
+  return "<content>";
+}
+
+function tokenNgrams(tokens, size) {
+  const grams = [];
+  for (let index = 0; index <= tokens.length - size; index += 1) {
+    grams.push(tokens.slice(index, index + size).join(" "));
+  }
+  return grams;
+}
+
+function maskedCharacterNgrams(text, size) {
+  const functionWordSet = new Set(FUNCTION_WORDS);
+  const masked = normalizeText(text)
+    .replace(/\p{L}[\p{L}\p{N}'-]*|\p{N}+/gu, (word) => {
+      const normalized = word.toLowerCase().replace(/'s$/, "");
+      if (functionWordSet.has(normalized)) {
+        return normalized;
+      }
+      if (/^\p{N}+$/u.test(normalized)) {
+        return "@";
+      }
+      return "#";
+    })
+    .replace(/\s+/g, " ");
+  const grams = [];
+  for (let index = 0; index <= masked.length - size; index += 1) {
+    const gram = masked.slice(index, index + size);
+    if (gram.trim()) {
+      grams.push(gram);
+    }
+  }
+  return grams;
+}
+
+function punctuationNgrams(text, size) {
+  const marks = Array.from(String(text ?? "").matchAll(/[.,;:!?-]/g)).map((match) => match[0]);
+  return tokenNgrams(marks, size);
+}
+
+function confidenceFor(wordCount) {
+  if (wordCount >= 2000) {
+    return "high";
+  }
+  if (wordCount >= 120) {
+    return "medium";
+  }
+  return "low";
+}
+
+function count(text, pattern) {
+  return Array.from(text.matchAll(pattern)).length;
+}

package/src/v2/analyzers/register.js

@@ -1,34 +1,70 @@
-import { contentWords, rate, topItems } from "../text-utils.js";
-
-const REGISTER_MARKERS = {
-  narrative: ["scene", "moment", "watched", "waited", "noticed", "remembered", "described", "story"],
-  explanatory: ["because", "so", "therefore", "means", "shows", "explains", "reason", "pattern"],
-  argumentative: ["should", "must", "better", "important", "claim", "therefore", "argue", "evidence"],
-  instructional: ["start", "fix", "use", "avoid", "keep", "write", "revise", "follow"],
-  reflective: ["lesson", "pause", "changed", "remember", "noticed", "felt", "learned", "realized"],
-  technical: ["file", "test", "system", "code", "api", "build"],
-  personal: ["i", "my", "we", "our"],
-  formal: ["requires", "outcomes", "process", "alignment", "therefore"],
-};
-
-export function analyzeRegister(documents) {
-  const text = documents.map((document) => document.text.toLowerCase()).join("\n\n");
-  const words = new Set(contentWords(text));
-  const scores = Object.entries(REGISTER_MARKERS).map(([value, markers]) => ({
-    value,
-    score: rate(markers.filter((marker) => text.includes(marker) || words.has(marker)).length, markers.length, 2),
-  })).sort((left, right) => right.score - left.score || left.value.localeCompare(right.value));
-
-  return {
-    family: "register",
-    confidence: documents.length >= 3 ? "medium" : "low",
-    features: {
-      primary: scores[0] ?? { value: "unknown", score: 0 },
-      scores,
-      topContentWords: topItems(contentWords(text), 12),
-    },
-    examples: scores.slice(0, 3).map((item) => `${item.value}: ${item.score}`),
-    warnings: documents.length < 3 ? ["Register confidence is limited because the corpus has fewer than 3 documents."] : [],
-    revisionHandles: ["Check whether the draft uses the same broad register and genre mix as the corpus."],
-  };
-}
+import { contentWords, rate, topItems } from "../text-utils.js";
+
+const REGISTER_MARKERS = {
+  narrative: ["scene", "moment", "watched", "waited", "noticed", "remembered", "described", "story"],
+  explanatory: ["because", "so", "therefore", "means", "shows", "explains", "reason", "pattern"],
+  argumentative: ["should", "must", "better", "important", "claim", "therefore", "argue", "evidence"],
+  instructional: ["start", "fix", "use", "avoid", "keep", "write", "revise", "follow"],
+  reflective: ["lesson", "pause", "changed", "remember", "noticed", "felt", "learned", "realized"],
+  technical: ["file", "test", "system", "code", "api", "build"],
+  personal: ["i", "my", "we", "our"],
+  formal: ["requires", "outcomes", "process", "alignment", "therefore"],
+};
+
+export function analyzeRegister(documents, { markers = REGISTER_MARKERS } = {}) {
+  const text = documents.map((document) => document.text.toLowerCase()).join("\n\n");
+  const words = new Set(contentWords(text));
+  const markerSets = Object.entries(markers).map(([value, markerList]) => {
+    const matchedMarkers = markerList.filter((marker) => markerAppears(text, words, marker));
+    return {
+      value,
+      markers: markerList,
+      matchedMarkers,
+      score: rate(matchedMarkers.length, markerList.length, 2),
+    };
+  });
+  const scores = markerSets.map(({ value, score }) => ({
+    value,
+    score,
+  })).sort((left, right) => right.score - left.score || left.value.localeCompare(right.value));
+  const mixedRegister = isMixedRegister(scores);
+
+  return {
+    family: "register",
+    confidence: documents.length >= 3 ? "medium" : "low",
+    features: {
+      primary: scores[0] ?? { value: "unknown", score: 0 },
+      scores,
+      markerSets,
+      mixedRegister,
+      topContentWords: topItems(contentWords(text), 12),
+    },
+    examples: scores.slice(0, 3).map((item) => `${item.value}: ${item.score}`),
+    warnings: [
+      ...(documents.length < 3 ? ["Register confidence is limited because the corpus has fewer than 3 documents."] : []),
+      ...(mixedRegister ? ["Mixed register signals detected; treat the primary register as a weak summary of the genre mix."] : []),
+    ],
+    revisionHandles: ["Check whether the draft uses the same broad register and genre mix as the corpus."],
+  };
+}
+
+function isMixedRegister(scores) {
+  const active = scores.filter((item) => item.score > 0);
+  if (active.length < 2) {
+    return false;
+  }
+  const [first, second] = active;
+  return second.score >= Math.max(0.2, first.score * 0.6);
+}
+
+function markerAppears(text, words, marker) {
+  const normalized = marker.toLowerCase();
+  if (/^[a-z0-9'-]+$/.test(normalized)) {
+    return words.has(normalized) || new RegExp(`\\b${escapeRegExp(normalized)}\\b`, "i").test(text);
+  }
+  return new RegExp(`\\b${escapeRegExp(normalized).replaceAll("\\ ", "\\s+")}\\b`, "i").test(text);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}