@agent-native/core 0.153.10 → 0.154.1

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/actions/resolve-content-landing.ts

@@ -1,15 +1,21 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 
 import { defineAction } from "@agent-native/core";
-import { readAppState } from "@agent-native/core/application-state";
+import {
+  compareAndSetAppState,
+  listAppState,
+  readAppState,
+} from "@agent-native/core/application-state";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { z } from "zod";
 
 import {
   CONTENT_LAST_LOCATION_STATE_KEY,
+  CONTENT_WELCOME_PAGE_STATE_KEY,
   type ContentLandingResolution,
   type ContentLastLocationState,
+  type ContentWelcomePageState,
 } from "../shared/content-landing.js";
 import { resolveContentDocumentAccess } from "./_content-document-access.js";
 import { normalizeContentSpaceEmail } from "./_content-space-access.js";
@@ -24,12 +30,85 @@ const WELCOME_CONTENT = `Start here with a page that is wholly yours.
 - Use the sidebar to find and organize your work.
 - Ask the agent when you want a hand.`;
 
-function welcomeDocumentId(userEmail: string) {
+function legacyWelcomeDocumentId(userEmail: string, generation: number) {
   const identity = normalizeContentSpaceEmail(userEmail);
-  const digest = createHash("sha256").update(identity).digest("hex");
+  const input = generation === 0 ? identity : `${identity}:${generation}`;
+  const digest = createHash("sha256").update(input).digest("hex");
   return `content_welcome_${digest.slice(0, 32)}`;
 }
 
+function randomWelcomeDocumentId() {
+  return `content_welcome_${randomUUID().replace(/-/g, "")}`;
+}
+
+function welcomeGeneration(state: Record<string, unknown>): number {
+  const candidate = state as ContentWelcomePageState;
+  if (
+    typeof candidate.generation !== "number" ||
+    !Number.isSafeInteger(candidate.generation) ||
+    candidate.generation < 0
+  ) {
+    throw new Error("Content welcome page state has an invalid generation");
+  }
+  return candidate.generation;
+}
+
+function isUniqueConstraintError(error: unknown): boolean {
+  let current: unknown = error;
+  const seen = new Set<unknown>();
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current as {
+      code?: unknown;
+      message?: unknown;
+      cause?: unknown;
+    };
+    const code = String(candidate.code ?? "");
+    const message = String(candidate.message ?? "");
+    if (
+      code === "23505" ||
+      code.includes("SQLITE_CONSTRAINT") ||
+      /unique constraint|unique violation|duplicate key/i.test(message)
+    ) {
+      return true;
+    }
+    current = candidate.cause;
+  }
+  return false;
+}
+
+async function resolveWelcomeState(): Promise<{
+  generation: number;
+  documentId: string | null;
+  expectedValue: Record<string, unknown>;
+}> {
+  while (true) {
+    const entries = await listAppState(CONTENT_WELCOME_PAGE_STATE_KEY);
+    const entry = entries.find(
+      ({ key }) => key === CONTENT_WELCOME_PAGE_STATE_KEY,
+    );
+    if (entry) {
+      if (!entry.value || typeof entry.value !== "object") {
+        throw new Error("Content welcome page state must be an object");
+      }
+      return {
+        generation: welcomeGeneration(entry.value),
+        documentId:
+          typeof entry.value.documentId === "string" && entry.value.documentId
+            ? entry.value.documentId
+            : null,
+        expectedValue: entry.value,
+      };
+    }
+
+    const initial = { generation: 0 };
+    if (
+      await compareAndSetAppState(CONTENT_WELCOME_PAGE_STATE_KEY, null, initial)
+    ) {
+      return { generation: 0, documentId: null, expectedValue: initial };
+    }
+  }
+}
 function savedDocumentId(state: Record<string, unknown> | null): string | null {
   const candidate = state as ContentLastLocationState | null;
   return typeof candidate?.documentId === "string" && candidate.documentId
@@ -44,22 +123,28 @@ async function resolveUsableDocument(documentId: string) {
   return access.resource;
 }
 
-async function resolveWelcomeDocument(userEmail: string) {
-  const documentId = welcomeDocumentId(userEmail);
-  const document = await resolveUsableDocument(documentId);
-  if (!document) return null;
+async function resolveWelcomeDocument(userEmail: string, documentId: string) {
+  const access = await resolveContentDocumentAccess(documentId);
+  const document = access?.resource;
+  if (!document) {
+    return (await isSoftDeletedDatabaseDocument(documentId))
+      ? { status: "unavailable" as const }
+      : { status: "missing" as const };
+  }
+  if (document.trashedAt || (await isSoftDeletedDatabaseDocument(documentId))) {
+    return { status: "unavailable" as const };
+  }
 
   const normalizedEmail = normalizeContentSpaceEmail(userEmail);
   if (
     normalizeContentSpaceEmail(document.ownerEmail) !== normalizedEmail ||
     document.spaceId !== personalContentSpaceId(normalizedEmail) ||
     document.parentId !== null ||
-    document.visibility !== "private" ||
-    document.title !== WELCOME_TITLE
+    document.visibility !== "private"
   ) {
-    return null;
+    return { status: "unavailable" as const };
   }
-  return documentId;
+  return { status: "usable" as const, documentId };
 }
 
 async function resolveWelcome(userEmail: string): Promise<{
@@ -69,27 +154,72 @@ async function resolveWelcome(userEmail: string): Promise<{
     "welcome-created" | "welcome-reused"
   >;
 }> {
-  const existing = await resolveWelcomeDocument(userEmail);
-  if (existing) return { documentId: existing, resolution: "welcome-reused" };
-
-  const documentId = welcomeDocumentId(userEmail);
   const normalizedEmail = normalizeContentSpaceEmail(userEmail);
-  try {
-    await runWithRequestContext({ userEmail: normalizedEmail }, () =>
-      createDocumentAction.run({
-        id: documentId,
-        title: WELCOME_TITLE,
-        content: WELCOME_CONTENT,
-      }),
-    );
-    return { documentId, resolution: "welcome-created" };
-  } catch (error) {
-    // The stable per-user document ID is the cross-request convergence point.
-    // A competing request can own the insert; only reuse it after the complete
-    // personal-page invariant has been rechecked.
-    const raced = await resolveWelcomeDocument(userEmail);
-    if (raced) return { documentId: raced, resolution: "welcome-reused" };
-    throw error;
+  while (true) {
+    const state = await resolveWelcomeState();
+    const documentId =
+      state.documentId ??
+      legacyWelcomeDocumentId(normalizedEmail, state.generation);
+    const existing = await resolveWelcomeDocument(normalizedEmail, documentId);
+    if (existing.status === "usable") {
+      if (!state.documentId) {
+        await compareAndSetAppState(
+          CONTENT_WELCOME_PAGE_STATE_KEY,
+          state.expectedValue,
+          { ...state.expectedValue, documentId },
+        );
+      }
+      return {
+        documentId: existing.documentId,
+        resolution: "welcome-reused",
+      };
+    }
+
+    if (!state.documentId || existing.status === "unavailable") {
+      await compareAndSetAppState(
+        CONTENT_WELCOME_PAGE_STATE_KEY,
+        state.expectedValue,
+        {
+          ...state.expectedValue,
+          generation: state.generation + 1,
+          documentId: randomWelcomeDocumentId(),
+        },
+      );
+      continue;
+    }
+
+    try {
+      await runWithRequestContext({ userEmail: normalizedEmail }, () =>
+        createDocumentAction.run({
+          id: documentId,
+          title: WELCOME_TITLE,
+          content: WELCOME_CONTENT,
+        }),
+      );
+      return { documentId, resolution: "welcome-created" };
+    } catch (error) {
+      const raced = await resolveWelcomeDocument(normalizedEmail, documentId);
+      if (raced.status === "usable") {
+        return {
+          documentId: raced.documentId,
+          resolution: "welcome-reused",
+        };
+      }
+      if (raced.status === "unavailable") continue;
+      if (isUniqueConstraintError(error)) {
+        await compareAndSetAppState(
+          CONTENT_WELCOME_PAGE_STATE_KEY,
+          state.expectedValue,
+          {
+            ...state.expectedValue,
+            generation: state.generation + 1,
+            documentId: randomWelcomeDocumentId(),
+          },
+        );
+        continue;
+      }
+      throw error;
+    }
   }
 }
 

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: "معلومات",