@juspay/neurolink 13.7.0 → 13.8.1

package/dist/voice/codeMix.js

@@ -0,0 +1,282 @@
+/**
+ * Code-mix analysis between two engines' readings of the same speech.
+ *
+ * An Indic engine writes English words phonetically in its own script
+ * ("मीटिंग" for "meeting"); an English-oriented engine writes Indian-language
+ * words as English-sounding guesses ("page dinner" for "भेज देना"). Brought
+ * to one rough phonetic form — Indic text romanized, both reduced to a
+ * consonant skeleton with voicing and aspiration folded — the two sequences
+ * line up word for word wherever the speaker spoke English, and stop lining
+ * up where they spoke an Indian language. The share of the Indic engine's
+ * words that find a phonetic partner is therefore an estimate of how much of
+ * the utterance was English, independent of either engine's own (accent-
+ * sensitive) language score; the alignment itself is what a word-level
+ * combination of the two readings is built on.
+ *
+ * @module voice/codeMix
+ */
+/** Devanagari (and, by block offset, every other Indic script) to rough Latin. */
+const CONSONANTS = {
+    0x15: "k",
+    0x16: "kh",
+    0x17: "g",
+    0x18: "gh",
+    0x19: "n",
+    0x1a: "ch",
+    0x1b: "chh",
+    0x1c: "j",
+    0x1d: "jh",
+    0x1e: "n",
+    0x1f: "t",
+    0x20: "th",
+    0x21: "d",
+    0x22: "dh",
+    0x23: "n",
+    0x24: "t",
+    0x25: "th",
+    0x26: "d",
+    0x27: "dh",
+    0x28: "n",
+    0x29: "n",
+    0x2a: "p",
+    0x2b: "ph",
+    0x2c: "b",
+    0x2d: "bh",
+    0x2e: "m",
+    0x2f: "y",
+    0x30: "r",
+    0x31: "r",
+    0x32: "l",
+    0x33: "l",
+    0x34: "l",
+    0x35: "v",
+    0x36: "sh",
+    0x37: "sh",
+    0x38: "s",
+    0x39: "h",
+    0x58: "q",
+    0x59: "kh",
+    0x5a: "g",
+    0x5b: "z",
+    0x5c: "r",
+    0x5d: "rh",
+    0x5e: "f",
+    0x5f: "y",
+};
+/** The same consonant with a nukta under it. */
+const NUKTA = {
+    0x15: "q",
+    0x16: "kh",
+    0x17: "g",
+    0x1c: "z",
+    0x21: "r",
+    0x22: "rh",
+    0x2b: "f",
+    0x2f: "y",
+};
+const VOWELS = {
+    0x05: "a",
+    0x06: "aa",
+    0x07: "i",
+    0x08: "ii",
+    0x09: "u",
+    0x0a: "uu",
+    0x0b: "ri",
+    0x0d: "e",
+    0x0e: "e",
+    0x0f: "e",
+    0x10: "ai",
+    0x11: "o",
+    0x12: "o",
+    0x13: "o",
+    0x14: "au",
+};
+const MATRAS = {
+    0x3e: "aa",
+    0x3f: "i",
+    0x40: "ii",
+    0x41: "u",
+    0x42: "uu",
+    0x43: "ri",
+    0x45: "e",
+    0x46: "e",
+    0x47: "e",
+    0x48: "ai",
+    0x49: "o",
+    0x4a: "o",
+    0x4b: "o",
+    0x4c: "au",
+};
+const VIRAMA = 0x4d;
+const NUKTA_SIGN = 0x3c;
+/** Offset of `cp` inside its 128-code-point Indic block, or -1 outside Devanagari…Malayalam. */
+function indicOffset(cp) {
+    return cp >= 0x0900 && cp <= 0x0d7f ? (cp - 0x0900) % 0x80 : -1;
+}
+/** Indic-script text in rough Latin letters; anything else passes through. */
+export function romanizeIndic(text) {
+    const cps = [...text].map((ch) => ch.codePointAt(0) ?? 0);
+    let out = "";
+    for (let i = 0; i < cps.length; i++) {
+        const off = indicOffset(cps[i]);
+        if (off < 0) {
+            out += String.fromCodePoint(cps[i]);
+            continue;
+        }
+        const nukta = indicOffset(cps[i + 1] ?? 0) === NUKTA_SIGN;
+        const consonant = (nukta ? NUKTA[off] : undefined) ?? CONSONANTS[off];
+        if (consonant) {
+            out += consonant;
+            const nextOff = indicOffset(cps[i + (nukta ? 2 : 1)] ?? 0);
+            if (nukta) {
+                i++;
+            }
+            // The inherent vowel, unless a matra or virama follows.
+            if (nextOff < 0 ||
+                (MATRAS[nextOff] === undefined && nextOff !== VIRAMA)) {
+                out += "a";
+            }
+            continue;
+        }
+        if (VOWELS[off]) {
+            out += VOWELS[off];
+        }
+        else if (MATRAS[off]) {
+            out += MATRAS[off];
+        }
+        else if (off === 0x02 || off === 0x01) {
+            out += "n";
+        }
+        else if (off === 0x03) {
+            out += "h";
+        }
+        else if (off === 0x64 || off === 0x65) {
+            out += ".";
+        }
+        else if (off >= 0x66 && off <= 0x6f) {
+            out += String(off - 0x66);
+        }
+    }
+    return out;
+}
+/**
+ * A word's consonant skeleton: digraphs folded, voicing pairs merged
+ * (t/d, k/g, p/b are where an accent and a script disagree most), vowels and
+ * h dropped, repeats collapsed. "meeting" and "मीटिंग" both give "mtnk".
+ */
+export function phoneticKey(word) {
+    let w = romanizeIndic(word)
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z]/gu, "");
+    w = w
+        .replace(/chh|ch/gu, "c")
+        .replace(/ck/gu, "k")
+        .replace(/qu/gu, "kv")
+        .replace(/ph/gu, "f")
+        .replace(/sh/gu, "s")
+        .replace(/x/gu, "ks")
+        .replace(/([kgbtdj])h/gu, "$1")
+        .replace(/[dt]/gu, "t")
+        .replace(/[gkcq]/gu, "k")
+        .replace(/[bp]/gu, "p")
+        .replace(/[zj]/gu, "j")
+        .replace(/w/gu, "v")
+        .replace(/[aeiouyh]/gu, "");
+    return w.replace(/(.)\1+/gu, "$1") || "_";
+}
+function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = tmp;
+        }
+    }
+    return row[b.length];
+}
+/** Whether two skeletons sound alike: equal, or one edit apart on three or more consonants (two on six). */
+export function soundsAlike(a, b) {
+    if (a === b) {
+        return a !== "_";
+    }
+    const n = Math.max(a.length, b.length);
+    if (n < 3) {
+        return false;
+    }
+    return editDistance(a, b) <= (n >= 6 ? 2 : 1);
+}
+function wordsOf(text) {
+    return text
+        .split(/\s+/u)
+        .map((w) => w.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""))
+        .filter(Boolean);
+}
+/**
+ * Align two readings word by word (Needleman–Wunsch on skeletons): a pair
+ * for every word of either side, matched where the words sound alike.
+ */
+export function alignReadings(indic, latin) {
+    const ka = indic.map(phoneticKey);
+    const kb = latin.map(phoneticKey);
+    const n = ka.length;
+    const m = kb.length;
+    const MATCH = 2;
+    const MISMATCH = -1;
+    const GAP = -1;
+    const score = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = 1; i <= n; i++) {
+        score[i][0] = i * GAP;
+    }
+    for (let j = 1; j <= m; j++) {
+        score[0][j] = j * GAP;
+    }
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            const s = soundsAlike(ka[i - 1], kb[j - 1]) ? MATCH : MISMATCH;
+            score[i][j] = Math.max(score[i - 1][j - 1] + s, score[i - 1][j] + GAP, score[i][j - 1] + GAP);
+        }
+    }
+    const pairs = [];
+    let i = n;
+    let j = m;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0) {
+            const alike = soundsAlike(ka[i - 1], kb[j - 1]);
+            if (score[i][j] === score[i - 1][j - 1] + (alike ? MATCH : MISMATCH)) {
+                pairs.push({ indic: indic[i - 1], latin: latin[j - 1], alike });
+                i--;
+                j--;
+                continue;
+            }
+        }
+        if (i > 0 && score[i][j] === score[i - 1][j] + GAP) {
+            pairs.push({ indic: indic[i - 1], alike: false });
+            i--;
+        }
+        else {
+            pairs.push({ latin: latin[j - 1], alike: false });
+            j--;
+        }
+    }
+    return pairs.reverse();
+}
+/**
+ * How much of an utterance two readings agree is English: the share of the
+ * Indic engine's words with a phonetic partner in the English-oriented
+ * engine's text. Near 1 for English an Indic engine wrote phonetically; well
+ * under it for code-mixed speech, where the Indian-language words find none.
+ */
+export function analyzeCodeMix(indicText, latinText) {
+    const a = wordsOf(indicText);
+    const b = wordsOf(latinText);
+    if (a.length === 0 || b.length === 0) {
+        return { englishShare: a.length === 0 ? 1 : 0, words: a.length, pairs: [] };
+    }
+    const pairs = alignReadings(a, b);
+    const matched = pairs.filter((p) => p.alike && p.indic !== undefined).length;
+    return { englishShare: matched / a.length, words: a.length, pairs };
+}

package/dist/voice/correction/align.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Word timings for corrected text. The engine timed the words it wrote; a
+ * rewrite changes them (spelling, script, punctuation), so the timings are
+ * carried over: one for one when the word count is unchanged, else spread
+ * over the same span in proportion to each word's length. Speaker labels are
+ * kept only where every source word agrees.
+ *
+ * @module voice/correction/align
+ */
+import type { WordTiming } from "../../types/index.js";
+/** `words` re-timed onto the words of `text`; empty when there is nothing to align. */
+export declare function alignWordsToText(words: readonly WordTiming[] | undefined, text: string): WordTiming[];

package/dist/voice/correction/align.js

@@ -0,0 +1,48 @@
+/**
+ * Word timings for corrected text. The engine timed the words it wrote; a
+ * rewrite changes them (spelling, script, punctuation), so the timings are
+ * carried over: one for one when the word count is unchanged, else spread
+ * over the same span in proportion to each word's length. Speaker labels are
+ * kept only where every source word agrees.
+ *
+ * @module voice/correction/align
+ */
+function startOf(w) {
+    return w.startTime ?? w.start;
+}
+function endOf(w) {
+    return w.endTime ?? w.end;
+}
+/** `words` re-timed onto the words of `text`; empty when there is nothing to align. */
+export function alignWordsToText(words, text) {
+    const tokens = text.split(/\s+/u).filter(Boolean);
+    if (!words?.length || tokens.length === 0) {
+        return [];
+    }
+    if (tokens.length === words.length) {
+        return words.map((w, i) => ({ ...w, word: tokens[i] }));
+    }
+    const spanStart = startOf(words[0]);
+    const spanEnd = endOf(words[words.length - 1]) ?? startOf(words[words.length - 1]);
+    if (spanStart === undefined || spanEnd === undefined || spanEnd < spanStart) {
+        return [];
+    }
+    const speakers = new Set(words.map((w) => w.speaker));
+    const speaker = speakers.size === 1 ? words[0].speaker : undefined;
+    const total = tokens.reduce((n, t) => n + t.length, 0);
+    const span = spanEnd - spanStart;
+    let at = spanStart;
+    return tokens.map((token) => {
+        const start = at;
+        const end = start + (span * token.length) / total;
+        at = end;
+        const timed = {
+            word: token,
+            start,
+            startTime: start,
+            end,
+            endTime: end,
+        };
+        return speaker ? { ...timed, speaker } : timed;
+    });
+}

package/dist/voice/correction/guards.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Guards on raw engine output, applied before LocalAgreement, the dictionary
+ * and the rewrite ever see a text. They catch the two ways a speech engine
+ * produces words that were never said:
+ *
+ * - a decoding loop ("Same one. Same one. Same one. …" for hundreds of
+ *   words), which Qwen3-ASR falls into on long or noisy chunks, and which the
+ *   correction layer cannot repair on purpose (removing the repeats would
+ *   trip the never-lose-words drop guard);
+ * - a prompt echo, where an engine answers a near-silent chunk with the
+ *   vocabulary prompt it was given ("Names and terms used: …").
+ *
+ * Both are deterministic and cheap, so they run on every pass.
+ *
+ * @module voice/correction/guards
+ */
+/**
+ * Collapse runaway repetition: any phrase of 1 to {@link MAX_NGRAM} words that
+ * repeats itself {@link LOOP_MIN_REPEATS} or more times in a row is cut down to
+ * {@link KEEP_REPEATS} occurrences. Returns the text and how many words were
+ * removed; `removed` is 0 when the text was left alone. Spacing between the
+ * surviving words is normalised to single spaces.
+ */
+export declare function collapseRepetitions(text: string): {
+    text: string;
+    removed: number;
+};
+/**
+ * True when an engine's output is the prompt it was given, or a subset of
+ * it: every word of the output occurs in `promptTerms` (the vocabulary
+ * terms and the fixed phrasing around them), AND it reads like the prompt
+ * rather than speech — it carries the fixed phrasing, or lists two or more
+ * distinct terms. A speaker who says only "Juspay." said a term; that is
+ * speech and is kept. An output with no words is not an echo; the empty
+ * path handles it.
+ */
+export declare function isPromptEcho(text: string, promptTerms: readonly string[]): boolean;
+/** Share of a text's words that came from a collapsed loop, for a "mostly loop" decision. */
+export declare function loopShare(removed: number, originalWordCount: number): number;

package/dist/voice/correction/guards.js

@@ -0,0 +1,122 @@
+/**
+ * Guards on raw engine output, applied before LocalAgreement, the dictionary
+ * and the rewrite ever see a text. They catch the two ways a speech engine
+ * produces words that were never said:
+ *
+ * - a decoding loop ("Same one. Same one. Same one. …" for hundreds of
+ *   words), which Qwen3-ASR falls into on long or noisy chunks, and which the
+ *   correction layer cannot repair on purpose (removing the repeats would
+ *   trip the never-lose-words drop guard);
+ * - a prompt echo, where an engine answers a near-silent chunk with the
+ *   vocabulary prompt it was given ("Names and terms used: …").
+ *
+ * Both are deterministic and cheap, so they run on every pass.
+ *
+ * @module voice/correction/guards
+ */
+/** Longest phrase (in words) a loop is looked for; longer repeats are real speech. */
+const MAX_NGRAM = 6;
+/** Repeats of one phrase in a row that count as a loop; "no, no, no" stays. */
+const LOOP_MIN_REPEATS = 4;
+/** Occurrences kept when a loop is collapsed. */
+const KEEP_REPEATS = 2;
+/** A word stripped of punctuation and case, for comparing repeats. */
+function key(word) {
+    return word
+        .toLowerCase()
+        .replace(/^[\s"'“”‘’([{¿¡]+|[\s"'“”‘’)\]}.,!?;:…।॥]+$/gu, "");
+}
+/**
+ * Collapse runaway repetition: any phrase of 1 to {@link MAX_NGRAM} words that
+ * repeats itself {@link LOOP_MIN_REPEATS} or more times in a row is cut down to
+ * {@link KEEP_REPEATS} occurrences. Returns the text and how many words were
+ * removed; `removed` is 0 when the text was left alone. Spacing between the
+ * surviving words is normalised to single spaces.
+ */
+export function collapseRepetitions(text) {
+    const words = text.split(/\s+/u).filter(Boolean);
+    if (words.length < LOOP_MIN_REPEATS) {
+        return { text, removed: 0 };
+    }
+    const keys = words.map(key);
+    const out = [];
+    let removed = 0;
+    let i = 0;
+    while (i < words.length) {
+        let collapsed = false;
+        for (let n = 1; n <= MAX_NGRAM && i + n * LOOP_MIN_REPEATS <= words.length; n++) {
+            // How many times does the n-gram starting at i repeat back to back?
+            let repeats = 1;
+            while (i + (repeats + 1) * n <= words.length &&
+                sameNgram(keys, i, i + repeats * n, n)) {
+                repeats++;
+            }
+            if (repeats >= LOOP_MIN_REPEATS) {
+                for (let k = 0; k < KEEP_REPEATS * n; k++) {
+                    out.push(words[i + k]);
+                }
+                removed += (repeats - KEEP_REPEATS) * n;
+                i += repeats * n;
+                collapsed = true;
+                break;
+            }
+        }
+        if (!collapsed) {
+            out.push(words[i]);
+            i++;
+        }
+    }
+    return removed > 0 ? { text: out.join(" "), removed } : { text, removed: 0 };
+}
+function sameNgram(keys, a, b, n) {
+    for (let k = 0; k < n; k++) {
+        if (keys[a + k] !== keys[b + k] || keys[a + k] === "") {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * True when an engine's output is the prompt it was given, or a subset of
+ * it: every word of the output occurs in `promptTerms` (the vocabulary
+ * terms and the fixed phrasing around them), AND it reads like the prompt
+ * rather than speech — it carries the fixed phrasing, or lists two or more
+ * distinct terms. A speaker who says only "Juspay." said a term; that is
+ * speech and is kept. An output with no words is not an echo; the empty
+ * path handles it.
+ */
+export function isPromptEcho(text, promptTerms) {
+    const words = text.split(/\s+/u).map(key).filter(Boolean);
+    if (words.length === 0 || promptTerms.length === 0) {
+        return false;
+    }
+    const allowed = new Set();
+    for (const term of promptTerms) {
+        for (const w of term.split(/\s+/u).map(key)) {
+            if (w) {
+                allowed.add(w);
+            }
+        }
+    }
+    if (!words.every((w) => allowed.has(w))) {
+        return false;
+    }
+    const joined = ` ${words.join(" ")} `;
+    if (joined.includes(` ${PROMPT_PHRASE} `)) {
+        return true;
+    }
+    const termsSeen = new Set();
+    for (const term of promptTerms) {
+        const phrase = term.split(/\s+/u).map(key).filter(Boolean).join(" ");
+        if (phrase && phrase !== PROMPT_PHRASE && joined.includes(` ${phrase} `)) {
+            termsSeen.add(phrase);
+        }
+    }
+    return termsSeen.size >= 2;
+}
+/** The fixed phrasing a vocabulary prompt carries, as keyed words. */
+const PROMPT_PHRASE = "names and terms used";
+/** Share of a text's words that came from a collapsed loop, for a "mostly loop" decision. */
+export function loopShare(removed, originalWordCount) {
+    return originalWordCount > 0 ? removed / originalWordCount : 0;
+}

package/dist/voice/correction/index.d.ts

@@ -12,9 +12,9 @@
  */
 import { applyDictionary, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates } from "./dictionary.js";
 import { decideCandidates } from "./guard.js";
-import { buildRewriteSystemPrompt, buildRewriteUserPrompt, rewriteLines, rewriteTranscript } from "./rewrite.js";
+import { buildRewriteSystemPrompt, buildRewriteUserPrompt, rewriteLines, rewriteTranscript, rewriteWanted } from "./rewrite.js";
 import type { STTCorrectionDeps, STTCorrectionInput, STTCorrectionOptions, STTCorrectionOutput, STTDecisionRecord, STTDictionaryEntry } from "../../types/index.js";
-export { applyDictionary, buildRewriteSystemPrompt, buildRewriteUserPrompt, decideCandidates, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates, rewriteLines, rewriteTranscript, };
+export { applyDictionary, buildRewriteSystemPrompt, buildRewriteUserPrompt, decideCandidates, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates, rewriteLines, rewriteTranscript, rewriteWanted, };
 /** Correction is on when asked for, or by default when a dictionary or a rewrite is configured. */
 export declare function isCorrectionEnabled(dictionary: readonly STTDictionaryEntry[] | undefined, options: STTCorrectionOptions | undefined): boolean;
 /**
@@ -30,6 +30,28 @@ export declare function isCorrectionEnabled(dictionary: readonly STTDictionaryEn
  * Indian-language words it did catch are not lost.
  */
 export declare function correctTranscript(input: STTCorrectionInput, deps: STTCorrectionDeps): Promise<STTCorrectionOutput>;
+/**
+ * Split a transcript into sentences on terminal punctuation (., !, ?, the
+ * danda, an ellipsis), keeping the marks. Text without any mark is one
+ * sentence; a split that would leave a fragment under three words glues it
+ * to its neighbour so a stray "No." never travels alone.
+ */
+export declare function splitSentences(text: string): string[];
+/**
+ * Correct one final sentence by sentence: each sentence gets its own
+ * dictionary pass, its own "does this need the rewrite" decision (an
+ * English sentence that is already clean costs nothing; a Devanagari one
+ * is romanised) and sentences run three at a time. The joined text has the
+ * same sentences in the same order; a sentence whose correction fails keeps
+ * its words. `onPartial` receives the whole utterance with the sentences
+ * corrected so far, so a caption can update progressively.
+ *
+ * Falls back to a single whole-text pass when there is one sentence or a
+ * second opinion (whole-utterance by nature) to reconcile.
+ */
+export declare function correctTranscriptSentences(input: STTCorrectionInput, deps: STTCorrectionDeps): Promise<STTCorrectionOutput & {
+    sentences: number;
+}>;
 /**
  * Correct a long transcript line by line (file transcription, diarized
  * turns). With the rewrite on, lines go to the model in numbered batches of
@@ -39,7 +61,7 @@ export declare function correctTranscript(input: STTCorrectionInput, deps: STTCo
  * four at a time) and the dictionary is applied per line. The result always
  * has exactly as many lines as the input.
  */
-export declare function correctTranscriptLines(lines: readonly string[], dictionary: readonly STTDictionaryEntry[] | undefined, options: STTCorrectionOptions | undefined, deps: STTCorrectionDeps): Promise<{
+export declare function correctTranscriptLines(lines: readonly string[], dictionary: readonly STTDictionaryEntry[] | undefined, options: STTCorrectionOptions | undefined, deps: STTCorrectionDeps, language?: string): Promise<{
     lines: string[];
     decisions: STTDecisionRecord[];
     steps: string[];