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. 提示词导演
JavaScript ai-artai-videochrome-extensionclaude-codecodexhiggsfieldjimenglocal-firstmcpmidjourneymoodboardprompt-engineeringprompt-libraryprompt-managerreference-libraryseedancevisual-bookmarksweb-clipper
import { createBlobDigestCache } from "./blob-digest.js";
import { sharedLibraryMediaFiles } from "./library-shared-media.js";
import {
hasLibrarySalvageDiagnostics,
mergeLibraryPackage,
parseCompleteFolderBackup,
parseLibraryPackage
} from "./library-package.js";
import { filesWithoutInvalidLibraryImages, findInvalidImportedImageIds } from "./library-import-media.js";
import { createLibraryImportPlanToken } from "./library-import-transaction.js";
import { caseSemanticFingerprint } from "./library-semantic-identity.js";
import { libraryStoredAssetIds } from "./library-asset-inventory.js";
export const LIBRARY_TRANSFER_SOURCES = Object.freeze({
SHARE_PACKAGE: "share-package",
COMPLETE_BACKUP: "complete-backup",
RESCUE_BACKUP: "rescue-backup"
});
export const LIBRARY_TRANSFER_MODES = Object.freeze({
SAFE_MERGE: "safe-merge",
EXACT_REPLACE: "exact-replace"
});
const SOURCE_TYPES = new Set(Object.values(LIBRARY_TRANSFER_SOURCES));
export async function inspectLibraryTransfer({
sourceType,
library,
files = new Map(),
limits = {},
validateImage,
signal,
onImageProgress,
sourceReport,
digest = createBlobDigestCache()
} = {}) {
if (!SOURCE_TYPES.has(sourceType)) throw new Error("资料检查缺少有效来源类型");
if (!(files instanceof Map)) throw new Error("资料检查缺少有效资源清单");
files = await sharedLibraryMediaFiles(library, files, { signal, digest });
const strict = sourceType === LIBRARY_TRANSFER_SOURCES.COMPLETE_BACKUP;
const sourceDiagnostics = Array.isArray(sourceReport?.diagnostics)
? structuredClone(sourceReport.diagnostics)
: [];
let effectiveSourceType = sourceType;
let inspected;
if (strict) {
try {
inspected = await parseCompleteFolderBackup(library, files, limits, { signal, digest });
} catch (error) {
let rescued;
try {
rescued = parseLibraryPackage(library, files, { ...limits, salvageInvalidMedia: true });
} catch {
throw error;
}
if (!hasLibrarySalvageDiagnostics(rescued.importDiagnostics)) throw error;
inspected = rescued;
effectiveSourceType = LIBRARY_TRANSFER_SOURCES.RESCUE_BACKUP;
sourceDiagnostics.push(completeBackupRescueDiagnostic());
}
} else {
inspected = parseLibraryPackage(library, files, { ...limits, salvageInvalidMedia: true });
}
if (validateImage !== undefined) {
const invalidImageIds = await findInvalidImportedImageIds(inspected.images, validateImage, { signal, onProgress: onImageProgress });
if (invalidImageIds.size) {
const salvageFiles = filesWithoutInvalidLibraryImages(library, files, invalidImageIds);
inspected = parseLibraryPackage(library, salvageFiles, { ...limits, salvageInvalidMedia: true });
if (strict) {
effectiveSourceType = LIBRARY_TRANSFER_SOURCES.RESCUE_BACKUP;
sourceDiagnostics.push(completeBackupRescueDiagnostic());
}
inspected.importDiagnostics = inspected.importDiagnostics.map((diagnostic) =>
diagnostic.action === "dropped" && invalidImageIds.has(diagnostic.assetId)
? { ...diagnostic, reason: "decode_failure" }
: diagnostic
);
}
}
const {
assets,
images,
skillAssets,
importDiagnostics,
importStats,
...state
} = inspected;
const diagnostics = [...sourceDiagnostics, ...structuredClone(importDiagnostics)];
return {
sourceType: effectiveSourceType,
state,
resources: { assets, images, skillAssets },
resourceIndex: {
mediaAssetIds: [...assets.keys()],
skillAssetIds: [...skillAssets.keys()]
},
report: {
status: diagnostics.length ? "partial" : "ready",
diagnostics,
stats: mergeReportStats(sourceReport?.stats, importStats)
}
};
}
function completeBackupRescueDiagnostic() {
return {
code: "backup_integrity_degraded",
severity: "backup",
action: "rescue",
reason: "recoverable_content_failure"
};
}
export function planLibraryTransfer({ currentState = {}, inspection, options = {} } = {}) {
if (!inspection?.state || !inspection?.report) throw new Error("资料恢复计划缺少检查结果");
const preferredPlan = options.preferredPlan && typeof options.preferredPlan === "object"
? options.preferredPlan
: {};
const preferredMappings = preferredPlan.mappings && typeof preferredPlan.mappings === "object"
? preferredPlan.mappings
: {};
const mode = normalizeTransferMode(preferredPlan.mode ?? options.mode);
if (mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE && inspection.sourceType !== LIBRARY_TRANSFER_SOURCES.COMPLETE_BACKUP) {
throw new Error("救援备份只能安全合并,不能恢复成备份当时状态");
}
const libraryAddedAt = receiverTimestamp(preferredPlan.libraryAddedAt || options.now);
const importBatchId = clean(preferredPlan.importBatchId || options.importBatchId) ||
`library-import:${globalThis.crypto.randomUUID()}`;
const preserveLibraryConfiguration = preferredPlan.preserveLibraryConfiguration === true ||
(!Object.hasOwn(preferredPlan, "preserveLibraryConfiguration") && options.preserveLibraryConfiguration === true);
const importReport = cloneReport(preferredPlan.importReport ?? inspection.report);
const conflicts = mode === LIBRARY_TRANSFER_MODES.SAFE_MERGE
? libraryEntryConflicts(currentState.entries, inspection.state.entries)
: [];
const conflictResolutions = plannedConflictResolutions(
conflicts,
preferredPlan.conflictResolutions ?? options.conflictResolutions
);
const resourceIndex = inspection.resourceIndex ?? {
mediaAssetIds: inspection.resources?.assets instanceof Map ? [...inspection.resources.assets.keys()] : [],
skillAssetIds: inspection.resources?.skillAssets instanceof Map ? [...inspection.resources.skillAssets.keys()] : []
};
const exactVisualIdMap = mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? isolatedResourceMap(resourceIndex.mediaAssetIds, preferredMappings.visualIds, "restore-media")
: preferredMappings.visualIds;
const exactSkillAssetIdMap = mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? isolatedResourceMap(resourceIndex.skillAssetIds, preferredMappings.skillAssetIds, "skill-file:restore")
: preferredMappings.skillAssetIds;
const mergeReceiver = mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? exactReplacementReceiver(inspection.state)
: currentState;
const result = mergeLibraryPackage(mergeReceiver, inspection.state, {
preserveLibraryConfiguration: mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE || preserveLibraryConfiguration,
preserveCaseIdentities: mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE,
libraryAddedAt,
importBatchId,
importReport,
facetIdMap: preferredMappings.facetIds,
nodeIdMap: preferredMappings.nodeIds,
entryIdMap: preferredMappings.entryIds,
collectionIdMap: preferredMappings.collectionIds,
compoundIdMap: preferredMappings.compoundIds,
visualIdMap: exactVisualIdMap,
reservedVisualIds: mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE ? resourceIndex.mediaAssetIds : [],
entryConflictResolutions: conflictResolutions,
sessionIdMap: preferredMappings.sessionIds,
runIdMap: preferredMappings.runIds,
skillIdMap: preferredMappings.skillIds,
skillVersionIdMap: preferredMappings.skillVersionIds,
packageAssetIdMap: exactSkillAssetIdMap,
trashEntryIdMap: preferredMappings.trashEntryIds,
trashCollectionIdMap: preferredMappings.trashCollectionIds,
trashCompoundIdMap: preferredMappings.trashCompoundIds
});
if (mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE) {
restoreExactEntryImportMetadata(result.state.entries, inspection.state.entries, result.entryIdMap);
}
const mappings = {
entryIds: result.entryIdMap,
collectionIds: result.collectionIdMap ?? {},
facetIds: result.facetIdMap ?? {},
nodeIds: result.nodeIdMap ?? {},
compoundIds: result.compoundIdMap,
visualIds: result.visualIdMap,
createdVisualIds: result.createdVisualIdMap,
sessionIds: result.sessionIdMap,
runIds: result.runIdMap,
skillIds: result.skillIdMap,
skillVersionIds: result.skillVersionIdMap ?? {},
skillAssetIds: result.packageAssetIdMap,
trashEntryIds: result.trashEntryIdMap ?? {},
trashCollectionIds: result.trashCollectionIdMap ?? {},
trashCompoundIds: result.trashCompoundIdMap ?? {}
};
const resourceWrites = [
...resourceIndex.mediaAssetIds.flatMap((sourceId) => (
mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE ? mappings.visualIds[sourceId] : mappings.createdVisualIds[sourceId]
)
? [{
sourceId,
targetId: mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? mappings.visualIds[sourceId]
: mappings.createdVisualIds[sourceId],
resourceType: "media"
}]
: []),
...resourceIndex.skillAssetIds.flatMap((sourceId) => mappings.skillAssetIds[sourceId]
? [{ sourceId, targetId: mappings.skillAssetIds[sourceId], resourceType: "skill" }]
: [])
];
const rollback = mode === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? { required: true, retainedAssetIds: retainedLibraryAssetIds(currentState) }
: { required: false, retainedAssetIds: [] };
const context = {
version: 1,
sourceType: inspection.sourceType,
mode,
preserveLibraryConfiguration,
libraryAddedAt,
importBatchId,
importReport,
mappings,
conflictResolutions,
resourceWrites,
cleanupAssetIds: [],
rollback
};
return {
...result,
targetState: result.state,
mappings,
resourceWrites,
cleanupAssetIds: [],
rollback,
conflicts: conflicts.map((conflict) => ({
...conflict,
resolution: conflictResolutions[conflict.entryId]
})),
context,
planToken: createLibraryImportPlanToken(currentState, inspection.state, context)
};
}
export function planLibraryTransferBatch({ currentState = {}, inspections = [], options = {} } = {}) {
if (!Array.isArray(inspections) || !inspections.length) throw new Error("批次导入缺少检查通过的案例包");
if (inspections.some((inspection) => !inspection?.state || !inspection?.report)) {
throw new Error("批次导入包含未经检查的案例包");
}
if (inspections.some((inspection) => inspection.sourceType !== LIBRARY_TRANSFER_SOURCES.SHARE_PACKAGE)) {
throw new Error("批次导入只接受案例分享包");
}
const preferredPlan = options.preferredPlan && typeof options.preferredPlan === "object"
? options.preferredPlan
: {};
const preferredItems = Array.isArray(preferredPlan.items) ? preferredPlan.items : [];
if (preferredItems.length && preferredItems.length !== inspections.length) {
throw new Error("批次导入计划与案例包数量不一致,请重新检查");
}
const libraryAddedAt = receiverTimestamp(preferredPlan.libraryAddedAt || options.now);
const importBatchId = clean(preferredPlan.importBatchId || options.importBatchId) ||
`library-import:${globalThis.crypto.randomUUID()}`;
const preserveLibraryConfiguration = preferredPlan.preserveLibraryConfiguration === true ||
(!Object.hasOwn(preferredPlan, "preserveLibraryConfiguration") && options.preserveLibraryConfiguration === true);
const requestedResolutions = preferredPlan.conflictResolutions && typeof preferredPlan.conflictResolutions === "object"
? preferredPlan.conflictResolutions
: options.conflictResolutions && typeof options.conflictResolutions === "object"
? options.conflictResolutions
: {};
const explicitConflictKeys = new Set(Array.isArray(preferredPlan.explicitConflictKeys)
? preferredPlan.explicitConflictKeys.map(clean).filter(Boolean)
: Object.keys(requestedResolutions));
const originalEntryIds = new Set((Array.isArray(currentState?.entries) ? currentState.entries : [])
.map((entry) => clean(entry?.id)).filter(Boolean));
let targetState = currentState;
const itemResults = [];
const conflicts = [];
const resourceWrites = [];
for (let sourceIndex = 0; sourceIndex < inspections.length; sourceIndex += 1) {
const inspection = inspections[sourceIndex];
const preferredItem = preferredItems[sourceIndex];
const itemResolutions = Object.fromEntries((Array.isArray(inspection.state.entries) ? inspection.state.entries : [])
.map((entry) => clean(entry?.id)).filter(Boolean).flatMap((entryId) => {
const resolution = requestedResolutions[batchConflictKey(sourceIndex, entryId)];
return ["keep-local", "use-incoming", "keep-both"].includes(resolution)
? [[entryId, resolution]]
: [];
}));
const result = planLibraryTransfer({
currentState: targetState,
inspection,
options: preferredItem
? { preferredPlan: preferredItem }
: {
preserveLibraryConfiguration,
now: libraryAddedAt,
importBatchId,
conflictResolutions: itemResolutions
}
});
targetState = result.targetState;
for (const conflict of result.conflicts) {
const conflictKey = batchConflictKey(sourceIndex, conflict.entryId);
const requiresResolution = !originalEntryIds.has(conflict.entryId);
conflicts.push({
...conflict,
sourceIndex,
conflictKey,
requiresResolution,
unresolved: requiresResolution && !explicitConflictKeys.has(conflictKey)
});
}
resourceWrites.push(...result.resourceWrites.map((write) => ({ ...write, sourceIndex })));
itemResults.push({ sourceIndex, ...result });
}
assertDistinctBatchResourceTargets(resourceWrites);
const conflictResolutions = Object.fromEntries(conflicts.map((conflict) => [
conflict.conflictKey,
conflict.resolution
]));
const context = {
version: 1,
sourceType: "share-package-batch",
preserveLibraryConfiguration,
libraryAddedAt,
importBatchId,
conflictResolutions,
explicitConflictKeys: [...explicitConflictKeys].filter((key) => Object.hasOwn(conflictResolutions, key)).sort(),
items: itemResults.map((item) => item.context),
resourceWrites,
cleanupAssetIds: [],
rollback: { required: false, retainedAssetIds: [] }
};
const unresolvedConflicts = conflicts.filter((conflict) => conflict.unresolved);
return {
targetState,
packageResults: itemResults.map(batchPackageResult),
resourceWrites,
cleanupAssetIds: [],
rollback: context.rollback,
conflicts,
unresolvedConflicts,
canApply: unresolvedConflicts.length === 0,
context,
planToken: createLibraryImportPlanToken(currentState, inspections.map((inspection) => inspection.state), context),
createdEntryIds: uniqueValues(itemResults.flatMap((item) => item.createdEntryIds)),
importDiagnostics: itemResults.flatMap((item) => (item.importDiagnostics ?? [])
.map((diagnostic) => ({ ...structuredClone(diagnostic), sourceIndex: item.sourceIndex }))),
importStats: mergeBatchImportStats(itemResults.map((item) => item.importStats)),
importedCount: sumResult(itemResults, "importedCount"),
remappedCount: sumResult(itemResults, "remappedCount"),
skippedCount: sumResult(itemResults, "skippedCount"),
importedRunCount: sumResult(itemResults, "importedRunCount"),
importedOutputCount: sumResult(itemResults, "importedOutputCount"),
importedSkillCount: sumResult(itemResults, "importedSkillCount"),
skippedSkillCount: sumResult(itemResults, "skippedSkillCount")
};
}
export function libraryTransferWriteBytes(resourceWritesValue, resourcesValue = {}) {
const assets = resourcesValue?.assets instanceof Map ? resourcesValue.assets : new Map();
const skillAssets = resourcesValue?.skillAssets instanceof Map ? resourcesValue.skillAssets : new Map();
let total = 0;
for (const item of Array.isArray(resourceWritesValue) ? resourceWritesValue : []) {
const blob = item?.resourceType === "skill"
? skillAssets.get(item.sourceId)
: assets.get(item?.sourceId);
if (!(blob instanceof Blob)) throw new Error("恢复计划引用的资源已经变化,请重新检查");
total += blob.size;
}
return total;
}
function batchConflictKey(sourceIndex, entryId) {
return `${sourceIndex}:${clean(entryId)}`;
}
function batchPackageResult(item) {
return {
sourceIndex: item.sourceIndex,
conflicts: item.conflicts.map((conflict) => ({
...conflict,
conflictKey: batchConflictKey(item.sourceIndex, conflict.entryId)
})),
resourceWrites: item.resourceWrites.map((write) => ({ ...write, sourceIndex: item.sourceIndex })),
createdEntryIds: [...item.createdEntryIds],
importDiagnostics: structuredClone(item.importDiagnostics ?? []),
importStats: structuredClone(item.importStats ?? {}),
importedCount: item.importedCount,
remappedCount: item.remappedCount,
skippedCount: item.skippedCount,
importedRunCount: item.importedRunCount,
importedOutputCount: item.importedOutputCount,
importedSkillCount: item.importedSkillCount,
skippedSkillCount: item.skippedSkillCount
};
}
function assertDistinctBatchResourceTargets(resourceWrites) {
const targets = new Set();
for (const write of resourceWrites) {
if (!clean(write?.targetId) || targets.has(write.targetId)) {
throw new Error("批次导入资源映射发生冲突,请重新检查");
}
targets.add(write.targetId);
}
}
function sumResult(items, key) {
return items.reduce((sum, item) => sum + (Number(item?.[key]) || 0), 0);
}
function uniqueValues(values) {
return [...new Set(values.map(clean).filter(Boolean))];
}
function mergeBatchImportStats(values) {
const result = {};
for (const value of values) {
for (const [key, item] of Object.entries(value && typeof value === "object" ? value : {})) {
result[key] = Number.isFinite(Number(item))
? (Number(result[key]) || 0) + Number(item)
: structuredClone(item);
}
}
return result;
}
function normalizeTransferMode(value) {
return value === LIBRARY_TRANSFER_MODES.EXACT_REPLACE
? LIBRARY_TRANSFER_MODES.EXACT_REPLACE
: LIBRARY_TRANSFER_MODES.SAFE_MERGE;
}
function libraryEntryConflicts(currentEntriesValue, incomingEntriesValue) {
const current = new Map((Array.isArray(currentEntriesValue) ? currentEntriesValue : [])
.map((entry) => [clean(entry?.id), entry]).filter(([id]) => Boolean(id)));
return (Array.isArray(incomingEntriesValue) ? incomingEntriesValue : []).flatMap((incoming) => {
const local = current.get(clean(incoming?.id));
if (!local) return [];
const localFingerprint = caseSemanticFingerprint(local);
const incomingFingerprint = caseSemanticFingerprint(incoming);
if (localFingerprint && incomingFingerprint && localFingerprint === incomingFingerprint) return [];
return [{
entryId: clean(incoming.id),
localTitle: clean(local.title) || "未命名案例",
incomingTitle: clean(incoming.title) || "未命名案例"
}];
});
}
function plannedConflictResolutions(conflicts, value) {
const requested = value && typeof value === "object" ? value : {};
return Object.fromEntries(conflicts.map((conflict) => {
const resolution = ["keep-local", "use-incoming", "keep-both"].includes(requested[conflict.entryId])
? requested[conflict.entryId]
: "keep-local";
return [conflict.entryId, resolution];
}));
}
function isolatedResourceMap(sourceIdsValue, preferredValue, prefix) {
const preferred = preferredValue && typeof preferredValue === "object" ? preferredValue : {};
const used = new Set();
return Object.fromEntries((Array.isArray(sourceIdsValue) ? sourceIdsValue : []).map((sourceIdValue) => {
const sourceId = clean(sourceIdValue);
const planned = clean(preferred[sourceId]);
const targetId = planned && planned !== sourceId && !used.has(planned)
? planned
: `${prefix}:${globalThis.crypto.randomUUID()}`;
used.add(targetId);
return [sourceId, targetId];
}).filter(([sourceId]) => Boolean(sourceId)));
}
function exactReplacementReceiver(source = {}) {
return {
...structuredClone(source),
entries: [],
trashState: { version: 1, items: [] },
organizerState: { version: 1, collections: [] },
compoundCases: [],
composerSessions: [],
creativeRuns: [],
creativeSkills: { version: 1, items: [] }
};
}
function restoreExactEntryImportMetadata(targetEntriesValue, sourceEntriesValue, entryIdMap = {}) {
const targets = new Map((Array.isArray(targetEntriesValue) ? targetEntriesValue : []).map((entry) => [entry.id, entry]));
for (const source of Array.isArray(sourceEntriesValue) ? sourceEntriesValue : []) {
const target = targets.get(entryIdMap[source.id] ?? source.id);
if (!target) continue;
for (const key of ["libraryAddedAt", "importBatchId", "importSource"]) {
if (Object.hasOwn(source, key)) target[key] = structuredClone(source[key]);
else delete target[key];
}
}
}
function retainedLibraryAssetIds(state = {}) {
return [...libraryStoredAssetIds(state)].sort();
}
function receiverTimestamp(value) {
const requested = clean(value);
return requested && Number.isFinite(Date.parse(requested))
? new Date(requested).toISOString()
: new Date().toISOString();
}
function cloneReport(value) {
return {
status: value?.status === "partial" ? "partial" : "ready",
diagnostics: Array.isArray(value?.diagnostics) ? structuredClone(value.diagnostics) : [],
stats: value?.stats && typeof value.stats === "object" ? structuredClone(value.stats) : {}
};
}
function mergeReportStats(sourceValue, inspectedValue) {
const merged = sourceValue && typeof sourceValue === "object" ? structuredClone(sourceValue) : {};
for (const [key, value] of Object.entries(inspectedValue && typeof inspectedValue === "object" ? inspectedValue : {})) {
const number = Number(value);
merged[key] = Number.isFinite(number) ? number : value;
}
return merged;
}
function clean(value) {
return String(value ?? "").trim();
}
// Preview and commit share the planner; only commit owns writes and revalidates the token.
export function previewLibraryTransferBatch(input) {
const result = planLibraryTransferBatch(input);
return {
ok: true,
planToken: result.planToken,
plan: result.context,
canApply: result.canApply,
conflicts: result.conflicts,
unresolvedConflicts: result.unresolvedConflicts,
packageResults: result.packageResults,
resourceWrites: result.resourceWrites,
createdEntryIds: result.createdEntryIds,
importDiagnostics: result.importDiagnostics,
importStats: result.importStats,
importedCount: result.importedCount,
remappedCount: result.remappedCount,
skippedCount: result.skippedCount,
importedRunCount: result.importedRunCount,
importedOutputCount: result.importedOutputCount,
importedSkillCount: result.importedSkillCount,
skippedSkillCount: result.skippedSkillCount
};
}