Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

41.5 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";

import {
  analysisBatchSummary,
  analysisRebuildRecovery,
  bindAnalysisItemAttempt,
  cancelAnalysisBatch,
  claimAnalysisItems,
  createAnalysisBatchUndo,
  createAnalysisBatchJob,
  finalizeAnalysisRebuild,
  failAnalysisItem,
  pauseAnalysisBatch,
  previewAnalysisBatch,
  finalizePartialAnalysisRebuild,
  resumeAnalysisBatch,
  restoreAnalysisBatchUndo,
  sealAnalysisBatchUndo,
  retryFailedAnalysisItems,
  stageAnalysisRebuildResults,
  backfillLegacyAnalysisMeta,
  succeedAnalysisItem,
  textFingerprint,
  previewVisionBatch,
  createVisionBatchJob,
  previewVideoBatch,
  createVideoBatchJob,
  normalizeAnalysisBatchJob,
  reconcileVisionBatchResults,
  recoverInterruptedAnalysisBatch
} from "../extension/analysis-batch.js";
import { ANALYSIS_PROMPT_VERSION } from "../extension/deepseek.js";
import { createFixedFacetCatalog } from "../extension/tag-taxonomy.js";

const backgroundSource = await readFile(new URL("../extension/background.js", import.meta.url), "utf8");

test("analysis-file import wires the legacy baseline helper into the background runtime", () => {
  const importEnd = backgroundSource.indexOf('} from "./analysis-batch.js";');
  const importStart = backgroundSource.lastIndexOf("import {", importEnd);
  assert.ok(importStart >= 0 && importEnd > importStart);
  assert.match(backgroundSource.slice(importStart, importEnd), /backfillLegacyAnalysisMeta/);
  assert.match(backgroundSource, /await backfillLegacyAnalysisMeta\(importedEntries\)/);
});

test("vision in-flight identity includes the analysis profile and request mode", () => {
  assert.match(backgroundSource, /requestKey = `\$\{schedulerKey\}:\$\{fingerprint\}:\$\{profileFingerprint\}/);
  assert.match(backgroundSource, /:\$\{requestMode\}`/);
  assert.match(backgroundSource, /return \{[\s\S]*?ok: true,[\s\S]*?attempts: result\.attempts,[\s\S]*?quality: result\.quality/);
});

test("manual text and vision batches run from the persistent background queue", () => {
  assert.match(backgroundSource, /scheduleAnalysisBatchRunner\(\)/);
  assert.match(backgroundSource, /runPersistedTextBatchSlice\(initial\.id\)/);
  assert.match(backgroundSource, /runPersistedVisionBatchSlice\(initial\.id\)/);
  assert.match(backgroundSource, /runPersistedVideoBatchSlice\(initial\.id\)/);
  assert.match(backgroundSource, /chrome\.alarms\.create\(ANALYSIS_BATCH_ALARM/);
});

test("video batch preview selects primary local videos and excludes current reconstructions by default", () => {
  const entries = [{
    id: "case:video",
    primaryMediaId: "video:primary",
    mediaAssets: [
      { id: "video:primary", kind: "video", storageMode: "managed", mimeType: "video/mp4", byteSize: 12, durationMs: 1000 },
      { id: "video:second", kind: "video", storageMode: "managed", mimeType: "video/mp4", byteSize: 20 },
      { id: "image:one", kind: "image", storageMode: "managed" }
    ],
    videoAnalyses: [{
      id: "analysis:old",
      assetId: "video:second",
      mode: "visual-reconstruction",
      contractVersion: "visual-reconstruction-tags-json-v3-1-evidence-guard",
      reconstructionPrompt: "第二支视频已有逆推",
      tags: [{ g: "visual.style", t: "写实" }],
      uncertainties: [],
      analysisScope: "visual",
      finishReason: "stop",
      createdAt: "2026-08-30T00:00:00.000Z"
    }]
  }];
  const primary = previewVideoBatch(entries, {
    entryIds: ["case:video"],
    sendableAssetIds: ["video:primary", "video:second"],
    providerId: "zhipu",
    model: "glm-5.3-flash",
    concurrency: 2
  });
  assert.deepEqual(primary.items.map((item) => item.assetId), ["video:primary"]);
  assert.equal(primary.totalBytes, 12);
  assert.equal(primary.knownDurationMs, 1000);

  const all = previewVideoBatch(entries, {
    entryIds: ["case:video"],
    sendableAssetIds: ["video:primary", "video:second"],
    includeAllVideos: true,
    reanalyze: true,
    providerId: "zhipu",
    model: "glm-5.3-flash",
    protocol: "chat_completions",
    sourcePlan: "local-video",
    endpoint: "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    localVideo: "base64",
    preferPublicVideoUrl: false,
    publicVideoUrl: "direct",
    assetSnapshots: [
      { entryId: "case:video", assetId: "video:primary", byteSize: 120, durationMs: 1100, fingerprint: "hash-primary" },
      { entryId: "case:video", assetId: "video:second", byteSize: 240, durationMs: 2200, fingerprint: "hash-second" }
    ]
  });
  assert.deepEqual(all.items.map((item) => item.assetId), ["video:primary", "video:second"]);
  const job = createVideoBatchJob(entries, {
    ...all,
    entryIds: ["case:video"],
    sendableAssetIds: ["video:primary", "video:second"],
    includeAllVideos: true,
    reanalyze: true,
    protocol: all.protocol,
    sourcePlan: all.sourcePlan,
    assetSnapshots: all.items,
    instruction: "批量逆推可见画面"
  });
  assert.equal(job.kind, "video");
  assert.equal(job.concurrency, 2);
  assert.equal(job.items.length, 2);
  assert.equal(job.protocol, "chat_completions");
  assert.equal(job.sourcePlan, "local-video");
  assert.equal(job.endpoint, "https://open.bigmodel.cn/api/paas/v4/chat/completions");
  assert.equal(job.localVideo, "base64");
  assert.equal(job.preferPublicVideoUrl, false);
  assert.equal(job.publicVideoUrl, "direct");
  assert.deepEqual(job.items.map((item) => item.sourcePlan), ["local-video", "local-video"]);
  assert.deepEqual(job.items.map((item) => item.fingerprint), ["hash-primary", "hash-second"]);
  const claimed = claimAnalysisItems(job, 2, () => "claim:video");
  const first = succeedAnalysisItem(claimed.job, "case:video", "claim:video", {
    promptTokens: 10,
    completionTokens: 20,
    totalTokens: 30
  }, undefined, { serviceRequests: 1, cost: 0.25 });
  const secondItem = first.items.find((item) => item.assetId === "video:second");
  const completed = succeedAnalysisItem(first, "case:video", secondItem.claimId, {}, undefined, {
    serviceRequests: 1,
    cost: null
  });
  const summary = analysisBatchSummary(completed);
  assert.equal(summary.totalCost, 0.25);
  assert.equal(summary.unknownCostCount, 1);
  assert.equal(summary.requestAttempts, 2);
});

test("video batch binds the exact task and attempt and retries only selected failures", () => {
  const entries = [{
    id: "case:video",
    primaryMediaId: "video:a",
    mediaAssets: [
      { id: "video:a", kind: "video", usage: "content", storageMode: "managed" },
      { id: "video:b", kind: "video", usage: "content", storageMode: "managed" }
    ]
  }];
  let job = createVideoBatchJob(entries, {
    id: "video-selective-retry",
    entryIds: ["case:video"],
    includeAllVideos: true,
    reanalyze: true,
    sendableAssetIds: ["video:a", "video:b"],
    assetSnapshots: [
      { entryId: "case:video", assetId: "video:a", fingerprint: "hash-a" },
      { entryId: "case:video", assetId: "video:b", fingerprint: "hash-b" }
    ],
    instruction: "逆推"
  });
  let claimed = claimAnalysisItems(job, 2, (() => { let index = 0; return () => `claim-${++index}`; })());
  job = bindAnalysisItemAttempt(claimed.job, "case:video", "claim-1", {
    taskId: "task-a",
    attemptId: "attempt-a",
    requestId: "attempt-a"
  });
  assert.deepEqual(
    Object.fromEntries(["taskId", "attemptId", "requestId"].map((key) => [key, job.items[0][key]])),
    { taskId: "task-a", attemptId: "attempt-a", requestId: "attempt-a" }
  );
  job = failAnalysisItem(job, "case:video", "claim-1", { message: "状态未知,服务商可能已收到", status: 0 });
  job = failAnalysisItem(job, "case:video", "claim-2", { message: "格式错误", status: 422 });
  assert.throws(() => retryFailedAnalysisItems(job, {
    itemKeys: ["case:video\u0000video:a"],
    requireSelection: true
  }), /确认可能重复计费/);
  job = retryFailedAnalysisItems(job, {
    itemKeys: ["case:video\u0000video:b"],
    requireSelection: true,
    confirmDuplicateCharge: false
  });
  assert.equal(job.items[0].status, "failed");
  assert.equal(job.items[1].status, "pending");
  assert.equal(job.items[1].taskId, "");
});

test("batch preview selects only text cases that are new or changed", async () => {
  const unchanged = await textFingerprint("same prompt");
  const preview = await previewAnalysisBatch([
    {
      id: "same",
      text: "same prompt",
      analysisMeta: { textFingerprint: unchanged, promptVersion: ANALYSIS_PROMPT_VERSION },
      facetAssignments: [{ source: "deepseek_text", nodeId: "node:same" }]
    },
    {
      id: "changed",
      text: "new prompt",
      textRevision: 2,
      analysisMeta: { textRevision: 1, textFingerprint: "old", promptVersion: ANALYSIS_PROMPT_VERSION },
      facetAssignments: [{ source: "deepseek_text", nodeId: "node:changed" }]
    },
    { id: "new", text: "first analysis" },
    { id: "image", text: "" }
  ]);
  assert.deepEqual(preview.entries.map((item) => item.entryId), ["changed", "new"]);
  assert.equal(preview.totalCharacters, "new prompt".length + "first analysis".length);
  assert.deepEqual(preview.reasonCounts, { missing_analysis: 1, text_changed: 1, explicit_reanalysis: 0 });
});

test("batch preview uses the same canonical primary-image prompt and revision as detail analysis", async () => {
  const entry = {
    id: "media-prompt",
    title: "带逐图提示词",
    text: "",
    primaryMediaId: "image-b",
    mediaAssets: [
      { id: "image-a", kind: "image" },
      { id: "image-b", kind: "image" }
    ],
    mediaPrompts: [
      { assetId: "image-b", text: "当前图片提示词", updatedAt: "2026-08-21T09:30:00.000Z" }
    ],
    facetAssignments: []
  };
  const preview = await previewAnalysisBatch([entry]);
  assert.deepEqual(preview.entries.map((item) => ({
    entryId: item.entryId,
    textRevision: item.textRevision,
    characterCount: item.characterCount,
    reason: item.reason
  })), [{
    entryId: "media-prompt",
    textRevision: Date.parse("2026-08-21T09:30:00.000Z"),
    characterCount: "当前图片提示词".length,
    reason: "missing_analysis"
  }]);
});

test("analysis profile changes never queue unchanged text in the default incremental preview", async () => {
  const unchanged = await textFingerprint("same prompt");
  const preview = await previewAnalysisBatch([{
    id: "same",
    text: "same prompt",
    analysisMeta: { textFingerprint: unchanged, promptVersion: ANALYSIS_PROMPT_VERSION, profileFingerprint: "old-profile" },
    facetAssignments: [{ source: "deepseek_text", nodeId: "node:same" }]
  }], { profileFingerprint: "new-profile" });
  assert.equal(preview.mode, "incremental");
  assert.equal(preview.caseCount, 0);
});

test("6500 never-analysed entries preview without precomputing fingerprints", async () => {
  const entries = Array.from({ length: 6500 }, (_, index) => ({ id: `new-${index}`, text: `prompt ${index}` }));
  const preview = await previewAnalysisBatch(entries);
  assert.equal(preview.caseCount, 6500);
  assert.ok(preview.entries.every((item) => !item.fingerprint));
  assert.ok(preview.entries.every((item) => item.textRevision === 1));
});

test("explicit rebuild queues completed text and remains separate from incremental work", async () => {
  const unchanged = await textFingerprint("same prompt");
  const preview = await previewAnalysisBatch([{
    id: "same",
    text: "same prompt",
    analysisMeta: { textFingerprint: unchanged, promptVersion: ANALYSIS_PROMPT_VERSION, profileFingerprint: "old-profile" }
  }], { mode: "reanalyze", profileFingerprint: "new-profile" });
  assert.equal(preview.mode, "rebuild");
  assert.equal(preview.caseCount, 1);
  assert.equal(preview.entries[0].reason, "explicit_reanalysis");
  assert.deepEqual(preview.reasonCounts, { missing_analysis: 0, text_changed: 0, explicit_reanalysis: 1 });
});

test("rebuild stages failures without changing the live library and switches only after every retry succeeds", async () => {
  const originalState = {
    facetCatalog: createFixedFacetCatalog(),
    entries: [
      { id: "a", text: "cel shaded hero", facetAssignments: [{ facetId: "style", nodeId: "style.medium", status: "confirmed", source: "manual" }] },
      { id: "b", text: "misty courtyard", facetAssignments: [] }
    ]
  };
  const originalSnapshot = structuredClone(originalState);
  let job = await createAnalysisBatchJob(originalState.entries, { id: "rebuild", mode: "rebuild", profileFingerprint: "profile" });
  let claimed = claimAnalysisItems(job, 2, (() => { let index = 0; return () => `claim-${++index}`; })());
  let staged = await stageAnalysisRebuildResults(claimed.job, null, originalState, [
    { entryId: "a", claimId: "claim-1", textRevision: 1, tags: [{ g: "style.render", t: "赛璐珞" }], model: "model", usage: { totalTokens: 12 } },
    { entryId: "b", claimId: "claim-2", textRevision: 1, error: { message: "busy", status: 503 } }
  ]);
  assert.deepEqual(originalState, originalSnapshot);
  assert.equal(analysisBatchSummary(staged.job).counts.failed, 1);
  await assert.rejects(() => finalizeAnalysisRebuild(staged.job, staged.staging, originalState), /尚未全部成功/);

  job = retryFailedAnalysisItems(staged.job);
  claimed = claimAnalysisItems(job, 1, () => "retry-b");
  staged = await stageAnalysisRebuildResults(claimed.job, structuredClone(staged.staging), originalState, [{
    entryId: "b", claimId: "retry-b", textRevision: 1,
    tags: [{ g: "scene.place", t: "庭院" }], model: "model", usage: { totalTokens: 9 }
  }]);
  const finalized = await finalizeAnalysisRebuild(staged.job, staged.staging, originalState, "2026-08-03T00:00:00.000Z");
  assert.deepEqual(originalState, originalSnapshot);
  assert.equal(finalized.state.entries[0].facetAssignments.some((item) => item.source === "manual"), true);
  assert.equal(finalized.state.entries.every((entry) => entry.analysisPending === false), true);
  assert.equal(finalized.state.facetCatalog.facets.length, 10);
  assert.equal(finalized.job.status, "completed");
});

test("rebuild undo snapshots every case including image-only labels and custom labels", async () => {
  const original = {
    facetCatalog: createFixedFacetCatalog(),
    entries: [
      {
        id: "text", text: "hero", customLabels: ["文本自定义"],
        facetAssignments: [{ facetId: "subject", nodeId: "subject.character", status: "confirmed", source: "manual" }]
      },
      {
        id: "image", text: "", customLabels: ["纯图片自定义"],
        facetAssignments: [{ facetId: "style", nodeId: "style.medium", status: "confirmed", source: "vision_model" }]
      }
    ]
  };
  const job = await createAnalysisBatchJob(original.entries, { id: "rebuild-undo", mode: "rebuild" });
  const undo = createAnalysisBatchUndo(job, original);
  assert.deepEqual(undo.entries.map((item) => item.entryId), ["text", "image"]);

  const changed = structuredClone(original);
  changed.facetCatalog = createFixedFacetCatalog();
  changed.facetCatalog.revision = 99;
  changed.entries[0].facetAssignments = [];
  changed.entries[0].customLabels = ["changed"];
  changed.entries[1].facetAssignments = [];
  changed.entries[1].customLabels = ["changed"];
  const sealed = sealAnalysisBatchUndo(undo, changed, ["text", "image"]);
  const restored = restoreAnalysisBatchUndo(changed, sealed);

  assert.deepEqual(restored.facetCatalog, original.facetCatalog);
  assert.deepEqual(restored.entries.map((item) => item.facetAssignments), original.entries.map((item) => item.facetAssignments));
  assert.deepEqual(restored.entries.map((item) => item.customLabels), original.entries.map((item) => item.customLabels));

  const editedLater = structuredClone(changed);
  editedLater.entries[0].customLabels.push("用户后来补的标签");
  assert.throws(() => restoreAnalysisBatchUndo(editedLater, sealed), /后来修改/);
  assert.throws(() => restoreAnalysisBatchUndo(changed, undo), /无法安全撤回/);
  assert.throws(() => restoreAnalysisBatchUndo({ ...changed, entries: [...changed.entries, { id: "later" }] }, sealed), /案例清单发生变化/);
});

test("matching text and analysis profile do not queue a paid request", async () => {
  const unchanged = await textFingerprint("same prompt");
  const preview = await previewAnalysisBatch([{
    id: "same",
    text: "same prompt",
    analysisMeta: { textFingerprint: unchanged, profileFingerprint: "same-profile" },
    facetAssignments: [{ source: "deepseek_text", nodeId: "node:same" }]
  }], { profileFingerprint: "same-profile" });
  assert.equal(preview.caseCount, 0);
});

test("legacy DeepSeek results receive a text baseline instead of being sent again", async () => {
  const legacy = Array.from({ length: 74 }, (_, index) => ({
    id: `legacy-${index}`,
    text: `prompt ${index}`,
    analyzedAt: "2026-07-18T00:00:00.000Z",
    facetAssignments: [{ source: "deepseek_text", status: "confirmed", nodeId: `node-${index}` }]
  }));
  const baseline = await backfillLegacyAnalysisMeta(legacy);
  const preview = await previewAnalysisBatch(baseline.entries);
  assert.equal(baseline.updatedCount, 74);
  assert.equal(preview.caseCount, 0);
  assert.equal(baseline.entries[0].analysisMeta.textRevision, 1);
  assert.equal(baseline.entries[0].analysisMeta.textFingerprint, undefined);
});

test("dangling text analysis metadata is still queued until committed deepseek tags exist", async () => {
  const preview = await previewAnalysisBatch([{
    id: "dangling",
    text: "共享提示词",
    textRevision: 4,
    analysisMeta: { textRevision: 4, model: "old" },
    analyzedAt: "2026-08-21T00:00:00.000Z",
    facetAssignments: []
  }]);
  assert.deepEqual(preview.entries.map((item) => item.entryId), ["dangling"]);
  assert.deepEqual(preview.reasonCounts, { missing_analysis: 1, text_changed: 0, explicit_reanalysis: 0 });
});

test("vision preview skips only analyses with a reusable reconstruction prompt and tags", () => {
  const preview = previewVisionBatch([{
    id: "case",
    title: "视觉案例",
    primaryMediaId: "image-a",
    mediaAssets: [
      {
        id: "image-a",
        kind: "image",
        visionAnalysis: {
          version: 2,
          description: "只有描述",
          reconstructionPrompt: "只有反推提示词但没有本图标签",
          quality: "complete"
        }
      },
      {
        id: "image-b",
        kind: "image",
        visionAnalysis: {
          version: 2,
          description: "完整分析",
          reconstructionPrompt: "可复用提示词",
          tags: [{ g: "style.render", t: "赛璐珞" }],
          quality: "complete"
        }
      },
      {
        id: "image-c",
        kind: "image",
        visionAnalysis: {
          version: 2,
          description: "partial",
          reconstructionPrompt: "不应视为完成",
          tags: [{ g: "style.render", t: "赛璐珞" }],
          quality: "partial"
        }
      }
    ],
    facetAssignments: [{ source: "vision_model", visualId: "image-b", nodeId: "style.render" }]
  }], {
    entryIds: ["case"],
    includeAllImages: true,
    reanalyze: false
  });
  assert.equal(preview.skippedAnalyzedCount, 1);
  assert.deepEqual(preview.items.map((item) => item.visualId), ["image-a", "image-c"]);
});

test("pausing and immediately resuming preserves active claims to prevent duplicate paid requests", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }, { id: "b", text: "two" }], { id: "job", now: "2026-07-18T00:00:00Z", outputLocale: "en" });
  assert.equal(job.outputLocale, "en");
  const claimed = claimAnalysisItems(job, 1, () => "claim-a");
  job = claimed.job;
  assert.equal(claimed.claims[0].entryId, "a");
  assert.equal(job.items[0].status, "running");

  job = pauseAnalysisBatch(job);
  job = resumeAnalysisBatch(job);
  assert.equal(job.items[0].status, "running");
  assert.equal(job.items[0].claimId, "claim-a");
  assert.equal(job.status, "running");
  job = succeedAnalysisItem(job, "a", "claim-a", {}, 1);
  assert.equal(job.items[0].status, "succeeded");
});

test("recovery preserves completed work and never resends an unknown paid request", async () => {
  const entries = Array.from({ length: 591 }, (_, index) => ({ id: `case-${index}`, text: `prompt ${index}` }));
  const job = await createAnalysisBatchJob(entries, { id: "stalled-rebuild", mode: "rebuild" });
  for (let index = 0; index < 586; index += 1) job.items[index].status = "succeeded";
  for (let index = 586; index < 589; index += 1) {
    job.items[index].status = "running";
    job.items[index].claimId = `old-claim-${index}`;
  }

  const recovered = recoverInterruptedAnalysisBatch(job);
  const summary = analysisBatchSummary(recovered);
  assert.deepEqual(summary.counts, { pending: 2, running: 0, succeeded: 586, partial: 0, failed: 3 });
  assert.match(recovered.items[586].error, /状态未知.*未自动重试/);
  assert.equal(recovered.items[586].claimId, "");
  assert.equal(summary.status, "running");
});

test("rebuild recovery requires every successful case to exist in the matching staging area", async () => {
  const entries = [{ id: "saved", text: "one" }, { id: "failed", text: "two" }];
  const job = await createAnalysisBatchJob(entries, { id: "recoverable", mode: "rebuild" });
  job.status = "completed";
  job.items[0].status = "succeeded";
  job.items[1].status = "failed";
  job.items[1].error = "AI returned an unknown path";

  assert.deepEqual(analysisRebuildRecovery(job, {
    version: 1,
    jobId: "recoverable",
    results: { saved: { tags: [] } }
  }), {
    stagedResultCount: 1,
    stagingValid: true,
    recoverable: true
  });
  assert.deepEqual(analysisRebuildRecovery(job, {
    version: 1,
    jobId: "recoverable",
    results: {}
  }), {
    stagedResultCount: 0,
    stagingValid: false,
    recoverable: false
  });
});

test("a confirmed partial rebuild applies staged successes and leaves failures pending on the new tree", async () => {
  const state = {
    facetCatalog: createFixedFacetCatalog(),
    entries: [
      {
        id: "saved", text: "cel shaded hero",
        facetAssignments: [
          { facetId: "style", nodeId: "style.medium", status: "confirmed", source: "manual" },
          { facetId: "style", nodeId: "style.render", status: "confirmed", source: "deepseek_text" }
        ]
      },
      {
        id: "failed", text: "misty courtyard", analyzedAt: "old", analysisMeta: { promptVersion: 1 },
        facetAssignments: [
          { facetId: "scene", nodeId: "scene.place", status: "confirmed", source: "deepseek_text" },
          { facetId: "light", nodeId: "light.source", status: "confirmed", source: "vision_model" }
        ]
      },
      { id: "new-after-start", text: "new prompt", facetAssignments: [] }
    ]
  };
  const job = await createAnalysisBatchJob(state.entries.slice(0, 2), { id: "partial", mode: "rebuild" });
  job.status = "completed";
  job.items[0].status = "succeeded";
  job.items[1].status = "failed";
  job.items[1].error = "invalid response";
  const staging = {
    version: 1,
    jobId: "partial",
    results: {
      saved: {
        tags: [{ g: "style.render", t: "赛璐珞" }],
        fingerprint: await textFingerprint(state.entries[0].text),
        textRevision: 1,
        model: "model",
        usage: { totalTokens: 10 }
      }
    }
  };

  const finalized = await finalizePartialAnalysisRebuild(job, staging, state, "2026-08-03T01:00:00.000Z");
  const saved = finalized.state.entries.find((entry) => entry.id === "saved");
  const failed = finalized.state.entries.find((entry) => entry.id === "failed");
  const added = finalized.state.entries.find((entry) => entry.id === "new-after-start");

  assert.equal(finalized.job.partialApplied, true);
  assert.equal(saved.analysisPending, false);
  assert.equal(saved.facetAssignments.some((item) => item.source === "manual"), true);
  assert.equal(saved.facetAssignments.some((item) => item.source === "deepseek_text"), true);
  assert.equal(failed.analysisPending, true);
  assert.equal(failed.facetAssignments.some((item) => item.source === "deepseek_text"), false);
  assert.equal(failed.facetAssignments.some((item) => item.source === "vision_model"), true);
  assert.equal(failed.analysisMeta, null);
  assert.equal(added.analysisPending, true);
  assert.equal(finalized.state.facetCatalog.facets.length, 10);
});

test("batch success totals usage and failures can be retried", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }, { id: "b", text: "two" }], { id: "job" });
  let claimed = claimAnalysisItems(job, 2, (() => { let index = 0; return () => `claim-${++index}`; })());
  job = succeedAnalysisItem(claimed.job, "a", "claim-1", { totalTokens: 12, cacheHitTokens: 7 }, 4);
  job = failAnalysisItem(job, "b", "claim-2", { message: "busy", status: 503 });
  let summary = analysisBatchSummary(job);
  assert.equal(summary.status, "partial");
  assert.equal(summary.counts.succeeded, 1);
  assert.equal(summary.counts.failed, 1);
  assert.equal(summary.usage.totalTokens, 12);

  job = retryFailedAnalysisItems(job);
  assert.equal(job.status, "running");
  assert.equal(job.items[1].status, "pending");
  job = cancelAnalysisBatch(job);
  assert.equal(job.status, "canceled");
});

test("failed analysis records token usage from rejected model output", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "failed-usage" });
  job = claimAnalysisItems(job, 1, () => "claim").job;
  job = failAnalysisItem(job, "a", "claim", {
    message: "AI 必须返回 1–10 个标签,本次没有写入",
    status: 422,
    usage: { promptTokens: 18, completionTokens: 2, totalTokens: 20, cacheHitTokens: 7 }
  });

  assert.equal(job.usage.promptTokens, 18);
  assert.equal(job.usage.completionTokens, 2);
  assert.equal(job.usage.totalTokens, 20);
  assert.equal(job.usage.cacheHitTokens, 7);
});

test("authentication failures pause the whole batch", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "job" });
  const claimed = claimAnalysisItems(job, 1, () => "claim");
  job = failAnalysisItem(claimed.job, "a", "claim", { message: "bad key", status: 401 });
  assert.equal(job.status, "paused");
  assert.equal(job.items[0].status, "failed");
});

test("rate limits and service errors after exhausted retries pause text, vision and video batches before more paid requests", async () => {
  const visionEntries = [{ id: "a", mediaAssets: [{ id: "a-img", kind: "image", usage: "content" }, { id: "a-img-2", kind: "image", usage: "content" }] }];
  const videoEntries = [{ id: "v", mediaAssets: [
    { id: "v-one", kind: "video", usage: "content", storageMode: "managed" },
    { id: "v-two", kind: "video", usage: "content", storageMode: "managed" }
  ] }];
  const jobs = [
    await createAnalysisBatchJob([{ id: "a", text: "one" }, { id: "b", text: "two" }], { id: "text" }),
    createVisionBatchJob(visionEntries, { id: "vision", entryIds: ["a"], includeAllImages: true, providerType: "openai", model: "vision-model" }),
    createVideoBatchJob(videoEntries, { id: "video", entryIds: ["v"], includeAllVideos: true, sendableAssetIds: ["v-one", "v-two"] })
  ];
  for (const status of [429, 500, 502, 503, 504]) {
    for (const created of jobs) {
      const claimed = claimAnalysisItems(structuredClone(created), 1, () => "claim");
      const [claim] = claimed.claims;
      const failed = failAnalysisItem(claimed.job, claim.entryId, "claim", { message: "busy", status });
      assert.equal(failed.status, "paused", `${created.kind} ${status}`);
      assert.equal(claimAnalysisItems(failed, 5, () => "next").claims.length, 0, "a paused batch must not claim another paid item");
      const resumed = resumeAnalysisBatch(failed);
      assert.equal(resumed.status, "running");
      assert.equal(claimAnalysisItems(resumed, 5, () => "next").claims.length, 1);
    }
  }
});

test("a final rate-limited item settles the batch instead of leaving an empty paused job", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "last" });
  job = claimAnalysisItems(job, 1, () => "claim").job;
  job = failAnalysisItem(job, "a", "claim", { message: "busy", status: 429 });
  assert.equal(job.status, "failed");
});

test("settled batch status distinguishes complete, partial, and failed outcomes", async () => {
  let mixed = await createAnalysisBatchJob([{ id: "a", text: "one" }, { id: "b", text: "two" }], { id: "mixed" });
  let claims = claimAnalysisItems(mixed, 2, (() => { let index = 0; return () => `mixed-${++index}`; })());
  mixed = succeedAnalysisItem(claims.job, "a", "mixed-1", { totalTokens: 1 });
  mixed = failAnalysisItem(mixed, "b", "mixed-2", { message: "bad json", status: 422 });
  assert.equal(mixed.status, "partial");

  let failed = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "failed" });
  claims = claimAnalysisItems(failed, 1, () => "failed-1");
  failed = failAnalysisItem(claims.job, "a", "failed-1", { message: "bad json", status: 422 });
  assert.equal(failed.status, "failed");

  let complete = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "complete" });
  claims = claimAnalysisItems(complete, 1, () => "complete-1");
  complete = succeedAnalysisItem(claims.job, "a", "complete-1", { totalTokens: 1 });
  assert.equal(complete.status, "completed");
});

test("legacy incomplete text items migrate to failures and retry without a partial state", () => {
  let job = normalizeAnalysisBatchJob({
    version: 2,
    kind: "text_tags",
    id: "saved-partial",
    status: "partial",
    items: [
      { entryId: "a", status: "succeeded", attempts: 1 },
      { entryId: "b", status: "partial", attempts: 1, error: "分析结果待补全" }
    ]
  });
  assert.deepEqual(analysisBatchSummary(job).counts, { pending: 0, running: 0, succeeded: 1, partial: 0, failed: 1 });
  assert.match(job.items[1].error, /不完整.*重试/);

  job = retryFailedAnalysisItems(job);
  assert.equal(job.items[0].status, "succeeded");
  assert.equal(job.items[1].status, "pending");
  assert.equal(job.status, "running");
});

test("batch summary exposes actual requests, output corrections, cache hits, and failure categories", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }, { id: "b", text: "two" }], { id: "execution-diagnostics" });
  const claims = claimAnalysisItems(job, 2, (() => { let index = 0; return () => `diag-${++index}`; })());
  job = succeedAnalysisItem(claims.job, "a", "diag-1", {}, undefined, {
    attempts: { serviceRequests: 0, outputCorrectionRequests: 0 }, cacheHit: true
  });
  job = failAnalysisItem(job, "b", "diag-2", {
    message: "rate limited", status: 429, attempts: { serviceRequests: 3, outputCorrectionRequests: 1 }
  });
  const summary = analysisBatchSummary(job);
  assert.equal(summary.requestAttempts, 3);
  assert.equal(summary.outputCorrectionRequests, 1);
  assert.equal(summary.cacheHitCount, 1);
  assert.deepEqual(summary.failureCategories, { rate_limit: 1 });
});

test("retry keeps lifetime request and correction counts instead of hiding earlier paid attempts", async () => {
  let job = await createAnalysisBatchJob([{ id: "a", text: "one" }], { id: "lifetime-counts" });
  let claimed = claimAnalysisItems(job, 1, () => "claim-1");
  job = failAnalysisItem(claimed.job, "a", "claim-1", {
    message: "busy", status: 503, attempts: { serviceRequests: 3, outputCorrectionRequests: 1 }
  });
  job = retryFailedAnalysisItems(job);
  claimed = claimAnalysisItems(job, 1, () => "claim-2");
  job = succeedAnalysisItem(claimed.job, "a", "claim-2", {}, 1, {
    attempts: { serviceRequests: 1, outputCorrectionRequests: 0 }, cacheHit: true
  });
  const summary = analysisBatchSummary(job);
  assert.equal(summary.requestAttempts, 4);
  assert.equal(summary.outputCorrectionRequests, 1);
  assert.equal(summary.cacheHitCount, 1);
});

test("batch jobs snapshot configured concurrency and vision claims use it", () => {
  const job = createVisionBatchJob([{
    id: "one",
    primaryMediaId: "image-1",
    mediaAssets: Array.from({ length: 12 }, (_, index) => ({ id: `image-${index + 1}`, kind: "image", usage: "content" }))
  }], {
    id: "vision-concurrency",
    entryIds: ["one"],
    includeAllImages: true,
    concurrency: 10
  });
  assert.equal(job.concurrency, 10);
  assert.deepEqual(job.retryPolicy, {
    serviceRetries: 2,
    outputCorrectionRequests: 1,
    maxProviderCallsPerItem: 3,
    backoffMs: [1000, 3000],
    obeyRetryAfter: true
  });
  assert.equal(job.outputProtocol, "json_object");
  assert.equal(claimAnalysisItems(job).claims.length, 10);
});

test("vision batch defaults to one primary image per selected case and can include every unanalysed image", async () => {
  const entries = [{
    id: "one",
    primaryMediaId: "one-a",
    mediaAssets: [
      { id: "one-a", kind: "image", usage: "content" },
      {
        id: "one-b",
        kind: "image",
        usage: "content",
        visionAnalysis: {
          description: "already analysed",
          reconstructionPrompt: "可复用提示词",
          tags: [{ g: "style.render", t: "赛璐珞" }],
          quality: "complete"
        }
      },
      { id: "one-c", kind: "image", usage: "content", visionAnalysis: { description: "usable partial", quality: "partial", missingFields: ["canvas"] } },
      { id: "one-poster", kind: "image", usage: "poster" }
    ]
  }, {
    id: "two",
    primaryMediaId: "two-a",
    mediaAssets: [{ id: "two-a", kind: "image", usage: "content" }]
  }];
  const primary = previewVisionBatch(entries, {
    entryIds: ["one", "two"],
    includeAllImages: false,
    reanalyze: false,
    providerType: "compatible",
    model: "vision-model"
  });
  assert.deepEqual(primary.items.map((item) => item.visualId), ["one-a", "two-a"]);

  const all = previewVisionBatch(entries, {
    entryIds: ["one", "two"],
    includeAllImages: true,
    reanalyze: false
  });
  assert.deepEqual(all.items.map((item) => item.visualId), ["one-a", "one-c", "two-a"]);
  assert.equal(all.skippedAnalyzedCount, 1);

  const job = createVisionBatchJob(entries, {
    entryIds: ["one"],
    includeAllImages: true,
    reanalyze: true,
    providerType: "openai",
    model: "gpt-vision"
  });
  assert.equal(job.kind, "vision");
  assert.equal(job.items.length, 3);
  assert.equal(job.requestCount, 3);

  const firstClaim = claimAnalysisItems(job, 1, () => "claim-one");
  const afterFirst = succeedAnalysisItem(firstClaim.job, "one", "claim-one", { totalTokens: 4 });
  const secondClaim = claimAnalysisItems(afterFirst, 1, () => "claim-two");
  assert.equal(secondClaim.claims[0].visualId, "one-b");
  const afterSecond = succeedAnalysisItem(secondClaim.job, "one", "claim-two", { totalTokens: 5 });
  assert.equal(analysisBatchSummary(afterSecond).counts.succeeded, 2);
});

test("vision batch resumes after a saved result without paying for the same image twice", () => {
  const job = createVisionBatchJob([{
    id: "one",
    primaryMediaId: "one-a",
    mediaAssets: [{ id: "one-a", kind: "image", usage: "content" }]
  }], {
    id: "vision-job",
    entryIds: ["one"]
  });
  const claimed = claimAnalysisItems(job, 1, () => "claim-one");
  const reconciled = reconcileVisionBatchResults(claimed.job, [{
    id: "one",
    mediaAssets: [{
      id: "one-a",
      kind: "image",
      usage: "content",
      visionAnalysis: {
        reconstructionPrompt: "云端白龙盘旋在少女身后,电影级逆光与冷暖对比",
        tags: [{ g: "style.render", t: "电影感" }],
        batchJobId: "vision-job",
        usage: { inputTokens: 40, outputTokens: 20, totalTokens: 60 }
      }
    }]
  }]);

  assert.equal(reconciled.recoveredCount, 1);
  assert.equal(reconciled.job.status, "completed");
  assert.equal(reconciled.job.items[0].status, "succeeded");
  assert.equal(reconciled.job.usage.totalTokens, 60);
  assert.deepEqual(claimAnalysisItems(reconciled.job, 1).claims, []);
});

test("legacy partial vision items migrate to failed so the UI can retry them", () => {
  const normalized = normalizeAnalysisBatchJob({
    version: 2,
    kind: "vision",
    id: "legacy-vision",
    status: "partial",
    items: [{
      entryId: "one",
      visualId: "one-a",
      status: "partial",
      error: "分析结果待补全"
    }]
  });

  assert.equal(normalized.items[0].status, "failed");
  assert.equal(normalized.items[0].error, "旧版图片分析结果不完整,请重试");
  assert.deepEqual(analysisBatchSummary(normalized).counts, {
    pending: 0,
    running: 0,
    succeeded: 0,
    partial: 0,
    failed: 1
  });
});

test("selected text tagging retags unchanged selections, skips empty text, and never becomes a catalog rebuild", async () => {
  const entries = [
    { id: "selected", text: "same", analysisMeta: { textRevision: 1 }, facetAssignments: [{ source: "deepseek_text", nodeId: "old" }] },
    { id: "outside", text: "needs tags" },
    { id: "empty", text: "" }
  ];
  assert.deepEqual((await previewAnalysisBatch(entries)).entries.map(item => item.entryId), ["outside"]);
  const job = await createAnalysisBatchJob(entries, { mode: "selected", entryIds: ["selected", "empty"] });
  assert.deepEqual(job.items.map(item => item.entryId), ["selected"]);
  assert.equal(normalizeAnalysisBatchJob(job).mode, "selected");
  assert.equal((await previewAnalysisBatch(entries, { mode: "selected", entryIds: [] })).caseCount, 0);
  const claimed = claimAnalysisItems(job);
  const failed = failAnalysisItem(claimed.job, "selected", claimed.claims[0].claimId, { message: "test failure", status: 422 });
  assert.deepEqual(retryFailedAnalysisItems(failed).items.map(item => [item.entryId, item.status]), [["selected", "pending"]]);
});

test('a staged result cannot overwrite text edited while other cases were still being analyzed', async () => {
  const state={facetCatalog:createFixedFacetCatalog(),entries:[{id:'a',text:'原始画面',textRevision:1},{id:'b',text:'原始场景',textRevision:1}]};
  const job=await createAnalysisBatchJob(state.entries,{id:'staged-edit',mode:'rebuild'});
  const claimed=claimAnalysisItems(job,2,()=>crypto.randomUUID());
  const result=async(index)=>({entryId:claimed.claims[index].entryId,claimId:claimed.claims[index].claimId,
    textRevision:1,fingerprint:await textFingerprint(state.entries[index].text),tags:[{g:'style.render',t:'赛璐珞'}]});
  const first=await stageAnalysisRebuildResults(claimed.job,null,state,[await result(0)]);
  state.entries[0].text='用户后来修订的内容';
  // A restored or replaced record can carry the same revision: fingerprint must also match.
  const before=structuredClone(state);
  const second=await stageAnalysisRebuildResults(first.job,first.staging,state,[await result(1)]);
  assert.equal(analysisBatchSummary(second.job).counts.failed,1);
  assert.equal(second.job.items.find(i=>i.entryId==='b').status,'succeeded');
  assert.equal(second.staging.results.a,undefined);
  assert.ok(second.staging.results.b);
  assert.deepEqual(state,before);
  await assert.rejects(async()=>finalizeAnalysisRebuild(second.job,second.staging,state),/尚未全部成功/);
});

test('applying a completed staged rebuild checks its source again, including unchanged revision numbers', async () => {
  const state={facetCatalog:createFixedFacetCatalog(),entries:[{id:'a',text:'原始画面',textRevision:1}]};
  const job=await createAnalysisBatchJob(state.entries,{id:'staged-apply',mode:'rebuild'});
  const claimed=claimAnalysisItems(job,1,()=> 'claim');
  const staged=await stageAnalysisRebuildResults(claimed.job,null,state,[{entryId:'a',claimId:'claim',
    textRevision:1,fingerprint:await textFingerprint('原始画面'),tags:[{g:'style.render',t:'赛璐珞'}]}]);
  state.entries[0].text='用户替换的新内容';
  const before=structuredClone(state);
  await assert.rejects(async()=>finalizeAnalysisRebuild(staged.job,staged.staging,state),/原文已变化/);
  assert.deepEqual(state,before);
});

test('batch catalog rollback refuses to orphan a tag held by a recoverable media snapshot', async () => {
  const before = { facetCatalog: createFixedFacetCatalog(), entries: [{ id: 'target', text: '原文', facetAssignments: [] }] };
  const job = await createAnalysisBatchJob(before.entries, { id: 'trash-guard', mode: 'missing' });
  const undo = createAnalysisBatchUndo(job, before);
  const after = structuredClone(before);
  const node = { id: 'new-tag', facetId: after.facetCatalog.facets[0].id, name: '新增标签', status: 'active' };
  after.facetCatalog.nodes.push(node);
  after.entries[0].facetAssignments = [{ facetId: node.facetId, nodeId: node.id, source: 'deepseek_text' }];
  const sealed = sealAnalysisBatchUndo(undo, after, ['target']);
  const state = { ...after, trashState: { items: [{ kind: 'media', relationships: { facetAssignments: [{ nodeId: node.id, visualId: 'deleted-image' }] } }] } };
  assert.throws(() => restoreAnalysisBatchUndo(state, sealed), /回收站/);
  assert.deepEqual(state.entries, after.entries);
});

test("batch undo preserves later cases and their edits and refuses to orphan their new tags", async () => {
  const original = { facetCatalog: createFixedFacetCatalog(), entries: [{ id: "target", text: "original", facetAssignments: [] }] };
  const job = await createAnalysisBatchJob(original.entries, { id: "undo-later", mode: "missing" });
  const undo = createAnalysisBatchUndo(job, original);
  const changed = structuredClone(original);
  const tag = { id: "batch-new-tag", facetId: changed.facetCatalog.facets[0].id, name: "新增", status: "active" };
  changed.facetCatalog.nodes.push(tag);
  changed.entries[0].facetAssignments = [{ nodeId: tag.id, source: "deepseek_text" }];
  const sealed = sealAnalysisBatchUndo(undo, changed, ["target"]);
  const later = { id: "later", title: "后来编辑", text: "后来原词", customLabels: ["人工"], mediaAssets: [{ id: "original-media" }], facetAssignments: [] };
  const current = { ...changed, entries: [...changed.entries, later] };
  const restored = restoreAnalysisBatchUndo(current, sealed);
  assert.deepEqual(restored.entries.map(entry => entry.id), ["target", "later"]);
  assert.deepEqual(restored.entries[1], later);
  later.facetAssignments = [{ nodeId: tag.id, source: "manual" }];
  assert.throws(() => restoreAnalysisBatchUndo(current, sealed), /仍在使用/);
});