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

Protect historical recovery across the 1.19.1 upgrade

MigenAI4fac262af7c7
diff --git a/README.md b/README.md
index 39af0bb..20c2f42 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,9 @@ npm install
npm run verify
```
-`npm run package` 生成保留固定身份的本地安装包;`npm run package:release` 生成移除 `key` 的 Chrome Web Store 上传包。两者包含相同的运行代码,只有安装身份用途不同。正式身份缺失时命令会明确失败,避免用户资料被错误扩展 ID 隔离。
+`npm run verify` 是唯一正式发布门槛:先完成源码、资源与单元测试,再跑完整浏览器 E2E,全部通过后才生成商店包;任一阶段失败都不会进入打包。只需快速检查源码时可运行 `npm run verify:source`。`npm run package` 生成保留固定身份的本地安装包;`npm run package:release` 生成移除 `key` 的 Chrome Web Store 上传包。两者包含相同的运行代码,只有安装身份用途不同。正式身份缺失时命令会明确失败,避免用户资料被错误扩展 ID 隔离。
+
+当前浏览器兼容边界和已确认但延期的增强记录在 [已知限制](docs/KNOWN_LIMITATIONS.md)。
## 参与与许可
diff --git a/analysis-scheduler.js b/analysis-scheduler.js
index 14fbb73..1b91e27 100644
--- a/analysis-scheduler.js
+++ b/analysis-scheduler.js
@@ -1,10 +1,68 @@
+import { analysisTaskPriorityRank, normalizeAnalysisPriority } from "./analysis-tasks.js";
import { ANALYSIS_RETRY_POLICY } from "./analysis-retry-policy.js";
const schedulers = new Map();
const inFlight = new Map();
const RETRYABLE_STATUSES = new Set([0, 408, 429, 500, 502, 503, 504]);
+const SHARED_QUEUE_AGING_MS = 30_000;
-export function scheduleAnalysis(keyValue, concurrencyValue, task) {
+export function createAnalysisScheduler(options = {}) {
+ const limit = normalizedQueueConcurrency(options.concurrency);
+ const agingMs = Math.max(1, Math.floor(Number(options.agingMs) || 30_000));
+ const state = {
+ active: 0,
+ limit,
+ queue: [],
+ nextSequence: 0,
+ nextId: 0,
+ agingMs
+ };
+
+ return {
+ schedule(task, scheduleOptions = {}) {
+ if (typeof task !== "function") throw new Error("分析调度参数无效");
+ const item = {
+ id: `analysis-scheduler-item:${++state.nextId}`,
+ task,
+ priority: normalizeAnalysisPriority(scheduleOptions.priority),
+ enqueuedAt: toTime(scheduleOptions.now),
+ sequence: state.nextSequence++,
+ started: false,
+ canceled: false
+ };
+ const promise = new Promise((resolve, reject) => {
+ item.resolve = resolve;
+ item.reject = reject;
+ });
+ const handle = {
+ id: item.id,
+ status: "queued",
+ promise,
+ cancel: () => cancelQueuedItem(state, item)
+ };
+ item.handle = handle;
+ state.queue.push(item);
+ drainPriorityQueue(state);
+ return handle;
+ },
+ snapshot() {
+ return {
+ active: state.active,
+ limit: state.limit,
+ queued: state.queue
+ .filter((item) => !item.canceled)
+ .map((item) => ({
+ id: item.id,
+ priority: item.priority,
+ sequence: item.sequence,
+ ageMs: Math.max(0, Date.now() - item.enqueuedAt)
+ }))
+ };
+ }
+ };
+}
+
+export function scheduleAnalysis(keyValue, concurrencyValue, task, options = {}) {
const key = String(keyValue ?? "").trim();
if (!key || typeof task !== "function") throw new Error("分析调度参数无效");
const concurrency = normalizedConcurrency(concurrencyValue);
@@ -14,12 +72,21 @@ export function scheduleAnalysis(keyValue, concurrencyValue, task) {
effectiveLimit: concurrency,
queue: [],
activeItems: new Set(),
+ nextSequence: 0,
throttledUntil: 0
};
state.activeItems ??= new Set();
if (!schedulers.has(key)) schedulers.set(key, state);
return new Promise((resolve, reject) => {
- state.queue.push({ task, resolve, reject, concurrency });
+ state.queue.push({
+ task,
+ resolve,
+ reject,
+ concurrency,
+ priority: normalizeAnalysisPriority(options.priority),
+ enqueuedAt: Date.now(),
+ sequence: state.nextSequence++
+ });
synchronizeLimit(state);
drain(state);
});
@@ -43,7 +110,9 @@ export async function runScheduledAnalysisWithRetries(options = {}) {
let retries = 0;
for (;;) {
try {
- return await scheduleAnalysis(options.key, options.concurrency, options.task);
+ return await scheduleAnalysis(options.key, options.concurrency, options.task, {
+ priority: options.priority
+ });
} catch (error) {
if (!isRetryable(error) || retries >= ANALYSIS_RETRY_POLICY.serviceRetries) throw error;
const retryAfter = Number(error?.retryAfterMs) || 0;
@@ -57,7 +126,8 @@ export async function runScheduledAnalysisWithRetries(options = {}) {
function drain(state) {
synchronizeLimit(state);
while (state.active < state.effectiveLimit && state.queue.length) {
- const item = state.queue.shift();
+ const item = nextSharedItem(state);
+ if (!item) return;
state.active += 1;
state.activeItems.add(item);
Promise.resolve().then(item.task).then((value) => {
@@ -81,6 +151,82 @@ function drain(state) {
}
}
+function nextSharedItem(state) {
+ let bestIndex = -1;
+ let bestScore = Infinity;
+ let bestSequence = Infinity;
+ const now = Date.now();
+ for (let index = 0; index < state.queue.length; index += 1) {
+ const item = state.queue[index];
+ const score = analysisPriorityScore(item.priority, now - item.enqueuedAt, SHARED_QUEUE_AGING_MS);
+ if (score < bestScore || (score === bestScore && item.sequence < bestSequence)) {
+ bestIndex = index;
+ bestScore = score;
+ bestSequence = item.sequence;
+ }
+ }
+ if (bestIndex < 0) return null;
+ return state.queue.splice(bestIndex, 1)[0];
+}
+
+function drainPriorityQueue(state) {
+ while (state.active < state.limit) {
+ const item = nextPriorityItem(state);
+ if (!item) return;
+ item.started = true;
+ state.active += 1;
+ item.handle.status = "running";
+ Promise.resolve()
+ .then(item.task)
+ .then((value) => {
+ item.handle.status = "completed";
+ item.resolve(value);
+ }, (error) => {
+ item.handle.status = "failed";
+ item.reject(error);
+ })
+ .finally(() => {
+ state.active -= 1;
+ drainPriorityQueue(state);
+ });
+ }
+}
+
+function nextPriorityItem(state) {
+ const now = Date.now();
+ let bestIndex = -1;
+ let bestScore = Infinity;
+ let bestSequence = Infinity;
+ for (let index = 0; index < state.queue.length; index += 1) {
+ const item = state.queue[index];
+ if (item.canceled || item.started) continue;
+ const score = analysisPriorityScore(item.priority, now - item.enqueuedAt, state.agingMs);
+ if (score < bestScore || (score === bestScore && item.sequence < bestSequence)) {
+ bestIndex = index;
+ bestScore = score;
+ bestSequence = item.sequence;
+ }
+ }
+ if (bestIndex < 0) return null;
+ const [item] = state.queue.splice(bestIndex, 1);
+ return item;
+}
+
+function analysisPriorityScore(priority, waitMs, agingMs) {
+ const rank = analysisTaskPriorityRank(priority);
+ return rank - Math.floor(Math.max(0, waitMs) / agingMs);
+}
+
+function cancelQueuedItem(state, item) {
+ if (item.started || item.canceled) return false;
+ item.canceled = true;
+ item.handle.status = "canceled";
+ const index = state.queue.indexOf(item);
+ if (index >= 0) state.queue.splice(index, 1);
+ item.reject(abortError());
+ return true;
+}
+
function synchronizeLimit(state) {
const requestedLimits = [...state.activeItems, ...state.queue].map((item) => item.concurrency);
if (requestedLimits.length) state.limit = Math.min(...requestedLimits);
@@ -100,6 +246,23 @@ function normalizedConcurrency(value) {
return Number.isInteger(number) && number >= 2 ? number : 2;
}
+function normalizedQueueConcurrency(value) {
+ const number = Number(value);
+ return Number.isInteger(number) && number >= 1 ? number : 1;
+}
+
function defaultWait(milliseconds) {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
}
+
+function toTime(value) {
+ if (Number.isFinite(value)) return Math.max(0, Math.floor(value));
+ const parsed = Number(value);
+ return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : Date.now();
+}
+
+function abortError() {
+ const error = new Error("分析任务已取消");
+ error.name = "AbortError";
+ return error;
+}
diff --git a/analysis-task-registry.js b/analysis-task-registry.js
new file mode 100644
index 0000000..6aff7bc
--- /dev/null
+++ b/analysis-task-registry.js
@@ -0,0 +1,115 @@
+import {
+ createAnalysisTask,
+ normalizeAnalysisPriority,
+ normalizeAnalysisTask,
+ restartRunningAnalysisTask
+} from "./analysis-tasks.js";
+
+const ANALYSIS_TASK_REGISTRY_VERSION = 1;
+const MAX_PERSISTED_ANALYSIS_TASKS = 50;
+
+export function createOrJoinAnalysisTask(value, requestValue = {}, options = {}) {
+ const state = normalizeAnalysisTaskRegistry(value);
+ const request = normalizeRequest(requestValue);
+ if (!request.sessionId || !request.tempReferenceIds.length || !request.clientRequestId) {
+ throw new Error("图片分析任务缺少会话、参考图片或请求编号");
+ }
+ const existing = state.items.find((task) => task.clientRequestIds.includes(request.clientRequestId));
+ if (existing) {
+ if (request.consumerId && !existing.consumerIds.includes(request.consumerId)) existing.consumerIds.push(request.consumerId);
+ return { state, task: structuredClone(existing), created: false };
+ }
+ const task = createAnalysisTask({
+ id: options.taskId,
+ priority: request.priority,
+ now: options.now
+ });
+ Object.assign(task, {
+ request: {
+ sessionId: request.sessionId,
+ tempReferenceIds: request.tempReferenceIds,
+ outputLocale: request.outputLocale,
+ priority: request.priority
+ },
+ consumerIds: request.consumerId ? [request.consumerId] : [],
+ clientRequestIds: [request.clientRequestId]
+ });
+ state.items.push(task);
+ state.items = state.items.slice(-MAX_PERSISTED_ANALYSIS_TASKS);
+ return { state, task: structuredClone(task), created: true };
+}
+
+export function detachAnalysisTaskConsumer(value, taskIdValue, consumerIdValue, clientRequestIdValue = "") {
+ const state = normalizeAnalysisTaskRegistry(value);
+ const taskId = clean(taskIdValue);
+ const consumerId = clean(consumerIdValue);
+ const clientRequestId = clean(clientRequestIdValue);
+ const task = state.items.find((item) => item.id === taskId)
+ ?? state.items.find((item) => clientRequestId && item.clientRequestIds.includes(clientRequestId));
+ if (!task) throw new Error("没有找到图片分析任务");
+ task.consumerIds = task.consumerIds.filter((id) => id !== consumerId);
+ return { state, task: structuredClone(task) };
+}
+
+export function replaceAnalysisTask(value, taskValue) {
+ const state = normalizeAnalysisTaskRegistry(value);
+ const task = normalizeRegistryTask(taskValue);
+ const index = state.items.findIndex((item) => item.id === task.id);
+ if (index < 0) state.items.push(task);
+ else state.items[index] = task;
+ state.items = state.items.slice(-MAX_PERSISTED_ANALYSIS_TASKS);
+ return state;
+}
+
+export function recoverInterruptedAnalysisTasks(value, options = {}) {
+ const state = normalizeAnalysisTaskRegistry(value);
+ state.items = state.items.map((task) => task.status === "running"
+ ? normalizeRegistryTask(restartRunningAnalysisTask(task, options))
+ : task);
+ return state;
+}
+
+export function analysisTaskById(value, taskIdValue) {
+ const taskId = clean(taskIdValue);
+ const task = normalizeAnalysisTaskRegistry(value).items.find((item) => item.id === taskId);
+ return task ? structuredClone(task) : null;
+}
+
+export function normalizeAnalysisTaskRegistry(value) {
+ const items = [];
+ const seen = new Set();
+ for (const raw of Array.isArray(value?.items) ? value.items : []) {
+ const task = normalizeRegistryTask(raw);
+ if (seen.has(task.id)) continue;
+ seen.add(task.id);
+ items.push(task);
+ }
+ return { version: ANALYSIS_TASK_REGISTRY_VERSION, items: items.slice(-MAX_PERSISTED_ANALYSIS_TASKS) };
+}
+
+function normalizeRegistryTask(value) {
+ const task = normalizeAnalysisTask(value);
+ task.request = normalizeRequest(value?.request);
+ task.consumerIds = uniqueIds(value?.consumerIds);
+ task.clientRequestIds = uniqueIds(value?.clientRequestIds);
+ return task;
+}
+
+function normalizeRequest(value = {}) {
+ return {
+ sessionId: clean(value.sessionId),
+ tempReferenceIds: uniqueIds(value.tempReferenceIds),
+ outputLocale: value.outputLocale === "en" ? "en" : "zh-CN",
+ priority: normalizeAnalysisPriority(value.priority),
+ consumerId: clean(value.consumerId),
+ clientRequestId: clean(value.clientRequestId)
+ };
+}
+
+function uniqueIds(values) {
+ return [...new Set((Array.isArray(values) ? values : []).map(clean).filter(Boolean))];
+}
+
+function clean(value) {
+ return String(value ?? "").trim();
+}
diff --git a/analysis-tasks.js b/analysis-tasks.js
new file mode 100644
index 0000000..e686beb
--- /dev/null
+++ b/analysis-tasks.js
@@ -0,0 +1,260 @@
+export const ANALYSIS_TASK_PRIORITIES = Object.freeze(["interactive", "user_batch", "background_import"]);
+
+export function normalizeAnalysisPriority(value) {
+ const priority = String(value ?? "").trim();
+ return ANALYSIS_TASK_PRIORITIES.includes(priority) ? priority : "user_batch";
+}
+
+export function analysisTaskPriorityRank(value) {
+ return {
+ interactive: 0,
+ user_batch: 1,
+ background_import: 2
+ }[normalizeAnalysisPriority(value)] ?? 1;
+}
+
+export function createAnalysisTask(value = {}) {
+ const now = timestamp(value.now);
+ return {
+ version: 1,
+ id: cleanId(value.id, "analysis-task"),
+ priority: normalizeAnalysisPriority(value.priority),
+ status: "queued",
+ executionState: "queued",
+ createdAt: now,
+ updatedAt: now,
+ activeAttemptId: "",
+ attemptCount: 0,
+ providerMayHaveAccepted: false,
+ attempts: []
+ };
+}
+
+export function startAnalysisAttempt(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ if (["canceled", "completed", "failed"].includes(task.status)) {
+ throw new Error("任务已经结束,不能再开始新的 Attempt");
+ }
+ if (task.status === "running") {
+ throw new Error("任务已经在运行中");
+ }
+ const attemptId = cleanId(options.attemptId, "attempt");
+ const now = timestamp(options.now);
+ const attemptNumber = task.attemptCount + 1;
+ const nextAttempt = {
+ id: attemptId,
+ attemptNumber,
+ status: "running",
+ startedAt: now,
+ finishedAt: "",
+ result: null,
+ writeCount: 0
+ };
+ task.attempts.push(nextAttempt);
+ task.activeAttemptId = attemptId;
+ task.attemptCount = attemptNumber;
+ task.status = "running";
+ task.executionState = "running";
+ task.updatedAt = now;
+ return task;
+}
+
+export function restartRunningAnalysisTask(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ if (task.status !== "running") return task;
+ const now = timestamp(options.now);
+ const attempt = currentAttempt(task);
+ if (attempt) {
+ attempt.status = "execution_state_unknown";
+ attempt.finishedAt = now;
+ }
+ task.activeAttemptId = "";
+ task.status = "stopped";
+ task.executionState = "execution_state_unknown";
+ task.updatedAt = now;
+ return task;
+}
+
+export function cancelQueuedAnalysisTask(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ if (task.status !== "queued" || task.attempts.length) return task;
+ task.status = "canceled";
+ task.executionState = "canceled";
+ task.updatedAt = timestamp(options.now);
+ return task;
+}
+
+export function applyAnalysisAttemptWrite(value, write = {}) {
+ const task = normalizeAnalysisTask(value);
+ const attemptId = String(write.attemptId ?? "").trim();
+ const attempt = attemptId ? task.attempts.find((item) => item.id === attemptId) : null;
+ if (!attempt || task.activeAttemptId !== attemptId || task.status !== "running" || task.executionState !== "running" || attempt.status !== "running") {
+ throw staleAttemptError();
+ }
+ const now = timestamp(write.now);
+ if (Object.hasOwn(write, "result")) {
+ attempt.result = structuredClone(write.result);
+ }
+ attempt.writeCount += 1;
+ task.updatedAt = now;
+ return task;
+}
+
+export function completeAnalysisAttempt(value, options = {}) {
+ const task = applyAnalysisAttemptWrite(value, {
+ attemptId: options.attemptId,
+ result: options.result,
+ now: options.now
+ });
+ const attempt = currentAttempt(task);
+ attempt.status = "completed";
+ attempt.finishedAt = timestamp(options.now);
+ task.status = "completed";
+ task.executionState = "completed";
+ task.activeAttemptId = "";
+ task.updatedAt = attempt.finishedAt;
+ return task;
+}
+
+export function failAnalysisAttempt(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ const attempt = requireActiveAttempt(task, options.attemptId);
+ const now = timestamp(options.now);
+ attempt.status = "failed";
+ attempt.finishedAt = now;
+ attempt.error = String(options.error ?? "").trim();
+ task.status = "failed";
+ task.executionState = "failed";
+ task.activeAttemptId = "";
+ task.updatedAt = now;
+ return task;
+}
+
+export function retryAnalysisAttempt(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ if (options.confirmed !== true) throw new Error("重新发起分析前必须确认可能再次计费");
+ if (!["failed", "stopped"].includes(task.status) && task.executionState !== "execution_state_unknown") {
+ throw new Error("当前分析任务不能重新发起");
+ }
+ task.status = "queued";
+ task.executionState = "queued";
+ task.activeAttemptId = "";
+ task.providerMayHaveAccepted = false;
+ return startAnalysisAttempt(task, options);
+}
+
+export function stopAnalysisTask(value, options = {}) {
+ const task = normalizeAnalysisTask(value);
+ if (["completed", "failed", "canceled"].includes(task.status)) return task;
+ const now = timestamp(options.now);
+ const attempt = currentAttempt(task);
+ task.providerMayHaveAccepted = task.status === "running" || Boolean(attempt);
+ if (attempt?.status === "running") {
+ attempt.status = "canceled";
+ attempt.finishedAt = now;
+ }
+ task.status = "stopped";
+ task.executionState = "canceled";
+ task.activeAttemptId = "";
+ task.updatedAt = now;
+ return task;
+}
+
+export function normalizeAnalysisTask(value) {
+ if (!value || typeof value !== "object" || Array.isArray(value)) {
+ return createAnalysisTask();
+ }
+ const task = structuredClone(value);
+ task.version = 1;
+ task.id = cleanId(task.id, "analysis-task");
+ task.priority = normalizeAnalysisPriority(task.priority);
+ task.status = normalizeTaskStatus(task.status);
+ task.executionState = normalizeExecutionState(task.executionState, task.status);
+ task.createdAt = String(task.createdAt ?? "");
+ task.updatedAt = String(task.updatedAt ?? task.createdAt ?? "");
+ task.activeAttemptId = String(task.activeAttemptId ?? "");
+ task.attemptCount = Math.max(0, Math.floor(Number(task.attemptCount) || 0));
+ task.providerMayHaveAccepted = task.providerMayHaveAccepted === true;
+ task.attempts = Array.isArray(task.attempts)
+ ? task.attempts.flatMap((attempt) => normalizeAttempt(attempt))
+ : [];
+ if (!task.attemptCount) task.attemptCount = task.attempts.reduce((max, attempt) => Math.max(max, attempt.attemptNumber), 0);
+ const activeAttempt = task.activeAttemptId ? task.attempts.find((attempt) => attempt.id === task.activeAttemptId) : null;
+ if (task.status === "running" && (!activeAttempt || activeAttempt.status !== "running")) {
+ task.status = "stopped";
+ task.executionState = "execution_state_unknown";
+ task.activeAttemptId = "";
+ }
+ if (task.status !== "running" && task.executionState === "running") {
+ task.executionState = task.status === "queued" ? "queued" : task.status === "canceled" ? "canceled" : task.status === "completed" ? "completed" : "execution_state_unknown";
+ }
+ return task;
+}
+
+function normalizeAttempt(value) {
+ if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+ const id = cleanId(value.id, "attempt");
+ const attemptNumber = Math.max(1, Math.floor(Number(value.attemptNumber) || 0));
+ const status = normalizeAttemptStatus(value.status);
+ return [{
+ id,
+ attemptNumber,
+ status,
+ startedAt: String(value.startedAt ?? ""),
+ finishedAt: String(value.finishedAt ?? ""),
+ result: Object.hasOwn(value, "result") ? structuredClone(value.result) : null,
+ error: String(value.error ?? ""),
+ writeCount: Math.max(0, Math.floor(Number(value.writeCount) || 0))
+ }];
+}
+
+function normalizeTaskStatus(value) {
+ const status = String(value ?? "").trim();
+ return ["queued", "running", "stopped", "completed", "failed", "canceled"].includes(status) ? status : "queued";
+}
+
+function normalizeExecutionState(value, status) {
+ const state = String(value ?? "").trim();
+ if (["queued", "running", "execution_state_unknown", "completed", "failed", "canceled"].includes(state)) return state;
+ return status === "running" ? "running"
+ : status === "canceled" ? "canceled"
+ : status === "completed" ? "completed"
+ : status === "failed" ? "failed"
+ : status === "stopped" ? "execution_state_unknown"
+ : "queued";
+}
+
+function normalizeAttemptStatus(value) {
+ const status = String(value ?? "").trim();
+ return ["queued", "running", "execution_state_unknown", "completed", "failed", "canceled"].includes(status)
+ ? status
+ : "queued";
+}
+
+function currentAttempt(task) {
+ return task.activeAttemptId ? task.attempts.find((attempt) => attempt.id === task.activeAttemptId) ?? null : null;
+}
+
+function requireActiveAttempt(task, attemptIdValue) {
+ const attemptId = String(attemptIdValue ?? "").trim();
+ const attempt = currentAttempt(task);
+ if (!attempt || attempt.id !== attemptId || task.status !== "running" || task.executionState !== "running" || attempt.status !== "running") {
+ throw staleAttemptError();
+ }
+ return attempt;
+}
+
+function staleAttemptError() {
+ const error = new Error("这次写回已经失效,请重新发起新的 Attempt");
+ error.code = "STALE_ATTEMPT";
+ return error;
+}
+
+function cleanId(value, fallbackPrefix) {
+ const text = String(value ?? "").trim();
+ return text || `${fallbackPrefix}:${globalThis.crypto.randomUUID()}`;
+}
+
+function timestamp(value) {
+ return String(value ?? new Date().toISOString());
+}
diff --git a/background.js b/background.js
index ed59485..24d4207 100644
--- a/background.js
+++ b/background.js
@@ -84,6 +84,21 @@ import {
import { canonicalTextAnalysisInput } from "./analysis-input.js";
import { buildAutomaticVisionJob } from "./automatic-vision.js";
import { coalesceAnalysisRequest, runScheduledAnalysisWithRetries } from "./analysis-scheduler.js";
+import {
+ completeAnalysisAttempt,
+ failAnalysisAttempt,
+ retryAnalysisAttempt,
+ startAnalysisAttempt,
+ stopAnalysisTask
+} from "./analysis-tasks.js";
+import {
+ analysisTaskById,
+ createOrJoinAnalysisTask,
+ detachAnalysisTaskConsumer,
+ normalizeAnalysisTaskRegistry,
+ recoverInterruptedAnalysisTasks,
+ replaceAnalysisTask
+} from "./analysis-task-registry.js";
import { findPersistedVisionAnalysis } from "./vision-analysis-cache.js";
import {
analysisRevisionMeta,
@@ -181,10 +196,17 @@ import {
selectLibraryPackage,
selectProjectPackage
} from "./library-package.js";
+import {
+ claimLibraryImportTransaction,
+ createLibraryImportPlanToken,
+ failLibraryImportTransaction,
+ succeedLibraryImportTransaction
+} from "./library-import-transaction.js";
import { mergeCuratedLibraryPackage } from "./curated-import.js";
import { prepareCuratedSubmissionState } from "./curated-submission.js";
import {
createCollection,
+ collectionEntryIds,
collectionPathLabel,
collectionSelectorLabelsById,
moveCollection,
@@ -372,6 +394,8 @@ const STORAGE_KEYS = Object.freeze({
visionAnalysisUndo: "visionAnalysisUndo",
automaticVisionBatchJob: "automaticVisionBatchJob",
batchJob: "batchJob",
+ analysisTasks: "analysisTasks",
+ libraryImportTransactions: "libraryImportTransactions",
libraryMaintenanceJob: "libraryMaintenanceJob",
legacyAnalysisBatchJob: "analysisBatchJob",
analysisBatchUndo: "analysisBatchUndo",
@@ -451,9 +475,11 @@ let analysisBatchRunnerActive = false;
let analysisBatchRunnerTimer = 0;
let importRunnerActive = false;
let importRunnerTimer = 0;
+const analysisTaskRunners = new Map();
const LIBRARY_MAINTENANCE_ALARM = "prompt-director-library-maintenance";
const AUTOMATIC_VISION_ALARM = "prompt-director-automatic-vision";
const ANALYSIS_BATCH_ALARM = "prompt-director-analysis-batch";
+const ANALYSIS_TASK_ALARM = "prompt-director-analysis-task";
const IMPORT_JOB_ALARM = "prompt-director-local-import";
const MAINTENANCE_SLICE_TARGET_MS = 250;
const captureRuntime = createCaptureWorkspace({
@@ -495,11 +521,15 @@ chrome.alarms.onAlarm.addListener((alarm) => {
if (alarm.name === ANALYSIS_BATCH_ALARM) scheduleAnalysisBatchRunner();
if (alarm.name === IMPORT_JOB_ALARM) scheduleImportRunner();
});
+chrome.alarms.onAlarm.addListener((alarm) => {
+ if (alarm.name === ANALYSIS_TASK_ALARM) return runQueuedAnalysisTasks();
+});
scheduleLibraryMaintenanceRunner();
scheduleAutomaticVisionRunner();
scheduleAnalysisBatchRunner();
recoverCreativeJobs().catch((error) => console.error("PromptDirector creative job recovery failed", error));
enqueue(recoverImportJobs).catch((error) => console.error("PromptDirector local import recovery failed", error));
+enqueue(recoverAnalysisTasks).catch((error) => console.error("PromptDirector analysis task recovery failed", error));
chrome.contextMenus.onClicked.addListener((info, tab) => {
handleContextMenuCapture(info, tab, {
@@ -775,8 +805,16 @@ async function handleMessage(message, interaction = {}) {
return enqueue(async () => removeTempReferenceAction(message));
case "SAVE_TEMP_REFERENCE_AS_CASE":
return enqueue(async () => saveTempReferenceAsCaseAction(message));
- case "ANALYZE_TEMP_REFERENCES":
- return analyzeTempReferencesAction(message);
+ case "START_OR_JOIN_ANALYSIS_TASK":
+ return startOrJoinAnalysisTaskAction(message);
+ case "GET_ANALYSIS_TASK":
+ return enqueue(async () => getAnalysisTaskAction(message.taskId));
+ case "DETACH_ANALYSIS_CONSUMER":
+ return enqueue(async () => detachAnalysisConsumerAction(message));
+ case "STOP_ANALYSIS_TASK":
+ return stopAnalysisTaskAction(message);
+ case "RETRY_ANALYSIS_TASK":
+ return retryAnalysisTaskAction(message);
case "CREATE_CREATIVE_SKILL":
return enqueue(async () => createCreativeSkillAction(message));
case "SAVE_CREATIVE_SKILL_VERSION":
@@ -824,7 +862,8 @@ async function handleMessage(message, interaction = {}) {
message.outputLocale,
message.batchJobId,
message.bypassCache === true,
- message.assignment
+ message.assignment,
+ "interactive"
);
} catch (error) {
return {
@@ -3681,6 +3720,178 @@ async function saveTempReferenceAsCaseAction(message) {
return { ok: true, message: "临时引用已保存为案例", entry, session, summaries: sessions.map(sessionSummary) };
}
+async function startOrJoinAnalysisTaskAction(message) {
+ const created = await enqueue(async () => {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const result = createOrJoinAnalysisTask(stored[STORAGE_KEYS.analysisTasks], message, {
+ taskId: `analysis-task:${crypto.randomUUID()}`
+ });
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: result.state }, { markSyncDirty: false });
+ return result;
+ });
+ if (created.created) scheduleAnalysisTaskRun(created.task.id);
+ return analysisTaskResponse(created.task);
+}
+
+async function getAnalysisTaskAction(taskId) {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const task = analysisTaskById(stored[STORAGE_KEYS.analysisTasks], taskId);
+ if (!task) return { ok: false, message: "没有找到图片分析任务" };
+ return analysisTaskResponse(task);
+}
+
+async function detachAnalysisConsumerAction(message) {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const detached = detachAnalysisTaskConsumer(
+ stored[STORAGE_KEYS.analysisTasks],
+ message.taskId,
+ message.consumerId,
+ message.clientRequestId
+ );
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: detached.state }, { markSyncDirty: false });
+ return analysisTaskResponse(detached.task);
+}
+
+async function stopAnalysisTaskAction(message) {
+ const stopped = await enqueue(async () => {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const state = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ const current = analysisTaskById(state, message.taskId);
+ if (!current) throw new Error("没有找到图片分析任务");
+ const task = stopAnalysisTask(current);
+ const next = replaceAnalysisTask(state, task);
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: next }, { markSyncDirty: false });
+ return task;
+ });
+ analysisTaskRunners.get(stopped.id)?.controller.abort();
+ await notifyAnalysisTaskUpdated(stopped);
+ return analysisTaskResponse(stopped);
+}
+
+async function retryAnalysisTaskAction(message) {
+ if (message.confirmDuplicateCharge !== true) throw new Error("重新分析前必须确认可能再次计费");
+ const retried = await enqueue(async () => {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const state = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ const current = analysisTaskById(state, message.taskId);
+ if (!current) throw new Error("没有找到图片分析任务");
+ const previousAttemptId = current.attempts.at(-1)?.id ?? "";
+ if (String(message.previousAttemptId ?? "").trim() !== previousAttemptId) {
+ throw new Error("图片分析任务已经变化,请刷新后再重试");
+ }
+ const task = retryAnalysisAttempt(current, {
+ attemptId: `analysis-attempt:${crypto.randomUUID()}`,
+ confirmed: true
+ });
+ task.consumerIds = [...new Set([...task.consumerIds, String(message.consumerId ?? "").trim()].filter(Boolean))];
+ task.clientRequestIds = [...new Set([...task.clientRequestIds, String(message.clientRequestId ?? "").trim()].filter(Boolean))];
+ const next = replaceAnalysisTask(state, task);
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: next }, { markSyncDirty: false });
+ return task;
+ });
+ scheduleAnalysisTaskRun(retried.id, retried.activeAttemptId);
+ return analysisTaskResponse(retried);
+}
+
+function scheduleAnalysisTaskRun(taskId, preparedAttemptId = "") {
+ if (analysisTaskRunners.has(taskId)) return;
+ chrome.alarms.create(ANALYSIS_TASK_ALARM, { when: Date.now() + 50 });
+ void runAnalysisTask(taskId, preparedAttemptId);
+}
+
+async function runQueuedAnalysisTasks() {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const state = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ for (const task of state.items.filter((item) => item.status === "queued")) scheduleAnalysisTaskRun(task.id);
+}
+
+async function runAnalysisTask(taskId, preparedAttemptId = "") {
+ if (analysisTaskRunners.has(taskId)) return;
+ const claimed = await enqueue(async () => {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const state = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ const current = analysisTaskById(state, taskId);
+ if (!current) return null;
+ let task = current;
+ if (task.status === "queued") {
+ task = startAnalysisAttempt(task, { attemptId: `analysis-attempt:${crypto.randomUUID()}` });
+ } else if (!preparedAttemptId || task.status !== "running" || task.activeAttemptId !== preparedAttemptId) {
+ return null;
+ }
+ const next = replaceAnalysisTask(state, task);
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: next }, { markSyncDirty: false });
+ return task;
+ });
+ if (!claimed) return;
+ const controller = new AbortController();
+ analysisTaskRunners.set(taskId, { attemptId: claimed.activeAttemptId, controller });
+ let actionResult;
+ try {
+ actionResult = await analyzeTempReferencesAction({
+ ...claimed.request,
+ taskId: claimed.id,
+ attemptId: claimed.activeAttemptId,
+ priority: claimed.priority,
+ signal: controller.signal
+ });
+ } catch (error) {
+ actionResult = { ok: false, message: userMessage(error) };
+ }
+ let settled;
+ try {
+ settled = await enqueue(async () => {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const state = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ const current = analysisTaskById(state, taskId);
+ if (!current || current.activeAttemptId !== claimed.activeAttemptId || current.status !== "running") return current;
+ const task = actionResult?.ok
+ ? completeAnalysisAttempt(current, { attemptId: claimed.activeAttemptId, result: actionResult })
+ : failAnalysisAttempt(current, { attemptId: claimed.activeAttemptId, error: actionResult?.message || "图片分析失败" });
+ const next = replaceAnalysisTask(state, task);
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: next }, { markSyncDirty: false });
+ return task;
+ });
+ } finally {
+ analysisTaskRunners.delete(taskId);
+ }
+ if (settled) await notifyAnalysisTaskUpdated(settled);
+}
+
+async function recoverAnalysisTasks() {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const current = normalizeAnalysisTaskRegistry(stored[STORAGE_KEYS.analysisTasks]);
+ const recovered = recoverInterruptedAnalysisTasks(current);
+ if (JSON.stringify(current) !== JSON.stringify(recovered)) {
+ await commitLocalChanges({ [STORAGE_KEYS.analysisTasks]: recovered }, { markSyncDirty: false });
+ for (const task of recovered.items.filter((item) => item.executionState === "execution_state_unknown")) {
+ await notifyAnalysisTaskUpdated(task);
+ }
+ }
+ for (const task of recovered.items.filter((item) => item.status === "queued")) scheduleAnalysisTaskRun(task.id);
+}
+
+async function analysisTaskAttemptIsActive(taskId, attemptId) {
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.analysisTasks);
+ const task = analysisTaskById(stored[STORAGE_KEYS.analysisTasks], taskId);
+ return Boolean(task && task.status === "running" && task.executionState === "running" && task.activeAttemptId === attemptId);
+}
+
+function analysisTaskResponse(task) {
+ const attempt = task?.activeAttemptId
+ ? task.attempts.find((item) => item.id === task.activeAttemptId)
+ : task?.attempts?.at(-1);
+ return {
+ ok: true,
+ task,
+ attemptId: attempt?.id ?? "",
+ ...(attempt?.result ? { result: attempt.result } : {})
+ };
+}
+
+async function notifyAnalysisTaskUpdated(task) {
+ await chrome.runtime.sendMessage({ type: "ANALYSIS_TASK_UPDATED", ...analysisTaskResponse(task) }).catch(() => undefined);
+}
+
async function analyzeTempReferencesAction(message) {
try {
const sessionId = String(message.sessionId ?? "").trim();
@@ -3708,6 +3919,7 @@ async function analyzeTempReferencesAction(message) {
const settledReferences = await Promise.allSettled(references.map(async (reference) => {
const imageAssets = unreadReferenceImageAssets(reference);
const assetResults = await Promise.all(imageAssets.map(async (asset) => {
+ if (message.signal?.aborted) throw new DOMException("图片分析已停止", "AbortError");
const blob = await getTempReferenceVisionBlob(asset);
if (!blob) throw new Error(`参考图片已经失效:${asset.name || "未命名图片"}`);
const { result, fingerprint } = await analyzeVisionBlobWithScheduler({
@@ -3715,7 +3927,8 @@ async function analyzeTempReferencesAction(message) {
catalog: stored[STORAGE_KEYS.facetCatalog],
locale,
configuration,
- entries: stored[STORAGE_KEYS.entries]
+ entries: stored[STORAGE_KEYS.entries],
+ priority: message.priority
});
return {
description: result.description,
@@ -3744,6 +3957,9 @@ async function analyzeTempReferencesAction(message) {
if (!analyzed.length) throw new Error(failures[0]?.message || "临时图片分析失败");
return await enqueue(async () => {
+ if (message.taskId && !await analysisTaskAttemptIsActive(message.taskId, message.attemptId)) {
+ return { ok: false, message: "这次图片分析已经停止或失效,结果没有写入" };
+ }
const latestStored = await chrome.storage.local.get(STORAGE_KEYS.composerSessions);
const latestSessions = normalizeComposerSessions(latestStored[STORAGE_KEYS.composerSessions]);
const latestSession = latestSessions.find((item) => item.id === sessionId);
@@ -4689,7 +4905,7 @@ function canonicalAiTaskId(value) {
return map[id] || id;
}
-async function analyzeEntryImage(entryId, visualIdValue, outputLocale, batchJobIdValue = "", bypassCache = false, assignmentOverride = null) {
+async function analyzeEntryImage(entryId, visualIdValue, outputLocale, batchJobIdValue = "", bypassCache = false, assignmentOverride = null, priority = "user_batch") {
const state = await readState();
const entry = findEntry(state, entryId);
const visualId = String(visualIdValue ?? "").trim() || primaryVisual(entry)?.id;
@@ -4708,7 +4924,8 @@ async function analyzeEntryImage(entryId, visualIdValue, outputLocale, batchJobI
configuration,
previousAnalysis: visual.visionAnalysis,
entries: state.entries,
- bypassCache
+ bypassCache,
+ priority
});
return await enqueue(async () => {
@@ -4788,7 +5005,7 @@ function configurationForAssignment(configuration, taskId, assignmentOverride) {
};
}
-async function analyzeVisionBlobWithScheduler({ blob, catalog, locale, measuredCanvas, configuration, previousAnalysis, entries = [], bypassCache = false }) {
+async function analyzeVisionBlobWithScheduler({ blob, catalog, locale, measuredCanvas, configuration, previousAnalysis, entries = [], bypassCache = false, priority = "user_batch" }) {
const fingerprint = await imageFingerprint(blob);
const assignment = configuration.assignments.imageAnalysis;
const settings = resolveVisionTaskSettings("imageAnalysis", configuration);
@@ -4818,6 +5035,7 @@ async function analyzeVisionBlobWithScheduler({ blob, catalog, locale, measuredC
result = await coalesceAnalysisRequest(requestKey, () => runScheduledAnalysisWithRetries({
key: schedulerKey,
concurrency: assignment.concurrency,
+ priority,
task: async () => {
return analyzeImageWithVision({
imageDataUrl: await blobToDataUrl(blob),
@@ -5946,7 +6164,8 @@ async function runPersistedVisionBatchSlice(jobId) {
prepared.job.outputLocale,
prepared.job.id,
prepared.job.reanalyze,
- prepared.job
+ prepared.job,
+ "user_batch"
);
} catch (error) {
result = {
@@ -6062,7 +6281,7 @@ async function runAutomaticVisionItem() {
await Promise.all(claimed.claims.map(async (claim) => {
let result;
try {
- result = await analyzeEntryImage(claim.entryId, claim.visualId, job.outputLocale, job.id, false, job);
+ result = await analyzeEntryImage(claim.entryId, claim.visualId, job.outputLocale, job.id, false, job, "background_import");
} catch (error) {
result = { ok: false, message: userMessage(error), status: Number(error?.status) || 0, usage: error?.usage };
}
@@ -6823,13 +7042,18 @@ function previewLibraryImport(state, library, options = {}) {
const result = mergeLibraryPackage(state, library, options);
return {
ok: true,
+ planToken: createLibraryImportPlanToken(state, library),
entryIdMap: result.entryIdMap,
compoundIdMap: result.compoundIdMap,
visualIdMap: result.visualIdMap,
+ createdVisualIdMap: result.createdVisualIdMap,
sessionIdMap: result.sessionIdMap,
runIdMap: result.runIdMap,
skillIdMap: result.skillIdMap,
packageAssetIdMap: result.packageAssetIdMap,
+ createdEntryIds: result.createdEntryIds,
+ importDiagnostics: result.importDiagnostics,
+ importStats: result.importStats,
importedCount: result.importedCount,
remappedCount: result.remappedCount,
skippedCount: result.skippedCount,
@@ -6841,33 +7065,73 @@ function previewLibraryImport(state, library, options = {}) {
}
async function applyLibraryImport(state, message) {
- const result = mergeLibraryPackage(state, message.library, {
- entryIdMap: message.entryIdMap,
- compoundIdMap: message.compoundIdMap,
- visualIdMap: message.visualIdMap,
- sessionIdMap: message.sessionIdMap,
- runIdMap: message.runIdMap,
- skillIdMap: message.skillIdMap,
- packageAssetIdMap: message.packageAssetIdMap,
- preserveLibraryConfiguration: message.preserveLibraryConfiguration === true
+ const stored = await chrome.storage.local.get(STORAGE_KEYS.libraryImportTransactions);
+ const claim = claimLibraryImportTransaction(stored[STORAGE_KEYS.libraryImportTransactions], {
+ operationId: message.operationId,
+ planToken: message.planToken,
+ stateValue: state,
+ sourceValue: message.library
});
+ if (claim.replayed) return claim.result;
+ if (!claim.acquired) {
+ throw Object.assign(new Error("这次导入仍在提交中,请稍后重试"), {
+ code: "IMPORT_TRANSACTION_PENDING"
+ });
+ }
await commitLocalChanges({
- ...storagePayload(result.state),
- [STORAGE_KEYS.settings]: normalizeSettings(result.state.settings ?? state.settings),
- [STORAGE_KEYS.composerSettings]: normalizeComposerSettings(result.state.composerSettings ?? state.composerSettings),
- [STORAGE_KEYS.composerSessions]: normalizeComposerSessions(result.state.composerSessions ?? state.composerSessions),
- [STORAGE_KEYS.creativeExperimentSettings]: normalizeCreativeExperimentSettings(
- result.state.creativeExperimentSettings ?? state.creativeExperimentSettings
- ),
- [STORAGE_KEYS.creativeRuns]: normalizeCreativeRuns(result.state.creativeRuns ?? state.creativeRuns),
- [STORAGE_KEYS.creativeSkills]: normalizeCreativeSkillsState(result.state.creativeSkills ?? state.creativeSkills)
- });
- const importedEntryIds = Object.values(result.entryIdMap);
+ [STORAGE_KEYS.libraryImportTransactions]: claim.state
+ }, { markSyncDirty: false });
+
+ let result;
+ let response;
+ try {
+ result = mergeLibraryPackage(state, message.library, {
+ entryIdMap: message.entryIdMap,
+ compoundIdMap: message.compoundIdMap,
+ visualIdMap: message.visualIdMap,
+ sessionIdMap: message.sessionIdMap,
+ runIdMap: message.runIdMap,
+ skillIdMap: message.skillIdMap,
+ packageAssetIdMap: message.packageAssetIdMap,
+ preserveLibraryConfiguration: message.preserveLibraryConfiguration === true
+ });
+ response = libraryImportResponse(result);
+ const completed = succeedLibraryImportTransaction(claim.state, claim.receipt, response);
+ await commitLocalChanges({
+ ...storagePayload(result.state),
+ [STORAGE_KEYS.settings]: normalizeSettings(result.state.settings ?? state.settings),
+ [STORAGE_KEYS.composerSettings]: normalizeComposerSettings(result.state.composerSettings ?? state.composerSettings),
+ [STORAGE_KEYS.composerSessions]: normalizeComposerSessions(result.state.composerSessions ?? state.composerSessions),
+ [STORAGE_KEYS.creativeExperimentSettings]: normalizeCreativeExperimentSettings(
+ result.state.creativeExperimentSettings ?? state.creativeExperimentSettings
+ ),
+ [STORAGE_KEYS.creativeRuns]: normalizeCreativeRuns(result.state.creativeRuns ?? state.creativeRuns),
+ [STORAGE_KEYS.creativeSkills]: normalizeCreativeSkillsState(result.state.creativeSkills ?? state.creativeSkills),
+ [STORAGE_KEYS.libraryImportTransactions]: completed.state
+ });
+ } catch (error) {
+ const failed = failLibraryImportTransaction(claim.state, claim.receipt);
+ await commitLocalChanges({
+ [STORAGE_KEYS.libraryImportTransactions]: failed
+ }, { markSyncDirty: false }).catch(() => undefined);
+ throw error;
+ }
+
+ const importedEntryIds = result.createdEntryIds;
if (importedEntryIds.length) {
const importedEntryIdSet = new Set(importedEntryIds);
- await enqueueAutomaticLibraryMaintenance(result.state.entries.filter((entry) => importedEntryIdSet.has(entry.id)));
+ await enqueueAutomaticLibraryMaintenance(
+ result.state.entries.filter((entry) => importedEntryIdSet.has(entry.id))
+ ).catch((error) => console.error("Imported library maintenance could not be queued", error));
+ }
+ if (importedEntryIds.length && message.autoAnalyze === true) {
+ await queueAutomaticVisionAnalysis(importedEntryIds)
+ .catch((error) => console.error("Imported library analysis could not be queued", error));
}
- if (importedEntryIds.length) await queueAutomaticVisionAnalysis(importedEntryIds);
+ return response;
+}
+
+function libraryImportResponse(result) {
return {
ok: true,
message: result.importedCount || result.importedRunCount || result.importedSkillCount
diff --git a/composer-analysis-task-bridge.js b/composer-analysis-task-bridge.js
new file mode 100644
index 0000000..1ed8191
--- /dev/null
+++ b/composer-analysis-task-bridge.js
@@ -0,0 +1,172 @@
+export function createComposerAnalysisTaskBridge(options = {}) {
+ if (typeof options.sendMessage !== "function") throw new Error("分析任务桥接缺少消息发送器");
+ const createId = typeof options.createId === "function"
+ ? options.createId
+ : () => globalThis.crypto.randomUUID();
+ let revision = 0;
+ let state = emptyState();
+
+ return {
+ async start(request = {}) {
+ const currentRevision = ++revision;
+ state = {
+ ...emptyState(),
+ attached: true,
+ consumerId: createId(),
+ clientRequestId: createId(),
+ status: "starting"
+ };
+ const response = await options.sendMessage({
+ type: "START_OR_JOIN_ANALYSIS_TASK",
+ priority: "interactive",
+ consumerId: state.consumerId,
+ clientRequestId: state.clientRequestId,
+ sessionId: String(request.sessionId ?? "").trim(),
+ tempReferenceIds: uniqueIds(request.tempReferenceIds),
+ outputLocale: request.outputLocale === "en" ? "en" : "zh-CN"
+ });
+ requireSuccessfulCommand(response);
+ if (currentRevision === revision && state.attached) applyResponse(response);
+ return snapshot();
+ },
+
+ async detach() {
+ if (!state.attached) return snapshot();
+ revision += 1;
+ const message = {
+ type: "DETACH_ANALYSIS_CONSUMER",
+ taskId: state.taskId,
+ consumerId: state.consumerId,
+ clientRequestId: state.clientRequestId
+ };
+ state.attached = false;
+ state.autoContinue = false;
+ requireSuccessfulCommand(await options.sendMessage(message));
+ return snapshot();
+ },
+
+ async stop() {
+ if (!state.attached && !state.taskId) return snapshot();
+ revision += 1;
+ const message = {
+ type: "STOP_ANALYSIS_TASK",
+ taskId: state.taskId,
+ consumerId: state.consumerId,
+ clientRequestId: state.clientRequestId
+ };
+ state.attached = false;
+ state.autoContinue = false;
+ try {
+ const response = await options.sendMessage(message);
+ requireSuccessfulCommand(response);
+ applyResponse(response);
+ return snapshot();
+ } catch (error) {
+ state.status = "stopped";
+ state.executionState = "execution_state_unknown";
+ throw error;
+ }
+ },
+
+ async refresh() {
+ if (!state.attached || !state.taskId) return snapshot();
+ const currentRevision = revision;
+ const response = await options.sendMessage({
+ type: "GET_ANALYSIS_TASK",
+ taskId: state.taskId,
+ consumerId: state.consumerId,
+ clientRequestId: state.clientRequestId
+ });
+ requireSuccessfulCommand(response);
+ if (currentRevision === revision && state.attached) applyResponse(response);
+ return snapshot();
+ },
+
+ async retry(retryOptions = {}) {
+ if (retryOptions.confirmed !== true) throw new Error("请确认重新分析可能再次计费");
+ if (!canRetry()) throw new Error("当前分析任务不能重新发起");
+ const previousAttemptId = state.attemptId;
+ const currentRevision = ++revision;
+ state.attached = true;
+ state.autoContinue = true;
+ state.consumerId = createId();
+ state.clientRequestId = createId();
+ state.status = "starting";
+ state.executionState = "";
+ state.result = null;
+ const response = await options.sendMessage({
+ type: "RETRY_ANALYSIS_TASK",
+ taskId: state.taskId,
+ previousAttemptId,
+ consumerId: state.consumerId,
+ clientRequestId: state.clientRequestId,
+ confirmDuplicateCharge: true
+ });
+ requireSuccessfulCommand(response);
+ if (currentRevision === revision && state.attached) applyResponse(response, { allowAttemptChange: true });
+ return snapshot();
+ },
+
+ acceptUpdate(response) {
+ if (!state.attached) return false;
+ return applyResponse(response);
+ },
+
+ consumeCompletion() {
+ if (!state.attached || !state.autoContinue || state.status !== "completed" || !state.result) return null;
+ const result = structuredClone(state.result);
+ state.attached = false;
+ state.autoContinue = false;
+ state.result = null;
+ return result;
+ },
+
+ snapshot
+ };
+
+ function applyResponse(response = {}, applyOptions = {}) {
+ const task = response?.task ?? {};
+ const taskId = String(task.id ?? response.taskId ?? state.taskId ?? "").trim();
+ const attemptId = String(response.attemptId ?? task.activeAttemptId ?? state.attemptId ?? "").trim();
+ if (state.taskId && taskId && state.taskId !== taskId) return false;
+ if (!applyOptions.allowAttemptChange && state.attemptId && attemptId && state.attemptId !== attemptId) return false;
+ state.taskId = taskId;
+ state.attemptId = attemptId;
+ state.status = String(task.status ?? response.status ?? state.status ?? "").trim();
+ state.executionState = String(task.executionState ?? response.executionState ?? "").trim();
+ state.result = Object.hasOwn(response, "result") ? structuredClone(response.result) : null;
+ state.autoContinue = state.attached;
+ return true;
+ }
+
+ function snapshot() {
+ return structuredClone({ ...state, result: undefined, canRetry: canRetry() });
+ }
+
+ function canRetry() {
+ return state.executionState === "execution_state_unknown" || ["failed", "stopped"].includes(state.status);
+ }
+}
+
+function emptyState() {
+ return {
+ attached: false,
+ autoContinue: false,
+ consumerId: "",
+ clientRequestId: "",
+ taskId: "",
+ attemptId: "",
+ status: "idle",
+ executionState: "",
+ result: null
+ };
+}
+
+function uniqueIds(values) {
+ return [...new Set((Array.isArray(values) ? values : []).map((value) => String(value ?? "").trim()).filter(Boolean))];
+}
+
+function requireSuccessfulCommand(response) {
+ if (response?.ok === true) return;
+ throw new Error(String(response?.message ?? "图片分析任务请求失败"));
+}
diff --git a/composer-page.js b/composer-page.js
index 06115b8..42cc596 100644
--- a/composer-page.js
+++ b/composer-page.js
@@ -45,6 +45,7 @@ import {
} from "./composer-service.js";
import { applyComposerServiceResult, planComposerSession } from "./composer-turn-core.js";
import { createComposerImageWorkspace } from "./composer-image-workspace.js";
+import { createComposerAnalysisTaskBridge } from "./composer-analysis-task-bridge.js";
import { composerAssemblyLayers } from "./composer-agent.js";
import { retrieveComposerSources } from "./composer-retrieval.js";
import { deleteScreenshotBlob, getScreenshotBlob, saveScreenshotBlob } from "./image-store.js";
@@ -131,7 +132,9 @@ const imageWorkspace = createComposerImageWorkspace({
});
let composerSession = null;
let activeOperation = null;
-let imageAnalysisPending = false;
+const composerAnalysisTaskBridge = createComposerAnalysisTaskBridge({
+ sendMessage: (message) => chrome.runtime.sendMessage(message)
+});
let referenceDraftSelections = new Map();
let referenceDraftOrder = [];
let referencePreviewAssetIds = new Map();
@@ -225,19 +228,17 @@ function bindEvents() {
elements.composerAssemblyOpen.addEventListener("click", openAssemblyDialog);
elements.composerAssemblyClose.addEventListener("click", () => elements.composerAssemblyDialog.close());
elements.composerImageBlockerChooseService.addEventListener("click", () => {
- if (imageAnalysisPending) return;
elements.composerImageBlocker.close();
openComposerModelMenu();
});
- elements.composerImageBlockerAnalyze.addEventListener("click", safely(analyzeBlockedTempReferences));
- elements.composerImageBlocker.addEventListener("cancel", (event) => {
- if (imageAnalysisPending) event.preventDefault();
- });
+ elements.composerImageBlockerAnalyze.addEventListener("click", safely(handleBlockedReferenceAnalysisAction));
+ elements.composerImageBlocker.addEventListener("close", safely(detachBlockedReferenceAnalysis));
elements.composerReferenceClose.addEventListener("click", closeReferenceWorkspace);
elements.composerReferenceCancel.addEventListener("click", closeReferenceWorkspace);
elements.composerReferenceSearch.addEventListener("input", renderCasePicker);
document.addEventListener("visibilitychange", () => {
document.body.classList.toggle("composer-page-paused", document.hidden);
+ if (!document.hidden && composerAnalysisTaskBridge.snapshot().attached) safely(refreshBlockedReferenceAnalysis)();
});
elements.composerReferenceProjectFilter.addEventListener("change", renderCasePicker);
elements.composerReferenceClear.addEventListener("click", () => {
@@ -256,8 +257,13 @@ function bindEvents() {
if (event.key === "Escape") closeComposerModelMenu();
});
addEventListener("beforeunload", () => {
+ composerAnalysisTaskBridge.detach().catch(() => undefined);
for (const url of thumbnailUrls.values()) URL.revokeObjectURL(url);
});
+ chrome.runtime.onMessage.addListener((message) => {
+ if (message?.type !== "ANALYSIS_TASK_UPDATED") return;
+ safely(() => acceptBlockedReferenceAnalysisUpdate(message))();
+ });
chrome.storage.onChanged.addListener((changes, areaName) => {
if (areaName !== "local") return;
if (changes.aiProviderRegistry || changes.aiTaskAssignments || changes.aiPreferences) safely(refreshComposerServiceSettings)();
@@ -1024,6 +1030,7 @@ function showImageTempReferenceBlock() {
if (!block.blocked) return false;
const serviceLabel = currentImageAnalysisServiceLabel();
elements.composerImageBlockerDescription.textContent = t("本轮有 {count} 张尚未分析的参考图片,但 {service} 只能读取文字。可切换到视觉创作服务;也可调用当前图片分析服务({analysisService}),预计发起 {count} 次额外请求,费用由服务商按你的账号计费。", { count: block.imageCount, service: service.shortLabel, analysisService: serviceLabel });
+ renderImageBlockerTaskState();
elements.composerImageBlocker.showModal();
return true;
}
@@ -1052,8 +1059,15 @@ function currentImageAnalysisServiceLabel() {
: `${fallbackProvider.label} · 未配置模型`;
}
-async function analyzeBlockedTempReferences() {
- if (!composerSession || imageAnalysisPending) return;
+async function handleBlockedReferenceAnalysisAction() {
+ const task = composerAnalysisTaskBridge.snapshot();
+ if (task.attached && analysisTaskIsActive(task.status)) return stopBlockedReferenceAnalysis();
+ if (task.canRetry) return retryBlockedReferenceAnalysis();
+ return startBlockedReferenceAnalysis();
+}
+
+async function startBlockedReferenceAnalysis() {
+ if (!composerSession) return;
const references = composerSession.referenceSnapshots.filter((reference) =>
unreadReferenceImageAssets(reference).length
);
@@ -1061,33 +1075,126 @@ async function analyzeBlockedTempReferences() {
elements.composerImageBlocker.close();
return sendComposerTurn();
}
- imageAnalysisPending = true;
- setImageBlockerPending(true);
- elements.composerImageBlockerDescription.textContent = t("正在通过当前图片分析服务处理 {count} 张图片。完成前不会发送本轮消息,也不会更换创作模型。", { count: references.length });
+ const imageCount = references.reduce((total, reference) => total + unreadReferenceImageAssets(reference).length, 0);
+ elements.composerImageBlockerDescription.textContent = t("正在创建图片分析任务,共 {count} 张。关闭此窗口只会取消本页自动继续,不会停止后台任务。", { count: imageCount });
+ const starting = composerAnalysisTaskBridge.start({
+ sessionId: composerSession.id,
+ tempReferenceIds: references.map((reference) => reference.entryId),
+ outputLocale: composerAnalysisOutputLocale()
+ });
+ renderImageBlockerTaskState();
try {
- const response = await chrome.runtime.sendMessage({
- type: "ANALYZE_TEMP_REFERENCES",
- sessionId: composerSession.id,
- tempReferenceIds: references.map((reference) => reference.entryId),
- outputLocale: elements.composerOutputLanguage.value === "en"
- ? "en"
- : elements.composerOutputLanguage.value === "zh-CN" ? "zh-CN" : currentLocale() === "en" ? "en" : "zh-CN"
- });
- applyTempReferenceResponse(response, "临时图片分析失败");
+ await handleBlockedReferenceAnalysisState(await starting);
+ } catch (error) {
+ await composerAnalysisTaskBridge.detach().catch(() => undefined);
+ renderImageBlockerTaskState();
+ elements.composerImageBlockerDescription.textContent = `${error.message || "无法创建图片分析任务"}。本轮输入和附件均已保留,未自动重试。`;
+ }
+}
+
+async function stopBlockedReferenceAnalysis() {
+ const previous = composerAnalysisTaskBridge.snapshot();
+ elements.composerImageBlockerDescription.textContent = t("正在请求停止图片分析。关闭窗口仍只会断开本页,不代表停止成功。");
+ renderImageBlockerTaskState({ ...previous, status: "stop-requested" });
+ try {
+ const stopped = await composerAnalysisTaskBridge.stop();
+ renderImageBlockerTaskState(stopped);
+ elements.composerImageBlockerDescription.textContent = previous.status === "queued"
+ ? t("任务已在发出服务请求前停止,本轮不会自动发送。")
+ : t("已请求停止任务。本轮不会自动发送;若服务商此前已接收请求,仍可能产生费用。可关闭窗口,或明确确认后重新分析。");
+ } catch (error) {
+ renderImageBlockerTaskState();
+ elements.composerImageBlockerDescription.textContent = `${error.message || "停止请求未确认"}。任务执行状态未知,本轮不会自动发送,也不会自动重试。`;
+ }
+}
+
+async function retryBlockedReferenceAnalysis() {
+ const confirmed = await confirmAppAction({
+ title: t("重新发起图片分析?"),
+ description: t("上一轮请求可能已经被服务商接收。重新分析会创建新的执行尝试,并可能再次计费;旧尝试的结果不会写回本轮。"),
+ confirmLabel: t("确认重新分析")
+ });
+ if (!confirmed) return;
+ elements.composerImageBlockerDescription.textContent = t("正在创建新的图片分析尝试。完成前不会发送本轮消息。");
+ const retrying = composerAnalysisTaskBridge.retry({ confirmed: true });
+ renderImageBlockerTaskState();
+ try {
+ await handleBlockedReferenceAnalysisState(await retrying);
+ } catch (error) {
+ await composerAnalysisTaskBridge.detach().catch(() => undefined);
+ renderImageBlockerTaskState();
+ elements.composerImageBlockerDescription.textContent = `${error.message || "无法重新创建图片分析任务"}。本轮输入和附件均已保留,未自动重试。`;
+ }
+}
+
+async function detachBlockedReferenceAnalysis() {
+ await composerAnalysisTaskBridge.detach();
+}
+
+async function refreshBlockedReferenceAnalysis() {
+ if (!composerAnalysisTaskBridge.snapshot().attached) return;
+ await handleBlockedReferenceAnalysisState(await composerAnalysisTaskBridge.refresh());
+}
+
+async function acceptBlockedReferenceAnalysisUpdate(message) {
+ if (!composerAnalysisTaskBridge.snapshot().attached) return;
+ if (!composerAnalysisTaskBridge.acceptUpdate(message)) return;
+ await handleBlockedReferenceAnalysisState(composerAnalysisTaskBridge.snapshot());
+}
+
+async function handleBlockedReferenceAnalysisState(task) {
+ if (!task.attached) return;
+ renderImageBlockerTaskState(task);
+ if (task.status === "completed") {
+ const result = composerAnalysisTaskBridge.consumeCompletion();
+ if (!result) return;
+ applyTempReferenceResponse(result, "临时图片分析失败");
renderComposer();
elements.composerImageBlocker.close();
- composerFeedback(`已完成 ${references.length} 项参考图片分析,正在继续本轮创作`);
+ composerFeedback(t("图片分析已完成,正在继续本轮创作"));
await sendComposerTurn();
- } catch (error) {
- elements.composerImageBlockerDescription.textContent = `${error.message || "临时图片分析失败"}。本轮输入和附件均已保留,请重试、切换视觉创作服务或取消。`;
- } finally {
- imageAnalysisPending = false;
- setImageBlockerPending(false);
+ return;
+ }
+ if (task.executionState === "execution_state_unknown") {
+ elements.composerImageBlockerDescription.textContent = t("浏览器后台曾中断,上一轮是否执行完成无法确认。系统不会自动重试或发送本轮;如要重试,请明确确认,新的尝试可能再次计费。");
+ return;
+ }
+ if (task.status === "failed") {
+ elements.composerImageBlockerDescription.textContent = t("图片分析未完成。本轮输入和附件均已保留,系统不会自动重试或发送;可确认后重新分析。");
+ return;
+ }
+ if (task.status === "stopped") {
+ elements.composerImageBlockerDescription.textContent = t("图片分析已停止,本轮不会自动发送。可关闭窗口,或明确确认后重新分析。");
+ return;
+ }
+ if (task.status === "queued") {
+ elements.composerImageBlockerDescription.textContent = t("图片分析正在等待执行,尚未开始服务请求。关闭窗口只会取消本页自动继续;点击“停止分析”才会请求停止任务。");
+ return;
+ }
+ if (["running", "stop-requested"].includes(task.status)) {
+ elements.composerImageBlockerDescription.textContent = task.status === "stop-requested"
+ ? t("正在请求停止图片分析。本轮不会自动发送。")
+ : t("图片分析正在执行。关闭窗口只会取消本页自动继续;点击“停止分析”才会请求停止任务。服务商已接收的请求仍可能计费。");
}
}
-function setImageBlockerPending(pending) {
- elements.composerImageBlocker.querySelectorAll("button").forEach((button) => { button.disabled = pending; });
+function renderImageBlockerTaskState(task = composerAnalysisTaskBridge.snapshot()) {
+ const active = task.attached && analysisTaskIsActive(task.status);
+ elements.composerImageBlockerChooseService.disabled = active;
+ elements.composerImageBlockerAnalyze.disabled = task.status === "stop-requested";
+ elements.composerImageBlockerAnalyze.textContent = active
+ ? t("停止分析")
+ : task.canRetry ? t("重新分析") : t("调用图片分析并继续");
+}
+
+function analysisTaskIsActive(status) {
+ return ["starting", "queued", "running", "stop-requested"].includes(status);
+}
+
+function composerAnalysisOutputLocale() {
+ return elements.composerOutputLanguage.value === "en"
+ ? "en"
+ : elements.composerOutputLanguage.value === "zh-CN" ? "zh-CN" : currentLocale() === "en" ? "en" : "zh-CN";
}
async function retryComposerTurn() {
diff --git a/composer.js b/composer.js
index ffcda23..916cb5b 100644
--- a/composer.js
+++ b/composer.js
@@ -4,6 +4,11 @@ import { primaryVisionDescription } from "./visuals.js";
import { entryMediaAssets } from "./media.js";
import { TEMP_REFERENCE_SOURCE_TYPES } from "./temp-references.js";
import { normalizeLocalRelativePath } from "./local-media.js";
+import {
+ hasCompleteReferenceAnalysis,
+ referenceHasPromptText,
+ referenceHasUsableLegacyDescription
+} from "./reference-readiness.js";
import { validReconstructionPrompt } from "./image-prompt.js";
import {
COMPOSER_AGENT_VERSION,
@@ -334,21 +339,14 @@ export function createComposerSession(input = {}) {
export function imageReferenceModeAvailability(referenceSnapshots = []) {
const missingAssetIds = [];
for (const reference of Array.isArray(referenceSnapshots) ? referenceSnapshots : []) {
- const promptBacked = Boolean(
- String(reference?.originalText ?? "").trim()
- || (["prompt", "prompt_vision"].includes(reference?.referenceKind)
- && String(reference?.referenceText ?? "").trim())
- );
+ const promptBacked = referenceHasPromptText(reference);
const assets = new Map((Array.isArray(reference?.assets) ? reference.assets : []).map((item) => [item.assetId, item]));
for (const imageRef of Array.isArray(reference?.imageRefs) ? reference.imageRefs : []) {
if (promptBacked) continue;
const assetId = String(imageRef?.visualId ?? "").trim();
const asset = assets.get(assetId);
- const fingerprintMatches = Boolean(asset?.imageFingerprint && asset?.analysisImageFingerprint
- && asset.imageFingerprint === asset.analysisImageFingerprint);
- if (!asset || asset.analysisVersion !== 2 || !asset.analysisFingerprint || !asset.reconstructionPrompt || !fingerprintMatches) {
- if (assetId && !missingAssetIds.includes(assetId)) missingAssetIds.push(assetId);
- }
+ if (referenceHasUsableLegacyDescription(reference, asset) || hasCompleteReferenceAnalysis(asset)) continue;
+ if (assetId && !missingAssetIds.includes(assetId)) missingAssetIds.push(assetId);
}
}
return { canDisableImages: missingAssetIds.length === 0, missingAssetIds };
diff --git a/docs/KNOWN_LIMITATIONS.md b/docs/KNOWN_LIMITATIONS.md
new file mode 100644
index 0000000..81f46dc
--- /dev/null
+++ b/docs/KNOWN_LIMITATIONS.md
@@ -0,0 +1,7 @@
+# 已知限制与后续增强
+
+## 浏览器无法直接解码的 MPEG-4 视频
+
+PromptDirector 目前依赖 Chrome 的原生媒体解码能力。遇到浏览器无法解码、但系统播放器可以播放的 MPEG-4 文件时,案例仍会保留原文件和来源信息,并提供使用系统播放器打开的路径;当前版本不在扩展内置软件解码器。
+
+后续如实施软件解码,至少需要同时满足以下验收条件:不改变原文件、不会把解码失败误报为导入成功、能中止长时间任务、限制内存与临时存储占用,并在发布包体积与浏览器安全策略检查通过后再启用。
diff --git a/i18n.js b/i18n.js
index e452969..f615de9 100644
--- a/i18n.js
+++ b/i18n.js
@@ -405,6 +405,23 @@ const EN = Object.freeze({
"正在通过当前图片分析服务处理 {count} 张图片。完成前不会发送本轮消息,也不会更换创作模型。": "Processing {count} images with the current image-analysis service. This message will not be sent and the creation model will not change until analysis finishes.",
"重新发起付费请求?": "Retry paid request?",
"上一次请求可能已经产生费用。重试会创建一个新任务,并可能再次计费。": "The previous request may already have incurred a charge. Retrying creates a new task and may charge again.",
+ "正在创建图片分析任务,共 {count} 张。关闭此窗口只会取消本页自动继续,不会停止后台任务。": "Creating an image-analysis task for {count} images. Closing this window only detaches this page and does not stop the background task.",
+ "正在请求停止图片分析。关闭窗口仍只会断开本页,不代表停止成功。": "Requesting that image analysis stop. Closing this window only detaches this page and does not confirm that the task stopped.",
+ "任务已在发出服务请求前停止,本轮不会自动发送。": "The task stopped before any service request was sent. This turn will not continue automatically.",
+ "已请求停止任务。本轮不会自动发送;若服务商此前已接收请求,仍可能产生费用。可关闭窗口,或明确确认后重新分析。": "The stop was requested. This turn will not continue automatically; if the provider already received the request, charges may still apply. Close the window or explicitly confirm a new analysis attempt.",
+ "重新发起图片分析?": "Start image analysis again?",
+ "上一轮请求可能已经被服务商接收。重新分析会创建新的执行尝试,并可能再次计费;旧尝试的结果不会写回本轮。": "The provider may have received the previous request. Reanalyzing creates a new attempt and may charge again; results from the old attempt will not be applied to this turn.",
+ "确认重新分析": "Confirm reanalysis",
+ "正在创建新的图片分析尝试。完成前不会发送本轮消息。": "Creating a new image-analysis attempt. This turn will not be sent until it finishes.",
+ "图片分析已完成,正在继续本轮创作": "Image analysis is complete. Continuing this creation turn.",
+ "浏览器后台曾中断,上一轮是否执行完成无法确认。系统不会自动重试或发送本轮;如要重试,请明确确认,新的尝试可能再次计费。": "The browser background was interrupted, so the previous attempt's outcome is unknown. It will not retry or send this turn automatically. Explicitly confirm a new attempt, which may incur another charge.",
+ "图片分析未完成。本轮输入和附件均已保留,系统不会自动重试或发送;可确认后重新分析。": "Image analysis did not finish. This turn and its attachments are preserved and will not retry or send automatically; confirm to analyze again.",
+ "图片分析已停止,本轮不会自动发送。可关闭窗口,或明确确认后重新分析。": "Image analysis stopped and this turn will not be sent automatically. Close the window or explicitly confirm a new analysis attempt.",
+ "图片分析正在等待执行,尚未开始服务请求。关闭窗口只会取消本页自动继续;点击“停止分析”才会请求停止任务。": "Image analysis is queued and no service request has started. Closing this window only cancels this page's automatic continuation; choose Stop analysis to request that the task stop.",
+ "正在请求停止图片分析。本轮不会自动发送。": "Requesting that image analysis stop. This turn will not be sent automatically.",
+ "图片分析正在执行。关闭窗口只会取消本页自动继续;点击“停止分析”才会请求停止任务。服务商已接收的请求仍可能计费。": "Image analysis is running. Closing this window only cancels this page's automatic continuation; choose Stop analysis to request that the task stop. A request already received by the provider may still be charged.",
+ "停止分析": "Stop analysis",
+ "重新分析": "Analyze again",
"继续重试": "Retry anyway",
"所选模型最多接收 {maximum} 张参考图;当前 {count} 张。选择已保留,请减少后再应用。": "The selected model accepts up to {maximum} reference images; {count} are selected. Your selection is preserved. Remove some images before applying.",
"导出对话诊断?": "Export conversation diagnostics?",
diff --git a/lib.js b/lib.js
index 93d4e62..b272866 100644
--- a/lib.js
+++ b/lib.js
@@ -16,6 +16,7 @@ import { normalizeCreativeSkillsState } from "./creative-skills.js";
import { entryPalette, normalizeEntryVisuals, primaryVisionDescription } from "./visuals.js";
import { normalizeCompoundCases } from "./compound-cases.js";
import { CURRENT_LIBRARY_PACKAGE_VERSION, LIBRARY_PACKAGE_FORMAT } from "./library-package-format.js";
+import { normalizeTrashState } from "./trash.js";
export const DEFAULT_SETTINGS = Object.freeze({
libraryTitle: "视觉创作灵感库",
@@ -243,6 +244,7 @@ export function renderLibraryJson(
entries: Array.isArray(entries) ? entries : []
};
if (composerState && typeof composerState === "object") {
+ if (composerState.trashState) payload.trashState = normalizeTrashState(composerState.trashState);
payload.composerSettings = normalizeComposerSettings(composerState.composerSettings);
payload.composerSessions = normalizeComposerSessions(composerState.composerSessions);
payload.creativeExperimentSettings = normalizeCreativeExperimentSettings(composerState.creativeExperimentSettings);
diff --git a/library-export-plan.js b/library-export-plan.js
new file mode 100644
index 0000000..dde84b1
--- /dev/null
+++ b/library-export-plan.js
@@ -0,0 +1,71 @@
+const FOLDER_BACKUP_FORMAT = "prompt-director-folder-backup";
+
+export async function buildFolderBackupCompletion(filesValue, metadata = {}) {
+ const files = backupFiles(filesValue);
+ const manifest = [];
+ for (const [path, blob] of [...files.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+ manifest.push({ path, byteSize: blob.size, sha256: await sha256Blob(blob) });
+ }
+ return {
+ format: FOLDER_BACKUP_FORMAT,
+ version: 2,
+ createdAt: validIso(metadata.createdAt) || new Date().toISOString(),
+ caseCount: nonNegativeInteger(metadata.caseCount),
+ trashCaseCount: nonNegativeInteger(metadata.trashCaseCount),
+ trashProjectCount: nonNegativeInteger(metadata.trashProjectCount),
+ mediaCount: nonNegativeInteger(metadata.mediaCount),
+ byteSize: nonNegativeInteger(metadata.byteSize),
+ fileCount: manifest.length,
+ files: manifest
+ };
+}
+
+export async function verifyFolderBackupCompletion(completionValue, filesValue) {
+ const completion = completionValue && typeof completionValue === "object" ? completionValue : {};
+ if (completion.format !== FOLDER_BACKUP_FORMAT || completion.version !== 2 || !Array.isArray(completion.files)) {
+ throw new Error("完整备份标记无效");
+ }
+ const files = backupFiles(filesValue);
+ if (completion.fileCount !== completion.files.length || files.size !== completion.files.length) {
+ throw new Error("完整备份的文件清单完整性校验失败");
+ }
+ const expectedPaths = new Set();
+ for (const descriptor of completion.files) {
+ const path = safePath(descriptor?.path);
+ if (!path || expectedPaths.has(path)) throw new Error("完整备份的文件清单完整性校验失败");
+ expectedPaths.add(path);
+ const blob = files.get(path);
+ if (!(blob instanceof Blob) || blob.size !== descriptor.byteSize || await sha256Blob(blob) !== descriptor.sha256) {
+ throw new Error(`完整备份文件“${path}”完整性校验失败`);
+ }
+ }
+ return true;
+}
+
+function backupFiles(value) {
+ const source = value instanceof Map ? value : new Map();
+ return new Map([...source].filter(([path, blob]) =>
+ safePath(path) && path !== "complete.json" && blob instanceof Blob
+ ));
+}
+
+function safePath(value) {
+ const path = String(value ?? "").replaceAll("\\", "/").trim();
+ if (!path || path.startsWith("/") || path.includes("..") || path.split("/").some((part) => !part || part === ".")) return "";
+ return path;
+}
+
+async function sha256Blob(blob) {
+ const digest = await crypto.subtle.digest("SHA-256", await blob.arrayBuffer());
+ return [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+
+function nonNegativeInteger(value) {
+ const number = Number(value);
+ return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+
+function validIso(value) {
+ const text = String(value ?? "").trim();
+ return text && Number.isFinite(Date.parse(text)) ? new Date(text).toISOString() : "";
+}
diff --git a/library-export-zip.js b/library-export-zip.js
new file mode 100644
index 0000000..be99d0f
--- /dev/null
+++ b/library-export-zip.js
@@ -0,0 +1,61 @@
+import { parseLibraryPackage } from "./library-package.js";
+import { PORTABLE_LIBRARY_LIMITS } from "./resource-limits.js";
+import { createZipBlob, readZipBlob } from "./zip.js";
+
+export async function createVerifiedLibraryZip(files, expectedLibraryJson) {
+ const archive = await createZipBlob(files);
+ await verifyLibraryZipRoundtrip(archive, expectedLibraryJson);
+ return archive;
+}
+
+export async function verifyLibraryZipRoundtrip(archive, expectedLibraryJson) {
+ try {
+ return await verifyRoundtrip(archive, expectedLibraryJson);
+ } catch (error) {
+ if (String(error?.message ?? "").startsWith("导出自检失败")) throw error;
+ throw new Error(`导出自检失败:${String(error?.message ?? "无法重新读取导出的 ZIP")}`, { cause: error });
+ }
+}
+
+async function verifyRoundtrip(archive, expectedLibraryJson) {
+ const limits = {
+ ...PORTABLE_LIBRARY_LIMITS,
+ maxArchiveBytes: archive.size,
+ maxFileBytes: archive.size,
+ maxImageBytes: archive.size,
+ maxVideoBytes: archive.size
+ };
+ const extracted = await readZipBlob(archive, limits);
+ const libraryFile = extracted.get("library.json");
+ if (!(libraryFile instanceof Blob)) throw new Error("导出的 ZIP 缺少 library.json");
+ if (libraryFile.size > limits.maxLibraryJsonBytes) throw new Error("导出的 library.json 超过安全上限");
+ const expected = parseLibraryPackage(JSON.parse(String(expectedLibraryJson ?? "")), extracted, limits);
+ const actual = parseLibraryPackage(JSON.parse(await libraryFile.text()), extracted, limits);
+ if (stableJson(packageSemantics(actual)) !== stableJson(packageSemantics(expected))) {
+ throw new Error("导出自检失败:ZIP 内容与生成前不一致");
+ }
+ return actual;
+}
+
+function packageSemantics(value) {
+ const {
+ assets: _assets,
+ images: _images,
+ skillAssets: _skillAssets,
+ importDiagnostics: _importDiagnostics,
+ importStats: _importStats,
+ exportedAt: _exportedAt,
+ ...persistent
+ } = value;
+ return persistent;
+}
+
+function stableJson(value) {
+ return JSON.stringify(canonicalValue(value));
+}
+
+function canonicalValue(value) {
+ if (Array.isArray(value)) return value.map(canonicalValue);
+ if (!value || typeof value !== "object") return value;
+ return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+}
diff --git a/library-import-dialog.js b/library-import-dialog.js
new file mode 100644
index 0000000..5131766
--- /dev/null
+++ b/library-import-dialog.js
@@ -0,0 +1,40 @@
+export function buildLibraryImportReport(previewValue = {}, details = {}) {
+ const preview = previewValue && typeof previewValue === "object" ? previewValue : {};
+ const stats = preview.importStats && typeof preview.importStats === "object" ? preview.importStats : {};
+ const importedCount = count(preview.importedCount);
+ const lines = [];
+ if (count(preview.skippedCount)) lines.push(`完全相同,跳过 ${count(preview.skippedCount)} 个`);
+ if (count(preview.remappedCount)) lines.push(`同一来源有新内容,保留副本 ${count(preview.remappedCount)} 个`);
+ if (count(stats.droppedAiAssignments)) lines.push(`丢弃损坏的 AI 标签 ${count(stats.droppedAiAssignments)} 条`);
+ if (count(stats.droppedMediaDescriptors)) lines.push(`丢弃损坏的媒体描述 ${count(stats.droppedMediaDescriptors)} 条`);
+ if (count(stats.droppedMediaFiles)) lines.push(`丢弃损坏或缺失的媒体 ${count(stats.droppedMediaFiles)} 项`);
+ if (count(stats.skippedCases)) lines.push(`跳过无法恢复的案例 ${count(stats.skippedCases)} 个`);
+ const recoveredExtras = [];
+ if (count(preview.importedSkillCount)) recoveredExtras.push(`${count(preview.importedSkillCount)} 个 Skill`);
+ if (count(details.mediaCount)) recoveredExtras.push(`${count(details.mediaCount)} 项本地文件${details.byteLabel ? `(${details.byteLabel})` : ""}`);
+ if (recoveredExtras.length) lines.push(`恢复 ${recoveredExtras.join("、")}`);
+ const partial = [
+ preview.skippedCount,
+ preview.remappedCount,
+ stats.droppedAiAssignments,
+ stats.droppedMediaDescriptors,
+ stats.droppedMediaFiles,
+ stats.skippedCases
+ ].some((value) => count(value) > 0);
+ return {
+ status: partial ? "partial" : "ready",
+ summary: importedCount ? `可导入 ${importedCount} 个新案例` : "没有需要新建的案例",
+ lines,
+ autoAnalysisNotice: "导入不会自动启动 AI 分析"
+ };
+}
+
+export function importReportDescription(reportValue = {}) {
+ const report = reportValue && typeof reportValue === "object" ? reportValue : {};
+ return [report.summary, ...(report.lines ?? []), report.autoAnalysisNotice].filter(Boolean).join("。") + "。";
+}
+
+function count(value) {
+ const number = Number(value);
+ return Number.isSafeInteger(number) && number > 0 ? number : 0;
+}
diff --git a/library-import-media.js b/library-import-media.js
new file mode 100644
index 0000000..71b9d1a
--- /dev/null
+++ b/library-import-media.js
@@ -0,0 +1,37 @@
+export async function findInvalidImportedImageIds(images, validateImage) {
+ if (!(images instanceof Map) || typeof validateImage !== "function") {
+ throw new Error("图片校验输入无效");
+ }
+ const invalidIds = new Set();
+ for (const [assetId, blob] of images) {
+ if (!(blob instanceof Blob) || !clean(assetId)) throw new Error("图片校验输入无效");
+ try {
+ await validateImage(blob);
+ } catch {
+ invalidIds.add(assetId);
+ }
+ }
+ return invalidIds;
+}
+
+export function filesWithoutInvalidEntryMedia(libraryValue, files, invalidAssetIds) {
+ if (!(files instanceof Map) || !(invalidAssetIds instanceof Set)) {
+ throw new Error("媒体修复输入无效");
+ }
+ const result = new Map(files);
+ for (const entry of Array.isArray(libraryValue?.entries) ? libraryValue.entries : []) {
+ const mediaAssets = Array.isArray(entry?.mediaAssets)
+ ? entry.mediaAssets
+ : Array.isArray(entry?.visuals) ? entry.visuals : [];
+ for (const asset of mediaAssets) {
+ if (!invalidAssetIds.has(clean(asset?.id))) continue;
+ const path = clean(asset?.assetPath || asset?.screenshotPath);
+ if (path) result.delete(path);
+ }
+ }
+ return result;
+}
+
+function clean(value) {
+ return String(value ?? "").trim();
+}
diff --git a/library-import-transaction.js b/library-import-transaction.js
new file mode 100644
index 0000000..47a5103
--- /dev/null
+++ b/library-import-transaction.js
@@ -0,0 +1,323 @@
+import { normalizeFacetCatalog } from "./facets.js";
+import { normalizeSettings } from "./lib.js";
+import { normalizeComposerSessions, normalizeComposerSettings } from "./composer.js";
+import {
+ normalizeCreativeExperimentSettings,
+ normalizeCreativeRuns
+} from "./creative-runs.js";
+import { normalizeEntryMedia } from "./media.js";
+import { normalizeOrganizerState } from "./organizer.js";
+import { normalizeCompoundCases } from "./compound-cases.js";
+import { normalizeTaxonomy } from "./taxonomy.js";
+import { normalizeTrashState } from "./trash.js";
+import { caseSemanticFingerprint } from "./library-semantic-identity.js";
+import { normalizeCreativeSkillsState } from "./creative-skills.js";
+
+const PLAN_TOKEN_VERSION = "v2";
+const DEFAULT_RECEIPT_TTL_MS = 30 * 60 * 1000;
+const RECEIPT_STATUSES = new Set(["pending", "completed"]);
+
+export function createLibraryImportPlanToken(stateValue = {}, sourceValue = {}) {
+ const payload = stableJson({
+ state: projectLibraryImportState(stateValue),
+ source: projectLibraryImportSource(sourceValue)
+ });
+ return `import-plan:${PLAN_TOKEN_VERSION}:${fnv1a64(payload)}`;
+}
+
+export function assertLibraryImportPlanCurrent(tokenValue, stateValue = {}, sourceValue = {}) {
+ const token = String(tokenValue ?? "").trim();
+ if (token && token === createLibraryImportPlanToken(stateValue, sourceValue)) return;
+ throw Object.assign(new Error("预览后资料库发生了变化,请重新检查再导入"), {
+ code: "IMPORT_PLAN_STALE"
+ });
+}
+
+export function normalizeLibraryImportTransactionsState(value = {}, options = {}) {
+ const now = toTimestamp(options.now);
+ const retentionMs = normalizeRetentionMs(options.retentionMs);
+ const receipts = new Map();
+ for (const candidate of Array.isArray(value?.items) ? value.items : []) {
+ const receipt = normalizeLibraryImportTransaction(candidate, { now, retentionMs });
+ if (!receipt) continue;
+ const existing = receipts.get(receipt.operationId);
+ if (!existing || toTimestamp(receipt.updatedAt) >= toTimestamp(existing.updatedAt)) {
+ receipts.set(receipt.operationId, receipt);
+ }
+ }
+ const items = [...receipts.values()].filter((item) => !isReceiptExpired(item, now));
+ return { version: 1, items };
+}
+
+export function claimLibraryImportTransaction(stateValue, request = {}, options = {}) {
+ const operationId = clean(request.operationId);
+ const planToken = clean(request.planToken);
+ if (!operationId) throw libraryImportTransactionError("导入事务缺少 operationId", "IMPORT_TRANSACTION_INVALID");
+ if (!planToken) throw libraryImportTransactionError("导入事务缺少 planToken", "IMPORT_TRANSACTION_INVALID");
+
+ const now = toTimestamp(options.now);
+ const retentionMs = normalizeRetentionMs(options.retentionMs);
+ const state = normalizeLibraryImportTransactionsState(stateValue, { now, retentionMs });
+ const current = state.items.find((item) => item.operationId === operationId);
+ if (current) {
+ if (current.planToken !== planToken) {
+ throw libraryImportTransactionError("同一导入操作已经对应不同的计划,不能复用", "IMPORT_RECEIPT_CONFLICT");
+ }
+ if (current.status === "completed") {
+ return {
+ state,
+ receipt: current,
+ result: cloneData(current.result),
+ acquired: false,
+ replayed: true,
+ pending: false
+ };
+ }
+ return {
+ state,
+ receipt: current,
+ acquired: false,
+ replayed: false,
+ pending: true
+ };
+ }
+
+ assertLibraryImportPlanCurrent(planToken, request.stateValue, request.sourceValue);
+
+ const receipt = normalizeLibraryImportTransaction({
+ operationId,
+ planToken,
+ status: "pending",
+ createdAt: isoString(now),
+ updatedAt: isoString(now),
+ expiresAt: isoString(now + retentionMs)
+ }, { now, retentionMs });
+
+ return {
+ state: { version: 1, items: [...state.items, receipt] },
+ receipt,
+ acquired: true,
+ replayed: false,
+ pending: true
+ };
+}
+
+export function succeedLibraryImportTransaction(stateValue, receiptValue, resultValue = {}, options = {}) {
+ const operationId = clean(receiptValue?.operationId);
+ const planToken = clean(receiptValue?.planToken);
+ if (!operationId || !planToken) {
+ throw libraryImportTransactionError("导入事务缺少回执编号", "IMPORT_TRANSACTION_INVALID");
+ }
+
+ const now = toTimestamp(options.now);
+ const retentionMs = normalizeRetentionMs(options.retentionMs);
+ const state = normalizeLibraryImportTransactionsState(stateValue, { now, retentionMs });
+ const current = state.items.find((item) => item.operationId === operationId);
+ if (current) {
+ if (current.planToken !== planToken) {
+ throw libraryImportTransactionError("导入回执计划已经变化,不能写回结果", "IMPORT_RECEIPT_CONFLICT");
+ }
+ if (current.status === "completed") {
+ return {
+ state,
+ receipt: current,
+ result: cloneData(current.result),
+ replayed: true
+ };
+ }
+ if (current.status !== "pending") {
+ throw libraryImportTransactionError("导入回执状态无效", "IMPORT_TRANSACTION_INVALID");
+ }
+ } else {
+ throw libraryImportTransactionError("没有找到可完成的导入回执", "IMPORT_TRANSACTION_MISSING");
+ }
+
+ const completed = normalizeLibraryImportTransaction({
+ ...current,
+ status: "completed",
+ result: cloneData(resultValue),
+ updatedAt: isoString(now),
+ expiresAt: isoString(now + retentionMs)
+ }, { now, retentionMs });
+
+ return {
+ state: replaceLibraryImportTransaction(state, completed),
+ receipt: completed,
+ result: cloneData(resultValue),
+ replayed: false
+ };
+}
+
+export function failLibraryImportTransaction(stateValue, receiptValue, options = {}) {
+ const operationId = clean(receiptValue?.operationId);
+ const planToken = clean(receiptValue?.planToken);
+ if (!operationId || !planToken) {
+ throw libraryImportTransactionError("导入事务缺少回执编号", "IMPORT_TRANSACTION_INVALID");
+ }
+
+ const now = toTimestamp(options.now);
+ const retentionMs = normalizeRetentionMs(options.retentionMs);
+ const state = normalizeLibraryImportTransactionsState(stateValue, { now, retentionMs });
+ const current = state.items.find((item) => item.operationId === operationId);
+ if (!current) return state;
+ if (current.planToken !== planToken) {
+ throw libraryImportTransactionError("导入回执计划已经变化,不能清理", "IMPORT_RECEIPT_CONFLICT");
+ }
+ if (current.status === "completed") {
+ return state;
+ }
+ return {
+ ...state,
+ items: state.items.filter((item) => item.operationId !== operationId)
+ };
+}
+
+function projectLibraryImportSource(value = {}) {
+ const projected = projectLibraryImportState(value);
+ const schemaVersion = toFiniteNumber(value?.schemaVersion);
+ const sourcePackageVersion = toFiniteNumber(value?.sourcePackageVersion);
+ if (schemaVersion !== null) projected.schemaVersion = schemaVersion;
+ if (sourcePackageVersion !== null) projected.sourcePackageVersion = sourcePackageVersion;
+ return projected;
+}
+
+function projectLibraryImportState(value = {}) {
+ const entries = projectLibraryImportEntries(value?.entries);
+ const entryIds = entries.map((entry) => entry.id);
+ return {
+ entries,
+ organizerState: normalizeOrganizerState(value?.organizerState, entryIds),
+ compoundCases: normalizeCompoundCases(value?.compoundCases, entries),
+ trashState: normalizeTrashState(value?.trashState),
+ settings: normalizeSettings(value?.settings),
+ taxonomy: normalizeTaxonomy(value?.taxonomy),
+ facetCatalog: normalizeFacetCatalog(value?.facetCatalog),
+ classificationRules: Array.isArray(value?.classificationRules) ? structuredClone(value.classificationRules) : [],
+ composerSettings: normalizeComposerSettings(value?.composerSettings),
+ composerSessions: normalizeComposerSessions(value?.composerSessions),
+ creativeExperimentSettings: normalizeCreativeExperimentSettings(value?.creativeExperimentSettings),
+ creativeRuns: normalizeCreativeRuns(value?.creativeRuns),
+ creativeSkills: normalizeCreativeSkillsState(value?.creativeSkills)
+ };
+}
+
+function projectLibraryImportEntries(value) {
+ return (Array.isArray(value) ? value : [])
+ .map((entry) => normalizeEntryMedia(entry))
+ .filter(Boolean)
+ .map((entry) => {
+ const normalized = structuredClone(entry);
+ delete normalized.importBatchId;
+ delete normalized.importSource;
+ delete normalized.libraryAddedAt;
+ return {
+ id: clean(normalized.id),
+ fingerprint: caseSemanticFingerprint(normalized),
+ mediaAssetIds: normalized.mediaAssets.map((asset) => asset.id)
+ };
+ })
+ .filter((entry) => Boolean(entry.id));
+}
+
+function normalizeLibraryImportTransaction(value, { now, retentionMs } = {}) {
+ const operationId = clean(value?.operationId);
+ const planToken = clean(value?.planToken);
+ if (!operationId || !planToken) return null;
+ const status = RECEIPT_STATUSES.has(value?.status) ? value.status : "pending";
+ const createdAt = isoString(value?.createdAt) || isoString(value?.updatedAt) || isoString(now);
+ const updatedAt = isoString(value?.updatedAt) || createdAt;
+ const expiresAt = isoString(value?.expiresAt) || isoString((toTimestamp(updatedAt) || now || Date.now()) + normalizeRetentionMs(retentionMs));
+ const receipt = {
+ operationId,
+ planToken,
+ status,
+ createdAt,
+ updatedAt,
+ expiresAt
+ };
+ if (status === "completed" && Object.hasOwn(value ?? {}, "result")) {
+ receipt.result = cloneData(value.result);
+ }
+ return receipt;
+}
+
+function replaceLibraryImportTransaction(state, receipt) {
+ const items = state.items.some((item) => item.operationId === receipt.operationId)
+ ? state.items.map((item) => item.operationId === receipt.operationId ? receipt : item)
+ : [...state.items, receipt];
+ return { ...state, items };
+}
+
+function isReceiptExpired(receipt, now) {
+ const nowMs = toTimestamp(now);
+ const expiresAt = toTimestamp(receipt?.expiresAt);
+ return Number.isFinite(nowMs) && Number.isFinite(expiresAt) && nowMs >= expiresAt;
+}
+
+function normalizeRetentionMs(value) {
+ const milliseconds = Math.floor(Number(value));
+ return Number.isFinite(milliseconds) && milliseconds > 0 ? milliseconds : DEFAULT_RECEIPT_TTL_MS;
+}
+
+function toFiniteNumber(value) {
+ const number = Number(value);
+ return Number.isFinite(number) ? number : null;
+}
+
+function toTimestamp(value) {
+ if (Number.isFinite(value)) return Number(value);
+ const parsed = Date.parse(String(value ?? "").trim());
+ return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+
+function isoString(value) {
+ const timestamp = toTimestamp(value);
+ return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : "";
+}
+
+function clean(value) {
+ return String(value ?? "").trim();
+}
+
+function stableJson(value) {
+ return JSON.stringify(canonicalValue(value));
+}
+
+function canonicalValue(value) {
+ if (Array.isArray(value)) return value.map(canonicalValue);
+ if (!value || typeof value !== "object") return value;
+ return Object.fromEntries(Object.keys(value).sort().flatMap((key) => {
+ const item = value[key];
+ return item === undefined ? [] : [[key, canonicalValue(item)]];
+ }));
+}
+
+function fnv1a64(value) {
+ let hash = 0xcbf29ce484222325n;
+ const bytes = new TextEncoder().encode(value);
+ for (const byte of bytes) {
+ hash ^= BigInt(byte);
+ hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+ }
+ return hash.toString(16).padStart(16, "0");
+}
+
+function cloneData(value) {
+ if (value === undefined) return undefined;
+ if (typeof structuredClone === "function") {
+ try {
+ return structuredClone(value);
+ } catch {
+ // Fall through to JSON cloning for plain receipts/results.
+ }
+ }
+ try {
+ return JSON.parse(JSON.stringify(value));
+ } catch {
+ return value;
+ }
+}
+
+function libraryImportTransactionError(message, code) {
+ return Object.assign(new Error(message), { code });
+}
diff --git a/library-package-contract.js b/library-package-contract.js
new file mode 100644
index 0000000..116770d
--- /dev/null
+++ b/library-package-contract.js
@@ -0,0 +1,39 @@
+import {
+ assetFormatForExtension,
+ canonicalMimeType,
+ fileExtension,
+ isReportedMimeCompatible
+} from "./asset-formats.js";
+
+export function normalizePortableMediaDescriptor(value = {}) {
+ const asset = structuredClone(value);
+ const pathExtension = fileExtension(asset.assetPath || asset.screenshotPath);
+ const declaredExtension = cleanExtension(asset.sourceFormat);
+ const pathFormat = assetFormatForExtension(pathExtension);
+ const declaredFormat = assetFormatForExtension(declaredExtension);
+
+ if (pathFormat && declaredFormat && pathFormat.id === declaredFormat.id && pathFormat.kind === asset.kind &&
+ isReportedMimeCompatible(pathFormat, asset.mimeType)) {
+ asset.sourceFormat = pathExtension;
+ asset.mimeType = canonicalMimeType(pathFormat, asset.mimeType);
+ }
+ return asset;
+}
+
+export function normalizePortablePackageLexemes(value = {}) {
+ const packageValue = structuredClone(value);
+ packageValue.entries = (Array.isArray(packageValue.entries) ? packageValue.entries : []).map((entry) => ({
+ ...entry,
+ ...(Array.isArray(entry?.mediaAssets)
+ ? { mediaAssets: entry.mediaAssets.map(normalizePortableMediaDescriptor) }
+ : {}),
+ ...(Array.isArray(entry?.visuals)
+ ? { visuals: entry.visuals.map(normalizePortableMediaDescriptor) }
+ : {})
+ }));
+ return packageValue;
+}
+
+function cleanExtension(value) {
+ return String(value ?? "").trim().toLocaleLowerCase("en-US").replace(/^\./u, "");
+}
diff --git a/library-package-migrations.js b/library-package-migrations.js
new file mode 100644
index 0000000..7059e0c
--- /dev/null
+++ b/library-package-migrations.js
@@ -0,0 +1,156 @@
+import { createDefaultFacetCatalog } from "./facets.js";
+import { normalizeSettings } from "./lib.js";
+import { CURRENT_LIBRARY_PACKAGE_VERSION, LIBRARY_PACKAGE_FORMAT, isSupportedLibraryPackageVersion } from "./library-package-format.js";
+import { normalizePortablePackageLexemes } from "./library-package-contract.js";
+import { migrateLibraryState } from "./migration.js";
+import { SCHEMA_VERSION, createDefaultTaxonomy } from "./taxonomy.js";
+
+const AI_ASSIGNMENT_SOURCES = new Set(["deepseek_text", "local_image_review", "vision_model"]);
+
+export function prepareLibraryPackageDraft(value = {}) {
+ if (!value || value.format !== LIBRARY_PACKAGE_FORMAT || !isSupportedLibraryPackageVersion(value.version) || !Array.isArray(value.entries)) {
+ throw new Error("这个来源不是受支持的 PromptDirector 资料包");
+ }
+
+ const sourceVersion = value.version;
+ const lexical = normalizePortablePackageLexemes(value);
+ const diagnostics = [];
+ const seenEntryIds = new Set();
+ const entries = [];
+ let droppedAiAssignments = 0;
+ let droppedMediaDescriptors = 0;
+ for (const entry of lexical.entries) {
+ const entryId = clean(entry?.id);
+ if (!entryId || seenEntryIds.has(entryId)) {
+ diagnostics.push({
+ code: "case_skipped_invalid_identity",
+ severity: "case",
+ action: "skipped",
+ entryId,
+ reason: entryId ? "duplicate_identity" : "missing_identity"
+ });
+ continue;
+ }
+ if (!hasRecoverableCaseContent(entry)) {
+ diagnostics.push({
+ code: "case_skipped_no_usable_content",
+ severity: "case",
+ action: "skipped",
+ entryId,
+ reason: "no_usable_content"
+ });
+ continue;
+ }
+ seenEntryIds.add(entryId);
+ entries.push({ ...entry, id: entryId });
+ }
+
+ const sourceFacetIds = new Set((lexical.facetCatalog?.facets ?? []).map((item) => clean(item?.id)).filter(Boolean));
+ const sourceNodeIds = new Set((lexical.facetCatalog?.nodes ?? []).map((item) => clean(item?.id)).filter(Boolean));
+ const sourceVocabularyKnown = sourceFacetIds.size > 0 || sourceNodeIds.size > 0;
+ const preSalvagedEntries = entries.map((entry) => {
+ const mediaIds = new Set((Array.isArray(entry.mediaAssets) ? entry.mediaAssets : entry.visuals ?? [])
+ .map((item) => clean(item?.id)).filter(Boolean));
+ if (entry.hasScreenshot && clean(entry.id)) mediaIds.add(clean(entry.id));
+ const facetAssignments = (Array.isArray(entry.facetAssignments) ? entry.facetAssignments : []).filter((assignment) => {
+ if (!AI_ASSIGNMENT_SOURCES.has(assignment?.source)) return true;
+ const missingVocabulary = sourceVocabularyKnown &&
+ (!sourceFacetIds.has(clean(assignment.facetId)) || !sourceNodeIds.has(clean(assignment.nodeId)));
+ const missingMedia = Boolean(clean(assignment.visualId)) && !mediaIds.has(clean(assignment.visualId));
+ if (!missingVocabulary && !missingMedia) return true;
+ droppedAiAssignments += 1;
+ diagnostics.push(aiAssignmentDiagnostic(entry.id, missingVocabulary ? "missing_vocabulary" : "missing_media"));
+ return false;
+ });
+ return { ...entry, facetAssignments };
+ });
+ const sourceMediaIdsByEntry = new Map(preSalvagedEntries.map((entry) => [entry.id, new Set(
+ (Array.isArray(entry.mediaAssets) ? entry.mediaAssets : entry.visuals ?? [])
+ .map((asset) => clean(asset?.id)).filter(Boolean)
+ )]));
+
+ const migrated = migrateLibraryState({
+ ...lexical,
+ schemaVersion: packageSchemaVersion(lexical),
+ taxonomy: lexical.taxonomy ?? createDefaultTaxonomy(),
+ facetCatalog: lexical.facetCatalog ?? createDefaultFacetCatalog(),
+ entries: preSalvagedEntries
+ }).state;
+ migrated.entries = migrated.entries.map((entry) => {
+ const facetIds = new Set(migrated.facetCatalog.facets.map((item) => item.id));
+ const nodeIds = new Set(migrated.facetCatalog.nodes.map((item) => item.id));
+ const mediaIds = new Set(entry.mediaAssets.map((item) => item.id));
+ for (const assetId of sourceMediaIdsByEntry.get(entry.id) ?? []) {
+ if (mediaIds.has(assetId)) continue;
+ droppedMediaDescriptors += 1;
+ diagnostics.push({
+ code: "media_descriptor_dropped",
+ severity: "media",
+ action: "dropped",
+ entryId: entry.id,
+ assetId,
+ reason: "invalid_descriptor"
+ });
+ }
+ const kept = [];
+ for (const assignment of entry.facetAssignments ?? []) {
+ const missingVocabulary = !facetIds.has(assignment.facetId) || !nodeIds.has(assignment.nodeId);
+ const missingMedia = Boolean(assignment.visualId) && !mediaIds.has(assignment.visualId);
+ if (AI_ASSIGNMENT_SOURCES.has(assignment.source) && (missingVocabulary || missingMedia)) {
+ droppedAiAssignments += 1;
+ diagnostics.push(aiAssignmentDiagnostic(entry.id, missingVocabulary ? "missing_vocabulary" : "missing_media"));
+ continue;
+ }
+ kept.push(assignment);
+ }
+ return { ...entry, facetAssignments: kept };
+ });
+
+ return {
+ sourceVersion,
+ draft: {
+ ...lexical,
+ ...migrated,
+ format: LIBRARY_PACKAGE_FORMAT,
+ version: CURRENT_LIBRARY_PACKAGE_VERSION,
+ schemaVersion: SCHEMA_VERSION,
+ settings: normalizeSettings(lexical.settings)
+ },
+ diagnostics,
+ stats: {
+ inputCases: lexical.entries.length,
+ keptCases: migrated.entries.length,
+ skippedCases: lexical.entries.length - migrated.entries.length,
+ droppedAiAssignments,
+ droppedMediaDescriptors
+ }
+ };
+}
+
+function aiAssignmentDiagnostic(entryId, reason) {
+ return {
+ code: "ai_assignment_dropped",
+ severity: "metadata",
+ action: "dropped",
+ entryId,
+ reason
+ };
+}
+
+function packageSchemaVersion(value = {}) {
+ if (Number.isInteger(value.schemaVersion)) return value.schemaVersion;
+ const versions = value.entries.map((entry) => Number(entry?.schemaVersion)).filter(Number.isInteger);
+ return versions.length ? Math.min(...versions) : 0;
+}
+
+function hasRecoverableCaseContent(entry = {}) {
+ if ([entry.title, entry.text, entry.note, entry.url].some((value) => clean(value))) return true;
+ if ((Array.isArray(entry.mediaAssets) ? entry.mediaAssets : entry.visuals ?? []).some((asset) => asset && typeof asset === "object")) {
+ return true;
+ }
+ return (entry.articleDocument?.blocks ?? []).some((block) => clean(block?.text) || clean(block?.assetId));
+}
+
+function clean(value) {
+ return String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, "").trim();
+}
diff --git a/library-package.js b/library-package.js
index f743528..c1d785b 100644
--- a/library-package.js
+++ b/library-package.js
@@ -5,7 +5,7 @@ import {
collectionEntryIds,
collectionSubtreeIds,
createDefaultOrganizerState,
- mergeOrganizerState,
+ mergeOrganizerStateWithMap,
normalizeOrganizerState
} from "./organizer.js";
import { normalizeComposerSessions, normalizeComposerSettings } from "./composer.js";
@@ -13,12 +13,12 @@ import { normalizeCreativeExperimentSettings, normalizeCreativeRuns } from "./cr
import { mergeCreativeSkillsState, normalizeCreativeSkillsState } from "./creative-skills.js";
import { formatBytes, portableLibraryLimits } from "./resource-limits.js";
import { normalizeEntryVisuals } from "./visuals.js";
-import { normalizeEntryMedia } from "./media.js";
+import { normalizeEntryMedia, removeEntryMedia } from "./media.js";
import { expandLogicalCaseIds, normalizeCompoundCases } from "./compound-cases.js";
-import { isFixedTagTree, migrateLegacyFacetState } from "./tag-taxonomy.js";
-import { migrateLibraryState } from "./migration.js";
-import { LIBRARY_PACKAGE_FORMAT, isSupportedLibraryPackageVersion } from "./library-package-format.js";
+import { prepareLibraryPackageDraft } from "./library-package-migrations.js";
import { remapArticleDocumentAssets } from "./article-document.js";
+import { caseSemanticFingerprint } from "./library-semantic-identity.js";
+import { normalizeTrashState } from "./trash.js";
import { boundedMediaBlobFromResponse, isSupportedDocumentMimeType } from "./bounded-media.js";
import {
assetFormatForExtension,
@@ -26,6 +26,8 @@ import {
isReportedMimeCompatible
} from "./asset-formats.js";
+const AI_ASSIGNMENT_SOURCES = new Set(["deepseek_text", "local_image_review", "vision_model"]);
+
export async function parseCompleteFolderBackup(value, files = new Map(), limitsValue = {}) {
const preparedFiles = new Map(files);
const limits = portableLibraryLimits(limitsValue);
@@ -39,15 +41,18 @@ export async function parseCompleteFolderBackup(value, files = new Map(), limits
});
preparedFiles.set(path, verified);
}
- return parseLibraryPackage(value, preparedFiles, limitsValue);
+ return parseLibraryPackage(value, preparedFiles, { ...limitsValue, salvageInvalidMedia: false });
}
export function parseLibraryPackage(value, files = new Map(), limitsValue = {}) {
const limits = portableLibraryLimits(limitsValue);
const skipMediaByteValidation = limitsValue?.skipMediaByteValidation === true;
- if (!value || value.format !== LIBRARY_PACKAGE_FORMAT || !isSupportedLibraryPackageVersion(value.version) || !Array.isArray(value.entries)) {
- throw new Error("这个 ZIP 不是受支持的 PromptDirector 分享包");
- }
+ const salvageInvalidMedia = limitsValue?.salvageInvalidMedia === true;
+ const prepared = prepareLibraryPackageDraft(value);
+ const importDiagnostics = [...prepared.diagnostics];
+ const importStats = { ...prepared.stats, droppedMediaFiles: 0 };
+ const packageVersion = prepared.sourceVersion;
+ value = prepared.draft;
if (value.entries.length > limits.maxEntries) {
throw new Error(`案例数量超过 ${limits.maxEntries} 条上限`);
}
@@ -73,17 +78,17 @@ export function parseLibraryPackage(value, files = new Map(), limitsValue = {})
const assets = new Map();
const images = new Map();
const skillAssets = new Map();
- if (value.version >= 4) {
+ 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), value.version);
+ validatePortableMediaDescriptor(asset, clean(asset?.assetPath), packageVersion);
}
}
}
data.entries = data.entries.map((entry) => {
const normalized = normalizeEntryVisuals(entry);
- if (value.version >= 4) {
+ if (packageVersion >= 4) {
const normalizedIds = new Set(normalized.mediaAssets.map((asset) => asset.id));
const missingAsset = (Array.isArray(entry?.mediaAssets) ? entry.mediaAssets : [])
.find((asset) => asset?.storageMode !== "reference" && clean(asset?.id) && !normalizedIds.has(clean(asset.id)));
@@ -93,44 +98,164 @@ export function parseLibraryPackage(value, files = new Map(), limitsValue = {})
normalized.metadataLabels = uniqueNames(entry?.metadataLabels);
return normalized;
});
- if (!isFixedTagTree(data.facetCatalog)) {
- const migrated = migrateLegacyFacetState(data.entries, data.facetCatalog);
- data.facetCatalog = migrated.catalog;
- data.entries = migrated.entries;
- }
- for (const entry of data.entries) {
+ 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 = [];
for (const asset of entry.mediaAssets) {
if (visualIds.has(asset.id)) throw new Error("案例包包含重复的媒体编号");
visualIds.add(asset.id);
if (asset.storageMode === "reference") continue;
const path = clean(asset.assetPath);
- const format = validatePortableMediaDescriptor(asset, path, value.version);
+ 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;
+ }
+ 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);
+ for (const item of data.trashState.items) {
+ if (item.kind !== "entry" && item.kind !== "media") continue;
+ const 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 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
+ });
+ } else {
+ item.snapshot.facetAssignments = dropDanglingAiAssignments(item.snapshot?.facetAssignments, {
+ facetIds: packageFacetIds,
+ nodeIds: packageNodeIds,
+ mediaIds: trashMediaIds,
+ entryId: clean(item.relationships?.entryId) || item.targetId,
+ importDiagnostics,
+ importStats
+ });
+ item.relationships.facetAssignments = dropDanglingAiAssignments(item.relationships?.facetAssignments, {
+ facetIds: packageFacetIds,
+ nodeIds: packageNodeIds,
+ mediaIds: trashMediaIds,
+ entryId: clean(item.relationships?.entryId) || item.targetId,
+ importDiagnostics,
+ importStats
+ });
+ }
+ for (const asset of entry.mediaAssets) {
+ if (visualIds.has(asset.id)) throw new Error("完整备份包含重复的媒体编号");
+ visualIds.add(asset.id);
+ if (asset.storageMode === "reference") continue;
+ const path = clean(asset.assetPath);
+ const format = validatePortableMediaDescriptor(asset, path, packageVersion);
const blob = files.get(path);
- if (!(blob instanceof Blob) || !blobMatchesKind(blob, asset, format, value.version)) {
- throw new Error(asset.kind === "image"
- ? `“${entry.title || "未命名案例"}”的截图缺失`
- : `“${entry.title || "未命名案例"}”的媒体文件缺失或类型不符`);
+ if (!(blob instanceof Blob) || !blobMatchesKind(blob, asset, format, packageVersion)) {
+ throw new Error(`回收站中的“${entry.title || "未命名案例"}”缺少媒体文件或类型不符`);
}
if (asset.kind === "image" && blob.size > limits.maxImageBytes) {
- throw new Error(`“${entry.title || "未命名案例"}”的图片超过 ${formatBytes(limits.maxImageBytes)} 上限`);
+ throw new Error(`回收站中的图片超过 ${formatBytes(limits.maxImageBytes)} 上限`);
}
if (asset.kind !== "image" && blob.size > limits.maxFileBytes) {
- throw new Error(`“${entry.title || "未命名案例"}”的媒体超过 ${formatBytes(limits.maxFileBytes)} 小型分享包上限,请使用完整资料夹备份`);
+ throw new Error(`回收站中的媒体超过 ${formatBytes(limits.maxFileBytes)} 上限`);
}
- if (!skipMediaByteValidation && value.version >= 3 && asset.byteSize && asset.byteSize !== blob.size) {
- throw new Error(
- `“${entry.title || "未命名案例"}”的媒体大小校验失败:期望 ${asset.byteSize} bytes,实际 ${blob.size} bytes(${path})`
- );
+ if (!skipMediaByteValidation && packageVersion >= 3 && asset.byteSize && asset.byteSize !== blob.size) {
+ throw new Error(`回收站中的媒体大小校验失败:${path}`);
}
assets.set(asset.id, blob);
if (asset.kind === "image") images.set(asset.id, blob);
}
+ if (item.kind === "entry") item.snapshot = entry;
+ else item.snapshot.mediaAssets = entry.mediaAssets;
}
- data.compoundCases = normalizeCompoundCases(data.compoundCases, data.entries);
data.organizerState = normalizeOrganizerState(data.organizerState, [...ids]);
data.composerSettings = normalizeComposerSettings(data.composerSettings);
data.composerSessions = normalizeComposerSessions(data.composerSessions);
@@ -201,38 +326,18 @@ export function parseLibraryPackage(value, files = new Map(), limitsValue = {})
skillAssets.set(file.assetId, blob);
}
}
- const migrated = migrateLibraryState({
- schemaVersion: packageSchemaVersion(data),
- entries: data.entries,
- compoundCases: data.compoundCases,
- taxonomy: data.taxonomy,
- facetCatalog: data.facetCatalog,
- classificationRules: data.classificationRules,
- organizerState: data.organizerState
- }).state;
return {
...data,
schemaVersion: SCHEMA_VERSION,
- entries: migrated.entries,
- compoundCases: migrated.compoundCases,
- taxonomy: migrated.taxonomy,
- facetCatalog: migrated.facetCatalog,
- classificationRules: migrated.classificationRules,
- organizerState: migrated.organizerState,
+ sourcePackageVersion: packageVersion,
+ importDiagnostics,
+ importStats,
assets,
images,
skillAssets
};
}
-function packageSchemaVersion(value = {}) {
- if (Number.isInteger(value.schemaVersion)) return value.schemaVersion;
- const versions = (value.entries ?? [])
- .map((entry) => Number(entry?.schemaVersion))
- .filter(Number.isInteger);
- return versions.length ? Math.min(...versions) : 0;
-}
-
export function selectLibraryPackage(state = {}, entryIds = []) {
const requestedIds = new Set(entryIds.map(clean).filter(Boolean));
const compounds = normalizeCompoundCases(state.compoundCases, state.entries);
@@ -345,9 +450,15 @@ function sanitizeSharedEntry(entry) {
}
export function mergeLibraryPackage(current = {}, importedValue = {}, options = {}) {
+ const priorImportEvidence = 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 empty = !(current.entries ?? []).length && options.preserveLibraryConfiguration !== true;
if (empty) {
@@ -356,6 +467,7 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
state: {
...structuredClone(current),
entries: imported.entries.map((entry) => withLocalImportMetadata(withoutArchivePath(entry), importMetadata)),
+ trashState: imported.trashState,
settings: imported.settings,
taxonomy: imported.taxonomy,
facetCatalog: imported.facetCatalog,
@@ -373,7 +485,14 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
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])
+ ...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,
packageAssetIdMap: skillMerge.packageAssetIdMap,
@@ -382,6 +501,9 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
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
};
@@ -405,12 +527,30 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
]);
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) {
const idCollision = usedEntryIds.has(source.id);
+ const sourceFingerprint = caseSemanticFingerprint(source);
+ const identical = sourceFingerprint && next.entries.find((entry) =>
+ (entry.id === source.id || clean(entry.importSource?.entryId) === source.id) &&
+ caseSemanticFingerprint(entry) === sourceFingerprint
+ );
+ 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]) visualIdMap[sourceAssets[index].id] = existingAssets[index].id;
+ }
+ continue;
+ }
if (idCollision && options.skipExistingEntryIds === true) {
skippedCount += 1;
organizerEntryIdMap[source.id] = source.id;
@@ -426,6 +566,7 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
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];
@@ -443,6 +584,7 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
: preferredVisualId;
usedVisualIds.add(targetVisualId);
visualIdMap[visual.id] = targetVisualId;
+ createdVisualIdMap[visual.id] = targetVisualId;
return { ...visual, id: targetVisualId };
});
entry.primaryMediaId = visualIdMap[entry.primaryMediaId] ?? entry.primaryMediaId;
@@ -472,6 +614,7 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
});
next.entries.push(entry);
usedEntryIds.add(targetId);
+ createdEntryIds.push(targetId);
entryIdMap[source.id] = targetId;
organizerEntryIdMap[source.id] = targetId;
importedCount += 1;
@@ -481,12 +624,13 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
if (!importedEntry?.creationMeta?.sourceEntryIds) continue;
importedEntry.creationMeta.sourceEntryIds = importedEntry.creationMeta.sourceEntryIds.map((id) => organizerEntryIdMap[id] ?? id);
}
- next.organizerState = mergeOrganizerState(
+ const organizerMerge = mergeOrganizerStateWithMap(
next.organizerState,
imported.organizerState,
organizerEntryIdMap,
options.preserveLibraryConfiguration === true ? { createdAt: importMetadata.libraryAddedAt } : {}
);
+ next.organizerState = organizerMerge.state;
const usedCompoundIds = new Set([
...next.entries.map((entry) => entry.id),
...next.compoundCases.map((item) => item.id)
@@ -517,6 +661,7 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
const targetAssetId = usedVisualIds.has(asset.assetId) ? uniqueId("temp-reference", usedVisualIds) : asset.assetId;
usedVisualIds.add(targetAssetId);
visualIdMap[asset.assetId] = targetAssetId;
+ createdVisualIdMap[asset.assetId] = targetAssetId;
}
const composerMerge = mergeComposerSessions(
next.composerSessions,
@@ -538,12 +683,33 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
options.runIdMap
);
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 skillMerge = mergeCreativeSkillsState(next.creativeSkills, imported.creativeSkills, options);
next.creativeSkills = skillMerge.state;
+ 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
+ });
+ next.trashState = trashMerge.trashState;
+ Object.assign(visualIdMap, trashMerge.visualIdMap);
+ Object.assign(createdVisualIdMap, trashMerge.visualIdMap);
return {
state: next,
entryIdMap,
visualIdMap,
+ createdVisualIdMap,
sessionIdMap: composerMerge.sessionIdMap,
runIdMap: creativeMerge.runIdMap,
compoundIdMap,
@@ -554,6 +720,11 @@ export function mergeLibraryPackage(current = {}, importedValue = {}, options =
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,
remappedCount,
skippedCount
};
@@ -668,6 +839,146 @@ function mergeVocabulary(target, sourceValue) {
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 ?? {}) };
+ for (const item of imported.items.filter((candidate) => candidate.kind === "collection")) {
+ const sourceId = item.targetId;
+ const targetId = usedCollectionIds.has(sourceId) ? uniqueId("collection", usedCollectionIds) : sourceId;
+ usedCollectionIds.add(targetId);
+ collectionIdMap[sourceId] = targetId;
+ }
+ const entryIdMap = { ...(context.entryIdMap ?? {}) };
+ for (const item of imported.items.filter((candidate) => candidate.kind === "entry")) {
+ const sourceId = item.targetId;
+ const targetId = usedEntryIds.has(sourceId) ? uniqueId("entry", usedEntryIds) : sourceId;
+ usedEntryIds.add(targetId);
+ entryIdMap[sourceId] = targetId;
+ }
+ const compoundIds = new Set(context.activeCompoundIds ?? []);
+ const compoundIdMap = {};
+ for (const item of imported.items) {
+ for (const compound of item.relationships?.compoundCases ?? []) {
+ const sourceId = clean(compound?.id);
+ if (!sourceId || compoundIdMap[sourceId]) continue;
+ const targetId = compoundIds.has(sourceId) ? uniqueId("compound", compoundIds) : sourceId;
+ compoundIds.add(targetId);
+ compoundIdMap[sourceId] = targetId;
+ }
+ }
+ const visualIdMap = {};
+ 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);
+ Object.assign(visualIdMap, 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);
+ Object.assign(visualIdMap, 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;
+ 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,
+ visualIdMap
+ };
+}
+
+function remapTrashedEntrySnapshot(entryValue, targetEntryId, usedVisualIds) {
+ 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 targetId = usedVisualIds.has(preferredId) ? 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;
+ 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
+ }));
+ 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);
@@ -691,7 +1002,18 @@ function packageImagePlaceholders(value) {
: [])
: [])
);
- return new Map([...entryImages, ...creativeAssets, ...skillFiles, ...tempFiles]);
+ const trashAssets = trashMediaAssets(value?.trashState).flatMap((asset) => asset.assetPath
+ ? [[asset.assetPath, new Blob(["placeholder"], { type: mediaType(asset.assetPath, asset.kind, asset.mimeType) })]]
+ : []);
+ return new Map([...entryImages, ...creativeAssets, ...skillFiles, ...tempFiles, ...trashAssets]);
+}
+
+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) {
@@ -791,6 +1113,35 @@ function validCreativeResultPath(path, kind) {
return /^(?:images|creative-results)\/[A-Za-z0-9._/-]+\.(?:png|jpe?g|webp)$/i.test(path);
}
+function portableMediaFileFailure(entry, asset, blob, format, packageVersion, limits, skipMediaByteValidation) {
+ const title = entry.title || "未命名案例";
+ if (!(blob instanceof Blob)) {
+ return {
+ reason: "missing_file",
+ message: asset.kind === "image" ? `“${title}”的截图缺失` : `“${title}”的媒体文件缺失或类型不符`
+ };
+ }
+ if (!blobMatchesKind(blob, asset, format, packageVersion)) {
+ return { reason: "type_mismatch", message: `“${title}”的媒体文件缺失或类型不符` };
+ }
+ if (asset.kind === "image" && blob.size > limits.maxImageBytes) {
+ return { reason: "too_large", message: `“${title}”的图片超过 ${formatBytes(limits.maxImageBytes)} 上限` };
+ }
+ if (asset.kind !== "image" && blob.size > limits.maxFileBytes) {
+ return {
+ reason: "too_large",
+ message: `“${title}”的媒体超过 ${formatBytes(limits.maxFileBytes)} 小型分享包上限,请使用完整资料夹备份`
+ };
+ }
+ if (!skipMediaByteValidation && packageVersion >= 3 && asset.byteSize && asset.byteSize !== blob.size) {
+ return {
+ reason: "byte_size_mismatch",
+ message: `“${title}”的媒体大小校验失败:期望 ${asset.byteSize} bytes,实际 ${blob.size} bytes(${clean(asset.assetPath)})`
+ };
+ }
+ return null;
+}
+
function blobMatchesKind(blob, asset, format, packageVersion) {
if (typeof asset === "string") {
if (asset === "image") return clean(blob.type).startsWith("image/");
@@ -810,7 +1161,12 @@ function blobMatchesKind(blob, asset, format, packageVersion) {
function completeBackupDocumentPaths(value = {}) {
const paths = new Map();
- for (const entry of Array.isArray(value?.entries) ? value.entries : []) {
+ 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 : [];
@@ -833,6 +1189,75 @@ function completeBackupDocumentPaths(value = {}) {
return paths;
}
+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 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"]) {
+ 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));
diff --git a/library-semantic-identity.js b/library-semantic-identity.js
new file mode 100644
index 0000000..6008f55
--- /dev/null
+++ b/library-semantic-identity.js
@@ -0,0 +1,61 @@
+const RECEIVER_LOCAL_FIELDS = new Set([
+ "libraryAddedAt",
+ "importBatchId",
+ "importSource",
+ "schemaVersion",
+ "assetPath",
+ "screenshotPath",
+ "byteSize",
+ "relativePath",
+ "sourceLastModified",
+ "linkStatus"
+]);
+
+export function caseSemanticFingerprint(entryValue = {}) {
+ const managedAssets = Array.isArray(entryValue?.mediaAssets)
+ ? entryValue.mediaAssets.filter((asset) => asset?.storageMode !== "reference")
+ : [];
+ if (managedAssets.some((asset) => !/^[a-f0-9]{64}$/iu.test(clean(asset?.contentHash)))) return "";
+ const canonical = canonicalizeReceiverIds(entryValue);
+ const { id: _entryId, ...entry } = canonical;
+ return stableJson(withoutReceiverLocalFields(entry));
+}
+
+function canonicalizeReceiverIds(entryValue) {
+ const entry = entryValue && typeof entryValue === "object" ? structuredClone(entryValue) : {};
+ const replacements = new Map();
+ if (clean(entry.id)) replacements.set(clean(entry.id), "$entry");
+ for (const [index, asset] of (Array.isArray(entry.mediaAssets) ? entry.mediaAssets : []).entries()) {
+ if (clean(asset?.id)) replacements.set(clean(asset.id), `$media:${index}`);
+ }
+ return replaceKnownIds(entry, replacements);
+}
+
+function replaceKnownIds(value, replacements) {
+ if (typeof value === "string") return replacements.get(value) ?? value;
+ if (Array.isArray(value)) return value.map((item) => replaceKnownIds(item, replacements));
+ if (!value || typeof value !== "object") return value;
+ return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, replaceKnownIds(item, replacements)]));
+}
+
+function withoutReceiverLocalFields(value, parentKey = "") {
+ if (Array.isArray(value)) return value.map((item) => withoutReceiverLocalFields(item, parentKey));
+ if (!value || typeof value !== "object") return value;
+ const result = {};
+ for (const key of Object.keys(value).sort()) {
+ if (RECEIVER_LOCAL_FIELDS.has(key)) continue;
+ const item = value[key];
+ if (item === undefined || item === null) continue;
+ if (parentKey === "classification" && ["reason", "classifierVersion"].includes(key)) continue;
+ result[key] = withoutReceiverLocalFields(item, key);
+ }
+ return result;
+}
+
+function stableJson(value) {
+ return JSON.stringify(value);
+}
+
+function clean(value) {
+ return String(value ?? "").trim();
+}
diff --git a/library.js b/library.js
index bba4a23..ec3c369 100644
--- a/library.js
+++ b/library.js
@@ -9,9 +9,17 @@ import {
getMediaBlob,
saveDerivedMetadata,
saveDerivedMedia,
- saveMediaBlob
+ saveMediaBlob,
+ savePortableAssetBlob
} from "./media-store.js";
import { parseCompleteFolderBackup, parseLibraryPackage, projectPackageEntryIds } from "./library-package.js";
+import { filesWithoutInvalidEntryMedia, findInvalidImportedImageIds } from "./library-import-media.js";
+import { caseSemanticFingerprint } from "./library-semantic-identity.js";
+import {
+ buildFolderBackupCompletion,
+ verifyFolderBackupCompletion
+} from "./library-export-plan.js";
+import { buildLibraryImportReport, importReportDescription } from "./library-import-dialog.js";
import { parseCreativeExperimentPackage } from "./creative-experiment-package.js";
import { readZipBlob } from "./zip.js";
import {
@@ -142,10 +150,12 @@ import {
} from "./capture-permissions.js";
import {
LOCAL_ASSET_FILE_ACCEPT,
+ LOCAL_ASSET_REFERENCE_RECORD_TYPE,
createUnsupportedLocalAssetReference,
extractLocalDocumentText,
findExactMediaDuplicate,
- prepareLocalMedia as prepareSharedLocalMedia
+ prepareLocalMedia as prepareSharedLocalMedia,
+ sha256Blob
} from "./local-media.js";
import {
LOCAL_ASSET_LINK_STATUS,
@@ -1445,7 +1455,7 @@ function createSourceFileCaseCover(entry, asset) {
rawTextEl("p", "case-asset-path", asset.relativePath || t("本机资料")),
rawTextEl("p", "case-asset-meta", mediaMetadataText(asset))
);
- if (asset.recordType === "local-asset-reference") {
+ if (asset.recordType === LOCAL_ASSET_REFERENCE_RECORD_TYPE) {
cover.append(rawTextEl("span", "case-local-link-badge", t("本机链接")));
}
return cover;
@@ -2379,7 +2389,7 @@ async function prepareShareLocalAssetRecords() {
const idSet = new Set(requestedIds);
const linked = entries.filter((entry) => idSet.has(entry.id)).flatMap((entry) =>
entryMediaAssets(entry)
- .filter((asset) => asset.recordType === "local-asset-reference")
+ .filter((asset) => asset.recordType === LOCAL_ASSET_REFERENCE_RECORD_TYPE)
.map((asset) => ({ entry, asset }))
);
const records = await Promise.all(linked.map(async (item) => ({
@@ -2930,29 +2940,44 @@ async function createCompleteFolderBackup() {
const resolvedEntries = [];
let mediaCount = 0;
let byteSize = 0;
- for (const entryValue of response.entries ?? []) {
+ const materializeAsset = async (entry, asset, scopeId = entry.id) => {
+ if (asset.storageMode === "reference" && asset.recordType !== LOCAL_ASSET_REFERENCE_RECORD_TYPE) return asset;
+ const blob = asset.recordType === LOCAL_ASSET_REFERENCE_RECORD_TYPE
+ ? await localAssetReferenceBackupBlob(entry, asset)
+ : await getMediaBlob(asset.id);
+ if (!(blob instanceof Blob)) throw new Error(`“${entry.title || "未命名案例"}”的媒体缺失,完整备份已停止`);
+ const assetPath = folderAssetPath(scopeId, asset, blob.type || asset.mimeType);
+ showDataSafetyFeedback(`正在写入第 ${mediaCount + 1} 项媒体 · ${formatBytes(byteSize + blob.size)}`);
+ await writeDirectoryFile(directory, assetPath, blob);
+ mediaCount += 1;
+ byteSize += blob.size;
+ return portableManagedBackupAsset(asset, blob, assetPath, await sha256Blob(blob));
+ };
+ const materializeEntry = async (entryValue, scopeId = "") => {
const entry = normalizeEntryMedia(entryValue);
const mediaAssets = [];
for (const asset of entry.mediaAssets) {
- if (asset.storageMode === "reference") {
- mediaAssets.push(asset);
- continue;
- }
- const blob = await getMediaBlob(asset.id);
- if (!blob) throw new Error(`“${entry.title || "未命名案例"}”的媒体缺失,完整备份已停止`);
- const assetPath = folderAssetPath(entry.id, asset, blob.type || asset.mimeType);
- showDataSafetyFeedback(`正在写入第 ${mediaCount + 1} 项媒体 · ${formatBytes(byteSize + blob.size)}`);
- await writeDirectoryFile(directory, assetPath, blob);
- mediaAssets.push({
- ...asset,
- mimeType: blob.type || asset.mimeType,
- byteSize: blob.size,
- assetPath
- });
- mediaCount += 1;
- byteSize += blob.size;
+ mediaAssets.push(await materializeAsset(entry, asset, scopeId || entry.id));
+ }
+ return { ...entry, mediaAssets };
+ };
+ for (const entryValue of response.entries ?? []) {
+ resolvedEntries.push(await materializeEntry(entryValue));
+ }
+ const trashState = structuredClone(response.trashState ?? { version: 1, items: [] });
+ for (const item of trashState.items ?? []) {
+ if (item.kind === "entry") {
+ item.snapshot = await materializeEntry(item.snapshot, `trash-entry-${item.targetId}`);
+ } else if (item.kind === "media") {
+ const pseudoEntry = {
+ id: item.relationships?.entryId || `trash-media-${item.targetId}`,
+ title: item.snapshot?.sourceTitle || "回收站媒体",
+ mediaAssets: item.snapshot?.mediaAssets ?? [],
+ primaryMediaId: ""
+ };
+ const materialized = await materializeEntry(pseudoEntry, `trash-media-${pseudoEntry.id}`);
+ item.snapshot.mediaAssets = materialized.mediaAssets;
}
- resolvedEntries.push({ ...entry, mediaAssets });
}
const creativeRuns = [];
for (const run of response.creativeRuns ?? []) {
@@ -3003,6 +3028,7 @@ async function createCompleteFolderBackup() {
resolvedEntries, response.settings, response.taxonomy, response.facetCatalog,
response.classificationRules, response.organizerState,
{
+ trashState,
composerSettings: response.composerSettings,
composerSessions,
creativeExperimentSettings: response.creativeExperimentSettings,
@@ -3012,10 +3038,34 @@ async function createCompleteFolderBackup() {
response.compoundCases
);
await writeDirectoryFile(directory, "library.json", new Blob([libraryJson], { type: "application/json" }));
- await writeDirectoryFile(directory, "complete.json", new Blob([JSON.stringify({
- format: "prompt-director-folder-backup", version: 1, createdAt: new Date().toISOString(),
- caseCount: resolvedEntries.length, mediaCount, byteSize
- }, null, 2)], { type: "application/json" }));
+ const writtenFiles = await readDirectoryFiles(directory);
+ const writtenLibraryFile = writtenFiles.get("library.json");
+ if (!(writtenLibraryFile instanceof Blob)) throw new Error("无法回读刚写入的 library.json");
+ const writtenLibrary = JSON.parse(await writtenLibraryFile.text());
+ const writtenMediaSizes = [...backupMediaPaths(writtenLibrary)].map((path) => writtenFiles.get(path)?.size ?? 0);
+ const writtenTotalBytes = writtenMediaSizes.reduce((sum, size) => sum + size, 0);
+ const largestWrittenMedia = Math.max(1, ...writtenMediaSizes);
+ const verified = await parseCompleteFolderBackup(writtenLibrary, writtenFiles, {
+ ...PORTABLE_LIBRARY_LIMITS,
+ maxArchiveBytes: Math.max(1, writtenTotalBytes),
+ maxFileBytes: largestWrittenMedia,
+ maxImageBytes: largestWrittenMedia,
+ maxVideoBytes: largestWrittenMedia
+ });
+ await validateImportedImageDimensions(verified.images);
+ assertFolderBackupRoundtrip(resolvedEntries, trashState, verified);
+ const trashCaseCount = trashState.items.filter((item) => item.kind === "entry").length;
+ const trashProjectCount = trashState.items.filter((item) => item.kind === "collection").length;
+ const completion = await buildFolderBackupCompletion(writtenFiles, {
+ createdAt: new Date().toISOString(),
+ caseCount: resolvedEntries.length,
+ trashCaseCount,
+ trashProjectCount,
+ mediaCount,
+ byteSize
+ });
+ await verifyFolderBackupCompletion(completion, writtenFiles);
+ await writeDirectoryFile(directory, "complete.json", new Blob([JSON.stringify(completion, null, 2)], { type: "application/json" }));
showDataSafetyFeedback(`完整备份已完成 · ${resolvedEntries.length} 个案例 · ${mediaCount} 项媒体 · ${formatBytes(byteSize)}`);
} catch (error) {
if (error?.name !== "AbortError") showDataSafetyFeedback(`${error.message};未写入完成标记的资料夹不会被当作有效备份`, true);
@@ -3029,6 +3079,7 @@ async function restoreCompleteFolderBackup() {
if (typeof window.showDirectoryPicker !== "function") return showDataSafetyFeedback("当前浏览器不支持资料夹恢复,请使用最新版 Chrome", true);
const savedIds = [];
let applyStarted = false;
+ let applySucceeded = false;
setDataSafetyBusy(true);
try {
const directory = await window.showDirectoryPicker({ mode: "read" });
@@ -3039,9 +3090,10 @@ async function restoreCompleteFolderBackup() {
let completion;
try { completion = JSON.parse(await marker.text()); }
catch { throw new Error("complete.json 已损坏,无法确认备份完整性"); }
- if (completion?.format !== "prompt-director-folder-backup" || completion.version !== 1) {
+ if (completion?.format !== "prompt-director-folder-backup" || ![1, 2].includes(completion.version)) {
throw new Error("完整备份标记无效");
}
+ if (completion.version === 2) await verifyFolderBackupCompletion(completion, files);
let library;
try { library = JSON.parse(await libraryFile.text()); }
catch { throw new Error("library.json 已损坏,无法恢复"); }
@@ -3068,40 +3120,53 @@ async function restoreCompleteFolderBackup() {
showDataSafetyFeedback(`预检完成 · ${parsed.entries.length} 个案例 · ${parsed.assets.size} 项本地媒体 · ${formatBytes(totalBytes)}`);
const preview = await chrome.runtime.sendMessage({ type: "PREVIEW_LIBRARY_IMPORT", library: restoredLibrary });
if (!preview?.ok) throw new Error(preview?.message || "无法检查资料夹备份");
+ const createdMediaIds = Object.keys(preview.createdVisualIdMap ?? {});
+ const createdMediaBytes = createdMediaIds.reduce((sum, sourceId) => sum + (parsed.assets.get(sourceId)?.size ?? 0), 0);
+ const report = buildLibraryImportReport(preview, {
+ mediaCount: createdMediaIds.length + Object.keys(preview.packageAssetIdMap ?? {}).length,
+ byteLabel: formatBytes(createdMediaBytes)
+ });
+ showDataSafetyFeedback(`${report.summary} · ${report.status === "partial" ? "发现可恢复问题,详情见确认框" : "检查通过"}`);
const approved = await confirmAppAction({
title: "恢复资料库备份?",
- description: `将恢复 ${preview.importedCount || 0} 个新案例、${preview.importedSkillCount || 0} 个 Skill 和 ${parsed.assets.size + parsed.skillAssets.size} 项本地文件(${formatBytes(totalBytes)})。${preview.remappedCount ? `其中 ${preview.remappedCount} 个同源案例会作为新副本导入。` : ""}已有内容不会被覆盖。`,
+ description: `${importReportDescription(report)}已有内容不会被覆盖。`,
confirmLabel: "开始恢复"
});
if (!approved) {
showDataSafetyFeedback("已取消恢复,资料库没有变化");
return;
}
- for (const [sourceId, targetId] of Object.entries(preview.visualIdMap ?? {})) {
+ const operationId = createLibraryImportOperationId();
+ for (const [sourceId, targetId] of Object.entries(preview.createdVisualIdMap ?? {})) {
const blob = parsed.assets.get(sourceId);
if (!blob) continue;
- await saveMediaBlob(targetId, blob);
+ await savePortableAssetBlob(targetId, blob);
savedIds.push(targetId);
}
for (const [sourceId, targetId] of Object.entries(preview.packageAssetIdMap ?? {})) {
const blob = parsed.skillAssets.get(sourceId);
if (!blob) continue;
- await saveMediaBlob(targetId, blob);
+ await savePortableAssetBlob(targetId, blob);
savedIds.push(targetId);
}
applyStarted = true;
- const response = await chrome.runtime.sendMessage({
+ const response = await applyLibraryImportWithReceipt({
type: "APPLY_LIBRARY_IMPORT", library: restoredLibrary,
+ operationId,
+ planToken: preview.planToken,
entryIdMap: preview.entryIdMap, compoundIdMap: preview.compoundIdMap,
visualIdMap: preview.visualIdMap, sessionIdMap: preview.sessionIdMap, runIdMap: preview.runIdMap,
skillIdMap: preview.skillIdMap, packageAssetIdMap: preview.packageAssetIdMap
});
if (!response?.ok) throw new Error(response?.message || "资料夹恢复失败");
+ applySucceeded = true;
await refreshLibrary();
showDataSafetyFeedback(`${response.message} · 媒体文件校验并恢复完成`);
await renderDataSafetyStatus();
} catch (error) {
- const retained = applyStarted ? await importedEntryIds(savedIds) : new Set();
+ const retained = applySucceeded
+ ? new Set(savedIds)
+ : applyStarted ? await committedMediaIds(savedIds) : new Set();
await Promise.allSettled(savedIds.filter((id) => !retained.has(id)).map((id) => deleteMediaBlob(id)));
if (error?.name !== "AbortError") showDataSafetyFeedback(error.message, true);
} finally {
@@ -3118,6 +3183,7 @@ async function importSharedLibraryPackage() {
}
const savedIds = [];
let applyStarted = false;
+ let applySucceeded = false;
setDataSafetyBusy(true);
try {
showDataSafetyFeedback(`正在检查 ${file.name}`);
@@ -3137,39 +3203,50 @@ async function importSharedLibraryPackage() {
let library;
try { library = JSON.parse(await libraryFile.text()); }
catch { throw new Error("分享包中的 library.json 已损坏"); }
- const parsed = parseLibraryPackage(library, files, packageLimits);
- await validateImportedImageDimensions(parsed.images);
+ const salvageOptions = { ...packageLimits, salvageInvalidMedia: true };
+ let parsed = parseLibraryPackage(library, files, salvageOptions);
+ const invalidImageIds = await findInvalidImportedImageIds(parsed.images, validateImportedImage);
+ if (invalidImageIds.size) {
+ const salvageFiles = filesWithoutInvalidEntryMedia(library, files, invalidImageIds);
+ parsed = parseLibraryPackage(library, salvageFiles, salvageOptions);
+ await validateImportedImageDimensions(parsed.images);
+ }
const importLibrary = { ...parsed };
delete importLibrary.assets;
delete importLibrary.images;
- const totalBytes = [...parsed.assets.values()].reduce((sum, blob) => sum + blob.size, 0);
+ delete importLibrary.skillAssets;
const preview = await chrome.runtime.sendMessage({
type: "PREVIEW_LIBRARY_IMPORT",
library: importLibrary,
preserveLibraryConfiguration: true
});
if (!preview?.ok) throw new Error(preview?.message || "无法检查分享包");
- showDataSafetyFeedback(
- `预检完成 · 新增 ${preview.importedCount || 0} 个案例 · ${parsed.assets.size} 项媒体 · ${formatBytes(totalBytes)}`
- );
+ const createdMediaIds = Object.keys(preview.createdVisualIdMap ?? {});
+ const createdMediaBytes = createdMediaIds.reduce((sum, sourceId) => sum + (parsed.assets.get(sourceId)?.size ?? 0), 0);
+ const report = buildLibraryImportReport(preview, {
+ mediaCount: createdMediaIds.length,
+ byteLabel: formatBytes(createdMediaBytes)
+ });
+ showDataSafetyFeedback(`${report.summary} · ${report.status === "partial" ? "发现可恢复问题,详情见确认框" : "检查通过"}`);
const approved = await confirmAppAction({
title: "导入分享包?",
- description: `将导入 ${preview.importedCount || 0} 个新案例和 ${parsed.assets.size} 项本地媒体` +
- `${preview.remappedCount ? `;其中 ${preview.remappedCount} 个同源案例会作为新副本导入` : ""}` +
- `${preview.skippedCount ? `,跳过 ${preview.skippedCount} 个已有案例` : ""}。现有资料不会被覆盖。`,
+ description: `${importReportDescription(report)}现有资料不会被覆盖。`,
confirmLabel: "开始导入"
});
if (!approved) return showDataSafetyFeedback("已取消导入,资料库没有变化");
- for (const [sourceId, targetId] of Object.entries(preview.visualIdMap ?? {})) {
+ const operationId = createLibraryImportOperationId();
+ for (const [sourceId, targetId] of Object.entries(preview.createdVisualIdMap ?? {})) {
const blob = parsed.assets.get(sourceId);
if (!blob) continue;
- await saveMediaBlob(targetId, blob);
+ await savePortableAssetBlob(targetId, blob);
savedIds.push(targetId);
}
applyStarted = true;
- const response = await chrome.runtime.sendMessage({
+ const response = await applyLibraryImportWithReceipt({
type: "APPLY_LIBRARY_IMPORT",
library: importLibrary,
+ operationId,
+ planToken: preview.planToken,
entryIdMap: preview.entryIdMap,
compoundIdMap: preview.compoundIdMap,
visualIdMap: preview.visualIdMap,
@@ -3178,11 +3255,14 @@ async function importSharedLibraryPackage() {
preserveLibraryConfiguration: true
});
if (!response?.ok) throw new Error(response?.message || "分享包导入失败");
+ applySucceeded = true;
await refreshLibrary();
showDataSafetyFeedback(`${response.message} · 分享包媒体已校验`);
await renderDataSafetyStatus();
} catch (error) {
- const retained = applyStarted ? await importedEntryIds(savedIds) : new Set();
+ const retained = applySucceeded
+ ? new Set(savedIds)
+ : applyStarted ? await committedMediaIds(savedIds) : new Set();
await Promise.allSettled(savedIds.filter((id) => !retained.has(id)).map((id) => deleteMediaBlob(id)));
showDataSafetyFeedback(error.message || "分享包导入失败", true);
} finally {
@@ -3191,6 +3271,22 @@ async function importSharedLibraryPackage() {
}
}
+function createLibraryImportOperationId() {
+ return `library-import:${crypto.randomUUID()}`;
+}
+
+async function applyLibraryImportWithReceipt(message) {
+ try {
+ return await chrome.runtime.sendMessage(message);
+ } catch (firstError) {
+ try {
+ return await chrome.runtime.sendMessage(message);
+ } catch {
+ throw firstError;
+ }
+ }
+}
+
function backupMediaPaths(library) {
return new Set([
...(library?.entries ?? []).flatMap((entry) => (entry.mediaAssets ?? entry.visuals ?? [])
@@ -3201,10 +3297,107 @@ function backupMediaPaths(library) {
.map((file) => file.archivePath).filter(Boolean)),
...(library?.composerSessions ?? []).flatMap((session) => (session.referenceSnapshots ?? [])
.filter((reference) => reference?.sourceType === "temporary")
- .flatMap((reference) => (reference.assetRefs ?? []).map((asset) => asset.archivePath).filter(Boolean)))
+ .flatMap((reference) => (reference.assetRefs ?? []).map((asset) => asset.archivePath).filter(Boolean))),
+ ...(library?.trashState?.items ?? []).flatMap((item) => {
+ if (item?.kind === "entry") {
+ return (item.snapshot?.mediaAssets ?? item.snapshot?.visuals ?? [])
+ .map((asset) => asset.assetPath || asset.screenshotPath).filter(Boolean);
+ }
+ if (item?.kind === "media") {
+ return (item.snapshot?.mediaAssets ?? [])
+ .map((asset) => asset.assetPath || asset.screenshotPath).filter(Boolean);
+ }
+ return [];
+ })
]);
}
+function assertFolderBackupRoundtrip(entriesValue, trashStateValue, parsed) {
+ const expectedEntries = Array.isArray(entriesValue) ? entriesValue : [];
+ if (parsed.entries.length !== expectedEntries.length) throw new Error("完整备份自检失败:案例数量不一致");
+ const parsedEntries = new Map(parsed.entries.map((entry) => [entry.id, entry]));
+ for (const entry of expectedEntries) {
+ const restored = parsedEntries.get(entry.id);
+ if (!restored || caseSemanticFingerprint(entry) !== caseSemanticFingerprint(restored)) {
+ throw new Error(`完整备份自检失败:“${entry.title || entry.id}”回读后内容不一致`);
+ }
+ }
+ const expectedTrash = Array.isArray(trashStateValue?.items) ? trashStateValue.items : [];
+ const actualTrash = Array.isArray(parsed.trashState?.items) ? parsed.trashState.items : [];
+ if (actualTrash.length !== expectedTrash.length) throw new Error("完整备份自检失败:回收站数量不一致");
+ const actualById = new Map(actualTrash.map((item) => [item.id, item]));
+ for (const expected of expectedTrash) {
+ const actual = actualById.get(expected.id);
+ if (!actual || actual.kind !== expected.kind || actual.targetId !== expected.targetId) {
+ throw new Error("完整备份自检失败:回收站关系不一致");
+ }
+ if (stableBackupValue(expected.relationships) !== stableBackupValue(actual.relationships)) {
+ throw new Error("完整备份自检失败:回收站关联关系不一致");
+ }
+ if (expected.kind === "entry" && caseSemanticFingerprint(expected.snapshot) !== caseSemanticFingerprint(actual.snapshot)) {
+ throw new Error(`完整备份自检失败:回收站案例“${expected.snapshot?.title || expected.targetId}”内容不一致`);
+ }
+ if (expected.kind === "collection" && stableBackupValue(expected.snapshot) !== stableBackupValue(actual.snapshot)) {
+ throw new Error(`完整备份自检失败:回收站项目“${expected.snapshot?.name || expected.targetId}”内容不一致`);
+ }
+ if (expected.kind === "media" && stableBackupValue(expected.snapshot) !== stableBackupValue(actual.snapshot)) {
+ throw new Error(`完整备份自检失败:回收站媒体“${expected.targetId}”内容不一致`);
+ }
+ }
+}
+
+function stableBackupValue(value) {
+ if (Array.isArray(value)) return `[${value.map(stableBackupValue).join(",")}]`;
+ if (!value || typeof value !== "object") return JSON.stringify(value);
+ return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableBackupValue(value[key])}`).join(",")}}`;
+}
+
+async function localAssetReferenceBackupBlob(entry, asset) {
+ const record = await getLocalAssetHandleRecord(asset.id);
+ if (!record) throw new Error(`“${asset.sourceTitle || entry.title || "未命名素材"}”的本机链接已丢失,完整备份已停止`);
+ let inspection = await inspectLocalAssetHandle(record, asset);
+ if (inspection.status === LOCAL_ASSET_LINK_STATUS.NEEDS_PERMISSION) {
+ if (typeof record.handle.requestPermission !== "function") {
+ throw new Error(`“${asset.sourceTitle || entry.title || "未命名素材"}”需要重新授权,完整备份已停止`);
+ }
+ const permission = await record.handle.requestPermission({ mode: "read" });
+ if (permission !== "granted") {
+ throw new Error(`没有获得“${asset.sourceTitle || entry.title || "未命名素材"}”的读取权限,完整备份已停止`);
+ }
+ inspection = await inspectLocalAssetHandle(record, asset);
+ }
+ if (![LOCAL_ASSET_LINK_STATUS.READY, LOCAL_ASSET_LINK_STATUS.CHANGED].includes(inspection.status) || !(inspection.file instanceof Blob)) {
+ throw new Error(`“${asset.sourceTitle || entry.title || "未命名素材"}”无法读取,完整备份已停止`);
+ }
+ return inspection.file;
+}
+
+function portableManagedBackupAsset(asset, blob, assetPath, contentHash) {
+ const {
+ recordType: _recordType,
+ linkStatus: _linkStatus,
+ importFailure: _importFailure,
+ sourceLastModified: _sourceLastModified,
+ linkedAt: _linkedAt,
+ localPath: _localPath,
+ absolutePath: _absolutePath,
+ fileHandle: _fileHandle,
+ handle: _handle,
+ reference: _reference,
+ relativePath: _relativePath,
+ ...portable
+ } = asset;
+ return {
+ ...portable,
+ storageMode: "managed",
+ ...(asset.kind === "attachment" ? { formatCategory: "other-source" } : {}),
+ mimeType: blob.type || asset.mimeType || "application/octet-stream",
+ byteSize: blob.size,
+ contentHash,
+ assetPath
+ };
+}
+
function skillFolderPath(portableId, assetId, packagePath) {
const parts = String(packagePath ?? "").split("/").filter(Boolean).map(safeFolderPart);
if (!parts.length) throw new Error("外部 Skill 原包路径无效");
@@ -3245,8 +3438,16 @@ async function readDirectoryFiles(directory, prefix = "") {
}
function folderAssetPath(entryId, asset, mimeType) {
- const directory = asset.kind === "video" ? "videos" : asset.kind === "document" ? "documents" : "images";
- return `${directory}/${safeFolderPart(entryId)}/${safeFolderPart(asset.id)}.${folderExtension(mimeType, asset.kind)}`;
+ const directories = {
+ image: "images",
+ video: "videos",
+ audio: "audio",
+ document: "documents",
+ attachment: "attachments"
+ };
+ const directory = directories[asset.kind];
+ if (!directory) throw new Error("媒体类型无效,完整备份已停止");
+ return `${directory}/${safeFolderPart(entryId)}/${safeFolderPart(asset.id)}.${folderExtension(mimeType, asset.kind, asset.sourceFormat)}`;
}
function safeFolderPart(value) {
@@ -3255,14 +3456,16 @@ function safeFolderPart(value) {
return safe;
}
-function folderExtension(mimeType, kind) {
+function folderExtension(mimeType, kind, sourceFormat = "") {
const known = {
"image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "video/mp4": "mp4", "video/webm": "webm",
"video/quicktime": "mov", "video/x-matroska": "mkv", "video/x-msvideo": "avi", "application/pdf": "pdf",
"application/rtf": "rtf", "text/rtf": "rtf", "application/x-rtf": "rtf",
"text/plain": "txt", "text/markdown": "md", "text/html": "html"
};
- return known[mimeType] || (kind === "video" ? "video" : kind === "document" ? "bin" : "webp");
+ const preserved = String(sourceFormat ?? "").trim().toLocaleLowerCase("en-US").replace(/^\./, "");
+ if (kind === "attachment" && /^[a-z0-9]+$/u.test(preserved)) return preserved;
+ return known[mimeType] || (kind === "video" ? "video" : ["document", "attachment"].includes(kind) ? "bin" : kind === "audio" ? "audio" : "webp");
}
async function importCreativeExperimentArchive() {
@@ -3316,14 +3519,22 @@ async function importCreativeExperimentArchive() {
}
}
-async function importedEntryIds(ids) {
+async function committedMediaIds(ids) {
try {
const response = await chrome.runtime.sendMessage({ type: "GET_STATE" });
if (!response?.ok) return new Set(ids);
const targets = new Set(ids);
const retained = [
...(response.entries ?? []).flatMap((entry) => entry.mediaAssets ?? entry.visuals ?? []).map((asset) => asset.id),
- ...(response.creativeSkills?.items ?? []).flatMap((skill) => skill.packageFiles ?? []).map((file) => file.assetId)
+ ...(response.creativeSkills?.items ?? []).flatMap((skill) => skill.packageFiles ?? []).map((file) => file.assetId),
+ ...(response.creativeRuns ?? []).flatMap((run) => run.outputs ?? []).map((output) => output.visual?.id),
+ ...(response.composerSessions ?? []).flatMap((session) => session.referenceSnapshots ?? [])
+ .flatMap((reference) => reference.assetRefs ?? []).map((asset) => asset.assetId),
+ ...(response.trashState?.items ?? []).flatMap((item) => {
+ if (item?.kind === "entry") return item.snapshot?.mediaAssets ?? item.snapshot?.visuals ?? [];
+ if (item?.kind === "media") return item.snapshot?.mediaAssets ?? [];
+ return [];
+ }).map((asset) => asset.id)
];
return new Set(retained.filter((id) => targets.has(id)));
} catch {
@@ -3333,11 +3544,15 @@ async function importedEntryIds(ids) {
async function validateImportedImageDimensions(images) {
for (const image of images.values()) {
- const metadata = await readImageDimensions(image);
- assertImageDimensions(metadata.width, metadata.height);
+ await validateImportedImage(image);
}
}
+async function validateImportedImage(image) {
+ const metadata = await readImageDimensions(image);
+ assertImageDimensions(metadata.width, metadata.height);
+}
+
async function hydrateCardImage(image) {
const visualId = image.dataset.visualId;
if (!visualId || image.src) return;
@@ -4537,7 +4752,7 @@ async function createMediaViewer(asset, imageUrl, entry) {
});
return image;
}
- if (asset.recordType === "local-asset-reference") return createLocalAssetReferenceViewer(asset, entry);
+ if (asset.recordType === LOCAL_ASSET_REFERENCE_RECORD_TYPE) return createLocalAssetReferenceViewer(asset, entry);
if (asset.storageMode === "reference") return createReferencedMediaViewer(asset, entry);
const blob = await getMediaBlob(asset.id);
if (!blob) return textEl("div", "detail-placeholder", "本地媒体文件缺失;请从完整备份恢复");
@@ -5685,7 +5900,7 @@ async function prepareLocalImport(fileItems, { source = "files" } = {}) {
renderImportProjectOptions(rootName);
const visionProvider = visionSettings.activeProvider === "compatible" ? visionSettings.compatible : visionSettings.openai;
const canAutoAnalyze = Boolean(visionSettings.consent && visionProvider?.configured);
- elements.importAutoAnalyze.checked = canAutoAnalyze && Boolean(visionSettings.autoAnalyzeImports);
+ elements.importAutoAnalyze.checked = false;
elements.importAutoAnalyze.disabled = !canAutoAnalyze;
elements.importAutoAnalyze.title = elements.importAutoAnalyze.disabled ? "先在设置的 AI 服务中配置并授权图片分析" : "";
elements.importPreparing.hidden = false;
@@ -6154,7 +6369,7 @@ async function discardPendingLocalImport() {
pendingLocalImport = null;
await Promise.allSettled(staged.flatMap((item) => [item.assetId, item.posterAssetId].filter(Boolean)).map(deleteMediaBlob));
await Promise.allSettled(staged
- .filter((item) => item.recordType === "local-asset-reference")
+ .filter((item) => item.recordType === LOCAL_ASSET_REFERENCE_RECORD_TYPE)
.map((item) => deleteLocalAssetHandle(item.assetId)));
}
diff --git a/manifest.json b/manifest.json
index 4519e4c..25000c9 100644
--- a/manifest.json
+++ b/manifest.json
@@ -1,7 +1,7 @@
{
"manifest_version": 3,
"name": "__MSG_extensionName__",
- "version": "1.19.1",
+ "version": "1.19.2",
"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAq2m8W9ACXJTkJqPAd36sPrtzonmHhOYU34uS7c+D7DXX6ggWNMwB4xZapGFJ4ScBQJv71PeG9KfsEnhcXFZ9RoX/X3wY+57evL19hf6woNX1xxhKOe1rtx5QmzWCEYIr99TzW50k/N9U6tS9Ri+2DHKYA85ssXTC8B2yRQ5zUXhsAWZe/HDU18UFuvUKXYt3ZdIUi31c2vIlgFFBfsyKbIUMny9LlxL/smb4vJzU/+A3LwJDjjvOtS/lmQ2vHoQGjHJItO18bYI6h67fIEvmWk+HJKtO08Ca+5RLS8TYhI+K7l7S0RyDVNujyVWtvhAULot1H0BvteYL87fKu3SNywIDAQAB",
"homepage_url": "https://github.com/wchao6891/PromptDirector",
"default_locale": "zh_CN",
diff --git a/media-store.js b/media-store.js
index a13714d..cf9ca4d 100644
--- a/media-store.js
+++ b/media-store.js
@@ -17,6 +17,16 @@ let databasePromise;
export async function saveMediaBlob(assetId, blob, options = {}) {
validateAssetId(assetId);
validateMediaBlob(blob);
+ return writeMediaBlob(assetId, blob, options);
+}
+
+export async function savePortableAssetBlob(assetId, blob, options = {}) {
+ validateAssetId(assetId);
+ validatePortableAssetBlob(blob);
+ return writeMediaBlob(assetId, blob, options);
+}
+
+async function writeMediaBlob(assetId, blob, options = {}) {
if (options.checkCapacity !== false) {
const estimate = await storageEstimate(options.estimateStorage);
assertStorageCapacity(estimate, blob.size);
@@ -231,15 +241,19 @@ export function assertStorageCapacity(estimate = {}, incomingBytes = 0) {
}
export function validateMediaBlob(blob) {
- if (!(blob instanceof Blob) || !blob.size) {
- throw assetImportError(ASSET_IMPORT_FAILURE_CODES.INVALID_FILE, "媒体文件无效");
- }
+ validatePortableAssetBlob(blob);
const type = String(blob.type || "").toLocaleLowerCase("en-US");
if (!(type.startsWith("image/") || type.startsWith("video/") || assetFormatsForMimeType(type).length)) {
throw assetImportError(ASSET_IMPORT_FAILURE_CODES.UNSUPPORTED_FORMAT, "暂不支持这种媒体格式");
}
}
+export function validatePortableAssetBlob(blob) {
+ if (!(blob instanceof Blob) || !blob.size) {
+ throw assetImportError(ASSET_IMPORT_FAILURE_CODES.INVALID_FILE, "媒体文件无效");
+ }
+}
+
async function storageEstimate(override) {
if (typeof override === "function") return override();
if (globalThis.navigator?.storage?.estimate) return globalThis.navigator.storage.estimate();
diff --git a/migration.js b/migration.js
index c49b124..c26e5b3 100644
--- a/migration.js
+++ b/migration.js
@@ -25,14 +25,17 @@ export function migrateLibraryState(stored = {}) {
let entries = (Array.isArray(stored.entries) ? stored.entries : []).map((entry) =>
migrateEntry(entry, classificationRules, taxonomy, resetRequired, legacyNodes, legacyFacetNodes)
);
+ let trashState = normalizeTrashState(stored.trashState);
let facetCatalog;
let facetTreeMigrated = false;
if (resetRequired) {
facetCatalog = createDefaultFacetCatalog();
} else if (!isFixedTagTree(sourceFacetCatalog)) {
- const migrated = migrateLegacyFacetState(entries, sourceFacetCatalog, { preserveDeepSeek: true });
+ const targets = legacyFacetMigrationTargets(entries, trashState);
+ const migrated = migrateLegacyFacetState(targets.entries, sourceFacetCatalog, { preserveDeepSeek: true });
facetCatalog = migrated.catalog;
- entries = migrated.entries;
+ entries = migrated.entries.slice(0, entries.length);
+ trashState = applyLegacyTrashFacetMigration(trashState, targets.bindings, migrated.entries);
facetTreeMigrated = true;
} else {
facetCatalog = sourceFacetCatalog;
@@ -45,7 +48,7 @@ export function migrateLibraryState(stored = {}) {
facetCatalog,
classificationRules,
entries,
- trashState: normalizeTrashState(stored.trashState),
+ trashState,
compoundCases: normalizeCompoundCases(stored.compoundCases, entries),
organizerState: normalizeOrganizerState(stored.organizerState, entries.map((entry) => entry.id))
},
@@ -56,6 +59,48 @@ export function migrateLibraryState(stored = {}) {
};
}
+function legacyFacetMigrationTargets(entries, trashState) {
+ const migrationEntries = [...entries];
+ const bindings = [];
+ for (const item of trashState.items) {
+ if (item.kind === "entry") {
+ bindings.push({ kind: "entry", itemId: item.id, index: migrationEntries.length });
+ migrationEntries.push(item.snapshot);
+ continue;
+ }
+ if (item.kind !== "media") continue;
+ for (const containerName of ["snapshot", "relationships"]) {
+ const container = item[containerName];
+ if (!Array.isArray(container?.facetAssignments)) continue;
+ bindings.push({ kind: "media", itemId: item.id, containerName, index: migrationEntries.length });
+ migrationEntries.push({
+ id: `${item.id}:${containerName}`,
+ facetAssignments: container.facetAssignments,
+ customLabels: container.customLabels ?? []
+ });
+ }
+ }
+ return { entries: migrationEntries, bindings };
+}
+
+function applyLegacyTrashFacetMigration(trashState, bindings, migratedEntries) {
+ const items = structuredClone(trashState.items);
+ const byId = new Map(items.map((item) => [item.id, item]));
+ for (const binding of bindings) {
+ const item = byId.get(binding.itemId);
+ const migrated = migratedEntries[binding.index];
+ if (!item || !migrated) continue;
+ if (binding.kind === "entry") {
+ item.snapshot = migrated;
+ continue;
+ }
+ const container = item[binding.containerName];
+ container.facetAssignments = migrated.facetAssignments;
+ if (migrated.customLabels?.length) container.customLabels = migrated.customLabels;
+ }
+ return normalizeTrashState({ items });
+}
+
export function needsMigration(stored = {}) {
return stored.schemaVersion !== SCHEMA_VERSION || !stored.taxonomy || !stored.facetCatalog ||
!stored.organizerState || stored.organizerState.version !== ORGANIZER_VERSION || !stored.trashState || !Array.isArray(stored.compoundCases) ||
diff --git a/offscreen.js b/offscreen.js
index 29bb512..5d9274b 100644
--- a/offscreen.js
+++ b/offscreen.js
@@ -8,6 +8,7 @@ import {
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,
@@ -332,7 +333,7 @@ async function cropLoadedScreenshot(image, entryId, selection) {
};
}
-async function createArchiveUrl({
+export async function createArchiveUrl({
entries, settings, taxonomy, facetCatalog, classificationRules, organizerState,
composerSettings, composerSessions, creativeExperimentSettings, creativeRuns,
creativeSkills, compoundCases, uiPreferences, locale: localeValue, sharing = false,
@@ -414,24 +415,25 @@ async function createArchiveUrl({
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: renderLibraryJson(
- resolvedEntries,
- settings,
- taxonomy,
- facetCatalog,
- classificationRules,
- organizerState,
- sharing ? null : {
- composerSettings,
- composerSessions,
- creativeExperimentSettings,
- creativeRuns: resolvedCreativeRuns,
- creativeSkills: resolvedCreativeSkills
- },
- compoundCases
- )
+ data: libraryJson
});
if (sharing) {
const [foundationCss, iconSprite, masonrySource] = await Promise.all([
@@ -458,7 +460,7 @@ async function createArchiveUrl({
{ name: SHARE_PREVIEW_MASONRY_FILENAME, data: renderSharePreviewMasonryJs(masonrySource) }
);
}
- const archive = await createZipBlob(files);
+ 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 };
diff --git a/organizer.js b/organizer.js
index 768ef09..bd50f14 100644
--- a/organizer.js
+++ b/organizer.js
@@ -255,6 +255,10 @@ export function removeEntriesFromOrganizer(stateValue, entryIds) {
}
export function mergeOrganizerState(currentValue, importedValue, entryIdMap = {}, options = {}) {
+ return mergeOrganizerStateWithMap(currentValue, importedValue, entryIdMap, options).state;
+}
+
+export function mergeOrganizerStateWithMap(currentValue, importedValue, entryIdMap = {}, options = {}) {
const current = structuredClone(normalizeOrganizerState(currentValue));
const imported = normalizeOrganizerState(importedValue);
const remap = (ids) => uniqueIds(ids).map((id) => cleanId(entryIdMap[id])).filter(Boolean);
@@ -282,7 +286,10 @@ export function mergeOrganizerState(currentValue, importedValue, entryIdMap = {}
});
collectionIdMap.set(source.id, id);
}
- return normalizeOrganizerState(current);
+ return {
+ state: normalizeOrganizerState(current),
+ collectionIdMap: Object.fromEntries(collectionIdMap)
+ };
}
function normalizeCollection(value = {}) {
diff --git a/package-lock.json b/package-lock.json
index e93910c..6535f6e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "prompt-case-collector",
- "version": "1.19.1",
+ "version": "1.19.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "prompt-case-collector",
- "version": "1.19.1",
+ "version": "1.19.2",
"license": "Apache-2.0",
"dependencies": {
"@jonahschulte/rtf-toolkit": "0.5.0",
diff --git a/package.json b/package.json
index ec0e9a2..8364370 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "prompt-case-collector",
- "version": "1.19.1",
+ "version": "1.19.2",
"private": false,
"license": "Apache-2.0",
"repository": "https://github.com/wchao6891/PromptDirector",
@@ -22,7 +22,9 @@
"package:release": "npm run build:brand && npm run build:documents && npm run build:icons && node tools/package-extension.mjs --release",
"test:e2e": "python3 test/run_e2e.py",
"test:smart-picker": "python3 test/smart_visual_picker_e2e.py",
- "verify": "npm run check:public && npm run check && npm run check:brand && npm run check:documents && npm run check:pdfjs && npm run check:store && npm test && npm run package:release"
+ "verify:source": "npm run check:public && npm run check && npm run check:brand && npm run check:documents && npm run check:pdfjs && npm run check:store && npm test",
+ "verify:release": "npm run verify:source && npm run test:e2e && npm run package:release",
+ "verify": "npm run verify:release"
},
"dependencies": {
"@jonahschulte/rtf-toolkit": "0.5.0",
diff --git a/reference-readiness.js b/reference-readiness.js
new file mode 100644
index 0000000..372bd53
--- /dev/null
+++ b/reference-readiness.js
@@ -0,0 +1,28 @@
+export function referenceHasPromptText(reference = {}) {
+ return Boolean(
+ clean(reference.originalText)
+ || (["prompt", "prompt_vision"].includes(reference.referenceKind) && clean(reference.referenceText))
+ );
+}
+
+export function referenceHasUsableLegacyDescription(reference = {}, asset = {}) {
+ if (reference.referenceKind !== "vision" || !clean(reference.referenceText)) return false;
+ const imageFingerprint = clean(asset.imageFingerprint);
+ const analysisImageFingerprint = clean(asset.analysisImageFingerprint);
+ return Number(asset.analysisVersion) >= 1 && imageFingerprint && analysisImageFingerprint &&
+ imageFingerprint === analysisImageFingerprint;
+}
+
+export function hasCompleteReferenceAnalysis(asset = {}) {
+ return Boolean(
+ Number(asset.analysisVersion) === 2
+ && clean(asset.analysisFingerprint)
+ && clean(asset.reconstructionPrompt)
+ && clean(asset.imageFingerprint)
+ && clean(asset.imageFingerprint) === clean(asset.analysisImageFingerprint)
+ );
+}
+
+function clean(value) {
+ return String(value ?? "").trim();
+}
diff --git a/store/CHROME_WEB_STORE_SUBMISSION.md b/store/CHROME_WEB_STORE_SUBMISSION.md
index 19c9c04..1ea8750 100644
--- a/store/CHROME_WEB_STORE_SUBMISSION.md
+++ b/store/CHROME_WEB_STORE_SUBMISSION.md
@@ -6,7 +6,7 @@ This file is the source-of-truth worksheet for the current PromptDirector manife
- Chrome Web Store item public key: stored in the source `manifest.json` for local identity verification only; `package:release` removes `key` from the upload manifest.
- Expected extension ID: `iahakaahijddcjjldidbclicedibgpjm`.
-- Current release candidate: `dist/PromptDirector-1.19.1.zip`.
+- Current release candidate: `dist/PromptDirector-1.19.2.zip`.
- Candidate size: `8,628,576` bytes.
- Candidate SHA-256: `75ac89066fa94aa2b21876796de9986173b6f3f8020bda9ef07d27e610ec12dd`.
- Generate a candidate only with `npm run package:release`; the command verifies the source public key against the expected identity, then removes `key` from the Web Store upload manifest.
diff --git a/temp-references.js b/temp-references.js
index 3f47918..6c54028 100644
--- a/temp-references.js
+++ b/temp-references.js
@@ -1,4 +1,9 @@
import { detectLocalMediaFile, extractLocalDocumentText } from "./local-media.js";
+import {
+ hasCompleteReferenceAnalysis,
+ referenceHasPromptText,
+ referenceHasUsableLegacyDescription
+} from "./reference-readiness.js";
export const TEMP_REFERENCE_SOURCE_TYPES = Object.freeze({
library: "library",
@@ -100,25 +105,23 @@ export function imageTempReferenceBlock(referenceSnapshots, service) {
export function unreadReferenceImageAssets(reference) {
const analyzedAssets = new Map((Array.isArray(reference?.assets) ? reference.assets : [])
.map((item) => [String(item?.assetId ?? "").trim(), item]));
- const promptBacked = Boolean(
- String(reference?.originalText ?? "").trim()
- || (["prompt", "prompt_vision"].includes(reference?.referenceKind)
- && String(reference?.referenceText ?? "").trim())
- );
+ const promptBacked = referenceHasPromptText(reference);
if (promptBacked || (String(reference?.referenceText ?? "").trim() && !analyzedAssets.size)) return [];
const assets = [];
const seen = new Set();
for (const asset of Array.isArray(reference?.assetRefs) ? reference.assetRefs : []) {
const assetId = String(asset?.assetId ?? "").trim();
if (asset?.kind !== "image" || !assetId || seen.has(assetId)) continue;
- if (hasCompleteReferenceAnalysis(analyzedAssets.get(assetId))) continue;
+ if (hasCompleteReferenceAnalysis(analyzedAssets.get(assetId)) ||
+ referenceHasUsableLegacyDescription(reference, analyzedAssets.get(assetId))) continue;
seen.add(assetId);
assets.push({ ...asset, assetId });
}
for (const image of Array.isArray(reference?.imageRefs) ? reference.imageRefs : []) {
const assetId = String(image?.visualId ?? "").trim();
if (!assetId || seen.has(assetId)) continue;
- if (hasCompleteReferenceAnalysis(analyzedAssets.get(assetId))) continue;
+ if (hasCompleteReferenceAnalysis(analyzedAssets.get(assetId)) ||
+ referenceHasUsableLegacyDescription(reference, analyzedAssets.get(assetId))) continue;
seen.add(assetId);
assets.push({
assetId,
@@ -130,15 +133,6 @@ export function unreadReferenceImageAssets(reference) {
return assets;
}
-function hasCompleteReferenceAnalysis(value) {
- return Boolean(value
- && Number(value.analysisVersion) === 2
- && String(value.analysisFingerprint ?? "").trim()
- && String(value.reconstructionPrompt ?? "").trim()
- && String(value.imageFingerprint ?? "").trim()
- && value.imageFingerprint === value.analysisImageFingerprint);
-}
-
export function tempReferenceAssetIds(reference) {
if (reference?.sourceType !== TEMP_REFERENCE_SOURCE_TYPES.temporary) return [];
return [...new Set((Array.isArray(reference.assetRefs) ? reference.assetRefs : [])
diff --git a/test/analysis-scheduler.test.js b/test/analysis-scheduler.test.js
index 436b444..ca364db 100644
--- a/test/analysis-scheduler.test.js
+++ b/test/analysis-scheduler.test.js
@@ -1,7 +1,12 @@
import test from "node:test";
import assert from "node:assert/strict";
-import { coalesceAnalysisRequest, runScheduledAnalysisWithRetries, scheduleAnalysis } from "../analysis-scheduler.js";
+import {
+ coalesceAnalysisRequest,
+ createAnalysisScheduler,
+ runScheduledAnalysisWithRetries,
+ scheduleAnalysis
+} from "../analysis-scheduler.js";
const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -70,3 +75,112 @@ test("shared work honors the lowest active job snapshot instead of the last call
]);
assert.equal(maximumWhileLowLimitActive, 2);
});
+
+test("interactive work outranks queued batch work while preserving no-preemption for the running item", async () => {
+ const scheduler = createAnalysisScheduler({ concurrency: 1, agingMs: 10 });
+ const events = [];
+ let release;
+
+ const blocker = scheduler.schedule(async () => {
+ events.push("background_import:started");
+ await new Promise((resolve) => { release = resolve; });
+ events.push("background_import:finished");
+ return "blocker";
+ }, { priority: "background_import" });
+
+ await delay(5);
+
+ const laterInteractive = scheduler.schedule(async () => {
+ events.push("interactive:started");
+ return "interactive";
+ }, { priority: "interactive" });
+
+ await delay(0);
+ assert.deepEqual(events, ["background_import:started"]);
+ release();
+ assert.equal(await blocker.promise, "blocker");
+ assert.equal(await laterInteractive.promise, "interactive");
+ assert.equal(events[0], "background_import:started");
+ assert.ok(events.includes("interactive:started"));
+ assert.ok(events.indexOf("background_import:started") < events.indexOf("interactive:started"));
+});
+
+test("same-priority work stays FIFO and queued cancel prevents execution", async () => {
+ const scheduler = createAnalysisScheduler({ concurrency: 1, agingMs: 10 });
+ const starts = [];
+ let release;
+
+ const blocker = scheduler.schedule(async () => {
+ starts.push("blocker:start");
+ await new Promise((resolve) => { release = resolve; });
+ }, { priority: "user_batch" });
+
+ await delay(5);
+ const first = scheduler.schedule(async () => {
+ starts.push("first");
+ return "first";
+ }, { priority: "user_batch" });
+ const second = scheduler.schedule(async () => {
+ starts.push("second");
+ return "second";
+ }, { priority: "user_batch" });
+
+ assert.equal(second.cancel(), true);
+ release();
+ await blocker.promise;
+ assert.equal(await first.promise, "first");
+ await assert.rejects(() => second.promise, /取消/);
+ assert.deepEqual(starts, ["blocker:start", "first"]);
+});
+
+test("aging lets a long-waiting lower-priority task overtake a newer higher-priority task", async () => {
+ const scheduler = createAnalysisScheduler({ concurrency: 1, agingMs: 10 });
+ const starts = [];
+ let release;
+
+ const blocker = scheduler.schedule(async () => {
+ starts.push("blocker:start");
+ await new Promise((resolve) => { release = resolve; });
+ }, { priority: "interactive" });
+
+ await delay(5);
+ const background = scheduler.schedule(async () => {
+ starts.push("background_import");
+ return "background";
+ }, { priority: "background_import" });
+
+ await delay(25);
+ const userBatch = scheduler.schedule(async () => {
+ starts.push("user_batch");
+ return "user";
+ }, { priority: "user_batch" });
+
+ release();
+ await blocker.promise;
+ assert.equal(await background.promise, "background");
+ assert.equal(await userBatch.promise, "user");
+ assert.deepEqual(starts, ["blocker:start", "background_import", "user_batch"]);
+});
+
+test("the production shared provider queue starts interactive work before queued background imports", async () => {
+ const starts = [];
+ const releases = [];
+ const blockers = [0, 1].map((index) => scheduleAnalysis("shared-priority", 2, async () => {
+ starts.push(`blocker:${index}`);
+ await new Promise((resolve) => releases.push(resolve));
+ }, { priority: "background_import" }));
+ await delay(0);
+ const background = scheduleAnalysis("shared-priority", 2, async () => {
+ starts.push("queued-background");
+ }, { priority: "background_import" });
+ const interactive = scheduleAnalysis("shared-priority", 2, async () => {
+ starts.push("interactive");
+ }, { priority: "interactive" });
+
+ releases.shift()();
+ await delay(0);
+ assert.equal(starts[2], "interactive");
+ releases.shift()();
+ await Promise.all([...blockers, background, interactive]);
+ assert.deepEqual(starts.slice(2), ["interactive", "queued-background"]);
+});
diff --git a/test/analysis-task-background.test.js b/test/analysis-task-background.test.js
new file mode 100644
index 0000000..d406c80
--- /dev/null
+++ b/test/analysis-task-background.test.js
@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+const background = await readFile(new URL("../background.js", import.meta.url), "utf8");
+
+test("background exposes the persisted Composer analysis task protocol and retires the direct paid entry point", () => {
+ for (const type of [
+ "START_OR_JOIN_ANALYSIS_TASK",
+ "GET_ANALYSIS_TASK",
+ "DETACH_ANALYSIS_CONSUMER",
+ "STOP_ANALYSIS_TASK",
+ "RETRY_ANALYSIS_TASK"
+ ]) assert.match(background, new RegExp(`case \\"${type}\\"`));
+ assert.doesNotMatch(background, /case "ANALYZE_TEMP_REFERENCES"/);
+ assert.match(background, /execution_state_unknown/);
+ assert.match(background, /confirmDuplicateCharge/);
+ assert.match(background, /ANALYSIS_TASK_UPDATED/);
+});
+
+test("temporary-reference analysis checks the active Attempt again before writing session results", () => {
+ const action = background.slice(
+ background.indexOf("async function analyzeTempReferencesAction"),
+ background.indexOf("async function getTempReferenceVisionBlob")
+ );
+ assert.match(action, /analysisTaskAttemptIsActive/);
+ assert.match(action, /priority/);
+});
+
+test("analysis runner ownership is always released when settlement persistence fails", () => {
+ const runner = background.slice(
+ background.indexOf("async function runAnalysisTask"),
+ background.indexOf("async function recoverAnalysisTasks")
+ );
+ assert.match(runner, /finally\s*\{\s*analysisTaskRunners\.delete\(taskId\)/);
+});
diff --git a/test/analysis-task-registry.test.js b/test/analysis-task-registry.test.js
new file mode 100644
index 0000000..ab0fb38
--- /dev/null
+++ b/test/analysis-task-registry.test.js
@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+ createOrJoinAnalysisTask,
+ detachAnalysisTaskConsumer,
+ recoverInterruptedAnalysisTasks,
+ replaceAnalysisTask
+} from "../analysis-task-registry.js";
+import { startAnalysisAttempt } from "../analysis-tasks.js";
+
+const request = {
+ sessionId: "session:one",
+ tempReferenceIds: ["reference:one", "reference:one"],
+ outputLocale: "zh-CN",
+ priority: "interactive",
+ consumerId: "consumer:one",
+ clientRequestId: "request:one"
+};
+
+test("the same client request joins one persisted task instead of creating duplicate paid work", () => {
+ const first = createOrJoinAnalysisTask({}, request, {
+ taskId: "task:one",
+ now: "2026-08-26T00:00:00.000Z"
+ });
+ const second = createOrJoinAnalysisTask(first.state, request, {
+ taskId: "task:must-not-exist",
+ now: "2026-08-26T00:00:01.000Z"
+ });
+
+ assert.equal(first.created, true);
+ assert.equal(second.created, false);
+ assert.equal(second.task.id, "task:one");
+ assert.equal(second.state.items.length, 1);
+ assert.deepEqual(second.task.request.tempReferenceIds, ["reference:one"]);
+});
+
+test("detaching removes only the consumer and leaves the running task intact", () => {
+ const created = createOrJoinAnalysisTask({}, request, { taskId: "task:detach" });
+ const running = startAnalysisAttempt(created.task, { attemptId: "attempt:detach" });
+ const state = replaceAnalysisTask(created.state, running);
+ const detached = detachAnalysisTaskConsumer(state, "task:detach", "consumer:one");
+
+ assert.equal(detached.task.status, "running");
+ assert.deepEqual(detached.task.consumerIds, []);
+});
+
+test("detaching can resolve a task by clientRequestId before the start response returns", () => {
+ const created = createOrJoinAnalysisTask({}, request, { taskId: "task:early-close" });
+ const detached = detachAnalysisTaskConsumer(
+ created.state,
+ "",
+ "consumer:one",
+ "request:one"
+ );
+
+ assert.equal(detached.task.id, "task:early-close");
+ assert.deepEqual(detached.task.consumerIds, []);
+});
+
+test("service-worker recovery marks running execution unknown and never queues it again", () => {
+ const created = createOrJoinAnalysisTask({}, request, { taskId: "task:recover" });
+ const running = startAnalysisAttempt(created.task, { attemptId: "attempt:recover" });
+ const recovered = recoverInterruptedAnalysisTasks(replaceAnalysisTask(created.state, running), {
+ now: "2026-08-26T00:01:00.000Z"
+ });
+
+ assert.equal(recovered.items[0].status, "stopped");
+ assert.equal(recovered.items[0].executionState, "execution_state_unknown");
+ assert.equal(recovered.items[0].attempts[0].status, "execution_state_unknown");
+});
diff --git a/test/analysis-task.test.js b/test/analysis-task.test.js
new file mode 100644
index 0000000..9487cfe
--- /dev/null
+++ b/test/analysis-task.test.js
@@ -0,0 +1,112 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+ applyAnalysisAttemptWrite,
+ cancelQueuedAnalysisTask,
+ completeAnalysisAttempt,
+ createAnalysisTask,
+ failAnalysisAttempt,
+ restartRunningAnalysisTask,
+ retryAnalysisAttempt,
+ stopAnalysisTask,
+ startAnalysisAttempt
+} from "../analysis-tasks.js";
+
+test("queued analysis tasks can be canceled before any execution attempt exists", () => {
+ const task = createAnalysisTask({ id: "task-queued", priority: "interactive", now: "2026-08-26T00:00:00.000Z" });
+ const canceled = cancelQueuedAnalysisTask(task, { now: "2026-08-26T00:00:01.000Z" });
+
+ assert.equal(canceled.status, "canceled");
+ assert.equal(canceled.executionState, "canceled");
+ assert.equal(canceled.attempts.length, 0);
+ assert.throws(
+ () => startAnalysisAttempt(canceled, { attemptId: "attempt:late", now: "2026-08-26T00:00:02.000Z" }),
+ /任务已经结束/
+ );
+});
+
+test("running analysis restart leaves execution state unknown until an explicit new Attempt is started", () => {
+ let task = createAnalysisTask({ id: "task-running" });
+ task = startAnalysisAttempt(task, { attemptId: "attempt:one", now: "2026-08-26T00:00:00.000Z" });
+ task = restartRunningAnalysisTask(task, { now: "2026-08-26T00:00:05.000Z" });
+
+ assert.equal(task.status, "stopped");
+ assert.equal(task.executionState, "execution_state_unknown");
+ assert.equal(task.attempts.length, 1);
+ assert.equal(task.attempts[0].status, "execution_state_unknown");
+
+ task = startAnalysisAttempt(task, { attemptId: "attempt:two", now: "2026-08-26T00:00:06.000Z" });
+
+ assert.equal(task.status, "running");
+ assert.equal(task.executionState, "running");
+ assert.equal(task.attempts.length, 2);
+ assert.equal(task.attempts[1].id, "attempt:two");
+ assert.equal(task.attempts[1].status, "running");
+});
+
+test("stale writes from an abandoned attempt are rejected after a restart", () => {
+ let task = createAnalysisTask({ id: "task-write" });
+ task = startAnalysisAttempt(task, { attemptId: "attempt:one" });
+ task = restartRunningAnalysisTask(task);
+ task = startAnalysisAttempt(task, { attemptId: "attempt:two" });
+
+ assert.throws(
+ () => applyAnalysisAttemptWrite(task, { attemptId: "attempt:one", result: { ok: true } }),
+ /失效|stale|重新发起/
+ );
+
+ const updated = applyAnalysisAttemptWrite(task, {
+ attemptId: "attempt:two",
+ result: { ok: true }
+ });
+
+ assert.deepEqual(updated.attempts[1].result, { ok: true });
+ assert.equal(updated.attempts[1].writeCount, 1);
+});
+
+test("an explicit retry creates a new Attempt after failure while the old Attempt stays immutable", () => {
+ let task = createAnalysisTask({ id: "task-retry" });
+ task = startAnalysisAttempt(task, { attemptId: "attempt:one" });
+ task = failAnalysisAttempt(task, { attemptId: "attempt:one", error: "provider failed" });
+
+ assert.throws(() => retryAnalysisAttempt(task, { attemptId: "attempt:two", confirmed: false }), /确认/);
+ task = retryAnalysisAttempt(task, { attemptId: "attempt:two", confirmed: true });
+
+ assert.equal(task.activeAttemptId, "attempt:two");
+ assert.equal(task.attemptCount, 2);
+ assert.equal(task.attempts[0].status, "failed");
+ assert.equal(task.attempts[1].status, "running");
+ assert.throws(() => completeAnalysisAttempt(task, { attemptId: "attempt:one", result: { stale: true } }), /失效|stale/);
+});
+
+test("stop distinguishes a free queued cancel from a running request whose provider may have accepted it", () => {
+ const queued = stopAnalysisTask(createAnalysisTask({ id: "task-queued-stop" }));
+ assert.equal(queued.status, "stopped");
+ assert.equal(queued.executionState, "canceled");
+ assert.equal(queued.providerMayHaveAccepted, false);
+
+ let running = createAnalysisTask({ id: "task-running-stop" });
+ running = startAnalysisAttempt(running, { attemptId: "attempt:running" });
+ running = stopAnalysisTask(running);
+ assert.equal(running.status, "stopped");
+ assert.equal(running.executionState, "canceled");
+ assert.equal(running.providerMayHaveAccepted, true);
+ assert.equal(running.activeAttemptId, "");
+ assert.equal(running.attempts[0].status, "canceled");
+ assert.throws(() => applyAnalysisAttemptWrite(running, { attemptId: "attempt:running", result: {} }), /失效|stale/);
+});
+
+test("only the active running Attempt can complete or fail a task", () => {
+ let completed = createAnalysisTask({ id: "task-complete" });
+ completed = startAnalysisAttempt(completed, { attemptId: "attempt:complete" });
+ completed = completeAnalysisAttempt(completed, { attemptId: "attempt:complete", result: { ok: true } });
+ assert.equal(completed.status, "completed");
+ assert.deepEqual(completed.attempts[0].result, { ok: true });
+
+ let failed = createAnalysisTask({ id: "task-fail" });
+ failed = startAnalysisAttempt(failed, { attemptId: "attempt:fail" });
+ failed = failAnalysisAttempt(failed, { attemptId: "attempt:fail", error: "bad output" });
+ assert.equal(failed.status, "failed");
+ assert.equal(failed.attempts[0].error, "bad output");
+});
diff --git a/test/composer-analysis-task-bridge.test.js b/test/composer-analysis-task-bridge.test.js
new file mode 100644
index 0000000..2a681d2
--- /dev/null
+++ b/test/composer-analysis-task-bridge.test.js
@@ -0,0 +1,218 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createComposerAnalysisTaskBridge } from "../composer-analysis-task-bridge.js";
+
+test("closing while task creation is pending detaches the consumer and rejects late automatic continuation", async () => {
+ const messages = [];
+ let finishStart;
+ const startResponse = new Promise((resolve) => { finishStart = resolve; });
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:one", "request:one"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async (message) => {
+ messages.push(structuredClone(message));
+ if (message.type === "START_OR_JOIN_ANALYSIS_TASK") return startResponse;
+ return { ok: true };
+ }
+ });
+
+ const starting = bridge.start({ sessionId: "session:one", tempReferenceIds: ["reference:one"] });
+ await Promise.resolve();
+ await bridge.detach();
+ finishStart({
+ ok: true,
+ task: { id: "task:one", status: "completed", executionState: "completed", activeAttemptId: "attempt:one" },
+ attemptId: "attempt:one",
+ result: { ok: true, session: { id: "session:one" } }
+ });
+ await starting;
+
+ assert.deepEqual(messages.map((message) => message.type), [
+ "START_OR_JOIN_ANALYSIS_TASK",
+ "DETACH_ANALYSIS_CONSUMER"
+ ]);
+ assert.equal(bridge.snapshot().attached, false);
+ assert.equal(bridge.consumeCompletion(), null);
+});
+
+test("a detached consumer rejects later task push updates", async () => {
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:detached", "request:detached"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async (message) => {
+ if (message.type === "START_OR_JOIN_ANALYSIS_TASK") {
+ return {
+ ok: true,
+ task: { id: "task:detached", status: "running", executionState: "running", activeAttemptId: "attempt:detached" },
+ attemptId: "attempt:detached"
+ };
+ }
+ return { ok: true };
+ }
+ });
+
+ await bridge.start({ sessionId: "session:detached", tempReferenceIds: ["reference:detached"] });
+ await bridge.detach();
+
+ assert.equal(bridge.acceptUpdate({
+ task: { id: "task:detached", status: "completed", executionState: "completed", activeAttemptId: "attempt:detached" },
+ attemptId: "attempt:detached",
+ result: { value: "must-not-be-consumed" }
+ }), false);
+ assert.equal(bridge.consumeCompletion(), null);
+});
+
+test("a rejected task command is surfaced instead of leaving a false running state", async () => {
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:rejected", "request:rejected"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async () => ({ ok: false, message: "任务协议尚未接线" })
+ });
+
+ await assert.rejects(
+ () => bridge.start({ sessionId: "session:rejected", tempReferenceIds: ["reference:rejected"] }),
+ /任务协议尚未接线/
+ );
+ assert.equal(bridge.consumeCompletion(), null);
+});
+
+test("stopping a queued interactive task cancels automatic continuation through a distinct stop message", async () => {
+ const messages = [];
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:queued", "request:queued"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async (message) => {
+ messages.push(structuredClone(message));
+ if (message.type === "START_OR_JOIN_ANALYSIS_TASK") {
+ return {
+ ok: true,
+ task: { id: "task:queued", status: "queued", executionState: "queued", activeAttemptId: "" }
+ };
+ }
+ return {
+ ok: true,
+ task: { id: "task:queued", status: "stopped", executionState: "canceled", activeAttemptId: "" }
+ };
+ }
+ });
+
+ await bridge.start({ sessionId: "session:queued", tempReferenceIds: ["reference:one", "reference:one"] });
+ await bridge.stop();
+
+ assert.deepEqual(messages, [
+ {
+ type: "START_OR_JOIN_ANALYSIS_TASK",
+ priority: "interactive",
+ consumerId: "consumer:queued",
+ clientRequestId: "request:queued",
+ sessionId: "session:queued",
+ tempReferenceIds: ["reference:one"],
+ outputLocale: "zh-CN"
+ },
+ {
+ type: "STOP_ANALYSIS_TASK",
+ taskId: "task:queued",
+ consumerId: "consumer:queued",
+ clientRequestId: "request:queued"
+ }
+ ]);
+ assert.equal(bridge.snapshot().attached, false);
+ assert.equal(bridge.snapshot().status, "stopped");
+ assert.equal(bridge.consumeCompletion(), null);
+});
+
+test("a lost stop acknowledgement becomes unknown and requires explicit retry confirmation", async () => {
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:stop-lost", "request:stop-lost"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async (message) => {
+ if (message.type === "START_OR_JOIN_ANALYSIS_TASK") {
+ return {
+ ok: true,
+ task: { id: "task:stop-lost", status: "running", executionState: "running", activeAttemptId: "attempt:stop-lost" },
+ attemptId: "attempt:stop-lost"
+ };
+ }
+ throw new Error("停止回执丢失");
+ }
+ });
+
+ await bridge.start({ sessionId: "session:stop-lost", tempReferenceIds: ["reference:stop-lost"] });
+ await assert.rejects(() => bridge.stop(), /停止回执丢失/);
+
+ assert.equal(bridge.snapshot().attached, false);
+ assert.equal(bridge.snapshot().executionState, "execution_state_unknown");
+ assert.equal(bridge.snapshot().canRetry, true);
+ await assert.rejects(() => bridge.retry({ confirmed: false }), /确认.*再次计费/);
+});
+
+test("unknown execution state retries only after confirmation and rejects the abandoned Attempt result", async () => {
+ const messages = [];
+ const bridge = createComposerAnalysisTaskBridge({
+ createId: (() => {
+ const ids = ["consumer:one", "request:one", "consumer:two", "request:two"];
+ return () => ids.shift();
+ })(),
+ sendMessage: async (message) => {
+ messages.push(structuredClone(message));
+ if (message.type === "START_OR_JOIN_ANALYSIS_TASK") {
+ return {
+ ok: true,
+ task: { id: "task:one", status: "running", executionState: "running", activeAttemptId: "attempt:one" },
+ attemptId: "attempt:one"
+ };
+ }
+ if (message.type === "GET_ANALYSIS_TASK") {
+ return {
+ ok: true,
+ task: { id: "task:one", status: "failed", executionState: "execution_state_unknown", activeAttemptId: "" },
+ attemptId: "attempt:one"
+ };
+ }
+ return {
+ ok: true,
+ task: { id: "task:one", status: "running", executionState: "running", activeAttemptId: "attempt:two" },
+ attemptId: "attempt:two"
+ };
+ }
+ });
+
+ await bridge.start({ sessionId: "session:one", tempReferenceIds: ["reference:one"], outputLocale: "en" });
+ await bridge.refresh();
+ assert.equal(bridge.snapshot().executionState, "execution_state_unknown");
+ assert.equal(bridge.snapshot().canRetry, true);
+ assert.deepEqual(messages.map((message) => message.type), ["START_OR_JOIN_ANALYSIS_TASK", "GET_ANALYSIS_TASK"]);
+
+ await assert.rejects(() => bridge.retry({ confirmed: false }), /确认.*再次计费/);
+ await bridge.retry({ confirmed: true });
+ assert.equal(messages.at(-1).type, "RETRY_ANALYSIS_TASK");
+ assert.equal(messages.at(-1).previousAttemptId, "attempt:one");
+ assert.equal(messages.at(-1).confirmDuplicateCharge, true);
+ assert.equal(bridge.snapshot().attemptId, "attempt:two");
+
+ assert.equal(bridge.acceptUpdate({
+ task: { id: "task:one", status: "completed", executionState: "completed", activeAttemptId: "attempt:one" },
+ attemptId: "attempt:one",
+ result: { value: "old" }
+ }), false);
+ assert.equal(bridge.consumeCompletion(), null);
+
+ assert.equal(bridge.acceptUpdate({
+ task: { id: "task:one", status: "completed", executionState: "completed", activeAttemptId: "attempt:two" },
+ attemptId: "attempt:two",
+ result: { value: "new" }
+ }), true);
+ assert.deepEqual(bridge.consumeCompletion(), { value: "new" });
+ assert.equal(bridge.consumeCompletion(), null);
+});
diff --git a/test/composer-page.test.js b/test/composer-page.test.js
index 1faf6d5..27e3a44 100644
--- a/test/composer-page.test.js
+++ b/test/composer-page.test.js
@@ -152,7 +152,12 @@ test("composer temporary references share one attachment entry and block text-on
assert.match(composerJs, /type:\s*"ADD_TEMP_REFERENCES"/);
assert.match(composerJs, /type:\s*"REMOVE_TEMP_REFERENCE"/);
assert.match(composerJs, /type:\s*"SAVE_TEMP_REFERENCE_AS_CASE"/);
- assert.match(composerJs, /type:\s*"ANALYZE_TEMP_REFERENCES"/);
+ assert.match(composerJs, /createComposerAnalysisTaskBridge/);
+ assert.match(composerJs, /detachBlockedReferenceAnalysis/);
+ assert.match(composerJs, /stopBlockedReferenceAnalysis/);
+ assert.match(composerJs, /retryBlockedReferenceAnalysis/);
+ assert.doesNotMatch(composerJs, /type:\s*"ANALYZE_TEMP_REFERENCES"/);
+ assert.doesNotMatch(composerJs, /if \(imageAnalysisPending\) event\.preventDefault\(\)/);
assert.match(composerJs, /composerPasteFiles\(event\.clipboardData\)/);
assert.match(composerJs, /if \(!files\.length\) return;\s*event\.preventDefault\(\)/s);
const sendTurn = composerJs.slice(composerJs.indexOf("async function sendComposerTurn"), composerJs.indexOf("async function retryComposerTurn"));
diff --git a/test/composer.test.js b/test/composer.test.js
index d16e3bc..b2e6d3a 100644
--- a/test/composer.test.js
+++ b/test/composer.test.js
@@ -295,6 +295,22 @@ test("image reference modes default to conditioned and unlock text-only modes fo
imageReferenceMode: "text_only"
}).imageReferenceMode, "conditioned");
+ const legacyDescription = imageReferenceModeAvailability([{
+ entryId: "legacy-described-image",
+ alias: "@参考旧图",
+ referenceKind: "vision",
+ referenceText: "一座被薄雾包围的古代庭院,青绿色冷光。",
+ imageRefs: [{ visualId: "image-v1", mimeType: "image/webp" }],
+ assets: [{
+ assetId: "image-v1",
+ analysisVersion: 1,
+ imageFingerprint: "a".repeat(64),
+ analysisImageFingerprint: "a".repeat(64),
+ reconstructionPrompt: ""
+ }]
+ }]);
+ assert.deepEqual(legacyDescription, { canDisableImages: true, missingAssetIds: [] });
+
const mixed = imageReferenceModeAvailability([
promptBackedReference,
{
diff --git a/test/data-safety-ui.test.js b/test/data-safety-ui.test.js
index 29a6f9d..dfd2efa 100644
--- a/test/data-safety-ui.test.js
+++ b/test/data-safety-ui.test.js
@@ -77,6 +77,7 @@ test("share-package import is separate from the two backup actions while sync st
test("share-package import preserves local configuration and accepts historical package versions", async () => {
const library = await readFile(new URL("../library.js", import.meta.url), "utf8");
const parser = await readFile(new URL("../library-package.js", import.meta.url), "utf8");
+ const migrations = await readFile(new URL("../library-package-migrations.js", import.meta.url), "utf8");
const format = await readFile(new URL("../library-package-format.js", import.meta.url), "utf8");
const action = library.slice(
library.indexOf("async function importSharedLibraryPackage"),
@@ -85,7 +86,8 @@ test("share-package import preserves local configuration and accepts historical
assert.match(action, /PREVIEW_LIBRARY_IMPORT/);
assert.match(action, /APPLY_LIBRARY_IMPORT/);
assert.equal((action.match(/preserveLibraryConfiguration:\s*true/g) ?? []).length, 2);
- assert.match(parser, /isSupportedLibraryPackageVersion\(value\.version\)/);
+ assert.match(parser, /prepareLibraryPackageDraft\(value\)/);
+ assert.match(migrations, /isSupportedLibraryPackageVersion\(value\.version\)/);
assert.match(format, /SUPPORTED_LIBRARY_PACKAGE_VERSIONS\s*=\s*Object\.freeze\(\[1, 2, 3, 4, 5\]\)/);
});
@@ -100,3 +102,14 @@ test("data safety cannot be dismissed accidentally while a storage operation is
assert.match(bindings, /dataSafetyOperationActive[^\n]*event\.preventDefault\(\)/);
assert.match(library, /elements\.settingsClose\.disabled\s*=\s*active/);
});
+
+test("folder backup self-check covers project and media trash snapshots plus their relationships", async () => {
+ const library = await readFile(new URL("../library.js", import.meta.url), "utf8");
+ const roundtrip = library.slice(
+ library.indexOf("function assertFolderBackupRoundtrip"),
+ library.indexOf("async function localAssetReferenceBackupBlob")
+ );
+ assert.match(roundtrip, /expected\.kind === "collection"/);
+ assert.match(roundtrip, /expected\.kind === "media"/);
+ assert.match(roundtrip, /expected\.relationships/);
+});
diff --git a/test/e2e_support.py b/test/e2e_support.py
index 159a590..17cadca 100644
--- a/test/e2e_support.py
+++ b/test/e2e_support.py
@@ -11,7 +11,10 @@ from typing import Iterator
from playwright.sync_api import BrowserContext, Page, Playwright, sync_playwright
-EXTENSION_DIR = Path(__file__).resolve().parents[1]
+SOURCE_EXTENSION_DIR = Path(__file__).resolve().parents[1]
+EXTENSION_DIR = Path(
+ os.environ.get("PROMPTDIRECTOR_E2E_EXTENSION_DIR", str(SOURCE_EXTENSION_DIR))
+).resolve()
AI_TASK_IDS = (
"textTags",
"skillExtraction",
diff --git a/test/fixtures/compat/provenance.json b/test/fixtures/compat/provenance.json
new file mode 100644
index 0000000..ea9dd26
--- /dev/null
+++ b/test/fixtures/compat/provenance.json
@@ -0,0 +1,35 @@
+{
+ "description": "Deterministic compatibility fixtures reconstructed from retained release code. They are not copies of the user's unavailable failure archives.",
+ "packages": {
+ "v1": {
+ "provenanceType": "reconstructed-from-earliest-retained-import-contract",
+ "sourceCommit": "e57b4d9",
+ "sourceRelease": "1.18.4",
+ "originalFailureArchive": false
+ },
+ "v2": {
+ "provenanceType": "reconstructed-from-earliest-retained-import-contract",
+ "sourceCommit": "e57b4d9",
+ "sourceRelease": "1.18.4",
+ "originalFailureArchive": false
+ },
+ "v3": {
+ "provenanceType": "reconstructed-from-release-code",
+ "sourceCommit": "e57b4d9",
+ "sourceRelease": "1.18.4",
+ "originalFailureArchive": false
+ },
+ "v4": {
+ "provenanceType": "reconstructed-from-release-code",
+ "sourceCommit": "2d68026",
+ "sourceRelease": "1.18.13",
+ "originalFailureArchive": false
+ },
+ "v5": {
+ "provenanceType": "reconstructed-from-release-code",
+ "sourceCommit": "d129daa",
+ "sourceRelease": "1.19.0",
+ "originalFailureArchive": false
+ }
+ }
+}
diff --git a/test/fixtures/compat/v1/library.json b/test/fixtures/compat/v1/library.json
new file mode 100644
index 0000000..e6b59c4
--- /dev/null
+++ b/test/fixtures/compat/v1/library.json
@@ -0,0 +1,15 @@
+{
+ "format": "prompt-case-library",
+ "version": 1,
+ "schemaVersion": 5,
+ "entries": [{
+ "id": "fixture:v1",
+ "schemaVersion": 5,
+ "title": "Reconstructed v1 case",
+ "text": "v1 prompt",
+ "savedAt": "2026-01-01T00:00:00.000Z",
+ "hasScreenshot": true,
+ "screenshotPath": "images/fixture-v1.webp",
+ "screenshotMimeType": "image/webp"
+ }]
+}
diff --git a/test/fixtures/compat/v2/library.json b/test/fixtures/compat/v2/library.json
new file mode 100644
index 0000000..d8b7ed5
--- /dev/null
+++ b/test/fixtures/compat/v2/library.json
@@ -0,0 +1,18 @@
+{
+ "format": "prompt-case-library",
+ "version": 2,
+ "schemaVersion": 5,
+ "entries": [{
+ "id": "fixture:v2",
+ "schemaVersion": 5,
+ "title": "Reconstructed v2 case",
+ "text": "v2 prompt",
+ "savedAt": "2026-01-02T00:00:00.000Z",
+ "visuals": [{
+ "id": "fixture:v2:image",
+ "screenshotPath": "images/fixture-v2.webp",
+ "mimeType": "image/webp"
+ }],
+ "primaryVisualId": "fixture:v2:image"
+ }]
+}
diff --git a/test/fixtures/compat/v3/library.json b/test/fixtures/compat/v3/library.json
new file mode 100644
index 0000000..fe03b60
--- /dev/null
+++ b/test/fixtures/compat/v3/library.json
@@ -0,0 +1,22 @@
+{
+ "format": "prompt-case-library",
+ "version": 3,
+ "schemaVersion": 5,
+ "entries": [{
+ "id": "fixture:v3",
+ "schemaVersion": 5,
+ "title": "Reconstructed v3 case",
+ "text": "v3 prompt",
+ "savedAt": "2026-01-03T00:00:00.000Z",
+ "mediaAssets": [{
+ "id": "fixture:v3:image",
+ "kind": "image",
+ "storageMode": "managed",
+ "assetPath": "images/fixture-v3.webp",
+ "sourceFormat": "webp",
+ "mimeType": "image/webp",
+ "byteSize": 5
+ }],
+ "primaryMediaId": "fixture:v3:image"
+ }]
+}
diff --git a/test/fixtures/compat/v4/library.json b/test/fixtures/compat/v4/library.json
new file mode 100644
index 0000000..ec35738
--- /dev/null
+++ b/test/fixtures/compat/v4/library.json
@@ -0,0 +1,22 @@
+{
+ "format": "prompt-case-library",
+ "version": 4,
+ "schemaVersion": 24,
+ "entries": [{
+ "id": "fixture:v4",
+ "schemaVersion": 24,
+ "title": "Reconstructed v4 case",
+ "text": "v4 prompt",
+ "savedAt": "2026-01-04T00:00:00.000Z",
+ "mediaAssets": [{
+ "id": "fixture:v4:image",
+ "kind": "image",
+ "storageMode": "managed",
+ "assetPath": "images/fixture-v4.jpg",
+ "sourceFormat": "jpeg",
+ "mimeType": "image/jpeg",
+ "byteSize": 5
+ }],
+ "primaryMediaId": "fixture:v4:image"
+ }]
+}
diff --git a/test/fixtures/compat/v5/library.json b/test/fixtures/compat/v5/library.json
new file mode 100644
index 0000000..30e268d
--- /dev/null
+++ b/test/fixtures/compat/v5/library.json
@@ -0,0 +1,32 @@
+{
+ "format": "prompt-case-library",
+ "version": 5,
+ "schemaVersion": 27,
+ "organizerState": {
+ "version": 7,
+ "collections": [{
+ "id": "fixture:v5:project",
+ "name": "Reconstructed project",
+ "parentId": null,
+ "order": 0,
+ "entryIds": ["fixture:v5"]
+ }]
+ },
+ "entries": [{
+ "id": "fixture:v5",
+ "schemaVersion": 27,
+ "title": "Reconstructed v5 case",
+ "text": "v5 prompt",
+ "savedAt": "2026-01-05T00:00:00.000Z",
+ "mediaAssets": [{
+ "id": "fixture:v5:image",
+ "kind": "image",
+ "storageMode": "managed",
+ "assetPath": "images/fixture-v5.webp",
+ "sourceFormat": "webp",
+ "mimeType": "image/webp",
+ "byteSize": 5
+ }],
+ "primaryMediaId": "fixture:v5:image"
+ }]
+}
diff --git a/test/historical_zip_salvage_e2e.py b/test/historical_zip_salvage_e2e.py
new file mode 100644
index 0000000..cc2dd3d
--- /dev/null
+++ b/test/historical_zip_salvage_e2e.py
@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import base64
+import json
+import tempfile
+import zipfile
+from pathlib import Path
+
+from playwright.sync_api import expect
+
+from e2e_support import extension_session
+
+
+GOOD_PNG = base64.b64decode(
+ "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="
+)
+BAD_PNG = b"not-a-real-png"
+
+
+def entry(entry_id: str, title: str, text: str, asset_id: str, path: str, byte_size: int, schema: int) -> dict:
+ return {
+ "id": entry_id,
+ "schemaVersion": schema,
+ "title": title,
+ "text": text,
+ "savedAt": "2026-08-26T00:00:00.000Z",
+ "classification": {"pathIds": [], "status": "needs_review", "source": "auto"},
+ "facetAssignments": [],
+ "mediaAssets": [{
+ "id": asset_id,
+ "kind": "image",
+ "storageMode": "managed",
+ "assetPath": path,
+ "sourceFormat": "png",
+ "mimeType": "image/png",
+ "byteSize": byte_size,
+ }],
+ "primaryMediaId": asset_id,
+ }
+
+
+def main() -> None:
+ with tempfile.TemporaryDirectory(prefix="prompt-director-broken-zip-") as temporary:
+ archive_path = Path(temporary) / "historical-broken-share.zip"
+ with extension_session("prompt-director-broken-zip-") as session:
+ setup = session.open_page("collector.html")
+ schema = setup.evaluate("async () => (await import(chrome.runtime.getURL('taxonomy.js'))).SCHEMA_VERSION")
+ package = {
+ "format": "prompt-case-library",
+ "version": 5,
+ "schemaVersion": schema,
+ "organizerState": {"version": 7, "collections": []},
+ "entries": [
+ entry("case:missing", "缺失素材但正文完好", "这段正文必须保留。", "image:missing", "images/missing.png", 5, schema),
+ entry("case:damaged", "图片字节损坏但正文完好", "这段正文也必须保留。", "image:damaged", "images/damaged.png", len(BAD_PNG), schema),
+ entry("case:good", "完整案例", "有效图片与正文。", "image:good", "images/good.png", len(GOOD_PNG), schema),
+ ],
+ }
+ with zipfile.ZipFile(archive_path, "w", compression=zipfile.ZIP_STORED) as archive:
+ archive.writestr("library.json", json.dumps(package, ensure_ascii=False))
+ archive.writestr("images/damaged.png", BAD_PNG)
+ archive.writestr("images/good.png", GOOD_PNG)
+
+ library = session.open_page("library.html", wait_until="networkidle")
+ library.locator("#library-package-file").set_input_files(str(archive_path))
+ dialog = library.locator("#promptdirector-app-dialog")
+ expect(dialog).to_be_visible(timeout=10_000)
+ expect(dialog).to_contain_text("可导入 3 个新案例")
+ expect(dialog).to_contain_text("丢弃损坏或缺失的媒体 2 项")
+ dialog.locator("button[type='submit']").click()
+ expect(library.locator("#data-safety-feedback")).to_contain_text("分享包媒体已校验", timeout=10_000)
+
+ restored = library.evaluate(
+ """async () => {
+ const state = await chrome.runtime.sendMessage({type: 'GET_STATE'});
+ const media = await import(chrome.runtime.getURL('media-store.js'));
+ return {
+ entries: state.entries.map((entry) => ({
+ id: entry.id,
+ text: entry.text,
+ mediaIds: (entry.mediaAssets || []).map((asset) => asset.id)
+ })).sort((left, right) => left.id.localeCompare(right.id)),
+ goodBytes: (await media.getMediaBlob('image:good'))?.size || 0,
+ damagedBytes: (await media.getMediaBlob('image:damaged'))?.size || 0
+ };
+ }"""
+ )
+ assert [item["id"] for item in restored["entries"]] == ["case:damaged", "case:good", "case:missing"], restored
+ assert restored["entries"][0]["mediaIds"] == [] and restored["entries"][0]["text"], restored
+ assert restored["entries"][1]["mediaIds"] == ["image:good"], restored
+ assert restored["entries"][2]["mediaIds"] == [] and restored["entries"][2]["text"], restored
+ assert restored["goodBytes"] == len(GOOD_PNG) and restored["damagedBytes"] == 0, restored
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/import-ui.test.js b/test/import-ui.test.js
index 8b161f0..da25e70 100644
--- a/test/import-ui.test.js
+++ b/test/import-ui.test.js
@@ -116,6 +116,7 @@ test("duplicate choice and import start preserve the complete background job con
assert.match(js, /stagedAssetId:\s*item\.id/);
assert.match(js, /keepDuplicate:\s*item\.keepDuplicate\s*===\s*true/);
assert.match(js, /options:\s*\{\s*autoAnalyze:\s*elements\.importAutoAnalyze\.checked\s*===\s*true\s*\}/);
+ assert.match(js, /elements\.importAutoAnalyze\.checked\s*=\s*false/);
});
test("project suggestions stay editable and import uses the shared multi-tag editor", () => {
@@ -154,3 +155,28 @@ test("active import restoration and every terminal job action stay wired", () =>
assert.match(js, /importLastJob\.hidden\s*=\s*!latestImportJob/);
assert.match(js, /selectedCollectionId\s*=\s*collectionId;[\s\S]*?renderGallery\(\);[\s\S]*?importDialog\.close\(\)/);
});
+
+test("folder restore and ZIP import retry one response loss with the same operation receipt", () => {
+ assert.match(js, /function createLibraryImportOperationId/);
+ assert.match(js, /async function applyLibraryImportWithReceipt/);
+ assert.equal(js.match(/const operationId\s*=\s*createLibraryImportOperationId\(\)/g)?.length, 2);
+ assert.equal(js.match(/applyLibraryImportWithReceipt\(\{[\s\S]{0,180}?operationId,/g)?.length, 2);
+ assert.match(js, /await chrome\.runtime\.sendMessage\(message\)[\s\S]*await chrome\.runtime\.sendMessage\(message\)/);
+});
+
+test("shared ZIP import salvages individual media failures while complete folder restore stays strict", () => {
+ const sharedImport = js.slice(js.indexOf("async function importSharedLibraryPackage"), js.indexOf("function createLibraryImportOperationId"));
+ const folderRestore = js.slice(js.indexOf("async function restoreCompleteFolderBackup"), js.indexOf("async function importSharedLibraryPackage"));
+ assert.match(sharedImport, /salvageInvalidMedia:\s*true/);
+ assert.match(sharedImport, /findInvalidImportedImageIds/);
+ assert.match(sharedImport, /filesWithoutInvalidEntryMedia/);
+ assert.match(sharedImport, /parseLibraryPackage\(library,\s*salvageFiles/);
+ assert.doesNotMatch(folderRestore, /salvageInvalidMedia:\s*true/);
+});
+
+test("a committed import never deletes restored non-case media during later UI refresh failure", () => {
+ assert.equal(js.match(/let applySucceeded\s*=\s*false/g)?.length, 2);
+ assert.equal(js.match(/applySucceeded\s*=\s*true/g)?.length, 2);
+ assert.match(js, /creativeRuns[\s\S]*composerSessions[\s\S]*trashState/);
+ assert.match(js, /applySucceeded\s*\?\s*new Set\(savedIds\)/);
+});
diff --git a/test/lib.test.js b/test/lib.test.js
index d893aa2..30ab73c 100644
--- a/test/lib.test.js
+++ b/test/lib.test.js
@@ -225,3 +225,33 @@ test("library JSON is machine-readable and references screenshots without base64
assert.equal(json.includes("base64,"), false);
assert.ok(Array.isArray(parsed.facetCatalog.facets));
});
+
+test("complete library JSON can carry recoverable trash cases and projects", () => {
+ const trashState = {
+ version: 1,
+ items: [
+ {
+ id: "trash:entry:deleted",
+ kind: "entry",
+ targetId: "deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: { id: "deleted", title: "已删除案例", text: "仍需灾备" },
+ relationships: {}
+ },
+ {
+ id: "trash:collection:collection:deleted",
+ kind: "collection",
+ targetId: "collection:deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: { id: "collection:deleted", name: "已删除项目", parentId: null, order: 0, entryIds: [] },
+ relationships: {}
+ }
+ ]
+ };
+ const parsed = JSON.parse(renderLibraryJson(
+ [], {}, createDefaultTaxonomy(), createDefaultFacetCatalog(), [], {},
+ { trashState }, []
+ ));
+
+ assert.deepEqual(parsed.trashState, trashState);
+});
diff --git a/test/library-export-plan.test.js b/test/library-export-plan.test.js
new file mode 100644
index 0000000..e9fcd86
--- /dev/null
+++ b/test/library-export-plan.test.js
@@ -0,0 +1,34 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+ buildFolderBackupCompletion,
+ verifyFolderBackupCompletion
+} from "../library-export-plan.js";
+
+test("folder completion is written from actual files and rejects later byte changes", async () => {
+ const files = new Map([
+ ["library.json", new Blob(["{\"entries\":[]}"], { type: "application/json" })],
+ ["images/case/image.webp", new Blob(["image-bytes"], { type: "image/webp" })]
+ ]);
+ const completion = await buildFolderBackupCompletion(files, {
+ createdAt: "2026-08-26T00:00:00.000Z",
+ caseCount: 1,
+ trashCaseCount: 2,
+ trashProjectCount: 1,
+ mediaCount: 1,
+ byteSize: 11
+ });
+
+ assert.equal(completion.version, 2);
+ assert.equal(completion.fileCount, 2);
+ assert.deepEqual(completion.files.map(({ path, byteSize }) => ({ path, byteSize })), [
+ { path: "images/case/image.webp", byteSize: 11 },
+ { path: "library.json", byteSize: 14 }
+ ]);
+ await assert.doesNotReject(() => verifyFolderBackupCompletion(completion, files));
+
+ const changed = new Map(files);
+ changed.set("images/case/image.webp", new Blob(["changed-bytes"], { type: "image/webp" }));
+ await assert.rejects(() => verifyFolderBackupCompletion(completion, changed), /完整性校验失败/);
+});
diff --git a/test/library-export-zip.test.js b/test/library-export-zip.test.js
new file mode 100644
index 0000000..1f98a3d
--- /dev/null
+++ b/test/library-export-zip.test.js
@@ -0,0 +1,108 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createVerifiedLibraryZip } from "../library-export-zip.js";
+import { renderLibraryJson } from "../lib.js";
+import { parseLibraryPackage } from "../library-package.js";
+import { createArchiveUrl } from "../offscreen.js";
+import { readZipBlob } from "../zip.js";
+
+test("current exports are returned only after the production ZIP reader and package parser accept them", async () => {
+ const libraryJson = renderLibraryJson([]);
+
+ const archive = await createVerifiedLibraryZip([
+ { name: "library.json", data: libraryJson },
+ { name: "案例库.md", data: "# 案例库\n" }
+ ], libraryJson);
+
+ assert.equal(archive.type, "application/zip");
+ const files = await readZipBlob(archive, {
+ maxArchiveBytes: archive.size,
+ maxFileBytes: archive.size
+ });
+ assert.equal(await files.get("library.json").text(), libraryJson);
+});
+
+test("a structurally valid ZIP is rejected when its parsed library meaning differs from the generated package", async () => {
+ const expectedLibraryJson = renderLibraryJson([]);
+ const changed = JSON.parse(expectedLibraryJson);
+ changed.settings.libraryTitle = "打包后被改写";
+
+ await assert.rejects(
+ () => createVerifiedLibraryZip([
+ { name: "library.json", data: `${JSON.stringify(changed)}\n` }
+ ], expectedLibraryJson),
+ /导出自检失败.*内容与生成前不一致/
+ );
+});
+
+test("offscreen never creates a downloadable URL when the generated package fails its production self-read", async () => {
+ const originalCreateObjectUrl = URL.createObjectURL;
+ let createObjectUrlCalls = 0;
+ URL.createObjectURL = () => {
+ createObjectUrlCalls += 1;
+ return "blob:must-not-be-created";
+ };
+ try {
+ await assert.rejects(() => createArchiveUrl({
+ entries: [{
+ id: "case-with-broken-relation",
+ title: "关系损坏案例",
+ text: "prompt",
+ facetAssignments: [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ status: "confirmed",
+ source: "manual"
+ }]
+ }]
+ }), /导出自检失败.*引用了缺失的 AI 标签词表/);
+ assert.equal(createObjectUrlCalls, 0);
+ } finally {
+ URL.createObjectURL = originalCreateObjectUrl;
+ }
+});
+
+test("self-read keeps a JPEG case while the production parser drops only its broken AI label", async () => {
+ const image = new Blob([new Uint8Array([0xff, 0xd8, 0xff, 0xd9])], { type: "image/jpeg" });
+ const libraryJson = renderLibraryJson([{
+ id: "jpeg-case",
+ title: "JPEG 案例",
+ text: "prompt",
+ mediaAssets: [{
+ id: "jpeg-asset",
+ kind: "image",
+ storageMode: "managed",
+ mimeType: "image/jpeg",
+ sourceFormat: "jpg",
+ byteSize: image.size,
+ capturedAt: "2026-08-26T00:00:00.000Z",
+ assetPath: "images/jpeg-case/jpeg-asset.jpg"
+ }],
+ primaryMediaId: "jpeg-asset",
+ facetAssignments: [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ visualId: "jpeg-asset",
+ status: "confirmed",
+ source: "vision_model"
+ }]
+ }]);
+ const archive = await createVerifiedLibraryZip([
+ { name: "library.json", data: libraryJson },
+ { name: "images/jpeg-case/jpeg-asset.jpg", data: image }
+ ], libraryJson);
+ const limits = {
+ maxArchiveBytes: archive.size,
+ maxFileBytes: archive.size,
+ maxImageBytes: archive.size
+ };
+ const files = await readZipBlob(archive, limits);
+ const parsed = parseLibraryPackage(JSON.parse(await files.get("library.json").text()), files, limits);
+
+ assert.equal(parsed.entries.length, 1);
+ assert.equal(parsed.entries[0].mediaAssets[0].sourceFormat, "jpg");
+ assert.equal(parsed.assets.get("jpeg-asset").size, image.size);
+ assert.deepEqual(parsed.entries[0].facetAssignments, []);
+ assert.equal(parsed.importStats.droppedAiAssignments, 1);
+});
diff --git a/test/library-import-background.test.js b/test/library-import-background.test.js
new file mode 100644
index 0000000..bdf964b
--- /dev/null
+++ b/test/library-import-background.test.js
@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+const background = await readFile(new URL("../background.js", import.meta.url), "utf8");
+
+test("library import commits business data and its completed receipt atomically", () => {
+ const apply = background.slice(
+ background.indexOf("async function applyLibraryImport"),
+ background.indexOf("function previewCuratedImport")
+ );
+
+ assert.match(apply, /claimLibraryImportTransaction/);
+ assert.match(apply, /IMPORT_TRANSACTION_PENDING/);
+ assert.match(apply, /succeedLibraryImportTransaction/);
+ assert.match(apply, /\[STORAGE_KEYS\.libraryImportTransactions\]:\s*completed\.state/);
+ assert.match(apply, /await commitLocalChanges\(\{[\s\S]*storagePayload\(result\.state\)[\s\S]*completed\.state/);
+ assert.match(apply, /failLibraryImportTransaction/);
+});
diff --git a/test/library-import-dedup.test.js b/test/library-import-dedup.test.js
new file mode 100644
index 0000000..cb87247
--- /dev/null
+++ b/test/library-import-dedup.test.js
@@ -0,0 +1,210 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { mergeLibraryPackage } from "../library-package.js";
+import { createDefaultFacetCatalog } from "../facets.js";
+import { CONTENT_IDS, createDefaultTaxonomy } from "../taxonomy.js";
+
+function portablePackage(entries) {
+ return {
+ format: "prompt-case-library",
+ version: 5,
+ schemaVersion: 28,
+ settings: {},
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: createDefaultFacetCatalog(),
+ classificationRules: [],
+ organizerState: { version: 1, collections: [] },
+ compoundCases: [],
+ entries
+ };
+}
+
+function portableEntry(id, overrides = {}) {
+ return {
+ id,
+ schemaVersion: 28,
+ title: "同一个案例",
+ text: "保留这段创作提示词",
+ url: "https://example.com/source-case",
+ savedAt: "2026-08-20T10:00:00.000Z",
+ classification: {
+ pathIds: [CONTENT_IDS.promptText],
+ status: "confirmed",
+ source: "manual"
+ },
+ customLabels: ["保留"],
+ metadataLabels: ["来源标签"],
+ facetAssignments: [],
+ mediaAssets: [],
+ primaryMediaId: "",
+ ...overrides
+ };
+}
+
+function portableImageEntry(id, contentHash = "a".repeat(64)) {
+ return portableEntry(id, {
+ mediaAssets: [{
+ id: `${id}-image`,
+ kind: "image",
+ usage: "content",
+ storageMode: "managed",
+ mimeType: "image/webp",
+ sourceFormat: "webp",
+ contentHash,
+ byteSize: 12,
+ assetPath: `images/${id}/${id}-image.webp`,
+ capturedAt: "2026-08-20T10:00:00.000Z",
+ reviewStatus: "verified"
+ }],
+ primaryMediaId: `${id}-image`
+ });
+}
+
+function emptyLibrary() {
+ return {
+ entries: [],
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: createDefaultFacetCatalog(),
+ classificationRules: [],
+ organizerState: { version: 1, collections: [] },
+ compoundCases: [],
+ settings: {}
+ };
+}
+
+test("reimporting the same source with identical persistent meaning skips the duplicate", () => {
+ const source = portablePackage([portableEntry("source-entry")]);
+ const first = mergeLibraryPackage(emptyLibrary(), source, {
+ now: "2026-08-25T10:00:00.000Z",
+ importBatchId: "first-import"
+ });
+
+ const second = mergeLibraryPackage(first.state, source, {
+ now: "2026-08-26T10:00:00.000Z",
+ importBatchId: "second-import"
+ });
+
+ assert.equal(second.state.entries.length, 1);
+ assert.equal(second.importedCount, 0);
+ assert.equal(second.skippedCount, 1);
+ assert.equal(second.remappedCount, 0);
+ assert.equal(second.entryIdMap["source-entry"], "source-entry");
+ assert.deepEqual(second.createdEntryIds, []);
+ assert.deepEqual(second.createdVisualIdMap, {});
+});
+
+test("reimporting the same source with changed persistent meaning keeps a new copy", () => {
+ const original = portablePackage([portableEntry("source-entry")]);
+ const first = mergeLibraryPackage(emptyLibrary(), original, {
+ now: "2026-08-25T10:00:00.000Z",
+ importBatchId: "first-import"
+ });
+ const changed = portablePackage([portableEntry("source-entry", {
+ text: "这是同一来源后来修改过的创作提示词"
+ })]);
+
+ const second = mergeLibraryPackage(first.state, changed, {
+ now: "2026-08-26T10:00:00.000Z",
+ importBatchId: "changed-import"
+ });
+
+ assert.equal(second.state.entries.length, 2);
+ assert.equal(second.importedCount, 1);
+ assert.equal(second.skippedCount, 0);
+ assert.equal(second.remappedCount, 1);
+ assert.notEqual(second.entryIdMap["source-entry"], "source-entry");
+});
+
+test("reimporting an already remapped source version reuses that copy instead of creating a third", () => {
+ const original = portablePackage([portableEntry("source-entry")]);
+ const first = mergeLibraryPackage(emptyLibrary(), original, {
+ now: "2026-08-24T10:00:00.000Z",
+ importBatchId: "original-import"
+ });
+ const changed = portablePackage([portableEntry("source-entry", {
+ text: "同一来源的第二个持久版本"
+ })]);
+ const second = mergeLibraryPackage(first.state, changed, {
+ now: "2026-08-25T10:00:00.000Z",
+ importBatchId: "changed-import"
+ });
+
+ const third = mergeLibraryPackage(second.state, changed, {
+ now: "2026-08-26T10:00:00.000Z",
+ importBatchId: "repeat-changed-import"
+ });
+
+ assert.equal(third.state.entries.length, 2);
+ assert.equal(third.importedCount, 0);
+ assert.equal(third.skippedCount, 1);
+ assert.equal(third.entryIdMap["source-entry"], second.entryIdMap["source-entry"]);
+});
+
+test("different source identities remain separate even when their content is identical", () => {
+ const first = mergeLibraryPackage(emptyLibrary(), portablePackage([
+ portableEntry("source-a")
+ ]));
+ const second = mergeLibraryPackage(first.state, portablePackage([
+ portableEntry("source-b")
+ ]));
+
+ assert.equal(second.state.entries.length, 2);
+ assert.equal(second.importedCount, 1);
+ assert.equal(second.skippedCount, 0);
+ assert.equal(second.entryIdMap["source-b"], "source-b");
+});
+
+test("identical managed media is reused by content hash even though archive paths are receiver-local", () => {
+ const source = portablePackage([portableImageEntry("source-image")]);
+ const first = mergeLibraryPackage(emptyLibrary(), source);
+ const second = mergeLibraryPackage(first.state, source);
+
+ assert.equal(second.state.entries.length, 1);
+ assert.equal(second.importedCount, 0);
+ assert.equal(second.skippedCount, 1);
+ assert.equal(second.visualIdMap["source-image-image"], "source-image-image");
+ assert.deepEqual(second.createdVisualIdMap, {});
+});
+
+test("a changed managed-media content hash keeps a new version of the same source", () => {
+ const first = mergeLibraryPackage(emptyLibrary(), portablePackage([
+ portableImageEntry("source-image", "a".repeat(64))
+ ]));
+ const second = mergeLibraryPackage(first.state, portablePackage([
+ portableImageEntry("source-image", "b".repeat(64))
+ ]));
+
+ assert.equal(second.state.entries.length, 2);
+ assert.equal(second.importedCount, 1);
+ assert.equal(second.skippedCount, 0);
+ assert.equal(second.remappedCount, 1);
+});
+
+test("an already remapped media version is skipped when the same source is imported again", () => {
+ const original = portablePackage([portableImageEntry("source-image", "a".repeat(64))]);
+ const changed = portablePackage([portableImageEntry("source-image", "b".repeat(64))]);
+ const first = mergeLibraryPackage(emptyLibrary(), original);
+ const second = mergeLibraryPackage(first.state, changed);
+ const third = mergeLibraryPackage(second.state, changed);
+
+ assert.equal(third.state.entries.length, 2);
+ assert.equal(third.importedCount, 0);
+ assert.equal(third.skippedCount, 1);
+ assert.equal(
+ third.visualIdMap["source-image-image"],
+ second.visualIdMap["source-image-image"]
+ );
+});
+
+test("managed media without a reliable content hash is preserved as a copy", () => {
+ const entryWithoutHash = portableImageEntry("source-image");
+ delete entryWithoutHash.mediaAssets[0].contentHash;
+ const source = portablePackage([entryWithoutHash]);
+ const first = mergeLibraryPackage(emptyLibrary(), source);
+ const second = mergeLibraryPackage(first.state, source);
+
+ assert.equal(second.state.entries.length, 2);
+ assert.equal(second.importedCount, 1);
+ assert.equal(second.skippedCount, 0);
+});
diff --git a/test/library-import-dialog.test.js b/test/library-import-dialog.test.js
new file mode 100644
index 0000000..403f659
--- /dev/null
+++ b/test/library-import-dialog.test.js
@@ -0,0 +1,34 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildLibraryImportReport } from "../library-import-dialog.js";
+
+test("import report separates created, identical, repaired, and skipped results", () => {
+ const report = buildLibraryImportReport({
+ importedCount: 8,
+ skippedCount: 3,
+ remappedCount: 2,
+ importedSkillCount: 1,
+ importStats: {
+ inputCases: 13,
+ keptCases: 12,
+ skippedCases: 1,
+ droppedAiAssignments: 4,
+ droppedMediaDescriptors: 1,
+ droppedMediaFiles: 2
+ }
+ }, { mediaCount: 7, byteLabel: "18 MB" });
+
+ assert.equal(report.status, "partial");
+ assert.match(report.summary, /可导入 8 个新案例/);
+ assert.deepEqual(report.lines, [
+ "完全相同,跳过 3 个",
+ "同一来源有新内容,保留副本 2 个",
+ "丢弃损坏的 AI 标签 4 条",
+ "丢弃损坏的媒体描述 1 条",
+ "丢弃损坏或缺失的媒体 2 项",
+ "跳过无法恢复的案例 1 个",
+ "恢复 1 个 Skill、7 项本地文件(18 MB)"
+ ]);
+ assert.equal(report.autoAnalysisNotice, "导入不会自动启动 AI 分析");
+});
diff --git a/test/library-import-media.test.js b/test/library-import-media.test.js
new file mode 100644
index 0000000..2de8433
--- /dev/null
+++ b/test/library-import-media.test.js
@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+ filesWithoutInvalidEntryMedia,
+ findInvalidImportedImageIds
+} from "../library-import-media.js";
+
+test("shared ZIP validation reports every undecodable image instead of stopping at the first one", async () => {
+ const good = new Blob(["good"], { type: "image/webp" });
+ const badOne = new Blob(["bad-one"], { type: "image/webp" });
+ const badTwo = new Blob(["bad-two"], { type: "image/webp" });
+ const images = new Map([
+ ["image:good", good],
+ ["image:bad-one", badOne],
+ ["image:bad-two", badTwo]
+ ]);
+
+ const invalidIds = await findInvalidImportedImageIds(images, async (blob) => {
+ if (blob !== good) throw new Error("无法解码");
+ });
+
+ assert.deepEqual([...invalidIds], ["image:bad-one", "image:bad-two"]);
+});
+
+test("shared ZIP validation propagates a programming error in the image map", async () => {
+ await assert.rejects(
+ () => findInvalidImportedImageIds(new Map([["image:bad-map", null]]), async () => {}),
+ /图片校验输入无效/
+ );
+});
+
+test("shared ZIP salvage removes only archive files belonging to undecodable entry images", () => {
+ const files = new Map([
+ ["library.json", new Blob(["{}"], { type: "application/json" })],
+ ["images/good.webp", new Blob(["good"], { type: "image/webp" })],
+ ["images/bad.webp", new Blob(["bad"], { type: "image/webp" })]
+ ]);
+ const library = {
+ entries: [{
+ id: "case:one",
+ mediaAssets: [
+ { id: "image:good", assetPath: "images/good.webp" },
+ { id: "image:bad", assetPath: "images/bad.webp" }
+ ]
+ }]
+ };
+
+ const salvageFiles = filesWithoutInvalidEntryMedia(library, files, new Set(["image:bad"]));
+
+ assert.equal(salvageFiles.has("images/bad.webp"), false);
+ assert.equal(salvageFiles.get("images/good.webp"), files.get("images/good.webp"));
+ assert.equal(salvageFiles.get("library.json"), files.get("library.json"));
+ assert.equal(files.has("images/bad.webp"), true);
+});
diff --git a/test/library-import-transaction.test.js b/test/library-import-transaction.test.js
new file mode 100644
index 0000000..9db2d3b
--- /dev/null
+++ b/test/library-import-transaction.test.js
@@ -0,0 +1,225 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+ assertLibraryImportPlanCurrent,
+ claimLibraryImportTransaction,
+ createLibraryImportPlanToken,
+ normalizeLibraryImportTransactionsState,
+ succeedLibraryImportTransaction
+} from "../library-import-transaction.js";
+
+test("plan tokens ignore sync status, undo, and job noise but still react to live library changes", () => {
+ const source = makeImportSource();
+ const before = makeCurrentLibrary();
+ const token = createLibraryImportPlanToken(before, source);
+
+ assert.equal(token, createLibraryImportPlanToken({
+ ...before,
+ syncStatus: { connected: true, lastCheckedAt: "2026-08-26T00:00:00.000Z" },
+ importJobs: { version: 1, items: [{ id: "job:one", status: "running" }] },
+ lastSaveUndo: { id: "undo:one", createdAt: "2026-08-26T00:00:00.000Z" },
+ libraryImportStats: { applied: 9, skipped: 1 }
+ }, source));
+
+ assert.doesNotThrow(() => assertLibraryImportPlanCurrent(token, before, source));
+ assert.throws(() => assertLibraryImportPlanCurrent(token, {
+ ...before,
+ entries: [...before.entries, { id: "parallel-import", title: "并行新增", mediaAssets: [] }]
+ }, source), (error) => {
+ assert.equal(error.code, "IMPORT_PLAN_STALE");
+ return true;
+ });
+});
+
+test("a completed apply is replayed for the same operationId and planToken without calling the writer again", () => {
+ const source = makeImportSource();
+ const before = makeCurrentLibrary();
+ const token = createLibraryImportPlanToken(before, source);
+ const operationId = "operation:one";
+ const receiptState = normalizeLibraryImportTransactionsState();
+ const claim = claimLibraryImportTransaction(receiptState, {
+ operationId,
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ });
+
+ assert.equal(claim.acquired, true);
+ assert.equal(claim.replayed, false);
+ assert.equal(claim.receipt.status, "pending");
+
+ const applied = succeedLibraryImportTransaction(claim.state, claim.receipt, {
+ ok: true,
+ message: "已导入 1 项",
+ importedCount: 1
+ });
+ const changed = {
+ ...before,
+ syncStatus: { connected: false, lastCheckedAt: "2026-08-26T00:10:00.000Z" },
+ entries: [...before.entries, { id: "parallel-import", title: "并行新增", mediaAssets: [] }]
+ };
+ const replay = claimLibraryImportTransaction(applied.state, {
+ operationId,
+ planToken: token,
+ stateValue: changed,
+ sourceValue: source
+ });
+
+ assert.equal(replay.acquired, false);
+ assert.equal(replay.replayed, true);
+ assert.deepEqual(replay.result, {
+ ok: true,
+ message: "已导入 1 项",
+ importedCount: 1
+ });
+ assert.equal(replay.receipt.status, "completed");
+ assert.equal(replay.receipt.operationId, operationId);
+ assert.equal(replay.receipt.planToken, token);
+});
+
+test("a pending receipt never claims success and blocks the same operation from being applied twice", () => {
+ const source = makeImportSource();
+ const before = makeCurrentLibrary();
+ const token = createLibraryImportPlanToken(before, source);
+ const operationId = "operation:pending";
+ const claimed = claimLibraryImportTransaction(normalizeLibraryImportTransactionsState(), {
+ operationId,
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ });
+
+ const duplicate = claimLibraryImportTransaction(claimed.state, {
+ operationId,
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ });
+
+ assert.equal(duplicate.acquired, false);
+ assert.equal(duplicate.replayed, false);
+ assert.equal(duplicate.pending, true);
+ assert.equal(duplicate.result, undefined);
+ assert.equal(duplicate.receipt.status, "pending");
+});
+
+test("the same operationId with a different planToken is rejected as a conflict", () => {
+ const source = makeImportSource();
+ const before = makeCurrentLibrary();
+ const token = createLibraryImportPlanToken(before, source);
+ const first = claimLibraryImportTransaction(normalizeLibraryImportTransactionsState(), {
+ operationId: "operation:conflict",
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ });
+ const applied = succeedLibraryImportTransaction(first.state, first.receipt, {
+ ok: true,
+ message: "已导入 1 项"
+ });
+ const changedSource = {
+ ...source,
+ entries: [...source.entries, { id: "source:extra", title: "源侧变化", mediaAssets: [] }]
+ };
+ const conflictToken = createLibraryImportPlanToken(before, changedSource);
+
+ assert.throws(() => claimLibraryImportTransaction(applied.state, {
+ operationId: "operation:conflict",
+ planToken: conflictToken,
+ stateValue: before,
+ sourceValue: changedSource
+ }), (error) => {
+ assert.equal(error.code, "IMPORT_RECEIPT_CONFLICT");
+ return true;
+ });
+});
+
+test("expired receipts are pruned so the same operation can be reacquired after the retention window", () => {
+ const source = makeImportSource();
+ const before = makeCurrentLibrary();
+ const token = createLibraryImportPlanToken(before, source);
+ const operationId = "operation:expire";
+
+ const initial = claimLibraryImportTransaction(normalizeLibraryImportTransactionsState(), {
+ operationId,
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ }, {
+ now: "2026-08-26T00:00:00.000Z",
+ retentionMs: 1
+ });
+
+ const reacquired = claimLibraryImportTransaction(initial.state, {
+ operationId,
+ planToken: token,
+ stateValue: before,
+ sourceValue: source
+ }, {
+ now: "2026-08-26T00:00:00.010Z",
+ retentionMs: 1
+ });
+
+ assert.equal(reacquired.acquired, true);
+ assert.equal(reacquired.pending, true);
+ assert.equal(reacquired.receipt.status, "pending");
+});
+
+function makeCurrentLibrary() {
+ return {
+ entries: [
+ {
+ id: "existing",
+ title: "现有案例",
+ mediaAssets: []
+ }
+ ],
+ organizerState: { collections: [] },
+ compoundCases: [],
+ trashState: { items: [] },
+ settings: { theme: "dark" },
+ taxonomy: { nodes: [] },
+ facetCatalog: { facets: [], nodes: [] },
+ classificationRules: [],
+ composerSettings: {},
+ composerSessions: [],
+ creativeExperimentSettings: {},
+ creativeRuns: [],
+ creativeSkills: { items: [] },
+ syncStatus: {
+ connected: true,
+ lastCheckedAt: "2026-08-26T00:00:00.000Z"
+ },
+ importJobs: { version: 1, items: [] },
+ importStaging: { version: 1, items: [] },
+ lastSaveUndo: { id: "undo:one" },
+ libraryImportStats: { applied: 1, skipped: 0 }
+ };
+}
+
+function makeImportSource() {
+ return {
+ format: "prompt-case-library",
+ version: 5,
+ entries: [
+ {
+ id: "source",
+ title: "源案例",
+ mediaAssets: []
+ }
+ ],
+ organizerState: { collections: [] },
+ compoundCases: [],
+ trashState: { items: [] },
+ settings: { theme: "dark" },
+ taxonomy: { nodes: [] },
+ facetCatalog: { facets: [], nodes: [] },
+ classificationRules: [],
+ composerSettings: {},
+ composerSessions: [],
+ creativeExperimentSettings: {},
+ creativeRuns: [],
+ creativeSkills: { items: [] }
+ };
+}
diff --git a/test/library-package-compatibility.test.js b/test/library-package-compatibility.test.js
new file mode 100644
index 0000000..a16cb7f
--- /dev/null
+++ b/test/library-package-compatibility.test.js
@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+import { CURRENT_LIBRARY_PACKAGE_VERSION } from "../library-package-format.js";
+import { prepareLibraryPackageDraft } from "../library-package-migrations.js";
+import { mergeLibraryPackage, parseLibraryPackage } from "../library-package.js";
+import { SCHEMA_VERSION } from "../taxonomy.js";
+
+const fixtureRoot = new URL("./fixtures/compat/", import.meta.url);
+
+test("the fixed v1-v5 compatibility fixtures all enter the current draft model with explicit provenance", async () => {
+ const provenance = await readJson(new URL("provenance.json", fixtureRoot));
+ assert.deepEqual(Object.keys(provenance.packages), ["v1", "v2", "v3", "v4", "v5"]);
+
+ for (const version of [1, 2, 3, 4, 5]) {
+ const key = `v${version}`;
+ const source = await readJson(new URL(`${key}/library.json`, fixtureRoot));
+ const origin = provenance.packages[key];
+ assert.equal(origin.originalFailureArchive, false, `${key} must not claim to be a user failure archive`);
+ assert.match(origin.provenanceType, /reconstructed/u);
+ assert.ok(origin.sourceCommit);
+
+ const result = prepareLibraryPackageDraft(source);
+ assert.equal(result.sourceVersion, version);
+ assert.equal(result.draft.version, CURRENT_LIBRARY_PACKAGE_VERSION);
+ assert.equal(result.draft.schemaVersion, SCHEMA_VERSION);
+ assert.deepEqual(result.draft.entries.map((entry) => entry.id), [`fixture:v${version}`]);
+ assert.equal(result.draft.entries[0].schemaVersion, SCHEMA_VERSION);
+ assert.equal(result.draft.entries[0].mediaAssets.length, 1);
+ assert.equal(Object.hasOwn(result.draft.entries[0], "visuals"), false);
+ assert.equal(Object.hasOwn(result.draft.entries[0], "screenshotPath"), false);
+ if (version === 4) assert.equal(result.draft.entries[0].mediaAssets[0].sourceFormat, "jpg");
+ }
+});
+
+test("the production parser drops a dangling AI label without rejecting the recoverable case", async () => {
+ const source = await readJson(new URL("v5/library.json", fixtureRoot));
+ const asset = source.entries[0].mediaAssets[0];
+ source.entries[0].facetAssignments = [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ visualId: asset.id,
+ status: "confirmed",
+ source: "vision_model"
+ }];
+ const parsed = parseLibraryPackage(source, new Map([[
+ asset.assetPath,
+ new Blob(["fixture-v5"], { type: asset.mimeType })
+ ]]), { skipMediaByteValidation: true });
+
+ assert.equal(parsed.entries.length, 1);
+ assert.deepEqual(parsed.entries[0].facetAssignments, []);
+ assert.equal(parsed.importStats.droppedAiAssignments, 1);
+ assert.deepEqual(parsed.importDiagnostics.map(({ code }) => code), ["ai_assignment_dropped"]);
+});
+
+test("the production import preview exposes salvage diagnostics for the user report", async () => {
+ const source = await readJson(new URL("v5/library.json", fixtureRoot));
+ source.entries[0].facetAssignments = [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ status: "confirmed",
+ source: "vision_model"
+ }];
+ const result = mergeLibraryPackage({ entries: [] }, source);
+
+ assert.equal(result.importedCount, 1);
+ assert.equal(result.importStats.droppedAiAssignments, 1);
+ assert.deepEqual(result.importDiagnostics.map(({ code }) => code), ["ai_assignment_dropped"]);
+});
+
+async function readJson(url) {
+ return JSON.parse(await readFile(url, "utf8"));
+}
diff --git a/test/library-package-contract.test.js b/test/library-package-contract.test.js
new file mode 100644
index 0000000..7b3fe9e
--- /dev/null
+++ b/test/library-package-contract.test.js
@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { normalizePortableMediaDescriptor } from "../library-package-contract.js";
+
+test("jpeg and jpg aliases normalize to the actual portable path without changing the image format", () => {
+ const normalized = normalizePortableMediaDescriptor({
+ id: "asset:legacy-jpeg",
+ kind: "image",
+ storageMode: "managed",
+ assetPath: "images/case-one/asset-one.jpg",
+ sourceFormat: "jpeg",
+ mimeType: "image/jpg",
+ byteSize: 12
+ });
+
+ assert.equal(normalized.assetPath, "images/case-one/asset-one.jpg");
+ assert.equal(normalized.sourceFormat, "jpg");
+ assert.equal(normalized.mimeType, "image/jpg");
+ assert.equal(normalized.byteSize, 12);
+});
diff --git a/test/library-package-migrations.test.js b/test/library-package-migrations.test.js
new file mode 100644
index 0000000..86115e0
--- /dev/null
+++ b/test/library-package-migrations.test.js
@@ -0,0 +1,129 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createDefaultFacetCatalog } from "../facets.js";
+import { prepareLibraryPackageDraft } from "../library-package-migrations.js";
+import { SCHEMA_VERSION, createDefaultTaxonomy } from "../taxonomy.js";
+
+test("dangling AI assignments are discarded while the case and durable visual analysis survive", () => {
+ const result = prepareLibraryPackageDraft(packageValue(5, [entry("case:analysis", {
+ facetAssignments: [
+ assignment("subject", "subject.character", "manual"),
+ assignment("missing-facet", "missing-node", "vision_model", "image:analysis"),
+ assignment("subject", "subject.character", "vision_model", "image:missing")
+ ],
+ mediaAssets: [image("image:analysis", {
+ visionAnalysis: {
+ version: 2,
+ description: "完整画面描述",
+ reconstructionPrompt: "完整反推提示词",
+ quality: "complete"
+ }
+ })],
+ primaryMediaId: "image:analysis"
+ })]));
+
+ assert.equal(result.draft.entries.length, 1);
+ assert.deepEqual(result.draft.entries[0].facetAssignments.map(({ facetId, nodeId, source }) => ({ facetId, nodeId, source })), [
+ { facetId: "subject", nodeId: "subject.character", source: "manual" }
+ ]);
+ assert.equal(result.draft.entries[0].mediaAssets[0].visionAnalysis.description, "完整画面描述");
+ assert.equal(result.draft.entries[0].mediaAssets[0].visionAnalysis.reconstructionPrompt, "完整反推提示词");
+ assert.equal(result.stats.droppedAiAssignments, 2);
+ assert.deepEqual(result.diagnostics.map(({ code, entryId }) => ({ code, entryId })), [
+ { code: "ai_assignment_dropped", entryId: "case:analysis" },
+ { code: "ai_assignment_dropped", entryId: "case:analysis" }
+ ]);
+});
+
+test("an unrecoverable empty case is skipped without blocking a valid case in the same package", () => {
+ const result = prepareLibraryPackageDraft(packageValue(5, [
+ entry("case:good"),
+ entry("case:empty", { title: "", text: "", mediaAssets: [], primaryMediaId: "" })
+ ]));
+
+ assert.deepEqual(result.draft.entries.map((item) => item.id), ["case:good"]);
+ assert.equal(result.stats.inputCases, 2);
+ assert.equal(result.stats.keptCases, 1);
+ assert.equal(result.stats.skippedCases, 1);
+ assert.deepEqual(result.diagnostics.map(({ code, entryId }) => ({ code, entryId })), [
+ { code: "case_skipped_no_usable_content", entryId: "case:empty" }
+ ]);
+});
+
+test("a malformed media descriptor is dropped and reported without hiding the case text", () => {
+ const result = prepareLibraryPackageDraft(packageValue(4, [entry("case:media", {
+ mediaAssets: [{
+ id: "asset:bad",
+ kind: "attachment",
+ storageMode: "managed",
+ sourceTitle: "font.psd",
+ sourceFormat: "psd",
+ mimeType: "font/otf",
+ byteSize: 4,
+ assetPath: "attachments/case-media/font.psd"
+ }],
+ primaryMediaId: "asset:bad"
+ })]));
+
+ assert.equal(result.draft.entries.length, 1);
+ assert.deepEqual(result.draft.entries[0].mediaAssets, []);
+ assert.equal(result.draft.entries[0].text, "prompt case:media");
+ assert.equal(result.stats.droppedMediaDescriptors, 1);
+ assert.deepEqual(result.diagnostics.map(({ code, entryId, assetId }) => ({ code, entryId, assetId })), [{
+ code: "media_descriptor_dropped",
+ entryId: "case:media",
+ assetId: "asset:bad"
+ }]);
+});
+
+function packageValue(version, entries) {
+ return {
+ format: "prompt-case-library",
+ version,
+ schemaVersion: SCHEMA_VERSION,
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: createDefaultFacetCatalog(),
+ classificationRules: [],
+ organizerState: { collections: [] },
+ entries
+ };
+}
+
+function entry(id, overrides = {}) {
+ return {
+ id,
+ schemaVersion: SCHEMA_VERSION,
+ title: id,
+ text: `prompt ${id}`,
+ savedAt: "2026-08-25T00:00:00.000Z",
+ classification: { pathIds: [], status: "needs_review", source: "auto" },
+ facetAssignments: [],
+ mediaAssets: [],
+ primaryMediaId: "",
+ ...overrides
+ };
+}
+
+function image(id, overrides = {}) {
+ return {
+ id,
+ kind: "image",
+ storageMode: "managed",
+ assetPath: `images/${id.replaceAll(":", "-")}.webp`,
+ sourceFormat: "webp",
+ mimeType: "image/webp",
+ byteSize: 5,
+ ...overrides
+ };
+}
+
+function assignment(facetId, nodeId, source, visualId) {
+ return {
+ facetId,
+ nodeId,
+ status: "confirmed",
+ source,
+ ...(visualId ? { visualId } : {})
+ };
+}
diff --git a/test/library-package-salvage.test.js b/test/library-package-salvage.test.js
new file mode 100644
index 0000000..313725e
--- /dev/null
+++ b/test/library-package-salvage.test.js
@@ -0,0 +1,371 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createDefaultFacetCatalog } from "../facets.js";
+import { mergeLibraryPackage, parseCompleteFolderBackup, parseLibraryPackage } from "../library-package.js";
+import { SCHEMA_VERSION, createDefaultTaxonomy } from "../taxonomy.js";
+import { restoreTrashItems } from "../trash.js";
+
+test("salvage mode drops one missing media file without blocking recoverable cases", () => {
+ const source = packageValue([
+ entry("case:missing", {
+ text: "这个案例仍有可恢复的正文",
+ mediaAssets: [image("image:missing")],
+ primaryMediaId: "image:missing"
+ }),
+ entry("case:good", {
+ mediaAssets: [image("image:good")],
+ primaryMediaId: "image:good"
+ })
+ ]);
+ const files = new Map([[
+ "images/image-good.webp",
+ new Blob(["good!"], { type: "image/webp" })
+ ]]);
+
+ const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });
+
+ assert.deepEqual(parsed.entries.map((item) => item.id), ["case:missing", "case:good"]);
+ assert.deepEqual(parsed.entries[0].mediaAssets, []);
+ assert.equal(parsed.entries[0].primaryMediaId, "");
+ assert.deepEqual(parsed.entries[1].mediaAssets.map((asset) => asset.id), ["image:good"]);
+ assert.deepEqual([...parsed.assets.keys()], ["image:good"]);
+ assert.equal(parsed.importStats.droppedMediaFiles, 1);
+ assert.deepEqual(parsed.importDiagnostics.filter(({ code }) => code === "media_file_dropped"), [{
+ code: "media_file_dropped",
+ severity: "media",
+ action: "dropped",
+ entryId: "case:missing",
+ assetId: "image:missing",
+ path: "images/image-missing.webp",
+ reason: "missing_file"
+ }]);
+});
+
+test("salvage mode reports a media MIME mismatch without hiding the case text", () => {
+ const source = packageValue([entry("case:type-mismatch", {
+ mediaAssets: [image("image:type-mismatch")],
+ primaryMediaId: "image:type-mismatch"
+ })]);
+ const files = new Map([[
+ "images/image-type-mismatch.webp",
+ new Blob(["wrong"], { type: "text/plain" })
+ ]]);
+
+ const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });
+
+ assert.equal(parsed.entries.length, 1);
+ assert.deepEqual(parsed.entries[0].mediaAssets, []);
+ assert.equal(parsed.importDiagnostics.at(-1).reason, "type_mismatch");
+ assert.equal(parsed.importStats.droppedMediaFiles, 1);
+});
+
+test("salvage mode treats one unsafe media descriptor as a case-local failure", () => {
+ const broken = image("image:unsafe-path");
+ broken.assetPath = "../images/unsafe.webp";
+ const source = packageValue([entry("case:unsafe-path", {
+ mediaAssets: [broken],
+ primaryMediaId: broken.id
+ })]);
+
+ const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });
+
+ assert.equal(parsed.entries.length, 1);
+ assert.deepEqual(parsed.entries[0].mediaAssets, []);
+ assert.equal(parsed.importStats.droppedMediaDescriptors, 1);
+ assert.equal(parsed.importDiagnostics.at(-1).code, "media_descriptor_dropped");
+});
+
+test("the import preview keeps salvage diagnostics produced before media blobs are removed from the message", () => {
+ const source = packageValue([entry("case:preview", {
+ mediaAssets: [image("image:preview-missing")],
+ primaryMediaId: "image:preview-missing"
+ })]);
+ const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });
+ const importLibrary = { ...parsed };
+ delete importLibrary.assets;
+ delete importLibrary.images;
+ delete importLibrary.skillAssets;
+
+ const preview = mergeLibraryPackage({ entries: [] }, importLibrary, {
+ preserveLibraryConfiguration: true
+ });
+
+ assert.equal(preview.importStats.droppedMediaFiles, 1);
+ assert.equal(preview.importDiagnostics.filter(({ code }) => code === "media_file_dropped").length, 1);
+});
+
+test("salvage mode skips a media-only case when its last recoverable file is broken", () => {
+ const source = packageValue([
+ entry("case:good"),
+ entry("case:media-only", {
+ title: "",
+ text: "",
+ note: "",
+ url: "",
+ mediaAssets: [image("image:broken-only")],
+ primaryMediaId: "image:broken-only"
+ })
+ ]);
+ source.organizerState = {
+ collections: [{
+ id: "collection:test",
+ name: "项目",
+ order: 0,
+ entryIds: ["case:good", "case:media-only"]
+ }]
+ };
+
+ const parsed = parseLibraryPackage(source, new Map(), { salvageInvalidMedia: true });
+
+ assert.deepEqual(parsed.entries.map((item) => item.id), ["case:good"]);
+ assert.deepEqual(parsed.organizerState.collections[0].entryIds, ["case:good"]);
+ assert.equal(parsed.importStats.inputCases, 2);
+ assert.equal(parsed.importStats.keptCases, 1);
+ assert.equal(parsed.importStats.skippedCases, 1);
+ assert.equal(parsed.importStats.droppedMediaFiles, 1);
+ assert.deepEqual(parsed.importDiagnostics.at(-1), {
+ code: "case_skipped_after_media_loss",
+ severity: "case",
+ action: "skipped",
+ entryId: "case:media-only",
+ reason: "no_usable_content"
+ });
+});
+
+test("complete folder backup parsing stays strict even if a caller requests ZIP media salvage", async () => {
+ const source = packageValue([entry("case:strict", {
+ mediaAssets: [image("image:strict-missing")],
+ primaryMediaId: "image:strict-missing"
+ })]);
+
+ await assert.rejects(
+ () => parseCompleteFolderBackup(source, new Map(), { salvageInvalidMedia: true }),
+ /截图缺失/
+ );
+});
+
+test("salvage mode removes relationships and AI labels that pointed at a dropped media file", () => {
+ const source = packageValue([entry("case:relations", {
+ mediaAssets: [image("image:missing-related"), image("image:kept")],
+ primaryMediaId: "image:missing-related",
+ mediaPrompts: [{
+ assetId: "image:missing-related",
+ text: "只属于坏文件的提示词",
+ source: "manual",
+ updatedAt: "2026-08-26T00:00:00.000Z"
+ }],
+ facetAssignments: [{
+ facetId: "subject",
+ nodeId: "subject.character",
+ visualId: "image:missing-related",
+ status: "confirmed",
+ source: "vision_model"
+ }]
+ })]);
+ const files = new Map([[
+ "images/image-kept.webp",
+ new Blob(["good!"], { type: "image/webp" })
+ ]]);
+
+ const parsed = parseLibraryPackage(source, files, { salvageInvalidMedia: true });
+ const recovered = parsed.entries[0];
+
+ assert.equal(recovered.primaryMediaId, "image:kept");
+ assert.deepEqual(recovered.mediaPrompts, []);
+ assert.deepEqual(recovered.facetAssignments, []);
+ assert.equal(parsed.importStats.droppedAiAssignments, 1);
+ assert.equal(parsed.importDiagnostics.filter(({ code }) => code === "ai_assignment_dropped").length, 1);
+});
+
+test("complete backup import drops broken AI labels before a trashed case is restored", async () => {
+ const source = packageValue([]);
+ const trashed = entry("case:trashed", {
+ mediaAssets: [image("image:trashed")],
+ primaryMediaId: "image:trashed",
+ facetAssignments: [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ visualId: "image:trashed",
+ status: "confirmed",
+ source: "vision_model"
+ }]
+ });
+ source.trashState = {
+ version: 1,
+ items: [{
+ id: "trash:entry:case:trashed",
+ kind: "entry",
+ targetId: "case:trashed",
+ deletedAt: "2026-08-26T01:00:00.000Z",
+ snapshot: trashed,
+ relationships: { collections: [] }
+ }]
+ };
+ const path = "images/image-trashed.webp";
+ const files = new Map([[path, new Blob(["good!"], { type: "image/webp" })]]);
+
+ const parsed = await parseCompleteFolderBackup(source, files);
+ const imported = mergeLibraryPackage({ entries: [] }, parsed);
+ const restored = restoreTrashItems(imported.state, ["trash:entry:case:trashed"]);
+
+ assert.deepEqual(parsed.trashState.items[0].snapshot.facetAssignments, []);
+ assert.equal(parsed.importStats.droppedAiAssignments, 1);
+ assert.equal(restored.entries.length, 1);
+ assert.deepEqual(restored.entries[0].facetAssignments, []);
+});
+
+test("complete backup import drops broken AI labels attached to a trashed media relationship", async () => {
+ const source = packageValue([entry("case:owner")]);
+ source.trashState = {
+ version: 1,
+ items: [{
+ id: "trash:media:case:owner:image:trashed-media",
+ kind: "media",
+ targetId: "image:trashed-media",
+ deletedAt: "2026-08-26T01:00:00.000Z",
+ snapshot: { mediaAssets: [image("image:trashed-media")] },
+ relationships: {
+ entryId: "case:owner",
+ positions: [{ id: "image:trashed-media", index: 0 }],
+ primaryMediaId: "image:trashed-media",
+ facetAssignments: [{
+ facetId: "missing-facet",
+ nodeId: "missing-node",
+ visualId: "image:trashed-media",
+ status: "confirmed",
+ source: "vision_model"
+ }]
+ }
+ }]
+ };
+ const files = new Map([[
+ "images/image-trashed-media.webp",
+ new Blob(["good!"], { type: "image/webp" })
+ ]]);
+
+ const parsed = await parseCompleteFolderBackup(source, files);
+ const imported = mergeLibraryPackage({ entries: [] }, parsed);
+ const restored = restoreTrashItems(imported.state, ["trash:media:case:owner:image:trashed-media"]);
+
+ assert.deepEqual(parsed.trashState.items[0].relationships.facetAssignments, []);
+ assert.equal(parsed.importStats.droppedAiAssignments, 1);
+ assert.deepEqual(restored.entries[0].facetAssignments, []);
+ assert.deepEqual(restored.entries[0].mediaAssets.map((asset) => asset.id), ["image:trashed-media"]);
+});
+
+test("legacy facet assignments migrate inside trashed cases and media before restore", async () => {
+ const source = packageValue([entry("case:owner")]);
+ source.facetCatalog = {
+ version: 1,
+ revision: 1,
+ facets: [{ id: "legacy:subject", name: "主体", order: 0 }],
+ nodes: [{
+ id: "legacy:character",
+ facetId: "legacy:subject",
+ parentId: null,
+ name: "人物",
+ aliases: [],
+ order: 0,
+ status: "active"
+ }]
+ };
+ const legacyAssignment = {
+ facetId: "legacy:subject",
+ nodeId: "legacy:character",
+ visualId: "image:legacy",
+ status: "confirmed",
+ source: "vision_model"
+ };
+ source.trashState = {
+ version: 1,
+ items: [
+ {
+ id: "trash:entry:case:legacy",
+ kind: "entry",
+ targetId: "case:legacy",
+ deletedAt: "2026-08-26T01:00:00.000Z",
+ snapshot: entry("case:legacy", {
+ mediaAssets: [image("image:legacy")],
+ primaryMediaId: "image:legacy",
+ facetAssignments: [legacyAssignment]
+ }),
+ relationships: { collections: [] }
+ },
+ {
+ id: "trash:media:case:owner:image:legacy-media",
+ kind: "media",
+ targetId: "image:legacy-media",
+ deletedAt: "2026-08-26T01:00:00.000Z",
+ snapshot: { mediaAssets: [image("image:legacy-media")] },
+ relationships: {
+ entryId: "case:owner",
+ positions: [{ id: "image:legacy-media", index: 0 }],
+ primaryMediaId: "image:legacy-media",
+ facetAssignments: [{ ...legacyAssignment, visualId: "image:legacy-media" }]
+ }
+ }
+ ]
+ };
+ const files = new Map([
+ ["images/image-legacy.webp", new Blob(["good!"], { type: "image/webp" })],
+ ["images/image-legacy-media.webp", new Blob(["good!"], { type: "image/webp" })]
+ ]);
+
+ const parsed = await parseCompleteFolderBackup(source, files);
+ const imported = mergeLibraryPackage({ entries: [] }, parsed);
+ const restored = restoreTrashItems(imported.state, [
+ "trash:entry:case:legacy",
+ "trash:media:case:owner:image:legacy-media"
+ ]);
+ const restoredAssignments = restored.entries.flatMap((item) => item.facetAssignments ?? []);
+ const validFacetIds = new Set(parsed.facetCatalog.facets.map((item) => item.id));
+ const validNodeIds = new Set(parsed.facetCatalog.nodes.map((item) => item.id));
+
+ assert.equal(restoredAssignments.length, 2);
+ assert.equal(restoredAssignments.every((item) => validFacetIds.has(item.facetId)), true);
+ assert.equal(restoredAssignments.every((item) => validNodeIds.has(item.nodeId)), true);
+ assert.equal(restoredAssignments.some((item) => item.nodeId === "legacy:character"), false);
+});
+
+function packageValue(entries) {
+ return {
+ format: "prompt-case-library",
+ version: 5,
+ schemaVersion: SCHEMA_VERSION,
+ settings: {},
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: createDefaultFacetCatalog(),
+ classificationRules: [],
+ organizerState: { collections: [] },
+ entries
+ };
+}
+
+function entry(id, overrides = {}) {
+ return {
+ id,
+ schemaVersion: SCHEMA_VERSION,
+ title: id,
+ text: `prompt ${id}`,
+ savedAt: "2026-08-26T00:00:00.000Z",
+ classification: { pathIds: [], status: "needs_review", source: "auto" },
+ facetAssignments: [],
+ mediaAssets: [],
+ primaryMediaId: "",
+ ...overrides
+ };
+}
+
+function image(id) {
+ return {
+ id,
+ kind: "image",
+ storageMode: "managed",
+ assetPath: `images/${id.replaceAll(":", "-")}.webp`,
+ sourceFormat: "webp",
+ mimeType: "image/webp",
+ byteSize: 5,
+ capturedAt: "2026-08-26T00:00:00.000Z"
+ };
+}
diff --git a/test/library-package.test.js b/test/library-package.test.js
index aa598bc..37fefb2 100644
--- a/test/library-package.test.js
+++ b/test/library-package.test.js
@@ -213,7 +213,7 @@ test("v4 mixed creative-asset ZIP restores image video audio subtitle PSD and fo
]);
});
-test("v4 package rejects asset paths whose registered extension kind or MIME disagrees", () => {
+test("v4 package reports and drops a mismatched media descriptor without losing recoverable case text", () => {
const data = packageData([], catalog());
data.version = 4;
data.entries = [{
@@ -223,9 +223,17 @@ test("v4 package rejects asset paths whose registered extension kind or MIME dis
sourceFormat: "psd", mimeType: "font/otf", byteSize: 4, assetPath: "attachments/mismatch/fake.psd"
}]
}];
- assert.throws(() => parseLibraryPackage(data, new Map([[
+ const parsed = parseLibraryPackage(data, new Map([[
"attachments/mismatch/fake.psd", new Blob(["fake"], { type: "application/octet-stream" })
- ]])), /扩展名、媒体类型和 MIME 不一致/);
+ ]]));
+ assert.equal(parsed.entries.length, 1);
+ assert.deepEqual(parsed.entries[0].mediaAssets, []);
+ assert.equal(parsed.entries[0].text, "prompt mismatch");
+ assert.deepEqual(parsed.importDiagnostics.map(({ code, entryId, assetId }) => ({ code, entryId, assetId })), [{
+ code: "media_descriptor_dropped",
+ entryId: "mismatch",
+ assetId: "fake-psd"
+ }]);
});
test("v4 package restores an unknown local source only as an inert managed attachment", () => {
@@ -409,6 +417,220 @@ test("empty-library import restores cases, settings, vocabulary and source rules
assert.deepEqual(result.state.organizerState.collections[0].entryIds, ["one"]);
});
+test("empty-library restore preserves trashed cases and projects from a complete backup", () => {
+ const data = packageData([], catalog());
+ const deletedEntry = { ...entry("deleted"), hasScreenshot: false };
+ delete deletedEntry.screenshotPath;
+ data.trashState = {
+ version: 1,
+ items: [
+ {
+ id: "trash:entry:deleted",
+ kind: "entry",
+ targetId: "deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: deletedEntry,
+ relationships: { collections: [{ id: "collection:deleted", index: 0 }] }
+ },
+ {
+ id: "trash:collection:collection:deleted",
+ kind: "collection",
+ targetId: "collection:deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: { id: "collection:deleted", name: "已删除项目", parentId: null, order: 0, entryIds: ["deleted"] },
+ relationships: {}
+ }
+ ]
+ };
+
+ const result = mergeLibraryPackage({ entries: [] }, data);
+
+ assert.deepEqual(result.state.trashState.items.map(({ kind, targetId }) => ({ kind, targetId })), [
+ { kind: "entry", targetId: "deleted" },
+ { kind: "collection", targetId: "collection:deleted" }
+ ]);
+ const restoredSnapshot = result.state.trashState.items[0].snapshot;
+ assert.equal(restoredSnapshot.id, "deleted");
+ assert.equal(restoredSnapshot.text, "prompt deleted");
+ assert.deepEqual(restoredSnapshot.mediaAssets, []);
+});
+
+test("complete-folder parsing validates and exposes media stored inside a trashed case", async () => {
+ const data = packageData([], catalog());
+ const path = "images/trash-entry-deleted/deleted-image.webp";
+ data.trashState = {
+ version: 1,
+ items: [{
+ id: "trash:entry:deleted",
+ kind: "entry",
+ targetId: "deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: {
+ ...entry("deleted"),
+ hasScreenshot: undefined,
+ screenshotPath: undefined,
+ mediaAssets: [{
+ id: "deleted-image",
+ kind: "image",
+ storageMode: "managed",
+ mimeType: "image/webp",
+ sourceFormat: "webp",
+ byteSize: 13,
+ assetPath: path
+ }],
+ primaryMediaId: "deleted-image"
+ },
+ relationships: {}
+ }]
+ };
+ const parsed = await parseCompleteFolderBackup(data, new Map([[
+ path,
+ new Blob(["trashed-image"], { type: "image/webp" })
+ ]]), { skipMediaByteValidation: true });
+
+ assert.equal(parsed.assets.get("deleted-image")?.size, 13);
+ assert.equal(parsed.trashState.items[0].snapshot.mediaAssets[0].assetPath, path);
+ const preview = mergeLibraryPackage({ entries: [] }, data);
+ assert.equal(preview.createdVisualIdMap["deleted-image"], "deleted-image");
+});
+
+test("non-empty restore remaps trashed case and project identities instead of dropping them", () => {
+ const data = packageData([], catalog());
+ const trashedEntry = { ...entry("deleted"), hasScreenshot: false };
+ delete trashedEntry.screenshotPath;
+ data.trashState = {
+ version: 1,
+ items: [
+ {
+ id: "trash:entry:deleted",
+ kind: "entry",
+ targetId: "deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: trashedEntry,
+ relationships: { collections: [{ id: "collection:deleted", index: 0 }] }
+ },
+ {
+ id: "trash:collection:collection:deleted",
+ kind: "collection",
+ targetId: "collection:deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: { id: "collection:deleted", name: "备份里的已删除项目", parentId: null, order: 0, entryIds: ["deleted"] },
+ relationships: {}
+ }
+ ]
+ };
+ const current = {
+ entries: [entry("deleted")],
+ trashState: { version: 1, items: [] },
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: catalog(),
+ classificationRules: [],
+ settings: {},
+ organizerState: {
+ collections: [{ id: "collection:deleted", name: "本地同名编号项目", parentId: null, order: 0, entryIds: ["deleted"] }]
+ },
+ compoundCases: []
+ };
+
+ const result = mergeLibraryPackage(current, data);
+ const restoredEntry = result.state.trashState.items.find((item) => item.kind === "entry");
+ const restoredProject = result.state.trashState.items.find((item) => item.kind === "collection");
+
+ assert.ok(restoredEntry);
+ assert.ok(restoredProject);
+ assert.notEqual(restoredEntry.targetId, "deleted");
+ assert.equal(restoredEntry.snapshot.id, restoredEntry.targetId);
+ assert.notEqual(restoredProject.targetId, "collection:deleted");
+ assert.equal(restoredProject.snapshot.id, restoredProject.targetId);
+ assert.deepEqual(restoredProject.snapshot.entryIds, [restoredEntry.targetId]);
+ assert.equal(restoredEntry.relationships.collections[0].id, restoredProject.targetId);
+});
+
+test("restored trash relationships follow the imported project into its actual merged destination", () => {
+ const data = packageData([entry("remote")], catalog());
+ data.organizerState = {
+ collections: [{ id: "collection:remote", name: "共享项目", order: 0, entryIds: ["remote"] }]
+ };
+ const deletedEntry = { ...entry("deleted"), hasScreenshot: false };
+ delete deletedEntry.screenshotPath;
+ data.trashState = {
+ version: 1,
+ items: [{
+ id: "trash:entry:deleted",
+ kind: "entry",
+ targetId: "deleted",
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot: deletedEntry,
+ relationships: { collections: [{ id: "collection:remote", index: 1 }] }
+ }]
+ };
+ const current = {
+ entries: [entry("local")],
+ trashState: { version: 1, items: [] },
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: catalog(),
+ classificationRules: [],
+ settings: {},
+ organizerState: {
+ collections: [{ id: "collection:local", name: "共享项目", order: 0, entryIds: ["local"] }]
+ },
+ compoundCases: []
+ };
+
+ const result = mergeLibraryPackage(current, data);
+ const restoredEntry = result.state.trashState.items.find((item) => item.kind === "entry");
+
+ assert.deepEqual(result.state.organizerState.collections[0].entryIds, ["local", "remote"]);
+ assert.equal(restoredEntry.relationships.collections[0].id, "collection:local");
+});
+
+test("restored trash compound relationships cannot reuse an active compound identity", () => {
+ const data = packageData([], catalog());
+ const deletedEntries = ["deleted-one", "deleted-two"].map((id) => {
+ const snapshot = { ...entry(id), hasScreenshot: false };
+ delete snapshot.screenshotPath;
+ return {
+ id: `trash:entry:${id}`,
+ kind: "entry",
+ targetId: id,
+ deletedAt: "2026-08-25T00:00:00.000Z",
+ snapshot,
+ relationships: {
+ compoundCases: [{
+ id: "compound:active",
+ title: "已删除组合",
+ memberEntryIds: ["deleted-one", "deleted-two"],
+ coverVisualId: ""
+ }]
+ }
+ };
+ });
+ data.trashState = { version: 1, items: deletedEntries };
+ const current = {
+ entries: [entry("local-one"), entry("local-two")],
+ trashState: { version: 1, items: [] },
+ taxonomy: createDefaultTaxonomy(),
+ facetCatalog: catalog(),
+ classificationRules: [],
+ settings: {},
+ organizerState: { collections: [] },
+ compoundCases: [{
+ id: "compound:active",
+ title: "本地组合",
+ memberEntryIds: ["local-one", "local-two"],
+ coverVisualId: "local-one"
+ }]
+ };
+
+ const result = mergeLibraryPackage(current, data);
+ const restored = result.state.trashState.items.filter((item) => item.kind === "entry");
+ const restoredCompoundIds = new Set(restored.flatMap((item) => item.relationships.compoundCases.map((compound) => compound.id)));
+
+ assert.equal(restoredCompoundIds.size, 1);
+ assert.equal(restoredCompoundIds.has("compound:active"), false);
+ assert.deepEqual(restored[0].relationships.compoundCases[0].memberEntryIds, restored.map((item) => item.targetId));
+});
+
test("single curated saves preserve an empty user's library configuration", () => {
const data = packageData([entry("curated-one")], catalog());
data.settings = { libraryTitle: "精选案例 Vol.1", outputPath: "精选案例.zip" };
@@ -494,7 +716,7 @@ test("a colliding case id imports as a new case instead of silently keeping a st
assert.equal(restored.facetAssignments.some((item) => item.source === "vision_model"), true);
});
-test("import aborts instead of silently dropping an assignment whose vocabulary node is missing", () => {
+test("import drops a dangling AI assignment while preserving the recoverable case", () => {
const incoming = entry("broken-label");
incoming.facetAssignments = [{
facetId: "facet:mood",
@@ -502,13 +724,17 @@ test("import aborts instead of silently dropping an assignment whose vocabulary
status: "confirmed",
source: "vision_model"
}];
- assert.throws(() => mergeLibraryPackage({
+ const result = mergeLibraryPackage({
entries: [entry("local")],
taxonomy: createDefaultTaxonomy(),
facetCatalog: catalog(),
classificationRules: [],
settings: {}
- }, packageData([incoming], catalog())), /标签|词表|不完整/);
+ }, packageData([incoming], catalog()));
+ assert.equal(result.importedCount, 1);
+ const restored = result.state.entries.find((item) => item.id === "broken-label");
+ assert.ok(restored);
+ assert.deepEqual(restored.facetAssignments, []);
});
test("package import keeps source time but assigns one receiver-local added time and batch", () => {
diff --git a/test/library_import_ui_e2e.py b/test/library_import_ui_e2e.py
index fdf9959..e416a41 100644
--- a/test/library_import_ui_e2e.py
+++ b/test/library_import_ui_e2e.py
@@ -159,7 +159,7 @@ def main() -> None:
expect(duplicate_row).to_contain_text("精确重复")
expect(new_row.locator("input")).to_be_checked()
expect(new_row.locator("input")).to_be_disabled()
- expect(library.locator("#import-auto-analyze")).to_be_checked()
+ expect(library.locator("#import-auto-analyze")).not_to_be_checked()
expect(library.locator("#import-project")).to_have_attribute("role", "combobox")
library.locator("#import-project").click()
expect(library.locator(".project-combobox-option")).to_have_count(12)
@@ -191,7 +191,7 @@ def main() -> None:
assert {item["name"] for item in payload["stagedAssets"]} == {"duplicate.txt", "new-note.md", "notes.rtf"}, payload
assert all(item.get("stagedAssetId") for item in payload["items"]), payload
assert {item["keepDuplicate"] for item in payload["items"]} == {False, True}, payload
- assert payload["options"] == {"autoAnalyze": True}, payload
+ assert payload["options"] == {"autoAnalyze": False}, payload
expect(library.locator("#import-undo")).to_be_visible()
expect(library.locator("#import-view-project")).to_be_visible()
diff --git a/test/media-archive-ui.test.js b/test/media-archive-ui.test.js
index 9cc16b0..3bc8e9a 100644
--- a/test/media-archive-ui.test.js
+++ b/test/media-archive-ui.test.js
@@ -73,7 +73,8 @@ test("share package import sizes only this user-selected package by its real fil
assert.match(imported, /maxFileBytes:\s*file\.size/);
assert.match(imported, /maxImageBytes:\s*file\.size/);
assert.match(imported, /readZipBlob\(file, packageLimits\)/);
- assert.match(imported, /parseLibraryPackage\(library, files, packageLimits\)/);
+ assert.match(imported, /salvageOptions = \{ \.\.\.packageLimits, salvageInvalidMedia: true \}/);
+ assert.match(imported, /parseLibraryPackage\(library, files, salvageOptions\)/);
});
test("complete folder restore derives its media budget from the selected verified backup", () => {
diff --git a/test/media-store.test.js b/test/media-store.test.js
index f53e5f9..c99bed9 100644
--- a/test/media-store.test.js
+++ b/test/media-store.test.js
@@ -7,6 +7,7 @@ import {
mediaStorageWriteError,
normalizeDerivedMedia,
normalizeDerivedMetadata,
+ validatePortableAssetBlob,
validateMediaBlob
} from "../media-store.js";
@@ -24,6 +25,11 @@ test("media storage accepts images videos audio documents and inert creator sour
});
});
+test("a parser-validated portable attachment may retain unknown original bytes", () => {
+ assert.doesNotThrow(() => validatePortableAssetBlob(new Blob(["source"], { type: "application/octet-stream" })));
+ assert.throws(() => validatePortableAssetBlob(new Blob([])), /媒体文件无效/);
+});
+
test("derived document data remains a rebuildable cache with bounded metadata", () => {
const thumbnail = new Blob(["preview"], { type: "image/webp" });
const value = normalizeDerivedMedia({ pageCount: 12, searchText: " 中文 PDF 内容 ", thumbnail });
diff --git a/test/media-ui.test.js b/test/media-ui.test.js
index e07d150..d444725 100644
--- a/test/media-ui.test.js
+++ b/test/media-ui.test.js
@@ -120,8 +120,11 @@ test("complete folder backup writes a completion marker after library metadata",
const backup = source.slice(source.indexOf("async function createCompleteFolderBackup"), source.indexOf("async function restoreCompleteFolderBackup"));
assert.ok(backup.indexOf('"library.json"') < backup.indexOf('"complete.json"'));
assert.match(backup, /await writeDirectoryFile\(directory, assetPath, blob\)/);
- assert.match(backup, /byteSize:\s*blob\.size/);
- assert.match(backup, /folderAssetPath\(entry\.id, asset, blob\.type \|\| asset\.mimeType\)/);
+ assert.match(backup, /portableManagedBackupAsset\(asset, blob, assetPath, await sha256Blob\(blob\)\)/);
+ assert.match(backup, /materializeEntry\(item\.snapshot, `trash-entry-/);
+ assert.match(backup, /buildFolderBackupCompletion\(writtenFiles/);
+ assert.match(backup, /verifyFolderBackupCompletion\(completion, writtenFiles\)/);
+ assert.ok(backup.indexOf("parseCompleteFolderBackup(writtenLibrary, writtenFiles") < backup.indexOf('"complete.json"'));
assert.match(source, /"application\/rtf":\s*"rtf"/);
});
diff --git a/test/organizer.test.js b/test/organizer.test.js
index 95fa3ff..c8b1bac 100644
--- a/test/organizer.test.js
+++ b/test/organizer.test.js
@@ -6,6 +6,7 @@ import {
createCollection,
deleteCollection,
mergeOrganizerState,
+ mergeOrganizerStateWithMap,
normalizeOrganizerState,
planCollectionAndEntriesDeletion,
reorderCollections,
@@ -58,6 +59,22 @@ test("organizer merge remaps entry ids and merges same-name collections", () =>
assert.deepEqual(merged.collections[0].entryIds, ["local", "imported"]);
});
+test("organizer merge exposes the actual destination id for every imported project", () => {
+ const result = mergeOrganizerStateWithMap({
+ collections: [{ id: "collection:local", name: "项目", order: 0, entryIds: ["local"] }]
+ }, {
+ collections: [
+ { id: "collection:remote", name: "项目", order: 0, entryIds: ["source"] },
+ { id: "collection:local", name: "另一个项目", order: 1, entryIds: ["second"] }
+ ]
+ }, { source: "imported", second: "imported-second" });
+
+ assert.equal(result.collectionIdMap["collection:remote"], "collection:local");
+ assert.notEqual(result.collectionIdMap["collection:local"], "collection:local");
+ assert.deepEqual(result.state.collections[0].entryIds, ["local", "imported"]);
+ assert.equal(result.state.collections.find((item) => item.id === result.collectionIdMap["collection:local"]).entryIds[0], "imported-second");
+});
+
test("receiver-local project creation time is assigned only to newly imported projects", () => {
const merged = mergeOrganizerState({
collections: [{ id: "existing", name: "已有", order: 0, entryIds: ["one"], createdAt: "2026-01-01T00:00:00.000Z" }]
diff --git a/test/project_deletion_e2e.py b/test/project_deletion_e2e.py
new file mode 100644
index 0000000..ab95498
--- /dev/null
+++ b/test/project_deletion_e2e.py
@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from playwright.sync_api import expect
+
+from e2e_support import base_entry, extension_session
+
+
+PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="
+
+
+def main() -> None:
+ entry = base_entry(
+ "project-delete-case",
+ "项目删除回归案例",
+ "项目和案例应一起进入回收站,并能完整恢复。",
+ "content:prompt:image",
+ )
+ entry["mediaAssets"] = [{
+ "id": "project-delete-image",
+ "kind": "image",
+ "usage": "content",
+ "storageMode": "managed",
+ "mimeType": "image/png",
+ "byteSize": 68,
+ "width": 1,
+ "height": 1,
+ "capturedAt": "2026-08-26T00:00:00.000Z",
+ }]
+ entry["primaryMediaId"] = "project-delete-image"
+ project = {
+ "id": "collection:project-delete",
+ "name": "待删除项目",
+ "parentId": None,
+ "order": 0,
+ "entryIds": [entry["id"]],
+ }
+
+ with extension_session("prompt-director-project-delete-") as session:
+ setup = session.open_page("collector.html")
+ setup.evaluate(
+ """async ({entry, project, png}) => {
+ const {saveMediaBlob} = await import(chrome.runtime.getURL('media-store.js'));
+ const bytes = Uint8Array.from(atob(png), value => value.charCodeAt(0));
+ await saveMediaBlob('project-delete-image', new Blob([bytes], {type: 'image/png'}), {checkCapacity: false});
+ await chrome.storage.local.clear();
+ await chrome.storage.local.set({
+ schemaVersion: 24,
+ entries: [entry],
+ organizerState: {version: 4, collections: [project]},
+ trashState: {version: 1, items: []}
+ });
+ }""",
+ {"entry": entry, "project": project, "png": PNG_BASE64},
+ )
+
+ library = session.open_page("library.html", wait_until="networkidle")
+ row = library.locator(".project-row", has_text="待删除项目")
+ expect(row).to_be_visible()
+ row.locator("summary").click()
+ row.get_by_role("button", name="删除项目及案例", exact=True).click()
+ dialog = library.locator("#promptdirector-app-dialog")
+ expect(dialog).to_be_visible()
+ dialog.get_by_role("button", name="全部移入回收站", exact=True).click()
+ expect(library.locator("#feedback")).to_contain_text("已移入回收站")
+
+ deleted = library.evaluate(
+ """async () => {
+ const state = await chrome.storage.local.get(['entries', 'organizerState', 'trashState']);
+ const {getMediaBlob} = await import(chrome.runtime.getURL('media-store.js'));
+ const blob = await getMediaBlob('project-delete-image');
+ return {
+ entryIds: (state.entries || []).map(item => item.id),
+ collectionIds: (state.organizerState?.collections || []).map(item => item.id),
+ trashKinds: (state.trashState?.items || []).map(item => item.kind).sort(),
+ mediaBytes: blob?.size || 0
+ };
+ }"""
+ )
+ assert deleted == {
+ "entryIds": [],
+ "collectionIds": [],
+ "trashKinds": ["collection", "entry"],
+ "mediaBytes": 68,
+ }, deleted
+
+ if library.locator("#settings-dialog").is_visible():
+ library.locator("#settings-close").click()
+ library.locator("#open-trash").click()
+ expect(library.locator("#trash-dialog")).to_be_visible()
+ expect(library.locator(".trash-item")).to_have_count(2)
+ library.locator("#trash-restore-all").click()
+ expect(library.locator("#trash-feedback")).to_contain_text("已恢复")
+ restored = library.evaluate(
+ """async () => {
+ const state = await chrome.storage.local.get(['entries', 'organizerState', 'trashState']);
+ const collection = state.organizerState.collections.find(item => item.id === 'collection:project-delete');
+ const {getMediaBlob} = await import(chrome.runtime.getURL('media-store.js'));
+ return {
+ entryIds: state.entries.map(item => item.id),
+ collectionEntryIds: collection?.entryIds || [],
+ trashCount: state.trashState.items.length,
+ mediaBytes: (await getMediaBlob('project-delete-image'))?.size || 0
+ };
+ }"""
+ )
+ assert restored == {
+ "entryIds": ["project-delete-case"],
+ "collectionEntryIds": ["project-delete-case"],
+ "trashCount": 0,
+ "mediaBytes": 68,
+ }, restored
+ print({"project_delete_restore": True, "media_bytes": restored["mediaBytes"]})
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/release-gate.test.js b/test/release-gate.test.js
new file mode 100644
index 0000000..b8ac20d
--- /dev/null
+++ b/test/release-gate.test.js
@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+const e2eSupport = await readFile(new URL("./e2e_support.py", import.meta.url), "utf8");
+
+test("the only release verification gate runs source tests and browser E2E before packaging", () => {
+ const scripts = packageJson.scripts;
+ assert.equal(scripts.verify, "npm run verify:release");
+ assert.match(scripts["verify:source"], /npm test/);
+ assert.match(scripts["verify:release"], /npm run verify:source/);
+ assert.match(scripts["verify:release"], /npm run test:e2e/);
+ assert.match(scripts["verify:release"], /npm run package:release/);
+ assert.ok(scripts["verify:release"].indexOf("npm run test:e2e") < scripts["verify:release"].indexOf("npm run package:release"));
+ assert.equal((scripts["verify:release"].match(/package:release/g) ?? []).length, 1);
+});
+
+test("installed-package acceptance can point the shared browser harness at an unpacked artifact", () => {
+ assert.match(e2eSupport, /PROMPTDIRECTOR_E2E_EXTENSION_DIR/);
+});
diff --git a/test/run_e2e.py b/test/run_e2e.py
index d31de2f..a9bb40f 100644
--- a/test/run_e2e.py
+++ b/test/run_e2e.py
@@ -16,6 +16,7 @@ SCRIPTS = [
"curated_skills_install_e2e.py",
"curated_video_workflow_e2e.py",
"library_import_ui_e2e.py",
+ "historical_zip_salvage_e2e.py",
"import_job_lifecycle_e2e.py",
"library_media_actions_e2e.py",
"video_detail_layout_e2e.py",
@@ -23,6 +24,7 @@ SCRIPTS = [
"library_detail_actions_e2e.py",
"library_discovery_e2e.py",
"projects_and_categories_e2e.py",
+ "project_deletion_e2e.py",
"text_and_image_analysis_e2e.py",
"single_case_visual_batch_e2e.py",
"composer_generation_e2e.py",
diff --git a/test/sharing_and_data_safety_e2e.py b/test/sharing_and_data_safety_e2e.py
index 82028bf..1a17875 100644
--- a/test/sharing_and_data_safety_e2e.py
+++ b/test/sharing_and_data_safety_e2e.py
@@ -32,10 +32,44 @@ def main() -> None:
entries[1]["primaryMediaId"] = "share-image-two"
entries[1]["note"] = "不应公开的私人笔记"
entries[1]["metadataLabels"] = ["作者:测试作者", "权利:本人原创", "秘密:sk-private"]
+ trashed_entry = base_entry("trash-one", "回收站案例", "需要跨电脑恢复。", "content:prompt:image", 3)
+ trashed_entry["mediaAssets"] = [{
+ "id": "trash-image",
+ "kind": "image",
+ "storageMode": "managed",
+ "mimeType": "image/png",
+ "width": 8,
+ "height": 8,
+ }]
+ trashed_entry["primaryMediaId"] = "trash-image"
+ trash_state = {
+ "version": 1,
+ "items": [{
+ "id": "trash:entry:trash-one",
+ "kind": "entry",
+ "targetId": "trash-one",
+ "deletedAt": "2026-08-26T00:00:00.000Z",
+ "snapshot": trashed_entry,
+ "relationships": {"collections": [{"id": "collection:trash", "index": 0}]},
+ }, {
+ "id": "trash:collection:collection:trash",
+ "kind": "collection",
+ "targetId": "collection:trash",
+ "deletedAt": "2026-08-26T00:00:00.000Z",
+ "snapshot": {
+ "id": "collection:trash",
+ "name": "回收站项目",
+ "parentId": None,
+ "order": 0,
+ "entryIds": ["trash-one"],
+ },
+ "relationships": {},
+ }],
+ }
with extension_session("prompt-director-share-") as session:
setup = session.open_page("collector.html")
current_schema = setup.evaluate("async () => (await import(chrome.runtime.getURL('taxonomy.js'))).SCHEMA_VERSION")
- session.seed_storage(setup, {"schemaVersion": current_schema, "entries": entries})
+ session.seed_storage(setup, {"schemaVersion": current_schema, "entries": entries, "trashState": trash_state})
setup.evaluate(
"""async () => {
const {saveMediaBlob} = await import(chrome.runtime.getURL('media-store.js'));
@@ -51,12 +85,42 @@ def main() -> None:
await saveMediaBlob('share-poster', imageBlob, {checkCapacity: false});
await saveMediaBlob('share-video', new Blob(['fixture-video'], {type: 'video/mp4'}), {checkCapacity: false});
await saveMediaBlob('share-document', new Blob(['%PDF-1.4 fixture'], {type: 'application/pdf'}), {checkCapacity: false});
+ await saveMediaBlob('trash-image', imageBlob, {checkCapacity: false});
+ const opfsRoot = await navigator.storage.getDirectory();
+ const linkedHandle = await opfsRoot.getFileHandle('linked-original.zzz', {create: true});
+ const writable = await linkedHandle.createWritable();
+ await writable.write(new Blob(['linked-original-bytes'], {type: 'application/octet-stream'}));
+ await writable.close();
+ const linkedFile = await linkedHandle.getFile();
+ const {saveLocalAssetHandle} = await import(chrome.runtime.getURL('local-asset-store.js'));
+ await saveLocalAssetHandle('linked-local-image', linkedHandle, linkedFile);
+ const stored = await chrome.storage.local.get('entries');
+ const linkedEntry = {
+ schemaVersion: 24,
+ id: 'linked-one',
+ title: '本机链接素材案例',
+ text: '备份时必须复制原件。',
+ url: 'https://fixture.invalid/linked-one',
+ savedAt: '2026-08-02T08:04:00.000Z',
+ classification: {pathIds: ['content:prompt:image'], status: 'confirmed', source: 'manual'},
+ facetAssignments: [], analysisCandidates: [], analysisBreakdown: [], rejectedCandidateKeys: [],
+ negativeTerms: [], customLabels: [], timeNotes: [],
+ mediaAssets: [{
+ id: 'linked-local-image', recordType: 'local-asset-reference', kind: 'attachment', usage: 'content',
+ storageMode: 'reference', mimeType: linkedFile.type, byteSize: linkedFile.size,
+ sourceTitle: linkedFile.name, sourceFormat: 'zzz', formatCategory: 'local-link',
+ relativePath: linkedFile.name, sourceLastModified: linkedFile.lastModified, linkStatus: 'linked',
+ importFailure: {code: 'unsupported_format', message: '不支持的素材格式', forceAllowed: false}
+ }],
+ primaryMediaId: 'linked-local-image'
+ };
+ await chrome.storage.local.set({entries: [...stored.entries, linkedEntry]});
}"""
)
setup.wait_for_function(
"""async () => {
const state = await chrome.runtime.sendMessage({type: 'GET_STATE'});
- return state?.entries?.length === 2;
+ return state?.entries?.length === 3;
}"""
)
library = session.open_page("library.html", wait_until="networkidle")
@@ -174,7 +238,166 @@ def main() -> None:
expect(library.locator("#create-folder-backup")).to_be_visible()
expect(library.locator("#restore-folder-backup")).to_be_visible()
assert library.locator("#create-portable-backup").count() == 0
- print({"shared_entries": 2, "curated_submission": True, "private_drafts_removed": True, "data_safety": True, "offline_preview": True, "mobile_width": 390, "screenshots": str(screenshots)})
+ library.evaluate(
+ """() => {
+ class MemoryFileHandle {
+ constructor(name) { this.kind = 'file'; this.name = name; this.blob = new Blob([]); }
+ async getFile() { return new File([this.blob], this.name, {type: this.blob.type}); }
+ async createWritable() {
+ let pending = this.blob;
+ return {
+ write: async (value) => { pending = value instanceof Blob ? value : new Blob([value]); },
+ close: async () => { this.blob = pending; },
+ abort: async () => undefined
+ };
+ }
+ }
+ class MemoryDirectoryHandle {
+ constructor(name) { this.kind = 'directory'; this.name = name; this.files = new Map(); this.directories = new Map(); }
+ async requestPermission() { return 'granted'; }
+ async getFileHandle(name, options = {}) {
+ if (!this.files.has(name) && options.create) this.files.set(name, new MemoryFileHandle(name));
+ if (!this.files.has(name)) throw new DOMException('Not found', 'NotFoundError');
+ return this.files.get(name);
+ }
+ async getDirectoryHandle(name, options = {}) {
+ if (!this.directories.has(name) && options.create) this.directories.set(name, new MemoryDirectoryHandle(name));
+ if (!this.directories.has(name)) throw new DOMException('Not found', 'NotFoundError');
+ return this.directories.get(name);
+ }
+ async *entries() {
+ for (const item of this.directories) yield item;
+ for (const item of this.files) yield item;
+ }
+ }
+ window.__installBackupRoot = () => {
+ window.__backupRoot = new MemoryDirectoryHandle('chosen-parent');
+ Object.defineProperty(window, 'showDirectoryPicker', {
+ value: async () => window.__backupRoot,
+ configurable: true
+ });
+ };
+ window.__installBackupRoot();
+ }"""
+ )
+ library.locator("#create-folder-backup").click()
+ expect(library.locator("#data-safety-feedback")).to_contain_text("完整备份已完成", timeout=15_000)
+ backup_result = library.evaluate(
+ """async () => {
+ const folder = [...window.__backupRoot.directories.values()][0];
+ const libraryJson = JSON.parse(await (await folder.files.get('library.json').getFile()).text());
+ const completion = JSON.parse(await (await folder.files.get('complete.json').getFile()).text());
+ const trashEntry = libraryJson.trashState.items.find((item) => item.kind === 'entry');
+ const linkedEntry = libraryJson.entries.find((entry) => entry.id === 'linked-one');
+ return {
+ completeExists: folder.files.has('complete.json'),
+ trashCases: completion.trashCaseCount,
+ trashProjects: completion.trashProjectCount,
+ manifestPaths: completion.files.map((item) => item.path),
+ trashAsset: trashEntry.snapshot.mediaAssets[0],
+ linkedAsset: linkedEntry.mediaAssets[0]
+ };
+ }"""
+ )
+ assert backup_result["completeExists"] is True, backup_result
+ assert backup_result["trashCases"] == 1 and backup_result["trashProjects"] == 1, backup_result
+ assert "library.json" in backup_result["manifestPaths"], backup_result
+ assert backup_result["trashAsset"]["storageMode"] == "managed", backup_result
+ assert backup_result["trashAsset"]["assetPath"] in backup_result["manifestPaths"], backup_result
+ assert backup_result["linkedAsset"]["storageMode"] == "managed", backup_result
+ assert backup_result["linkedAsset"]["assetPath"] in backup_result["manifestPaths"], backup_result
+ assert "recordType" not in backup_result["linkedAsset"], backup_result
+
+ library.evaluate(
+ """async () => {
+ window.__portableBackupFolder = [...window.__backupRoot.directories.values()][0];
+ const media = await import(chrome.runtime.getURL('media-store.js'));
+ for (const id of ['share-image-one', 'share-image-two', 'share-poster', 'share-video', 'share-document', 'trash-image', 'linked-local-image']) {
+ await media.deleteMediaBlob(id);
+ }
+ const {deleteLocalAssetHandle} = await import(chrome.runtime.getURL('local-asset-store.js'));
+ await deleteLocalAssetHandle('linked-local-image');
+ await chrome.storage.local.set({
+ entries: [],
+ trashState: {version: 1, items: []},
+ organizerState: {version: 7, collections: []},
+ compoundCases: [],
+ composerSessions: [],
+ creativeRuns: [],
+ creativeSkills: {version: 1, items: []}
+ });
+ Object.defineProperty(window, 'showDirectoryPicker', {
+ value: async () => window.__portableBackupFolder,
+ configurable: true
+ });
+ }"""
+ )
+ library.locator("#restore-folder-backup").click()
+ restore_dialog = library.locator("#promptdirector-app-dialog")
+ expect(restore_dialog).to_be_visible(timeout=15_000)
+ expect(restore_dialog).to_contain_text("恢复资料库备份")
+ restore_dialog.locator("button[type='submit']").click()
+ expect(library.locator("#data-safety-feedback")).to_contain_text("媒体文件校验并恢复完成", timeout=15_000)
+ restored_state = library.evaluate(
+ """async () => {
+ const state = await chrome.runtime.sendMessage({type: 'GET_STATE'});
+ const media = await import(chrome.runtime.getURL('media-store.js'));
+ return {
+ entryIds: state.entries.map((entry) => entry.id).sort(),
+ trashKinds: state.trashState.items.map((item) => item.kind).sort(),
+ activeImageBytes: (await media.getMediaBlob('share-image-one'))?.size || 0,
+ trashImageBytes: (await media.getMediaBlob('trash-image'))?.size || 0,
+ linkedImageBytes: (await media.getMediaBlob('linked-local-image'))?.size || 0,
+ linkedStorageMode: state.entries.find((entry) => entry.id === 'linked-one')?.mediaAssets?.[0]?.storageMode || ''
+ };
+ }"""
+ )
+ assert restored_state["entryIds"] == ["linked-one", "share-one", "share-two"], restored_state
+ assert restored_state["trashKinds"] == ["collection", "entry"], restored_state
+ assert restored_state["activeImageBytes"] > 0 and restored_state["trashImageBytes"] > 0, restored_state
+ assert restored_state["linkedImageBytes"] > 0 and restored_state["linkedStorageMode"] == "managed", restored_state
+
+ library.evaluate(
+ """async () => {
+ const stored = await chrome.storage.local.get('entries');
+ const linked = {
+ ...stored.entries[0],
+ id: 'unreadable-linked-case',
+ title: '失效本机链接',
+ mediaAssets: [{
+ id: 'unreadable-linked-asset',
+ recordType: 'local-asset-reference',
+ kind: 'attachment',
+ storageMode: 'reference',
+ mimeType: 'application/octet-stream',
+ byteSize: 12,
+ sourceTitle: 'missing.zzz',
+ sourceFormat: 'zzz',
+ formatCategory: 'local-link',
+ relativePath: 'missing.zzz',
+ linkStatus: 'relink-required',
+ importFailure: {
+ code: 'unsupported_format',
+ message: '不支持的素材格式',
+ forceAllowed: false
+ }
+ }],
+ primaryMediaId: 'unreadable-linked-asset'
+ };
+ await chrome.storage.local.set({entries: [...stored.entries, linked]});
+ window.__installBackupRoot();
+ }"""
+ )
+ library.locator("#create-folder-backup").click()
+ expect(library.locator("#data-safety-feedback")).to_contain_text("未写入完成标记", timeout=15_000)
+ failed_backup = library.evaluate(
+ """() => {
+ const folder = [...window.__backupRoot.directories.values()][0];
+ return {created: Boolean(folder), completeExists: Boolean(folder?.files.has('complete.json'))};
+ }"""
+ )
+ assert failed_backup == {"created": True, "completeExists": False}, failed_backup
+ print({"shared_entries": 2, "curated_submission": True, "private_drafts_removed": True, "data_safety": True, "folder_backup": backup_result, "cross_machine_restore": restored_state, "unreadable_source_no_marker": failed_backup, "offline_preview": True, "mobile_width": 390, "screenshots": str(screenshots)})
if __name__ == "__main__":
diff --git a/test/temp-references.test.js b/test/temp-references.test.js
index 18a6b0b..6082723 100644
--- a/test/temp-references.test.js
+++ b/test/temp-references.test.js
@@ -167,6 +167,26 @@ test("a partial temporary-image analysis remains eligible for completion", () =>
}), []);
});
+test("a fingerprint-bound legacy description is usable without requesting another image analysis", () => {
+ const reference = {
+ referenceKind: "vision",
+ referenceText: "被青绿色薄雾包围的古代庭院。",
+ imageRefs: [{ visualId: "legacy-image", mimeType: "image/webp" }],
+ assets: [{
+ assetId: "legacy-image",
+ imageFingerprint: "legacy-hash",
+ analysisImageFingerprint: "legacy-hash",
+ analysisVersion: 1,
+ reconstructionPrompt: ""
+ }]
+ };
+ assert.deepEqual(unreadReferenceImageAssets(reference), []);
+ assert.deepEqual(unreadReferenceImageAssets({
+ ...reference,
+ assets: [{ ...reference.assets[0], analysisImageFingerprint: "other-image" }]
+ }).map((item) => item.assetId), ["legacy-image"]);
+});
+
test("text, Markdown, and HTML attachments expose readable text without script content", async () => {
const parser = (html) => ({
body: {
diff --git a/test/trash.test.js b/test/trash.test.js
index 284e52f..a99e27f 100644
--- a/test/trash.test.js
+++ b/test/trash.test.js
@@ -300,6 +300,30 @@ test("restoring a child without its missing parent moves it to root and reports
assert.match(restored.warnings[0].reason, /恢复到根级/);
});
+test("restoring a legacy root project without parentId reclaims its original sibling position", () => {
+ const restored = restoreTrashItems({
+ entries: [],
+ organizerState: {
+ collections: [{ id: "collection:outside", name: "Outside", parentId: null, order: 0, entryIds: [] }]
+ },
+ trashState: {
+ items: [{
+ id: "trash:collection:collection:root",
+ kind: "collection",
+ targetId: "collection:root",
+ deletedAt: "2026-08-24T00:00:00Z",
+ snapshot: { id: "collection:root", name: "Root", order: 0, entryIds: [] },
+ relationships: {}
+ }]
+ }
+ }, ["trash:collection:collection:root"]);
+
+ assert.deepEqual(restored.organizerState.collections.map(({ id, parentId, order }) => ({ id, parentId, order })), [
+ { id: "collection:root", parentId: null, order: 0 },
+ { id: "collection:outside", parentId: null, order: 1 }
+ ]);
+});
+
test("moving a case to trash keeps its labels and exact project memberships without ghost references", () => {
const source = {
trashState: createDefaultTrashState(),
@@ -340,6 +364,90 @@ test("moving a case to trash keeps its labels and exact project memberships with
assert.deepEqual(repeated, { ...moved, movedItemIds: [] });
});
+test("moving a project with its cases rejects an existing case trash target without changing the source", () => {
+ const source = {
+ trashState: {
+ version: TRASH_VERSION,
+ items: [{
+ id: "trash:entry:one",
+ kind: "entry",
+ targetId: "one",
+ deletedAt: "2026-08-21T00:00:00Z",
+ snapshot: { id: "one", title: "较早删除的案例" },
+ relationships: {}
+ }]
+ },
+ entries: [
+ { id: "one", title: "当前案例一" },
+ { id: "two", title: "当前案例二" },
+ { id: "outside", title: "树外案例" }
+ ],
+ organizerState: {
+ collections: [
+ { id: "collection:a", name: "项目 A", order: 0, entryIds: ["one", "two"] },
+ { id: "collection:outside", name: "树外项目", order: 1, entryIds: ["outside", "one"] }
+ ]
+ },
+ compoundCases: [{
+ id: "compound:a",
+ title: "组合",
+ memberEntryIds: ["one", "two"],
+ coverVisualId: "",
+ customLabels: [],
+ createdAt: "2026-08-20T00:00:00Z",
+ updatedAt: "2026-08-20T00:00:00Z"
+ }]
+ };
+ const before = structuredClone(source);
+ const serializedBefore = JSON.stringify(source);
+
+ assert.throws(
+ () => moveCollectionWithEntriesToTrash(source, "collection:a", { deletedAt: "2026-08-22T06:00:00Z" }),
+ (error) => {
+ assert.equal(error.code, "TRASH_TARGET_CONFLICT");
+ assert.match(error.message, /回收站.*冲突/);
+ assert.deepEqual(error.conflictingTrashIds, ["trash:entry:one"]);
+ return true;
+ }
+ );
+ assert.deepEqual(source, before);
+ assert.equal(JSON.stringify(source), serializedBefore);
+});
+
+test("moving a project with its cases rejects a trash target collision anywhere in the project subtree", () => {
+ const source = {
+ trashState: {
+ version: TRASH_VERSION,
+ items: [{
+ id: "trash:collection:collection:child",
+ kind: "collection",
+ targetId: "collection:child",
+ deletedAt: "2026-08-21T00:00:00Z",
+ snapshot: { id: "collection:child", name: "较早删除的子项目", parentId: "collection:root", order: 0, entryIds: [] },
+ relationships: {}
+ }]
+ },
+ entries: [{ id: "root-case" }, { id: "child-case" }],
+ organizerState: {
+ collections: [
+ { id: "collection:root", name: "Root", parentId: null, order: 0, entryIds: ["root-case"] },
+ { id: "collection:child", name: "Child", parentId: "collection:root", order: 0, entryIds: ["child-case"] }
+ ]
+ }
+ };
+ const before = structuredClone(source);
+
+ assert.throws(
+ () => moveCollectionWithEntriesToTrash(source, "collection:root", { deletedAt: "2026-08-22T06:00:00Z" }),
+ (error) => {
+ assert.equal(error.code, "TRASH_TARGET_CONFLICT");
+ assert.deepEqual(error.conflictingTrashIds, ["trash:collection:collection:child"]);
+ return true;
+ }
+ );
+ assert.deepEqual(source, before);
+});
+
test("moving a project with its cases preserves project and compound relationships until permanent deletion", () => {
const source = {
trashState: createDefaultTrashState(),
@@ -384,6 +492,97 @@ test("moving a project with its cases preserves project and compound relationshi
assert.deepEqual(restored.trashState.items, []);
});
+test("a project subtree with shared and compound cases can be restored and deleted again", () => {
+ const source = {
+ trashState: createDefaultTrashState(),
+ entries: [
+ {
+ id: "shared",
+ title: "共享案例",
+ mediaAssets: [{ id: "image:shared", kind: "image", storageMode: "managed", capturedAt: "2026-08-20T00:00:00Z" }]
+ },
+ {
+ id: "child-only",
+ title: "子项目案例",
+ mediaAssets: [{ id: "image:child", kind: "image", storageMode: "managed", capturedAt: "2026-08-20T00:00:00Z" }]
+ },
+ { id: "outside", title: "树外案例" }
+ ],
+ organizerState: {
+ collections: [
+ { id: "collection:root", name: "Root", parentId: null, order: 0, entryIds: ["shared"] },
+ { id: "collection:child", name: "Child", parentId: "collection:root", order: 0, entryIds: ["child-only", "shared"] },
+ { id: "collection:outside", name: "Outside", parentId: null, order: 1, entryIds: ["outside", "shared"] }
+ ]
+ },
+ compoundCases: [{
+ id: "compound:shared-child",
+ title: "共享组合",
+ memberEntryIds: ["shared", "child-only"],
+ coverVisualId: "image:shared",
+ customLabels: ["组合"],
+ createdAt: "2026-08-20T00:00:00Z",
+ updatedAt: "2026-08-20T00:00:00Z"
+ }]
+ };
+ const before = structuredClone(source);
+
+ const moved = moveCollectionWithEntriesToTrash(source, "collection:root", {
+ deletedAt: "2026-08-22T06:00:00Z"
+ });
+ assert.deepEqual(source, before);
+ assert.deepEqual(moved.entries.map((entry) => entry.id), ["outside"]);
+ assert.deepEqual(moved.organizerState.collections.map((collection) => ({ id: collection.id, entryIds: collection.entryIds })), [
+ { id: "collection:outside", entryIds: ["outside"] }
+ ]);
+ assert.deepEqual(moved.compoundCases, []);
+ assert.deepEqual(moved.movedItemIds, [
+ "trash:entry:shared",
+ "trash:entry:child-only",
+ "trash:collection:collection:root",
+ "trash:collection:collection:child"
+ ]);
+ assert.equal(new Set(moved.movedItemIds).size, moved.movedItemIds.length);
+ assert.deepEqual([...new Set(moved.trashState.items.slice(-4).map((item) => item.deletedAt))], ["2026-08-22T06:00:00.000Z"]);
+ assert.deepEqual(
+ moved.trashState.items.find((item) => item.id === "trash:entry:shared").relationships.collections,
+ [
+ { id: "collection:root", index: 0 },
+ { id: "collection:child", index: 1 },
+ { id: "collection:outside", index: 1 }
+ ]
+ );
+
+ const restored = restoreTrashItems(moved, moved.movedItemIds);
+ assert.deepEqual(restored.trashState.items, []);
+ assert.deepEqual(restored.entries.map((entry) => entry.id), ["outside", "shared", "child-only"]);
+ const restoredCollections = new Map(restored.organizerState.collections.map((collection) => [collection.id, collection]));
+ assert.deepEqual(
+ ["collection:root", "collection:child", "collection:outside"].map((id) => {
+ const collection = restoredCollections.get(id);
+ return { id, parentId: collection.parentId, order: collection.order, entryIds: collection.entryIds };
+ }),
+ [
+ { id: "collection:root", parentId: null, order: 0, entryIds: ["shared"] },
+ { id: "collection:child", parentId: "collection:root", order: 0, entryIds: ["child-only", "shared"] },
+ { id: "collection:outside", parentId: null, order: 1, entryIds: ["outside", "shared"] }
+ ]
+ );
+ assert.deepEqual(restored.compoundCases.map((compound) => ({ id: compound.id, memberEntryIds: compound.memberEntryIds })), [
+ { id: "compound:shared-child", memberEntryIds: ["shared", "child-only"] }
+ ]);
+
+ const movedAgain = moveCollectionWithEntriesToTrash(restored, "collection:root", {
+ deletedAt: "2026-08-23T06:00:00Z"
+ });
+ assert.deepEqual(movedAgain.movedItemIds, moved.movedItemIds);
+ assert.deepEqual(movedAgain.entries.map((entry) => entry.id), ["outside"]);
+ assert.deepEqual(movedAgain.organizerState.collections.map((collection) => ({ id: collection.id, entryIds: collection.entryIds })), [
+ { id: "collection:outside", entryIds: ["outside"] }
+ ]);
+ assert.deepEqual(movedAgain.compoundCases, []);
+});
+
test("media trash restores visual-derived labels and permanent cleanup protects active shared blobs", () => {
const entry = {
id: "case:one",
diff --git a/trash.js b/trash.js
index b764f5f..f15081f 100644
--- a/trash.js
+++ b/trash.js
@@ -87,6 +87,19 @@ export function moveCollectionWithEntriesToTrash(contextValue = {}, collectionId
const subtreeCollectionIds = collectionSubtreeIds(organizerState, collection.id);
const subtreeEntryIds = collectionEntryIds(organizerState, collection.id, { subtree: true });
+ const activeEntryIds = new Set(entries.map((entry) => clean(entry?.id)));
+ const targetTrashIds = [
+ ...subtreeEntryIds.filter((id) => activeEntryIds.has(id)).map((id) => trashItemId("entry", id)),
+ ...subtreeCollectionIds.map((id) => trashItemId("collection", id))
+ ];
+ const existingTrashIds = new Set(normalizeTrashState(contextValue.trashState).items.map((item) => item.id));
+ const conflictingTrashIds = targetTrashIds.filter((id) => existingTrashIds.has(id));
+ if (conflictingTrashIds.length) {
+ throw Object.assign(new Error("回收站目标冲突,未执行删除"), {
+ code: "TRASH_TARGET_CONFLICT",
+ conflictingTrashIds
+ });
+ }
const entriesMoved = moveEntriesToTrash({ ...contextValue, organizerState }, subtreeEntryIds, options);
const collectionMoved = moveCollectionsToTrash({
...contextValue,
@@ -324,12 +337,28 @@ function restoreCollectionItems(items, organizerState, restorableEntryIds) {
if (originalParentId && !availableIds.has(originalParentId)) {
acceptedItem.snapshot.parentId = null;
warnings.push({ itemId: acceptedItem.item.id, reason: "原父项目不存在,已恢复到根级", missingParentId: originalParentId });
+ } else {
+ acceptedItem.snapshot.parentId = originalParentId || null;
}
}
+ const collectionsByParent = new Map();
+ for (const collection of structuredClone(organizerState.collections)) {
+ const siblings = collectionsByParent.get(collection.parentId) ?? [];
+ siblings.push(collection);
+ collectionsByParent.set(collection.parentId, siblings);
+ }
+ const restoredSnapshots = accepted.map(({ snapshot }) => snapshot).filter(Boolean)
+ .toSorted((left, right) => clean(left.parentId).localeCompare(clean(right.parentId)) || safeIndex(left.order) - safeIndex(right.order));
+ for (const snapshot of restoredSnapshots) {
+ const siblings = collectionsByParent.get(snapshot.parentId) ?? [];
+ siblings.splice(Math.min(safeIndex(snapshot.order), siblings.length), 0, snapshot);
+ siblings.forEach((collection, order) => { collection.order = order; });
+ collectionsByParent.set(snapshot.parentId, siblings);
+ }
return {
organizerState: normalizeOrganizerState({
...organizerState,
- collections: [...organizerState.collections, ...accepted.map(({ snapshot }) => snapshot).filter(Boolean)]
+ collections: [...collectionsByParent.values()].flat()
}),
restoredItemIds: accepted.map(({ item }) => item.id),
unresolved,