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. 提示词导演

64.5 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";

import {
  mergeLibraryPackage,
  parseCompleteFolderBackup,
  parseLibraryPackage,
  projectPackageEntryIds,
  selectLibraryPackage,
  selectProjectPackage
} from "../extension/library-package.js";
import { createDefaultFacetCatalog, createFacet, createFacetNode } from "../extension/facets.js";
import { CONTENT_IDS, CONTENT_ROLES, SCHEMA_VERSION, createContentType, createDefaultTaxonomy } from "../extension/taxonomy.js";
import { COMPOSER_METHOD_VERSION, createComposerSession, normalizeComposerSettings } from "../extension/composer.js";
import { createZipBlob, readZipBlob } from "../extension/zip.js";
import { DEFAULT_SETTINGS } from "../extension/lib.js";

function packageData(entries, facetCatalog) {
  return {
    format: "prompt-case-library",
    version: 3,
    settings: { libraryTitle: "我的灵感库", outputPath: "提示词案例库/案例库.zip" },
    taxonomy: createDefaultTaxonomy(),
    facetCatalog,
    classificationRules: [{ hostname: "example.com", pathIds: [CONTENT_IDS.promptImage], enabled: true }],
    organizerState: {
      collections: [{ id: "collection:project", name: "项目", order: 0, entryIds: entries.map((item) => item.id) }]
    },
    entries
  };
}

function entry(id, nodeId = "tag:epic") {
  return {
    id,
    schemaVersion: 5,
    title: `案例 ${id}`,
    text: `prompt ${id}`,
    url: `https://example.com/${id}`,
    savedAt: "2026-07-18T10:00:00.000Z",
    hasScreenshot: true,
    screenshotPath: `images/${id}.webp`,
    classification: { pathIds: [CONTENT_IDS.promptImage], status: "confirmed", source: "manual" },
    facetAssignments: [{ facetId: "facet:mood", nodeId, status: "confirmed", source: "manual" }]
  };
}

function catalog() {
  let value = createFacet(createDefaultFacetCatalog(), { id: "facet:mood", name: "画面情绪", color: "#7755aa" });
  value = createFacetNode(value, { id: "tag:dramatic", facetId: "facet:mood", name: "戏剧性" });
  return createFacetNode(value, { id: "tag:epic", facetId: "facet:mood", parentId: "tag:dramatic", name: "史诗" });
}

test("webpage prompt provenance survives a portable package and media identity collisions", () => {
  const data = packageData([{ ...entry("remote"), hasScreenshot: false, screenshotPath: undefined,
    mediaAssets: [{ id: "shared-image", kind: "image", storageMode: "managed", sourceUrl: "https://example.com/remote.png", mimeType: "image/png", assetPath: "images/remote.png" }],
    coverVisualId: "shared-image",
    mediaPrompts: [{ assetId: "shared-image", source: "webpage", text: "Original source prompt", textRevision: 1 }]
  }], catalog());
  const parsed = parseLibraryPackage(data, new Map([["images/remote.png", new Blob(["fixture image"], { type: "image/png" })]]));
  assert.equal(parsed.entries[0].mediaPrompts[0].source, "webpage");
  const current = { entries: [{ ...entry("local"), hasScreenshot: false, screenshotPath: undefined,
    mediaAssets: [{ id: "shared-image", kind: "image", storageMode: "reference", sourceUrl: "https://example.com/local.png" }] }],
    taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), settings: {}, classificationRules: [], organizerState: { collections: [] } };
  const merged = mergeLibraryPackage(current, data);
  const restored = merged.state.entries.find(item => item.title === "案例 remote");
  assert.ok(restored);
  assert.notEqual(restored.mediaAssets[0].id, "shared-image");
  assert.equal(restored.mediaPrompts[0].assetId, restored.mediaAssets[0].id);
  assert.equal(restored.coverVisualId, restored.mediaAssets[0].id);
  assert.equal(restored.mediaPrompts[0].source, "webpage");
  assert.equal(restored.mediaPrompts[0].text, "Original source prompt");
});

test("parseLibraryPackage validates the portable library format and referenced screenshots", () => {
  const data = packageData([entry("one")], catalog());
  data.entries[0].customLabels = ["喜欢", " 喜欢 ", "待复刻"];
  data.entries[0].metadataLabels = ["AIArtWorks", " AIArtWorks ", "Vol.319"];
  const parsed = parseLibraryPackage(data, new Map([["images/one.webp", new Blob(["image"], { type: "image/webp" })]]));
  assert.equal(parsed.entries.length, 1);
  assert.equal(parsed.schemaVersion, SCHEMA_VERSION);
  assert.equal(parsed.entries[0].schemaVersion, SCHEMA_VERSION);
  assert.deepEqual(parsed.entries[0].customLabels, ["喜欢", "待复刻"]);
  assert.deepEqual(parsed.entries[0].metadataLabels, ["AIArtWorks", "Vol.319"]);
  assert.equal(parsed.images.get("one").type, "image/webp");
  assert.throws(() => parseLibraryPackage(data, new Map()), /截图缺失/);
  assert.throws(() => parseLibraryPackage({ ...data, version: "3" }, new Map()), /不是受支持/);
});

test("parseLibraryPackage rejects project trees beyond the portable package safety limit", () => {
  const data = packageData([entry("one")], catalog());
  data.organizerState.collections.push({ id: "collection:extra", name: "额外项目", entryIds: [] });
  assert.throws(() => parseLibraryPackage(data, new Map(), { maxCollections: 1 }), /项目数量超过 1 个上限/);
});

test("legacy v1 and v2 share packages preserve multiple visuals and their primary relationship", () => {
  const data = packageData([], catalog());
  data.version = 2;
  data.entries = [{
    ...entry("multi"),
    hasScreenshot: undefined,
    screenshotPath: undefined,
    visuals: [
      { id: "visual-a", screenshotPath: "images/multi/visual-a.webp" },
      { id: "visual-b", screenshotPath: "images/multi/visual-b.png" }
    ],
    primaryVisualId: "visual-b"
  }];
  const files = new Map([
    ["images/multi/visual-a.webp", new Blob(["a"], { type: "image/webp" })],
    ["images/multi/visual-b.png", new Blob(["b"], { type: "image/png" })]
  ]);
  const parsedV2 = parseLibraryPackage(data, files);
  assert.equal(parsedV2.entries[0].schemaVersion, SCHEMA_VERSION);
  assert.deepEqual(parsedV2.entries[0].mediaAssets.map((visual) => visual.id), ["visual-a", "visual-b"]);
  assert.equal(parsedV2.entries[0].primaryMediaId, "visual-b");
  assert.equal(parsedV2.images.size, 2);
  data.version = 1;
  const parsedV1 = parseLibraryPackage(data, files);
  assert.equal(parsedV1.entries[0].schemaVersion, SCHEMA_VERSION);
  assert.equal(parsedV1.entries[0].primaryMediaId, "visual-b");
});

test("every released share-package version enters the current canonical architecture", () => {
  for (const version of [1, 2, 3]) {
    const data = packageData([], catalog());
    data.version = version;
    delete data.schemaVersion;
    data.entries = [{
      ...entry(`legacy-${version}`),
      schemaVersion: 5,
      hasScreenshot: true,
      screenshotPath: `images/legacy-${version}.webp`,
      visuals: undefined,
      mediaAssets: undefined
    }];
    const parsed = parseLibraryPackage(data, new Map([[
      `images/legacy-${version}.webp`,
      new Blob([`version-${version}`], { type: "image/webp" })
    ]]));
    const imported = parsed.entries[0];
    assert.equal(parsed.schemaVersion, SCHEMA_VERSION);
    assert.equal(imported.schemaVersion, SCHEMA_VERSION);
    assert.equal(imported.mediaAssets.length, 1);
    assert.equal(imported.primaryMediaId, `legacy-${version}`);
    assert.equal(Object.prototype.propertyIsEnumerable.call(imported, "visuals"), false);
    assert.equal(Object.hasOwn(imported, "screenshotPath"), false);
    assert.doesNotMatch(JSON.stringify(imported), /"visuals"|"screenshotPath"/);
  }
});

test("v3 packages restore video documents and time notes with their media relationships", () => {
  const data = packageData([], catalog());
  data.version = 3;
  data.entries = [{
    ...entry("mixed"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [
      { id: "video-a", kind: "video", storageMode: "managed", mimeType: "video/mp4", byteSize: 5, assetPath: "videos/mixed/video-a.mp4" },
      { id: "doc-a", kind: "document", storageMode: "managed", mimeType: "application/pdf", byteSize: 3, assetPath: "documents/mixed/doc-a.pdf" }
    ],
    primaryMediaId: "video-a",
    timeNotes: [{ id: "note-a", assetId: "video-a", startMs: 1250, endMs: 2400, text: "动作加速", createdAt: "2026-08-01T10:01:00Z" }]
  }];
  const parsed = parseLibraryPackage(data, new Map([
    ["videos/mixed/video-a.mp4", new Blob(["video"], { type: "video/mp4" })],
    ["documents/mixed/doc-a.pdf", new Blob(["pdf"], { type: "application/pdf" })]
  ]));
  assert.deepEqual(parsed.entries[0].mediaAssets.map((asset) => asset.kind), ["video", "document"]);
  assert.equal(parsed.entries[0].timeNotes[0].assetId, "video-a");
  assert.equal(parsed.assets.size, 2);
  assert.equal(parsed.images.size, 0);
  assert.throws(() => parseLibraryPackage(data, new Map([
    ["videos/mixed/video-a.mp4", new Blob(["truncated"], { type: "video/mp4" })],
    ["documents/mixed/doc-a.pdf", new Blob(["pdf"], { type: "application/pdf" })]
  ])), /大小校验失败/);
});

test("v4 mixed creative-asset ZIP restores image video audio subtitle PSD and font bytes", async () => {
  const assets = [
    { id: "image", kind: "image", mimeType: "image/png", sourceFormat: "png", path: "images/mixed/image.png", bytes: "image" },
    { id: "video", kind: "video", mimeType: "video/mp4", sourceFormat: "mp4", path: "videos/mixed/video.mp4", bytes: "video" },
    { id: "audio", kind: "audio", mimeType: "audio/mpeg", sourceFormat: "mp3", path: "audio/mixed/theme.mp3", bytes: "audio" },
    { id: "subtitle", kind: "document", mimeType: "application/x-subrip", sourceFormat: "srt", path: "documents/mixed/subtitle.srt", bytes: "subtitle" },
    { id: "psd", kind: "attachment", mimeType: "image/vnd.adobe.photoshop", sourceFormat: "psd", path: "attachments/mixed/artwork.psd", bytes: "psd-source" },
    { id: "font", kind: "attachment", mimeType: "font/otf", sourceFormat: "otf", path: "attachments/mixed/typeface.otf", bytes: "font-source" }
  ];
  const data = packageData([], catalog());
  data.version = 4;
  data.entries = [{
    ...entry("mixed"),
    hasScreenshot: undefined,
    screenshotPath: undefined,
    mediaAssets: assets.map((asset) => ({
      id: asset.id,
      kind: asset.kind,
      storageMode: "managed",
      mimeType: asset.mimeType,
      sourceFormat: asset.sourceFormat,
      sourceTitle: asset.path.split("/").at(-1),
      byteSize: new Blob([asset.bytes]).size,
      assetPath: asset.path
    })),
    primaryMediaId: "image"
  }];
  const archive = await createZipBlob([
    { name: "library.json", data: JSON.stringify(data) },
    ...assets.map((asset) => ({ name: asset.path, data: new Blob([asset.bytes], { type: asset.mimeType }) }))
  ]);
  const files = await readZipBlob(archive, {
    maxArchiveBytes: archive.size,
    maxFileBytes: archive.size,
    maxImageBytes: archive.size
  });
  const parsed = parseLibraryPackage(JSON.parse(await files.get("library.json").text()), files, {
    maxArchiveBytes: archive.size,
    maxFileBytes: archive.size,
    maxImageBytes: archive.size
  });

  assert.deepEqual(parsed.entries[0].mediaAssets.map((asset) => asset.kind), [
    "image", "video", "audio", "document", "attachment", "attachment"
  ]);
  for (const asset of assets) {
    assert.equal(parsed.assets.get(asset.id)?.size, new Blob([asset.bytes]).size);
    const restored = parsed.entries[0].mediaAssets.find((item) => item.id === asset.id);
    assert.equal(restored.sourceFormat, asset.sourceFormat);
    assert.equal(restored.mimeType, asset.mimeType);
  }
  const preview = mergeLibraryPackage({
    entries: [], taxonomy: createDefaultTaxonomy(), facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [], settings: {}
  }, data, { now: "2026-08-22T10:00:00.000Z", importBatchId: "mixed-zip" });
  assert.deepEqual(preview.state.entries[0].mediaAssets.map((asset) => asset.sourceFormat), [
    "png", "mp4", "mp3", "srt", "psd", "otf"
  ]);
});

test("v4 package reports and drops a mismatched media descriptor without losing recoverable case text", () => {
  const data = packageData([], catalog());
  data.version = 4;
  data.entries = [{
    ...entry("mismatch"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "fake-psd", kind: "attachment", storageMode: "managed", sourceTitle: "fake.psd",
      sourceFormat: "psd", mimeType: "font/otf", byteSize: 4, assetPath: "attachments/mismatch/fake.psd"
    }]
  }];
  const parsed = parseLibraryPackage(data, new Map([[
    "attachments/mismatch/fake.psd", new Blob(["fake"], { type: "application/octet-stream" })
  ]]));
  assert.equal(parsed.entries.length, 1);
  assert.deepEqual(parsed.entries[0].mediaAssets, []);
  assert.equal(parsed.entries[0].text, "prompt mismatch");
  assert.deepEqual(parsed.importDiagnostics.map(({ code, entryId, assetId }) => ({ code, entryId, assetId })), [{
    code: "media_descriptor_dropped",
    entryId: "mismatch",
    assetId: "fake-psd"
  }]);
});

test("v4 package restores an unknown local source only as an inert managed attachment", () => {
  const data = packageData([], catalog());
  data.version = 4;
  data.entries = [{
    ...entry("generic-source"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "generic", kind: "attachment", storageMode: "managed", sourceTitle: "scene.customsource",
      sourceFormat: "customsource", formatCategory: "other-source", mimeType: "application/octet-stream",
      byteSize: 6, assetPath: "attachments/generic-source/scene.customsource"
    }],
    primaryMediaId: "generic"
  }];
  const parsed = parseLibraryPackage(data, new Map([[
    "attachments/generic-source/scene.customsource", new Blob(["source"], { type: "application/octet-stream" })
  ]]));
  const restored = parsed.entries[0].mediaAssets[0];
  assert.equal(restored.kind, "attachment");
  assert.equal(restored.storageMode, "managed");
  assert.equal(restored.formatCategory, "other-source");
  assert.equal(restored.sourceFormat, "customsource");
  for (const field of ["recordType", "linkStatus", "importFailure"]) {
    assert.equal(Object.hasOwn(restored, field), false);
  }
});

test("complete folder backups restore genuine legacy RTF documents without trusting a .bin MIME type", async () => {
  const rtf = String.raw`{\rtf1\ansi PromptDirector backup}`;
  const path = "documents/rtf-case/rtf-asset.bin";
  const data = packageData([], catalog());
  data.entries = [{
    ...entry("rtf-case"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "rtf-asset", kind: "document", storageMode: "managed", mimeType: "application/rtf",
      byteSize: new Blob([rtf]).size, assetPath: path
    }],
    primaryMediaId: "rtf-asset"
  }];

  const parsed = await parseCompleteFolderBackup(data, new Map([[
    path,
    new Blob([rtf], { type: "application/octet-stream" })
  ]]));
  assert.equal(parsed.assets.get("rtf-asset").type, "application/rtf");

  await assert.rejects(
    () => parseCompleteFolderBackup(data, new Map([[
      path,
      new Blob(["not an RTF document"], { type: "application/octet-stream" })
    ]])),
    /来源没有返回有效文档文件/
  );
});

test("portable packages accept the explicit .rtf path used by new complete backups", () => {
  const rtf = String.raw`{\rtf1\ansi PromptDirector backup}`;
  const path = "documents/rtf-case/rtf-asset.rtf";
  const data = packageData([], catalog());
  data.entries = [{
    ...entry("rtf-case"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "rtf-asset", kind: "document", storageMode: "managed", mimeType: "application/rtf",
      byteSize: new Blob([rtf]).size, assetPath: path
    }],
    primaryMediaId: "rtf-asset"
  }];

  const parsed = parseLibraryPackage(data, new Map([[
    path,
    new Blob([rtf], { type: "application/rtf" })
  ]]));
  assert.equal(parsed.assets.get("rtf-asset").type, "application/rtf");
});

test("metadata-only import preview never compares declared bytes to its 11-byte placeholder", () => {
  const data = packageData([], catalog());
  data.entries = [{
    ...entry("placeholder-size"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "placeholder-image", kind: "image", storageMode: "managed", mimeType: "image/webp",
      byteSize: 445596, assetPath: "images/placeholder-size.webp"
    }],
    primaryMediaId: "placeholder-image"
  }];

  const preview = mergeLibraryPackage({ entries: [] }, data);
  assert.equal(preview.importedCount, 1);
  assert.equal(preview.state.entries[0].mediaAssets[0].byteSize, 445596);
});

test("imports remap visual ids that would overwrite a different local case", () => {
  const current = {
    entries: [{ ...entry("local"), visuals: [{ id: "shared-visual" }], primaryVisualId: "shared-visual" }],
    taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), classificationRules: [], settings: {}
  };
  const imported = packageData([], catalog());
  imported.version = 3;
  imported.entries = [{
    ...entry("remote"),
    hasScreenshot: undefined,
    screenshotPath: undefined,
    visuals: [{ id: "shared-visual", screenshotPath: "images/remote/shared.webp" }],
    primaryVisualId: "shared-visual",
    articleDocument: {
      version: 1,
      blocks: [
        { id: "article-copy", kind: "paragraph", text: "正文" },
        { id: "article-image", kind: "image", assetId: "shared-visual", sourceUrl: "https://example.com/original.webp" }
      ]
    },
    facetAssignments: [
      { facetId: "facet:mood", nodeId: "tag:epic", status: "confirmed", source: "manual" },
      { facetId: "facet:mood", nodeId: "tag:dramatic", status: "confirmed", source: "vision_model", visualId: "shared-visual" }
    ]
  }];
  const result = mergeLibraryPackage(current, imported);
  const remote = result.state.entries.find((item) => item.id === "remote");
  assert.notEqual(remote.primaryMediaId, "shared-visual");
  assert.equal(result.visualIdMap["shared-visual"], remote.primaryMediaId);
  assert.equal(remote.articleDocument.blocks[1].assetId, remote.primaryMediaId);
  assert.equal(
    remote.facetAssignments.find((item) => item.source === "vision_model").visualId,
    remote.primaryMediaId
  );
});

test("imports remap both sides of a video poster relationship", () => {
  const videoEntry = (id) => ({
    ...entry(id), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [
      { id: "video-shared", kind: "video", storageMode: "managed", mimeType: "video/mp4", assetPath: `videos/${id}.mp4`, posterAssetId: "poster-shared" },
      { id: "poster-shared", kind: "image", usage: "poster", storageMode: "managed", mimeType: "image/webp", assetPath: `images/${id}.webp`, derivedFromAssetId: "video-shared" }
    ],
    primaryMediaId: "video-shared",
    videoAnalyses: [{
      id: `analysis:${id}`, assetId: "video-shared", mode: "visual-reconstruction",
      requestId: `attempt:${id}`, contractVersion: "visual-reconstruction-tags-json-v3-1-evidence-guard",
      reconstructionPrompt: `${id} 视觉逆推`, tags: [], uncertainties: [], includeTags: false,
      analysisScope: "visual", finishReason: "stop", createdAt: "2026-08-30T00:00:00.000Z"
    }]
  });
  const current = {
    entries: [videoEntry("local")], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: {}
  };
  const imported = packageData([videoEntry("remote")], catalog());
  imported.version = 3;
  const result = mergeLibraryPackage(current, imported);
  const remote = result.state.entries.find((item) => item.id === "remote");
  const video = remote.mediaAssets.find((asset) => asset.kind === "video");
  const poster = remote.mediaAssets.find((asset) => asset.usage === "poster");
  assert.notEqual(video.id, "video-shared");
  assert.equal(video.posterAssetId, poster.id);
  assert.equal(poster.derivedFromAssetId, video.id);
  assert.equal(remote.videoAnalyses[0].assetId, video.id);
  assert.equal(remote.videoAnalyses[0].reconstructionPrompt, "remote 视觉逆推");
});

test("parseLibraryPackage enforces case and image byte limits before storage", () => {
  const twoEntries = packageData([entry("one"), entry("two")], catalog());
  const files = new Map([
    ["images/one.webp", new Blob(["12345"], { type: "image/webp" })],
    ["images/two.webp", new Blob(["image"], { type: "image/webp" })]
  ]);
  assert.throws(
    () => parseLibraryPackage(twoEntries, files, { maxEntries: 1, maxImageBytes: 100 }),
    /案例数量超过.*上限/
  );
  assert.throws(
    () => parseLibraryPackage(packageData([entry("one")], catalog()), files, { maxEntries: 2, maxImageBytes: 4 }),
    /图片超过.*上限/
  );
});

test("empty-library import restores cases, settings, vocabulary and source rules", () => {
  const data = packageData([entry("one")], catalog());
  const result = mergeLibraryPackage({
    entries: [], taxonomy: createDefaultTaxonomy(), facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [], settings: DEFAULT_SETTINGS
  }, data);

  assert.equal(result.importedCount, 1);
  assert.equal(result.state.entries[0].id, "one");
  assert.equal(result.state.settings.libraryTitle, "我的灵感库");
  assert.equal(result.state.facetCatalog.facets.length, 10);
  assert.equal(result.state.facetCatalog.nodes.length, 61);
  assert.equal(result.state.classificationRules.length, 1);
  assert.deepEqual(result.state.organizerState.collections[0].entryIds, ["one"]);
});

test("empty-library restore preserves trashed cases and projects from a complete backup", () => {
  const data = packageData([], catalog());
  const deletedEntry = { ...entry("deleted"), hasScreenshot: false };
  delete deletedEntry.screenshotPath;
  data.trashState = {
    version: 1,
    items: [
      {
        id: "trash:entry:deleted",
        kind: "entry",
        targetId: "deleted",
        deletedAt: "2026-08-25T00:00:00.000Z",
        snapshot: deletedEntry,
        relationships: { collections: [{ id: "collection:deleted", index: 0 }] }
      },
      {
        id: "trash:collection:collection:deleted",
        kind: "collection",
        targetId: "collection:deleted",
        deletedAt: "2026-08-25T00:00:00.000Z",
        snapshot: { id: "collection:deleted", name: "已删除项目", parentId: null, order: 0, entryIds: ["deleted"] },
        relationships: {}
      }
    ]
  };

  const result = mergeLibraryPackage({ entries: [] }, data);

  assert.deepEqual(result.state.trashState.items.map(({ kind, targetId }) => ({ kind, targetId })), [
    { kind: "entry", targetId: "deleted" },
    { kind: "collection", targetId: "collection:deleted" }
  ]);
  const restoredSnapshot = result.state.trashState.items[0].snapshot;
  assert.equal(restoredSnapshot.id, "deleted");
  assert.equal(restoredSnapshot.text, "prompt deleted");
  assert.deepEqual(restoredSnapshot.mediaAssets, []);
});

test("complete-folder parsing validates and exposes media stored inside a trashed case", async () => {
  const data = packageData([], catalog());
  const path = "images/trash-entry-deleted/deleted-image.webp";
  data.trashState = {
    version: 1,
    items: [{
      id: "trash:entry:deleted",
      kind: "entry",
      targetId: "deleted",
      deletedAt: "2026-08-25T00:00:00.000Z",
      snapshot: {
        ...entry("deleted"),
        hasScreenshot: undefined,
        screenshotPath: undefined,
        mediaAssets: [{
          id: "deleted-image",
          kind: "image",
          storageMode: "managed",
          mimeType: "image/webp",
          sourceFormat: "webp",
          byteSize: 13,
          assetPath: path
        }],
        primaryMediaId: "deleted-image"
      },
      relationships: {}
    }]
  };
  const parsed = await parseCompleteFolderBackup(data, new Map([[
    path,
    new Blob(["trashed-image"], { type: "image/webp" })
  ]]), { skipMediaByteValidation: true });

  assert.equal(parsed.assets.get("deleted-image")?.size, 13);
  assert.equal(parsed.trashState.items[0].snapshot.mediaAssets[0].assetPath, path);
  const preview = mergeLibraryPackage({ entries: [] }, data);
  assert.equal(preview.createdVisualIdMap["deleted-image"], "deleted-image");
});

test("non-empty restore remaps trashed case and project identities instead of dropping them", () => {
  const data = packageData([], catalog());
  const trashedEntry = { ...entry("deleted"), hasScreenshot: false };
  delete trashedEntry.screenshotPath;
  data.trashState = {
    version: 1,
    items: [
      {
        id: "trash:entry:deleted",
        kind: "entry",
        targetId: "deleted",
        deletedAt: "2026-08-25T00:00:00.000Z",
        snapshot: trashedEntry,
        relationships: { collections: [{ id: "collection:deleted", index: 0 }] }
      },
      {
        id: "trash:collection:collection:deleted",
        kind: "collection",
        targetId: "collection:deleted",
        deletedAt: "2026-08-25T00:00:00.000Z",
        snapshot: { id: "collection:deleted", name: "备份里的已删除项目", parentId: null, order: 0, entryIds: ["deleted"] },
        relationships: {}
      }
    ]
  };
  const current = {
    entries: [entry("deleted")],
    trashState: { version: 1, items: [] },
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {},
    organizerState: {
      collections: [{ id: "collection:deleted", name: "本地同名编号项目", parentId: null, order: 0, entryIds: ["deleted"] }]
    },
    compoundCases: []
  };

  const result = mergeLibraryPackage(current, data);
  const restoredEntry = result.state.trashState.items.find((item) => item.kind === "entry");
  const restoredProject = result.state.trashState.items.find((item) => item.kind === "collection");

  assert.ok(restoredEntry);
  assert.ok(restoredProject);
  assert.notEqual(restoredEntry.targetId, "deleted");
  assert.equal(restoredEntry.snapshot.id, restoredEntry.targetId);
  assert.notEqual(restoredProject.targetId, "collection:deleted");
  assert.equal(restoredProject.snapshot.id, restoredProject.targetId);
  assert.deepEqual(restoredProject.snapshot.entryIds, [restoredEntry.targetId]);
  assert.equal(restoredEntry.relationships.collections[0].id, restoredProject.targetId);
});

test("trash import remaps structured video analysis to the restored video asset", () => {
  const videoSnapshot = {
    ...entry("deleted-video"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{
      id: "video:trash-shared", kind: "video", storageMode: "managed", mimeType: "video/mp4",
      assetPath: "videos/deleted-video.mp4"
    }],
    primaryMediaId: "video:trash-shared",
    videoAnalyses: [{
      id: "analysis:trash", assetId: "video:trash-shared", mode: "visual-reconstruction",
      requestId: "attempt:trash", contractVersion: "visual-reconstruction-tags-json-v3-1-evidence-guard",
      reconstructionPrompt: "回收站视频逆推", tags: [], uncertainties: [], includeTags: false,
      analysisScope: "visual", finishReason: "stop", createdAt: "2026-08-30T00:00:00.000Z"
    }]
  };
  const data = packageData([], catalog());
  data.trashState = { version: 1, items: [{
    id: "trash:entry:deleted-video", kind: "entry", targetId: "deleted-video",
    deletedAt: "2026-08-30T00:01:00.000Z", snapshot: videoSnapshot, relationships: {}
  }] };
  const current = {
    entries: [{
      ...entry("local-video"), hasScreenshot: undefined, screenshotPath: undefined,
      mediaAssets: [{
        id: "video:trash-shared", kind: "video", storageMode: "managed", mimeType: "video/mp4",
        assetPath: "videos/local-video.mp4"
      }],
      primaryMediaId: "video:trash-shared"
    }],
    trashState: { version: 1, items: [] }, taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: {}, organizerState: { collections: [] }, compoundCases: []
  };

  const result = mergeLibraryPackage(current, data);
  const restored = result.state.trashState.items.find((item) => item.kind === "entry").snapshot;
  assert.notEqual(restored.primaryMediaId, "video:trash-shared");
  assert.equal(restored.videoAnalyses[0].assetId, restored.primaryMediaId);
  assert.equal(restored.videoAnalyses[0].reconstructionPrompt, "回收站视频逆推");
});

test("restored trash relationships follow the imported project into its actual merged destination", () => {
  const data = packageData([entry("remote")], catalog());
  data.organizerState = {
    collections: [{ id: "collection:remote", name: "共享项目", order: 0, entryIds: ["remote"] }]
  };
  const deletedEntry = { ...entry("deleted"), hasScreenshot: false };
  delete deletedEntry.screenshotPath;
  data.trashState = {
    version: 1,
    items: [{
      id: "trash:entry:deleted",
      kind: "entry",
      targetId: "deleted",
      deletedAt: "2026-08-25T00:00:00.000Z",
      snapshot: deletedEntry,
      relationships: { collections: [{ id: "collection:remote", index: 1 }] }
    }]
  };
  const current = {
    entries: [entry("local")],
    trashState: { version: 1, items: [] },
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {},
    organizerState: {
      collections: [{ id: "collection:local", name: "共享项目", order: 0, entryIds: ["local"] }]
    },
    compoundCases: []
  };

  const result = mergeLibraryPackage(current, data);
  const restoredEntry = result.state.trashState.items.find((item) => item.kind === "entry");

  assert.deepEqual(result.state.organizerState.collections[0].entryIds, ["local", "remote"]);
  assert.equal(restoredEntry.relationships.collections[0].id, "collection:local");
});

test("restored trash compound relationships cannot reuse an active compound identity", () => {
  const data = packageData([], catalog());
  const deletedEntries = ["deleted-one", "deleted-two"].map((id) => {
    const snapshot = { ...entry(id), hasScreenshot: false };
    delete snapshot.screenshotPath;
    return {
      id: `trash:entry:${id}`,
      kind: "entry",
      targetId: id,
      deletedAt: "2026-08-25T00:00:00.000Z",
      snapshot,
      relationships: {
        compoundCases: [{
          id: "compound:active",
          title: "已删除组合",
          memberEntryIds: ["deleted-one", "deleted-two"],
          coverVisualId: ""
        }]
      }
    };
  });
  data.trashState = { version: 1, items: deletedEntries };
  const current = {
    entries: [entry("local-one"), entry("local-two")],
    trashState: { version: 1, items: [] },
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {},
    organizerState: { collections: [] },
    compoundCases: [{
      id: "compound:active",
      title: "本地组合",
      memberEntryIds: ["local-one", "local-two"],
      coverVisualId: "local-one"
    }]
  };

  const result = mergeLibraryPackage(current, data);
  const restored = result.state.trashState.items.filter((item) => item.kind === "entry");
  const restoredCompoundIds = new Set(restored.flatMap((item) => item.relationships.compoundCases.map((compound) => compound.id)));

  assert.equal(restoredCompoundIds.size, 1);
  assert.equal(restoredCompoundIds.has("compound:active"), false);
  assert.deepEqual(restored[0].relationships.compoundCases[0].memberEntryIds, restored.map((item) => item.targetId));
});

test("single curated saves preserve an empty user's library configuration", () => {
  const data = packageData([entry("curated-one")], catalog());
  data.settings = { libraryTitle: "精选案例 Vol.1", outputPath: "精选案例.zip" };
  data.classificationRules = [];
  data.organizerState = { version: 4, collections: [] };
  const current = {
    entries: [],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [{ hostname: "local.example", pathIds: [CONTENT_IDS.promptImage], enabled: true }],
    organizerState: { version: 4, collections: [{ id: "collection:empty", name: "我的项目", order: 0, entryIds: [] }] },
    settings: { libraryTitle: "我的视觉灵感库", outputPath: "我的案例.zip" }
  };
  const result = mergeLibraryPackage(current, data, { preserveLibraryConfiguration: true });

  assert.equal(result.importedCount, 1);
  assert.equal(result.state.settings.libraryTitle, "我的视觉灵感库");
  assert.equal(result.state.classificationRules[0].hostname, "local.example");
  assert.deepEqual(result.state.organizerState.collections.map((item) => item.name), ["我的项目"]);
});

test("existing-library import reuses same-name vocabulary and remaps repeated case ids without merging", () => {
  const localCatalog = createFacetNode(createDefaultFacetCatalog(), {
    id: "tag:local-epic", facetId: "mood", parentId: "mood.emotion", name: "史诗"
  });
  const current = {
    entries: [entry("one")], taxonomy: createDefaultTaxonomy(), facetCatalog: localCatalog,
    classificationRules: [], settings: { libraryTitle: "接收者资料库" }
  };

  const first = mergeLibraryPackage(current, packageData([entry("one"), entry("two")], catalog()));
  assert.equal(first.importedCount, 2);
  assert.equal(first.skippedCount, 0);
  assert.equal(first.state.entries.length, 3);
  assert.equal(first.state.entries.find((item) => item.id === "two").facetAssignments[0].nodeId, "tag:local-epic");
  assert.equal(first.state.facetCatalog.facets.length, 10);
  assert.equal(first.state.settings.libraryTitle, "接收者资料库");
  assert.equal(first.state.classificationRules.length, 0);

  const repeated = mergeLibraryPackage(first.state, packageData([entry("two")], catalog()));
  assert.equal(repeated.importedCount, 1);
  assert.equal(repeated.skippedCount, 0);
  assert.equal(repeated.state.entries.length, 4);
});

test("a colliding case id imports as a new case instead of silently keeping a stale tagless copy", () => {
  const stale = entry("shared-case");
  stale.facetAssignments = [];
  const incoming = entry("shared-case");
  incoming.facetAssignments = [{
    facetId: "facet:mood",
    nodeId: "tag:epic",
    status: "confirmed",
    source: "vision_model"
  }];
  incoming.visuals = [{
    id: "shared-case",
    screenshotPath: "images/shared-case.webp",
    visionAnalysis: {
      version: 2,
      reconstructionPrompt: "保留这份完整反推提示词",
      quality: "complete",
      tags: [{ g: "mood.emotion", t: "史诗" }]
    }
  }];
  incoming.primaryVisualId = "shared-case";

  const result = mergeLibraryPackage({
    entries: [stale],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {}
  }, packageData([incoming], catalog()));

  assert.equal(result.importedCount, 1);
  assert.equal(result.remappedCount, 1);
  assert.equal(result.skippedCount, 0);
  assert.equal(result.state.entries.length, 2);
  const restored = result.state.entries.find((item) => item.id !== "shared-case");
  assert.ok(restored);
  assert.equal(restored.mediaAssets[0].visionAnalysis.reconstructionPrompt, "保留这份完整反推提示词");
  assert.equal(restored.facetAssignments.some((item) => item.source === "vision_model"), true);
});

test("import drops a dangling AI assignment while preserving the recoverable case", () => {
  const incoming = entry("broken-label");
  incoming.facetAssignments = [{
    facetId: "facet:mood",
    nodeId: "tag:not-in-package",
    status: "confirmed",
    source: "vision_model"
  }];
  const result = mergeLibraryPackage({
    entries: [entry("local")],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {}
  }, packageData([incoming], catalog()));
  assert.equal(result.importedCount, 1);
  const restored = result.state.entries.find((item) => item.id === "broken-label");
  assert.ok(restored);
  assert.deepEqual(restored.facetAssignments, []);
});

test("package import keeps source time but assigns one receiver-local added time and batch", () => {
  const source = entry("received");
  source.libraryAddedAt = "2026-07-01T00:00:00.000Z";
  source.importBatchId = "sender-batch";
  const result = mergeLibraryPackage({
    entries: [], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: {}
  }, packageData([source], catalog()), {
    now: "2026-08-22T08:30:00+08:00",
    importBatchId: "receiver-batch"
  });

  const received = result.state.entries[0];
  assert.equal(received.savedAt, "2026-07-18T10:00:00.000Z");
  assert.equal(received.libraryAddedAt, "2026-08-22T00:30:00.000Z");
  assert.equal(received.importBatchId, "receiver-batch");
});

test("existing-library import carries user content types and keeps imported cases connected", () => {
  const source = entry("document");
  source.classification.pathIds = ["content:work-doc"];
  const data = packageData([source], catalog());
  data.taxonomy = createContentType(createDefaultTaxonomy(), {
    id: "content:work-doc",
    name: "工作文档",
    role: CONTENT_ROLES.general
  });
  const result = mergeLibraryPackage({
    entries: [entry("local")], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: {}
  }, data);
  assert.equal(result.state.taxonomy.nodes.find((item) => item.id === "content:work-doc").name, "工作文档");
  assert.deepEqual(result.state.entries.find((item) => item.id === "document").classification.pathIds, ["content:work-doc"]);
});

test("selected share packages contain only chosen cases and the vocabulary they use", () => {
  let value = catalog();
  value = createFacetNode(value, { id: "tag:quiet", facetId: "facet:mood", name: "静谧" });
  const selected = selectLibraryPackage(
    { entries: [entry("one"), entry("two", "tag:quiet")], taxonomy: createDefaultTaxonomy(), facetCatalog: value, classificationRules: [] },
    ["one"]
  );

  assert.deepEqual(selected.entries.map((item) => item.id), ["one"]);
  assert.deepEqual(selected.facetCatalog.nodes.map((item) => item.id), ["tag:dramatic", "tag:epic"]);
  assert.deepEqual(selected.organizerState.collections, []);
});

test("selected share does not leak sender-local library time or import batch", () => {
  const source = entry("one");
  source.libraryAddedAt = "2026-08-21T00:00:00.000Z";
  source.importBatchId = "local-import:one";
  const selected = selectLibraryPackage({
    entries: [source], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), classificationRules: []
  }, ["one"]);

  assert.equal(selected.entries[0].savedAt, source.savedAt);
  assert.equal("libraryAddedAt" in selected.entries[0], false);
  assert.equal("importBatchId" in selected.entries[0], false);
});

test("sharing and importing a compound case preserves all members and remaps its relationship", () => {
  const source = packageData([entry("one"), entry("two")], catalog());
  source.version = 3;
  source.compoundCases = [{
    id: "compound:story", title: "完整流程", memberEntryIds: ["one", "two"], coverVisualId: "two",
    customLabels: [], createdAt: "2026-08-01T00:00:00.000Z", updatedAt: "2026-08-01T00:00:00.000Z"
  }];
  const selected = selectLibraryPackage(source, ["compound:story"]);
  assert.deepEqual(selected.entries.map((item) => item.id), ["one", "two"]);
  assert.deepEqual(selected.compoundCases[0].memberEntryIds, ["one", "two"]);

  const imported = mergeLibraryPackage({
    entries: [entry("local")], compoundCases: [], taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(), classificationRules: [], settings: {}
  }, source, { entryIdMap: { one: "imported-one", two: "imported-two" } });
  assert.deepEqual(imported.state.compoundCases[0].memberEntryIds, ["imported-one", "imported-two"]);
});

test("project packages include every project member and only that project relationship", () => {
  const entries = [entry("one"), entry("two"), entry("outside")];
  const source = packageData(entries, catalog());
  source.organizerState = {
    version: 2,
    collections: [
      { id: "collection:project", name: "Campaign", order: 0, entryIds: ["one", "two"] },
      { id: "collection:private", name: "Private", order: 1, entryIds: ["outside"] }
    ]
  };
  source.composerSessions = [{ id: "private-draft" }];

  const selected = selectProjectPackage(source, "collection:project");
  assert.deepEqual(selected.entries.map((item) => item.id), ["one", "two"]);
  assert.deepEqual(selected.organizerState.collections.map((item) => item.name), ["Campaign"]);
  assert.deepEqual(selected.organizerState.collections[0].entryIds, ["one", "two"]);
  assert.deepEqual(selected.composerSessions, []);

  const received = mergeLibraryPackage({
    entries: [entry("local")], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: {}, organizerState: { collections: [] }
  }, selected, {
    preserveLibraryConfiguration: true,
    now: "2026-08-22T09:00:00.000Z"
  });
  assert.equal(received.state.organizerState.collections[0].createdAt, "2026-08-22T09:00:00.000Z");
});

test("project packages preserve a selected project subtree and deduplicate its cases", () => {
  const source = packageData([entry("root-case"), entry("child-case"), entry("shared"), entry("outside")], catalog());
  source.organizerState = {
    version: 7,
    collections: [
      { id: "collection:root", name: "Campaign", parentId: null, order: 0, entryIds: ["root-case", "shared"] },
      { id: "collection:child", name: "References", parentId: "collection:root", order: 0, entryIds: ["child-case", "shared"] },
      { id: "collection:outside", name: "Outside", parentId: null, order: 1, entryIds: ["outside"] }
    ]
  };

  const selected = selectProjectPackage(source, "collection:root");

  assert.deepEqual(selected.entries.map((item) => item.id), ["root-case", "child-case", "shared"]);
  assert.deepEqual(selected.organizerState.collections.map((item) => ({ id: item.id, parentId: item.parentId })), [
    { id: "collection:root", parentId: null },
    { id: "collection:child", parentId: "collection:root" }
  ]);
  assert.deepEqual(selected.organizerState.collections[0].entryIds, ["root-case", "shared"]);
  assert.deepEqual(selected.organizerState.collections[1].entryIds, ["child-case", "shared"]);
});

test("project packages keep a visible compound complete in the exported project", () => {
  const source = packageData([entry("one"), entry("two"), entry("outside")], catalog());
  source.compoundCases = [{
    id: "compound:story", title: "完整流程", memberEntryIds: ["one", "two"], coverVisualId: "",
    customLabels: [], createdAt: "2026-08-01T00:00:00.000Z", updatedAt: "2026-08-01T00:00:00.000Z"
  }];
  source.organizerState = {
    version: 2,
    collections: [{ id: "collection:project", name: "Campaign", order: 0, entryIds: ["one"] }]
  };

  assert.deepEqual(projectPackageEntryIds(source, "collection:project"), ["one", "two"]);
  const selected = selectProjectPackage(source, "collection:project");
  assert.deepEqual(selected.entries.map((item) => item.id), ["one", "two"]);
  assert.deepEqual(selected.organizerState.collections[0].entryIds, ["one"]);
  assert.deepEqual(selected.compoundCases[0].memberEntryIds, ["one", "two"]);
});

test("share package keeps vision description but strips provider metadata", () => {
  const source = entry("one");
  source.visuals = [{ id: "one", screenshotPath: "images/one.webp", visionAnalysis: {
    version: 1,
    description: "A reusable scene description.",
    locale: "en",
    imageFingerprint: "private-fingerprint",
    analyzedAt: "2026-07-19T10:00:00.000Z",
    providerType: "compatible",
    model: "private-model",
    usage: { totalTokens: 99 },
    userEdited: true
  } }];
  source.primaryVisualId = "one";
  const selected = selectLibraryPackage(
    { entries: [source], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), classificationRules: [] },
    ["one"]
  );
  assert.deepEqual(selected.entries[0].visuals[0].visionAnalysis, {
    version: 1,
    description: "A reusable scene description.",
    locale: "en",
    analyzedAt: "2026-07-19T10:00:00.000Z",
    userEdited: true
  });
});

test("v2 share packages roundtrip reconstruction prompts, inline vision tags, and persisted vision labels", () => {
  const source = entry("vision-v2");
  source.visuals = [{
    id: "vision-v2",
    screenshotPath: "images/vision-v2.webp",
    visionAnalysis: {
      version: 2,
      description: "完整画面描述",
      reconstructionPrompt: "完整反推提示词",
      quality: "complete",
      tags: [{ g: "style.render", t: "赛璐珞" }],
      locale: "zh-CN",
      analyzedAt: "2026-08-21T10:00:00.000Z"
    }
  }];
  source.primaryVisualId = "vision-v2";
  source.facetAssignments = [
    { facetId: "facet:mood", nodeId: "tag:epic", status: "confirmed", source: "manual" },
    { facetId: "facet:mood", nodeId: "tag:dramatic", status: "confirmed", source: "vision_model" }
  ];
  const selected = selectLibraryPackage(
    { entries: [source], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), classificationRules: [] },
    ["vision-v2"]
  );
  const exported = {
    format: "prompt-case-library",
    version: 3,
    settings: { libraryTitle: "我的灵感库", outputPath: "提示词案例库/案例库.zip" },
    taxonomy: selected.taxonomy,
    facetCatalog: selected.facetCatalog,
    classificationRules: selected.classificationRules,
    organizerState: selected.organizerState,
    entries: selected.entries
  };
  const merged = mergeLibraryPackage({ entries: [] }, exported);
  const restored = merged.state.entries[0];
  const restoredVisual = restored.mediaAssets?.[0] ?? restored.visuals?.[0];

  assert.equal(restoredVisual.visionAnalysis.reconstructionPrompt, "完整反推提示词");
  assert.deepEqual(restoredVisual.visionAnalysis.tags, [{ g: "style.render", t: "赛璐珞" }]);
  assert.equal(restoredVisual.visionAnalysis.quality, "complete");
  assert.equal(restored.facetAssignments.some((item) => item.source === "vision_model"), true);
});

test("full imports merge project collections and permanently ignore legacy project methods", () => {
  const current = {
    entries: [entry("local")], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: { libraryTitle: "本地" },
    organizerState: { collections: [{
      id: "collection:local", name: "项目", entryIds: ["local"],
      projectMethods: { image: { targetType: "image", systemInstruction: "Local image method 【subject】", variableSlots: [{ name: "subject", description: "subject", placeholder: "【subject】" }] } }
    }] }
  };
  const imported = packageData([entry("remote")], catalog());
  imported.organizerState.collections[0].projectMethods = {
    image: { targetType: "image", systemInstruction: "Imported image method 【subject】", variableSlots: [{ name: "subject", description: "subject", placeholder: "【subject】" }] },
    video: { targetType: "video", systemInstruction: "Imported video method 【action】", variableSlots: [{ name: "action", description: "action", placeholder: "【action】" }] }
  };
  const result = mergeLibraryPackage(current, imported);
  assert.deepEqual(result.state.organizerState.collections[0].entryIds, ["local", "remote"]);
  assert.equal(Object.hasOwn(result.state.organizerState.collections[0], "projectMethods"), false);
});

test("full imports restore methods and drafts while remapping private source relations", () => {
  const source = entry("remote");
  source.creationMeta = { sourceEntryIds: ["source"], methodVersion: "1.0.0", createdAt: "2026-07-20T00:00:00.000Z" };
  const sourceCase = entry("source");
  const data = packageData([sourceCase, source], catalog());
  data.composerSettings = normalizeComposerSettings({ lastTargetPlatform: "Seedance" });
  data.composerSessions = [createComposerSession({
    id: "draft",
    referenceSnapshots: [{ entryId: "source", alias: "@参考1", referenceKind: "prompt", referenceText: sourceCase.text }]
  })];
  const result = mergeLibraryPackage({
    entries: [entry("local")], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(),
    classificationRules: [], settings: { libraryTitle: "本地" }, composerSessions: []
  }, data, { entryIdMap: { source: "remapped-source", remote: "remapped-result" } });
  assert.equal(result.state.composerSettings.methodVersion, COMPOSER_METHOD_VERSION);
  assert.equal(result.state.composerSessions[0].referenceSnapshots[0].entryId, "remapped-source");
  assert.deepEqual(result.state.entries.find((item) => item.id === "remapped-result").creationMeta.sourceEntryIds, ["remapped-source"]);
});

test("full backups parse temporary reference attachments from safe archive paths", () => {
  const data = packageData([entry("one")], catalog());
  data.composerSessions = [createComposerSession({
    id: "session:temp",
    referenceSnapshots: [{
      entryId: "temp-reference:one",
      alias: "@参考1",
      title: "本机图片",
      sourceType: "temporary",
      referenceKind: "reference",
      referenceText: "",
      imageRefs: [{ visualId: "temp-reference-asset:one", mimeType: "image/webp" }],
      assetRefs: [{
        assetId: "temp-reference-asset:one",
        kind: "image",
        mimeType: "image/webp",
        name: "lighting.webp",
        byteSize: 8,
        archivePath: "temp-references/session-one/lighting.webp"
      }]
    }]
  })];

  const parsed = parseLibraryPackage(data, new Map([
    ["images/one.webp", new Blob(["image"], { type: "image/webp" })],
    ["temp-references/session-one/lighting.webp", new Blob(["lighting"], { type: "image/webp" })]
  ]));

  const snapshot = parsed.composerSessions[0].referenceSnapshots[0];
  assert.equal(snapshot.assetRefs[0].archivePath, "temp-references/session-one/lighting.webp");
  assert.equal(parsed.assets.get("temp-reference-asset:one")?.size, 8);
  assert.equal(parsed.images.get("temp-reference-asset:one")?.size, 8);
});

test("temporary reference attachments reject missing blobs and dangerous archive paths", () => {
  const data = packageData([entry("one")], catalog());
  const withReference = (archivePath) => {
    data.composerSessions = [createComposerSession({
      id: "session:temp",
      referenceSnapshots: [{
        entryId: "temp-reference:one",
        alias: "@参考1",
        title: "本机文档",
        sourceType: "temporary",
        referenceKind: "reference",
        referenceText: "",
        assetRefs: [{
          assetId: "temp-reference-asset:one",
          kind: "document",
          mimeType: "text/plain",
          name: "notes.txt",
          byteSize: 5,
          archivePath
        }]
      }]
    })];
    return structuredClone(data);
  };

  assert.throws(() => parseLibraryPackage(
    withReference("temp-references/session-one/notes.txt"),
    new Map([["images/one.webp", new Blob(["image"], { type: "image/webp" })]])
  ), /临时附件缺失或类型不符/);

  assert.throws(() => parseLibraryPackage(
    withReference("../private/notes.txt"),
    new Map([
      ["images/one.webp", new Blob(["image"], { type: "image/webp" })],
      ["../private/notes.txt", new Blob(["notes"], { type: "text/plain" })]
    ])
  ), /临时附件路径无效/);
});

test("temporary reference asset collisions remap both assetRefs and imageRefs during import", () => {
  const current = {
    entries: [entry("local")],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    settings: {},
    composerSessions: [createComposerSession({
      id: "session:local",
      referenceSnapshots: [{
        entryId: "temp-reference:local",
        alias: "@参考1",
        title: "本机图片",
        sourceType: "temporary",
        referenceKind: "reference",
        referenceText: "",
        imageRefs: [{ visualId: "temp-reference-asset:shared", mimeType: "image/webp" }],
        assetRefs: [{
          assetId: "temp-reference-asset:shared",
          kind: "image",
          mimeType: "image/webp",
          name: "local.webp",
          byteSize: 5,
          archivePath: "temp-references/session-local/local.webp"
        }]
      }]
    })]
  };
  const imported = packageData([entry("remote")], catalog());
  imported.composerSessions = [createComposerSession({
    id: "session:remote",
    referenceSnapshots: [{
      entryId: "temp-reference:remote",
      alias: "@参考1",
      title: "导入图片",
      sourceType: "temporary",
      referenceKind: "reference",
      referenceText: "",
      imageRefs: [{ visualId: "temp-reference-asset:shared", mimeType: "image/webp" }],
        assetRefs: [{
          assetId: "temp-reference-asset:shared",
          kind: "image",
          mimeType: "image/webp",
          name: "remote.webp",
          byteSize: 6,
          archivePath: "temp-references/session-remote/remote.webp"
        }]
      }]
    })];

  const result = mergeLibraryPackage(current, imported);
  const importedSession = result.state.composerSessions.find((session) => session.id === "session:remote");
  const importedReference = importedSession.referenceSnapshots[0];
  const remappedAssetId = result.visualIdMap["temp-reference-asset:shared"];

  assert.notEqual(remappedAssetId, "temp-reference-asset:shared");
  assert.equal(importedReference.assetRefs[0].assetId, remappedAssetId);
  assert.equal(importedReference.imageRefs[0].visualId, remappedAssetId);
  assert.equal(current.composerSessions[0].referenceSnapshots[0].assetRefs[0].assetId, "temp-reference-asset:shared");
});

test("selected shares remove drafts, methods, and private source IDs", () => {
  const source = entry("one");
  source.creationMeta = { sourceEntryIds: ["private-source"], methodVersion: "1.0.0", targetPlatform: "General", outputLanguage: "en", createdAt: "2026-07-20T00:00:00.000Z" };
  const selected = selectLibraryPackage({
    entries: [source], taxonomy: createDefaultTaxonomy(), facetCatalog: catalog(), classificationRules: [],
    composerSettings: normalizeComposerSettings(), composerSessions: [{ id: "private-draft" }]
  }, ["one"]);
  assert.equal(selected.composerSettings, undefined);
  assert.deepEqual(selected.composerSessions, []);
  assert.equal(Object.hasOwn(selected.entries[0].creationMeta, "sourceEntryIds"), false);
});

test("selected shares still exclude composer sessions even when temporary attachments exist", () => {
  const source = entry("one");
  const selected = selectLibraryPackage({
    entries: [source],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: catalog(),
    classificationRules: [],
    composerSessions: [createComposerSession({
      id: "session:temp",
      referenceSnapshots: [{
        entryId: "temp-reference:one",
        alias: "@参考1",
        title: "临时附件",
        sourceType: "temporary",
        referenceKind: "reference",
        referenceText: "",
        imageRefs: [{ visualId: "temp-reference-asset:one", mimeType: "image/webp" }],
        assetRefs: [{
          assetId: "temp-reference-asset:one",
          kind: "image",
          mimeType: "image/webp",
          name: "lighting.webp",
          byteSize: 8,
          archivePath: "temp-references/session-one/lighting.webp"
        }]
      }]
    })]
  }, ["one"]);

  assert.deepEqual(selected.composerSessions, []);
});

test("full backups restore creative runs while selected shares exclude private result evidence", () => {
  const data = packageData([entry("one")], catalog());
  data.composerSessions = [createComposerSession({
    id: "session:one",
    messages: [{ role: "user", content: "生成电影海报" }],
    promptVersions: [{
      id: "prompt:one",
      text: "cinematic poster",
      createdAt: "2026-07-24T10:00:00.000Z"
    }]
  })];
  data.creativeExperimentSettings = { enabled: true, autoAnalyze: true };
  data.creativeRuns = [{
    id: "run:one",
    version: 1,
    sessionId: "session:one",
    promptVersionId: "prompt:one",
    targetType: "image",
    promptText: "cinematic poster",
    createdAt: "2026-07-24T10:05:00.000Z",
    updatedAt: "2026-07-24T10:05:00.000Z",
    outputs: [{
      visual: {
        id: "result:one",
        capturedAt: "2026-07-24T10:05:00.000Z",
        screenshotPath: "creative-results/run-one/result-one.webp"
      },
      capturedAt: "2026-07-24T10:05:00.000Z",
      signals: [{ type: "captured", at: "2026-07-24T10:05:00.000Z" }]
    }]
  }];

  const parsed = parseLibraryPackage(data, new Map([
    ["images/one.webp", new Blob(["case"], { type: "image/webp" })],
    ["creative-results/run-one/result-one.webp", new Blob(["result"], { type: "image/webp" })]
  ]));
  assert.equal(parsed.assets.get("result:one")?.size, 6);

  const restored = mergeLibraryPackage({
    entries: [],
    taxonomy: createDefaultTaxonomy(),
    facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [],
    settings: {}
  }, data);
  assert.equal(restored.state.creativeRuns.length, 1);
  assert.equal(restored.state.creativeRuns[0].outputs[0].visual.id, "result:one");
  assert.equal(restored.state.creativeRuns[0].outputs[0].visual.screenshotPath, undefined);
  assert.deepEqual(restored.state.creativeExperimentSettings, { enabled: true, autoAnalyze: true });

  const shared = selectLibraryPackage(data, ["one"]);
  assert.deepEqual(shared.creativeRuns, []);
  assert.equal(shared.creativeExperimentSettings, undefined);
});

test("full backups restore video creative evidence with frozen Skills and judgments", () => {
  const data = packageData([entry("one")], catalog());
  data.composerSessions = [createComposerSession({
    id: "session:video",
    targetType: "video",
    messages: [{ role: "user", content: "生成短片" }],
    promptVersions: [{ id: "prompt:video", text: "cinematic clip", createdAt: "2026-08-08T10:00:00.000Z" }]
  })];
  data.creativeRuns = [{
    id: "run:video",
    sessionId: "session:video",
    promptVersionId: "prompt:video",
    targetType: "video",
    promptText: "cinematic clip",
    appliedSkills: [{
      skillId: "skill:one", versionId: "skill-version:one", callName: "clip-method", portableId: "clip-method",
      description: "Clip method", skillMarkdown: "# Clip method", references: [], source: "generated", textMode: true
    }],
    createdAt: "2026-08-08T10:01:00.000Z",
    updatedAt: "2026-08-08T10:01:00.000Z",
    outputs: [{
      visual: {
        id: "result:video", kind: "video", storageMode: "managed", mimeType: "video/mp4", byteSize: 5,
        capturedAt: "2026-08-08T10:01:00.000Z", assetPath: "creative-results/run-video/result-video.mp4"
      },
      capturedAt: "2026-08-08T10:01:00.000Z",
      signals: [{ type: "captured", at: "2026-08-08T10:01:00.000Z" }],
      judgment: { keep: "保留运动节奏", improve: "减少镜头抖动", updatedAt: "2026-08-08T10:02:00.000Z" }
    }]
  }];
  const parsed = parseLibraryPackage(data, new Map([
    ["images/one.webp", new Blob(["case"], { type: "image/webp" })],
    ["creative-results/run-video/result-video.mp4", new Blob(["video"], { type: "video/mp4" })]
  ]));
  assert.equal(parsed.assets.get("result:video").type, "video/mp4");
  assert.equal(parsed.images.has("result:video"), false);
  assert.equal(parsed.creativeRuns[0].appliedSkills[0].versionId, "skill-version:one");
  assert.equal(parsed.creativeRuns[0].outputs[0].judgment.improve, "减少镜头抖动");
});

test("full backups restore external Skill files while case shares exclude every Skill", () => {
  const data = packageData([entry("one")], catalog());
  data.creativeSkills = {
    version: 1,
    items: [{
      id: "skill:one",
      callName: "广告大片",
      portableId: "advertising-blockbuster",
      description: "广告视觉方法",
      currentVersionId: "skill-version:one",
      versions: [{
        id: "skill-version:one",
        createdAt: "2026-08-06T00:00:00.000Z",
        reason: "imported",
        source: "imported",
        skillMarkdown: "# 广告大片\n\n保持品牌主体清晰。",
        references: [],
        provenanceMarkdown: ""
      }],
      packageFiles: [{
        path: "external/SKILL.md",
        assetId: "skill-file:one",
        byteSize: 11,
        mimeType: "text/markdown",
        archivePath: "skills/advertising-blockbuster/skill-file-one/external/SKILL.md"
      }],
      textModeConfirmed: false,
      runtimeDependencies: [],
      createdAt: "2026-08-06T00:00:00.000Z",
      updatedAt: "2026-08-06T00:00:00.000Z"
    }]
  };
  const files = new Map([
    ["images/one.webp", new Blob(["image"], { type: "image/webp" })],
    ["skills/advertising-blockbuster/skill-file-one/external/SKILL.md", new Blob(["skill bytes"], { type: "text/markdown" })]
  ]);
  const parsed = parseLibraryPackage(data, files);
  assert.equal(parsed.skillAssets.get("skill-file:one")?.size, 11);
  const restored = mergeLibraryPackage({
    entries: [], taxonomy: createDefaultTaxonomy(), facetCatalog: createDefaultFacetCatalog(),
    classificationRules: [], settings: {}, creativeSkills: { version: 1, items: [] }
  }, data);
  assert.equal(restored.state.creativeSkills.items[0].callName, "广告大片");
  assert.equal(restored.packageAssetIdMap["skill-file:one"], "skill-file:one");
  assert.equal(restored.state.creativeSkills.items[0].packageFiles[0].archivePath, undefined);

  const shared = selectLibraryPackage(data, ["one"]);
  assert.deepEqual(shared.creativeSkills, { version: 1, items: [] });
});

test("backup media kinds retain large temporary images, videos and generated videos under their own limits", () => {
  // Small injected limits exercise the production byte policy without allocating large media.
  const limits = { maxFileBytes: 4, maxImageBytes: 10, maxVideoBytes: 20 };
  const data = packageData([], catalog());
  data.composerSessions = [createComposerSession({
    id: "session:kind-limits", referenceSnapshots: [{
      entryId: "temp-reference:kind-limits", alias: "@参考1", sourceType: "temporary", referenceKind: "video_sources",
      assetRefs: [
        { assetId: "temp-image", kind: "image", mimeType: "image/png", archivePath: "temp-references/session/image.png", byteSize: 8 },
        { assetId: "temp-video", kind: "video", mimeType: "video/mp4", archivePath: "temp-references/session/video.mp4", byteSize: 16 }
      ]
    }]
  })];
  data.creativeRuns = [{ id: "run:kind-limits", sessionId: "session:kind-limits", promptVersionId: "prompt:fixture", promptText: "Test video", targetType: "video", outputs: [{
    visual: { id: "result:video", kind: "video", mimeType: "video/mp4", assetPath: "creative-results/run/video.mp4" }
  }] }];
  const files = new Map([
    ["temp-references/session/image.png", new Blob([new Uint8Array(8)], { type: "image/png" })],
    ["temp-references/session/video.mp4", new Blob([new Uint8Array(16)], { type: "video/mp4" })],
    ["creative-results/run/video.mp4", new Blob([new Uint8Array(16)], { type: "video/mp4" })]
  ]);
  const parsed = parseLibraryPackage(data, files, limits);
  assert.equal(parsed.composerSessions[0].referenceSnapshots[0].assetRefs.length, 2);
  assert.equal(parsed.assets.get("temp-image").size, 8);
  assert.equal(parsed.assets.get("temp-video").size, 16);
  assert.equal(parsed.assets.get("result:video").size, 16);
  assert.throws(() => parseLibraryPackage(data, files, { ...limits, maxVideoBytes: 12 }), /超过/);
});


test("folder restore preserves skill attachments reported with the desktop registered MIME", async () => {
  const data = packageData([], catalog());
  data.version = 5;
  const path = "attachments/skill-case/original.skill";
  const blob = new Blob(["original archive bytes"], { type: "application/vnd.openai.codex.skill" });
  data.entries = [{
    ...entry("skill-case"), hasScreenshot: undefined, screenshotPath: undefined,
    mediaAssets: [{ id: "skill-original", kind: "attachment", storageMode: "managed", sourceTitle: "original.skill",
      sourceFormat: "skill", mimeType: "application/zip", byteSize: blob.size, assetPath: path }]
  }];
  const { parseCompleteFolderBackup } = await import("../extension/library-package.js");
  const restored = await parseCompleteFolderBackup(data, new Map([[path, blob]]));
  assert.equal(restored.entries[0].mediaAssets.length, 1);
  assert.equal(restored.assets.get("skill-original"), blob);
  assert.equal(restored.importDiagnostics.length, 0);
});

test('public selection rejects recovery-only content while healthy cases remain shareable', () => {
  const healthy = { id: 'healthy', text: 'current', mediaAssets: [] };
  const recovery = { id: 'broken', text: 'old', mediaAssets: [], vaultReadStatus: { readOnly: true } };
  assert.throws(() => selectLibraryPackage({ entries: [healthy, recovery] }, ['broken']), { code: 'case_files_unavailable' });
  assert.equal(selectLibraryPackage({ entries: [healthy, recovery] }, ['healthy']).entries[0].text, 'current');
});

test('backup retains complete unfinished tool work and import requires target review before replay', () => {
  const checkpoint = { protocol: 'chat_completions', body: { model: 'm', messages: [{ role: 'tool', content: '已经完成的工具结果' }] },
    retainedSkillVersionIds: [], callIds: ['write-once'], requestCount: 1, usageKnown: false };
  const original = createComposerSession({ id: 'work', title: '未完成任务', messages: [{ id: 'user', role: 'user', content: '完整用户要求' }], toolContinuations: { user: checkpoint } });
  const backup = JSON.parse(JSON.stringify({ ...packageData([], createDefaultFacetCatalog()), composerSessions: [original] }));
  assert.equal(backup.composerSessions[0].toolContinuations.user.body.messages[0].content, '已经完成的工具结果');
  const parsed = parseLibraryPackage(backup, new Map());
  assert.equal(parsed.composerSessions[0].toolContinuations.user.needsTargetReview, true);
  assert.deepEqual(parsed.composerSessions[0].toolContinuations.user.callIds, ['write-once']);
  assert.equal(original.toolContinuations.user.needsTargetReview, undefined);
});