openyida 2026.9.11 → 2026.9.13

package/lib/asset/asset-resolve.js

@@ -1,31 +1,3 @@
-
-/**
- * asset-resolve.js - 素材解析与回填引擎
- *
- * P3 素材工具化的收口层：把 spec 里声明的图片素材（Hero / 产品图，可能是
- * 本地路径、外链 URL 或空）解析为「可直接写进页面的稳定 URL」，并诚实地
- * 给出素材完成度（materialStatus）与缺口（materialGaps），供生成链路决定
- * 交付「最终版」还是「标注缺口的低保真草稿」。
- *
- * 解析规则（对每个候选图片）：
- *   - 本地文件（存在于磁盘）：
- *       · 有 CDN → 转存 CDN，替换为稳定 CDN URL（source: cdn）；
- *       · 无 CDN → 无法交付浏览器可访问的稳定 URL → 记为缺口。
- *   - http(s) 外链：由 resolve 流程确认可用后保留（source: external）；
- *     有 CDN 且 options.mirror=true 时镜像转存；不可用时记为缺口。
- *   - 空 / 占位：记为对应槽位缺口。
- *
- * materialStatus：
- *   - 'final' : 所需素材（含 Hero，若 requireHero）均已解析为稳定 URL；
- *   - 'draft' : 页面可渲染但存在素材缺口（缺 Hero / 部分产品图失败）；
- *   - 'none'  : 无任何可用素材且需要图片 → 只能交付低保真草稿。
- *
- * 用法：
- *   const { resolveAssets } = require('./asset-resolve');
- *   const r = await resolveAssets(spec.assets, { requireHero: true });
- *   // { assets, materialStatus, materialGaps, strategy, actions, status }
- */
-
 'use strict';
 
 const fs = require('fs');
@@ -33,16 +5,24 @@ const os = require('os');
 const path = require('path');
 const https = require('https');
 const http = require('http');
-const { verifyImageUrl } = require('./url-verify');
-const { getAssetStatus, STRATEGY } = require('./asset-status');
+const crypto = require('crypto');
+const { minimumSize, prepareAssetPlan } = require('./asset-plan');
+const { readImageMetadata, parseImageMetadata } = require('./image-metadata');
+const { MAX_IMAGE_BYTES, uploadAttachment } = require('./attachment-upload');
+const { getAssetStatus } = require('./asset-status');
+
+const ALLOWED_STOCK_IMAGE_PROVIDERS = Object.freeze({
+  unsplash: Object.freeze(['images.unsplash.com']),
+  pexels: Object.freeze(['images.pexels.com']),
+});
+const ASSET_SOURCES = Object.freeze(['search', 'user', 'generated']);
 
 function isHttpUrl(value) {
   return typeof value === 'string' && /^https?:\/\//i.test(value.trim());
 }
 
 function isLocalFile(value) {
-  if (!value || typeof value !== 'string') {return false;}
-  if (isHttpUrl(value)) {return false;}
+  if (!value || typeof value !== 'string' || isHttpUrl(value)) {return false;}
   try {
     return fs.existsSync(value) && fs.statSync(value).isFile();
   } catch {
@@ -50,250 +30,383 @@ function isLocalFile(value) {
   }
 }
 
+function getCollectedImageProvider(rawUrl) {
+  try {
+    const host = new URL(rawUrl).hostname.toLowerCase();
+    for (const [provider, hosts] of Object.entries(ALLOWED_STOCK_IMAGE_PROVIDERS)) {
+      if (hosts.some(allowed => host === allowed || host.endsWith(`.${allowed}`))) {return provider;}
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function getExternalDeliveryPolicy(rawUrl) {
+  return isHttpUrl(rawUrl) ? 'yida-attachment' : 'standard';
+}
+
 function extensionFromUrl(rawUrl) {
   try {
-    const parsed = new URL(rawUrl);
-    const ext = path.extname(parsed.pathname || '').toLowerCase();
+    const ext = path.extname(new URL(rawUrl).pathname || '').toLowerCase();
     return ext && ext.length <= 8 ? ext : '.img';
   } catch {
     return '.img';
   }
 }
 
-function downloadUrlToTemp(rawUrl, options = {}) {
-  const timeout = options.timeout || 15000;
-  const tempPath = path.join(os.tmpdir(), `openyida-asset-${Date.now()}-${Math.random().toString(36).slice(2)}${extensionFromUrl(rawUrl)}`);
-  return new Promise((resolve, reject) => {
-    let parsed;
-    try {
-      parsed = new URL(rawUrl);
-    } catch {
-      reject(new Error('INVALID_URL'));
-      return;
-    }
-    const client = parsed.protocol === 'https:' ? https : http;
-    const req = client.get(
-      parsed,
-      {
-        headers: {
-          'User-Agent': 'Mozilla/5.0 (compatible; OpenYidaAssetMirror/1.0)',
-          Accept: 'image/*,*/*;q=0.8',
-        },
-      },
-      (res) => {
+async function downloadUrlToTemp(rawUrl, options = {}, depth = 0) {
+  if (depth > 4) {throw new Error('TOO_MANY_REDIRECTS');}
+  if (options.stockOnly && !getCollectedImageProvider(rawUrl)) {throw new Error('STOCK_PROVIDER_REDIRECT_NOT_ALLOWED');}
+  const parsed = new URL(rawUrl);
+  if (!['https:', 'http:'].includes(parsed.protocol)) {throw new Error('UNSUPPORTED_PROTOCOL');}
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openyida-asset-'));
+  const tempPath = path.join(dir, `image${extensionFromUrl(rawUrl)}`);
+  let fileStream;
+  let fileClosed;
+  try {
+    const redirect = await new Promise((resolve, reject) => {
+      const client = parsed.protocol === 'https:' ? https : http;
+      const req = client.get(parsed, { headers: { 'User-Agent': 'OpenYidaAsset/1.0', Accept: 'image/*' } }, res => {
         if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
           res.resume();
-          downloadUrlToTemp(new URL(res.headers.location, rawUrl).toString(), options).then(resolve, reject);
+          try { resolve(new URL(res.headers.location, rawUrl).toString()); } catch (error) { reject(error); }
           return;
         }
-        if (res.statusCode < 200 || res.statusCode >= 400) {
-          res.resume();
-          reject(new Error(`HTTP_${res.statusCode || 0}`));
-          return;
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          res.resume(); reject(new Error(`HTTP_${res.statusCode}`)); return;
         }
+        const declaredTooLarge = Number(res.headers['content-length']) > MAX_IMAGE_BYTES;
+        let bytes = 0;
+        let header = Buffer.alloc(0);
         const out = fs.createWriteStream(tempPath);
+        fileStream = out;
+        fileClosed = new Promise(resolve => out.once('close', resolve));
+        let failed = false;
+        const fail = error => {
+          if (failed) {return;}
+          failed = true;
+          reject(error);
+          out.destroy();
+          res.destroy();
+        };
+        res.on('data', chunk => {
+          bytes += chunk.length;
+          if (header.length < 128 * 1024) {header = Buffer.concat([header, chunk.subarray(0, 128 * 1024 - header.length)]);}
+          const metadata = declaredTooLarge ? parseImageMetadata(header) : null;
+          if (bytes > MAX_IMAGE_BYTES || (declaredTooLarge && (metadata.width > 0 || header.length >= 128 * 1024))) {
+            const error = new Error('ASSET_TOO_LARGE');
+            error.metadata = metadata || parseImageMetadata(header);
+            fail(error);
+          }
+        });
+        res.on('error', fail);
+        res.on('aborted', () => fail(new Error('DOWNLOAD_ABORTED')));
+        out.on('error', fail);
+        out.on('finish', () => out.close(() => resolve('')));
         res.pipe(out);
-        out.on('finish', () => out.close(() => resolve(tempPath)));
-        out.on('error', reject);
-      }
-    );
-    req.setTimeout(timeout, () => req.destroy(new Error('TIMEOUT')));
-    req.on('error', reject);
-  });
+      });
+      req.setTimeout(options.timeout || 15000, () => req.destroy(new Error('TIMEOUT')));
+      req.on('error', reject);
+    });
+    if (redirect) {
+      fs.rmSync(dir, { recursive: true, force: true });
+      return downloadUrlToTemp(redirect, options, depth + 1);
+    }
+    // Correct missing/wrong URL extensions using the downloaded image header.
+    const type = readImageMetadata(tempPath).type;
+    const target = path.join(dir, `image.${type || 'img'}`);
+    if (tempPath !== target) {fs.renameSync(tempPath, target);}
+    return target;
+  } catch (error) {
+    if (fileStream) {
+      // destroy() closes the handle asynchronously; Windows cannot unlink it yet.
+      fileStream.destroy();
+      await fileClosed;
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+    throw error;
+  }
 }
 
-/**
- * 解析单个候选图片
- * @param {string} candidate 本地路径或外链 URL
- * @param {object} ctx { canUpload, online, uploadFn }
- * @returns {Promise<{ resolved:boolean, url:string, source:string, reason:string }>}
- */
-async function resolveOne(candidate, ctx) {
-  const raw = (candidate || '').trim();
-  if (!raw) {
-    return { resolved: false, url: '', source: 'empty', reason: 'EMPTY' };
+function sizeFailure(metadata, ctx) {
+  if (!metadata.type) {return 'NOT_IMAGE_FILE';}
+  if (![metadata.width, metadata.height].every(value => Number.isFinite(value) && value > 0)) {
+    return 'DIMENSIONS_UNAVAILABLE';
   }
+  if (ctx.minWidth > 0 && metadata.width < ctx.minWidth) {return 'WIDTH_TOO_SMALL';}
+  if (ctx.minHeight > 0 && metadata.height < ctx.minHeight) {return 'HEIGHT_TOO_SMALL';}
+  return '';
+}
+
+function fileHash(file) {
+  const hash = crypto.createHash('sha256');
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buffer = Buffer.alloc(64 * 1024);
+    let bytes;
+    while ((bytes = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0) {hash.update(buffer.subarray(0, bytes));}
+    return hash.digest('hex');
+  } finally { fs.closeSync(fd); }
+}
+
+async function reuseDelivery(input, metadata, ctx) {
+  const previous = ctx.previous || {};
+  const delivery = previous.delivery || {};
+  if (ctx.online === false || delivery.source !== 'yida-attachment' || delivery.input !== input ||
+      delivery.assetSource !== ctx.assetSource || !metadata.contentHash || delivery.contentHash !== metadata.contentHash ||
+      !isHttpUrl(previous.url)) {return null;}
+  return { ...metadata, resolved: true, url: previous.url, source: 'yida-attachment', reason: 'OK_REUSED' };
+}
+
+async function resolveOne(candidate, ctx = {}) {
+  const raw = String(candidate || '').trim();
+  if (!raw) {return { resolved: false, url: '', source: 'empty', reason: 'EMPTY' };}
 
-  // 外链素材：由 resolve 流程统一确认并按需镜像
   if (isHttpUrl(raw)) {
-    const v = await (ctx.verifyFn || verifyImageUrl)(raw, { timeout: ctx.timeout });
-    if (v.ok) {
-      if (ctx.mirrorExternal && ctx.canUpload) {
-        let tempPath = '';
-        try {
-          tempPath = await (ctx.downloadFn || downloadUrlToTemp)(v.finalUrl || raw, { timeout: ctx.timeout });
-          const results = await ctx.uploadFn([tempPath]);
-          const hit = (results || []).find((r) => r.success && r.originalPath === tempPath) ||
-            (results || []).find((r) => r.success);
-          if (hit && hit.cdnUrl) {
-            return { resolved: true, url: hit.cdnUrl, source: 'cdn-mirrored', reason: 'OK' };
-          }
-          const failed = (results || [])[0];
-          return {
-            resolved: false,
-            url: raw,
-            source: 'external',
-            reason: (failed && failed.error) || 'MIRROR_UPLOAD_FAILED',
-          };
-        } catch (err) {
-          return { resolved: false, url: raw, source: 'external', reason: (err && err.message) || 'MIRROR_FAILED' };
-        } finally {
-          if (tempPath) {
-            fs.rmSync(tempPath, { force: true });
-          }
-        }
-      }
+    if (ctx.online === false) {
+      return { resolved: false, url: raw, source: 'external', reason: 'OFFLINE_EXTERNAL_URL' };
+    }
+    const assetSource = ASSET_SOURCES.includes(ctx.assetSource) ? ctx.assetSource : 'search';
+    const inputProvider = getCollectedImageProvider(raw);
+    if (assetSource === 'search' && !inputProvider) {
       return {
-        resolved: true,
-        url: v.finalUrl || raw,
+        resolved: false,
+        url: raw,
         source: 'external',
-        reason: 'OK',
+        reason: 'STOCK_PROVIDER_NOT_ALLOWED',
+        deliveryPolicy: 'blocked',
+        provider: null,
+        allowedProviders: Object.keys(ALLOWED_STOCK_IMAGE_PROVIDERS),
       };
     }
-    return { resolved: false, url: raw, source: 'external', reason: v.reason || 'ASSET_UNAVAILABLE' };
+    const deliveryPolicy = getExternalDeliveryPolicy(raw);
+    const common = { provider: inputProvider || ctx.provider || assetSource };
+    const original = metadata => {
+      const failure = sizeFailure(metadata, ctx);
+      if (failure) {return { ...common, resolved: false, reason: failure };}
+      return { ...common, ...metadata, imageType: metadata.type, resolved: true, url: raw,
+        source: 'external', reason: 'ASSET_TOO_LARGE', deliveryPolicy: 'original-url' };
+    };
+    let tempPath = '';
+    try {
+      tempPath = await (ctx.downloadFn || downloadUrlToTemp)(raw, { timeout: ctx.timeout, stockOnly: assetSource === 'search' });
+      if (fs.statSync(tempPath).size > MAX_IMAGE_BYTES) {return original(readImageMetadata(tempPath));}
+      const downloaded = readImageMetadata(tempPath);
+      const failure = sizeFailure(downloaded, ctx);
+      if (failure) {return { resolved: false, url: raw, source: 'external', reason: failure };}
+      Object.assign(common, downloaded, { contentHash: fileHash(tempPath), imageType: downloaded.type });
+      const reused = await reuseDelivery(raw, common, ctx);
+      if (reused) {return reused;}
+      if (!ctx.canUpload) {return { resolved: false, url: raw, source: 'external', reason: 'YIDA_ATTACHMENT_UNAVAILABLE' };}
+      const results = await ctx.uploadFn([tempPath]);
+      const hit = (results || []).find(result => result.success && result.originalPath === tempPath)
+        || (results || []).find(result => result.success);
+      if (hit && isHttpUrl(hit.cdnUrl)) {
+        return { ...common, resolved: true, url: hit.cdnUrl, source: 'yida-attachment', reason: 'OK', deliveryPolicy };
+      }
+      return { ...common, resolved: false, url: raw, source: 'external', reason: ((results || [])[0] || {}).error || 'UPLOAD_FAILED' };
+    } catch (error) {
+      if (error.message === 'ASSET_TOO_LARGE') {return original(error.metadata || {});}
+      return { ...common, resolved: false, url: raw, source: 'external', reason: error.code || error.message || 'UPLOAD_FAILED' };
+    } finally {
+      if (tempPath) {
+        fs.rmSync(tempPath, { force: true });
+        if (!ctx.downloadFn) {fs.rmSync(path.dirname(tempPath), { recursive: true, force: true });}
+      }
+    }
   }
 
-  // 本地文件：需要 CDN 才能转存为浏览器可访问的稳定 URL
   if (isLocalFile(raw)) {
-    if (!ctx.canUpload) {
+    const assetSource = ASSET_SOURCES.includes(ctx.assetSource) ? ctx.assetSource : '';
+    const provider = String(ctx.provider || '').trim().toLowerCase();
+    if (assetSource === 'search' && !ALLOWED_STOCK_IMAGE_PROVIDERS[provider]) {
       return {
         resolved: false,
         url: raw,
         source: 'local',
-        reason: 'LOCAL_NO_CDN',
+        reason: 'STOCK_PROVIDER_NOT_ALLOWED',
+        provider: provider || null,
+        allowedProviders: Object.keys(ALLOWED_STOCK_IMAGE_PROVIDERS),
       };
     }
+    const metadata = readImageMetadata(raw);
+    const failure = sizeFailure(metadata, ctx);
+    if (failure) {
+      return { ...metadata, resolved: false, url: raw, source: 'local', reason: failure };
+    }
+    if (ctx.online === false) {
+      return { ...metadata, resolved: false, url: raw, source: 'local', reason: 'OFFLINE_UPLOAD_BLOCKED' };
+    }
+    if (fs.statSync(raw).size > MAX_IMAGE_BYTES) {return { ...metadata, resolved: false, url: '', source: 'local', reason: 'ASSET_TOO_LARGE_NO_ORIGINAL_URL' };}
+    metadata.contentHash = fileHash(raw);
+    const reused = await reuseDelivery(raw, metadata, ctx);
+    if (reused) {return reused;}
+    if (!ctx.canUpload) {
+      return { ...metadata, resolved: false, url: raw, source: 'local', reason: 'YIDA_ATTACHMENT_UNAVAILABLE' };
+    }
     try {
       const results = await ctx.uploadFn([raw]);
-      const hit = (results || []).find((r) => r.success && r.originalPath === raw) ||
-        (results || []).find((r) => r.success);
-      if (hit && hit.cdnUrl) {
-        return { resolved: true, url: hit.cdnUrl, source: 'cdn', reason: 'OK' };
+      const hit = (results || []).find(result => result.success && result.originalPath === raw)
+        || (results || []).find(result => result.success);
+      if (hit && isHttpUrl(hit.cdnUrl)) {
+        return { ...metadata, resolved: true, url: hit.cdnUrl, source: 'yida-attachment', reason: 'OK' };
       }
-      const failed = (results || [])[0];
-      return {
-        resolved: false,
-        url: raw,
-        source: 'local',
-        reason: (failed && failed.error) || 'UPLOAD_FAILED',
-      };
-    } catch (err) {
-      return { resolved: false, url: raw, source: 'local', reason: (err && err.message) || 'UPLOAD_ERROR' };
+      return { ...metadata, resolved: false, url: raw, source: 'local', reason: ((results || [])[0] || {}).error || 'UPLOAD_FAILED' };
+    } catch (error) {
+      return { ...metadata, resolved: false, url: raw, source: 'local', reason: error.code || error.message || 'UPLOAD_FAILED' };
     }
   }
 
-  // 既不是外链也不是磁盘文件 → 视为未落地的占位引用
   return { resolved: false, url: raw, source: 'unknown', reason: 'NOT_FOUND' };
 }
 
-/**
- * 解析并回填一组素材
- * @param {object} assets { heroImage, heroImageAlt, productImages, materialStrategy }
- * @param {object} [options]
- * @param {boolean} [options.requireHero] 页面是否必须有 Hero 图（官网/落地页通常 true）
- * @param {boolean} [options.online] 是否可联网处理外链（默认 true）
- * @param {number}  [options.timeout] 单个外链处理超时
- * @param {function} [options.uploadFn] 自定义上传函数（默认懒加载 cdn-upload.performUpload）
- * @returns {Promise<{
- *   assets: object,
- *   materialStatus: 'final'|'draft'|'none',
- *   materialGaps: string[],
- *   strategy: string,
- *   actions: Array,
- *   status: object
- * }>}
- */
-async function resolveAssets(assets = {}, options = {}) {
-  const online = options.online !== false;
-  const requireHero = !!options.requireHero;
-  const status = getAssetStatus({ online });
-  const hasInjectedUpload = typeof options.uploadFn === 'function';
-
-  const ctx = {
-    canUpload: status.canUpload || hasInjectedUpload,
-    online,
-    mirrorExternal: !!options.mirrorExternal,
-    timeout: options.timeout,
-    verifyFn: options.verifyFn,
-    downloadFn: options.downloadFn,
-    uploadFn:
-      options.uploadFn ||
-      ((files) => {
-        // 懒加载，避免无 CDN 场景加载 ali-oss
-        const { performUpload } = require('../cdn/cdn-upload');
-        return performUpload({ files });
-      }),
-  };
-
-  const inputHero = assets.heroImage || '';
-  const inputProducts = Array.isArray(assets.productImages) ? assets.productImages : [];
-
-  const actions = [];
-  const materialGaps = [];
-
-  // Hero
-  let heroUrl = '';
-  if (inputHero) {
-    const r = await resolveOne(inputHero, ctx);
-    actions.push({ slot: 'heroImage', input: inputHero, ...r });
-    if (r.resolved) {
-      heroUrl = r.url;
-    } else {
-      materialGaps.push(`Hero 图未落地（${r.reason}）：${inputHero}`);
-    }
-  } else if (requireHero) {
-    materialGaps.push('缺少 Hero 图：官网/落地页应提供一张品牌主视觉大图。');
-  }
+function normalizeSource(source, fallback) {
+  return ASSET_SOURCES.includes(source) ? source : fallback;
+}
 
-  // 产品/场景图
-  const productUrls = [];
-  for (let i = 0; i < inputProducts.length; i++) {
-    const item = inputProducts[i];
-    const r = await resolveOne(item, ctx);
-    actions.push({ slot: `productImages[${i}]`, input: item, ...r });
-    if (r.resolved) {
-      productUrls.push(r.url);
-    } else {
-      materialGaps.push(`产品图 #${i + 1} 未落地（${r.reason}）：${item}`);
+function metadataGaps(asset) {
+  const missing = [];
+  ['slotId', 'usage', 'alt'].forEach((field) => {
+    if (typeof asset[field] !== 'string' || !asset[field].trim()) {missing.push(field);}
+  });
+  if (![asset.width, asset.height].every(value => Number.isFinite(value) && value > 0)) {missing.push('width/height');}
+  if (asset.source === 'search') {
+    ['provider', 'sourcePage', 'creator', 'license', 'attribution'].forEach((field) => {
+      if (typeof asset[field] !== 'string' || !asset[field].trim()) {missing.push(field);}
+    });
+    if (asset.provider === 'unsplash') {
+      if (!asset.downloadLocation) {missing.push('downloadLocation');}
+      if (asset.downloadTracked !== true) {missing.push('downloadTracked');}
     }
   }
+  return missing;
+}
 
-  // 计算 materialStatus
-  const resolvedCount = (heroUrl ? 1 : 0) + productUrls.length;
-  let materialStatus;
-  if (materialGaps.length === 0) {
-    // 没有缺口：要么素材齐全，要么本就不需要图片
-    materialStatus = 'final';
-  } else if (resolvedCount > 0) {
-    // 有部分素材落地，但仍有缺口 → 草稿
-    materialStatus = 'draft';
-  } else if (requireHero) {
-    // 需要图片却一张都没落地 → 低保真
-    materialStatus = 'none';
-  } else {
-    materialStatus = 'draft';
-  }
+async function resolveAssets(assets = [], options = {}) {
+  const plan = prepareAssetPlan(assets, options.assetStrategy);
+  const entries = plan.entries;
+  const online = options.online !== false;
+  const status = options.status || getAssetStatus({ online, env: options.env, runtime: options.runtime });
+  const canUpload = online;
+  const defaultSource = normalizeSource(options.assetSource, 'search');
+  const uploadFn = options.uploadFn || (files => uploadAttachment(files, options));
 
-  // strategy：以实际落地来源反推，优先反映真实能力
-  let strategy = status.recommendedStrategy;
-  if (materialStatus === 'none') {
-    strategy = STRATEGY.LOW_FIDELITY;
-  }
+  const actions = await Promise.all(entries.map(async (asset, index) => {
+    const declaredSource = String(asset.source || '').trim();
+    const source = declaredSource || defaultSource;
+    const input = String(asset.input || asset.localPath || asset.url || '').trim();
+    const size = minimumSize(asset);
+    if (!ASSET_SOURCES.includes(source) || (source === 'generated' && asset.generationAllowed === false)) {
+      return {
+        index,
+        asset,
+        input,
+        source,
+        result: { resolved: false, url: input, source: 'unknown', reason: !ASSET_SOURCES.includes(source) ? 'INVALID_SOURCE' : 'GENERATION_NOT_ALLOWED' },
+      };
+    }
+    let result;
+    try {
+      result = await resolveOne(input, {
+        previous: asset,
+        assetSource: source,
+        provider: asset.provider,
+        online,
+        canUpload,
+        timeout: options.timeout,
+        downloadFn: options.downloadFn,
+        uploadFn,
+        ...size,
+      });
+    } catch (error) {
+      result = { resolved: false, url: input, reason: error.code || 'ASSET_READ_FAILED' };
+    }
+    return { index, asset, input, source, result };
+  }));
 
-  const resolvedAssets = {
-    heroImage: heroUrl,
-    heroImageAlt: assets.heroImageAlt || '',
-    productImages: productUrls,
-    materialStrategy: strategy,
-  };
+  const outputAssets = [];
+  const gaps = [];
+  actions.forEach(({ asset, input, source, result }, index) => {
+    const slotId = String(asset.slotId || '').trim();
+    const provider = result.provider || asset.provider || '';
+    const output = {
+      slotId,
+      pageId: asset.pageId || '',
+      input,
+      ...minimumSize(asset),
+      ...(asset.minSize !== undefined ? { minSize: asset.minSize } : {}),
+      usage: asset.usage || '',
+      required: asset.required !== false,
+      url: result.resolved ? result.url : '',
+      localPath: isLocalFile(input) ? input : '',
+      source,
+      provider,
+      sourcePage: asset.sourcePage || '',
+      creator: asset.creator || '',
+      license: asset.license || '',
+      attribution: asset.attribution || '',
+      downloadLocation: asset.downloadLocation || '',
+      downloadTracked: asset.downloadTracked === true,
+      width: result.width || 0,
+      height: result.height || 0,
+      imageType: result.imageType || result.type || '',
+      ...(result.resolved ? { delivery: { source: result.source, input, assetSource: source, contentHash: result.contentHash || '', reason: result.reason } } : {}),
+      alt: asset.alt || '',
+      isIllustrative: asset.isIllustrative === true || source === 'generated',
+    };
+    output.materialStatus = 'draft';
+    output.gaps = [];
+    outputAssets.push(output);
+    if (!result.resolved) {
+      output.gaps.push({
+        slotId: slotId || `slot-${index + 1}`,
+        pageId: output.pageId,
+        code: result.reason,
+        message: `图片未落地：${result.reason}`,
+      });
+      gaps.push(...output.gaps.map(gap => ({ ...gap })));
+      return;
+    }
+    const missing = metadataGaps(output);
+    if (missing.length > 0) {
+      output.gaps.push({
+        slotId: slotId || `slot-${index + 1}`,
+        pageId: output.pageId,
+        code: 'MISSING_METADATA',
+        message: `缺少字段：${missing.join(', ')}`,
+      });
+    }
+    output.materialStatus = output.gaps.length ? 'draft' : 'final';
+    gaps.push(...output.gaps.map(gap => ({ ...gap })));
+  });
 
+  const pages = plan.pages.map(page => {
+    const pageAssets = outputAssets.filter(asset => asset.pageId === page.pageId);
+    const pageGaps = gaps.filter(gap => gap.pageId === page.pageId).map(gap => ({ ...gap }));
+    if (page.imageNeed === 'required' && page.slotIds.length === 0) {
+      const gap = { pageId: page.pageId, code: 'MISSING_PAGE_SLOTS', message: 'MISSING_PAGE_SLOTS' };
+      pageGaps.push(gap);
+      gaps.push({ ...gap });
+    }
+    const blocked = pageGaps.some(gap => !gap.slotId || pageAssets.some(asset => asset.slotId === gap.slotId && asset.required));
+    return { ...page, materialStatus: blocked ? 'draft' : pageAssets.length ? 'final' : 'none', gaps: pageGaps };
+  });
+  const materialStatus = gaps.length ? 'draft' : entries.length ? 'final' : 'none';
   return {
-    assets: resolvedAssets,
+    schemaVersion: 2,
     materialStatus,
-    materialGaps,
-    strategy,
-    actions,
-    status,
+    ...(plan.assetStrategy !== undefined ? { assetStrategy: plan.assetStrategy } : {}),
+    pages,
+    capabilityEvidence: {
+      host: status.hostCapabilities,
+      cdnConfigured: status.cdnConfigured,
+      uploadTarget: 'yida-attachment',
+      maxUploadBytes: MAX_IMAGE_BYTES,
+      online,
+    },
+    assets: outputAssets,
+    gaps,
   };
 }
 
@@ -302,4 +415,9 @@ module.exports = {
   resolveOne,
   isHttpUrl,
   isLocalFile,
+  getExternalDeliveryPolicy,
+  getCollectedImageProvider,
+  ALLOWED_STOCK_IMAGE_PROVIDERS,
+  ASSET_SOURCES,
+  downloadUrlToTemp,
 };