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

30.1 KB
Raw Blame
import { skillPackageFiles } from './skill-files.js';
import { createBlobDigestCache } from './blob-digest.js';
import { prepareAgentFile } from "./agent-file-preparation.js";
import { deleteScreenshotBlob, getScreenshotBlob, saveScreenshotBlob } from "./image-store.js";
import { deleteMediaBlob, getMediaBlob, saveMediaBlob } from "./media-store.js";
import { readVideoMedia } from "./browser-video-media.js";
import {
  SCREENSHOT_SETTINGS,
  archiveMarkdownFilename,
  calculateCropGeometry,
  renderLibraryJson,
  renderMarkdown
} from "./lib.js";
import { createZipBlob } from "./zip.js";
import { createVerifiedLibraryZip } from "./library-export-zip.js";
import { sha256Hex } from "./sync-crypto.js";
import {
  CURATED_SUBMISSION_MAX_FILE_BYTES,
  CURATED_SUBMISSION_PART_PAYLOAD_BYTES,
  submissionManifest,
  submissionPartManifest
} from "./curated-submission.js";
import { PALETTE_VERSION, extractPalette } from "./palette.js";
import {
  SHARE_PREVIEW_FOUNDATION_FILENAME,
  SHARE_PREVIEW_HTML_FILENAME,
  SHARE_PREVIEW_MASONRY_FILENAME,
  SHARE_PREVIEW_RUNTIME_FILENAME,
  renderSharePreviewHtml,
  renderSharePreviewMasonryJs,
  renderSharePreviewRuntimeJs
} from "./share-preview.js";
import { normalizeUiPreferences } from "./preferences.js";
import { normalizeEntryMedia } from "./media.js";
import { normalizeCreativeRuns } from "./creative-runs.js";
import { buildCreativeExperimentPackage } from "./creative-experiment-package.js";
import { runCreativeJob } from "./creative-job-runner.js";
import { runVideoAnalysisJob } from "./video-analysis-runner.js";
import { sanitizeAnalysisDiagnostic } from "./analysis-response.js";
import { composerServiceErrorDetails } from "./composer-service.js";
import { resolvePortableAssetFormat } from "./asset-formats.js";
import {
  LOCAL_ASSET_LINK_STATUS,
  getLocalAssetHandleRecord,
  inspectStoredLocalAsset
} from "./local-asset-store.js";

import { shareDirectory, writeShareArchive } from './share-directory.js';
const blobUrls = new Set();
let creativeJobRunner = null;
const videoAnalysisRunners = new Map();

if (globalThis.chrome?.runtime?.onMessage) {
  chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
    if (message?.target !== "offscreen") return false;
    handleMessage(message)
      .then(sendResponse)
      .catch((error) => sendResponse({ ok: false, message: error.message }));
    return true;
  });
}

async function handleMessage(message) {
  switch (message.type) {
    case 'WRITE_SHARE_ARCHIVE': {
      if (!blobUrls.has(message.url)) throw new Error('分享包已过期,请重新导出');
      const directory = await shareDirectory();
      if (!directory) throw new Error('请先选择分享文件夹');
      const blob = await (await fetch(message.url)).blob();
      const filename = await writeShareArchive(directory, blob, message.filename);
      return { ok: true, filename, directoryName: directory.name };
    }
    case "PREPARE_AGENT_FILE":
      return { ok: true, prepared: await prepareAgentFile(message.record) };
    case "PREPARE_STORED_VIDEO_POSTER": {
      const blob = await getMediaBlob(message.assetId);
      if (!blob) throw new Error("本地视频文件缺失");
      const prepared = await readVideoMedia(blob, blob.type, message.assetId, { timeoutMs: message.timeoutMs });
      if (prepared.poster) await saveMediaBlob(prepared.poster.asset.id, prepared.poster.blob);
      return { ok: true, metadata: prepared.metadata, poster: prepared.poster?.asset || null };
    }
    case "CROP_AND_STORE_SCREENSHOT":
      return cropScreenshot(message);
    case "CROP_AND_STORE_SCREENSHOTS":
      return cropScreenshots(message);
    case "CROP_PAGE_CAPTURE_PREVIEWS":
      return cropPageCapturePreviews(message);
    case "CREATE_ARCHIVE_URL":
      return createArchiveUrl(message);
    case "CREATE_CURATED_SUBMISSION_URLS":
      return createCuratedSubmissionUrls(message);
    case "CREATE_CREATIVE_EXPERIMENT_ARCHIVE_URL":
      return createCreativeExperimentArchiveUrl(message);
    case "ANALYZE_STORED_SCREENSHOT":
      return analyzeStoredScreenshot(message.entryId);
    case "RUN_CREATIVE_JOB":
      return startCreativeJob(message.job);
    case "CANCEL_CREATIVE_JOB":
      return cancelCreativeJob(message.jobId);
    case "GET_CREATIVE_JOB_RUNNER":
      return { ok: true, jobId: creativeJobRunner?.jobId ?? "" };
    case "RUN_VIDEO_ANALYSIS":
      return startVideoAnalysis(message.job);
    case "CANCEL_VIDEO_ANALYSIS":
      return cancelVideoAnalysis(message.taskId, message.attemptId);
    case "GET_VIDEO_ANALYSIS_RUNNER":
      return {
        ok: true,
        runners: [...videoAnalysisRunners.values()].map(({ taskId, attemptId }) => ({ taskId, attemptId }))
      };
    case "REVOKE_BLOB_URL":
      if (blobUrls.delete(message.url)) URL.revokeObjectURL(message.url);
      return { ok: true };
    default:
      return { ok: false, message: "未知后台画布操作" };
  }
}

function startVideoAnalysis(job) {
  const taskId = String(job?.taskId ?? "").trim();
  const attemptId = String(job?.attemptId ?? "").trim();
  if (!taskId || !attemptId) throw new Error("视频分析任务标识无效");
  const runnerKey = `${taskId}\u0000${attemptId}`;
  if (videoAnalysisRunners.has(runnerKey)) return { ok: true, taskId, attemptId, running: true };
  const controller = new AbortController();
  const runner = { taskId, attemptId, controller, cancelRequested: false, promise: null };
  runner.promise = runVideoAnalysisJob(job, {
    signal: controller.signal,
    progress: async ({ phase, providerMayHaveAccepted, requestBudget, requestId, diagnostic }) => {
      const response = await sendBackgroundMessage({
        type: "UPDATE_VIDEO_ANALYSIS_PROGRESS",
        taskId,
        attemptId,
        phase,
        requestBudget,
        requestId,
        diagnostic,
        providerMayHaveAccepted: providerMayHaveAccepted === true
      });
      if (response?.ok === false) throw new DOMException("分析任务已经失效", "AbortError");
      return response;
    }
  }).then((analysis) => sendBackgroundMessage({
    type: "COMPLETE_VIDEO_ANALYSIS",
    taskId,
    attemptId,
    analysis
  })).catch(async (error) => {
    if (runner.cancelRequested || error?.name === "AbortError") return { ok: false, canceled: true };
    return sendBackgroundMessage({
      type: "FAIL_VIDEO_ANALYSIS",
      taskId,
      attemptId,
      error: {
        message: String(error?.message || "视频分析失败"),
        status: Number(error?.status) || 0,
        code: String(error?.code || ""),
        diagnostic: sanitizeAnalysisDiagnostic(error?.diagnostic || { code: error?.code || "analysis_failed" }),
        requestBudget: error?.requestBudget,
        usage: error?.usage
      }
    }).catch(() => ({ ok: false }));
  }).finally(() => {
    if (videoAnalysisRunners.get(runnerKey) === runner) videoAnalysisRunners.delete(runnerKey);
  });
  videoAnalysisRunners.set(runnerKey, runner);
  return { ok: true, taskId, attemptId, running: true };
}

async function cancelVideoAnalysis(taskIdValue, attemptIdValue) {
  const taskId = String(taskIdValue ?? "").trim();
  const attemptId = String(attemptIdValue ?? "").trim();
  const runnerKey = `${taskId}\u0000${attemptId}`;
  const runner = videoAnalysisRunners.get(runnerKey);
  if (!runner) {
    return { ok: false, message: "后台没有找到正在运行的视频分析" };
  }
  runner.cancelRequested = true;
  runner.controller.abort();
  await runner.promise;
  return { ok: true, taskId, attemptId, canceled: true };
}

function startCreativeJob(job) {
  const jobId = String(job?.id ?? "").trim();
  if (!jobId) throw new Error("创作任务编号无效");
  if (creativeJobRunner) {
    if (creativeJobRunner.jobId === jobId) return { ok: true, jobId, running: true };
    throw new Error("后台已有创作任务正在运行");
  }
  const controller = new AbortController();
  const runner = { jobId, controller, cancelRequested: false, providerMayHaveAccepted: false, promise: null };
  runner.promise = runCreativeJob(job, {
    signal: controller.signal,
    loadState: () => sendBackgroundMessage({ type: "GET_CREATIVE_JOB_EXECUTION_STATE" }),
    progress: ({ phase, session, remoteVideo, providerMayHaveAccepted, actualStages }) => {
      if (providerMayHaveAccepted === true) runner.providerMayHaveAccepted = true;
      return sendBackgroundMessage({
        type: "UPDATE_CREATIVE_JOB_PROGRESS",
        jobId,
        phase,
        actualStages,
        session,
        remoteVideo,
        providerMayHaveAccepted: runner.providerMayHaveAccepted
      });
    }
  }).then(async (result) => {
    const response = await sendBackgroundMessage({
      type: "COMPLETE_CREATIVE_JOB",
      jobId,
      session: result.session,
      visuals: result.visuals,
      generation: result.generation
    });
    if (!response?.ok) {
      await Promise.allSettled((result.visuals ?? []).map((visual) => visual.kind === "video" ? deleteMediaBlob(visual.id) : deleteScreenshotBlob(visual.id)));
      throw new Error(response?.message || "创作任务结果保存失败");
    }
    return response;
  }).catch(async (error) => {
    if (runner.cancelRequested || error?.name === "AbortError") return { ok: false, canceled: true };
    const details = composerServiceErrorDetails(error);
    await sendBackgroundMessage({
      type: "FAIL_CREATIVE_JOB",
      jobId,
      error: details
    }).catch(() => undefined);
    return { ok: false, message: details.message };
  }).finally(() => {
    if (creativeJobRunner === runner) creativeJobRunner = null;
  });
  creativeJobRunner = runner;
  return { ok: true, jobId, running: true };
}

async function cancelCreativeJob(jobIdValue) {
  const jobId = String(jobIdValue ?? "").trim();
  if (!creativeJobRunner || creativeJobRunner.jobId !== jobId) {
    return { ok: false, message: "后台没有找到正在运行的创作任务" };
  }
  const runner = creativeJobRunner;
  runner.cancelRequested = true;
  runner.controller.abort();
  await runner.promise;
  return {
    ok: true,
    jobId,
    canceled: true,
    providerMayHaveAccepted: runner.providerMayHaveAccepted
  };
}

async function sendBackgroundMessage(message) {
  const recoveryDeadline = Date.now() + 5_000;
  let transportError;
  do {
    try {
      const response = await chrome.runtime.sendMessage(message);
      if (!response?.ok) throw new Error(response?.message || "后台任务状态保存失败");
      return response;
    } catch (error) {
      transportError = error;
      if (!isTransientRuntimeMessageError(error) || Date.now() >= recoveryDeadline) throw error;
      await new Promise((resolve) => setTimeout(resolve, 100));
    }
  } while (Date.now() < recoveryDeadline);
  throw transportError || new Error("后台任务状态保存失败");
}

function isTransientRuntimeMessageError(error) {
  const message = String(error?.message ?? "");
  return /message channel closed|receiving end does not exist|extension context invalidated/iu.test(message);
}

async function createCreativeExperimentArchiveUrl({
  composerSettings,
  composerSessions,
  creativeExperimentSettings,
  creativeRuns
}) {
  const files = [];
  const visualPaths = {};
  const seen = new Set();
  for (const run of normalizeCreativeRuns(creativeRuns)) {
    for (const output of run.outputs) {
      if (seen.has(output.visual.id)) continue;
      const video = output.visual.kind === "video" || String(output.visual.mimeType ?? "").startsWith("video/");
      const blob = video ? await getMediaBlob(output.visual.id) : await getScreenshotBlob(output.visual.id);
      if (!blob) throw new Error(`创作实验中的生成结果${video ? "视频" : "图片"}缺失,请删除该结果或重新采集后再导出`);
      const path = `results/${safeAssetName(run.id)}/${safeAssetName(output.visual.id)}.${resultExtension(blob.type)}`;
      visualPaths[output.visual.id] = path;
      files.push({ name: path, data: blob });
      seen.add(output.visual.id);
    }
  }
  const data = buildCreativeExperimentPackage({
    composerSettings,
    composerSessions,
    creativeExperimentSettings,
    creativeRuns
  }, visualPaths);
  files.unshift({ name: "experiments.json", data: `${JSON.stringify(data, null, 2)}\n` });
  const archive = await createZipBlob(files);
  const url = URL.createObjectURL(archive);
  blobUrls.add(url);
  return {
    ok: true,
    url,
    runCount: data.runs.length,
    mediaCount: seen.size,
    imageCount: seen.size,
    byteSize: archive.size
  };
}

function resultExtension(mimeType) {
  const known = {
    "video/mp4": "mp4",
    "video/webm": "webm",
    "video/quicktime": "mov"
  };
  return known[mimeType] || imageExtension(mimeType);
}

async function analyzeStoredScreenshot(entryId) {
  const blob = await getScreenshotBlob(entryId);
  if (!blob) return { ok: false, message: "没有找到已保存的截图" };
  const url = URL.createObjectURL(blob);
  try {
    const image = await loadImage(url);
    const maximumWidth = 480;
    const width = Math.min(maximumWidth, image.naturalWidth);
    const height = Math.max(1, Math.round(image.naturalHeight * width / image.naturalWidth));
    const canvas = document.createElement("canvas");
    canvas.width = width;
    canvas.height = height;
    const context = canvas.getContext("2d", { alpha: false });
    if (!context) throw new Error("浏览器无法创建色卡画布");
    context.drawImage(image, 0, 0, width, height);
    const colors = extractPalette(context.getImageData(0, 0, width, height));
    return {
      ok: true,
      width: image.naturalWidth,
      height: image.naturalHeight,
      mimeType: blob.type,
      byteSize: blob.size,
      palette: colors.length ? { colors, source: "screenshot", version: PALETTE_VERSION } : undefined
    };
  } finally {
    URL.revokeObjectURL(url);
  }
}

async function cropScreenshot({ entryId, dataUrl, selection }) {
  const image = await loadImage(dataUrl);
  return cropLoadedScreenshot(image, entryId, selection);
}

async function cropScreenshots({ entryIds, dataUrl, selections }) {
  const ids = Array.isArray(entryIds) ? entryIds : [];
  const values = Array.isArray(selections) ? selections : [];
  if (!ids.length || ids.length !== values.length) throw new Error("批量截图数据不完整");
  const image = await loadImage(dataUrl);
  const storedIds = [];
  try {
    const results = [];
    for (const [index, selection] of values.entries()) {
      storedIds.push(ids[index]);
      results.push(await cropLoadedScreenshot(image, ids[index], selection));
    }
    return { ok: true, results };
  } catch (error) {
    await Promise.allSettled(storedIds.map((entryId) => deleteScreenshotBlob(entryId)));
    throw error;
  }
}

async function cropPageCapturePreviews({ dataUrl, selections, maxDataUrlCharacters }) {
  const values = Array.isArray(selections) ? selections : [];
  if (!values.length) return { ok: true, dataUrls: [] };
  const image = await loadImage(dataUrl);
  const limit = Number.isSafeInteger(Number(maxDataUrlCharacters)) && Number(maxDataUrlCharacters) > 0
    ? Number(maxDataUrlCharacters)
    : 1;
  return {
    ok: true,
    dataUrls: values.map((selection) => cropLoadedScreenshotDataUrl(image, selection, limit))
  };
}

function cropLoadedScreenshotDataUrl(image, selection, maxCharacters) {
  const geometry = calculateCropGeometry({
    imageWidth: image.naturalWidth,
    imageHeight: image.naturalHeight,
    viewportWidth: selection.viewportWidth,
    viewportHeight: selection.viewportHeight,
    rect: selection.rect
  });
  let width = geometry.outputWidth;
  let height = geometry.outputHeight;
  for (let attempt = 0; attempt < 5; attempt += 1) {
    const canvas = document.createElement("canvas");
    canvas.width = width;
    canvas.height = height;
    const context = canvas.getContext("2d", { alpha: false });
    if (!context) return "";
    context.drawImage(image, geometry.sourceX, geometry.sourceY, geometry.sourceWidth, geometry.sourceHeight, 0, 0, width, height);
    const dataUrl = canvas.toDataURL(SCREENSHOT_SETTINGS.mimeType, SCREENSHOT_SETTINGS.quality);
    if (dataUrl.length <= maxCharacters) return dataUrl;
    width = Math.max(1, Math.floor(width * 0.7));
    height = Math.max(1, Math.floor(height * 0.7));
  }
  return "";
}

async function cropLoadedScreenshot(image, entryId, selection) {
  const geometry = calculateCropGeometry({
    imageWidth: image.naturalWidth,
    imageHeight: image.naturalHeight,
    viewportWidth: selection.viewportWidth,
    viewportHeight: selection.viewportHeight,
    rect: selection.rect
  });
  const canvas = document.createElement("canvas");
  canvas.width = geometry.outputWidth;
  canvas.height = geometry.outputHeight;
  const context = canvas.getContext("2d", { alpha: false });
  if (!context) throw new Error("浏览器无法创建截图画布");
  context.drawImage(
    image,
    geometry.sourceX,
    geometry.sourceY,
    geometry.sourceWidth,
    geometry.sourceHeight,
    0,
    0,
    geometry.outputWidth,
    geometry.outputHeight
  );
  const blob = await canvasToBlob(canvas);
  await saveScreenshotBlob(entryId, blob);
  const colors = extractPalette(context.getImageData(0, 0, canvas.width, canvas.height));
  return {
    ok: true,
    width: geometry.outputWidth,
    height: geometry.outputHeight,
    mimeType: blob.type,
    byteSize: blob.size,
    palette: colors.length ? { colors, source: "screenshot", version: PALETTE_VERSION } : undefined
  };
}

export async function createArchiveUrl({
  entries, settings, taxonomy, facetCatalog, classificationRules, organizerState,
  composerSettings, composerSessions, creativeExperimentSettings, creativeRuns,
  creativeSkills, compoundCases, uiPreferences, locale: localeValue, sharing = false,
  installUrl = "", sourceUrl = ""
}) {
  const files = [];
  const resolvedEntries = [];
  const imagePaths = new Map();
  let imageCount = 0;
  const preferences = normalizeUiPreferences(uiPreferences);
  const locale = localeValue === "en" ? "en" : "zh-CN";

  for (const entry of Array.isArray(entries) ? entries : []) {
    assertCaseFilesReadable(entry);
    const normalized = normalizeEntryMedia(entry);
    const mediaAssets = [];
    for (const asset of normalized.mediaAssets) {
      if (asset.storageMode === "reference") {
        if (sharing && asset.recordType === "local-asset-reference") {
          const blob = await readLinkedAssetForShare(asset, entry.title);
          const portableFormat = resolvePortableAssetFormat(asset, blob);
          const assetPath = `${portableFormat.directory}/${safeAssetName(entry.id)}/${safeAssetName(asset.id)}.${portableFormat.extension}`;
          files.push({ name: assetPath, data: blob });
          mediaAssets.push(portableManagedAsset(asset, blob, assetPath, portableFormat));
          continue;
        }
        mediaAssets.push(asset);
        continue;
      }
      const blob = await getMediaBlob(asset.id);
      if (!blob) throw new Error(`“${entry.title || "未命名案例"}”的媒体文件缺失,请从完整备份恢复后再导出`);
      const portableFormat = resolvePortableAssetFormat(asset, blob);
      const assetPath = `${portableFormat.directory}/${safeAssetName(entry.id)}/${safeAssetName(asset.id)}.${portableFormat.extension}`;
      files.push({ name: assetPath, data: blob });
      if (asset.kind === "image") {
        imagePaths.set(asset.id, assetPath);
        imageCount += 1;
      }
      mediaAssets.push(portableManagedAsset(asset, blob, assetPath, portableFormat));
    }
    resolvedEntries.push({ ...normalized, mediaAssets });
  }

  const resolvedCreativeRuns = [];
  if (!sharing) {
    for (const run of normalizeCreativeRuns(creativeRuns)) {
      const outputs = [];
      for (const output of run.outputs) {
        let screenshotPath = imagePaths.get(output.visual.id);
        if (!screenshotPath) {
          const blob = await getScreenshotBlob(output.visual.id);
          if (!blob) throw new Error("创作实验中的生成结果图片缺失,请删除该结果或重新采集后再备份");
          screenshotPath = `creative-results/${safeAssetName(run.id)}/${safeAssetName(output.visual.id)}.${imageExtension(blob.type)}`;
          files.push({ name: screenshotPath, data: blob });
          imagePaths.set(output.visual.id, screenshotPath);
          imageCount += 1;
        }
        outputs.push({ ...output, visual: { ...output.visual, screenshotPath } });
      }
      resolvedCreativeRuns.push({ ...run, outputs });
    }
  }

  const archivedSkillPaths = new Set();
  const archivedSkillBlobs = new Map(), skillDigest = createBlobDigestCache();
  const resolvedCreativeSkills = structuredClone(creativeSkills ?? { version: 1, items: [] });
  if (!sharing) {
    for (const skill of resolvedCreativeSkills.items ?? []) {
      for (const file of skillPackageFiles(skill)) {
        const blob = archivedSkillBlobs.get(file.assetId) ?? await getMediaBlob(file.assetId);
        if (!blob) throw new Error(`外部 Skill 原包文件缺失:${file.path}`);
        archivedSkillBlobs.set(file.assetId, blob);
        if (file.sha256 && await skillDigest(blob) !== file.sha256) throw new Error(`Skill文件与保存时摘要不一致:${file.path}`);
        const archivePath = skillArchivePath(skill.portableId, file.assetId, file.path);
        if (!archivedSkillPaths.has(archivePath)) files.push({ name: archivePath, data: blob });
        archivedSkillPaths.add(archivePath);
        file.archivePath = archivePath;
        file.byteSize = blob.size;
        file.mimeType = blob.type || file.mimeType || "application/octet-stream";
      }
    }
  }

  files.unshift({
    name: archiveMarkdownFilename(settings),
    data: renderMarkdown(resolvedEntries, settings, taxonomy, facetCatalog, { locale })
  });
  const libraryJson = renderLibraryJson(
    resolvedEntries,
    settings,
    taxonomy,
    facetCatalog,
    classificationRules,
    organizerState,
    sharing ? null : {
      composerSettings,
      composerSessions,
      creativeExperimentSettings,
      creativeRuns: resolvedCreativeRuns,
      creativeSkills: resolvedCreativeSkills
    },
    compoundCases
  );
  files.splice(1, 0, {
    name: "library.json",
    data: libraryJson
  });
  if (sharing) {
    const [foundationCss, iconSprite, masonrySource] = await Promise.all([
      packagedRuntimeAsset("ui-foundation.css"),
      packagedRuntimeAsset("assets/ui-icons.svg"),
      packagedRuntimeAsset("stable-masonry.js")
    ]);
    files.splice(2, 0, {
      name: SHARE_PREVIEW_HTML_FILENAME,
      data: renderSharePreviewHtml(resolvedEntries, settings, taxonomy, facetCatalog, {
        installUrl,
        sourceUrl,
        locale,
        theme: preferences.theme,
        iconSprite
      })
    });
    files.splice(3, 0, {
      name: SHARE_PREVIEW_RUNTIME_FILENAME,
      data: renderSharePreviewRuntimeJs()
    });
    files.splice(4, 0,
      { name: SHARE_PREVIEW_FOUNDATION_FILENAME, data: foundationCss },
      { name: SHARE_PREVIEW_MASONRY_FILENAME, data: renderSharePreviewMasonryJs(masonrySource) }
    );
  }
  const archive = await createVerifiedLibraryZip(files, libraryJson);
  const url = URL.createObjectURL(archive);
  blobUrls.add(url);
  return { ok: true, url, imageCount, fileCount: files.length, byteSize: archive.size };
}

async function createCuratedSubmissionUrls({
  entries, settings, taxonomy, facetCatalog, classificationRules, organizerState, compoundCases, locale
}) {
  const submissionName = locale === "en" ? "Submission" : "投稿";
  const files = [];
  const resolvedEntries = [];
  let mediaCount = 0;
  for (const entry of Array.isArray(entries) ? entries : []) {
    const normalized = normalizeEntryMedia(entry);
    const mediaAssets = [];
    for (const asset of normalized.mediaAssets) {
      if (asset.storageMode !== "managed") throw new Error(`“${entry.title || "未命名案例"}”包含未保存到本地的媒体`);
      const blob = await getMediaBlob(asset.id);
      if (!blob) throw new Error(`“${entry.title || "未命名案例"}”的媒体文件缺失`);
      const portableFormat = resolvePortableAssetFormat(asset, blob);
      const assetPath = `${portableFormat.directory}/${safeAssetName(entry.id)}/${safeAssetName(asset.id)}.${portableFormat.extension}`;
      files.push({ name: assetPath, data: blob });
      mediaAssets.push(portableManagedAsset(asset, blob, assetPath, portableFormat));
      mediaCount += 1;
    }
    resolvedEntries.push({ ...normalized, mediaAssets });
  }
  files.unshift({
    name: "library.json",
    data: renderLibraryJson(
      resolvedEntries,
      settings,
      taxonomy,
      facetCatalog,
      classificationRules,
      organizerState,
      null,
      compoundCases
    )
  });
  const payload = await createZipBlob(files);
  const submissionId = await sha256Hex(payload);
  const manifest = submissionManifest({
    submissionId,
    payloadBytes: payload.size,
    caseCount: resolvedEntries.length,
    mediaCount
  });
  const submissionArchive = await createZipBlob([
    { name: "submission.json", data: `${JSON.stringify(manifest, null, 2)}\n` },
    { name: "payload.zip", data: payload }
  ]);
  const archiveSha256 = await sha256Hex(submissionArchive);
  const outputBlobs = submissionArchive.size <= CURATED_SUBMISSION_MAX_FILE_BYTES
    ? [submissionArchive]
    : await splitCuratedSubmissionArchive(submissionArchive, { submissionId, archiveSha256 });
  const shortId = submissionId.slice(0, 12);
  const outputs = outputBlobs.map((blob, index) => {
    const url = URL.createObjectURL(blob);
    blobUrls.add(url);
    const split = outputBlobs.length > 1;
    return {
      url,
      byteSize: blob.size,
      filename: split
        ? `PromptDirector-${submissionName}-${shortId}-${String(index + 1).padStart(2, "0")}-of-${String(outputBlobs.length).padStart(2, "0")}.zip`
        : `PromptDirector-${submissionName}-${shortId}.zip`
    };
  });
  return {
    ok: true,
    submissionId,
    caseCount: resolvedEntries.length,
    mediaCount,
    payloadBytes: payload.size,
    archiveBytes: submissionArchive.size,
    partCount: outputs.length,
    outputs
  };
}

async function splitCuratedSubmissionArchive(archive, { submissionId, archiveSha256 }) {
  const bytes = new Uint8Array(await archive.arrayBuffer());
  const partCount = Math.ceil(bytes.byteLength / CURATED_SUBMISSION_PART_PAYLOAD_BYTES);
  const parts = [];
  for (let index = 0; index < partCount; index += 1) {
    const start = index * CURATED_SUBMISSION_PART_PAYLOAD_BYTES;
    const payload = bytes.slice(start, Math.min(bytes.byteLength, start + CURATED_SUBMISSION_PART_PAYLOAD_BYTES));
    const manifest = submissionPartManifest({
      submissionId,
      archiveSha256,
      archiveBytes: bytes.byteLength,
      partIndex: index + 1,
      partCount,
      payloadSha256: await sha256Hex(payload),
      payloadBytes: payload.byteLength
    });
    const part = await createZipBlob([
      { name: "part.json", data: `${JSON.stringify(manifest, null, 2)}\n` },
      { name: "payload.bin", data: payload }
    ]);
    if (part.size > CURATED_SUBMISSION_MAX_FILE_BYTES) throw new Error("投稿分卷超过 GitHub 上传上限");
    parts.push(part);
  }
  return parts;
}

async function packagedRuntimeAsset(path) {
  const response = await fetch(chrome.runtime.getURL(path));
  if (!response.ok) throw new Error(`分享页运行资源缺失:${path}`);
  return response.text();
}

function skillArchivePath(portableId, assetId, packagePath) {
  const parts = String(packagePath ?? "").split("/").filter(Boolean).map(safeAssetName);
  if (!parts.length) throw new Error("外部 Skill 原包路径无效");
  return ["skills", safeAssetName(portableId), safeAssetName(assetId), ...parts].join("/");
}

function canvasToBlob(canvas) {
  return new Promise((resolve, reject) => {
    canvas.toBlob(
      (blob) => (blob ? resolve(blob) : reject(new Error("截图压缩失败"))),
      SCREENSHOT_SETTINGS.mimeType,
      SCREENSHOT_SETTINGS.quality
    );
  });
}

function safeAssetName(value) {
  const safe = String(value ?? "").replace(/[^A-Za-z0-9._-]/g, "-");
  if (!safe || safe === "." || safe === "..") throw new Error("案例编号无效");
  return safe;
}

function imageExtension(mimeType) {
  if (mimeType === "image/png") return "png";
  if (mimeType === "image/jpeg") return "jpg";
  if (mimeType === "image/webp") return "webp";
  throw new Error(`不支持的截图格式:${mimeType || "未知"}`);
}

export function portableManagedAsset(asset, blob, assetPath, portableFormat) {
  const next = { ...asset };
  for (const field of [
    "recordType", "linkStatus", "importFailure", "sourceLastModified", "linkedAt",
    "localPath", "absolutePath", "fileHandle", "handle", "reference"
  ]) delete next[field];
  next.storageMode = "managed";
  next.assetPath = assetPath;
  next.byteSize = blob.size;
  next.mimeType = portableFormat.mimeType;
  next.sourceFormat = portableFormat.extension;
  next.formatCategory = portableFormat.formatCategory;
  next.playbackCapability = portableFormat.playbackCapability;
  return next;
}

export async function readLinkedAssetForShare(asset, entryTitle, dependencies = {}) {
  const label = `“${entryTitle || "未命名案例"}”中的“${asset.sourceTitle || "本机源文件"}”`;
  const getRecord = dependencies.getLocalAssetHandleRecord || getLocalAssetHandleRecord;
  const inspect = dependencies.inspectStoredLocalAsset || inspectStoredLocalAsset;
  const record = await getRecord(asset.id);
  if (!record) throw new Error(`${label}没有保存可读取的本机链接,请重新选择文件后再分享`);
  const inspection = await inspect(asset.id);
  if (inspection.status === LOCAL_ASSET_LINK_STATUS.NEEDS_PERMISSION) {
    throw new Error(`${label}尚未获得读取权限,请在素材详情中授权后再分享`);
  }
  if (inspection.status === LOCAL_ASSET_LINK_STATUS.MISSING) {
    throw new Error(`${label}已移动、改名或删除,请重新链接后再分享`);
  }
  if (inspection.status === LOCAL_ASSET_LINK_STATUS.CHANGED) {
    throw new Error(`${label}自链接后发生了变化,请确认并重新链接后再分享`);
  }
  if (inspection.status !== LOCAL_ASSET_LINK_STATUS.READY || !(inspection.file instanceof Blob)) {
    throw new Error(`${label}当前不可读取,请重新链接后再分享`);
  }
  return inspection.file;
}

function loadImage(dataUrl) {
  return new Promise((resolve, reject) => {
    const image = new Image();
    image.onload = () => resolve(image);
    image.onerror = () => reject(new Error("浏览器无法读取当前截图"));
    image.src = dataUrl;
  });
}
import { assertCaseFilesReadable } from './case-file-status.js';