@agent-native/core 0.153.10 → 0.154.0

package/corpus/templates/clips/shared/mic-audio-cleanup.ts

@@ -0,0 +1,350 @@
+/**
+ * Conservative browser-side mic cleanup for Clips recorders.
+ *
+ * The goal is not to "fix" bad audio with a heavy denoiser. Instead we trim
+ * obvious AC rumble, notch the mains hum that sits under cheap mics, and only
+ * apply a gentle downward expander when the signal is already quiet.
+ *
+ * Safe failure rule: if the browser does not support the needed Web Audio
+ * pieces, or if graph setup fails for any reason, callers get the original
+ * stream back with a no-op cleanup handle rather than a thrown error.
+ */
+
+export const MIC_AUDIO_HIGH_PASS_HZ = 70;
+export const MIC_AUDIO_HUM_NOTCH_FREQUENCIES = [50, 60, 100, 120] as const;
+export const MIC_AUDIO_HUM_NOTCH_Q = 35;
+export const MIC_AUDIO_EXPANDER_INTERVAL_MS = 40;
+export const MIC_AUDIO_EXPANDER_FLOOR_GAIN = 0.24;
+export const MIC_AUDIO_EXPANDER_OPEN_DB = -42;
+export const MIC_AUDIO_EXPANDER_CLOSE_DB = -58;
+export const MIC_AUDIO_EXPANDER_SMOOTHING_SECONDS = 0.09;
+
+export type MicAudioCleanupPreset = "balanced" | "strong";
+
+export interface MicAudioCleanupOptions {
+  audioContext?: AudioContext | null;
+  preset?: MicAudioCleanupPreset;
+  intervalMs?: number;
+}
+
+export interface MicAudioCleanupHandle {
+  readonly inputStream: MediaStream;
+  readonly stream: MediaStream;
+  readonly active: boolean;
+  stop(): void;
+}
+
+type AudioContextLike = Pick<
+  AudioContext,
+  | "state"
+  | "currentTime"
+  | "resume"
+  | "close"
+  | "createAnalyser"
+  | "createBiquadFilter"
+  | "createGain"
+  | "createMediaStreamDestination"
+  | "createMediaStreamSource"
+>;
+
+type AudioNodeLike = {
+  connect(destination: unknown): unknown;
+  disconnect(): void;
+};
+
+type GainNodeLike = AudioNodeLike & {
+  gain: AudioParam & {
+    setTargetAtTime?: (
+      value: number,
+      startTime: number,
+      timeConstant: number,
+    ) => void;
+  };
+};
+
+type BiquadFilterNodeLike = AudioNodeLike & {
+  type: BiquadFilterType;
+  frequency: AudioParam;
+  Q: AudioParam;
+};
+
+type AnalyserNodeLike = AudioNodeLike & {
+  fftSize: number;
+  getFloatTimeDomainData: (dataArray: Float32Array<ArrayBuffer>) => void;
+};
+
+type MediaStreamDestinationNodeLike = AudioNodeLike & {
+  stream: MediaStream;
+};
+
+type MediaStreamSourceNodeLike = AudioNodeLike;
+
+interface MicAudioCleanupRuntime {
+  ctx: AudioContextLike;
+  ownsContext: boolean;
+  source: MediaStreamSourceNodeLike;
+  highPass: BiquadFilterNodeLike;
+  notches: BiquadFilterNodeLike[];
+  gain: GainNodeLike;
+  analyser: AnalyserNodeLike;
+  destination: MediaStreamDestinationNodeLike;
+  intervalId: ReturnType<typeof setInterval>;
+}
+
+function getAudioContextCtor(): typeof AudioContext | null {
+  const global = globalThis as typeof globalThis & {
+    AudioContext?: typeof AudioContext;
+    webkitAudioContext?: typeof AudioContext;
+  };
+  return global.AudioContext ?? global.webkitAudioContext ?? null;
+}
+
+function normalizePreset(preset: MicAudioCleanupPreset | undefined) {
+  return preset === "strong"
+    ? {
+        floorGain: 0.16,
+        openDb: -38,
+        closeDb: -56,
+        smoothingSeconds: 0.07,
+        intervalMs: 32,
+      }
+    : {
+        floorGain: MIC_AUDIO_EXPANDER_FLOOR_GAIN,
+        openDb: MIC_AUDIO_EXPANDER_OPEN_DB,
+        closeDb: MIC_AUDIO_EXPANDER_CLOSE_DB,
+        smoothingSeconds: MIC_AUDIO_EXPANDER_SMOOTHING_SECONDS,
+        intervalMs: MIC_AUDIO_EXPANDER_INTERVAL_MS,
+      };
+}
+
+function hasAudioTrack(stream: MediaStream): boolean {
+  try {
+    return stream.getAudioTracks().length > 0;
+    // coercion-ok: an unreadable track is a typed inactive cleanup fallback.
+  } catch {
+    return false;
+  }
+}
+
+function buildTargetGain(
+  levelDb: number,
+  preset: ReturnType<typeof normalizePreset>,
+) {
+  if (!Number.isFinite(levelDb)) return preset.floorGain;
+  if (levelDb >= preset.openDb) return 1;
+  if (levelDb <= preset.closeDb) return preset.floorGain;
+
+  const span = preset.openDb - preset.closeDb;
+  const t = (levelDb - preset.closeDb) / span;
+  // Ease in so the expander stays out of the way until the signal is
+  // genuinely quiet, then falls away a little more decisively.
+  return preset.floorGain + (1 - preset.floorGain) * t * t;
+}
+
+function measureRmsDb(samples: Float32Array): number {
+  let sumSquares = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const sample = samples[i] ?? 0;
+    sumSquares += sample * sample;
+  }
+  if (sumSquares <= 0) return Number.NEGATIVE_INFINITY;
+  const rms = Math.sqrt(sumSquares / samples.length);
+  if (rms <= 0) return Number.NEGATIVE_INFINITY;
+  return 20 * Math.log10(rms);
+}
+
+function disconnectNode(node: AudioNodeLike | null | undefined): void {
+  if (!node) return;
+  try {
+    node.disconnect();
+    // coercion-ok: disconnect is teardown-only and may race an ended track.
+  } catch {
+    // ignore — cleanup must be best-effort.
+  }
+}
+
+function stopDestinationStream(stream: MediaStream): void {
+  try {
+    for (const track of stream.getTracks()) {
+      try {
+        track.stop();
+        // coercion-ok: stopping an already-ended destination track is cleanup-only.
+      } catch {
+        // ignore
+      }
+    }
+    // coercion-ok: destination teardown is best-effort after capture has ended.
+  } catch {
+    // ignore
+  }
+}
+
+function createInactiveHandle(stream: MediaStream): MicAudioCleanupHandle {
+  return {
+    inputStream: stream,
+    stream,
+    active: false,
+    stop() {
+      // no-op
+    },
+  };
+}
+
+function tryBuildMicAudioCleanup(
+  stream: MediaStream,
+  options: MicAudioCleanupOptions,
+): MicAudioCleanupHandle {
+  // The browser path can hand us the actual `AudioContext` instance, while
+  // tests can inject a fake object. If neither exists, there is nothing to do.
+  const audioContextCtor = getAudioContextCtor();
+  const providedContext = options.audioContext ?? null;
+  const audioContext: AudioContextLike | null =
+    providedContext ?? (audioContextCtor ? new audioContextCtor() : null);
+  const ownsContext = !providedContext;
+
+  if (!audioContext || !hasAudioTrack(stream)) {
+    return createInactiveHandle(stream);
+  }
+
+  const preset = normalizePreset(options.preset);
+  const intervalMs = Math.max(
+    16,
+    Math.round(options.intervalMs ?? preset.intervalMs),
+  );
+  const supportsNodes =
+    typeof audioContext.createAnalyser === "function" &&
+    typeof audioContext.createBiquadFilter === "function" &&
+    typeof audioContext.createGain === "function" &&
+    typeof audioContext.createMediaStreamDestination === "function" &&
+    typeof audioContext.createMediaStreamSource === "function";
+  if (!supportsNodes) {
+    return createInactiveHandle(stream);
+  }
+
+  let runtime: MicAudioCleanupRuntime | null = null;
+  try {
+    const source = audioContext.createMediaStreamSource(stream);
+    const highPass = audioContext.createBiquadFilter();
+    highPass.type = "highpass";
+    highPass.frequency.value = MIC_AUDIO_HIGH_PASS_HZ;
+    highPass.Q.value = 0.707;
+
+    const notches = MIC_AUDIO_HUM_NOTCH_FREQUENCIES.map((frequency) => {
+      const filter = audioContext.createBiquadFilter();
+      filter.type = "notch";
+      filter.frequency.value = frequency;
+      filter.Q.value = MIC_AUDIO_HUM_NOTCH_Q;
+      return filter;
+    });
+
+    const gain = audioContext.createGain();
+    gain.gain.value = 1;
+    const analyser = audioContext.createAnalyser();
+    analyser.fftSize = 1024;
+    const destination = audioContext.createMediaStreamDestination();
+
+    source.connect(highPass);
+    let node: AudioNodeLike = highPass;
+    for (const notch of notches) {
+      node.connect(notch);
+      node = notch;
+    }
+    node.connect(gain);
+    node.connect(analyser);
+    gain.connect(destination);
+
+    if (
+      audioContext.state === "suspended" &&
+      typeof audioContext.resume === "function"
+    ) {
+      void audioContext.resume().catch(() => {});
+    }
+
+    const samples = new Float32Array(analyser.fftSize);
+    const tick = () => {
+      if (!runtime) return;
+      try {
+        runtime.analyser.getFloatTimeDomainData(samples);
+        const nextGain = buildTargetGain(measureRmsDb(samples), preset);
+        const now = runtime.ctx.currentTime;
+        if (typeof runtime.gain.gain.setTargetAtTime === "function") {
+          runtime.gain.gain.setTargetAtTime(
+            nextGain,
+            now,
+            preset.smoothingSeconds,
+          );
+        } else {
+          runtime.gain.gain.value = nextGain;
+        }
+        // coercion-ok: a transient analyser/meter failure must not stop recording.
+      } catch {
+        // Keep the recording alive even if the meter path glitches.
+      }
+    };
+
+    const intervalId = globalThis.setInterval(tick, intervalMs);
+    runtime = {
+      ctx: audioContext,
+      ownsContext,
+      source,
+      highPass,
+      notches,
+      gain,
+      analyser,
+      destination,
+      intervalId,
+    };
+
+    return {
+      inputStream: stream,
+      stream: destination.stream,
+      active: true,
+      stop() {
+        if (!runtime) return;
+        const current = runtime;
+        runtime = null;
+        try {
+          clearInterval(current.intervalId);
+          // coercion-ok: timer cleanup is best-effort after the interval ends.
+        } catch {
+          // ignore
+        }
+        disconnectNode(current.source);
+        disconnectNode(current.highPass);
+        for (const notch of current.notches) disconnectNode(notch);
+        disconnectNode(current.gain);
+        disconnectNode(current.analyser);
+        stopDestinationStream(current.destination.stream);
+        if (current.ownsContext && typeof current.ctx.close === "function") {
+          void current.ctx.close().catch(() => {});
+        }
+      },
+    };
+  } catch {
+    if (runtime) {
+      try {
+        clearInterval(runtime.intervalId);
+      } catch {
+        // ignore
+      }
+      disconnectNode(runtime.source);
+      disconnectNode(runtime.highPass);
+      for (const notch of runtime.notches) disconnectNode(notch);
+      disconnectNode(runtime.gain);
+      disconnectNode(runtime.analyser);
+      stopDestinationStream(runtime.destination.stream);
+    }
+    return createInactiveHandle(stream);
+  }
+}
+
+export function createMicAudioCleanup(
+  stream: MediaStream,
+  options: MicAudioCleanupOptions = {},
+): MicAudioCleanupHandle {
+  try {
+    return tryBuildMicAudioCleanup(stream, options);
+  } catch {
+    return createInactiveHandle(stream);
+  }
+}

package/corpus/templates/content/app/i18n-data.ts

@@ -2915,7 +2915,7 @@ const editorSlashMessages = {
   equationPreview: "Preview",
   equationPreviewEmpty: "Your equation will appear here.",
   equationSubmitHint:
-    "Preview updates as you type. Press Cmd/Ctrl+Enter to insert.",
+    "Preview updates as you type. Press Cmd/Ctrl Enter to insert.",
   quote: "Quote",
   quoteDescription: "Block quote",
   table: "Table",
@@ -11195,7 +11195,7 @@ const contentExactEnglishTranslations = {
         equationPlaceholder: String.raw`输入 LaTeX，例如 \frac{a}{b}`,
         equationPreview: "预览",
         equationPreviewEmpty: "公式将在此处显示。",
-        equationSubmitHint: "输入时会实时更新预览。按 Cmd/Ctrl+Enter 插入。",
+        equationSubmitHint: "输入时会实时更新预览。按 Cmd/Ctrl Enter 插入。",
       },
       toolbar: {
         info: "信息",
@@ -11242,7 +11242,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "Vista previa",
         equationPreviewEmpty: "Tu ecuación aparecerá aquí.",
         equationSubmitHint:
-          "La vista previa se actualiza mientras escribes. Pulsa Cmd/Ctrl+Enter para insertar.",
+          "La vista previa se actualiza mientras escribes. Pulsa Cmd/Ctrl Enter para insertar.",
       },
       toolbar: {
         info: "Información",
@@ -11291,7 +11291,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "Aperçu",
         equationPreviewEmpty: "Votre équation apparaîtra ici.",
         equationSubmitHint:
-          "L’aperçu se met à jour pendant la saisie. Appuyez sur Cmd/Ctrl+Entrée pour insérer.",
+          "L’aperçu se met à jour pendant la saisie. Appuyez sur Cmd/Ctrl Entrée pour insérer.",
       },
       toolbar: {
         info: "Informations",
@@ -11341,7 +11341,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "Vorschau",
         equationPreviewEmpty: "Ihre Gleichung wird hier angezeigt.",
         equationSubmitHint:
-          "Die Vorschau wird während der Eingabe aktualisiert. Mit Cmd/Ctrl+Enter einfügen.",
+          "Die Vorschau wird während der Eingabe aktualisiert. Mit Cmd/Ctrl Enter einfügen.",
       },
       toolbar: {
         info: "Informationen",
@@ -11390,7 +11390,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "プレビュー",
         equationPreviewEmpty: "ここに数式が表示されます。",
         equationSubmitHint:
-          "入力中にプレビューが更新されます。Cmd/Ctrl+Enter で挿入します。",
+          "入力中にプレビューが更新されます。Cmd/Ctrl Enter で挿入します。",
       },
       toolbar: {
         info: "情報",
@@ -11438,7 +11438,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "미리보기",
         equationPreviewEmpty: "여기에 수식이 표시됩니다.",
         equationSubmitHint:
-          "입력하는 동안 미리보기가 업데이트됩니다. Cmd/Ctrl+Enter로 삽입하세요.",
+          "입력하는 동안 미리보기가 업데이트됩니다. Cmd/Ctrl Enter로 삽입하세요.",
       },
       toolbar: {
         info: "정보",
@@ -11487,7 +11487,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "Prévia",
         equationPreviewEmpty: "Sua equação aparecerá aqui.",
         equationSubmitHint:
-          "A prévia é atualizada enquanto você digita. Pressione Cmd/Ctrl+Enter para inserir.",
+          "A prévia é atualizada enquanto você digita. Pressione Cmd/Ctrl Enter para inserir.",
       },
       toolbar: {
         info: "Informações",
@@ -11535,7 +11535,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "पूर्वावलोकन",
         equationPreviewEmpty: "आपका समीकरण यहाँ दिखाई देगा।",
         equationSubmitHint:
-          "लिखते समय पूर्वावलोकन अपडेट होता है। सम्मिलित करने के लिए Cmd/Ctrl+Enter दबाएँ।",
+          "लिखते समय पूर्वावलोकन अपडेट होता है। सम्मिलित करने के लिए Cmd/Ctrl Enter दबाएँ।",
       },
       toolbar: {
         info: "जानकारी",
@@ -11581,7 +11581,7 @@ const contentExactEnglishTranslations = {
         equationPreview: "معاينة",
         equationPreviewEmpty: "ستظهر معادلتك هنا.",
         equationSubmitHint:
-          "تتحدث المعاينة أثناء الكتابة. اضغط Cmd/Ctrl+Enter للإدراج.",
+          "تتحدث المعاينة أثناء الكتابة. اضغط Cmd/Ctrl Enter للإدراج.",
       },
       toolbar: {
         info: "معلومات",

package/corpus/templates/content/scripts/check-native-deps.mjs

@@ -1,11 +1,25 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  writeSync,
+} from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
+const REBUILD_LOCK = ".agent-native-better-sqlite3-rebuild.lock";
+const LOCK_INITIALIZATION_TIMEOUT_MS = 5_000;
+const REBUILD_WAIT_MS = 250;
+const REBUILD_TIMEOUT_MS = 10 * 60 * 1000;
 
 function resolveBetterSqlite3() {
   try {
@@ -29,29 +43,181 @@ function resolveBetterSqlite3() {
   }
 }
 
-try {
-  const { default: Database } = await import(
-    pathToFileURL(resolveBetterSqlite3()).href
+function npmExecutable() {
+  const sibling = join(
+    dirname(process.execPath),
+    process.platform === "win32" ? "npm.cmd" : "npm",
   );
+  return existsSync(sibling) ? sibling : "npm";
+}
+
+function sleepSync(milliseconds) {
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(signal, 0, 0, milliseconds);
+}
+
+function processIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code !== "ESRCH";
+  }
+}
+
+function acquireRebuildLock(packageDir) {
+  const lockPath = join(packageDir, REBUILD_LOCK);
+  const startedWaiting = Date.now();
+
+  while (true) {
+    try {
+      const lockFd = openSync(lockPath, "wx");
+      writeSync(
+        lockFd,
+        JSON.stringify({
+          pid: process.pid,
+          startedAt: new Date().toISOString(),
+        }),
+      );
+      return () => {
+        try {
+          closeSync(lockFd);
+        } finally {
+          try {
+            unlinkSync(lockPath);
+          } catch (error) {
+            if (
+              !(
+                error instanceof Error &&
+                "code" in error &&
+                error.code === "ENOENT"
+              )
+            ) {
+              throw error;
+            }
+          }
+        }
+      };
+    } catch (error) {
+      if (
+        !(error instanceof Error && "code" in error && error.code === "EEXIST")
+      ) {
+        throw error;
+      }
+
+      let ownerPid = null;
+      let lockAge = 0;
+      try {
+        const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+        ownerPid = typeof lock.pid === "number" ? lock.pid : null;
+      } catch {
+        // The owner may be between creating and writing the lock metadata.
+      }
+      try {
+        lockAge = Date.now() - statSync(lockPath).mtimeMs;
+      } catch {
+        continue;
+      }
+
+      if (
+        (ownerPid !== null && !processIsRunning(ownerPid)) ||
+        (ownerPid === null && lockAge > LOCK_INITIALIZATION_TIMEOUT_MS)
+      ) {
+        try {
+          unlinkSync(lockPath);
+          continue;
+        } catch (unlinkError) {
+          if (
+            !(
+              unlinkError instanceof Error &&
+              "code" in unlinkError &&
+              unlinkError.code === "ENOENT"
+            )
+          ) {
+            throw unlinkError;
+          }
+          continue;
+        }
+      }
+
+      if (Date.now() - startedWaiting > REBUILD_TIMEOUT_MS) {
+        throw new Error(
+          "Timed out waiting for another process to rebuild better-sqlite3",
+        );
+      }
+      sleepSync(REBUILD_WAIT_MS);
+    }
+  }
+}
+
+function verifyBetterSqlite3(entry) {
+  const requireFromPackage = createRequire(entry);
+  const Database = requireFromPackage(entry);
   const db = new Database(":memory:");
   db.close();
+}
+
+let packageEntry;
+try {
+  packageEntry = resolveBetterSqlite3();
 } catch (error) {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`
 [content dev preflight] better-sqlite3 could not load its native binding.
 
-This usually means the local install was restored without rebuilding native
-modules. Try:
-
-  pnpm rebuild better-sqlite3
-
-If that still fails, rebuild the package directly:
-
-  cd ../../node_modules/.pnpm/better-sqlite3@*/node_modules/better-sqlite3
-  npm run build-release
-
 Original error:
 ${message}
 `);
   process.exit(1);
 }
+
+try {
+  verifyBetterSqlite3(packageEntry);
+} catch (firstError) {
+  const packageDir = dirname(dirname(packageEntry));
+  const releaseLock = acquireRebuildLock(packageDir);
+  let repairError;
+  try {
+    let alreadyRepaired = false;
+    try {
+      verifyBetterSqlite3(packageEntry);
+      alreadyRepaired = true;
+    } catch {
+      // Another preflight may have repaired the package while we waited.
+    }
+    if (!alreadyRepaired) {
+      console.warn(
+        `[content dev preflight] Rebuilding ${packageDir} with Node ${process.version} (ABI ${process.versions.modules})...`,
+      );
+      execFileSync(
+        npmExecutable(),
+        ["run", "build-release", "--prefix", packageDir],
+        {
+          cwd: packageDir,
+          stdio: "inherit",
+        },
+      );
+      verifyBetterSqlite3(packageEntry);
+    }
+  } catch (error) {
+    repairError = error;
+  } finally {
+    releaseLock();
+  }
+
+  if (repairError) {
+    const original =
+      firstError instanceof Error ? firstError.message : String(firstError);
+    const repaired =
+      repairError instanceof Error ? repairError.message : String(repairError);
+    console.error(`
+[content dev preflight] better-sqlite3 is still unusable after a direct rebuild.
+
+Package: ${packageDir}
+Node: ${process.version} (ABI ${process.versions.modules})
+Original error: ${original}
+Rebuild error: ${repaired}
+`);
+    process.exit(1);
+  }
+}