[Init] Initial commit - NetMesh terminal manager

domain/imeControlledInput.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure helpers for controlled text inputs that must not fight CJK IME composition.
+ *
+ * Deferred parent updates (e.g. startTransition) against `value={external}` reset
+ * the DOM mid-composition and break Windows IMEs (candidate dismiss / pinyin echo).
+ */
+
+export function shouldCommitImeControlledChange(input: {
+  isComposingSession: boolean;
+  nativeEventIsComposing?: boolean;
+  /**
+   * When true, the open (or just-ended) composition was discarded by an external
+   * value change (e.g. navigation cleared the filter). Suppress commits so a
+   * post-compositionend `onChange` cannot reassert the stale composed draft.
+   */
+  compositionExternallySuperseded?: boolean;
+}): boolean {
+  if (input.compositionExternallySuperseded) return false;
+  return !input.isComposingSession && input.nativeEventIsComposing !== true;
+}
+
+export function shouldAdoptExternalImeControlledValue(input: {
+  isComposingSession: boolean;
+  draftValue: string;
+  externalValue: string;
+  /**
+   * Committed external value captured at compositionstart. When provided during
+   * an open composition, an external change relative to this baseline (e.g.
+   * different-directory navigation setting filter to "") supersedes the draft
+   * so compositionend cannot re-commit stale text over the navigation clear.
+   */
+  valueAtComposeStart?: string;
+}): boolean {
+  if (input.draftValue === input.externalValue) return false;
+  if (!input.isComposingSession) return true;
+  // Mid-composition: only adopt when parent moved away from the compose-start
+  // baseline. Without a baseline, never fight the IME for self-driven drafts.
+  if (input.valueAtComposeStart !== undefined) {
+    return input.externalValue !== input.valueAtComposeStart;
+  }
+  return false;
+}
+
+/**
+ * Resolve an input event when a composition may have been externally superseded
+ * (navigation clear mid-IME). Browsers often re-fire the composed text via
+ * `onChange` with `isComposing=false` immediately after `compositionend`; that
+ * follow-up must not reassert the stale draft.
+ *
+ * - While still composing after supersede: keep ignoring event values (draft stays
+ *   on the external value) and keep the latch armed.
+ * - Once composition has fully ended: ignore that one post-composition change and
+ *   clear the latch so subsequent ordinary typing commits normally.
+ */
+export function resolveSupersededImeInputEvent(input: {
+  compositionExternallySuperseded: boolean;
+  isComposingSession: boolean;
+  nativeEventIsComposing?: boolean;
+}): {
+  ignoreEventValue: boolean;
+  clearSupersedeLatch: boolean;
+} {
+  if (!input.compositionExternallySuperseded) {
+    return { ignoreEventValue: false, clearSupersedeLatch: false };
+  }
+  const compositionFullyEnded =
+    !input.isComposingSession && input.nativeEventIsComposing !== true;
+  return {
+    ignoreEventValue: true,
+    clearSupersedeLatch: compositionFullyEnded,
+  };
+}