@xiaohhhh1/canvas-agent 0.4.79 → 0.4.80

package/dist/integrations/fastmoss-opportunity.d.ts

@@ -0,0 +1,160 @@
+/** V2 uses visible, dated product evidence. The historical 6.9 selector is separate. */
+export declare const OPPORTUNITY_VERSION: "fastmoss-evidence-v2";
+export declare const MARKETS: {
+    MX: string;
+    US: string;
+    GB: string;
+    BR: string;
+    DE: string;
+    ES: string;
+    FR: string;
+    IT: string;
+    ID: string;
+    TH: string;
+    VN: string;
+    PH: string;
+    MY: string;
+    JP: string;
+    SG: string;
+    AT: string;
+    BE: string;
+    NL: string;
+    PL: string;
+    PT: string;
+};
+export type Ranking = "sales" | "new" | "hot" | "video";
+export declare const RANKINGS: Record<Ranking, string>;
+export type SelectionConfig = {
+    market: string;
+    categories: string[]; /** Legacy single-category sessions. */
+    category?: string;
+    opportunity: "all" | "emerging" | "rebound";
+    candidateLimit: number;
+    detailLimit: number;
+};
+type CategoryScope = Pick<Partial<SelectionConfig>, "categories" | "category">;
+export declare function selectionCategories(input: CategoryScope): string[];
+/** Match any selected visible category keyword; an empty scope means all categories. */
+export declare function matchesCategory(category: string, config: CategoryScope): boolean;
+export type Period = {
+    start: string;
+    end: string;
+    timeZone: string;
+};
+export type EvidenceRef = {
+    url: string;
+    section: string;
+    observedAt: string;
+    period: Period | null;
+};
+export type DailySale = {
+    date: string;
+    units: number | null;
+    ref: EvidenceRef;
+};
+export type VideoSale = {
+    id: string;
+    url: string;
+    creatorId: string | null;
+    creatorName: string;
+    published: string;
+    units: number | null;
+    ad: boolean | null;
+    ref: EvidenceRef;
+};
+export type ProductEvidence = {
+    version: typeof OPPORTUNITY_VERSION;
+    productId: string;
+    market: string;
+    title: string;
+    url: string;
+    category: string;
+    storeName: string;
+    imageUrls: string[];
+    discoveredAt: string;
+    rankings: Array<{
+        source: Ranking;
+        position: number;
+        ref: EvidenceRef;
+    }>;
+    identityVerified: boolean;
+    currency: string | null;
+    listingDate: string | null;
+    price: number | null;
+    stock: number | null;
+    rating: number | null;
+    priceBasis?: "7天成交均价";
+    stockText?: string;
+    reviewCount?: number | null;
+    daily: DailySale[];
+    videos: VideoSale[];
+    overview: {
+        ref: EvidenceRef;
+        units?: number | null;
+        unitsTolerance?: number;
+        videoShare: number | null;
+        liveShare: number | null;
+        adShare: number | null;
+        otherShare: number | null;
+    } | null;
+    missing: string[];
+    detailState: "pending" | "running" | "complete" | "failed";
+    error?: string;
+};
+export type Assessment = {
+    decision: "test" | "watch" | "skip";
+    opportunity: "emerging" | "rebound" | "unconfirmed";
+    reasons: string[];
+    risks: string[];
+    missing: string[];
+    cutoff: string | null;
+    recentUnits: number | null;
+    previousUnits: number | null;
+    growthPercent: number | null;
+    increment: number | null;
+    newVideoUnits: number | null;
+    newVideoCount: number;
+    convertingCreators: number;
+    topCreatorShare: number | null;
+    reboundWindows: Array<{
+        start: string;
+        end: string;
+        units: number;
+    }>;
+};
+export declare function selectionConfig(input: Partial<SelectionConfig>): SelectionConfig;
+/** Missing, rounded lower bounds and ranges must never silently become exact zero. */
+export declare function visibleNumber(value: unknown): number | null;
+export declare const isoDate: (value: string) => boolean;
+export declare const dayOffset: (date: string, days: number) => string;
+export declare const samePeriod: (a: Period | null, b: Period | null) => boolean;
+export declare function assessOpportunity(product: ProductEvidence, config: SelectionConfig, now?: Date): Assessment;
+export declare function opportunityCandidate(product: ProductEvidence, config: SelectionConfig, sessionId: string): {
+    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: Assessment;
+        opportunityEvidence: ProductEvidence;
+    };
+};
+export {};

package/dist/integrations/fastmoss-opportunity.js

@@ -0,0 +1,183 @@
+/** V2 uses visible, dated product evidence. The historical 6.9 selector is separate. */
+export const OPPORTUNITY_VERSION = "fastmoss-evidence-v2";
+export const MARKETS = { MX: "墨西哥", US: "美国", GB: "英国", BR: "巴西", DE: "德国", ES: "西班牙", FR: "法国", IT: "意大利", ID: "印度尼西亚", TH: "泰国", VN: "越南", PH: "菲律宾", MY: "马来西亚", JP: "日本", SG: "新加坡", AT: "奥地利", BE: "比利时", NL: "荷兰", PL: "波兰", PT: "葡萄牙" };
+export const RANKINGS = { sales: "saleslist", new: "newProducts", hot: "hotlist", video: "hotvideo" };
+export function selectionCategories(input) {
+    const values = input.categories === undefined ? [input.category || ""] : input.categories;
+    if (!Array.isArray(values) || values.some(value => typeof value !== "string"))
+        throw new Error("类目须为文字列表");
+    const categories = [...new Set(values.map(value => value.trim().replace(/\s+/g, " ").toLowerCase()).filter(Boolean))].sort();
+    if (categories.some(value => value.length > 100))
+        throw new Error("每个类目关键词最多100字");
+    return categories;
+}
+/** Match any selected visible category keyword; an empty scope means all categories. */
+export function matchesCategory(category, config) {
+    const categories = selectionCategories(config), visible = category.trim().replace(/\s+/g, " ").toLowerCase();
+    return !categories.length || categories.some(keyword => visible.includes(keyword));
+}
+export function selectionConfig(input) {
+    const market = String(input.market || "MX").toUpperCase();
+    if (!(market in MARKETS))
+        throw new Error("请选择支持的具体国家");
+    const opportunity = input.opportunity || "all";
+    if (!["all", "emerging", "rebound"].includes(opportunity))
+        throw new Error("选品方向无效");
+    const bounded = (value, fallback, max) => {
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > max)
+            throw new Error("采集数量超出范围");
+        return value;
+    };
+    const candidateLimit = bounded(input.candidateLimit, 30, 100);
+    if (candidateLimit < 4)
+        throw new Error("四榜采集的候选数量上限至少为4");
+    return { market, categories: selectionCategories(input), opportunity, candidateLimit, detailLimit: Math.min(candidateLimit, bounded(input.detailLimit, 10, 30)) };
+}
+/** Missing, rounded lower bounds and ranges must never silently become exact zero. */
+export function visibleNumber(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    if (typeof value !== "string")
+        return null;
+    const raw = value.trim().replace(/,/g, "");
+    if (!raw || /[+<>~～]|\d\s*[-–—]\s*\d|解锁|升级|示例|演示/.test(raw))
+        return null;
+    const match = raw.match(/^(?:(?:MX\$|R\$|RM|Rp|US\$|USD|MXN|GBP|EUR|BRL|SGD|PHP|IDR|THB|MYR|VND|JPY)|[$€£฿¥₱₫])?\s*(\d+(?:\.\d+)?)\s*(亿|万|[kKmMbB])?%?$/);
+    if (!match)
+        return null;
+    const factors = { 亿: 1e8, 万: 1e4, k: 1e3, m: 1e6, b: 1e9 };
+    return Number(match[1]) * (factors[String(match[2] || "").toLowerCase()] || 1);
+}
+export const isoDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+export const dayOffset = (date, days) => new Date(Date.parse(date) + days * 86400000).toISOString().slice(0, 10);
+export const samePeriod = (a, b) => Boolean(a && b && a.start === b.start && a.end === b.end && a.timeZone === b.timeZone);
+export function assessOpportunity(product, config, now = new Date()) {
+    const reasons = [], risks = [], missing = [...product.missing];
+    const belongs = (reference) => { try {
+        const url = new URL(reference.url);
+        return url.hostname === "www.fastmoss.com" && url.pathname.endsWith(`/e-commerce/detail/${product.productId}`);
+    }
+    catch {
+        return false;
+    } };
+    const valid = product.daily.filter(p => belongs(p.ref) && isoDate(p.date) && p.units !== null && p.units >= 0 && p.ref.period && p.date >= p.ref.period.start && p.date <= p.ref.period.end);
+    const byDate = new Map();
+    for (const point of valid) {
+        const previous = byDate.get(point.date);
+        if (previous && previous.units !== point.units)
+            missing.push("同一天销量快照不一致，需复核");
+        if (!previous || point.ref.observedAt > previous.ref.observedAt)
+            byDate.set(point.date, point);
+    }
+    const cutoff = [...byDate.keys()].sort().at(-1) || null;
+    const window = (end, length) => Array.from({ length }, (_, i) => byDate.get(dayOffset(end, i - length + 1)));
+    const sum = (points) => points.every((p) => Boolean(p && p.units !== null)) && new Set(points.map(p => p.ref.period.timeZone)).size === 1 ? points.reduce((total, p) => total + p.units, 0) : null;
+    const current = cutoff ? window(cutoff, 7) : [];
+    const recentUnits = current.length ? sum(current) : null;
+    const previousUnits = cutoff && sum(window(cutoff, 14)) !== null ? sum(window(dayOffset(cutoff, -7), 7)) : null;
+    const increment = recentUnits !== null && previousUnits !== null ? recentUnits - previousUnits : null;
+    const growthPercent = increment !== null && previousUnits > 0 ? increment / previousUnits * 100 : null;
+    if (recentUnits === null)
+        missing.push("缺少连续7天可见日销量");
+    if (previousUnits === null)
+        missing.push("缺少前一可比7天，不能确认周增长");
+    if (recentUnits !== null)
+        reasons.push(`最近7天 ${recentUnits} 单`);
+    if (increment !== null)
+        reasons.push(`比前7天${increment >= 0 ? "增加" : "减少"} ${Math.abs(increment)} 单${growthPercent !== null ? `（${growthPercent.toFixed(1)}%）` : "（前期为0，不计算百分比）"}`);
+    const fresh = Boolean(cutoff && Date.parse(cutoff) <= now.getTime() && now.getTime() - Date.parse(cutoff) < 4 * 86400000);
+    if (!fresh)
+        missing.push("数据截止日期缺失或已超过3天，需刷新");
+    const previousAverage = previousUnits === null ? null : previousUnits / 7;
+    const sustained = recentUnits !== null && previousAverage !== null && current.slice(-3).every(p => p.units > previousAverage);
+    const rising = increment !== null && increment > 0 && sustained;
+    if (!sustained && increment !== null && increment > 0)
+        risks.push("尚未连续3天高于前周日均，可能受单日尖峰影响");
+    if (current.length && recentUnits && Math.max(...current.map(p => p?.units || 0)) / recentUnits > 0.5)
+        risks.push("超过一半周销量集中在一天");
+    const recentPeriod = cutoff && current[0]?.ref.period ? { start: dayOffset(cutoff, -6), end: cutoff, timeZone: current[0].ref.period.timeZone } : null;
+    const videos = [...new Map(product.videos.filter(v => belongs(v.ref) && samePeriod(v.ref.period, recentPeriod) && isoDate(v.published) && v.published >= recentPeriod.start && v.published <= recentPeriod.end && v.units !== null && v.units > 0).map(v => [v.id, v])).values()];
+    const creatorSales = new Map();
+    for (const v of videos)
+        if (v.creatorId)
+            creatorSales.set(v.creatorId, (creatorSales.get(v.creatorId) || 0) + v.units);
+    const newVideoUnits = videos.length ? videos.reduce((s, v) => s + v.units, 0) : null;
+    const topCreatorShare = newVideoUnits && creatorSales.size ? Math.max(...creatorSales.values()) / newVideoUnits : null;
+    if (!videos.length)
+        missing.push("缺少同期间新发布且出单的视频");
+    if (videos.some(v => !v.creatorId))
+        missing.push("部分出单视频的达人ID尚未核实");
+    const distributed = creatorSales.size >= 2 && videos.every(v => v.creatorId) && topCreatorShare !== null && topCreatorShare <= 0.8;
+    if (!distributed)
+        missing.push("尚未验证多个不同达人均有近期有效成交");
+    if (topCreatorShare !== null && topCreatorShare > 0.8)
+        risks.push("已读取的新视频成交超过80%集中在一个达人，扩散证据不足");
+    if (videos.length)
+        reasons.push(`已读取 ${videos.length} 条近期出单新视频，核实 ${creatorSales.size} 个达人（样本，非全量）`);
+    const overview = product.overview && belongs(product.overview.ref) && samePeriod(product.overview.ref.period, recentPeriod) ? product.overview : null;
+    if (!overview)
+        missing.push("成交渠道统计与7天销量窗口未对齐");
+    const totalsMatch = Boolean(overview && overview.units !== null && overview.units !== undefined && recentUnits !== null && Math.abs(overview.units - recentUnits) <= (overview.unitsTolerance || 0));
+    if (!totalsMatch)
+        missing.push(overview?.units !== null && overview?.units !== undefined && recentUnits !== null ? `7天总览 ${overview.units} 单与逐日合计 ${recentUnits} 单不一致，需复核数据快照` : "缺少7天总览销量，尚不能与逐日合计核对");
+    if (overview?.adShare === null || !overview)
+        missing.push("广告成交占比未知");
+    if (overview?.liveShare === null || !overview)
+        missing.push("直播成交占比未知");
+    if (overview && overview.adShare !== null && overview.adShare >= 70)
+        risks.push(`广告成交占比 ${overview.adShare}%，需验证投流条件，不能推断自然流量可复制`);
+    if (overview && overview.liveShare !== null && overview.liveShare >= 50)
+        risks.push(`直播成交占比 ${overview.liveShare}%，短视频机会仍待验证`);
+    const weeks = [];
+    if (cutoff)
+        for (let end = dayOffset(cutoff, -7); end >= dayOffset(cutoff, -83); end = dayOffset(end, -7)) {
+            const total = sum(window(end, 7));
+            if (total !== null)
+                weeks.unshift({ start: dayOffset(end, -6), end, units: total });
+        }
+    let reboundWindows = [];
+    // Require a complete observed path from a past peak through a subsequent trough.
+    for (let peak = 0; peak < weeks.length - 1; peak++)
+        for (let trough = peak + 1; trough < weeks.length; trough++) {
+            const path = weeks.slice(peak, trough + 1);
+            const continuous = path.every((w, i) => !i || dayOffset(path[i - 1].end, 1) === w.start);
+            if (continuous && cutoff && sum(window(cutoff, Math.round((Date.parse(cutoff) - Date.parse(weeks[peak].start)) / 86400000) + 1)) !== null && weeks[peak].units > 0 && weeks[trough].units <= weeks[peak].units * 0.5 && recentUnits !== null && recentUnits >= Math.max(1, weeks[trough].units * 1.5) && rising)
+                reboundWindows = [weeks[peak], weeks[trough], { start: dayOffset(cutoff, -6), end: cutoff, units: recentUnits }];
+        }
+    const opportunity = reboundWindows.length ? "rebound" : rising ? "emerging" : "unconfirmed";
+    if (reboundWindows.length)
+        reasons.push("逐日历史支持高峰→回落→再次起量，仍需结合新内容判断驱动");
+    if (config.opportunity === "rebound" && !reboundWindows.length)
+        missing.push("历史高峰、回落及持续回升尚未全部证实");
+    if (!product.identityVerified || product.market !== config.market)
+        missing.push("国家与商品身份尚未在详情页核实");
+    if (product.stock === null)
+        missing.push("具体SKU库存待核对");
+    if (product.rating === null)
+        missing.push("商品评分未知");
+    missing.push("同国同类目相近价格带竞争、具体SKU及实际视频呈现仍需人工复核");
+    const wrongDirection = config.opportunity === "emerging" && opportunity === "rebound";
+    const poorRating = product.rating !== null && product.rating < 3.5 && product.reviewCount !== 0;
+    const hardSkip = product.stock === 0 || poorRating || (increment !== null && increment <= 0) || wrongDirection;
+    if (product.stock === 0)
+        risks.push("详情显示无库存");
+    if (poorRating)
+        risks.push("详情评分低于3.5，先核对质量问题");
+    if (product.reviewCount === 0)
+        missing.push("暂无评论，不能按0分判断质量");
+    if (increment !== null && increment <= 0)
+        risks.push("近7天销量未高于前7天");
+    if (wrongDirection)
+        risks.push("已识别为二次起量，与本轮仅找潜力起量的范围不符");
+    const aligned = overview && overview.adShare !== null && overview.adShare < 70 && overview.liveShare !== null && overview.liveShare < 50 && overview.videoShare !== null && overview.videoShare >= 50;
+    const hasConflict = missing.some(x => /快照不一致/.test(x));
+    const decision = hardSkip ? "skip" : product.detailState === "complete" && product.identityVerified && product.market === config.market && fresh && rising && distributed && aligned && totalsMatch && !hasConflict && (config.opportunity !== "rebound" || reboundWindows.length > 0) ? "test" : "watch";
+    return { decision, opportunity, reasons, risks, missing: [...new Set(missing)], cutoff, recentUnits, previousUnits, growthPercent, increment, newVideoUnits, newVideoCount: videos.length, convertingCreators: creatorSales.size, topCreatorShare, reboundWindows };
+}
+export function opportunityCandidate(product, config, sessionId) {
+    const assessment = assessOpportunity(product, config);
+    return { source: "fastmoss-agent", sourceProductId: product.productId, platformProductId: product.productId, title: product.title, market: product.market, category: product.category, storeName: product.storeName, productUrl: product.url, imageUrls: product.imageUrls,
+        metrics: { strategy: OPPORTUNITY_VERSION, selectionSessionId: sessionId, selectionDecision: assessment.decision, selectionEligible: assessment.decision !== "skip", portfolioSelected: assessment.decision === "test", selectionReasons: assessment.reasons, selectionRisks: [...assessment.risks, ...assessment.missing], sales: assessment.recentUnits, growthPercent: assessment.growthPercent, price: product.price, currency: product.currency, captureDate: product.discoveredAt, sourceVerified: false, opportunityAssessment: assessment, opportunityEvidence: product } };
+}

package/dist/integrations/fastmoss-selection-session.d.ts

@@ -0,0 +1,112 @@
+import { type ProductEvidence, type Ranking, type SelectionConfig } from "./fastmoss-opportunity.js";
+export type SelectionSession = {
+    id: string;
+    config: SelectionConfig;
+    createdAt: string;
+    updatedAt: string;
+    phase: "collecting" | "reviewing" | "complete" | "interrupted";
+    active: boolean;
+    completedRankings: Ranking[];
+    rankingErrors: Partial<Record<Ranking, string>>;
+    products: ProductEvidence[];
+    error?: string;
+};
+export type SelectionAdapter = {
+    discover: (ranking: Ranking, config: SelectionConfig, save: (products: ProductEvidence[]) => Promise<void>) => Promise<void>;
+    detail: (product: ProductEvidence, config: SelectionConfig, save: (product: ProductEvidence) => Promise<void>) => Promise<ProductEvidence>;
+};
+export declare class FastMossSelectionSessions {
+    private directory;
+    private adapter;
+    private activeId;
+    private task;
+    private serial;
+    constructor(directory: string, adapter: SelectionAdapter);
+    isRunning(): boolean;
+    private atomic;
+    private persist;
+    private load;
+    get(id?: string): 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: ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: Ranking[];
+        rankingErrors: Partial<Record<Ranking, string>>;
+        products: ProductEvidence[];
+        error?: string;
+    } | null>;
+    /** Serialize ACK creation; repeat POST with the same id never starts duplicate work. */
+    start(id: string, input: 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: ProductEvidence;
+            };
+        }[];
+        id: string;
+        config: SelectionConfig;
+        createdAt: string;
+        updatedAt: string;
+        phase: "collecting" | "reviewing" | "complete" | "interrupted";
+        active: boolean;
+        completedRankings: Ranking[];
+        rankingErrors: Partial<Record<Ranking, string>>;
+        products: ProductEvidence[];
+        error?: string;
+    } | null>;
+    waitUntilIdle(): Promise<void>;
+    private run;
+}

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>;

package/dist/integrations/fastmoss.js

@@ -4,6 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import { chromium } from "playwright-core";
 import { CONFIG_DIR } from "../config.js";
+import { FastMossSelectionSessions } from "./fastmoss-selection-session.js";
+import { VisibleFastMossCollector, readVisibleSection } from "./fastmoss-visible-evidence.js";
 const FASTMOSS_HOME = "https://www.fastmoss.com/";
 const MEMBERSHIP_RECHECK_MS = 5 * 60_000;
 const MANUAL_VERIFICATION_TIMEOUT_MS = 10 * 60_000;
@@ -37,6 +39,11 @@ export class FastMossIntegration {
     profileDir = path.join(CONFIG_DIR, "fastmoss-session");
     authenticatedMarker = path.join(this.profileDir, "authenticated.json");
     dataDir = path.join(CONFIG_DIR, "fastmoss-selection");
+    selectionPage = null;
+    selection = new FastMossSelectionSessions(path.join(this.dataDir, "sessions-v2"), {
+        discover: async (ranking, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).discover(ranking, config, save),
+        detail: async (product, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).detail(product, config, save),
+    });
     savedAuthenticated = existsSync(this.authenticatedMarker);
     observedVideoRecords = [];
     videoResponseTasks = new Set();
@@ -48,6 +55,40 @@ export class FastMossIntegration {
         this.authenticated = true;
         this.message = "FastMoss 登录已保存在本机；窗口可以关闭，抓取时会自动恢复";
     }
+    async startSelection(id, config, resume = false) {
+        return this.selection.start(id, config, resume);
+    }
+    async selectionBrowser() {
+        if (!this.context)
+            await this.start();
+        if (!this.context)
+            throw new Error("FastMoss 本机浏览器未启动");
+        if (!this.selectionPage || this.selectionPage.isClosed())
+            this.selectionPage = await this.context.newPage();
+        const page = this.selectionPage;
+        return {
+            goto: async (url) => {
+                const parsed = new URL(url);
+                if (parsed.protocol !== "https:" || parsed.hostname !== "www.fastmoss.com")
+                    throw new Error("商品证据地址不是 FastMoss 页面");
+                await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45_000 });
+            },
+            snapshot: selector => page.evaluate(readVisibleSection, selector),
+            clickText: async (selector, text, occurrence = 0) => {
+                const scope = page.locator(selector);
+                const matches = selector.endsWith(" label") ? scope.filter({ hasText: new RegExp(`^${text}$`) }) : scope.getByText(text, { exact: true });
+                await matches.nth(occurrence).click({ timeout: 15_000 });
+            },
+            next: async (selector) => {
+                const next = page.locator(`${selector} .ant-pagination-next`).first();
+                if (!(await next.count()) || await next.getAttribute("aria-disabled") === "true" || (await next.getAttribute("class"))?.includes("ant-pagination-disabled"))
+                    return false;
+                await next.click({ timeout: 10_000 });
+                return true;
+            },
+            pause: () => page.waitForTimeout(600),
+        };
+    }
     status() {
         return {
             phase: this.phase,
@@ -172,6 +213,8 @@ export class FastMossIntegration {
         return this.status();
     }
     async capture(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("新版选品正在采集，请等待完成");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -280,6 +323,8 @@ export class FastMossIntegration {
      * private FastMoss API requests and pauses for the operator when a CAPTCHA appears.
      */
     async captureLearningVideos(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("选品正在使用 FastMoss，请等待完成后再采集素材");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -385,6 +430,8 @@ export class FastMossIntegration {
         return { ...this.status(), sources, rejected, requestedTarget, complete: sources.length >= requestedTarget };
     }
     async close() {
+        if (this.selection.isRunning())
+            throw new Error("选品正在保存数据，请等待完成后关闭浏览器");
         const context = this.context;
         this.context = null;
         this.page = null;
@@ -500,6 +547,8 @@ export class FastMossIntegration {
         }
     }
     async switchAccount() {
+        if (this.selection.isRunning())
+            throw new Error("选品尚未完成，请等待完成后更换账号");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         this.useLatestPage();

package/dist/server/http.js

@@ -133,7 +133,10 @@ export function startHttpServer() {
         await openExternalUrl(url.toString());
         res.json({ ok: true });
     }));
-    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));
+    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...(fastmoss.selection.isRunning() ? fastmoss.status() : await fastmoss.inspect()) })));
+    app.get("/agent/integrations/fastmoss/selection", route(async (_req, res) => res.json({ ok: true, session: await fastmoss.selection.get() })));
+    app.get("/agent/integrations/fastmoss/selection/:sessionId", route(async (req, res) => res.json({ ok: true, session: await fastmoss.selection.get(routeParam(req.params.sessionId)) })));
+    app.post("/agent/integrations/fastmoss/selection", route(async (req, res) => res.json({ ok: true, session: await fastmoss.startSelection(String(req.body?.sessionId || ""), req.body?.config || {}, req.body?.resume === true) })));
     app.get("/agent/integrations/fastmoss/observations", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.observations() })));
     app.post("/agent/integrations/fastmoss/start", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.start() })));
     app.post("/agent/integrations/fastmoss/refresh", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.79",
+  "version": "0.4.80",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",