@bigbinary/neeto-media-recorder 2.7.51 → 2.7.53

package/core.js

@@ -1,43 +1,13 @@
+import { isEmpty, isNotNil, min, isNil, identity, pick, not } from 'ramda';
 import axios from 'axios';
 import { existsBy, isNotEmpty, isNot, noop } from '@bigbinary/neeto-cist';
 import { UPLOAD_STATUS, UPLOAD_EVENT, SCREEN_RECORDER_STATUS as SCREEN_RECORDER_STATUS$1, COUNTDOWN_TIME } from '@bigbinary/neeto-media-recorder/constants';
 import { useMultipartS3UploadStatus as useMultipartS3UploadStatus$1, getMultipartS3Uploader as getMultipartS3Uploader$1 } from '@bigbinary/neeto-media-recorder/core';
-import { isNotNil, min, isNil, identity, isEmpty, pick, not } from 'ramda';
 import platform from 'platform';
 import withImmutableActions from '@bigbinary/neeto-commons-frontend/react-utils/withImmutableActions';
 import { create as create$3 } from 'zustand';
 import { useSyncExternalStore } from 'react';
 
-function _arrayLikeToArray(r, a) {
-  (null == a || a > r.length) && (a = r.length);
-  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-  return n;
-}
-
-function _arrayWithoutHoles(r) {
-  if (Array.isArray(r)) return _arrayLikeToArray(r);
-}
-
-function _iterableToArray(r) {
-  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
-}
-
-function _unsupportedIterableToArray(r, a) {
-  if (r) {
-    if ("string" == typeof r) return _arrayLikeToArray(r, a);
-    var t = {}.toString.call(r).slice(8, -1);
-    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
-  }
-}
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _toConsumableArray(r) {
-  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
-}
-
 function asyncGeneratorStep(n, t, e, r, o, a, c) {
   try {
     var i = n[a](c),
@@ -494,6 +464,386 @@ try {
 
 var _regeneratorRuntime = /*@__PURE__*/getDefaultExportFromCjs(regenerator);
 
+// Where a recording's opening audio is PUT. Uploading it is the whole handoff —
+// the bucket triggers a lambda which titles the recording and reports it to the
+// server, so there is no second call to make.
+//
+// A nil upload_url means the recording already has a title, which is the
+// caller's signal to stop.
+var show = function show(_ref) {
+  var recordingId = _ref.recordingId;
+  return axios.get("/api/v1/recordings/".concat(encodeURIComponent(recordingId), "/fast_title_upload_url"));
+};
+var fastTitleApi = {
+  show: show
+};
+
+var createPrefixedLogger = function createPrefixedLogger(prefix) {
+  return {
+    info: function info() {
+      var _logger;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_logger = logger).info.apply(_logger, [prefix].concat(args));
+    },
+    error: function error() {
+      var _logger2;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return (_logger2 = logger).error.apply(_logger2, [prefix].concat(args));
+    },
+    warn: function warn() {
+      var _logger3;
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return (_logger3 = logger).warn.apply(_logger3, [prefix].concat(args));
+    },
+    debug: function debug() {
+      var _logger4;
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      return (_logger4 = logger).debug.apply(_logger4, [prefix].concat(args));
+    }
+  };
+};
+
+// How much of the opening to transcribe. Long enough that a recording has
+// usually said something, short enough that the title is saved well before the
+// user stops — which is the whole point, since a link pasted right after
+// recording is what the unfurl cache captures.
+//
+// There is only ever one window. The title is built from whatever these seconds
+// contain rather than waiting for a clearly stated topic, so a second attempt
+// would rarely say anything new.
+var FAST_TITLE_WINDOW_MS = 20000;
+
+// Ordered by preference. Opus at a low bitrate is all the transcription API
+// consumes, and keeps the window small enough that the upload never dominates.
+//
+// Independent of the video format: this records audio only, so a recording made
+// in MP4 still captures its opening as Opus. The MP4 entries are the fallback
+// for a browser whose MediaRecorder cannot do audio/webm at all — Safari.
+var FAST_TITLE_MIME_TYPES = ["audio/webm;codecs=opus", "audio/ogg;codecs=opus", "audio/webm", "audio/mp4;codecs=mp4a.40.2", "audio/mp4"];
+var FAST_TITLE_AUDIO_BITS_PER_SECOND = 24000;
+
+function _classPrivateFieldInitSpec$2(e, t, a) { _checkPrivateRedeclaration$2(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration$2(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+var supportedMimeType = function supportedMimeType() {
+  return FAST_TITLE_MIME_TYPES.find(function (type) {
+    return MediaRecorder.isTypeSupported(type);
+  });
+};
+
+/**
+ * Titles a recording while it is still being made.
+ *
+ * Link unfurlers (Slack, X, Teams) fetch a page's metadata the first time
+ * somebody pastes the URL and cache it per URL, with no purge API worth relying
+ * on — so whatever title exists at that moment is the one that sticks. Titling
+ * after the upload finishes can lose that race. Titling during the recording
+ * does not: for anything longer than about half a minute the title is saved
+ * before the user presses stop.
+ *
+ * Runs a second, audio-only MediaRecorder over cloned audio tracks. When its
+ * first window closes it PUTs that audio to S3 and stops. The upload is the
+ * whole handoff: the bucket triggers a lambda which titles the recording and
+ * reports it to the server, so there is no result to wait for here.
+ *
+ * It shares no object with the real recorder, and every failure path is a no-op
+ * — the transcode lambda still titles the recording from its full transcript
+ * afterwards.
+ */
+var _logger$2 = /*#__PURE__*/new WeakMap();
+var _recorder = /*#__PURE__*/new WeakMap();
+var _tracks = /*#__PURE__*/new WeakMap();
+var _recordingId$1 = /*#__PURE__*/new WeakMap();
+var _mimeType$2 = /*#__PURE__*/new WeakMap();
+var _finished = /*#__PURE__*/new WeakMap();
+var _reset = /*#__PURE__*/new WeakMap();
+var _onWindowClosed = /*#__PURE__*/new WeakMap();
+var _upload = /*#__PURE__*/new WeakMap();
+var FastTitleRunner = /*#__PURE__*/function () {
+  function FastTitleRunner() {
+    var _this = this;
+    _classCallCheck(this, FastTitleRunner);
+    _classPrivateFieldInitSpec$2(this, _logger$2, {
+      writable: true,
+      value: createPrefixedLogger("[FastTitle]")
+    });
+    _classPrivateFieldInitSpec$2(this, _recorder, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$2(this, _tracks, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec$2(this, _recordingId$1, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$2(this, _mimeType$2, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$2(this, _finished, {
+      writable: true,
+      value: false
+    });
+    _defineProperty(this, "setRecordingId", function (recordingId) {
+      _classPrivateFieldSet(_this, _recordingId$1, recordingId);
+    });
+    _defineProperty(this, "start", function (mediaStream) {
+      var _mediaStream$getAudio, _mediaStream$getAudio2;
+      if (_this.isRunning) return;
+      var audioTracks = (_mediaStream$getAudio = mediaStream === null || mediaStream === void 0 ? void 0 : (_mediaStream$getAudio2 = mediaStream.getAudioTracks) === null || _mediaStream$getAudio2 === void 0 ? void 0 : _mediaStream$getAudio2.call(mediaStream)) !== null && _mediaStream$getAudio !== void 0 ? _mediaStream$getAudio : [];
+      if (isEmpty(audioTracks)) {
+        _classPrivateFieldGet(_this, _logger$2).info("start -> no audio track, skipping");
+        return;
+      }
+      _classPrivateFieldSet(_this, _mimeType$2, supportedMimeType());
+      if (!_classPrivateFieldGet(_this, _mimeType$2)) {
+        _classPrivateFieldGet(_this, _logger$2).info("start -> no supported audio mime type, skipping");
+        return;
+      }
+      _classPrivateFieldGet(_this, _reset).call(_this);
+      try {
+        // Cloned rather than shared: a clone is an independent track, so a second
+        // MediaRecorder reading it cannot affect the one producing the actual
+        // recording. Clones must be stopped explicitly or they outlive the take.
+        _classPrivateFieldSet(_this, _tracks, audioTracks.map(function (track) {
+          return track.clone();
+        }));
+        _classPrivateFieldSet(_this, _recorder, new MediaRecorder(new MediaStream(_classPrivateFieldGet(_this, _tracks)), {
+          mimeType: _classPrivateFieldGet(_this, _mimeType$2),
+          audioBitsPerSecond: FAST_TITLE_AUDIO_BITS_PER_SECOND
+        }));
+        _classPrivateFieldGet(_this, _recorder).ondataavailable = _classPrivateFieldGet(_this, _onWindowClosed);
+        _classPrivateFieldGet(_this, _recorder).onerror = function (event) {
+          var _event$error;
+          _classPrivateFieldGet(_this, _logger$2).error("recorder error", event === null || event === void 0 ? void 0 : (_event$error = event.error) === null || _event$error === void 0 ? void 0 : _event$error.name);
+          _this.stop();
+        };
+        _classPrivateFieldGet(_this, _recorder).start(FAST_TITLE_WINDOW_MS);
+        _classPrivateFieldGet(_this, _logger$2).info("start -> recording opening audio", {
+          mimeType: _classPrivateFieldGet(_this, _mimeType$2),
+          trackCount: _classPrivateFieldGet(_this, _tracks).length
+        });
+      } catch (error) {
+        _classPrivateFieldGet(_this, _logger$2).error("start -> failed", error === null || error === void 0 ? void 0 : error.message);
+        _this.stop();
+      }
+    });
+    _defineProperty(this, "pause", function () {
+      var _classPrivateFieldGet2;
+      if (((_classPrivateFieldGet2 = _classPrivateFieldGet(_this, _recorder)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.state) === "recording") _classPrivateFieldGet(_this, _recorder).pause();
+    });
+    _defineProperty(this, "resume", function () {
+      var _classPrivateFieldGet3;
+      if (((_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _recorder)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.state) === "paused") _classPrivateFieldGet(_this, _recorder).resume();
+    });
+    _defineProperty(this, "stop", function () {
+      _classPrivateFieldSet(_this, _finished, true);
+      try {
+        if (_classPrivateFieldGet(_this, _recorder) && _classPrivateFieldGet(_this, _recorder).state !== "inactive") {
+          // No final flush: audio sent now would arrive while the recording is
+          // already uploading, which is what the transcode lambda is for.
+          _classPrivateFieldGet(_this, _recorder).ondataavailable = null;
+          _classPrivateFieldGet(_this, _recorder).stop();
+        }
+      } catch (error) {
+        _classPrivateFieldGet(_this, _logger$2).error("stop -> error stopping recorder", error === null || error === void 0 ? void 0 : error.message);
+      }
+      _classPrivateFieldGet(_this, _tracks).forEach(function (track) {
+        return track.stop();
+      });
+      _classPrivateFieldGet(_this, _reset).call(_this);
+    });
+    _classPrivateFieldInitSpec$2(this, _reset, {
+      writable: true,
+      value: function value() {
+        _classPrivateFieldSet(_this, _recorder, null);
+        _classPrivateFieldSet(_this, _tracks, []);
+        _classPrivateFieldSet(_this, _finished, false);
+      }
+    });
+    _classPrivateFieldInitSpec$2(this, _onWindowClosed, {
+      writable: true,
+      value: function () {
+        var _value = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(event) {
+          var _event$data;
+          var _event$data$size, _event$data2, audio, recordingId;
+          return _regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!_classPrivateFieldGet(_this, _finished)) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return");
+              case 2:
+                if (!(!((_event$data = event.data) !== null && _event$data !== void 0 && _event$data.size) || !_classPrivateFieldGet(_this, _recordingId$1))) {
+                  _context.next = 6;
+                  break;
+                }
+                _classPrivateFieldGet(_this, _logger$2).info("nothing to send, stopping", {
+                  size: (_event$data$size = (_event$data2 = event.data) === null || _event$data2 === void 0 ? void 0 : _event$data2.size) !== null && _event$data$size !== void 0 ? _event$data$size : 0,
+                  hasRecordingId: Boolean(_classPrivateFieldGet(_this, _recordingId$1))
+                });
+                _this.stop();
+                return _context.abrupt("return");
+              case 6:
+                // Stopped up front: this runs once either way, and stopping first means a
+                // slow upload cannot overlap a second window.
+                audio = event.data;
+                recordingId = _classPrivateFieldGet(_this, _recordingId$1);
+                _this.stop();
+                _context.prev = 9;
+                _context.next = 12;
+                return _classPrivateFieldGet(_this, _upload).call(_this, recordingId, audio);
+              case 12:
+                _context.next = 17;
+                break;
+              case 14:
+                _context.prev = 14;
+                _context.t0 = _context["catch"](9);
+                // Not fatal: the transcode lambda still titles the recording from its
+                // full transcript afterwards.
+                _classPrivateFieldGet(_this, _logger$2).error("upload failed", _context.t0 === null || _context.t0 === void 0 ? void 0 : _context.t0.message);
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[9, 14]]);
+        }));
+        function value(_x) {
+          return _value.apply(this, arguments);
+        }
+        return value;
+      }()
+    });
+    _classPrivateFieldInitSpec$2(this, _upload, {
+      writable: true,
+      value: function () {
+        var _value2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(recordingId, audio) {
+          var startedAt, _yield$fastTitleApi$s, uploadUrl, response;
+          return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                startedAt = performance.now(); // Already the response body: the host app's axios interceptors unwrap it,
+                // the same way generatePreSignedUrl's caller destructures its result.
+                _context2.next = 3;
+                return fastTitleApi.show({
+                  recordingId: recordingId
+                });
+              case 3:
+                _yield$fastTitleApi$s = _context2.sent;
+                uploadUrl = _yield$fastTitleApi$s.uploadUrl;
+                if (uploadUrl) {
+                  _context2.next = 8;
+                  break;
+                }
+                _classPrivateFieldGet(_this, _logger$2).info("not wanted for this recording");
+                return _context2.abrupt("return");
+              case 8:
+                _context2.next = 10;
+                return fetch(uploadUrl, {
+                  method: "PUT",
+                  headers: {
+                    "Content-Type": _classPrivateFieldGet(_this, _mimeType$2)
+                  },
+                  body: audio
+                });
+              case 10:
+                response = _context2.sent;
+                if (response.ok) {
+                  _context2.next = 13;
+                  break;
+                }
+                throw new Error("audio upload ".concat(response.status));
+              case 13:
+                // The last thing this client will say about the recording. Uploading is the
+                // whole handoff — the bucket triggers a lambda which transcribes, titles and
+                // reports the title to the server — so nothing further appears here whether
+                // it succeeds or finds nothing to title.
+                _classPrivateFieldGet(_this, _logger$2).info("upload succeeded -> handed off for titling", {
+                  recordingId: recordingId,
+                  bytes: audio.size,
+                  mimeType: _classPrivateFieldGet(_this, _mimeType$2),
+                  ms: Math.round(performance.now() - startedAt),
+                  // Path only. The query string of a presigned URL carries its signature.
+                  key: new URL(uploadUrl).pathname.replace(/^\//, "")
+                });
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        function value(_x2, _x3) {
+          return _value2.apply(this, arguments);
+        }
+        return value;
+      }()
+    });
+  }
+  _createClass(FastTitleRunner, [{
+    key: "isRunning",
+    get: function get() {
+      return Boolean(_classPrivateFieldGet(this, _recorder)) && !_classPrivateFieldGet(this, _finished);
+    }
+
+    // Set once the recording exists. It is created asynchronously and usually
+    // lands well before the first window closes.
+    /**
+     * @param {MediaStream} mediaStream the stream being recorded; its audio tracks
+     *   are cloned so nothing here can disturb the real recorder
+     */
+    // Fires once, when the first window closes. Whatever it holds is the title's
+    // only source, so this uploads it and stops.
+  }]);
+  return FastTitleRunner;
+}();
+var runner = null;
+var getFastTitleRunner = function getFastTitleRunner() {
+  if (!runner) runner = new FastTitleRunner();
+  return runner;
+};
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+
 const byteToHex = [];
 for (let i = 0; i < 256; ++i) {
     byteToHex.push((i + 0x100).toString(16).slice(1));
@@ -952,39 +1302,6 @@ var s3Api = {
   presignedUpload: retryablePresignedUpload
 };
 
-var createPrefixedLogger = function createPrefixedLogger(prefix) {
-  return {
-    info: function info() {
-      var _logger;
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      return (_logger = logger).info.apply(_logger, [prefix].concat(args));
-    },
-    error: function error() {
-      var _logger2;
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
-      return (_logger2 = logger).error.apply(_logger2, [prefix].concat(args));
-    },
-    warn: function warn() {
-      var _logger3;
-      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-        args[_key3] = arguments[_key3];
-      }
-      return (_logger3 = logger).warn.apply(_logger3, [prefix].concat(args));
-    },
-    debug: function debug() {
-      var _logger4;
-      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-        args[_key4] = arguments[_key4];
-      }
-      return (_logger4 = logger).debug.apply(_logger4, [prefix].concat(args));
-    }
-  };
-};
-
 /**
  * Due to the custom axios interceptor for s3Api,
  * it'll return false for cancelled requests instead of a cancelled error object.
@@ -1804,6 +2121,7 @@ var _playCountdownAudio = /*#__PURE__*/new WeakMap();
 var _mimeType = /*#__PURE__*/new WeakMap();
 var _dataReceiving = /*#__PURE__*/new WeakMap();
 var _recordSystemAudio = /*#__PURE__*/new WeakMap();
+var _hasSpeechSourceForTitle = /*#__PURE__*/new WeakMap();
 var _stopAllStreams = /*#__PURE__*/new WeakMap();
 var _playCountdownBeep = /*#__PURE__*/new WeakMap();
 var _checkCompatibility = /*#__PURE__*/new WeakMap();
@@ -2174,6 +2492,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
           status: SCREEN_RECORDER_STATUS.paused
         });
         _classPrivateFieldGet(_this, _mediaRecorder).pause();
+        getFastTitleRunner().pause();
       } else {
         _classPrivateFieldGet(_this, _logger).warn("pauseRecording -> ignored, recorder not in recording state", _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this));
       }
@@ -2187,6 +2506,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
           status: SCREEN_RECORDER_STATUS.recording
         });
         _classPrivateFieldGet(_this, _mediaRecorder).resume();
+        getFastTitleRunner().resume();
       } else {
         _classPrivateFieldGet(_this, _logger).warn("resumeRecording -> ignored, recorder not paused", _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this));
       }
@@ -2239,26 +2559,43 @@ var ScreenRecorder = /*#__PURE__*/function () {
       _classPrivateFieldGet(_this, _mediaRecorder).onstop = null;
       _classPrivateFieldGet(_this, _stopAllStreams).call(_this);
     });
+    _classPrivateFieldInitSpec(this, _hasSpeechSourceForTitle, {
+      writable: true,
+      value: function value() {
+        var _classPrivateFieldGet9, _classPrivateFieldGet10, _classPrivateFieldGet11, _classPrivateFieldGet12, _classPrivateFieldGet13;
+        var _ref2 = (_classPrivateFieldGet9 = (_classPrivateFieldGet10 = _classPrivateFieldGet(_this, _micAudioStream)) === null || _classPrivateFieldGet10 === void 0 ? void 0 : (_classPrivateFieldGet11 = _classPrivateFieldGet10.getAudioTracks) === null || _classPrivateFieldGet11 === void 0 ? void 0 : _classPrivateFieldGet11.call(_classPrivateFieldGet10)) !== null && _classPrivateFieldGet9 !== void 0 ? _classPrivateFieldGet9 : [],
+          _ref3 = _slicedToArray(_ref2, 1),
+          micTrack = _ref3[0];
+        var micLive = Boolean(micTrack) && micTrack.readyState !== "ended" && !micTrack.muted && micTrack.enabled;
+        var hasSystemAudio = isNotEmpty((_classPrivateFieldGet12 = (_classPrivateFieldGet13 = _classPrivateFieldGet(_this, _stream)) === null || _classPrivateFieldGet13 === void 0 ? void 0 : _classPrivateFieldGet13.getAudioTracks()) !== null && _classPrivateFieldGet12 !== void 0 ? _classPrivateFieldGet12 : []);
+        if (!micLive && !hasSystemAudio) {
+          _classPrivateFieldGet(_this, _logger).info("fast title skipped -> mic is off and no system audio");
+          return false;
+        }
+        return true;
+      }
+    });
     _classPrivateFieldInitSpec(this, _stopAllStreams, {
       writable: true,
       value: function value() {
-        var _classPrivateFieldGet9, _classPrivateFieldGet10, _classPrivateFieldGet11, _classPrivateFieldGet12, _classPrivateFieldGet13, _classPrivateFieldGet14;
+        var _classPrivateFieldGet14, _classPrivateFieldGet15, _classPrivateFieldGet16, _classPrivateFieldGet17, _classPrivateFieldGet18, _classPrivateFieldGet19;
+        getFastTitleRunner().stop();
         _classPrivateFieldGet(_this, _logger).info("stopAllStreams", {
           mediaStream: _classPrivateFieldGet(_this, _summarizeStream).call(_this, _classPrivateFieldGet(_this, _mediaStream)),
           stream: _classPrivateFieldGet(_this, _summarizeStream).call(_this, _classPrivateFieldGet(_this, _stream)),
           audioStream: _classPrivateFieldGet(_this, _summarizeStream).call(_this, _classPrivateFieldGet(_this, _audioStream)),
           micAudioStream: _classPrivateFieldGet(_this, _summarizeStream).call(_this, _classPrivateFieldGet(_this, _micAudioStream))
         });
-        _classPrivateFieldGet(_this, _mediaStream) && ((_classPrivateFieldGet9 = _classPrivateFieldGet(_this, _mediaStream)) === null || _classPrivateFieldGet9 === void 0 ? void 0 : _classPrivateFieldGet9.getTracks().forEach(function (track) {
+        _classPrivateFieldGet(_this, _mediaStream) && ((_classPrivateFieldGet14 = _classPrivateFieldGet(_this, _mediaStream)) === null || _classPrivateFieldGet14 === void 0 ? void 0 : _classPrivateFieldGet14.getTracks().forEach(function (track) {
           return track.stop();
         }));
-        (_classPrivateFieldGet10 = _classPrivateFieldGet(_this, _stream)) === null || _classPrivateFieldGet10 === void 0 ? void 0 : _classPrivateFieldGet10.getTracks().forEach(function (track) {
+        (_classPrivateFieldGet15 = _classPrivateFieldGet(_this, _stream)) === null || _classPrivateFieldGet15 === void 0 ? void 0 : _classPrivateFieldGet15.getTracks().forEach(function (track) {
           return track.stop();
         });
-        (_classPrivateFieldGet11 = _classPrivateFieldGet(_this, _audioStream)) === null || _classPrivateFieldGet11 === void 0 ? void 0 : (_classPrivateFieldGet12 = _classPrivateFieldGet11.getAudioTracks()) === null || _classPrivateFieldGet12 === void 0 ? void 0 : _classPrivateFieldGet12.forEach(function (track) {
+        (_classPrivateFieldGet16 = _classPrivateFieldGet(_this, _audioStream)) === null || _classPrivateFieldGet16 === void 0 ? void 0 : (_classPrivateFieldGet17 = _classPrivateFieldGet16.getAudioTracks()) === null || _classPrivateFieldGet17 === void 0 ? void 0 : _classPrivateFieldGet17.forEach(function (track) {
           return track.stop();
         });
-        (_classPrivateFieldGet13 = _classPrivateFieldGet(_this, _micAudioStream)) === null || _classPrivateFieldGet13 === void 0 ? void 0 : (_classPrivateFieldGet14 = _classPrivateFieldGet13.getAudioTracks()) === null || _classPrivateFieldGet14 === void 0 ? void 0 : _classPrivateFieldGet14.forEach(function (track) {
+        (_classPrivateFieldGet18 = _classPrivateFieldGet(_this, _micAudioStream)) === null || _classPrivateFieldGet18 === void 0 ? void 0 : (_classPrivateFieldGet19 = _classPrivateFieldGet18.getAudioTracks()) === null || _classPrivateFieldGet19 === void 0 ? void 0 : _classPrivateFieldGet19.forEach(function (track) {
           return track.stop();
         });
       }
@@ -2389,9 +2726,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
                   break;
                 }
                 _context2.prev = 41;
-                workletUrl = IS_EXTENSION ?
-                // eslint-disable-next-line no-undef
-                chrome.runtime.getURL("public/NoiseSuppressorWorklet.js") : "NoiseSuppressorWorklet.js";
+                workletUrl = IS_EXTENSION ? chrome.runtime.getURL("public/NoiseSuppressorWorklet.js") : "NoiseSuppressorWorklet.js";
                 _classPrivateFieldGet(_this, _logger).info("acquireMediaStream -> loading noise suppressor worklet", {
                   workletUrl: workletUrl
                 });
@@ -2447,10 +2782,10 @@ var ScreenRecorder = /*#__PURE__*/function () {
                 // diagnostics) over to it; otherwise preserve the legacy behavior of
                 // finalizing the recording immediately.
                 stream.getVideoTracks()[0].addEventListener("ended", function () {
-                  var _classPrivateFieldGet15, _classPrivateFieldGet16;
-                  var hasUnexpectedEndHandler = isNotEmpty((_classPrivateFieldGet15 = _classPrivateFieldGet(_this, _callbacks)[SCREEN_RECORDER_EVENT.onUnexpectedEnd]) !== null && _classPrivateFieldGet15 !== void 0 ? _classPrivateFieldGet15 : []);
+                  var _classPrivateFieldGet20, _classPrivateFieldGet21;
+                  var hasUnexpectedEndHandler = isNotEmpty((_classPrivateFieldGet20 = _classPrivateFieldGet(_this, _callbacks)[SCREEN_RECORDER_EVENT.onUnexpectedEnd]) !== null && _classPrivateFieldGet20 !== void 0 ? _classPrivateFieldGet20 : []);
                   _classPrivateFieldGet(_this, _logger).info("display video track ended event received", {
-                    recorderState: (_classPrivateFieldGet16 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet16 === void 0 ? void 0 : _classPrivateFieldGet16.state,
+                    recorderState: (_classPrivateFieldGet21 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet21 === void 0 ? void 0 : _classPrivateFieldGet21.state,
                     status: _classPrivateFieldGet(_this, _store).getState().status,
                     hasUnexpectedEndHandler: hasUnexpectedEndHandler,
                     stream: _classPrivateFieldGet(_this, _summarizeStream).call(_this, stream)
@@ -2542,9 +2877,9 @@ var ScreenRecorder = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _fireCallbacks, {
       writable: true,
       value: function value(event) {
-        var _classPrivateFieldGet17;
+        var _classPrivateFieldGet22;
         var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-        (_classPrivateFieldGet17 = _classPrivateFieldGet(_this, _callbacks)[event]) === null || _classPrivateFieldGet17 === void 0 ? void 0 : _classPrivateFieldGet17.forEach(function (callback) {
+        (_classPrivateFieldGet22 = _classPrivateFieldGet(_this, _callbacks)[event]) === null || _classPrivateFieldGet22 === void 0 ? void 0 : _classPrivateFieldGet22.forEach(function (callback) {
           callback.apply(void 0, _toConsumableArray(args));
         });
       }
@@ -2558,9 +2893,9 @@ var ScreenRecorder = /*#__PURE__*/function () {
     });
     _classPrivateFieldInitSpec(this, _onRecordingActive, {
       writable: true,
-      value: function value(_ref2) {
-        var _classPrivateFieldGet18;
-        var data = _ref2.data;
+      value: function value(_ref4) {
+        var _classPrivateFieldGet23;
+        var data = _ref4.data;
         if (data.size <= 0) {
           _classPrivateFieldGet(_this, _logger).warn("ondataavailable -> empty chunk, ignoring", {
             chunkCount: _classPrivateFieldGet(_this, _mediaChunks).length
@@ -2578,7 +2913,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
           chunkType: data.type,
           chunkCount: _classPrivateFieldGet(_this, _mediaChunks).length,
           totalBytes: totalBytes,
-          recorderState: (_classPrivateFieldGet18 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet18 === void 0 ? void 0 : _classPrivateFieldGet18.state
+          recorderState: (_classPrivateFieldGet23 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet23 === void 0 ? void 0 : _classPrivateFieldGet23.state
         });
         _classPrivateFieldGet(_this, _fireCallbacks).call(_this, SCREEN_RECORDER_EVENT.onDataAvailable, [data]);
       }
@@ -2586,14 +2921,14 @@ var ScreenRecorder = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _onRecordingStop, {
       writable: true,
       value: function value() {
-        var _classPrivateFieldGet19, _classPrivateFieldGet20;
+        var _classPrivateFieldGet24, _classPrivateFieldGet25;
         var totalBytes = _classPrivateFieldGet(_this, _mediaChunks).reduce(function (sum, chunk) {
           var _chunk$size2;
           return sum + ((_chunk$size2 = chunk === null || chunk === void 0 ? void 0 : chunk.size) !== null && _chunk$size2 !== void 0 ? _chunk$size2 : 0);
         }, 0);
         _classPrivateFieldGet(_this, _logger).info("MediaRecorder.onstop fired", _objectSpread(_objectSpread({}, _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this)), {}, {
           totalBytes: totalBytes,
-          mediaStreamActive: (_classPrivateFieldGet19 = _classPrivateFieldGet(_this, _mediaStream)) === null || _classPrivateFieldGet19 === void 0 ? void 0 : _classPrivateFieldGet19.active
+          mediaStreamActive: (_classPrivateFieldGet24 = _classPrivateFieldGet(_this, _mediaStream)) === null || _classPrivateFieldGet24 === void 0 ? void 0 : _classPrivateFieldGet24.active
         }));
         _classPrivateFieldGet(_this, _store).setState({
           status: SCREEN_RECORDER_STATUS.stopped
@@ -2602,7 +2937,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
 
         // If mediaStream is active after stopping mediaRecorder, then that means that
         // we are restarting and not stopping.
-        if ((_classPrivateFieldGet20 = _classPrivateFieldGet(_this, _mediaStream)) !== null && _classPrivateFieldGet20 !== void 0 && _classPrivateFieldGet20.active) {
+        if ((_classPrivateFieldGet25 = _classPrivateFieldGet(_this, _mediaStream)) !== null && _classPrivateFieldGet25 !== void 0 && _classPrivateFieldGet25.active) {
           _classPrivateFieldGet(_this, _logger).info("onRecordingStop -> mediaStream still active, transitioning to restarting");
           _classPrivateFieldGet(_this, _store).setState({
             status: SCREEN_RECORDER_STATUS.restarting
@@ -2686,10 +3021,10 @@ var ScreenRecorder = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _summarizeRecorderState, {
       writable: true,
       value: function value() {
-        var _classPrivateFieldGet21;
+        var _classPrivateFieldGet26;
         var extra = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
         return _objectSpread({
-          recorderState: (_classPrivateFieldGet21 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet21 === void 0 ? void 0 : _classPrivateFieldGet21.state,
+          recorderState: (_classPrivateFieldGet26 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet26 === void 0 ? void 0 : _classPrivateFieldGet26.state,
           status: _classPrivateFieldGet(_this, _store).getState().status,
           elapsedTime: _classPrivateFieldGet(_this, _store).getState().elapsedTime,
           chunkCount: _classPrivateFieldGet(_this, _mediaChunks).length,
@@ -2707,7 +3042,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
         }, _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this)));
         _classPrivateFieldSet(_this, _startRecordingTimeoutID, setTimeout(function () {
           try {
-            var _classPrivateFieldGet22;
+            var _classPrivateFieldGet27;
             if (!_classPrivateFieldGet(_this, _mediaRecorder)) {
               _classPrivateFieldGet(_this, _logger).error("startMediaRecorder -> aborted, mediaRecorder is null", _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this));
               _classPrivateFieldGet(_this, _store).setState({
@@ -2728,7 +3063,7 @@ var ScreenRecorder = /*#__PURE__*/function () {
               });
               return;
             }
-            if (((_classPrivateFieldGet22 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet22 === void 0 ? void 0 : _classPrivateFieldGet22.state) === "recording") {
+            if (((_classPrivateFieldGet27 = _classPrivateFieldGet(_this, _mediaRecorder)) === null || _classPrivateFieldGet27 === void 0 ? void 0 : _classPrivateFieldGet27.state) === "recording") {
               _classPrivateFieldGet(_this, _logger).warn("startMediaRecorder -> mediaRecorder already recording, skipping", _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this));
               return;
             }
@@ -2736,6 +3071,12 @@ var ScreenRecorder = /*#__PURE__*/function () {
               timesliceMs: 5000
             }, _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this)));
             _classPrivateFieldGet(_this, _mediaRecorder).start(5000);
+
+            // Titles the recording from its opening seconds, while it is still
+            // being made. Skipped when there is nothing that could carry speech.
+            if (_classPrivateFieldGet(_this, _hasSpeechSourceForTitle).call(_this)) {
+              getFastTitleRunner().start(_classPrivateFieldGet(_this, _mediaStream));
+            }
             _classPrivateFieldGet(_this, _logger).info("startMediaRecorder -> start() returned", _classPrivateFieldGet(_this, _summarizeRecorderState).call(_this));
             _classPrivateFieldGet(_this, _startTimer).call(_this);
           } catch (error) {
@@ -2776,8 +3117,8 @@ var ScreenRecorder = /*#__PURE__*/function () {
         _classPrivateFieldGet(_this, _fireCallbacks).call(_this, SCREEN_RECORDER_EVENT.onCountdownStart);
         _classPrivateFieldSet(_this, _countdownTimerId, setInterval(function () {
           var shouldBeep = false;
-          _classPrivateFieldGet(_this, _store).setState(function (_ref3) {
-            var countdownTimeLeft = _ref3.countdownTimeLeft;
+          _classPrivateFieldGet(_this, _store).setState(function (_ref5) {
+            var countdownTimeLeft = _ref5.countdownTimeLeft;
             if (countdownTimeLeft - ONE_SECOND > 0) {
               var next = countdownTimeLeft - ONE_SECOND;
               _classPrivateFieldGet(_this, _logger).info("startCountdown -> tick", {
@@ -2812,8 +3153,8 @@ var ScreenRecorder = /*#__PURE__*/function () {
       value: function value() {
         _classPrivateFieldSet(_this, _lastTimerUpdatedAt, Date.now());
         _classPrivateFieldSet(_this, _timerId, setInterval(function () {
-          _classPrivateFieldGet(_this, _store).setState(function (_ref4) {
-            var elapsedTime = _ref4.elapsedTime;
+          _classPrivateFieldGet(_this, _store).setState(function (_ref6) {
+            var elapsedTime = _ref6.elapsedTime;
             var now = Date.now();
             var newElapsedTime = elapsedTime + (now - _classPrivateFieldGet(_this, _lastTimerUpdatedAt));
             _classPrivateFieldSet(_this, _lastTimerUpdatedAt, now);
@@ -2884,10 +3225,10 @@ var ScreenRecorder = /*#__PURE__*/function () {
   }, {
     key: "displaySurface",
     get: function get() {
-      var _classPrivateFieldGet23, _classPrivateFieldGet24;
-      var _ref5 = (_classPrivateFieldGet23 = (_classPrivateFieldGet24 = _classPrivateFieldGet(this, _mediaStream)) === null || _classPrivateFieldGet24 === void 0 ? void 0 : _classPrivateFieldGet24.getVideoTracks()) !== null && _classPrivateFieldGet23 !== void 0 ? _classPrivateFieldGet23 : [],
-        _ref6 = _slicedToArray(_ref5, 1),
-        videoTrack = _ref6[0];
+      var _classPrivateFieldGet28, _classPrivateFieldGet29;
+      var _ref7 = (_classPrivateFieldGet28 = (_classPrivateFieldGet29 = _classPrivateFieldGet(this, _mediaStream)) === null || _classPrivateFieldGet29 === void 0 ? void 0 : _classPrivateFieldGet29.getVideoTracks()) !== null && _classPrivateFieldGet28 !== void 0 ? _classPrivateFieldGet28 : [],
+        _ref8 = _slicedToArray(_ref7, 1),
+        videoTrack = _ref8[0];
       return videoTrack === null || videoTrack === void 0 ? void 0 : videoTrack.getSettings().displaySurface;
     }
   }, {
@@ -2905,6 +3246,15 @@ var ScreenRecorder = /*#__PURE__*/function () {
     // The chime is suppressed (vs. natural completion which plays it) since the
     // user explicitly opted out of the count-in. Listeners hook onCountdownSkip
     // to clean up countdown-only side effects like scheduled beeps.
+    // Whether this recording could contain speech worth titling from.
+    //
+    // A muted mic is the case that matters: with the mic off the fast-title path
+    // would upload audio, spend a transcription and a completion, and get nothing
+    // back. Checked against the raw mic rather than #audioStream, which is the mic
+    // mixed with system audio and stays loud through a dead mic.
+    //
+    // System audio counts on its own — a recording narrated by the thing on screen
+    // is exactly as titleable as one narrated by the user.
     // `delayMs` only exists to keep the start chime out of the recording; when no
     // chime plays (countdown skipped or disabled) we start immediately so the
     // recorder begins ticking without a perceptible gap.
@@ -2950,5 +3300,5 @@ var useMultipartS3UploadStatus = function useMultipartS3UploadStatus() {
 };
 useMultipartS3UploadStatus.triggerStatusChange = triggerStatusChange;
 
-export { getMultipartS3Uploader, getSupportedMimeType, screenRecorder, useMultipartS3UploadStatus };
+export { getFastTitleRunner, getMultipartS3Uploader, getSupportedMimeType, screenRecorder, useMultipartS3UploadStatus };
 //# sourceMappingURL=core.js.map