feat(organize): 整理记录默认按作品分组，行内显示整理方式标签与分类

学 MP 历史记录页：整理方式改为中性小标签（移动 / 复制 / 硬链接 / 原地入库），标题下显示分类（二级分类，没有时退回作品类型）。
列表缺省按作品分组：一季多集收成一组并缺省折叠，组头显示海报、作品、季集范围（S01E01–E10）、分类、条数与非成功状态；只有一条的作品和未识别记录不画组头。切换后本浏览器记住，URL ?group=entity|none 优先。
DataTable 分组追加可选项 meta / defaultCollapsed / flat（不改既有调用的表现）。

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01Cxwgnn2pbzQ7rXv3rq7fei

apps/web/app/components/organize/record-parts.test.ts

@@ -1,5 +1,21 @@
+import { OrganizationAction, type PublicOrganizationRecord } from "@umt/contracts";
 import { describe, expect, it } from "vitest";
-import { canReorganize, episodeTag, hasFiles, isRunning, recordFileProgress, recordTitle } from "./record-parts.ts";
+import { ACTION_LABEL } from "~/api/records.ts";
+import {
+  canReorganize,
+  episodeRange,
+  episodeTag,
+  GROUPING_STORAGE_KEY,
+  groupIssues,
+  hasFiles,
+  isRunning,
+  readGroupingPref,
+  recordCategory,
+  recordFileProgress,
+  recordTitle,
+  resolveGrouping,
+  writeGroupingPref,
+} from "./record-parts.ts";
 
 // HIS-1 整理记录展示小件:标题 / 季集、能否重新整理、能否连文件删除
 
@@ -65,3 +81,72 @@ describe("文件级进度", () => {
     expect(recordFileProgress({ files })).toEqual({ completed: 3, total: 5, current: "/source/3.mkv" });
   });
 });
+
+describe("整理记录列表:整理方式、分类、分组", () => {
+  it("整理方式文案覆盖全部取值,常用的四种照 glossary", () => {
+    for (const a of OrganizationAction.options) expect(ACTION_LABEL[a]).toBeTruthy();
+    expect([ACTION_LABEL.move, ACTION_LABEL.copy, ACTION_LABEL.hardlink, ACTION_LABEL.in_place]).toEqual([
+      "移动",
+      "复制",
+      "硬链接",
+      "原地入库",
+    ]);
+  });
+
+  it("分类:有二级分类用分类,没有退回作品类型,未识别为空", () => {
+    expect(recordCategory({ media: { ...media(), category: "纪录片" } })).toBe("纪录片");
+    expect(recordCategory({ media: { ...media(), category: null } })).toBe("剧集");
+    expect(recordCategory({ media: { ...media(), kind: "movie" as const } })).toBe("电影");
+    expect(recordCategory({ media: null })).toBe("");
+  });
+
+  it("季集范围:单集、同季连续、同季有缺、跨季、非剧集", () => {
+    const ep = (s: number | null, e: number | null) => media({ seasonNumber: s, episodeNumber: e });
+    expect(episodeRange([ep(1, 5)])).toBe("S01E05");
+    expect(episodeRange([3, 1, 2, 4, 5, 6, 7, 8, 9, 10].map((e) => ep(1, e)))).toBe("S01E01–E10");
+    expect(episodeRange([1, 2, 3, 5, 5].map((e) => ep(1, e)))).toBe("S01E01–E03、E05");
+    expect(episodeRange([ep(1, 9), ep(2, 1)])).toBe("S01–S02");
+    expect(episodeRange([ep(2, null)])).toBe("S02");
+    expect(episodeRange([media(), null])).toBe("");
+  });
+
+  it("组汇总只列非成功的非零项", () => {
+    const st = (...xs: PublicOrganizationRecord["status"][]) => xs.map((status) => ({ status }));
+    expect(groupIssues(st("succeeded", "succeeded"))).toEqual([]);
+    expect(groupIssues(st("succeeded", "failed", "partial", "running", "queued"))).toEqual([
+      { label: "失败", n: 1, tone: "destructive" },
+      { label: "部分成功", n: 1, tone: "warning" },
+      { label: "进行中", n: 2, tone: "neutral" },
+    ]);
+  });
+
+  it("分组缺省按作品;URL 优先,其次本浏览器记住的选择", () => {
+    expect(resolveGrouping(null, null)).toBe("entity");
+    expect(resolveGrouping("", "none")).toBe("none");
+    expect(resolveGrouping("entity", "none")).toBe("entity");
+    expect(resolveGrouping("none", null)).toBe("none");
+    expect(resolveGrouping("bogus", "bogus")).toBe("entity");
+  });
+
+  it("记住分组选择;存储不可用时不报错", () => {
+    const mem = new Map<string, string>();
+    const store = () => ({
+      getItem: (k: string) => mem.get(k) ?? null,
+      setItem: (k: string, v: string) => void mem.set(k, v),
+    });
+    expect(readGroupingPref(store)).toBeNull();
+    writeGroupingPref("none", store);
+    expect(mem.get(GROUPING_STORAGE_KEY)).toBe("none");
+    expect(resolveGrouping(null, readGroupingPref(store))).toBe("none");
+    const broken = () => ({
+      getItem: () => {
+        throw new Error("denied");
+      },
+      setItem: () => {
+        throw new Error("denied");
+      },
+    });
+    expect(readGroupingPref(broken)).toBeNull();
+    expect(() => writeGroupingPref("entity", broken)).not.toThrow();
+  });
+});

apps/web/app/components/organize/record-parts.ts

@@ -47,3 +47,85 @@ export function recordFileProgress(
     current: current?.source.path ?? current?.target.path ?? null,
   };
 }
+
+const pad = (n: number) => String(n).padStart(2, "0");
+
+/**
+ * 一组记录的季集范围(组头用):单集 S01E05;同季连续 S01E01–E10;同季有缺 S01E01–E03、E05;
+ * 跨季 S01–S02;只有季 S01;都不是剧集返回空串。
+ */
+export function episodeRange(media: ReadonlyArray<PublicOrganizationRecord["media"]>): string {
+  const pairs = media.filter((m): m is NonNullable<typeof m> => m?.seasonNumber != null);
+  if (!pairs.length) return "";
+  const seasons = [...new Set(pairs.map((m) => m.seasonNumber as number))].sort((a, b) => a - b);
+  if (seasons.length > 1) return `S${pad(seasons[0] as number)}–S${pad(seasons[seasons.length - 1] as number)}`;
+  const s = `S${pad(seasons[0] as number)}`;
+  const eps = [...new Set(pairs.map((m) => m.episodeNumber).filter((e): e is number => e != null))].sort(
+    (a, b) => a - b,
+  );
+  if (!eps.length) return s;
+  // 连续段:[1,2,3,5] → 1–3、5
+  const runs: [number, number][] = [];
+  for (const e of eps) {
+    const last = runs[runs.length - 1];
+    if (last && e === last[1] + 1) last[1] = e;
+    else runs.push([e, e]);
+  }
+  return `${s}${runs.map(([a, b]) => (a === b ? `E${pad(a)}` : `E${pad(a)}–E${pad(b)}`)).join("、")}`;
+}
+
+/** 分组汇总里要提示的状态(成功是常态不列,只列非零项) */
+export function groupIssues(
+  rows: ReadonlyArray<Pick<PublicOrganizationRecord, "status">>,
+): { label: string; n: number; tone: "destructive" | "warning" | "neutral" }[] {
+  const n = (f: (s: PublicOrganizationRecord["status"]) => boolean) => rows.filter((r) => f(r.status)).length;
+  return [
+    { label: "失败", n: n((s) => s === "failed"), tone: "destructive" as const },
+    { label: "部分成功", n: n((s) => s === "partial"), tone: "warning" as const },
+    { label: "进行中", n: n((s) => s === "queued" || s === "running"), tone: "neutral" as const },
+    { label: "已取消", n: n((s) => s === "cancelled"), tone: "neutral" as const },
+  ].filter((x) => x.n > 0);
+}
+
+const MEDIA_KIND_LABEL: Record<NonNullable<PublicOrganizationRecord["media"]>["kind"], string> = {
+  movie: "电影",
+  series: "剧集",
+  variety: "综艺",
+  collection: "合集",
+  other: "其他",
+};
+
+/** 分类(照 MP 历史记录的「纪录片 / 欧美电影」):整理时的二级分类,没有时退回作品类型;未识别为空串 */
+export function recordCategory(r: Pick<PublicOrganizationRecord, "media">): string {
+  if (!r.media) return "";
+  return r.media.category || MEDIA_KIND_LABEL[r.media.kind];
+}
+
+// ── 列表分组偏好:URL ?group= 优先(entity / none),没有时用本浏览器记住的选择,缺省按作品分组 ──
+
+export type RecordGrouping = "entity" | "none";
+export const GROUPING_STORAGE_KEY = "umt.organize.records-group";
+
+export function resolveGrouping(param: string | null | undefined, stored: string | null | undefined): RecordGrouping {
+  if (param === "entity" || param === "none") return param;
+  return stored === "none" ? "none" : "entity";
+}
+
+type PrefStore = Pick<Storage, "getItem" | "setItem">;
+const prefStore = (): PrefStore | undefined => globalThis.localStorage;
+
+export function readGroupingPref(store = prefStore): string | null {
+  try {
+    return store()?.getItem(GROUPING_STORAGE_KEY) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeGroupingPref(v: RecordGrouping, store = prefStore): void {
+  try {
+    store()?.setItem(GROUPING_STORAGE_KEY, v);
+  } catch {
+    // 私密窗口 / 配额满:只是不记住
+  }
+}