fix(note): 手动序清理校验/选区区间与落点/划选泄漏（2026-09-05 审查批C）

Author: Aparencia

app/src-tauri/src/commands.rs

@@ -470,6 +470,8 @@ pub async fn delete_note(state: State<'_, AppState>, id: i64) -> Result<bool, St
     }
     let deleted = state.db.delete_note(id).map_err(|e| e.to_string())?;
     if deleted {
+        // 审查 L6：删除即清手动序行（note_orders 无 FK——防孤儿行累积）
+        let _ = state.db.purge_note_ids(&[id]);
         // v0.15：notes-images/{nid}/ 只属于该笔记——删除笔记即清空（尽力而为：
         // 失败不阻断（用户重试删除无意义时也允许残留，垃圾回收后续单独任务）
         let img_dir = state.data_dir.join("notes-images").join(id.to_string());

app/src-tauri/src/commands_groups.rs

@@ -180,6 +180,8 @@ pub fn move_note_to_group(
     let ok = state.db.update_note_group(note_id, group_id).map_err(|e| e.to_string())?;
     // REQ-278：归组 = 笔记归属 + 组内容双变 → 双域广播（成功才发）
     if ok {
+        // 审查 L6：移组即清旧 scope 手动序行（防"移出后移回复活旧序位"）
+        let _ = state.db.purge_note_ids(&[note_id]);
         crate::notify::emit_changed(&state.app, crate::notify::DataDomain::Notes);
         crate::notify::emit_changed(&state.app, crate::notify::DataDomain::NoteGroups);
     }

app/src-tauri/src/commands_note_orders.rs

@@ -38,6 +38,14 @@ pub fn note_order_save(state: State<'_, AppState>, scope: String, note_ids: Vec<
     if !note_ids.iter().all(|id| *id > 0 && seen.insert(*id)) {
         return Err("笔记 id 非法或重复".to_string());
     }
+    // 审查 L6：归属校验——全部 id 必须当前属于该 scope（陈旧/跨组序整体拒绝）
+    let ok = state
+        .db
+        .verify_scope_membership(&scope, &note_ids)
+        .map_err(|e| e.to_string())?;
+    if !ok {
+        return Err("部分笔记不属于该排序范围——请先归组或刷新后再排序".to_string());
+    }
     state.db.save_note_order(&scope, &note_ids).map_err(|e| e.to_string())?;
     // REQ-278：notes 域广播（排序变化 → 列表刷新）
     crate::notify::emit_changed(&state.app, crate::notify::DataDomain::Notes);

app/src-tauri/src/db_note_orders.rs

@@ -44,12 +44,13 @@ impl Db {
             .lock()
             .unwrap_or_else(|poisoned| poisoned.into_inner());
         let tx = conn.transaction()?;
-        tx.execute("DELETE FROM note_orders WHERE scope = ?1", [scope])?;
+        tx.execute("DELETE FROM note_orders WHERE scope = ?1", rusqlite::params![scope])?;
         {
             let mut stmt =
                 tx.prepare("INSERT INTO note_orders (scope, note_id, ord) VALUES (?1, ?2, ?3)")?;
             for (i, id) in note_ids.iter().enumerate() {
-                stmt.execute([scope, &id.to_string(), &(i as i64).to_string()])?;
+                // L12（审查）：INTEGER 列按类型直绑（不再字符串化依赖列亲和）
+                stmt.execute(rusqlite::params![scope, *id, i as i64])?;
             }
         }
         tx.commit()?;
@@ -63,6 +64,53 @@ impl Db {
             Ok(affected > 0)
         })
     }
+
+    /// 笔记删除/移组时清理其全部手动序行（审查 L6：无 FK——防孤儿行累积与
+    /// "移出后移回复活旧序位"；删除路径幂等，移组路径清除旧 scope 序）。
+    pub fn purge_note_ids(&self, note_ids: &[i64]) -> Result<()> {
+        self.with_conn(|conn| {
+            for id in note_ids {
+                conn.execute(
+                    "DELETE FROM note_orders WHERE note_id = ?1",
+                    rusqlite::params![*id],
+                )?;
+            }
+            Ok(())
+        })
+    }
+
+    /// 归属校验（审查 L6）：scope 要求每个 id 当前确属于该组/未分组——前端
+    /// bug/并发移组后的陈旧序不得污染（不匹配 → Err，调用方整体拒绝）。
+    pub fn verify_scope_membership(&self, scope: &str, note_ids: &[i64]) -> Result<bool> {
+        self.with_conn(|conn| {
+            let mut sql = String::from("SELECT id FROM notes WHERE ");
+            let mut params: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+            match scope.strip_prefix("g:") {
+                Some(rest) => {
+                    sql.push_str("group_id = ?1 AND id IN (");
+                    params.push(Box::new(rest.to_string()));
+                }
+                None => {
+                    sql.push_str("group_id IS NULL AND id IN (");
+                }
+            }
+            for (i, _) in note_ids.iter().enumerate() {
+                if i > 0 { sql.push(','); }
+                sql.push_str(&format!("?{}", i + params.len() + 1));
+                params.push(Box::new(note_ids[i].to_string()));
+            }
+            sql.push(')');
+            let mut stmt = conn.prepare(&sql)?;
+            let rows = stmt.query_map(
+                rusqlite::params_from_iter(params.iter().map(|b| b.as_ref())),
+                |row| row.get::<_, i64>(0),
+            )?;
+            let found: Vec<i64> = rows.collect::<rusqlite::Result<Vec<_>>>()?;
+            let want: std::collections::HashSet<i64> = note_ids.iter().copied().collect();
+            let got: std::collections::HashSet<i64> = found.into_iter().collect();
+            Ok(got == want)
+        })
+    }
 }
 
 #[cfg(test)]

app/src/components/NoteListRow.tsx

@@ -32,18 +32,16 @@ interface Props {
   onModifierClick: (note: Note, ctrl: boolean, shift: boolean) => void;
   /** 拖拽行载荷（多选整组=选集 ids；未选中态=单行 id） */
   dragIds: number[];
-  /** 行间落点（组内手动排序；父层判定） */
+  /** 行间落点（组内手动排序；父层判定——仅树模式传入） */
   onDropOnRow?: (ids: number[], targetId: number, before: boolean) => void;
-  /** 父层行间落点指示（视觉反馈） */
-  dropIndicator?: "before" | "after" | null;
   onOpenSession: (sessionId: number) => void;
   /** v0.16.1：右键菜单打开（父层持有坐标/状态；原生菜单已全局禁用） */
   onContextMenu?: (e: React.MouseEvent, note: Note) => void;
 }
 
 export default function NoteListRow({
   note, accent, openId, multiSelected, tagColors, onOpen, onModifierClick,
-  dragIds, onDropOnRow, dropIndicator = null, onOpenSession, onContextMenu,
+  dragIds, onDropOnRow, onOpenSession, onContextMenu,
 }: Props) {
   const tags = parseTags(note);
   // v0.14 B：当前主题（跟随 prefers-color-scheme；jsdom 无 matchMedia 回退 light）
@@ -76,7 +74,7 @@ export default function NoteListRow({
         let ids: number[] = [];
         try {
           const arr: unknown = JSON.parse(raw);
-          if (Array.isArray(arr)) ids = arr.filter((x): x is number => typeof x === "number" && x > 0);
+          if (Array.isArray(arr)) ids = arr.filter((x): x is number => typeof x === "number" && Number.isInteger(x) && x > 0);
         } catch { /* 兜底单 id */ }
         if (ids.length === 0) {
           const single = Number(e.dataTransfer.getData("text/note-id"));
@@ -103,9 +101,6 @@ export default function NoteListRow({
         borderLeft: `4px solid ${accent}`,
         cursor: "pointer",
         background: isOpen ? "#f0fdfa" : multiSelected ? "#eef2ff" : "transparent",
-        boxShadow: dropIndicator === "before"
-          ? "inset 0 2px 0 #4f46e5"
-          : dropIndicator === "after" ? "inset 0 -2px 0 #4f46e5" : "none",
       }}
     >
       <div style={{ display: "flex", alignItems: "center", gap: 6 }}>

app/src/components/NoteListView.tsx

@@ -104,6 +104,8 @@ export default function NoteListView({
   const [manualOrders, setManualOrders] = useState<Record<string, number[]>>({});
 
   const visibleIdsRef = useRef<number[]>([]);
+  // L5：行落点并发锁（防陈旧快照互覆）
+  const dropBusyRef = useRef(false);
 
   const clearSelection = useCallback(() => {
     setSelection(emptySelection());
@@ -235,7 +237,16 @@ export default function NoteListView({
     return out;
   }, [treeMode, grouped, groups, notes, groupFolds, applyManual, theme, groupFilter]);
 
-  const visibleOrder = useMemo(() => sections.flatMap((s) => s.items.map((n) => n.id)), [sections]);
+  // 可见序（L1 审查：折叠组行不参与区间/划选——与渲染可见一致；折叠组头仍在）
+  const visibleOrder = useMemo(() => {
+    const out: number[] = [];
+    for (const sec of sections) {
+      const key = sec.groupId == null ? "none" : String(sec.groupId);
+      if (groupFolds[key] === true) continue; // 折叠=行不可见，排除出选择语义
+      for (const n of sec.items) out.push(n.id);
+    }
+    return out;
+  }, [sections, groupFolds]);
   useEffect(() => { visibleIdsRef.current = visibleOrder; }, [visibleOrder]);
 
   // ── 行交互 ──
@@ -246,16 +257,25 @@ export default function NoteListView({
       setAnchor(note.id);
       return;
     }
+    // 审查 L4：普通单击=单选并打开——先清既有选集，anchor 恒指向本次点击
+    if (selection.size > 0) clearSelection();
     onSelect(note);
-    if (selection.size === 0) setAnchor(note.id);
-  }, [selectionMode, onSelect, selection.size]);
+    setAnchor(note.id);
+  }, [selectionMode, onSelect, selection.size, clearSelection]);
 
   const handleModifierClick = useCallback((note: Note, ctrl: boolean, shift: boolean) => {
     if (ctrl) {
       setSelection((cur) => toggleSelection(cur, note.id));
+      // 审查 L4：Ctrl 后 anchor 指向本次点击行（即使该行被移除——Explorer 同款）
       setAnchor(note.id);
     } else if (shift) {
-      setSelection((cur) => rangeSelection(cur, visibleIdsRef.current, anchor, note.id));
+      if (anchor == null) {
+        // 审查 L4：无锚的首次 Shift=单选该行并设为锚（连按两次不再各加单行）
+        setSelection(new Set([note.id]));
+        setAnchor(note.id);
+      } else {
+        setSelection((cur) => rangeSelection(cur, visibleIdsRef.current, anchor, note.id));
+      }
     }
   }, [anchor]);
 
@@ -285,37 +305,62 @@ export default function NoteListView({
     }
   }, [notes, manualOrders, saveOrder, onNoteMoved]);
 
-  /** 行间落点（同 scope 手动排序；自动排序组=仅归组语义已在 header 处理） */
+  /** 行间落点（同 scope 手动排序；跨组归入目标组后按落点插入——L2 审查修正：
+   *  先归组、后整表覆写；目标不可见/无 ord 尾部不再静默 no-op） */
   const handleDropOnRow = useCallback(async (ids: number[], targetId: number, before: boolean) => {
+    // L3：平铺态（搜索/标签/非默认排序）禁排序拖拽——矩阵锁定规则
+    if (!treeMode) return;
+    if (dropBusyRef.current) return;
     const target = notes.find((n) => n.id === targetId);
-    if (!target) return;
-    const scope = scopeKey(target.group_id ?? null);
-    const order = manualOrders[scope];
-    const movers = ids.filter((id) => !order || order.includes(id) || notes.find((n) => n.id === id)?.group_id === target.group_id);
-    const current = order ?? sections.find((s) => s.scope === scope)?.items.map((n) => n.id) ?? [];
-    // 快照语义：首次拖=自动启用（当前可见序即快照）
-    const list = (order ?? current).filter((id) => !movers.includes(id));
-    const idx = list.indexOf(targetId);
-    if (idx < 0) return;
-    list.splice(before ? idx : idx + 1, 0, ...movers);
-    // 跨组落点：先把非本组笔记归入目标组
-    for (const id of ids) {
-      const n = notes.find((x) => x.id === id);
-      if (n && (n.group_id ?? null) !== (target.group_id ?? null)) {
+    if (!target || ids.includes(targetId)) return;
+    dropBusyRef.current = true;
+    try {
+      const targetGroup = target.group_id ?? null;
+      const scope = scopeKey(targetGroup);
+      const currentList = manualOrders[scope]
+        ?? sections.find((s) => s.scope === scope)?.items.map((n) => n.id)
+        ?? [];
+      // 跨组 id：先归入目标组（await 顺序执行——同事务语义由命令层保证）
+      const external = ids.filter((id) => {
+        const n = notes.find((x) => x.id === id);
+        return n && (n.group_id ?? null) !== targetGroup;
+      });
+      for (const id of external) {
         await invoke("move_note_to_group", { noteId: id, groupId: target.group_id });
       }
+      // 落位（移出原序再插入；未启手排的 scope=快照语义自动启用）
+      const list = currentList.filter((id) => !ids.includes(id));
+      const idx = list.indexOf(targetId);
+      if (idx < 0) {
+        // 目标不可见（折叠/异常）——至少完成归组，不写序
+        onNoteMoved?.();
+        return;
+      }
+      list.splice(before ? idx : idx + 1, 0, ...ids);
+      await saveOrder(scope, list);
+      onNoteMoved?.();
+    } catch (e) {
+      console.warn("[notes] 行落点排序失败（部分操作可能已提交）:", e);
+      onNoteMoved?.();
+    } finally {
+      dropBusyRef.current = false;
     }
-    await saveOrder(scope, list);
-    onNoteMoved?.();
-  }, [notes, manualOrders, sections, saveOrder, onNoteMoved]);
+  }, [treeMode, notes, manualOrders, sections, saveOrder, onNoteMoved]);
 
-  /** 划选（组头空白起 → 组内首行至当前行带；走既有行命中的全局序） */
+  /** 划选（组头空白起 → 组内首行至当前行带；走既有行命中的全局可见序）。
+   *  L9 审查修正：rAF 节流 + pointercancel/blur/松开（buttons=0）即清理——
+   *  不再有"窗口外释放后监听永久残留、悬停任意行改写选区"的泄漏。 */
   const startMarquee = useCallback((scope: string) => {
+    // 折叠组行不可见——不提供划选起点（避免选中不可见数据）
+    const foldKey = scope === "none" ? "none" : scope.slice(2);
+    if (groupFolds[foldKey] === true) return;
     const section = sections.find((s) => s.scope === scope);
     if (!section || section.items.length === 0) return;
     const startGlobal = visibleOrder.indexOf(section.items[0].id);
     if (startGlobal < 0) return;
-    const onMove = (e: PointerEvent) => {
+
+    let raf = 0;
+    const hit = (e: PointerEvent) => {
       const el = document.elementFromPoint(e.clientX, e.clientY) as HTMLElement | null;
       const rowEl = el?.closest<HTMLElement>('[id^="note-row-"]');
       if (!rowEl) return;
@@ -326,13 +371,23 @@ export default function NoteListView({
       const hi = Math.max(startGlobal, gi);
       setSelection(new Set(visibleOrder.slice(lo, hi + 1)));
     };
-    const onUp = () => {
+    const onMove = (e: PointerEvent) => {
+      if (e.buttons === 0) { cleanup(); return; }
+      if (raf) return;
+      raf = requestAnimationFrame(() => { raf = 0; hit(e); });
+    };
+    const cleanup = () => {
+      if (raf) cancelAnimationFrame(raf);
       window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("pointerup", cleanup);
+      window.removeEventListener("pointercancel", cleanup);
+      window.removeEventListener("blur", cleanup);
     };
     window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
-  }, [sections, visibleOrder]);
+    window.addEventListener("pointerup", cleanup);
+    window.addEventListener("pointercancel", cleanup);
+    window.addEventListener("blur", cleanup);
+  }, [sections, visibleOrder, groupFolds]);
 
   const rowAccent = (n: Note) => paletteHex(noteColors?.[n.id] ?? null, theme);