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

77.0 KB
Raw Blame
import { t } from './i18n.js';
import { skillFileOwners, skillPackageFiles } from './skill-files.js';
import { libraryStoredAssets, libraryStoredAssetIds } from "./library-asset-inventory.js";
import { syncStateHasContent } from "./sync-model.js";
import { mediaIdentity, sameMediaIdentity, sharedLibraryMediaFiles } from "./library-shared-media.js";
import { createDefaultFacetCatalog, normalizeFacetCatalog, uniqueNames } from "./facets.js";
import { normalizeSettings, DEFAULT_SETTINGS, DEFAULT_SETTINGS_EN } from "./lib.js";
import { SCHEMA_VERSION, mergeTaxonomies, normalizeTaxonomy } from "./taxonomy.js";
import {
  collectionEntryIds,
  collectionSubtreeIds,
  createDefaultOrganizerState,
  mergeOrganizerStateWithMap,
  normalizeOrganizerState,
  removeEntriesFromOrganizer
} from "./organizer.js";
import { normalizeComposerSessions, normalizeComposerSettings } from "./composer.js";
import { normalizeCreativeExperimentSettings, normalizeCreativeRuns } from "./creative-runs.js";
import { mergeCreativeSkillsState, normalizeCreativeSkillsState } from "./creative-skills.js";
import { formatBytes, libraryTransferLimits, portableAssetByteLimit } from "./resource-limits.js";
import { normalizeEntryVisuals } from "./visuals.js";
import { normalizeEntryMedia, removeEntryMedia, remapMediaAnalysisAssets } from "./media.js";
import { expandLogicalCaseIds, normalizeCompoundCases, removeEntriesFromCompoundCases } from "./compound-cases.js";
import { prepareLibraryPackageDraft } from "./library-package-migrations.js";
import { remapArticleDocumentAssets } from "./article-document.js";
import { caseSemanticFingerprint } from "./library-semantic-identity.js";
import { libraryCaseScopes } from "./library-case-scope.js";
import { normalizeTrashState } from "./trash.js";
import { verifiedDocumentBlob, isSupportedDocumentMimeType } from "./bounded-media.js";
import {
  assetFormatForExtension,
  fileExtension,
  isReportedMimeCompatible,
  portableAssetDirectory
} from "./asset-formats.js";

const AI_ASSIGNMENT_SOURCES = new Set(["deepseek_text", "local_image_review", "vision_model"]);

export function hasLibrarySalvageDiagnostics(diagnosticsValue) {
  return (Array.isArray(diagnosticsValue) ? diagnosticsValue : [])
    .some((item) => item?.action === "dropped" || item?.action === "skipped");
}

export async function parseCompleteFolderBackup(value, files = new Map(), limitsValue = {}, options = {}) {
  const preparedFiles = new Map(files);
  const limits = libraryTransferLimits(limitsValue);
  for (const [path, mimeType] of completeBackupDocumentPaths(value)) {
    const blob = preparedFiles.get(path);
    if (!(blob instanceof Blob)) continue;
    const verified = await verifiedDocumentBlob(blob, mimeType, limits.maxFileBytes);
    preparedFiles.set(path, verified);
  }
  return parseLibraryPackage(value, await sharedLibraryMediaFiles(value, preparedFiles, options), { ...limitsValue, salvageInvalidMedia: false });
}

export function parseLibraryPackage(value, files = new Map(), limitsValue = {}) {
  const limits = libraryTransferLimits(limitsValue);
  const skipMediaByteValidation = limitsValue?.skipMediaByteValidation === true;
  const salvageInvalidMedia = limitsValue?.salvageInvalidMedia === true;
  const prepared = prepareLibraryPackageDraft(value);
  const importDiagnostics = [...prepared.diagnostics];
  const importStats = {
    ...prepared.stats,
    droppedMediaFiles: 0,
    droppedTrashMedia: 0,
    droppedTemporaryAssets: 0,
    droppedCreativeOutputs: 0,
    droppedSkillFiles: 0
  };
  const packageVersion = prepared.sourceVersion;
  value = prepared.draft;
  if (value.entries.length > limits.maxEntries) {
    throw new Error(t("案例数量超过 {limit} 条上限", { limit: limits.maxEntries }));
  }
  if (Array.isArray(value.organizerState?.collections) && value.organizerState.collections.length > limits.maxCollections) {
    throw new Error(t("项目数量超过 {limit} 个上限", { limit: limits.maxCollections }));
  }
  const data = structuredClone(value);
  data.settings = normalizeSettings(data.settings);
  data.taxonomy = normalizeTaxonomy(data.taxonomy);
  data.facetCatalog = normalizeFacetCatalog(data.facetCatalog);
  data.classificationRules = Array.isArray(data.classificationRules) ? data.classificationRules : [];
  const packageFacetIds = new Set(data.facetCatalog.facets.map((item) => item.id));
  const packageNodeIds = new Set(data.facetCatalog.nodes.map((item) => item.id));
  for (const entry of data.entries) {
    const missingAssignment = (Array.isArray(entry?.facetAssignments) ? entry.facetAssignments : [])
      .find((item) => !packageFacetIds.has(String(item?.facetId ?? "")) || !packageNodeIds.has(String(item?.nodeId ?? "")));
    if (missingAssignment) {
      throw new Error(t("分享包中的案例“{title}”引用了缺失的 AI 标签词表,导入已取消", { title: clean(entry?.title) || clean(entry?.id) || t("未命名案例") }));
    }
  }
  const ids = new Set();
  const mediaIdentities = new Map();
  const claimMedia = (asset, blob) => {
    const identity = mediaIdentity(asset, blob);
    const existing = mediaIdentities.get(asset.id);
    if (existing && !sameMediaIdentity(existing, identity)) return false;
    mediaIdentities.set(asset.id, identity);
    return true;
  };
  const assets = new Map();
  const images = new Map();
  const skillAssets = new Map();
  if (packageVersion >= 4 && !salvageInvalidMedia) {
    for (const entry of data.entries) {
      for (const asset of Array.isArray(entry?.mediaAssets) ? entry.mediaAssets : []) {
        if (asset?.storageMode === "reference") continue;
        validatePortableMediaDescriptor(asset, clean(asset?.assetPath), packageVersion);
      }
    }
  }
  const normalizationDroppedAssetIds = new Map();
  data.entries = data.entries.map((entry, entryIndex) => {
    const normalized = normalizeEntryVisuals(entry);
    if (packageVersion >= 4) {
      const normalizedIds = new Set(normalized.mediaAssets.map((asset) => asset.id));
      const missingAssets = (Array.isArray(entry?.mediaAssets) ? entry.mediaAssets : [])
        .filter((asset) => asset?.storageMode !== "reference" && clean(asset?.id) && !normalizedIds.has(clean(asset.id)));
      if (missingAssets.length && !salvageInvalidMedia) throw new Error("案例包包含无法安全规范化的媒体描述");
      if (missingAssets.length) {
        const droppedIds = missingAssets.map((asset) => clean(asset.id));
        normalizationDroppedAssetIds.set(entryIndex, droppedIds);
        importStats.droppedMediaDescriptors += droppedIds.length;
        importDiagnostics.push(...droppedIds.map((assetId) => ({
          code: "media_descriptor_dropped",
          severity: "media",
          action: "dropped",
          entryId: clean(entry?.id),
          assetId,
          reason: "invalid_descriptor"
        })));
      }
    }
    normalized.customLabels = uniqueNames(entry?.customLabels);
    normalized.metadataLabels = uniqueNames(entry?.metadataLabels);
    return normalized;
  });
  for (let entryIndex = 0; entryIndex < data.entries.length; entryIndex += 1) {
    let entry = data.entries[entryIndex];
    const id = clean(entry?.id);
    if (!id || ids.has(id)) throw new Error("案例包包含无效或重复的案例编号");
    ids.add(id);
    entry.id = id;
    const entryAssets = new Map();
    const droppedAssetIds = [...(normalizationDroppedAssetIds.get(entryIndex) ?? [])];
    for (const asset of entry.mediaAssets) {
      const identityBlob = asset.storageMode === "reference" ? undefined : files.get(clean(asset.assetPath));
      const existingIdentity = mediaIdentities.get(asset.id);
      if (existingIdentity && !sameMediaIdentity(existingIdentity, mediaIdentity(asset, identityBlob))) {
        if (!salvageInvalidMedia) throw new Error("案例包包含冲突的媒体编号");
        droppedAssetIds.push(asset.id);
        importStats.droppedMediaDescriptors += 1;
        importDiagnostics.push({ code: "media_descriptor_dropped", severity: "media", action: "dropped",
          entryId: entry.id, assetId: asset.id, path: clean(asset.assetPath), reason: "duplicate_asset_id",
          message: "同一媒体编号对应不同内容,本项不能自动恢复" });
        continue;
      }
      if (asset.storageMode === "reference") {
        claimMedia(asset, undefined);
        continue;
      }
      const path = clean(asset.assetPath);
      let format;
      try {
        format = validatePortableMediaDescriptor(asset, path, packageVersion);
      } catch (error) {
        if (!salvageInvalidMedia) throw error;
        droppedAssetIds.push(asset.id);
        importStats.droppedMediaDescriptors += 1;
        importDiagnostics.push({
          code: "media_descriptor_dropped",
          severity: "media",
          action: "dropped",
          entryId: entry.id,
          assetId: asset.id,
          reason: "invalid_descriptor"
        });
        continue;
      }
      const blob = files.get(path);
      const failure = portableMediaFileFailure(entry, asset, blob, format, packageVersion, limits, skipMediaByteValidation);
      if (failure) {
        if (!salvageInvalidMedia) throw new Error(failure.message);
        droppedAssetIds.push(asset.id);
        importStats.droppedMediaFiles += 1;
        importDiagnostics.push({
          code: "media_file_dropped",
          severity: "media",
          action: "dropped",
          entryId: entry.id,
          assetId: asset.id,
          path,
          reason: failure.reason
        });
        continue;
      }
      claimMedia(asset, blob);
      entryAssets.set(asset.id, blob);
    }
    for (const assetId of droppedAssetIds) entry = removeEntryMedia(entry, assetId);
    const retainedAssetIds = new Set(entry.mediaAssets.map((asset) => asset.id));
    if (droppedAssetIds.length) {
      entry.facetAssignments = (entry.facetAssignments ?? []).flatMap((assignment) => {
        const visualId = clean(assignment?.visualId);
        if (!visualId || retainedAssetIds.has(visualId)) return [assignment];
        if (!AI_ASSIGNMENT_SOURCES.has(assignment?.source)) {
          const { visualId: _visualId, ...portableAssignment } = assignment;
          return [portableAssignment];
        }
        importStats.droppedAiAssignments += 1;
        importDiagnostics.push({
          code: "ai_assignment_dropped",
          severity: "metadata",
          action: "dropped",
          entryId: entry.id,
          reason: "missing_media"
        });
        return [];
      });
    }
    data.entries[entryIndex] = entry;
    for (const [assetId, blob] of entryAssets) {
      if (!retainedAssetIds.has(assetId)) continue;
      assets.set(assetId, blob);
      if (entry.mediaAssets.find((asset) => asset.id === assetId)?.kind === "image") images.set(assetId, blob);
    }
  }
  if (salvageInvalidMedia) {
    data.entries = data.entries.filter((entry) => {
      if (hasRecoverableCaseContent(entry)) return true;
      ids.delete(entry.id);
      importStats.keptCases = Math.max(0, importStats.keptCases - 1);
      importStats.skippedCases += 1;
      importDiagnostics.push({
        code: "case_skipped_after_media_loss",
        severity: "case",
        action: "skipped",
        entryId: entry.id,
        reason: "no_usable_content"
      });
      return false;
    });
  }
  data.compoundCases = normalizeCompoundCases(data.compoundCases, data.entries);
  data.trashState = normalizeTrashState(data.trashState);
  const retainedTrashItems = [];
  for (const item of data.trashState.items) {
    if (item.kind !== "entry" && item.kind !== "media") {
      retainedTrashItems.push(item);
      continue;
    }
    let entry = item.kind === "entry"
      ? normalizeEntryMedia(item.snapshot)
      : normalizeEntryMedia({
          id: clean(item.relationships?.entryId) || `trash-media:${item.targetId}`,
          title: clean(item.snapshot?.sourceTitle) || "回收站媒体",
          mediaAssets: item.snapshot?.mediaAssets ?? [],
          primaryMediaId: ""
        });
    const droppedAssetIds = [];
    for (const asset of entry.mediaAssets) {
      const identityBlob = asset.storageMode === "reference" ? undefined : files.get(clean(asset.assetPath));
      const existingIdentity = mediaIdentities.get(asset.id);
      if (existingIdentity && !sameMediaIdentity(existingIdentity, mediaIdentity(asset, identityBlob))) {
        if (!salvageInvalidMedia) throw new Error("完整备份包含冲突的媒体编号");
        droppedAssetIds.push(asset.id);
        importStats.droppedTrashMedia += 1;
        importDiagnostics.push(trashMediaDiagnostic(item, asset, "duplicate_asset_id"));
        continue;
      }
      if (asset.storageMode === "reference") {
        claimMedia(asset, undefined);
        continue;
      }
      const path = clean(asset.assetPath);
      let format;
      try {
        format = validatePortableMediaDescriptor(asset, path, packageVersion);
      } catch (error) {
        if (!salvageInvalidMedia) throw error;
        droppedAssetIds.push(asset.id);
        importStats.droppedMediaDescriptors += 1;
        importStats.droppedTrashMedia += 1;
        importDiagnostics.push(trashMediaDiagnostic(item, asset, "invalid_descriptor"));
        continue;
      }
      const blob = files.get(path);
      const failure = portableMediaFileFailure(entry, asset, blob, format, packageVersion, limits, skipMediaByteValidation);
      if (failure) {
        if (!salvageInvalidMedia) throw new Error(t("回收站中的“{title}”{reason}", { title: entry.title || t("未命名案例"), reason: failure.message }));
        droppedAssetIds.push(asset.id);
        importStats.droppedMediaFiles += 1;
        importStats.droppedTrashMedia += 1;
        importDiagnostics.push(trashMediaDiagnostic(item, asset, failure.reason));
        continue;
      }
      claimMedia(asset, blob);
      assets.set(asset.id, blob);
      if (asset.kind === "image") images.set(asset.id, blob);
    }
    for (const assetId of droppedAssetIds) entry = removeEntryMedia(entry, assetId);
    const trashMediaIds = new Set(entry.mediaAssets.map((asset) => asset.id));
    if (item.kind === "entry") {
      entry.facetAssignments = dropDanglingAiAssignments(entry.facetAssignments, {
        facetIds: packageFacetIds,
        nodeIds: packageNodeIds,
        mediaIds: trashMediaIds,
        entryId: entry.id,
        importDiagnostics,
        importStats
      });
      if (salvageInvalidMedia && !hasRecoverableCaseContent(entry)) {
        importDiagnostics.push({
          code: "trash_item_skipped",
          severity: "trash",
          action: "skipped",
          targetId: item.targetId,
          reason: "no_usable_content"
        });
        continue;
      }
      item.snapshot = entry;
    } else {
      if (salvageInvalidMedia && !trashMediaIds.has(item.targetId)) {
        importDiagnostics.push({
          code: "trash_item_skipped",
          severity: "trash",
          action: "skipped",
          targetId: item.targetId,
          reason: "missing_target_media"
        });
        continue;
      }
      item.snapshot.mediaAssets = entry.mediaAssets;
      item.snapshot.facetAssignments = dropDanglingAiAssignments(item.snapshot?.facetAssignments, {
        facetIds: packageFacetIds,
        nodeIds: packageNodeIds,
        mediaIds: trashMediaIds,
        entryId: clean(item.relationships?.entryId) || item.targetId,
        importDiagnostics,
        importStats
      });
      item.relationships.positions = (item.relationships?.positions ?? [])
        .filter((position) => trashMediaIds.has(clean(position?.id)));
      item.relationships.primaryMediaId = trashMediaIds.has(clean(item.relationships?.primaryMediaId))
        ? item.relationships.primaryMediaId
        : "";
      item.relationships.facetAssignments = dropDanglingAiAssignments(item.relationships?.facetAssignments, {
        facetIds: packageFacetIds,
        nodeIds: packageNodeIds,
        mediaIds: trashMediaIds,
        entryId: clean(item.relationships?.entryId) || item.targetId,
        importDiagnostics,
        importStats
      });
    }
    retainedTrashItems.push(item);
  }
  data.trashState = normalizeTrashState({ ...data.trashState, items: retainedTrashItems });
  data.organizerState = normalizeOrganizerState(data.organizerState, [...ids]);
  data.composerSettings = normalizeComposerSettings(data.composerSettings);
  data.composerSessions = normalizeComposerSessions(data.composerSessions);
  for (const session of data.composerSessions) for (const checkpoint of Object.values(session.toolContinuations || {})) checkpoint.needsTargetReview = true;
  for (const session of data.composerSessions) {
    for (const reference of session.referenceSnapshots) {
      if (reference.sourceType !== "temporary") continue;
      const retainedAssetRefs = [];
      const droppedAssetIds = new Set();
      for (const asset of reference.assetRefs) {
        const path = clean(asset.archivePath);
        if (!validTemporaryAssetPath(path)) {
          if (!salvageInvalidMedia) throw new Error(t("临时附件路径无效:{name}", { name: asset.name || asset.assetId }));
          droppedAssetIds.add(asset.assetId);
          importStats.droppedTemporaryAssets += 1;
          importDiagnostics.push(privateResourceDiagnostic("temporary_asset_dropped", asset, path, "invalid_descriptor"));
          continue;
        }
        const blob = files.get(path);
        if (!(blob instanceof Blob) || !blobMatchesKind(blob, asset.kind)) {
          if (!salvageInvalidMedia) throw new Error(t("临时附件缺失或类型不符:{name}", { name: asset.name || asset.assetId }));
          droppedAssetIds.add(asset.assetId);
          importStats.droppedMediaFiles += 1;
          importStats.droppedTemporaryAssets += 1;
          importDiagnostics.push(privateResourceDiagnostic(
            "temporary_asset_dropped", asset, path, blob instanceof Blob ? "type_mismatch" : "missing_file"
          ));
          continue;
        }
        const byteLimit = portableAssetByteLimit(asset.kind, limits);
        if (blob.size > byteLimit) {
          if (!salvageInvalidMedia) throw new Error(t("临时附件超过 {limit} 上限:{name}", { limit: formatBytes(byteLimit), name: asset.name || asset.assetId }));
          droppedAssetIds.add(asset.assetId);
          importStats.droppedMediaFiles += 1;
          importStats.droppedTemporaryAssets += 1;
          importDiagnostics.push(privateResourceDiagnostic("temporary_asset_dropped", asset, path, "size_limit"));
          continue;
        }
        if (!skipMediaByteValidation && asset.byteSize && asset.byteSize !== blob.size) {
          if (!salvageInvalidMedia) throw new Error(t("临时附件大小校验失败:{name}", { name: asset.name || asset.assetId }));
          droppedAssetIds.add(asset.assetId);
          importStats.droppedMediaFiles += 1;
          importStats.droppedTemporaryAssets += 1;
          importDiagnostics.push(privateResourceDiagnostic("temporary_asset_dropped", asset, path, "byte_size_mismatch"));
          continue;
        }
        if (!claimMedia({ ...asset, id: asset.assetId }, blob)) {
          if (!salvageInvalidMedia) throw new Error("案例包包含冲突的临时附件编号");
          droppedAssetIds.add(asset.assetId);
          importStats.droppedTemporaryAssets += 1;
          importDiagnostics.push(privateResourceDiagnostic("temporary_asset_dropped", asset, path, "duplicate_asset_id"));
          continue;
        }
        assets.set(asset.assetId, blob);
        if (asset.kind === "image") images.set(asset.assetId, blob);
        retainedAssetRefs.push(asset);
      }
      reference.assetRefs = retainedAssetRefs;
      reference.imageRefs = reference.imageRefs.filter((image) => !droppedAssetIds.has(clean(image?.visualId)));
    }
  }
  data.creativeExperimentSettings = normalizeCreativeExperimentSettings(data.creativeExperimentSettings);
  data.creativeRuns = normalizeCreativeRuns(data.creativeRuns);
  data.creativeSkills = normalizeCreativeSkillsState(data.creativeSkills);
  for (const run of data.creativeRuns) {
    const retainedOutputs = [];
    for (const output of run.outputs) {
      const visual = output.visual;
      const path = clean(visual.assetPath || visual.screenshotPath);
      const video = visual.kind === "video" || String(visual.mimeType ?? "").startsWith("video/");
      if (!validCreativeResultPath(path, video ? "video" : "image")) {
        if (!salvageInvalidMedia) throw new Error("创作实验包包含无效的结果媒体路径");
        importStats.droppedCreativeOutputs += 1;
        importDiagnostics.push(privateResourceDiagnostic("creative_output_dropped", visual, path, "invalid_descriptor"));
        continue;
      }
      const asset = files.get(path);
      if (!(asset instanceof Blob) || !blobMatchesKind(asset, video ? "video" : "image")) {
        if (!salvageInvalidMedia) throw new Error(t(video ? "创作实验包缺少结果视频" : "创作实验包缺少结果图片"));
        importStats.droppedMediaFiles += 1;
        importStats.droppedCreativeOutputs += 1;
        importDiagnostics.push(privateResourceDiagnostic(
          "creative_output_dropped", visual, path, asset instanceof Blob ? "type_mismatch" : "missing_file"
        ));
        continue;
      }
      const byteLimit = portableAssetByteLimit(video ? "video" : "image", limits);
      if (asset.size > byteLimit) {
        if (!salvageInvalidMedia) throw new Error(t("创作结果媒体超过 {limit} 上限", { limit: formatBytes(byteLimit) }));
        importStats.droppedMediaFiles += 1;
        importStats.droppedCreativeOutputs += 1;
        importDiagnostics.push(privateResourceDiagnostic("creative_output_dropped", visual, path, "size_limit"));
        continue;
      }
      if (!claimMedia({ ...visual, kind: video ? "video" : "image" }, asset)) {
        if (!salvageInvalidMedia) throw new Error("案例包包含冲突的结果媒体编号");
        importStats.droppedCreativeOutputs += 1;
        importDiagnostics.push(privateResourceDiagnostic("creative_output_dropped", visual, path, "duplicate_asset_id"));
        continue;
      }
      assets.set(visual.id, asset);
      if (!video) images.set(visual.id, asset);
      retainedOutputs.push(output);
    }
    run.outputs = retainedOutputs;
    const retainedVisualIds = new Set(retainedOutputs.map((output) => output.visual.id));
    run.events = run.events.filter((event) => retainedVisualIds.has(event.visualId));
  }
  for (const skill of data.creativeSkills.items) for (const owner of skillFileOwners(skill)) {
    const retainedFiles = [];
    for (const file of owner.packageFiles ?? []) {
      const path = clean(file.archivePath);
      if (!/^skills\/[A-Za-z0-9._/-]+$/i.test(path) || path.includes("..")) {
        if (!salvageInvalidMedia) throw new Error(t("外部 Skill 原包路径无效:{path}", { path: file.path }));
        importStats.droppedSkillFiles += 1;
        importDiagnostics.push(privateResourceDiagnostic("skill_file_dropped", file, path, "invalid_descriptor"));
        continue;
      }
      const blob = files.get(path);
      if (!(blob instanceof Blob)) {
        if (!salvageInvalidMedia) throw new Error(t("外部 Skill 原包文件缺失:{path}", { path: file.path }));
        importStats.droppedMediaFiles += 1;
        importStats.droppedSkillFiles += 1;
        importDiagnostics.push(privateResourceDiagnostic("skill_file_dropped", file, path, "missing_file"));
        continue;
      }
      if (blob.size > limits.maxFileBytes) {
        if (!salvageInvalidMedia) throw new Error(t("外部 Skill 文件超过 {limit} 上限", { limit: formatBytes(limits.maxFileBytes) }));
        importStats.droppedMediaFiles += 1;
        importStats.droppedSkillFiles += 1;
        importDiagnostics.push(privateResourceDiagnostic("skill_file_dropped", file, path, "size_limit"));
        continue;
      }
      if (!skipMediaByteValidation && file.byteSize && file.byteSize !== blob.size) {
        if (!salvageInvalidMedia) throw new Error(t("外部 Skill 文件大小校验失败:{path}", { path: file.path }));
        importStats.droppedMediaFiles += 1;
        importStats.droppedSkillFiles += 1;
        importDiagnostics.push(privateResourceDiagnostic("skill_file_dropped", file, path, "byte_size_mismatch"));
        continue;
      }
      if (!claimMedia({ id: file.assetId, kind: 'skill-file' }, blob)) {
        if (!salvageInvalidMedia) throw new Error(t("Skill版本包含冲突的文件编号:{path}", { path: file.path }));
        importStats.droppedSkillFiles += 1;
        importDiagnostics.push(privateResourceDiagnostic('skill_file_dropped', file, path, 'duplicate_asset_id'));
        continue;
      }
      skillAssets.set(file.assetId, blob);
      retainedFiles.push(file);
    }
    owner.packageFiles = retainedFiles;
  }
  return {
    ...data,
    schemaVersion: SCHEMA_VERSION,
    sourcePackageVersion: packageVersion,
    importDiagnostics,
    importStats,
    assets,
    images,
    skillAssets
  };
}

export function selectLibraryPackage(state = {}, entryIds = []) {
  const requestedIds = new Set(entryIds.map(clean).filter(Boolean));
  const compounds = normalizeCompoundCases(state.compoundCases, state.entries);
  const selectedIds = new Set(expandLogicalCaseIds([...requestedIds], compounds));
  const entries = (state.entries ?? []).filter((entry) => selectedIds.has(entry.id));
  entries.forEach(assertCaseFilesReadable);
  if (!entries.length) throw new Error("请先选择要分享的案例");
  const catalog = normalizeFacetCatalog(state.facetCatalog);
  const usedNodeIds = new Set(entries.flatMap((entry) =>
    (entry.facetAssignments ?? []).map((item) => item.nodeId).filter(Boolean)
  ));
  const byId = new Map(catalog.nodes.map((node) => [node.id, node]));
  for (const nodeId of [...usedNodeIds]) {
    let current = byId.get(nodeId);
    while (current?.parentId) {
      usedNodeIds.add(current.parentId);
      current = byId.get(current.parentId);
    }
  }
  const usedFacetIds = new Set([...usedNodeIds].map((id) => byId.get(id)?.facetId).filter(Boolean));
  const selected = {
    ...state,
    entries: entries.map(sanitizeSharedEntry),
    taxonomy: {
      ...normalizeTaxonomy(state.taxonomy),
      nodes: normalizeTaxonomy(state.taxonomy).nodes.filter((node) => entries.some((entry) => entry.classification?.pathIds?.[0] === node.id))
    },
    facetCatalog: {
      ...catalog,
      facets: catalog.facets.filter((facet) => usedFacetIds.has(facet.id)),
      nodes: catalog.nodes.filter((node) => usedNodeIds.has(node.id))
    },
    classificationRules: [],
    compoundCases: compounds.filter((item) => requestedIds.has(item.id) || item.memberEntryIds.every((id) => selectedIds.has(id))),
    organizerState: createDefaultOrganizerState(),
    composerSettings: undefined,
    composerSessions: [],
    creativeExperimentSettings: undefined,
    creativeRuns: [],
    creativeSkills: { version: 1, items: [] }
  };
  const equivalent = new Map();
  for (const entry of selected.entries) {
    const fingerprint = caseSemanticFingerprint(entry);
    if (!fingerprint) continue;
    const group = equivalent.get(fingerprint) ?? [];
    group.push(entry);
    equivalent.set(fingerprint, group);
  }
  // Selection sharing omits private folders. Preserve separately selected cases
  // that would otherwise become indistinguishable once that context is removed.
  for (const group of equivalent.values()) {
    if (group.length < 2) continue;
    for (const entry of group) entry.caseInstanceId ||= `case-instance:${entry.id}`;
  }
  return selected;
}

export function selectProjectPackage(state = {}, collectionId) {
  const organizer = normalizeOrganizerState(state.organizerState, (state.entries ?? []).map((entry) => entry.id));
  const collection = organizer.collections.find((item) => item.id === clean(collectionId));
  if (!collection) throw new Error("项目不存在");
  const subtreeIds = collectionSubtreeIds(organizer, collection.id);
  if (!collectionEntryIds(organizer, collection.id, { subtree: true }).length) throw new Error("这个项目及其子项目还没有可分享的案例");
  const exportedEntryIds = projectPackageEntryIds(state, collection.id);
  const selected = selectLibraryPackage(state, exportedEntryIds);
  const selectedEntryIds = new Set(selected.entries.map((entry) => entry.id));
  selected.organizerState = normalizeOrganizerState({
    version: organizer.version,
    collections: organizer.collections
      .filter((item) => subtreeIds.includes(item.id))
      .map((item) => ({
        ...structuredClone(item),
        parentId: item.id === collection.id ? null : item.parentId,
        order: item.id === collection.id ? 0 : item.order,
        entryIds: item.entryIds.filter((entryId) => selectedEntryIds.has(entryId))
      }))
  }, selected.entries.map((entry) => entry.id));
  return selected;
}

export function projectPackageEntryIds(state = {}, collectionId) {
  const entries = Array.isArray(state.entries) ? state.entries : [];
  const validEntryIds = new Set(entries.map((entry) => clean(entry?.id)).filter(Boolean));
  const organizer = normalizeOrganizerState(state.organizerState, [...validEntryIds]);
  const collection = organizer.collections.find((item) => item.id === clean(collectionId));
  if (!collection) throw new Error("项目不存在");
  const selectedIds = collectionEntryIds(organizer, collection.id, { subtree: true });
  const selectedSet = new Set(selectedIds);
  for (const compound of normalizeCompoundCases(state.compoundCases, entries)) {
    if (!compound.memberEntryIds.some((entryId) => selectedSet.has(entryId))) continue;
    for (const entryId of compound.memberEntryIds) {
      if (selectedSet.has(entryId)) continue;
      selectedSet.add(entryId);
      selectedIds.push(entryId);
    }
  }
  return selectedIds.filter((entryId) => validEntryIds.has(entryId));
}

function sanitizeSharedEntry(entry) {
  const next = normalizeEntryVisuals(entry);
  delete next.libraryAddedAt;
  delete next.importBatchId;
  next.mediaAssets = next.mediaAssets.map((asset) => {
    if (!asset.visionAnalysis) return asset;
    const {
      imageFingerprint: _imageFingerprint,
      profileFingerprint: _profileFingerprint,
      providerType: _providerType,
      provider: _provider,
      model: _model,
      usage: _usage,
      batchJobId: _batchJobId,
      ...portableAnalysis
    } = asset.visionAnalysis;
    return { ...asset, visionAnalysis: structuredClone(portableAnalysis) };
  });
  delete next.visionAnalysisUndo;
  if (next.creationMeta) {
    const { methodVersion, targetPlatform, outputLanguage, createdAt } = next.creationMeta;
    next.creationMeta = { methodVersion, targetPlatform, outputLanguage, createdAt };
  }
  return next;
}

export function mergeLibraryPackage(current = {}, importedValue = {}, options = {}) {
  const priorImportEvidence = importReportEvidence(options.importReport) ?? parsedImportEvidence(importedValue);
  const imported = parseLibraryPackage(importedValue, packageImagePlaceholders(importedValue), {
    skipMediaByteValidation: true
  });
  if (priorImportEvidence) {
    imported.importDiagnostics = mergeImportDiagnostics(priorImportEvidence.diagnostics, imported.importDiagnostics);
    imported.importStats = mergeImportStats(priorImportEvidence.stats, imported.importStats);
  }
  const importedTrashAssets = trashMediaAssets(imported.trashState);
  const importMetadata = localImportMetadata(options);
  const retainedAssetIds = libraryStoredAssetIds(current, { includeLocalOnly: true });
  const empty = options.preserveLibraryConfiguration !== true
    && !retainedAssetIds.size && !options.reservedVisualIds?.length
    && !libraryHasRetainedContentOrConfiguration(current);
  if (empty) {
    const skillMerge = mergeCreativeSkillsState(current.creativeSkills, imported.creativeSkills, options);
    return {
      state: {
        ...structuredClone(current),
        entries: imported.entries.map((entry) => withLocalImportMetadata(withoutArchivePath(entry), importMetadata)),
        trashState: imported.trashState,
        settings: imported.settings,
        taxonomy: imported.taxonomy,
        facetCatalog: imported.facetCatalog,
        classificationRules: imported.classificationRules,
        compoundCases: imported.compoundCases,
        organizerState: imported.organizerState,
        composerSettings: imported.composerSettings,
        composerSessions: imported.composerSessions.map((session) => remapAppliedSkillReferences(
          withoutComposerArchivePaths(session),
          skillMerge.skillIdMap,
          skillMerge.skillVersionIdMap
        )),
        creativeExperimentSettings: imported.creativeExperimentSettings,
        creativeRuns: imported.creativeRuns.map((run) => remapAppliedSkillReferences(
          withoutCreativeArchivePaths(run),
          skillMerge.skillIdMap,
          skillMerge.skillVersionIdMap
        )),
        creativeSkills: skillMerge.state
      },
      entryIdMap: Object.fromEntries(imported.entries.map((entry) => [entry.id, entry.id])),
      collectionIdMap: Object.fromEntries(imported.organizerState.collections.map((item) => [item.id, item.id])),
      facetIdMap: Object.fromEntries(imported.facetCatalog.facets.map((item) => [item.id, item.id])),
      nodeIdMap: Object.fromEntries(imported.facetCatalog.nodes.map((item) => [item.id, item.id])),
      compoundIdMap: Object.fromEntries(imported.compoundCases.map((item) => [item.id, item.id])),
      visualIdMap: Object.fromEntries([
        ...imported.entries.flatMap((entry) => entry.mediaAssets.map((visual) => [visual.id, visual.id])),
        ...imported.creativeRuns.flatMap((run) => run.outputs.map((output) => [output.visual.id, output.visual.id])),
        ...temporaryReferenceAssets(imported.composerSessions).map((asset) => [asset.assetId, asset.assetId]),
        ...importedTrashAssets.map((asset) => [asset.id, asset.id])
      ]),
      createdVisualIdMap: Object.fromEntries([
        ...imported.entries.flatMap((entry) => entry.mediaAssets.map((visual) => [visual.id, visual.id])),
        ...imported.creativeRuns.flatMap((run) => run.outputs.map((output) => [output.visual.id, output.visual.id])),
        ...temporaryReferenceAssets(imported.composerSessions).map((asset) => [asset.assetId, asset.assetId]),
        ...importedTrashAssets.map((asset) => [asset.id, asset.id])
      ]),
      skillIdMap: skillMerge.skillIdMap,
      skillVersionIdMap: skillMerge.skillVersionIdMap,
      packageAssetIdMap: skillMerge.packageAssetIdMap,
      importedSkillCount: skillMerge.importedSkillCount,
      skippedSkillCount: skillMerge.skippedSkillCount,
      importedRunCount: imported.creativeRuns.length,
      importedOutputCount: imported.creativeRuns.reduce((sum, run) => sum + run.outputs.length, 0),
      importedCount: imported.entries.length,
      createdEntryIds: imported.entries.map((entry) => entry.id),
      importDiagnostics: imported.importDiagnostics,
      importStats: imported.importStats,
      remappedCount: 0,
      skippedCount: 0
    };
  }

  const next = structuredClone(current);
  next.taxonomy = normalizeTaxonomy(next.taxonomy);
  next.facetCatalog = normalizeFacetCatalog(next.facetCatalog);
  next.settings = normalizeSettings(next.settings);
  next.classificationRules = Array.isArray(next.classificationRules) ? next.classificationRules : [];
  next.entries = Array.isArray(next.entries) ? next.entries : [];
  next.organizerState = normalizeOrganizerState(next.organizerState, next.entries.map((entry) => entry.id));
  next.compoundCases = normalizeCompoundCases(next.compoundCases, next.entries);
  const taxonomyMerge = mergeTaxonomies(next.taxonomy, imported.taxonomy);
  next.taxonomy = taxonomyMerge.taxonomy;
  const { facetIds, nodeIds } = mergeVocabulary(next.facetCatalog, imported.facetCatalog, options);
  const usedEntryIds = new Set(next.entries.map((entry) => entry.id));
  const entriesById = new Map(next.entries.map((entry) => [entry.id, entry]));
  const entriesByFingerprint = new Map();
  const fingerprintById = new Map();
  const currentScopes = libraryCaseScopes(next);
  const importedScopes = libraryCaseScopes(imported);
  function scopedFingerprint(entry, scope) {
    const content = caseSemanticFingerprint(normalizeEntryMedia(entry));
    return content ? JSON.stringify([scope, content]) : "";
  }
  function indexEntry(entry, scope = currentScopes.get(entry.id)) {
    const fingerprint = scopedFingerprint(entry, scope);
    if (!fingerprint) return;
    const matches = entriesByFingerprint.get(fingerprint) ?? new Set();
    matches.add(entry);
    entriesByFingerprint.set(fingerprint, matches);
    fingerprintById.set(entry.id, fingerprint);
  }
  for (const entry of next.entries) indexEntry(entry);
  const usedVisualIds = new Set([
    ...retainedAssetIds,
    ...(Array.isArray(options.reservedVisualIds) ? options.reservedVisualIds : [])
  ]);
  const entryIdMap = {};
  const visualIdMap = { ...(options.visualIdMap ?? {}) };
  const createdVisualIdMap = {};
  const organizerEntryIdMap = {};
  let importedCount = 0;
  const createdEntryIds = [];
  let remappedCount = 0;
  let skippedCount = 0;
  for (const source of imported.entries) {
    let idCollision = usedEntryIds.has(source.id);
    const sourceFingerprint = scopedFingerprint(source, importedScopes.get(source.id));
    const existing = entriesById.get(source.id);
    const sameExportedInstance = source.caseInstanceId === `case-instance:${source.id}` && existing && !existing.caseInstanceId
      && currentScopes.get(existing.id) === importedScopes.get(source.id)
      && scopedFingerprint({ ...source, caseInstanceId: undefined }, importedScopes.get(source.id)) === scopedFingerprint(existing, currentScopes.get(existing.id));
    const identical = !options.preserveCaseIdentities && sourceFingerprint &&
      (entriesByFingerprint.get(sourceFingerprint)?.values().next().value || (sameExportedInstance ? existing : null));
    if (identical) {
      skippedCount += 1;
      entryIdMap[source.id] = identical.id;
      organizerEntryIdMap[source.id] = identical.id;
      const sourceAssets = normalizeEntryMedia(source).mediaAssets;
      const existingAssets = normalizeEntryMedia(identical).mediaAssets;
      for (let index = 0; index < sourceAssets.length; index += 1) {
        if (existingAssets[index] && !createdVisualIdMap[sourceAssets[index].id]) visualIdMap[sourceAssets[index].id] = existingAssets[index].id;
      }
      continue;
    }
    const conflictResolution = clean(options.entryConflictResolutions?.[source.id]);
    if (idCollision && conflictResolution === "use-incoming") {
      const fingerprint = fingerprintById.get(source.id);
      const matches = entriesByFingerprint.get(fingerprint);
      matches?.delete(entriesById.get(source.id));
      if (matches?.size === 0) entriesByFingerprint.delete(fingerprint);
      fingerprintById.delete(source.id);
      entriesById.delete(source.id);
      next.entries = next.entries.filter((entry) => entry.id !== source.id);
      next.organizerState = removeEntriesFromOrganizer(next.organizerState, [source.id]);
      next.compoundCases = removeEntriesFromCompoundCases(next.compoundCases, current.entries, [source.id]);
      usedEntryIds.delete(source.id);
      idCollision = false;
    }
    if (idCollision && (conflictResolution === "keep-local" || options.skipExistingEntryIds === true)) {
      const existing = entriesById.get(source.id);
      skippedCount += 1;
      entryIdMap[source.id] = source.id;
      organizerEntryIdMap[source.id] = source.id;
      if (existing) {
        const sourceAssets = normalizeEntryMedia(source).mediaAssets;
        const existingAssets = normalizeEntryMedia(existing).mediaAssets;
        for (let index = 0; index < sourceAssets.length; index += 1) {
          if (existingAssets[index] && !createdVisualIdMap[sourceAssets[index].id]) visualIdMap[sourceAssets[index].id] = existingAssets[index].id;
        }
      }
      continue;
    }
    const preferred = clean(options.entryIdMap?.[source.id]);
    const targetId = preferred && !usedEntryIds.has(preferred)
      ? preferred
      : usedEntryIds.has(source.id)
        ? uniqueId("entry", usedEntryIds)
        : source.id;
    if (idCollision) remappedCount += 1;
    if (usedEntryIds.has(targetId)) throw new Error("导入期间案例库发生变化,请重试");
    const entry = withoutArchivePath(structuredClone(source));
    Object.assign(entry, importMetadata);
    entry.importSource = { entryId: source.id };
    entry.id = targetId;
    const sourceContentId = entry.classification?.pathIds?.[0];
    const targetContentId = taxonomyMerge.idMap[sourceContentId];
    if (targetContentId) entry.classification.pathIds = [targetContentId];
    else entry.classification = {
      pathIds: [], status: "needs_review", source: "auto", reason: "导入包缺少对应内容类型"
    };
    entry.mediaAssets = entry.mediaAssets.map((visual) => {
      const preferredVisualId = visual.id === source.id && targetId !== source.id ? targetId : visual.id;
      const mappedVisualId = clean(options.visualIdMap?.[visual.id]);
      const targetVisualId = createdVisualIdMap[visual.id] || (usedVisualIds.has(preferredVisualId)
        ? mappedVisualId && !usedVisualIds.has(mappedVisualId)
          ? mappedVisualId
          : uniqueId("visual", usedVisualIds)
        : preferredVisualId);
      usedVisualIds.add(targetVisualId);
      visualIdMap[visual.id] = targetVisualId;
      createdVisualIdMap[visual.id] = targetVisualId;
      return { ...visual, id: targetVisualId };
    });
    entry.primaryMediaId = visualIdMap[entry.primaryMediaId] ?? entry.primaryMediaId;
    if (entry.coverVisualId) entry.coverVisualId = visualIdMap[entry.coverVisualId] ?? entry.coverVisualId;
    entry.articleDocument = remapArticleDocumentAssets(entry.articleDocument, visualIdMap);
    entry.mediaAssets = entry.mediaAssets.map((asset) => ({
      ...asset,
      ...(asset.posterAssetId ? { posterAssetId: visualIdMap[asset.posterAssetId] ?? asset.posterAssetId } : {}),
      ...(asset.derivedFromAssetId ? { derivedFromAssetId: visualIdMap[asset.derivedFromAssetId] ?? asset.derivedFromAssetId } : {})
    }));
    entry.timeNotes = (entry.timeNotes ?? []).map((note) => ({
      ...note,
      assetId: visualIdMap[note.assetId] ?? note.assetId,
      ...(note.frameAssetId ? { frameAssetId: visualIdMap[note.frameAssetId] ?? note.frameAssetId } : {})
    }));
    entry.mediaPrompts = (entry.mediaPrompts ?? []).map((prompt) => ({
      ...prompt,
      assetId: visualIdMap[prompt.assetId] ?? prompt.assetId
    }));
    Object.assign(entry, remapMediaAnalysisAssets(entry, visualIdMap));
    entry.facetAssignments = (entry.facetAssignments ?? []).map((item) => {
      const facetId = facetIds.get(item.facetId);
      const nodeId = nodeIds.get(item.nodeId);
      if (!facetId || !nodeId) {
        throw new Error(t("分享包中的案例“{title}”引用了缺失的 AI 标签词表,导入已取消且没有写入案例", { title: clean(entry.title) || source.id }));
      }
      return {
        ...item,
        facetId,
        nodeId,
        ...(item.visualId ? { visualId: visualIdMap[item.visualId] ?? item.visualId } : {})
      };
    });
    next.entries.push(entry);
    entriesById.set(targetId, entry);
    indexEntry(entry, importedScopes.get(source.id));
    usedEntryIds.add(targetId);
    createdEntryIds.push(targetId);
    entryIdMap[source.id] = targetId;
    organizerEntryIdMap[source.id] = targetId;
    importedCount += 1;
  }
  for (const targetId of Object.values(entryIdMap)) {
    const importedEntry = entriesById.get(targetId);
    if (!importedEntry?.creationMeta?.sourceEntryIds) continue;
    importedEntry.creationMeta.sourceEntryIds = importedEntry.creationMeta.sourceEntryIds.map((id) => organizerEntryIdMap[id] ?? id);
  }
  const organizerMerge = mergeOrganizerStateWithMap(
    next.organizerState,
    imported.organizerState,
    organizerEntryIdMap,
    {
      ...(options.preserveLibraryConfiguration === true ? { createdAt: importMetadata.libraryAddedAt } : {}),
      collectionIdMap: options.collectionIdMap
    }
  );
  next.organizerState = organizerMerge.state;
  const usedCompoundIds = new Set([
    ...next.entries.map((entry) => entry.id),
    ...next.compoundCases.map((item) => item.id)
  ]);
  const compoundIdMap = {};
  for (const source of imported.compoundCases) {
    const memberEntryIds = source.memberEntryIds.map((id) => organizerEntryIdMap[id]).filter(Boolean);
    if (memberEntryIds.length < 2) continue;
    const preferred = clean(options.compoundIdMap?.[source.id]);
    const targetId = !usedCompoundIds.has(source.id)
      ? source.id
      : preferred && !usedCompoundIds.has(preferred)
        ? preferred
        : uniqueId("compound", usedCompoundIds);
    usedCompoundIds.add(targetId);
    compoundIdMap[source.id] = targetId;
    next.compoundCases.push({
      ...source,
      id: targetId,
      memberEntryIds,
      coverVisualId: visualIdMap[source.coverVisualId] ?? source.coverVisualId
    });
  }
  next.compoundCases = normalizeCompoundCases(next.compoundCases, next.entries);
  next.composerSettings = normalizeComposerSettings(next.composerSettings);
  for (const asset of temporaryReferenceAssets(imported.composerSessions)) {
    if (visualIdMap[asset.assetId]) continue;
    const targetAssetId = usedVisualIds.has(asset.assetId) ? uniqueId("temp-reference", usedVisualIds) : asset.assetId;
    usedVisualIds.add(targetAssetId);
    visualIdMap[asset.assetId] = targetAssetId;
    createdVisualIdMap[asset.assetId] = targetAssetId;
  }
  const skillMerge = mergeCreativeSkillsState(next.creativeSkills, imported.creativeSkills, {
    ...options, reservedAssetIds: [...usedVisualIds]
  });
  next.creativeSkills = skillMerge.state;
  for (const id of libraryStoredAssetIds({ creativeSkills: next.creativeSkills })) usedVisualIds.add(id);
  const composerMerge = mergeComposerSessions(
    next.composerSessions,
    imported.composerSessions,
    organizerEntryIdMap,
    options.sessionIdMap,
    visualIdMap,
    skillMerge.skillIdMap,
    skillMerge.skillVersionIdMap
  );
  next.composerSessions = composerMerge.sessions;
  next.creativeExperimentSettings = normalizeCreativeExperimentSettings(
    next.creativeExperimentSettings ?? imported.creativeExperimentSettings
  );
  const creativeMerge = mergeCreativeRuns(
    next.creativeRuns,
    imported.creativeRuns,
    composerMerge.sessionIdMap,
    usedVisualIds,
    visualIdMap,
    options.runIdMap,
    skillMerge.skillIdMap,
    skillMerge.skillVersionIdMap
  );
  next.creativeRuns = creativeMerge.runs;
  for (const run of imported.creativeRuns) {
    for (const output of run.outputs) {
      const sourceId = output.visual.id;
      if (visualIdMap[sourceId]) createdVisualIdMap[sourceId] = visualIdMap[sourceId];
    }
  }
  const trashMerge = mergeImportedTrashState(next.trashState, imported.trashState, {
    activeEntryIds: next.entries.map((entry) => entry.id),
    activeCollectionIds: next.organizerState.collections.map((collection) => collection.id),
    activeCompoundIds: [
      ...next.entries.map((entry) => entry.id),
      ...next.compoundCases.map((compound) => compound.id)
    ],
    activeVisualIds: [...usedVisualIds],
    entryIdMap: organizerEntryIdMap,
    collectionIdMap: organizerMerge.collectionIdMap,
    preferredEntryIdMap: options.trashEntryIdMap,
    preferredCollectionIdMap: options.trashCollectionIdMap,
    preferredCompoundIdMap: options.trashCompoundIdMap,
    preferredVisualIdMap: options.visualIdMap,
    sharedVisualIdMap: visualIdMap
  });
  next.trashState = trashMerge.trashState;
  Object.assign(visualIdMap, trashMerge.visualIdMap);
  Object.assign(createdVisualIdMap, trashMerge.visualIdMap);
  return {
    state: next,
    entryIdMap,
    collectionIdMap: organizerMerge.collectionIdMap,
    facetIdMap: Object.fromEntries(facetIds),
    nodeIdMap: Object.fromEntries(nodeIds),
    visualIdMap,
    createdVisualIdMap,
    sessionIdMap: composerMerge.sessionIdMap,
    runIdMap: creativeMerge.runIdMap,
    compoundIdMap,
    skillIdMap: skillMerge.skillIdMap,
    skillVersionIdMap: skillMerge.skillVersionIdMap,
    packageAssetIdMap: skillMerge.packageAssetIdMap,
    importedSkillCount: skillMerge.importedSkillCount,
    skippedSkillCount: skillMerge.skippedSkillCount,
    importedRunCount: imported.creativeRuns.length,
    importedOutputCount: imported.creativeRuns.reduce((sum, run) => sum + run.outputs.length, 0),
    importedCount,
    createdEntryIds,
    importDiagnostics: imported.importDiagnostics,
    importStats: imported.importStats,
    trashEntryIdMap: trashMerge.entryIdMap,
    trashCollectionIdMap: trashMerge.collectionIdMap,
    trashCompoundIdMap: trashMerge.compoundIdMap,
    remappedCount,
    skippedCount
  };
}

function libraryHasRetainedContentOrConfiguration(state) {
  if (syncStateHasContent(state) || (state.classificationRules ?? []).length) return true;
  // Default first-run configuration may be restored from a package. Explicit
  // user choices still belong to the receiver after its last active case goes.
  const settings = JSON.stringify(normalizeSettings(state.settings));
  if (settings !== JSON.stringify(DEFAULT_SETTINGS) && settings !== JSON.stringify(DEFAULT_SETTINGS_EN)) return true;
  return JSON.stringify(normalizeTaxonomy(state.taxonomy)) !== JSON.stringify(normalizeTaxonomy())
    || JSON.stringify(normalizeFacetCatalog(state.facetCatalog ?? createDefaultFacetCatalog())) !== JSON.stringify(normalizeFacetCatalog(createDefaultFacetCatalog()))
    || JSON.stringify(normalizeComposerSettings(state.composerSettings)) !== JSON.stringify(normalizeComposerSettings())
    || JSON.stringify(normalizeCreativeExperimentSettings(state.creativeExperimentSettings)) !== JSON.stringify(normalizeCreativeExperimentSettings());
}

function localImportMetadata(options = {}) {
  const requestedTime = clean(options.libraryAddedAt ?? options.now);
  const parsedTime = requestedTime && Number.isFinite(Date.parse(requestedTime))
    ? new Date(requestedTime).toISOString()
    : new Date().toISOString();
  return {
    libraryAddedAt: parsedTime,
    importBatchId: clean(options.importBatchId) || `library-import:${globalThis.crypto.randomUUID()}`
  };
}

function withLocalImportMetadata(entry, metadata) {
  return { ...entry, ...metadata };
}

function mergeComposerSessions(
  currentValue,
  importedValue,
  entryIdMap,
  preferredIds = {},
  visualIdMap = {},
  skillIdMap = {},
  skillVersionIdMap = {}
) {
  const current = normalizeComposerSessions(currentValue);
  const used = new Set(current.map((item) => item.id));
  const sessionIdMap = {};
  const imported = normalizeComposerSessions(importedValue).map((session) => {
    const next = structuredClone(session);
    const sourceId = next.id;
    if (used.has(next.id)) {
      const preferred = clean(preferredIds?.[sourceId]);
      next.id = preferred && !used.has(preferred) ? preferred : globalThis.crypto.randomUUID();
    }
    used.add(next.id);
    sessionIdMap[sourceId] = next.id;
    next.referenceSnapshots = next.referenceSnapshots.map((item) => ({
      ...item,
      entryId: entryIdMap[item.entryId] ?? item.entryId,
      imageRefs: item.imageRefs.map((image) => ({ ...image, visualId: visualIdMap[image.visualId] ?? image.visualId })),
      assetRefs: item.assetRefs.map(({ archivePath: _archivePath, ...asset }) => ({
        ...asset,
        assetId: visualIdMap[asset.assetId] ?? asset.assetId
      }))
    }));
    return remapAppliedSkillReferences(next, skillIdMap, skillVersionIdMap);
  });
  return { sessions: [...current, ...imported], sessionIdMap };
}

function mergeCreativeRuns(
  currentValue,
  importedValue,
  sessionIdMap,
  usedVisualIds,
  visualIdMap,
  preferredRunIds = {},
  skillIdMap = {},
  skillVersionIdMap = {}
) {
  const current = normalizeCreativeRuns(currentValue);
  const usedRunIds = new Set(current.map((item) => item.id));
  const runIdMap = {};
  const imported = normalizeCreativeRuns(importedValue).map((source) => {
    const run = withoutCreativeArchivePaths(source);
    const sourceRunId = run.id;
    if (usedRunIds.has(run.id)) {
      const preferred = clean(preferredRunIds?.[sourceRunId]);
      run.id = preferred && !usedRunIds.has(preferred) ? preferred : globalThis.crypto.randomUUID();
    }
    usedRunIds.add(run.id);
    runIdMap[sourceRunId] = run.id;
    run.sessionId = sessionIdMap[run.sessionId] ?? run.sessionId;
    run.outputs = run.outputs.map((output) => {
      const sourceVisualId = output.visual.id;
      let targetVisualId = visualIdMap[sourceVisualId];
      if (!targetVisualId) {
        targetVisualId = usedVisualIds.has(sourceVisualId)
          ? uniqueId("creative-visual", usedVisualIds)
          : sourceVisualId;
        usedVisualIds.add(targetVisualId);
        visualIdMap[sourceVisualId] = targetVisualId;
      }
      return { ...output, visual: { ...output.visual, id: targetVisualId } };
    });
    return remapAppliedSkillReferences(run, skillIdMap, skillVersionIdMap);
  });
  return { runs: normalizeCreativeRuns([...current, ...imported]), runIdMap };
}

function remapAppliedSkillReferences(value, skillIdMap = {}, skillVersionIdMap = {}) {
  return {
    ...value,
    toolSkillVersionIds: (value?.toolSkillVersionIds || []).map(id => skillVersionIdMap[id] ?? id),
    appliedSkills: (Array.isArray(value?.appliedSkills) ? value.appliedSkills : []).map((skill) => ({
      ...skill,
      skillId: skillIdMap[skill.skillId] ?? skill.skillId,
      versionId: skillVersionIdMap[skill.versionId] ?? skill.versionId
    }))
  };
}

function mergeVocabulary(target, sourceValue, options = {}) {
  const source = normalizeFacetCatalog(sourceValue);
  const facetIds = new Map();
  const nodeIds = new Map();
  for (const facet of source.facets.toSorted((a, b) => a.order - b.order)) {
    const sameId = target.facets.find((item) => item.id === facet.id && canonical(item.name) === canonical(facet.name));
    const sameName = target.facets.find((item) => canonical(item.name) === canonical(facet.name));
    const existing = sameId ?? sameName;
    if (existing) {
      facetIds.set(facet.id, existing.id);
      continue;
    }
    const usedFacetIds = new Set(target.facets.map((item) => item.id));
    const preferredId = clean(options.facetIdMap?.[facet.id]);
    const id = usedFacetIds.has(facet.id)
      ? preferredId && !usedFacetIds.has(preferredId) ? preferredId : uniqueId("facet", usedFacetIds)
      : facet.id;
    target.facets.push({ ...facet, id, order: target.facets.length });
    facetIds.set(facet.id, id);
  }
  const orderedNodes = source.nodes.toSorted((left, right) => Number(Boolean(left.parentId)) - Number(Boolean(right.parentId)) || left.order - right.order);
  for (const node of orderedNodes) {
    const facetId = facetIds.get(node.facetId);
    const parentId = node.parentId ? nodeIds.get(node.parentId) : null;
    if (!facetId || (node.parentId && !parentId)) continue;
    const existing = target.nodes.find((item) =>
      item.facetId === facetId && (item.parentId || null) === parentId && canonical(item.name) === canonical(node.name)
    );
    if (existing) {
      nodeIds.set(node.id, existing.id);
      continue;
    }
    const usedNodeIds = new Set(target.nodes.map((item) => item.id));
    const preferredId = clean(options.nodeIdMap?.[node.id]);
    const id = usedNodeIds.has(node.id)
      ? preferredId && !usedNodeIds.has(preferredId) ? preferredId : uniqueId("tag", usedNodeIds)
      : node.id;
    target.nodes.push({ ...node, id, facetId, parentId, order: target.nodes.length });
    nodeIds.set(node.id, id);
  }
  target.revision += 1;
  return { facetIds, nodeIds };
}

function mergeImportedTrashState(currentValue, importedValue, context = {}) {
  const current = normalizeTrashState(currentValue);
  const imported = normalizeTrashState(importedValue);
  if (!imported.items.length) {
    return { trashState: current, entryIdMap: {}, collectionIdMap: {}, visualIdMap: {} };
  }
  const usedEntryIds = new Set([
    ...(context.activeEntryIds ?? []),
    ...current.items.filter((item) => item.kind === "entry").map((item) => item.targetId)
  ]);
  const usedCollectionIds = new Set([
    ...(context.activeCollectionIds ?? []),
    ...current.items.filter((item) => item.kind === "collection").map((item) => item.targetId)
  ]);
  const usedVisualIds = new Set(context.activeVisualIds ?? []);
  for (const item of current.items) {
    if (item.kind === "entry") {
      for (const asset of normalizeEntryMedia(item.snapshot).mediaAssets) usedVisualIds.add(asset.id);
    }
    if (item.kind === "media") {
      for (const asset of normalizeEntryMedia({ mediaAssets: item.snapshot?.mediaAssets ?? [] }).mediaAssets) usedVisualIds.add(asset.id);
    }
  }
  const collectionIdMap = { ...(context.collectionIdMap ?? {}) };
  const preferredCollectionIdMap = context.preferredCollectionIdMap ?? {};
  for (const item of imported.items.filter((candidate) => candidate.kind === "collection")) {
    const sourceId = item.targetId;
    const preferredId = clean(preferredCollectionIdMap[sourceId]);
    const targetId = usedCollectionIds.has(sourceId)
      ? preferredId && !usedCollectionIds.has(preferredId) ? preferredId : uniqueId("collection", usedCollectionIds)
      : sourceId;
    usedCollectionIds.add(targetId);
    collectionIdMap[sourceId] = targetId;
  }
  const entryIdMap = { ...(context.entryIdMap ?? {}) };
  const preferredEntryIdMap = context.preferredEntryIdMap ?? {};
  for (const item of imported.items.filter((candidate) => candidate.kind === "entry")) {
    const sourceId = item.targetId;
    const preferredId = clean(preferredEntryIdMap[sourceId]);
    const targetId = usedEntryIds.has(sourceId)
      ? preferredId && !usedEntryIds.has(preferredId) ? preferredId : uniqueId("entry", usedEntryIds)
      : sourceId;
    usedEntryIds.add(targetId);
    entryIdMap[sourceId] = targetId;
  }
  const compoundIds = new Set(context.activeCompoundIds ?? []);
  const compoundIdMap = {};
  const preferredCompoundIdMap = context.preferredCompoundIdMap ?? {};
  for (const item of imported.items) {
    for (const compound of item.relationships?.compoundCases ?? []) {
      const sourceId = clean(compound?.id);
      if (!sourceId || compoundIdMap[sourceId]) continue;
      const preferredId = clean(preferredCompoundIdMap[sourceId]);
      const targetId = compoundIds.has(sourceId)
        ? preferredId && !compoundIds.has(preferredId) ? preferredId : uniqueId("compound", compoundIds)
        : sourceId;
      compoundIds.add(targetId);
      compoundIdMap[sourceId] = targetId;
    }
  }
  const visualIdMap = {};
  const sharedVisualIdMap = { ...context.sharedVisualIdMap };
  const moved = imported.items.map((sourceItem) => {
    const item = structuredClone(sourceItem);
    if (item.kind === "collection") {
      const targetId = collectionIdMap[item.targetId];
      item.targetId = targetId;
      item.id = `trash:collection:${targetId}`;
      item.snapshot.id = targetId;
      item.snapshot.parentId = collectionIdMap[item.snapshot.parentId] ?? item.snapshot.parentId ?? null;
      item.snapshot.entryIds = (item.snapshot.entryIds ?? []).map((id) => entryIdMap[id] ?? id);
      return item;
    }
    if (item.kind === "entry") {
      const targetId = entryIdMap[item.targetId];
      const remapped = remapTrashedEntrySnapshot(item.snapshot, targetId, usedVisualIds, context.preferredVisualIdMap, sharedVisualIdMap);
      Object.assign(visualIdMap, remapped.visualIdMap);
      Object.assign(sharedVisualIdMap, remapped.visualIdMap);
      item.targetId = targetId;
      item.id = `trash:entry:${targetId}`;
      item.snapshot = remapped.entry;
      item.relationships.collections = (item.relationships.collections ?? []).map((membership) => ({
        ...membership,
        id: collectionIdMap[membership.id] ?? membership.id
      }));
      item.relationships.compoundCases = (item.relationships.compoundCases ?? []).map((compound) => ({
        ...compound,
        id: compoundIdMap[compound.id] ?? compound.id,
        memberEntryIds: (compound.memberEntryIds ?? []).map((id) => entryIdMap[id] ?? id),
        coverVisualId: remapped.visualIdMap[compound.coverVisualId] ?? compound.coverVisualId
      }));
      return item;
    }
    const parentEntryId = entryIdMap[item.relationships?.entryId] ?? item.relationships?.entryId;
    const remapped = remapTrashedEntrySnapshot({
      id: parentEntryId || `trash-media:${item.targetId}`,
      mediaAssets: item.snapshot?.mediaAssets ?? [],
      primaryMediaId: ""
    }, parentEntryId || `trash-media:${item.targetId}`, usedVisualIds, context.preferredVisualIdMap, sharedVisualIdMap);
    Object.assign(visualIdMap, remapped.visualIdMap);
    Object.assign(sharedVisualIdMap, remapped.visualIdMap);
    const targetId = remapped.visualIdMap[item.targetId] ?? item.targetId;
    item.targetId = targetId;
    item.id = ["trash", "media", parentEntryId, targetId].filter(Boolean).join(":");
    item.snapshot.mediaAssets = remapped.entry.mediaAssets;
    item.relationships.entryId = parentEntryId;
    item.relationships.positions = (item.relationships.positions ?? []).map((position) => ({
      ...position,
      id: remapped.visualIdMap[position.id] ?? position.id
    }));
    item.relationships.primaryMediaId = remapped.visualIdMap[item.relationships.primaryMediaId] ?? item.relationships.primaryMediaId;
    if (item.relationships.coverVisualId) item.relationships.coverVisualId = remapped.visualIdMap[item.relationships.coverVisualId] ?? item.relationships.coverVisualId;
    return item;
  });
  return {
    trashState: normalizeTrashState({ items: [...current.items, ...moved] }),
    entryIdMap: Object.fromEntries(imported.items.filter((item) => item.kind === "entry").map((item) => [item.targetId, entryIdMap[item.targetId]])),
    collectionIdMap,
    compoundIdMap,
    visualIdMap
  };
}

function remapTrashedEntrySnapshot(entryValue, targetEntryId, usedVisualIds, preferredVisualIdMap = {}, sharedVisualIdMap = {}) {
  const entry = normalizeEntryMedia(entryValue);
  const visualIdMap = {};
  entry.mediaAssets = entry.mediaAssets.map((asset) => {
    const preferredId = asset.id === entry.id && targetEntryId !== entry.id ? targetEntryId : asset.id;
    const plannedId = clean(preferredVisualIdMap[asset.id]);
    const targetId = sharedVisualIdMap[asset.id] || (usedVisualIds.has(preferredId)
      ? plannedId && !usedVisualIds.has(plannedId) ? plannedId : uniqueId("visual", usedVisualIds)
      : preferredId);
    usedVisualIds.add(targetId);
    visualIdMap[asset.id] = targetId;
    return { ...asset, id: targetId };
  });
  entry.id = targetEntryId;
  entry.primaryMediaId = visualIdMap[entry.primaryMediaId] ?? entry.primaryMediaId;
  if (entry.coverVisualId) entry.coverVisualId = visualIdMap[entry.coverVisualId] ?? entry.coverVisualId;
  entry.articleDocument = remapArticleDocumentAssets(entry.articleDocument, visualIdMap);
  entry.mediaAssets = entry.mediaAssets.map((asset) => ({
    ...asset,
    ...(asset.posterAssetId ? { posterAssetId: visualIdMap[asset.posterAssetId] ?? asset.posterAssetId } : {}),
    ...(asset.derivedFromAssetId ? { derivedFromAssetId: visualIdMap[asset.derivedFromAssetId] ?? asset.derivedFromAssetId } : {})
  }));
  entry.timeNotes = (entry.timeNotes ?? []).map((note) => ({
    ...note,
    assetId: visualIdMap[note.assetId] ?? note.assetId,
    ...(note.frameAssetId ? { frameAssetId: visualIdMap[note.frameAssetId] ?? note.frameAssetId } : {})
  }));
  entry.mediaPrompts = (entry.mediaPrompts ?? []).map((prompt) => ({
    ...prompt,
    assetId: visualIdMap[prompt.assetId] ?? prompt.assetId
  }));
  Object.assign(entry, remapMediaAnalysisAssets(entry, visualIdMap));
  entry.facetAssignments = (entry.facetAssignments ?? []).map((assignment) => ({
    ...assignment,
    ...(assignment.visualId ? { visualId: visualIdMap[assignment.visualId] ?? assignment.visualId } : {})
  }));
  return { entry, visualIdMap };
}

function packageImagePlaceholders(value) {
  const entryImages = (value?.entries ?? []).flatMap((entryValue) => {
    const entry = normalizeEntryMedia(entryValue);
    return entry.mediaAssets.flatMap((asset) => asset.assetPath
      ? [[asset.assetPath, new Blob(["placeholder"], { type: mediaType(asset.assetPath, asset.kind, asset.mimeType) })]] : []);
  });
  const creativeAssets = normalizeCreativeRuns(value?.creativeRuns).flatMap((run) =>
    run.outputs.flatMap((output) => (output.visual.assetPath || output.visual.screenshotPath)
      ? [[output.visual.assetPath || output.visual.screenshotPath, new Blob(["placeholder"], { type: mediaType(output.visual.assetPath || output.visual.screenshotPath, output.visual.kind) })]]
      : [])
  );
  const skillFiles = normalizeCreativeSkillsState(value?.creativeSkills).items.flatMap((skill) =>
    skillPackageFiles(skill).flatMap((file) => file.archivePath
      ? [[file.archivePath, new Blob(["placeholder"], { type: file.mimeType || "application/octet-stream" })]]
      : [])
  );
  const tempFiles = normalizeComposerSessions(value?.composerSessions).flatMap((session) =>
    session.referenceSnapshots.flatMap((reference) => reference.sourceType === "temporary"
      ? reference.assetRefs.flatMap((asset) => asset.archivePath
        ? [[asset.archivePath, new Blob(["placeholder"], { type: asset.mimeType || "application/octet-stream" })]]
        : [])
      : [])
  );
  const trashAssets = trashMediaAssets(value?.trashState).flatMap((asset) => asset.assetPath
    ? [[asset.assetPath, new Blob(["placeholder"], { type: mediaType(asset.assetPath, asset.kind, asset.mimeType) })]]
    : []);
  const files = new Map([...entryImages, ...creativeAssets, ...skillFiles, ...tempFiles, ...trashAssets]);
  // Merge validates structure with placeholders after the real-byte inspection.
  // Preserve shared media identity across the placeholder paths as well.
  const byId = new Map();
  for (const asset of libraryStoredAssets(value)) {
    const path = asset.assetPath || asset.screenshotPath || asset.archivePath;
    const blob = files.get(path);
    if (!blob) continue;
    const key = `${asset.id || asset.assetId}:${blob.type}`;
    if (byId.has(key)) files.set(path, byId.get(key));
    else byId.set(key, blob);
  }
  return files;
}

function trashMediaAssets(trashStateValue) {
  return normalizeTrashState(trashStateValue).items.flatMap((item) => {
    if (item.kind === "entry") return normalizeEntryMedia(item.snapshot).mediaAssets;
    if (item.kind === "media") return normalizeEntryMedia({ mediaAssets: item.snapshot?.mediaAssets ?? [] }).mediaAssets;
    return [];
  });
}

function withoutArchivePath(entry) {
  const next = normalizeEntryMedia(entry);
  next.mediaAssets = next.mediaAssets.map(({ assetPath: _assetPath, ...asset }) => asset);
  return next;
}

function withoutCreativeArchivePaths(runValue) {
  const run = structuredClone(runValue);
  run.outputs = (run.outputs ?? []).map((output) => {
    const { screenshotPath: _screenshotPath, assetPath: _assetPath, ...visual } = output.visual ?? {};
    return { ...output, visual };
  });
  return run;
}

function withoutComposerArchivePaths(sessionValue) {
  const session = structuredClone(sessionValue);
  session.referenceSnapshots = (session.referenceSnapshots ?? []).map((reference) => ({
    ...reference,
    assetRefs: (reference.assetRefs ?? []).map(({ archivePath: _archivePath, ...asset }) => asset)
  }));
  return session;
}

function temporaryReferenceAssets(sessionsValue) {
  return normalizeComposerSessions(sessionsValue).flatMap((session) =>
    session.referenceSnapshots
      .filter((reference) => reference.sourceType === "temporary")
      .flatMap((reference) => reference.assetRefs)
  );
}

function validTemporaryAssetPath(path) {
  return /^temp-references\/[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\.[A-Za-z0-9]+$/u.test(path) && !path.includes("..");
}

function imageType(path) {
  if (/\.png$/i.test(path)) return "image/png";
  if (/\.jpe?g$/i.test(path)) return "image/jpeg";
  return "image/webp";
}

function mediaType(path, kind, declaredMimeType = "") {
  const declared = clean(declaredMimeType).toLocaleLowerCase("en-US");
  if (declared) return declared;
  if (kind === "image") return imageType(path);
  if (/\.mp4$/i.test(path)) return "video/mp4";
  if (/\.webm$/i.test(path)) return "video/webm";
  if (/\.mov$/i.test(path)) return "video/quicktime";
  if (/\.mkv$/i.test(path)) return "video/x-matroska";
  if (/\.avi$/i.test(path)) return "video/x-msvideo";
  if (/\.pdf$/i.test(path)) return "application/pdf";
  if (/\.rtf$/i.test(path)) return "application/rtf";
  if (/\.html?$/i.test(path)) return "text/html";
  if (/\.md$/i.test(path)) return "text/markdown";
  return "text/plain";
}

function validatePortableMediaDescriptor(asset, path, packageVersion) {
  if (!validMediaPath(path, asset.kind, packageVersion)) {
    throw new Error("案例包包含无效或与媒体类型不符的文件路径");
  }
  if (packageVersion < 4) return null;
  const extension = fileExtension(path);
  const format = assetFormatForExtension(extension);
  const genericAttachment = asset.kind === "attachment" && !format && /^[a-z0-9]+$/u.test(extension);
  if (!format && !genericAttachment) throw new Error("案例包包含未登记的媒体格式");
  if (format && (format.kind !== asset.kind || !isReportedMimeCompatible(format, asset.mimeType))) {
    throw new Error("案例包中的扩展名、媒体类型和 MIME 不一致");
  }
  const declaredFormat = clean(asset.sourceFormat).toLocaleLowerCase("en-US").replace(/^\./u, "");
  if (declaredFormat && declaredFormat !== extension) {
    throw new Error("案例包中的源文件格式和文件扩展名不一致");
  }
  return format;
}

function validMediaPath(path, kind, packageVersion = 4) {
  if (!path || path.includes("..")) return false;
  const safeFile = "[A-Za-z0-9._/-]+\\.[A-Za-z0-9]+";
  let directory;
  if (packageVersion >= 4) {
    try { directory = portableAssetDirectory(kind); }
    catch { return false; }
  } else {
    directory = { image: "images", video: "videos", document: "documents" }[kind];
  }
  if (!directory || !(new RegExp(`^${directory}\\/${safeFile}$`, "i")).test(path)) return false;
  if (packageVersion >= 4) return true;
  if (kind === "image") return /\.(?:png|jpe?g|webp)$/i.test(path);
  if (kind === "video") return /\.(?:mp4|webm|mov|mkv|avi|video)$/i.test(path);
  return /\.(?:pdf|rtf|md|txt|html?|bin)$/i.test(path);
}

function validCreativeResultPath(path, kind) {
  if (!path || path.includes("..")) return false;
  const validPath = kind === "video"
    ? /^creative-results\/[A-Za-z0-9._/-]+\.[A-Za-z0-9]+$/i.test(path)
    : /^(?:images|creative-results)\/[A-Za-z0-9._/-]+\.[A-Za-z0-9]+$/i.test(path);
  if (!validPath) return false;
  const format = assetFormatForExtension(fileExtension(path));
  return format?.kind === kind;
}

function portableMediaFileFailure(entry, asset, blob, format, packageVersion, limits, skipMediaByteValidation) {
  const title = entry.title || t("未命名案例");
  if (!(blob instanceof Blob)) {
    return {
      reason: "missing_file",
      message: t(asset.kind === "image" ? "“{title}”的截图缺失" : "“{title}”的媒体文件缺失或类型不符", { title })
    };
  }
  if (!blobMatchesKind(blob, asset, format, packageVersion)) {
    return { reason: "type_mismatch", message: t("“{title}”的媒体文件缺失或类型不符", { title }) };
  }
  const byteLimit = portableAssetByteLimit(asset.kind, limits);
  if (blob.size > byteLimit) {
    return {
      reason: "too_large",
      message: t(asset.kind === "image" ? "“{title}”的图片超过 {limit} 分享包上限,请使用完整资料夹备份" : "“{title}”的媒体超过 {limit} 分享包上限,请使用完整资料夹备份", { title, limit: formatBytes(byteLimit) })
    };
  }
  if (!skipMediaByteValidation && packageVersion >= 3 && asset.byteSize && asset.byteSize !== blob.size) {
    return {
      reason: "byte_size_mismatch",
      message: t("“{title}”的媒体大小校验失败:期望 {expected} bytes,实际 {actual} bytes({path})", { title, expected: asset.byteSize, actual: blob.size, path: clean(asset.assetPath) })
    };
  }
  return null;
}

function blobMatchesKind(blob, asset, format, packageVersion) {
  if (typeof asset === "string") {
    if (asset === "image") return clean(blob.type).startsWith("image/");
    if (asset === "video") return clean(blob.type).startsWith("video/");
    return isSupportedDocumentMimeType(blob.type);
  }
  const blobType = clean(blob.type).toLocaleLowerCase("en-US");
  if (packageVersion >= 4) {
    if (!blobType || ["application/octet-stream", "application/x-unknown"].includes(blobType)) return true;
    if (format) return isReportedMimeCompatible(format, blobType);
    return asset.kind === "attachment";
  }
  if (asset.kind === "image") return blobType.startsWith("image/");
  if (asset.kind === "video") return blobType.startsWith("video/");
  return isSupportedDocumentMimeType(blobType);
}

function completeBackupDocumentPaths(value = {}) {
  const paths = new Map();
  const trashEntries = (Array.isArray(value?.trashState?.items) ? value.trashState.items : []).flatMap((item) => {
    if (item?.kind === "entry") return [item.snapshot];
    if (item?.kind === "media") return [{ mediaAssets: item.snapshot?.mediaAssets ?? [] }];
    return [];
  });
  for (const entry of [...(Array.isArray(value?.entries) ? value.entries : []), ...trashEntries]) {
    const mediaAssets = Array.isArray(entry?.mediaAssets)
      ? entry.mediaAssets
      : Array.isArray(entry?.visuals) ? entry.visuals : [];
    for (const asset of mediaAssets) {
      if (asset?.kind === "document" && asset.storageMode !== "reference" && asset.assetPath) {
        paths.set(String(asset.assetPath), String(asset.mimeType ?? ""));
      }
    }
  }
  for (const session of Array.isArray(value?.composerSessions) ? value.composerSessions : []) {
    for (const reference of Array.isArray(session?.referenceSnapshots) ? session.referenceSnapshots : []) {
      if (reference?.sourceType !== "temporary") continue;
      for (const asset of Array.isArray(reference.assetRefs) ? reference.assetRefs : []) {
        if (asset?.kind === "document" && asset.archivePath) {
          paths.set(String(asset.archivePath), String(asset.mimeType ?? ""));
        }
      }
    }
  }
  return paths;
}

function trashMediaDiagnostic(item, asset, reason) {
  return {
    code: "trash_media_dropped",
    severity: "trash",
    action: "dropped",
    targetId: clean(item?.targetId),
    assetId: clean(asset?.id),
    path: clean(asset?.assetPath),
    reason
  };
}

function privateResourceDiagnostic(code, value, path, reason) {
  return {
    code,
    severity: "media",
    action: "dropped",
    assetId: clean(value?.assetId || value?.id),
    path: clean(path),
    reason
  };
}

function hasRecoverableCaseContent(entry = {}) {
  if ([entry.title, entry.text, entry.note, entry.url].some((value) => clean(value))) return true;
  if ((entry.mediaAssets ?? []).some((asset) => asset && typeof asset === "object")) return true;
  return (entry.articleDocument?.blocks ?? []).some((block) => clean(block?.text) || clean(block?.assetId));
}

function dropDanglingAiAssignments(values, context) {
  return (Array.isArray(values) ? values : []).flatMap((assignment) => {
    if (!AI_ASSIGNMENT_SOURCES.has(assignment?.source)) return [assignment];
    const missingVocabulary = !context.facetIds.has(clean(assignment?.facetId)) ||
      !context.nodeIds.has(clean(assignment?.nodeId));
    const visualId = clean(assignment?.visualId);
    const missingMedia = Boolean(visualId) && !context.mediaIds.has(visualId);
    if (!missingVocabulary && !missingMedia) return [assignment];
    context.importStats.droppedAiAssignments += 1;
    context.importDiagnostics.push({
      code: "ai_assignment_dropped",
      severity: "metadata",
      action: "dropped",
      entryId: context.entryId,
      reason: missingVocabulary ? "missing_vocabulary" : "missing_media"
    });
    return [];
  });
}

function parsedImportEvidence(value) {
  if (!Number.isInteger(value?.sourcePackageVersion) || !Array.isArray(value?.importDiagnostics) ||
      !value?.importStats || typeof value.importStats !== "object") return null;
  return {
    diagnostics: structuredClone(value.importDiagnostics),
    stats: structuredClone(value.importStats)
  };
}

function importReportEvidence(value) {
  if (!Array.isArray(value?.diagnostics) || !value?.stats || typeof value.stats !== "object") return null;
  return {
    diagnostics: structuredClone(value.diagnostics),
    stats: structuredClone(value.stats)
  };
}

function mergeImportDiagnostics(previous, current) {
  const result = [];
  const seen = new Set();
  for (const diagnostic of [...previous, ...current]) {
    if (!diagnostic || typeof diagnostic !== "object") continue;
    const key = JSON.stringify(diagnostic);
    if (seen.has(key)) continue;
    seen.add(key);
    result.push(structuredClone(diagnostic));
  }
  return result;
}

function mergeImportStats(previous, current) {
  const dropped = {};
  for (const key of [
    "droppedAiAssignments",
    "droppedMediaDescriptors",
    "droppedMediaFiles",
    "droppedTrashMedia",
    "droppedTemporaryAssets",
    "droppedCreativeOutputs",
    "droppedSkillFiles"
  ]) {
    dropped[key] = nonNegativeStat(previous?.[key]) + nonNegativeStat(current?.[key]);
  }
  return {
    ...current,
    inputCases: Number.isSafeInteger(previous?.inputCases)
      ? nonNegativeStat(previous.inputCases)
      : nonNegativeStat(current?.inputCases),
    keptCases: nonNegativeStat(current?.keptCases),
    skippedCases: nonNegativeStat(previous?.skippedCases) + nonNegativeStat(current?.skippedCases),
    ...dropped
  };
}

function nonNegativeStat(value) {
  const number = Number(value);
  return Number.isSafeInteger(number) && number >= 0 ? number : 0;
}

function uniqueId(prefix, used) {
  let id;
  do id = `${prefix}:${globalThis.crypto.randomUUID()}`; while (used.has(id));
  return id;
}

function clean(value) {
  return String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, "").trim();
}

function canonical(value) {
  return clean(value).toLocaleLowerCase("zh-CN").replace(/[\s._·—–-]+/g, "");
}
import { assertCaseFilesReadable } from './case-file-status.js';