@hasna/recordings 0.1.29 → 0.1.30

package/dist/cli/index.js

@@ -5098,7 +5098,7 @@ var init_pg_migrate = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.29",
+    version: "0.1.30",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -6081,7 +6081,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.29";
+var VERSION = "0.1.30";
 
 // src/cli/storage.ts
 import chalk from "chalk";

package/dist/mcp/index.js

@@ -4920,7 +4920,7 @@ var require_lib2 = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.29",
+    version: "0.1.30",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -9797,7 +9797,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.29";
+var VERSION = "0.1.30";
 
 // src/db/storage-config.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.29";
+export declare const VERSION = "0.1.30";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "type": "module",
   "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
   "repository": {

package/src/native/Recordings/RecordingsLib/RecordingEngine.swift

@@ -558,20 +558,21 @@ public final class RecordingEngine: ObservableObject {
             self.streamingTask = nil
 
             let realtimeText = Self.normalizedRealtimeTranscript(streamingResult)
-
-            self.liveTranscriptionText = ""
-
-            if Self.shouldUseRealtimeFastPath(
+            let fastPathText = Self.realtimeFastPathTranscript(
                 realtimeText: streamingResult,
                 pcmByteCount: self.recordedPCM.count,
                 language: transcriptionLanguage
-            ),
-               let realtimeText {
+            )
+
+            self.liveTranscriptionText = ""
+
+            if let fastPathText {
                 let releaseToTextMS = Int(Date().timeIntervalSince(stopStartedAt) * 1_000)
-                self.log("using realtime fast path chars=\(realtimeText.count) releaseToTextMs=\(releaseToTextMS)")
+                let repaired = Self.wasRealtimeTranscriptRepaired(rawText: streamingResult, cleanedText: fastPathText)
+                self.log("using realtime fast path chars=\(fastPathText.count) repaired=\(repaired) releaseToTextMs=\(releaseToTextMS)")
                 self.isTranscribing = false
                 self.finishWithText(
-                    realtimeText,
+                    fastPathText,
                     curMode: curMode,
                     targetAppBundleIdentifier: targetAppBundleIdentifier,
                     targetAppPid: targetAppPid,
@@ -639,11 +640,23 @@ public final class RecordingEngine: ObservableObject {
         pcmByteCount: Int,
         language: String = "en"
     ) -> Bool {
-        guard let text = normalizedRealtimeTranscript(realtimeText) else { return false }
+        realtimeFastPathTranscript(
+            realtimeText: realtimeText,
+            pcmByteCount: pcmByteCount,
+            language: language
+        ) != nil
+    }
+
+    public nonisolated static func realtimeFastPathTranscript(
+        realtimeText: String?,
+        pcmByteCount: Int,
+        language: String = "en"
+    ) -> String? {
+        guard let text = normalizedRealtimeTranscript(realtimeText) else { return nil }
         guard isSafeRealtimeFastPathText(rawText: realtimeText ?? "", cleanedText: text, language: language) else {
-            return false
+            return nil
         }
-        return !shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount)
+        return shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount) ? nil : text
     }
 
     public nonisolated static func isSafeRealtimeFastPathText(rawText: String, cleanedText: String, language: String) -> Bool {
@@ -652,19 +665,31 @@ public final class RecordingEngine: ObservableObject {
         guard languageHint == "en" else { return true }
 
         let rawTrimmed = rawText.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !containsCJKArtifact(in: rawTrimmed) else { return false }
+        let rawNormalized = normalizedTranscriptText(rawTrimmed)
+        let cleanedNormalized = normalizedTranscriptText(cleanedText)
+        guard !cleanedNormalized.isEmpty else { return false }
+        guard rawNormalized != cleanedNormalized else { return true }
+        guard cjkLetterCount(in: cleanedNormalized) == 0 else { return false }
 
-        let rawNormalized = rawTrimmed.replacingOccurrences(
-            of: #"\s+"#,
-            with: " ",
-            options: .regularExpression
-        )
-        let cleanedNormalized = cleanedText.replacingOccurrences(
-            of: #"\s+"#,
-            with: " ",
-            options: .regularExpression
-        )
-        return rawNormalized == cleanedNormalized
+        let cleanedWords = canonicalTranscriptWords(cleanedNormalized, droppingArtifacts: false)
+        guard !cleanedWords.isEmpty else { return false }
+
+        let rawWords = canonicalTranscriptWords(rawNormalized, droppingArtifacts: true)
+        guard isSubsequence(cleanedWords, of: rawWords) else { return false }
+
+        let rawCJKCount = cjkLetterCount(in: rawNormalized)
+        if rawCJKCount > 0 {
+            let cleanedLatinCount = latinLetterCount(in: cleanedNormalized)
+            guard cleanedLatinCount >= max(2, rawCJKCount * 2) else { return false }
+            guard rawCJKCount <= max(6, cleanedLatinCount / 3) else { return false }
+        }
+
+        let removedWordCount = max(0, rawWords.count - cleanedWords.count)
+        return removedWordCount <= max(8, cleanedWords.count + 3)
+    }
+
+    public nonisolated static func wasRealtimeTranscriptRepaired(rawText: String, cleanedText: String) -> Bool {
+        normalizedTranscriptText(rawText) != normalizedTranscriptText(cleanedText)
     }
 
     public nonisolated static func cleanRealtimeArtifactText(_ text: String) -> String {
@@ -709,6 +734,55 @@ public final class RecordingEngine: ObservableObject {
         return words.joined(separator: " ")
     }
 
+    private nonisolated static func normalizedTranscriptText(_ text: String) -> String {
+        text
+            .replacingOccurrences(of: "\n", with: " ")
+            .replacingOccurrences(of: "\t", with: " ")
+            .replacingOccurrences(
+                of: #"\s+"#,
+                with: " ",
+                options: .regularExpression
+            )
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private nonisolated static func canonicalTranscriptWords(_ text: String, droppingArtifacts: Bool) -> [String] {
+        text.split(whereSeparator: { $0.isWhitespace || $0.isNewline }).compactMap { rawWord in
+            var normalized = String(rawWord)
+                .trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
+                .lowercased()
+            if droppingArtifacts {
+                normalized = normalized.unicodeScalars.reduce(into: "") { output, scalar in
+                    if !isCJKScalar(scalar) {
+                        output.unicodeScalars.append(scalar)
+                    }
+                }
+            }
+            guard !normalized.isEmpty else { return nil }
+            if droppingArtifacts, isStandaloneRealtimeArtifact(normalized) {
+                return nil
+            }
+            return normalized
+        }
+    }
+
+    private nonisolated static func isSubsequence(_ needle: [String], of haystack: [String]) -> Bool {
+        guard !needle.isEmpty else { return true }
+        var index = 0
+        for word in haystack where word == needle[index] {
+            index += 1
+            if index == needle.count {
+                return true
+            }
+        }
+        return false
+    }
+
+    private nonisolated static func isStandaloneRealtimeArtifact(_ word: String) -> Bool {
+        let artifactTokens: Set<String> = ["어", "음", "um", "umm", "uh", "uhh", "erm", "hmm", "eh"]
+        return artifactTokens.contains(word) || isMostlyCJKArtifact(word)
+    }
+
     private nonisolated static func collapseAdjacentDuplicateWords(in text: String) -> String {
         let words = text.split(separator: " ").map(String.init)
         guard words.count > 1 else { return text }

package/src/native/Recordings/RecordingsTests/RealtimeTranscriptionTests.swift

@@ -126,22 +126,32 @@ struct RealtimeTranscriptionTests {
         #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "Hi", pcmByteCount: 12_000) == false)
     }
 
-    @Test("Realtime fast path accepts useful text and rejects empty or suspicious partial output")
+    @Test("Realtime fast path accepts useful and safely repaired text")
     func realtimeFastPathDecision() {
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "  this is a useful transcript  ", pcmByteCount: 96_000))
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 12_000))
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 96_000) == false)
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "   ", pcmByteCount: 96_000) == false)
-        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+        #expect(RecordingEngine.realtimeFastPathTranscript(
             realtimeText: "Actually 리수 Zoom your goal",
             pcmByteCount: 96_000,
             language: "en"
-        ) == false)
-        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+        ) == "Actually Zoom your goal")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
+            realtimeText: "어 Okay I don't know if this This is working어 Okay I don't know if this This is working",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == "Okay I don't know if this is working")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
             realtimeText: "Actually Zoom your goal",
             pcmByteCount: 96_000,
             language: "en"
-        ))
+        ) == "Actually Zoom your goal")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
+            realtimeText: "리수 度扫 開けたの 어",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == nil)
     }
 
     @Test("Realtime artifact cleanup removes duplicated chunks and filler tokens")

package/src/native/Recordings/RecordingsTests/TranscriptResolutionTests.swift

@@ -64,17 +64,26 @@ struct TranscriptResolutionTests {
         #expect(RecordingEngine.normalizedRealtimeTranscript(nil) == nil)
     }
 
-    @Test("Unsafe English realtime text is not eligible for fast-path paste")
-    func unsafeRealtimeTextRejectedForFastPath() {
+    @Test("English realtime text can be safely repaired before fast-path paste")
+    func realtimeTextRepairedForFastPath() {
         #expect(RecordingEngine.isSafeRealtimeFastPathText(
             rawText: "Actually 리수 Zoom your goal",
             cleanedText: "Actually Zoom your goal",
             language: "en"
-        ) == false)
+        ))
         #expect(RecordingEngine.isSafeRealtimeFastPathText(
             rawText: "Actually Zoom your goal",
             cleanedText: "Actually Zoom your goal",
             language: "en"
         ))
+        #expect(RecordingEngine.isSafeRealtimeFastPathText(
+            rawText: "Actually Zoom your goal",
+            cleanedText: "Actually invented Zoom your goal",
+            language: "en"
+        ) == false)
+        #expect(RecordingEngine.wasRealtimeTranscriptRepaired(
+            rawText: "working어",
+            cleanedText: "working"
+        ))
     }
 }