@xiaohhhh1/canvas-agent 0.4.79 → 0.4.81

package/dist/integrations/fastmoss-selection-session.js

@@ -0,0 +1,174 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { matchesCategory, opportunityCandidate, selectionConfig } from "./fastmoss-opportunity.js";
+const rankings = ["sales", "new", "hot", "video"];
+const safeId = (id) => { if (!/^[a-zA-Z0-9-]{8,80}$/.test(id))
+    throw new Error("选品会话ID无效"); return id; };
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+export class FastMossSelectionSessions {
+    directory;
+    adapter;
+    activeId = null;
+    task = null;
+    serial = Promise.resolve();
+    constructor(directory, adapter) {
+        this.directory = directory;
+        this.adapter = adapter;
+    }
+    isRunning() { return Boolean(this.activeId); }
+    async atomic(file, value) {
+        await mkdir(this.directory, { recursive: true });
+        const destination = path.join(this.directory, file);
+        await writeFile(`${destination}.tmp`, JSON.stringify(value, null, 2), "utf8");
+        // Windows may briefly deny replacement while a progress reader holds the
+        // old file. Keep the durable old snapshot until replacement succeeds.
+        for (let attempt = 0;; attempt++) {
+            try {
+                await rename(`${destination}.tmp`, destination);
+                break;
+            }
+            catch (error) {
+                if (attempt >= 5 || !["EPERM", "EBUSY", "EACCES"].includes(error.code || ""))
+                    throw error;
+                await delay(30 * (attempt + 1));
+            }
+        }
+    }
+    async persist(session) {
+        session.updatedAt = new Date().toISOString();
+        await this.atomic(`${safeId(session.id)}.json`, session);
+    }
+    async load(id) {
+        try {
+            const session = JSON.parse(await readFile(path.join(this.directory, `${safeId(id)}.json`), "utf8"));
+            session.config = selectionConfig(session.config);
+            return session;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async get(id) {
+        if (!id) {
+            try {
+                id = JSON.parse(await readFile(path.join(this.directory, "latest.json"), "utf8")).id;
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            }
+        }
+        const session = id ? await this.load(id) : null;
+        if (!session)
+            return null;
+        session.active = this.activeId === session.id;
+        if (!session.active && ["collecting", "reviewing"].includes(session.phase))
+            session.phase = "interrupted";
+        return { ...session, candidates: session.products.map(p => opportunityCandidate(p, session.config, session.id)) };
+    }
+    /** Serialize ACK creation; repeat POST with the same id never starts duplicate work. */
+    start(id, input, resume = false) {
+        const operation = this.serial.then(async () => {
+            safeId(id);
+            const config = selectionConfig(input);
+            let session = await this.load(id);
+            if (session && JSON.stringify(session.config) !== JSON.stringify(config))
+                throw new Error("该会话的国家或规则不同，请新建一轮选品");
+            if (this.activeId) {
+                if (this.activeId !== id)
+                    throw new Error("已有选品正在运行，请先等待完成");
+                return this.get(id);
+            }
+            if (session && !resume)
+                return this.get(id);
+            if (!session) {
+                if (resume)
+                    throw new Error("没有找到要继续的选品会话");
+                session = { id, config, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), phase: "collecting", active: true, completedRankings: [], rankingErrors: {}, products: [] };
+            }
+            session.active = true;
+            session.error = undefined;
+            session.phase = "collecting";
+            await this.persist(session);
+            await this.atomic("latest.json", { id });
+            this.activeId = id;
+            this.task = this.run(session).finally(() => { this.activeId = null; this.task = null; });
+            // ACK is returned after durable creation, not after the whole capture.
+            return this.get(id);
+        });
+        this.serial = operation.catch(() => undefined);
+        return operation;
+    }
+    async waitUntilIdle() { await this.serial; await this.task; }
+    async run(session) {
+        try {
+            for (const ranking of rankings) {
+                if (session.completedRankings.includes(ranking))
+                    continue;
+                try {
+                    await this.adapter.discover(ranking, session.config, async (products) => {
+                        for (const product of products) {
+                            if (product.market !== session.config.market || !matchesCategory(product.category, session.config))
+                                continue;
+                            const existing = session.products.find(p => p.productId === product.productId);
+                            if (existing)
+                                existing.rankings = [...new Map([...existing.rankings, ...product.rankings].map(r => [r.source, r])).values()];
+                            else
+                                session.products.push(product);
+                        }
+                        await this.persist(session);
+                    });
+                    session.completedRankings.push(ranking);
+                    delete session.rankingErrors[ranking];
+                }
+                catch (error) {
+                    session.rankingErrors[ranking] = errorText(error);
+                }
+                await this.persist(session);
+            }
+            // Round-robin discovery sources: repeated ranking appearances add no score.
+            const selected = [];
+            const queues = rankings.map(source => session.products.filter(p => p.rankings.some(r => r.source === source) && matchesCategory(p.category, session.config)).sort((a, b) => a.rankings.find(r => r.source === source).position - b.rankings.find(r => r.source === source).position));
+            while (queues.some(q => q.length) && selected.length < session.config.candidateLimit)
+                for (const queue of queues) {
+                    const next = queue.shift();
+                    if (next && !selected.includes(next) && selected.length < session.config.candidateLimit)
+                        selected.push(next);
+                }
+            session.phase = "reviewing";
+            await this.persist(session);
+            for (const product of selected.slice(0, session.config.detailLimit)) {
+                if (product.detailState === "complete")
+                    continue;
+                const save = async (next) => { Object.assign(product, next); await this.persist(session); };
+                product.detailState = "running";
+                delete product.error;
+                await save(product);
+                try {
+                    await save({ ...await this.adapter.detail(structuredClone(product), session.config, save), detailState: "complete" });
+                }
+                catch (error) {
+                    await save({ ...product, detailState: "failed", error: errorText(error) });
+                }
+            }
+            session.phase = Object.keys(session.rankingErrors).length || selected.slice(0, session.config.detailLimit).some(p => p.detailState === "failed") ? "interrupted" : "complete";
+        }
+        catch (error) {
+            session.phase = "interrupted";
+            session.error = errorText(error);
+        }
+        finally {
+            session.active = false;
+            try {
+                await this.persist(session);
+            }
+            catch (error) {
+                console.error("FastMoss selection persistence failed", errorText(error));
+            }
+        }
+    }
+}

package/dist/integrations/fastmoss-visible-evidence.d.ts

@@ -0,0 +1,52 @@
+import { type DailySale, type Period, type ProductEvidence, type Ranking, type SelectionConfig, type VideoSale } from "./fastmoss-opportunity.js";
+export type VisibleSection = {
+    url: string;
+    selector: string;
+    observedAt: string;
+    text: string;
+    blocked: string | null;
+    loading: boolean;
+    inputs: Array<{
+        value: string;
+        placeholder: string;
+        checked: boolean;
+        label: string;
+    }>;
+    links: Array<{
+        href: string;
+        text: string;
+    }>;
+    tables: Array<{
+        headers: string[];
+        rows: Array<{
+            cells: string[];
+            links: Array<{
+                href: string;
+                text: string;
+            }>;
+            images: string[];
+        }>;
+    }>;
+};
+/** Serializable DOM-only reader. Never reads app state, network responses or concealed text. */
+export declare function readVisibleSection(selector: string): VisibleSection;
+export declare function sectionPeriod(snapshot: VisibleSection, days?: number): Period | null;
+export declare function rankingProducts(snapshot: VisibleSection, ranking: Ranking, config: SelectionConfig, offset?: number): ProductEvidence[];
+export declare function dailyFromSection(snapshot: VisibleSection, days: number): DailySale[];
+export declare function overviewFromSection(snapshot: VisibleSection): ProductEvidence["overview"];
+export declare function videosFromSection(snapshot: VisibleSection, expected: Period | null): VideoSale[];
+export interface EvidenceBrowser {
+    goto(url: string): Promise<void>;
+    snapshot(selector: string): Promise<VisibleSection>;
+    clickText(selector: string, text: string, occurrence?: number): Promise<void>;
+    next(selector: string): Promise<boolean>;
+    pause(): Promise<void>;
+}
+export declare class VisibleFastMossCollector {
+    private browser;
+    constructor(browser: EvidenceBrowser);
+    private stable;
+    verifyOverview(product: ProductEvidence): Promise<ProductEvidence>;
+    discover(ranking: Ranking, config: SelectionConfig, save: (products: ProductEvidence[]) => Promise<void>): Promise<void>;
+    detail(product: ProductEvidence, config: SelectionConfig, save: (product: ProductEvidence) => Promise<void>): Promise<ProductEvidence>;
+}

package/dist/integrations/fastmoss-visible-evidence.js

@@ -0,0 +1,303 @@
+import { MARKETS, OPPORTUNITY_VERSION, RANKINGS, isoDate, matchesCategory, visibleNumber } from "./fastmoss-opportunity.js";
+/** Serializable DOM-only reader. Never reads app state, network responses or concealed text. */
+export function readVisibleSection(selector) {
+    const root = document.querySelector(selector);
+    const readability = [];
+    const readable = (element) => {
+        const cached = readability.find(([node]) => node === element);
+        if (cached)
+            return cached[1];
+        for (let node = element; node; node = node.parentElement) {
+            const style = getComputedStyle(node);
+            if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0 || /blur\((?!0px)/.test(style.filter) || node.getAttribute("aria-hidden") === "true") {
+                if (element)
+                    readability.push([element, false]);
+                return false;
+            }
+        }
+        const value = Boolean(element?.getClientRects().length);
+        if (element)
+            readability.push([element, value]);
+        return value;
+    };
+    const gateCache = [];
+    const gated = (element) => {
+        const cached = gateCache.find(([node]) => node === element);
+        if (cached)
+            return cached[1];
+        // Upgrade masks belong to their own section; the global upgrade button is not a gate.
+        const value = [...element.querySelectorAll("div,span,p")].some(n => readable(n) && /升级会员解锁|升级.*查看.*数据|仅.*会员.*查看|unlock.*(?:data|access)|sample data|演示数据/i.test([...n.childNodes].filter(c => c.nodeType === 3).map(c => c.textContent || "").join("")));
+        gateCache.push([element, value]);
+        return value;
+    };
+    const blocked = !root ? "页面区域尚未出现" : !readable(root) ? "页面区域不可见" : gated(root) && !selector.includes("dashboard-container") ? "该区域需要升级或仅展示样例，未采集" : null;
+    const empty = { url: location.href, selector, observedAt: new Date().toISOString(), text: "", blocked, loading: false, inputs: [], links: [], tables: [] };
+    if (!root || blocked)
+        return empty;
+    const inGate = (element) => {
+        for (let node = element; node && node !== root; node = node.parentElement)
+            if (node.id && gated(node))
+                return true;
+        return false;
+    };
+    const allowed = (element) => readable(element) && !inGate(element);
+    const text = (element) => {
+        if (!allowed(element))
+            return "";
+        if ([...element.querySelectorAll("*")].some(n => !allowed(n)))
+            return [...element.childNodes].map(n => n.nodeType === 3 ? n.textContent || "" : n.nodeType === 1 && "innerText" in n ? text(n) : "").join("\n");
+        return element.innerText;
+    };
+    const links = (element) => [...element.querySelectorAll("a[href]")].filter(allowed).map(a => ({ href: a.href, text: text(a) }));
+    return { ...empty, text: text(root).slice(0, 45000), loading: [...root.querySelectorAll(".ant-spin-spinning,[aria-busy=true]")].some(readable),
+        inputs: [...root.querySelectorAll("input")].filter(i => readable(i) || (i.type === "radio" && i.closest("label") && allowed(i.closest("label")))).filter(i => !inGate(i)).map(i => ({ value: i.value, placeholder: i.placeholder, checked: i.checked, label: i.closest("label") ? text(i.closest("label")) : "" })),
+        links: links(root),
+        tables: [...root.querySelectorAll("table")].filter(allowed).map(table => ({ headers: [...table.querySelectorAll("thead th")].map(h => allowed(h) ? text(h).trim() : ""), rows: [...table.querySelectorAll("tbody tr")].filter(row => allowed(row) && !row.className.includes("measure-row")).map(row => {
+                const productLink = [...row.querySelectorAll("a[href]")].find(a => /\/e-commerce\/detail\/\d+/.test(a.href));
+                return { cells: [...row.querySelectorAll("td")].map(cell => text(cell).trim()), links: links(row), images: [...(productLink?.closest("td") || row).querySelectorAll("img")].filter(allowed).map(i => i.currentSrc || i.src).filter(u => /^https:\/\//.test(u)).slice(0, 5) };
+            }) })) };
+}
+export function sectionPeriod(snapshot, days) {
+    const start = snapshot.inputs.find(i => i.placeholder === "开始日期")?.value || "";
+    const end = snapshot.inputs.find(i => i.placeholder === "结束日期")?.value || "";
+    if (!isoDate(start) || !isoDate(end) || start > end || (days && (Date.parse(end) - Date.parse(start)) / 86400000 + 1 !== days))
+        return null;
+    return { start, end, timeZone: "UTC+08:00" };
+}
+const ref = (snapshot, period) => ({ url: snapshot.url, section: snapshot.selector, observedAt: snapshot.observedAt, period });
+const cell = (headers, cells, pattern) => cells[headers.findIndex(h => pattern.test(h.replace(/\s+/g, "")))] || "";
+export function rankingProducts(snapshot, ranking, config, offset = 0) {
+    if (snapshot.blocked || snapshot.loading || new URL(snapshot.url).searchParams.get("region") !== config.market)
+        return [];
+    const result = [];
+    for (const table of snapshot.tables)
+        for (const row of table.rows) {
+            const link = row.links.find(a => /\/e-commerce\/detail\/\d+/.test(a.href));
+            const productId = link?.href.match(/\/e-commerce\/detail\/(\d+)/)?.[1];
+            if (!link || !productId)
+                continue;
+            const country = cell(table.headers, row.cells, /国家|地区|country|market/i);
+            if (country && !country.includes(config.market) && !country.includes(MARKETS[config.market]))
+                continue;
+            const title = (link.text.trim() || cell(table.headers, row.cells, /商品|product/i)).split(/\n\s*(?:售价|价格|佣金)/)[0].trim();
+            const category = cell(table.headers, row.cells, /类目|分类|category/i);
+            result.push({ version: OPPORTUNITY_VERSION, productId, market: config.market, title, url: link.href, category, storeName: cell(table.headers, row.cells, /所属店铺|店铺名称|shop/i), imageUrls: row.images,
+                discoveredAt: snapshot.observedAt, rankings: [{ source: ranking, position: visibleNumber(row.cells[0]) || offset + result.length + 1, ref: ref(snapshot, null) }], identityVerified: false, currency: null, listingDate: null, price: null, stock: null, rating: null, daily: [], videos: [], overview: null, missing: [], detailState: "pending" });
+        }
+    return [...new Map(result.map(p => [p.productId, p])).values()];
+}
+export function dailyFromSection(snapshot, days) {
+    const period = sectionPeriod(snapshot, days);
+    if (snapshot.blocked || snapshot.loading || !period)
+        return [];
+    const table = snapshot.tables.find(t => t.headers.some(h => /^(时间|日期)$/.test(h.trim())) && t.headers.some(h => h.trim() === "销量"));
+    if (!table)
+        return [];
+    return table.rows.flatMap(row => {
+        const date = cell(table.headers, row.cells, /^(时间|日期)$/).slice(0, 10);
+        if (!isoDate(date) || date < period.start || date > period.end)
+            return [];
+        return [{ date, units: visibleNumber(cell(table.headers, row.cells, /^销量$/)), ref: ref(snapshot, period) }];
+    });
+}
+export function overviewFromSection(snapshot) {
+    const period = sectionPeriod(snapshot, 7);
+    if (snapshot.blocked || snapshot.loading || !period)
+        return null;
+    const share = (pattern) => { const value = visibleNumber(snapshot.text.match(pattern)?.[1]); return value !== null && value <= 100 ? value : null; };
+    const unitsText = snapshot.inputs.find(i => i.value === "sold_count_show")?.label.trim().split("\n").filter(Boolean)[0] || "";
+    const compact = unitsText.match(/\d+(?:\.(\d+))?(万|亿|[kKmMbB])$/);
+    const factors = { 万: 1e4, 亿: 1e8, k: 1e3, m: 1e6, b: 1e9 };
+    // FastMoss abbreviates by truncation too (26491 appears as 2.64万).
+    // Allow one displayed unit of precision, never a blanket percentage.
+    const unitsTolerance = compact ? factors[compact[2].toLowerCase()] / 10 ** (compact[1]?.length || 0) : 0;
+    return { ref: ref(snapshot, period), units: visibleNumber(unitsText), unitsTolerance, videoShare: share(/(?:^|\n)视频\s*\n\s*([\d.]+%)/), liveShare: share(/(?:^|\n)直播\s*\n\s*([\d.]+%)/), adShare: share(/广告投放[（(]视频[）)]\s*\n\s*([\d.]+%)/), otherShare: share(/其他流量\s*\n\s*([\d.]+%)/) };
+}
+export function videosFromSection(snapshot, expected) {
+    if (snapshot.blocked || snapshot.loading || !expected)
+        return [];
+    const publishedPeriod = sectionPeriod(snapshot, 7);
+    if (!publishedPeriod || publishedPeriod.start !== expected.start || publishedPeriod.end !== expected.end)
+        return [];
+    // Dates in this section belong to publication filtering. Transaction dates are
+    // aligned independently through the selected first period group + column label.
+    const firstSelected = snapshot.inputs.find(i => i.checked && /^近\d+天$/.test(i.label.trim()));
+    if (firstSelected?.label.trim() !== "近7天")
+        return [];
+    const table = snapshot.tables.find(t => t.headers.some(h => /^销量\(近7天\)$/.test(h.replace(/\s/g, ""))));
+    if (!table)
+        return [];
+    return table.rows.flatMap(row => {
+        const link = row.links.find(a => /\/media-source\/video\/\d+/.test(a.href));
+        const id = link?.href.match(/\/media-source\/video\/(\d+)/)?.[1];
+        if (!id || !link)
+            return [];
+        const creator = row.links.find(a => /\/(?:influencer|author)\/detail\/\d+/.test(a.href));
+        return [{ id, url: link.href, creatorId: creator?.href.match(/\/detail\/(\d+)/)?.[1] || null, creatorName: row.cells[0]?.split("\n").filter(Boolean).at(-1) || "", published: cell(table.headers, row.cells, /视频发布时间/).slice(0, 10), units: visibleNumber(cell(table.headers, row.cells, /^销量\(近7天\)$/)), ad: /\bAds\b/.test(row.cells[0] || "") ? true : null, ref: ref(snapshot, expected) }];
+    });
+}
+export class VisibleFastMossCollector {
+    browser;
+    constructor(browser) {
+        this.browser = browser;
+    }
+    async stable(selector, accept) {
+        let previous = "", stableReads = 0;
+        const deadline = Date.now() + 25_000;
+        for (let attempt = 0; attempt < 200 && Date.now() < deadline; attempt++) {
+            const snapshot = await this.browser.snapshot(selector);
+            if (snapshot.blocked && snapshot.blocked !== "页面区域尚未出现")
+                throw new Error(snapshot.blocked);
+            const signature = JSON.stringify([snapshot.text, snapshot.inputs, snapshot.tables]);
+            stableReads = !snapshot.loading && accept(snapshot) && signature === previous ? stableReads + 1 : 0;
+            if (stableReads >= 2)
+                return snapshot;
+            previous = signature;
+            await this.browser.pause();
+        }
+        throw new Error("页面未稳定或时间范围未核实，已保留此前数据");
+    }
+    async verifyOverview(product) {
+        let latest = null;
+        let snapshot;
+        try {
+            snapshot = await this.stable("#overview", s => {
+                const overview = overviewFromSection(s);
+                if (!overview || overview.units === null || overview.units === undefined)
+                    return false;
+                latest = s;
+                const dates = [...new Map(product.daily.filter(d => d.date >= overview.ref.period.start && d.date <= overview.ref.period.end).map(d => [d.date, d])).values()];
+                return dates.length === 7 && dates.every(d => d.units !== null) && Math.abs(dates.reduce((sum, d) => sum + d.units, 0) - overview.units) <= (overview.unitsTolerance || 0);
+            });
+        }
+        catch (error) {
+            if (!latest)
+                throw error;
+            // A stable source discrepancy is an observation, not a reason to keep
+            // failing the whole product forever. The evaluator blocks recommendation.
+            snapshot = latest;
+            product.missing.push("7天汇总未与逐日合计对齐，保留可见数值待复核");
+        }
+        product.overview = overviewFromSection(snapshot);
+        product.price = visibleNumber(snapshot.inputs.find(i => i.value === "price")?.label.trim().split("\n").filter(Boolean)[0]);
+        product.priceBasis = "7天成交均价";
+        return product;
+    }
+    async discover(ranking, config, save) {
+        await this.browser.goto(`https://www.fastmoss.com/zh/e-commerce/${RANKINGS[ranking]}?region=${config.market}&page=1`);
+        const seen = new Set();
+        const sourceIndex = ["sales", "new", "hot", "video"].indexOf(ranking);
+        const target = Math.floor(config.candidateLimit / 4) + (sourceIndex < config.candidateLimit % 4 ? 1 : 0);
+        let previous = "";
+        // Categories are filtered on observed row text; never claim a hidden site filter was applied.
+        for (let page = 0; page < 5 && seen.size < target; page++) {
+            const snapshot = await this.stable("#dashboard-container-zh", s => rankingProducts(s, ranking, config).length > 0 && JSON.stringify(s.tables) !== previous);
+            const products = rankingProducts(snapshot, ranking, config, page * 10).filter(p => matchesCategory(p.category, config));
+            const fresh = products.filter(p => !seen.has(p.productId)).slice(0, target - seen.size);
+            for (const product of fresh)
+                seen.add(product.productId);
+            if (fresh.length)
+                await save(fresh);
+            previous = JSON.stringify(snapshot.tables);
+            if (seen.size >= target || !(await this.browser.next("#dashboard-container-zh")))
+                break;
+        }
+    }
+    async detail(product, config, save) {
+        await this.browser.goto(product.url);
+        const head = await this.stable("#dashboard-container-zh", s => s.text.includes("预估上架日期") && s.text.includes("数据总览"));
+        const text = head.text.split("数据总览")[0];
+        product.identityVerified = head.url.includes(`/detail/${product.productId}`) && text.includes(`${MARKETS[config.market]}销量榜`);
+        if (!product.identityVerified)
+            throw new Error("详情页未核实国家与商品身份");
+        product.listingDate = text.match(/预估上架日期[：:]?\s*(\d{4}-\d{2}-\d{2})/)?.[1] || null;
+        const priceText = text.match(/价格[：:]\s*([^\n]+)/)?.[1] || "";
+        product.price = visibleNumber(priceText);
+        product.currency = priceText.match(/MX\$|R\$|RM|Rp|US\$|[$€£฿¥₱₫]/)?.[0] || null;
+        product.stockText = text.match(/(?:^|\n)库存[：:]\s*([^\n]+)/)?.[1] || "";
+        product.stock = visibleNumber(product.stockText);
+        product.rating = visibleNumber(text.match(/(?:^|\n)([\d.]+)\s*\/\s*5\s*评论数/)?.[1]);
+        product.reviewCount = visibleNumber(text.match(/评论数[：:]?\s*([^\n]+)/)?.[1]);
+        if (product.reviewCount === 0)
+            product.rating = null;
+        product.error = undefined;
+        product.missing = [];
+        await save(product);
+        for (const days of [7, config.opportunity === "emerging" ? 28 : 90]) {
+            try {
+                await this.browser.clickText("#overview label", `近${days}天`);
+                let snapshot = await this.stable("#overview", s => Boolean(sectionPeriod(s, days)) && s.inputs.some(i => i.checked && i.label.trim() === `近${days}天`));
+                if (days === 7) {
+                    product.overview = overviewFromSection(snapshot);
+                    const averagePrice = snapshot.inputs.find(i => i.value === "price")?.label.trim().split("\n").filter(Boolean)[0];
+                    product.price = visibleNumber(averagePrice);
+                    product.priceBasis = "7天成交均价";
+                    await save(product);
+                }
+                const period = sectionPeriod(snapshot, days);
+                const savedDates = new Set(product.daily.filter(d => d.units !== null && d.ref.period?.start === period.start && d.ref.period?.end === period.end).map(d => d.date));
+                if (savedDates.size === days) {
+                    if (days === 7) {
+                        await this.verifyOverview(product);
+                        await save(product);
+                    }
+                    continue;
+                }
+                if (!snapshot.tables.some(t => t.headers.includes("时间")))
+                    await this.browser.clickText("#overview", "查看表格");
+                let previous = "";
+                for (let page = 0; page < 24; page++) {
+                    snapshot = await this.stable("#overview", s => dailyFromSection(s, days).length > 0 && JSON.stringify(s.tables) !== previous);
+                    const points = dailyFromSection(snapshot, days);
+                    // Retain 7-day and historical observations separately so conflicting
+                    // same-day snapshots remain detectable instead of being overwritten.
+                    product.daily.push(...points);
+                    await save(product);
+                    previous = JSON.stringify(snapshot.tables);
+                    if (!(await this.browser.next("#overview")))
+                        break;
+                }
+                if (days === 7) {
+                    await this.verifyOverview(product);
+                    await save(product);
+                }
+            }
+            catch (error) {
+                product.missing.push(`${days}天总览：${error instanceof Error ? error.message : String(error)}`);
+                await save(product);
+            }
+        }
+        try {
+            // FastMoss mounts lower detail sections only after they enter view.
+            await this.browser.clickText("#dashboard-container-zh", "商品关联视频");
+            await this.stable("#related_videos", s => s.inputs.some(i => /^近7天$/.test(i.label.trim())));
+            await this.browser.clickText("#related_videos label", "近7天", 0);
+            await this.browser.clickText("#related_videos label", "近7天", 1);
+            const expected = product.overview?.ref.period || null;
+            const snapshot = await this.stable("#related_videos", s => (videosFromSection(s, expected).length > 0 || /暂无数据|No data/i.test(s.text)) && s.inputs.filter(i => i.checked && i.label.trim() === "近7天").length === 2);
+            product.videos = videosFromSection(snapshot, expected);
+            if (!product.videos.length)
+                product.missing.push("所选窗口关联视频显示暂无数据，缺少近期新视频成交证据");
+            await save(product);
+            for (const video of product.videos.slice(0, 5)) {
+                try {
+                    await this.browser.goto(video.url);
+                    const detail = await this.stable("#dashboard-container-zh", s => s.links.some(l => /\/(?:influencer|author)\/detail\/\d+/.test(l.href)));
+                    const link = detail.links.find(l => /\/(?:influencer|author)\/detail\/\d+/.test(l.href));
+                    video.creatorId = link?.href.match(/\/detail\/(\d+)/)?.[1] || null;
+                    await save(product);
+                }
+                catch {
+                    product.missing.push(`视频 ${video.id} 的达人ID未核实`);
+                }
+            }
+        }
+        catch (error) {
+            product.missing.push(`近期视频：${error instanceof Error ? error.message : String(error)}`);
+        }
+        await save(product);
+        if (product.missing.some(m => /未稳定|deadline|超时|Timeout|selector/i.test(m)))
+            throw new Error("部分详情未完成，已保存可用证据，可继续复核");
+        return product;
+    }
+}

package/dist/integrations/fastmoss.d.ts

@@ -1,4 +1,6 @@
 import { type Response } from "playwright-core";
+import { FastMossSelectionSessions } from "./fastmoss-selection-session.js";
+import type { SelectionConfig } from "./fastmoss-opportunity.js";
 export type FastMossRankingSource = "new" | "hot" | "video" | "sales";
 export type FastMossPhase = "idle" | "saved" | "launching" | "login_required" | "ready" | "verification_required" | "membership_expired" | "error";
 export type FastMossStatus = {
@@ -55,11 +57,54 @@ export declare class FastMossIntegration {
     private readonly profileDir;
     private readonly authenticatedMarker;
     private readonly dataDir;
+    private selectionPage;
+    readonly selection: FastMossSelectionSessions;
     private savedAuthenticated;
     private observedVideoRecords;
     private videoResponseTasks;
     private observedVideoPages;
     constructor();
+    startSelection(id: string, config: Partial<SelectionConfig>, resume?: boolean): Promise<{
+        candidates: {
+            source: string;
+            sourceProductId: string;
+            platformProductId: string;
+            title: string;
+            market: string;
+            category: string;
+            storeName: string;
+            productUrl: string;
+            imageUrls: string[];
+            metrics: {
+                strategy: "fastmoss-evidence-v2";
+                selectionSessionId: string;
+                selectionDecision: "test" | "watch" | "skip";
+                selectionEligible: boolean;
+                portfolioSelected: boolean;
+                selectionReasons: string[];
+                selectionRisks: string[];
+                sales: number | null;
+                growthPercent: number | null;
+                price: number | null;
+                currency: string | null;
+                captureDate: string;
+                sourceVerified: boolean;
+                opportunityAssessment: import("./fastmoss-opportunity.js").Assessment;
+                opportunityEvidence: import("./fastmoss-opportunity.js").ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: import("./fastmoss-opportunity.js").Ranking[];
+        rankingErrors: Partial<Record<import("./fastmoss-opportunity.js").Ranking, string>>;
+        products: import("./fastmoss-opportunity.js").ProductEvidence[];
+        error?: string;
+    } | null>;
+    private selectionBrowser;
     status(): FastMossStatus;
     start(): Promise<FastMossStatus>;
     inspect(): Promise<FastMossStatus>;