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 test from "node:test";
import assert from "node:assert/strict";
import { hasEnglishTranslation } from "../extension/i18n.js";
import { normalizeMediaAsset } from "../extension/media.js";
import {
PAGE_CAPTURE_ADAPTERS,
applyPageCaptureSelections,
combinePageCaptureCandidates,
collectPageCaptureSnapshot,
readPageCaptureInjectionResult,
detectPageCaptureAdapter,
mergePageCaptureRegionEdit,
normalizePageCaptureBatch,
normalizePageCaptureCandidate,
normalizePageCaptureSelection,
normalizeSourceFacts,
pageCaptureDefaultMediaIds,
reconcilePageCaptureArticlePlacement,
resolvePageCapturePageType,
pageCaptureMediaDecisionsResolved,
pageCaptureMediaFetchCandidates,
pageCapturePermissionOrigins,
pageCaptureStructureMatches,
resolvePageCaptureImage
} from "../extension/page-capture.js";
test('Chrome injection failures retain their actual cause instead of masquerading as an empty page', () => {
assert.throws(() => readPageCaptureInjectionResult({ result: { captureError: { message: '采集页面已改变;当前草稿已保留', code: 'PAGE_CAPTURE_FAILED' } } }), /采集页面已改变/u);
assert.throws(() => readPageCaptureInjectionResult({ result: null }), /未返回结果.*草稿已保留/u);
assert.throws(() => readPageCaptureInjectionResult({ error: { message: 'site failure' } }), /site failure/u);
assert.deepEqual(readPageCaptureInjectionResult({ result: { candidates: [] } }), { candidates: [] });
});
test("only media proven inside the article is proposed by default", () => {
const candidate = normalizePageCaptureCandidate({
title: "正文和素材区并存",
canonicalUrl: "https://example.com/article",
media: [
{ id: "article-image", kind: "image", url: "https://example.com/article.webp", placement: "inline" },
{ id: "asset-image", kind: "image", url: "https://example.com/asset.webp", placement: "unplaced" }
]
});
assert.deepEqual(pageCaptureDefaultMediaIds(candidate), ["article-image"]);
});
test("a social post keeps its post identity when the page also declares video and article data", () => {
assert.equal(resolvePageCapturePageType({
adapterPageType: "post",
structuredTypes: ["VideoObject", "Article"],
articleTextLength: 2_000,
cardCount: 1,
metadataType: "article"
}), "post");
});
test("article placement only puts DOM-proven media into the reading order", () => {
const result = reconcilePageCaptureArticlePlacement({
articleDocument: {
version: 1,
blocks: [
{ id: "copy-a", kind: "paragraph", text: "第一段正文", sourceOrder: 0 },
{ id: "copy-b", kind: "paragraph", text: "第二段正文", sourceOrder: 1 }
]
},
media: [
{ id: "inline-image", kind: "image", url: "https://cdn.example.com/article.webp" },
{ id: "asset-image", kind: "image", url: "https://cdn.example.com/asset.webp" }
],
contentTargets: [
{ id: "target-a", kind: "text", path: "main > p:nth-of-type(1)", articleBlockIds: ["copy-a"], mediaIds: [], sourceOrder: 0 },
{ id: "target-image", kind: "image", path: "main > img:nth-of-type(1)", articleBlockIds: [], mediaIds: ["inline-image"], sourceOrder: 1 },
{ id: "target-b", kind: "text", path: "main > p:nth-of-type(2)", articleBlockIds: ["copy-b"], mediaIds: [], sourceOrder: 2 }
]
});
assert.deepEqual(result.articleDocument.blocks.map((block) => block.id), ["copy-a", "article:image:inline-image", "copy-b"]);
assert.deepEqual(result.articleDocument.blocks.map((block) => block.sourceOrder), [0, 1, 2]);
assert.deepEqual(result.media.map((item) => [item.id, item.placement]), [
["inline-image", "inline"],
["asset-image", "unplaced"]
]);
});
test("candidate normalization preserves transient inline and unplaced media evidence", () => {
const candidate = normalizePageCaptureCandidate({
title: "有位置证据的文章",
canonicalUrl: "https://example.com/article",
media: [
{ id: "inline", kind: "image", url: "https://example.com/inline.webp", placement: "inline" },
{ id: "unplaced", kind: "image", url: "https://example.com/unplaced.webp", placement: "unplaced" }
]
});
assert.deepEqual(candidate.media.map((item) => item.placement), ["inline", "unplaced"]);
});
test("page capture quality evidence is complete in the English interface", () => {
const labels = [
"原网页选区",
"智能正文",
"结构化正文",
"页面正文",
"正文分段",
"{count} 段 · 可逐段确认",
"第 {count} 段",
"候选 {count}px",
"候选 {count}x",
"picture 响应图",
"延迟加载原图",
"srcset 响应图",
"站点原图",
"结构化原图",
"页面当前图",
"页面可见画面",
"CSS 背景图",
"公开原图失败时,只会使用当前网页已有登录状态读取已确认主体内的相关媒体;不会读取或保存登录信息。",
"预览不可用",
"保存案例 · 含 {count} 项媒体",
"保存 {cases} 个案例 · 含 {media} 项媒体",
"只保存 {count} 个正文案例",
"只保存正文",
"保存时将确认 {count} 项媒体",
"未识别到媒体,可返回网页补选",
"可能遗漏媒体({count})"
];
assert.deepEqual(labels.filter((label) => !hasEnglishTranslation(label)), []);
});
test("page capture adapter registry preserves first-wave routes and enables verified tool parsers", () => {
const fixtures = new Map([
["https://jimeng.jianying.com/ai-tool/home", "jimeng"],
["https://www.liblib.art/modelinfo/example", "liblibai"],
["https://higgsfield.ai/feed", "higgsfield"],
["https://www.krea.ai/apps/image/realtime", "krea"],
["https://www.tapnow.ai/explore", "tapnow"],
["https://www.pinterest.com/pin/123", "pinterest"],
["https://www.artstation.com/artwork/example", "artstation"],
["https://x.com/user/status/123", "x"],
["https://www.reddit.com/r/art/comments/abc/work", "reddit"],
["https://www.youtube.com/watch?v=abc", "youtube"],
["https://www.bilibili.com/video/BV1xx", "bilibili"],
["https://store.steampowered.com/app/123/game", "steam"]
]);
for (const [url, expected] of fixtures) assert.equal(detectPageCaptureAdapter(url).id, expected, url);
assert.equal(detectPageCaptureAdapter("https://example.com/article").id, "generic");
assert.equal(detectPageCaptureAdapter("https://mp.weixin.qq.com/s/example").id, "wechat");
assert.equal(detectPageCaptureAdapter("https://yesand.ai/prompt/example").id, "generic");
assert.equal(PAGE_CAPTURE_ADAPTERS.every((adapter) => adapter.fields && adapter.support), true);
});
test("whole-page scanning accumulates each virtualized viewport before the page restores its scroll", () => {
const source = collectPageCaptureSnapshot.toString();
const scan = source.slice(source.indexOf("async function scanLoadedPage"), source.indexOf("function detectAdapter"));
assert.match(scan, /collectVisible\(\)/);
assert.match(scan, /window\.scrollY.*viewport/);
assert.match(source, /accumulated\.set/);
assert.match(scan, /waitForVisibleMedia\(\)/);
assert.match(source, /image\.decode\(\)/);
assert.match(source, /PAGE_CAPTURE_VIEWPORT_FALLBACKS/);
});
test("page capture ignores ordinary iframes while retaining supported video providers", () => {
const source = collectPageCaptureSnapshot.toString();
assert.match(source, /element\.matches\("iframe"\) && !isSupportedVideoFrame\(element\)/);
assert.match(source, /player\.vimeo\.com/);
assert.match(source, /player\.bilibili\.com/);
});
test("page capture keeps source facts searchable without turning volatile metrics into labels", () => {
const facts = normalizeSourceFacts({
provider: "x",
pageType: "post",
itemId: "123",
author: "Director",
engagement: { likes: 42, invalid: "unknown" },
capturedAt: "2026-08-09T00:00:00.000Z"
}, "https://x.com/director/status/123");
assert.equal(facts.provider, "x");
assert.deepEqual(facts.engagement, { likes: 42 });
assert.equal(facts.engagementObservedAt, "2026-08-09T00:00:00.000Z");
assert.equal("labels" in facts, false);
});
test("page capture candidates deduplicate media and preserve partial extraction", () => {
const candidate = normalizePageCaptureCandidate({
title: "公开作品",
canonicalUrl: "https://example.com/work/1",
pageType: "artwork",
media: [
{ kind: "image", url: "https://cdn.example.com/a.jpg", width: 1200, height: 800 },
{ kind: "image", url: "https://cdn.example.com/a.jpg", width: 300, height: 200 }
]
});
assert.equal(candidate.media.length, 1);
assert.equal(candidate.completeness, "partial");
});
test("a video poster never becomes an independent article image", () => {
const candidate = normalizePageCaptureCandidate({
title: "视频文章",
canonicalUrl: "https://example.com/video-article",
media: [
{ id: "video", kind: "video", url: "https://video.example.com/watch", posterUrl: "https://cdn.example.com/poster.webp" },
{ id: "poster-copy", kind: "image", url: "https://cdn.example.com/poster.webp" },
{ id: "content-image", kind: "image", url: "https://cdn.example.com/content.webp" }
]
});
assert.deepEqual(candidate.media.map((item) => item.id), ["video", "content-image"]);
});
test("page capture selections preserve one ordered article document", () => {
const batch = normalizePageCaptureBatch({
candidates: [{
id: "article",
title: "完整文章",
canonicalUrl: "https://example.com/article",
textBlocks: [
{ id: "heading", kind: "section", text: "创作过程", sourceOrder: 0 },
{ id: "paragraph", kind: "section", text: "正文内容", sourceOrder: 2 }
],
media: [{ id: "hero", kind: "image", url: "https://example.com/hero.webp" }],
articleDocument: {
version: 1,
blocks: [
{ id: "heading", kind: "heading", level: 2, text: "创作过程", sourceOrder: 0 },
{ id: "hero-block", kind: "image", assetId: "hero", sourceUrl: "https://example.com/hero.webp", sourceOrder: 1 },
{ id: "paragraph", kind: "paragraph", text: "正文内容", sourceOrder: 2 }
]
}
}],
selections: [{
candidateId: "article",
selectedTextBlockIds: ["heading", "paragraph"],
selectedMediaIds: ["hero"],
mediaDecision: "confirmed"
}]
});
const [selected] = applyPageCaptureSelections(batch);
assert.deepEqual(selected.articleDocument.blocks.map((block) => block.kind), ["heading", "image", "paragraph"]);
assert.deepEqual(selected.articleDocument.blocks.map((block) => block.sourceOrder), [0, 1, 2]);
});
test("unconfirmed media never enters a saved article", () => {
const copy = "这是一段已经确认属于创作主体的完整正文,用来验证文字可以正常保存,而图片、GIF、视频和文档仍需要独立确认。".repeat(4);
const candidate = normalizePageCaptureCandidate({
id: "article",
title: "待确认媒体文章",
canonicalUrl: "https://example.com/article",
textBlocks: [{ id: "copy", kind: "paragraph", text: copy, sourceOrder: 0 }],
media: [{ id: "hero", kind: "image", url: "https://example.com/hero.webp" }],
articleDocument: {
version: 1,
blocks: [
{ id: "copy", kind: "paragraph", text: copy, sourceOrder: 0 },
{ id: "hero-block", kind: "image", assetId: "hero", sourceUrl: "https://example.com/hero.webp", sourceOrder: 1 }
]
}
});
const batch = normalizePageCaptureBatch({
candidates: [candidate],
selections: [{
candidateId: candidate.id,
selectedTextBlockIds: candidate.textBlocks.map((block) => block.id),
selectedMediaIds: ["hero"],
mediaDecision: "pending"
}]
});
assert.equal(batch.selections[0].mediaDecision, "pending");
const [pending] = applyPageCaptureSelections(batch);
assert.deepEqual(pending.media, []);
assert.deepEqual(pending.articleDocument.blocks.map((block) => block.kind), ["paragraph"]);
const [confirmed] = applyPageCaptureSelections(normalizePageCaptureBatch({
...batch,
selections: [{ ...batch.selections[0], mediaDecision: "confirmed" }]
}));
assert.deepEqual(confirmed.media.map((media) => media.id), ["hero"]);
assert.deepEqual(confirmed.articleDocument.blocks.map((block) => block.kind), ["paragraph", "image"]);
const [withoutMedia] = applyPageCaptureSelections(normalizePageCaptureBatch({
...batch,
selections: [{ ...batch.selections[0], mediaDecision: "none" }]
}));
assert.deepEqual(withoutMedia.media, []);
});
test("a case cannot be saved until the user resolves its media proposal", () => {
const candidate = normalizePageCaptureCandidate({
id: "proposal",
title: "媒体待确认",
canonicalUrl: "https://example.com/proposal",
contentText: "已确认正文",
media: [{ id: "preview", kind: "image", url: "https://example.com/preview.webp" }]
});
const selection = {
candidateId: candidate.id,
includeText: true,
selectedMediaIds: ["preview"]
};
assert.equal(pageCaptureMediaDecisionsResolved(normalizePageCaptureBatch({
candidates: [candidate], selections: [{ ...selection, mediaDecision: "pending" }]
})), false);
assert.equal(pageCaptureMediaDecisionsResolved(normalizePageCaptureBatch({
candidates: [candidate], selections: [{ ...selection, mediaDecision: "confirmed" }]
})), true);
assert.equal(pageCaptureMediaDecisionsResolved(normalizePageCaptureBatch({
candidates: [candidate], selections: [{ ...selection, mediaDecision: "none" }]
})), true);
});
test("manual DOM correction keeps verified source facts and original media quality", () => {
const revised = mergePageCaptureRegionEdit({
id: "original",
title: "原始标题",
canonicalUrl: "https://example.com/article",
region: {
marker: "region:original",
contentTargets: [{ id: "old", kind: "text", path: "body:nth-of-type(1) > main:nth-of-type(1) > p:nth-of-type(1)", articleBlockIds: ["old-text"], sourceOrder: 0 }]
},
sourceFacts: { provider: "verified-site", author: "作者", status: "complete" },
media: [{ id: "verified-image", kind: "image", url: "https://cdn.example.com/image.webp", variants: [{ url: "https://cdn.example.com/image.webp", sourceKind: "site-original", width: 2400 }] }],
articleDocument: { version: 1, blocks: [{ id: "image", kind: "image", assetId: "verified-image", sourceUrl: "https://cdn.example.com/image.webp", sourceOrder: 0 }] }
}, {
title: "临时 DOM 标题",
canonicalUrl: "https://example.com/article",
region: {
marker: "region:revised",
edits: [{ mode: "exclude", path: "body:nth-of-type(1) > main:nth-of-type(1) > div:nth-of-type(2)" }],
contentTargets: [
{ id: "copy", kind: "text", path: "body:nth-of-type(1) > main:nth-of-type(1) > div:nth-of-type(1)", articleBlockIds: ["text"], sourceOrder: 0 },
{ id: "media", kind: "image", path: "body:nth-of-type(1) > main:nth-of-type(1) > div:nth-of-type(3) > img:nth-of-type(1)", mediaIds: ["revised-image"], groupId: "group", sourceOrder: 1 },
{ id: "group", kind: "group", path: "body:nth-of-type(1) > main:nth-of-type(1) > div:nth-of-type(3)", mediaIds: ["revised-image"], sourceOrder: 1 }
]
},
contentText: "修正后的正文",
textBlocks: [{ id: "text", kind: "section", text: "修正后的正文", sourceOrder: 0 }],
media: [{ id: "revised-image", kind: "image", url: "https://cdn.example.com/image.webp", width: 320 }],
articleDocument: { version: 1, blocks: [{ id: "image", kind: "image", assetId: "revised-image", sourceUrl: "https://cdn.example.com/image.webp", sourceOrder: 0 }] }
});
assert.equal(revised.id, "original");
assert.equal(revised.title, "原始标题");
assert.equal(revised.sourceFacts.provider, "verified-site");
assert.equal(revised.media[0].id, "verified-image");
assert.equal(revised.media[0].url, "https://cdn.example.com/image.webp");
assert.equal(revised.articleDocument.blocks[0].assetId, "verified-image");
assert.equal(revised.region.marker, "region:original");
assert.deepEqual(revised.region.edits, [{ mode: "exclude", path: "body:nth-of-type(1) > main:nth-of-type(1) > div:nth-of-type(2)" }]);
assert.deepEqual(revised.region.contentTargets.map((target) => target.kind), ["text", "image", "group"]);
assert.deepEqual(revised.region.contentTargets[1].mediaIds, ["verified-image"]);
});
test("manual range edits keep distinct same-poster videos and restore originals through actual playback variants", () => {
const posterUrl = "https://cdn.example.com/shared-poster.jpg";
const source = { title: "Two films", canonicalUrl: "https://example.com/project", media: ["one", "two"].map(id => ({
id, kind: "video", url: `https://cdn.example.com/${id}.mp4`, posterUrl,
variants: [{ url: `https://cdn.example.com/${id}.m3u8`, sourceKind: "video-element" }]
})) };
const revised = mergePageCaptureRegionEdit(source, { ...source, media: ["two", "one", "third"].map(id => ({
id: `dom-${id}`, kind: "video", url: `https://cdn.example.com/${id}.m3u8`, posterUrl
})) });
assert.deepEqual(revised.media.map(item => item.id), ["two", "one", "dom-third"]);
assert.deepEqual(revised.media.map(item => item.url), ["https://cdn.example.com/two.mp4", "https://cdn.example.com/one.mp4", "https://cdn.example.com/third.m3u8"]);
});
test("the generic capture exposes meaningful nested blocks without turning every DOM node into a choice", () => {
const source = collectPageCaptureSnapshot.toString();
const targets = source.slice(source.indexOf("function collectContentTargets"), source.indexOf("function collectTextBlocks"));
assert.match(targets, /kind: "group"/);
assert.match(targets, /articleBlockIds/);
assert.match(targets, /mediaIds/);
assert.match(targets, /div,section,figure/);
assert.match(targets, /!element\.querySelector\?\.\(`\$\{semanticSelector\},div,section`\)/);
assert.match(source, /playerForCompanionPoster/);
assert.match(source, /companionPosterForPlayer/);
});
test("one stable media selection keeps ranked original, lazy and current variants", () => {
const candidate = normalizePageCaptureCandidate({
title: "多清晰度作品",
canonicalUrl: "https://example.com/work/variants",
media: [{
id: "hero-image",
kind: "image",
url: "https://cdn.example.com/thumb.jpg",
sourceKind: "current",
variants: [
{ url: "https://cdn.example.com/thumb.jpg", sourceKind: "current", width: 320 },
{ url: "https://cdn.example.com/lazy.jpg", sourceKind: "deferred-src", width: 1600 },
{ url: "https://origin.example.com/original.webp", sourceKind: "site-original", width: 2160, height: 3840 }
]
}]
});
const [media] = candidate.media;
assert.equal(media.id, "hero-image");
assert.equal(media.url, "https://origin.example.com/original.webp");
assert.deepEqual(pageCaptureMediaFetchCandidates(media), [
"https://origin.example.com/original.webp",
"https://cdn.example.com/lazy.jpg",
"https://cdn.example.com/thumb.jpg"
]);
assert.deepEqual(pageCapturePermissionOrigins([candidate]), ["https://cdn.example.com/*", "https://origin.example.com/*"]);
});
test("responsive URLs for one image merge without changing the first selection id", () => {
const candidate = normalizePageCaptureCandidate({
title: "同一作品的两个尺寸",
canonicalUrl: "https://example.com/work/one-image",
media: [
{ id: "visible-image", kind: "image", url: "https://cdn.example.com/photo.jpg?width=320&quality=70", sourceKind: "current", width: 320 },
{ id: "late-copy", kind: "image", url: "https://cdn.example.com/photo.jpg?width=2048&quality=90", sourceKind: "site-original", width: 2048 }
]
});
assert.equal(candidate.media.length, 1);
assert.equal(candidate.media[0].id, "visible-image");
assert.equal(candidate.media[0].url, "https://cdn.example.com/photo.jpg?width=2048&quality=90");
assert.deepEqual(candidate.media[0].variants.map((item) => item.width), [2048, 320]);
});
test("the generic collector preserves original resolution and every selectable media object", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability,
Element: globalThis.Element,
HTMLElement: globalThis.HTMLElement,
HTMLCanvasElement: globalThis.HTMLCanvasElement,
getComputedStyle: globalThis.getComputedStyle
};
class Element {}
class Canvas extends Element {}
const attributes = new Map([
["data-full-image", "https://cdn.example.com/work.jpg?width=2400"],
["src", "https://cdn.example.com/work.jpg?width=320"]
]);
const image = new Element();
Object.assign(image, {
alt: "作品原图",
src: attributes.get("src"),
currentSrc: attributes.get("src"),
srcset: "",
naturalWidth: 320,
naturalHeight: 480,
complete: false,
width: 320,
height: 480,
className: "work-image",
matches: (selector) => selector.split(",").includes("img"),
closest: () => null,
getAttribute: (name) => attributes.get(name) || "",
hasAttribute: (name) => attributes.has(name),
getBoundingClientRect: () => ({ x: 0, y: 0, width: 320, height: 480, top: 0, bottom: 480 })
});
const body = new Element();
Object.assign(body, {
innerText: "一张可以保存的公开作品。",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: (selector) => selector === "img,video,iframe,canvas" ? [image] : []
});
Object.defineProperty(body, "childNodes", { get: () => body.querySelectorAll("img,video,iframe,canvas") });
globalThis.Element = Element;
globalThis.HTMLElement = Element;
globalThis.HTMLCanvasElement = Canvas;
globalThis.window = { scrollX: 0, scrollY: 0, innerWidth: 1200, innerHeight: 800, scrollTo: () => undefined };
globalThis.document = {
title: "Generic image fixture",
body,
documentElement: { scrollHeight: 800, clientWidth: 1200, clientHeight: 800 },
baseURI: "https://example.com/work",
images: [image],
querySelector: () => null,
querySelectorAll: () => [],
cloneNode: () => ({}),
createElement: () => ({ width: 0, height: 0, getContext: () => null, toDataURL: () => "" })
};
globalThis.location = { hostname: "example.com", href: "https://example.com/work" };
globalThis.getComputedStyle = () => ({ backgroundImage: "none" });
globalThis.chrome = undefined;
globalThis.Readability = undefined;
try {
const result = await injected({ adapters: PAGE_CAPTURE_ADAPTERS, maxCandidates: 10, maxMedia: 10 });
assert.equal(result.candidates[0].media[0].url, "https://cdn.example.com/work.jpg?width=2400");
assert.equal(result.candidates[0].media[0].sourceKind, "site-original");
const images = Array.from({ length: 205 }, (_, index) => {
const src = `https://cdn.example.com/original-${index}.png`;
return Object.assign(new Element(), image, {
nodeType: 1,
tagName: "IMG",
parentElement: body,
alt: `Original ${index}`,
src,
currentSrc: src,
getAttribute: name => name === "src" ? src : ""
});
});
Object.assign(body, {
nodeType: 1,
tagName: "BODY",
children: images,
closest: () => null,
setAttribute: () => undefined,
querySelectorAll: selector => selector.includes("img") ? images : []
});
globalThis.document.images = images;
const complete = await injected({ adapters: PAGE_CAPTURE_ADAPTERS });
assert.equal(complete.candidates[0].media.length, images.length,
"an omitted work budget must preserve every original in the selected work");
assert.equal(complete.candidates[0].media.at(-1).url, images.at(-1).src);
assert.equal(complete.candidates[0].region.contentTargets.length, images.length,
"objects after target 200 must remain available for manual selection");
assert.deepEqual(complete.candidates[0].region.contentTargets.flatMap(target => target.mediaIds),
complete.candidates[0].media.map(item => item.id));
const dataUrl = "data:image/webp;base64,AAAA";
const canvas = Object.assign(new Canvas(), {
width: 800, height: 600, toDataURL: () => dataUrl,
getAttribute: () => "", closest: () => null, matches: selector => selector.split(",").includes("canvas"),
getBoundingClientRect: () => ({ x: 0, y: 0, width: 800, height: 600, top: 0, bottom: 600 })
});
body.children = [canvas];
body.querySelectorAll = selector => selector === "img,video,iframe,canvas" ? [canvas] : [];
globalThis.document.images = [];
const pixels = await injected({ adapters: PAGE_CAPTURE_ADAPTERS });
assert.equal(pixels.candidates[0].media.length, 1,
"a selected canvas must not disappear when the caller omits an inline transfer budget");
assert.equal(pixels.candidates[0].media[0].dataUrl, dataUrl);
} finally {
Object.assign(globalThis, original);
}
});
test("page capture retries media variants and uses visible pixels only after every remote source fails", async () => {
const attempts = [];
const media = normalizePageCaptureCandidate({
title: "回退作品",
canonicalUrl: "https://example.com/work/fallback",
media: [{
id: "hero",
dataUrl: "data:image/webp;base64,AAAA",
variants: [
{ url: "https://origin.example.com/broken.webp", sourceKind: "site-original" },
{ url: "https://cdn.example.com/working.webp", sourceKind: "deferred-src" }
]
}]
}).media[0];
const remote = await resolvePageCaptureImage(media, {
fetchMedia: async (url) => {
attempts.push(url);
if (url.includes("broken")) throw new Error("HTTP 403");
return new Blob(["remote"], { type: "image/webp" });
},
decodeDataUrl: async () => new Blob(["pixels"], { type: "image/webp" })
});
assert.deepEqual(attempts, ["https://origin.example.com/broken.webp", "https://cdn.example.com/working.webp"]);
assert.equal(remote.usedPixelFallback, false);
const pixels = await resolvePageCaptureImage(media, {
fetchMedia: async () => { throw new Error("unavailable"); },
decodeDataUrl: async () => new Blob(["pixels"], { type: "image/webp" })
});
assert.equal(pixels.usedPixelFallback, true);
assert.equal(pixels.captureMethod, "pixel-fallback");
});
test("selected media uses the current page session only after public variants fail", async () => {
const calls = [];
const media = normalizePageCaptureCandidate({
title: "登录后可见作品",
canonicalUrl: "https://example.com/work/session",
media: [{
id: "session-image",
dataUrl: "data:image/webp;base64,AAAA",
variants: [{ url: "https://media.example.com/original.webp", sourceKind: "site-original" }]
}]
}).media[0];
const resolved = await resolvePageCaptureImage(media, {
fetchMedia: async (url) => { calls.push(`public:${url}`); throw new Error("HTTP 403"); },
fetchSessionMedia: async (url) => {
calls.push(`session:${url}`);
return { blob: new Blob(["session"], { type: "image/webp" }), metadata: { width: 2048, height: 3072 } };
},
decodeDataUrl: async () => { calls.push("pixels"); return new Blob(["pixels"], { type: "image/webp" }); }
});
assert.deepEqual(calls, [
"public:https://media.example.com/original.webp",
"session:https://media.example.com/original.webp"
]);
assert.equal(resolved.captureMethod, "page-session");
assert.equal(resolved.usedPixelFallback, false);
assert.deepEqual(resolved.metadata, { width: 2048, height: 3072 });
});
test("denied media-domain access skips the page session and keeps the pixel fallback", async () => {
const calls = [];
const media = normalizePageCaptureCandidate({
title: "拒绝额外权限",
canonicalUrl: "https://example.com/work/denied",
media: [{ id: "image", url: "https://media.example.com/image.webp", dataUrl: "data:image/webp;base64,AAAA" }]
}).media[0];
const resolved = await resolvePageCaptureImage(media, {
sessionMediaAllowed: false,
fetchMedia: async () => { calls.push("public"); throw new Error("denied"); },
fetchSessionMedia: async () => { calls.push("session"); return new Blob(["unexpected"]); },
decodeDataUrl: async () => { calls.push("pixels"); return new Blob(["pixels"], { type: "image/webp" }); }
});
assert.deepEqual(calls, ["public", "pixels"]);
assert.equal(resolved.captureMethod, "pixel-fallback");
assert.equal(normalizePageCaptureBatch({ sessionMediaAllowed: false }).sessionMediaAllowed, false);
});
test("page capture requires explicit component confirmation and requests only chosen media origins", () => {
const batch = normalizePageCaptureBatch({ candidates: [
{ id: "one", title: "一", canonicalUrl: "https://example.com/1", contentText: "正文一", media: [{ id: "one-image", url: "https://img.example.com/a.jpg" }] },
{ id: "two", title: "二", canonicalUrl: "https://example.com/2", contentText: "正文二", media: [{ id: "two-image", url: "https://media.example.net/b.jpg" }] }
] });
assert.deepEqual(batch.selections, []);
const confirmed = normalizePageCaptureBatch({
...batch,
selections: [{ candidateId: "one", includeText: false, selectedMediaIds: ["one-image"] }]
});
assert.deepEqual(confirmed.selections, [{ candidateId: "one", includeText: false, selectedMediaIds: ["one-image"], mediaDecision: "pending" }]);
assert.deepEqual(applyPageCaptureSelections(confirmed)[0].media, []);
const selected = applyPageCaptureSelections(normalizePageCaptureBatch({
...confirmed,
selections: confirmed.selections.map((selection) => ({ ...selection, mediaDecision: "confirmed" }))
}));
assert.equal(selected.length, 1);
assert.equal(selected[0].contentText, "");
assert.deepEqual(selected[0].media.map((item) => item.id), ["one-image"]);
assert.deepEqual(pageCapturePermissionOrigins(selected), ["https://img.example.com/*"]);
});
test("page capture requests download access only for verified safe documents", () => {
const candidate = normalizePageCaptureCandidate({
id: "downloads",
title: "文章下载区",
canonicalUrl: "https://example.com/article",
media: [
{ id: "brief", kind: "document", url: "https://files.example.com/brief.pdf", mimeType: "application/pdf" },
{ id: "archive", kind: "document", url: "https://unsafe.example.com/skill.zip", mimeType: "application/zip" }
]
});
assert.deepEqual(pageCapturePermissionOrigins([candidate]), ["https://files.example.com/*"]);
});
test("page capture selection ignores unknown candidates and media", () => {
const candidates = [normalizePageCaptureCandidate({
id: "known", title: "作品", canonicalUrl: "https://example.com/work",
contentText: "正文", media: [{ id: "known-image", url: "https://img.example.com/a.jpg" }]
})];
assert.equal(normalizePageCaptureSelection({ candidateId: "missing", includeText: true }, candidates), null);
assert.deepEqual(normalizePageCaptureSelection({
candidateId: "known", includeText: true, selectedMediaIds: ["missing", "known-image"]
}, candidates), { candidateId: "known", includeText: true, selectedMediaIds: ["known-image"], mediaDecision: "pending" });
});
test("page capture saves only the article sections the user explicitly chose", () => {
const batch = normalizePageCaptureBatch({
candidates: [{
id: "article",
title: "长文章",
canonicalUrl: "https://example.com/article",
contentText: "开场段落\n\n需要保留的核心段落\n\n结尾段落",
contentHtml: "<p>开场段落</p><p>需要保留的核心段落</p><p>结尾段落</p>",
textBlocks: [
{ id: "intro", text: "开场段落", html: "<p>开场段落</p>" },
{ id: "core", text: "需要保留的核心段落", html: "<p>需要保留的核心段落</p>" },
{ id: "outro", text: "结尾段落", html: "<p>结尾段落</p>" }
]
}],
selections: [{
candidateId: "article",
selectedTextBlockIds: ["core"],
selectedMediaIds: [],
mediaDecision: "none"
}]
});
assert.deepEqual(batch.selections, [{
candidateId: "article",
includeText: true,
selectedTextBlockIds: ["core"],
selectedMediaIds: [],
mediaDecision: "none"
}]);
const [selected] = applyPageCaptureSelections(batch);
assert.equal(selected.contentText, "需要保留的核心段落");
assert.equal(selected.contentHtml, "<p>需要保留的核心段落</p>");
});
test("creative sections merge adjacent fragments, hide weak page chrome and restore source order when saving", () => {
const candidate = normalizePageCaptureCandidate({
id: "creative-brief",
title: "Project Aurora",
canonicalUrl: "https://example.com/projects/aurora",
contentText: "Project Aurora\n\n首页\n\nBrief\n\n一部关于三名水下清理员的动作喜剧。\n\n他们试图证明自己,却意外卷入一场远超预期的深海危机。\n\n评论",
textBlocks: [
{ id: "title", text: "Project Aurora", html: "<h1>Project Aurora</h1>", kind: "heading", sourceOrder: 0 },
{ id: "nav", text: "首页", html: "<p>首页</p>", kind: "noise", sourceOrder: 1 },
{ id: "brief", text: "Brief", html: "<h2>Brief</h2>", kind: "heading", sourceOrder: 2 },
{ id: "body-a", text: "一部关于三名水下清理员的动作喜剧。", html: "<p>一部关于三名水下清理员的动作喜剧。</p>", sourceOrder: 3 },
{ id: "body-b", text: "他们试图证明自己,却意外卷入一场远超预期的深海危机。", html: "<p>他们试图证明自己,却意外卷入一场远超预期的深海危机。</p>", sourceOrder: 4 },
{ id: "comment", text: "评论", html: "<p>评论</p>", kind: "noise", sourceOrder: 5 }
]
});
assert.equal(candidate.textBlocks.length, 1);
assert.match(candidate.textBlocks[0].text, /^Brief\n/u);
assert.doesNotMatch(candidate.textBlocks[0].text, /首页|评论|Project Aurora/u);
assert.deepEqual(candidate.possibleOmissions.map((item) => item.text), ["首页", "评论"]);
const [selected] = applyPageCaptureSelections(normalizePageCaptureBatch({
candidates: [candidate],
selections: [{ candidateId: candidate.id, selectedTextBlockIds: [candidate.textBlocks[0].id], selectedMediaIds: [] }]
}));
assert.equal(selected.contentText, candidate.textBlocks[0].text);
});
test("creative-section preview rank never changes the saved page order", () => {
const candidate = normalizePageCaptureCandidate({
id: "ordered-brief",
title: "Ordered brief",
canonicalUrl: "https://example.com/ordered",
textBlocks: [
{ text: "Brief", kind: "heading", sourceOrder: 0 },
{ text: "第一部分很短。", kind: "paragraph", sourceOrder: 1 },
{ text: "Prompt", kind: "heading", sourceOrder: 2 },
{ text: "第二部分更长,用于确保预览相关性排序与网页原始顺序不同。", kind: "paragraph", sourceOrder: 3 }
]
});
assert.match(candidate.textBlocks[0].text, /^Prompt/u);
const [selected] = applyPageCaptureSelections(normalizePageCaptureBatch({
candidates: [candidate],
selections: [{
candidateId: candidate.id,
selectedTextBlockIds: candidate.textBlocks.map((item) => item.id),
selectedMediaIds: []
}]
}));
assert.match(selected.contentText, /^Brief/u);
assert.match(selected.contentText, /第一部分[\s\S]*Prompt/u);
});
test("structured site content stays one clean creative section instead of being resegmented from the page shell", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability
};
const body = {
innerText: "首页 发现 项目 Brief 评论 推荐 下载 分享 以及大量页面壳文字",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: () => []
};
globalThis.window = { scrollX: 0, scrollY: 0, scrollTo: () => undefined };
globalThis.document = {
title: "Cully Hill Boys",
body,
documentElement: { scrollHeight: 800 },
baseURI: "https://higgsfield.ai/projects/cully-hill-boys",
querySelector: () => null,
querySelectorAll: () => [],
cloneNode: () => ({})
};
globalThis.location = { hostname: "higgsfield.ai", href: "https://higgsfield.ai/projects/cully-hill-boys" };
globalThis.chrome = undefined;
globalThis.Readability = undefined;
const siteData = {
adapter: "higgsfield",
pageKind: "detail",
completeness: "complete",
canonicalUrl: globalThis.location.href,
title: "Cully Hill Boys",
contentText: "This is the project brief for the Cully Hill Boys, our feature-length AI film.",
media: [],
sourceFacts: { provider: "higgsfield", extractionMethod: "structured" }
};
try {
const result = normalizePageCaptureBatch(await injected({
adapters: PAGE_CAPTURE_ADAPTERS,
siteData,
maxCandidates: 10,
maxMedia: 10
}));
assert.equal(result.candidates[0].textBlocks.length, 1);
assert.equal(result.candidates[0].textBlocks[0].text, siteData.contentText);
assert.doesNotMatch(result.candidates[0].contentText, /首页|评论|推荐/u);
body.innerText = "A complete visible project description remains available when the optional site enhancement is unavailable.";
const genericFallback = normalizePageCaptureBatch(await injected({
adapters: PAGE_CAPTURE_ADAPTERS,
siteData: { ...siteData, contentText: "", completeness: "partial", sourceFacts: {} },
maxCandidates: 10,
maxMedia: 10
}));
assert.match(genericFallback.candidates[0].contentText, /complete visible project description/u);
} finally {
Object.assign(globalThis, original);
}
});
test("the actual Chrome injection function is self-contained", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability
};
const body = {
innerText: "A real article body that is long enough to become a capture candidate.",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: () => []
};
globalThis.window = { scrollX: 0, scrollY: 0, scrollTo: () => undefined };
globalThis.document = {
title: "Injection fixture",
body,
documentElement: { scrollHeight: 800 },
baseURI: "https://example.com/article",
querySelector: () => null,
querySelectorAll: () => [],
cloneNode: () => ({})
};
globalThis.location = { hostname: "example.com", href: "https://example.com/article" };
globalThis.chrome = undefined;
globalThis.Readability = undefined;
try {
const result = await injected({ adapters: [], maxCandidates: 10, maxMedia: 10 });
assert.equal(result.candidates.length, 1);
assert.equal(result.candidates[0].title, "Injection fixture");
} finally {
Object.assign(globalThis, original);
}
});
test("Jimeng home uses structured works and never falls back to application-shell text", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability
};
const body = {
innerText: "发现 技能 上传参考图 输入文字 图片生成 二维码",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: () => []
};
globalThis.window = { scrollX: 0, scrollY: 0, scrollTo: () => undefined };
globalThis.document = {
title: "即梦AI - 一站式AI创作平台",
body,
documentElement: { scrollHeight: 800 },
baseURI: "https://jimeng.jianying.com/ai-tool/home",
querySelector: () => null,
querySelectorAll: () => [],
cloneNode: () => ({})
};
globalThis.location = { hostname: "jimeng.jianying.com", href: "https://jimeng.jianying.com/ai-tool/home" };
globalThis.chrome = undefined;
globalThis.Readability = undefined;
const siteData = {
adapter: "jimeng",
pageKind: "feed",
completeness: "complete",
candidates: [{
id: "jimeng:7490123456789012345",
pageType: "artwork",
title: "AIGC大叔 · 2026-05-30",
canonicalUrl: "https://jimeng.jianying.com/ai-tool/work-detail/7490123456789012345",
contentText: "真实作品提示词",
media: [{
id: "jimeng:7490123456789012345:1",
kind: "image",
placement: "inline",
url: "https://p3-dreamina-sign.byteimg.com/7490123456789012345.webp"
}],
sourceFacts: { provider: "jimeng", itemId: "7490123456789012345", author: "AIGC大叔" },
extraction: { scope: "document", method: "structured" }
}]
};
try {
const result = await injected({ adapters: PAGE_CAPTURE_ADAPTERS, siteData, maxCandidates: 10, maxMedia: 10 });
assert.equal(result.candidates.length, 1);
assert.equal(result.candidates[0].contentText, "真实作品提示词");
assert.doesNotMatch(result.candidates[0].contentText, /上传参考图|二维码/u);
assert.deepEqual(pageCaptureDefaultMediaIds(result.candidates[0]), ["jimeng:7490123456789012345:1"]);
const missing = await injected({
adapters: PAGE_CAPTURE_ADAPTERS,
siteData: { ...siteData, completeness: "partial", candidates: [] },
maxCandidates: 10,
maxMedia: 10
});
assert.deepEqual(missing.candidates, []);
const krea = await injected({
adapters: PAGE_CAPTURE_ADAPTERS,
siteData: {
...siteData,
adapter: "krea",
candidates: [{
...siteData.candidates[0],
id: "krea:554bfb91-2a06-5e91-8a21-24a162f3b81f",
title: "Krea public artwork",
sourceFacts: { provider: "krea", itemId: "554bfb91-2a06-5e91-8a21-24a162f3b81f" }
}]
},
maxCandidates: 10,
maxMedia: 10
});
assert.equal(krea.candidates[0].title, "Krea public artwork");
} finally {
Object.assign(globalThis, original);
}
});
test("generic JSON-LD provides author, identity, publication time, engagement and structured original media", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability
};
const structured = {
"@type": "ImageObject",
name: "Structured artwork",
identifier: "work-77",
author: [{ "@type": "Person", name: "Structured Author" }],
datePublished: "2026-08-01T12:00:00Z",
image: { contentUrl: "https://cdn.example.com/original.webp", width: 2048, height: 3072 },
interactionStatistic: [{ interactionType: { "@type": "LikeAction" }, userInteractionCount: 91 }]
};
const body = {
innerText: "Structured prompt body",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: () => []
};
globalThis.window = { scrollX: 0, scrollY: 0, scrollTo: () => undefined };
globalThis.document = {
title: "Fallback title",
body,
documentElement: { scrollHeight: 800 },
baseURI: "https://example.com/work/77",
querySelector: () => null,
querySelectorAll: (selector) => selector === 'script[type="application/ld+json"]' ? [{ textContent: JSON.stringify(structured) }] : [],
cloneNode: () => ({})
};
globalThis.location = { hostname: "example.com", href: "https://example.com/work/77" };
globalThis.chrome = undefined;
globalThis.Readability = undefined;
try {
const result = await injected({ adapters: [], maxCandidates: 10, maxMedia: 10 });
const [candidate] = result.candidates;
assert.equal(candidate.sourceFacts.author, "Structured Author");
assert.equal(candidate.sourceFacts.itemId, "work-77");
assert.equal(candidate.sourceFacts.publishedAt, "2026-08-01T12:00:00Z");
assert.deepEqual(candidate.sourceFacts.engagement, { likes: 91 });
assert.equal(candidate.media[0].url, "https://cdn.example.com/original.webp");
assert.equal(candidate.media[0].sourceKind, "structured");
Object.assign(structured, { "@type": "VideoObject", contentUrl: "https://cdn.example.com/work.m3u8", thumbnailUrl: "https://cdn.example.com/poster.jpg" });
delete structured.image;
const video = (await injected({ adapters: [], maxCandidates: 10, maxMedia: 10 })).candidates[0];
assert.equal(video.media.length, 1, "a video poster must not become a separate image case");
assert.equal(video.media[0].kind, "video");
assert.equal(video.media[0].streamUrl, structured.contentUrl);
assert.equal(video.pageType, "video");
const embeddedVideo = { ...structured };
Object.assign(structured, { "@type": "Article", video: embeddedVideo });
delete structured.contentUrl;
const article = (await injected({ adapters: [], maxCandidates: 10, maxMedia: 10 })).candidates[0];
assert.equal(article.pageType, "article", "an article containing a film retains article reading");
assert.equal(article.media[0].kind, "video");
} finally {
Object.assign(globalThis, original);
}
});
test("page capture prefers the user's live page selection and preserves its HTML", async () => {
const injected = (0, eval)(`(${collectPageCaptureSnapshot.toString()})`);
const original = {
window: globalThis.window,
document: globalThis.document,
location: globalThis.location,
chrome: globalThis.chrome,
Readability: globalThis.Readability
};
const selectedText = "只保存用户选中的这一段";
const selectionContainer = {
innerHTML: "",
appendChild: () => { selectionContainer.innerHTML = `<p>${selectedText}</p>`; }
};
const body = {
innerText: "页面上还有很多用户没有选择的正文内容。",
scrollHeight: 800,
querySelector: () => null,
querySelectorAll: () => []
};
globalThis.window = {
scrollX: 0,
scrollY: 0,
scrollTo: () => undefined,
getSelection: () => ({
isCollapsed: false,
rangeCount: 1,
toString: () => selectedText,
getRangeAt: () => ({ cloneContents: () => ({}) })
})
};
globalThis.document = {
title: "Selection fixture",
body,
documentElement: { scrollHeight: 800 },
baseURI: "https://example.com/article",
querySelector: () => null,
querySelectorAll: () => [],
cloneNode: () => ({}),
createElement: () => selectionContainer
};
globalThis.location = { hostname: "example.com", href: "https://example.com/article" };
globalThis.chrome = undefined;
globalThis.Readability = undefined;
try {
const result = await injected({ adapters: [], maxCandidates: 10, maxMedia: 10 });
assert.equal(result.candidates[0].contentText, selectedText);
assert.equal(result.candidates[0].contentHtml, `<p>${selectedText}</p>`);
assert.equal(result.candidates[0].extraction.scope, "selection");
const wholePage = await injected({ adapters: [], mode: "whole", maxScrollSteps: 1, maxCandidates: 10, maxMedia: 10 });
assert.equal(wholePage.candidates[0].contentText, body.innerText);
assert.equal(wholePage.candidates[0].extraction.scope, "document");
} finally {
Object.assign(globalThis, original);
}
});
test("visible canvas pixels stay local to the capture payload and do not request a fake host permission", () => {
const candidate = normalizePageCaptureCandidate({
id: "canvas-work", title: "Canvas 作品", canonicalUrl: "https://example.com/work",
media: [{ id: "canvas:1", kind: "image", dataUrl: "data:image/webp;base64,AAAA", captureMethod: "pixel-fallback", width: 800, height: 600 }]
});
assert.equal(candidate.media[0].captureMethod, "pixel-fallback");
assert.equal(candidate.media[0].dataUrl, "data:image/webp;base64,AAAA");
assert.deepEqual(pageCapturePermissionOrigins([candidate]), []);
});
test("list capture can combine cases without losing per-media provenance", () => {
const batch = normalizePageCaptureBatch({
captureMode: "list",
saveMode: "combined",
targetCount: 2,
stopReason: "target-reached",
candidates: [
{
id: "work-a", title: "作品 A", canonicalUrl: "https://example.com/work/a", contentText: "Prompt A",
sourceFacts: { author: "作者 A" },
media: [{ id: "media-a", url: "https://cdn.example.com/a.jpg" }]
},
{
id: "work-b", title: "作品 B", canonicalUrl: "https://example.com/work/b", contentText: "Prompt B",
sourceFacts: { author: "作者 B" },
media: [{ id: "media-b", url: "https://cdn.example.com/b.jpg" }]
}
]
});
assert.equal(batch.captureMode, "list");
assert.equal(batch.targetCount, 2);
assert.equal(batch.saveMode, "combined");
const combined = combinePageCaptureCandidates(batch.candidates, {
title: "本次列表灵感",
canonicalUrl: "https://example.com/gallery"
});
assert.equal(combined.title, "本次列表灵感");
assert.match(combined.contentText, /作品 A[\s\S]*Prompt A[\s\S]*作品 B[\s\S]*Prompt B/u);
assert.deepEqual(combined.media.map((item) => ({ title: item.sourceTitle, author: item.sourceAuthor, url: item.originalWorkUrl })), [
{ title: "作品 A", author: "作者 A", url: "https://example.com/work/a" },
{ title: "作品 B", author: "作者 B", url: "https://example.com/work/b" }
]);
const stored = normalizeMediaAsset({
id: "stored-media", kind: "image", sourceUrl: combined.media[0].url,
sourceTitle: combined.media[0].sourceTitle,
sourceAuthor: combined.media[0].sourceAuthor,
originalWorkUrl: combined.media[0].originalWorkUrl
});
assert.deepEqual({ title: stored.sourceTitle, author: stored.sourceAuthor, url: stored.originalWorkUrl }, {
title: "作品 A", author: "作者 A", url: "https://example.com/work/a"
});
});
test("list capture inherits a representative structure without auto-accepting a different content shape", () => {
const reference = {
title: "作品一",
canonicalUrl: "https://example.com/1",
textBlocks: [{ id: "prompt", kind: "section", text: "创作提示" }],
media: [{ id: "image", kind: "image", url: "https://example.com/1.webp" }],
articleDocument: { version: 1, blocks: [
{ id: "prompt", kind: "paragraph", text: "创作提示", sourceOrder: 0 },
{ id: "image-block", kind: "image", assetId: "image", sourceOrder: 1 }
] }
};
assert.equal(pageCaptureStructureMatches(reference, {
...reference,
title: "作品二",
canonicalUrl: "https://example.com/2",
media: [{ id: "other", kind: "image", url: "https://example.com/2.webp" }],
articleDocument: { version: 1, blocks: [
{ id: "prompt-2", kind: "paragraph", text: "另一条创作提示", sourceOrder: 0 },
{ id: "image-block-2", kind: "image", assetId: "other", sourceOrder: 1 }
] }
}), true);
assert.equal(pageCaptureStructureMatches(reference, {
...reference,
title: "混入的视频模块",
canonicalUrl: "https://example.com/3",
media: [{ id: "video", kind: "video", url: "https://example.com/3.mp4" }],
articleDocument: { version: 1, blocks: [{ id: "video-block", kind: "video", assetId: "video", sourceOrder: 0 }] }
}), false);
});
test("session image file bytes are not mislabeled as a screenshot fallback", async () => {
const bytes = new Blob([new Uint8Array([1, 2, 3])], { type: "image/png" });
const result = await resolvePageCaptureImage({ dataUrl: "data:image/png;base64,AQID", captureMethod: "page-session" }, {
fetchMedia: async () => { throw new Error("No network URL expected"); },
decodeDataUrl: async () => bytes
});
assert.equal(result.blob, bytes);
assert.equal(result.captureMethod, "page-session");
assert.equal(result.usedPixelFallback, false);
});
test("capture names strip accessibility wrappers and untitled works retain distinct source identities", () => {
const candidate = (title, id) => normalizePageCaptureCandidate({
title, canonicalUrl: `https://www.pinterest.com/pin/${id}/`,
sourceFacts: { provider: 'pinterest', itemId: id },
media: [{ id, kind: 'image', url: `https://i.pinimg.com/originals/${id}.png`, alt: title, sourceTitle: title }]
});
const empty = candidate('其中包括图片:', '123456');
assert.equal(empty.title, 'Pinterest · 123456');
assert.equal(empty.media[0].alt, '');
assert.equal(empty.media[0].sourceTitle, '');
assert.notEqual(empty.title, candidate('其中包括图片:', '654321').title);
assert.equal(candidate('其中包括图片: Dragon and Artemis', '1').title, 'Dragon and Artemis');
assert.equal(candidate('Image may contain: Forest temple', '2').title, 'Forest temple');
assert.equal(candidate('作者原题:山海', '3').title, '作者原题:山海');
const generic = normalizePageCaptureCandidate({title:'',canonicalUrl:'https://portfolio.example/art/real-work',sourceFacts:{}});
assert.equal(generic.title, 'portfolio.example · art/real-work');
assert.equal(generic.sourceFacts.author, '');
assert.equal(generic.sourceFacts.publishedAt, '');
});