e10-ebuilder-prototype 0.5.2 → 0.5.4

package/README.md

@@ -1,7 +1,7 @@
 # e10-ebuilder-prototype
 
 根据 E10 **应用 ID 或后台应用地址生成应用原型，包含已发布菜单中的页面、建模列表和流程页面**。
-当前版本 0.5.2。保持我们的 TypeScript CLI 为主：CLI 管登录、菜单发现、配置采集、截图、任务队列、校验、恢复与打包；宿主 AI 根据完整截图或建模配置生成独立 HTML。CLI 不调用 LLM，不要求额外模型 API Key，也不调用 ui-code-agent 生成。
+版本 0.5.4，默认并发 6。保持我们的 TypeScript CLI 为主：CLI 管登录、菜单发现、配置采集、截图、任务队列、校验、恢复与打包；宿主 AI 根据完整截图或建模配置生成独立 HTML。CLI 不调用 LLM，不要求额外模型 API Key，也不调用 ui-code-agent 生成。
 
 ## 范围与交付
 
@@ -31,7 +31,7 @@ ZIP 名为 `应用页面-<appId>.zip`，位于任务目录 artifacts/；本地
 需要 Node >=22.5、npm 和已安装 Google Chrome，playwright-core 固定 1.62.1，不下载浏览器。
 
 ```sh
-npm install -g e10-ebuilder-prototype@0.5.2 --registry=https://registry.npmjs.org/
+npm install -g e10-ebuilder-prototype@0.5.4 --registry=https://registry.npmjs.org/
 e10-ebuilder-prototype auth set --base-url https://your-e10.example.com --eteamsid-stdin
 e10-ebuilder-prototype run --app-id 1234567890123456789 --dir ./work/app-demo --json
 # 或使用后台应用地址：
@@ -45,14 +45,15 @@ e10-ebuilder-prototype run --app-url "https://your-e10.example.com/sp/ebdapp/det
 `run` 完成确定性工作后停在 HTML，由宿主继续：
 
 ```sh
-e10-ebuilder-prototype html next --dir ./work/app-demo --json
-# 宿主按 jobs 的 prompt 写入各自 outputPath，并做视觉/交互检查
-e10-ebuilder-prototype html accept --dir ./work/app-demo --kind page --page-id "<ID>" --token "<TOKEN>" --json
+e10-ebuilder-prototype html next --dir ./work/app-demo --brief --json
+# 宿主读取各 job 的 promptPath，写完整草稿；CLI 离线渲染后实际看图
+e10-ebuilder-prototype html inspect --dir ./work/app-demo --kind page --page-id "<ID>" --token "<TOKEN>" --json
+e10-ebuilder-prototype html accept --dir ./work/app-demo --kind page --page-id "<ID>" --token "<TOKEN>" --refill --brief --json
 e10-ebuilder-prototype html accept --dir ./work/app-demo --kind form --page-id "<菜单键>" --token "<TOKEN>" --json
 e10-ebuilder-prototype pack --dir ./work/app-demo --json
 ```
 
-同一个生成队列最多 4 个任务，可按用户需求 --concurrency 1..8。page 输入 screenshotPath；form 输入 sourcePath，附带 contextPath 分片索引、guidePath 完整规范、runtimePath 固定存储脚本及 navigationPath 已发布目标映射。一个协调者串行 accept/fail/next，任务只写自己的草稿；宿主支持且允许并行时补位执行，否则如实采用顺序生成。
+同一个生成队列默认最多 6 个任务，可按用户需求 --concurrency 1..8。page 输入 screenshotPath；form 输入 sourcePath，附带 contextPath 分片索引、guidePath 完整规范、runtimePath 固定存储脚本及 navigationPath 已发布目标映射。一个协调者串行 accept/fail/next，任务只写自己的草稿；宿主支持且允许并行时补位执行，否则如实采用顺序生成。
 
 生成文件为真实 DOM、内联 CSS/JS/SVG，无外部资源或后台调用。页面忠实还原视觉结构，空数据用一致 Mock 内容填充。表单按当前模式/字段/选项/按钮及布局依据生成，固定种子约 20 条主记录、明细每条 2–5 行；所有统计由数据推导。完整规范随 CLI 打包，不能用“能打开表格”代替验收。
 
@@ -91,7 +92,7 @@ isIndependentDeploy 请求失败时，默认按非独立部署继续采集，并
 
 ## 截图和资源限制
 
-PC 默认 1440×900，MOBILE-only 页面 390×844；默认并发 4。页面初始渲染上限 10 秒、稳定窗口 800ms；超时本轮失败，其他可恢复失败额外重试一次。就绪后立即继续，不固定睡眠。
+PC 默认 1440×900，MOBILE-only 页面 390×844；默认并发 6。页面初始渲染上限 10 秒、稳定窗口 800ms；超时本轮失败，其他可恢复失败额外重试一次。就绪后立即继续，不固定睡眠。
 只用页面组件请求、可见加载、字体/图片、主体内容与稳定性判断；全局后台请求不阻塞。随后滚动检查、编码和清理另有边界，详见协议。
 
 截图覆盖当前已加载/可滚动内容，不自动点击标签或分页。承载 EB 主体的 iframe 完整滚动展开，普通内嵌网站保留设计视口。稳定业务错误可原样截图并带 warning，未知空白、超时、身份失效、内容丢失仍失败。源站错误截图不等于业务功能健康。
@@ -121,3 +122,16 @@ Windows 使用原生 Node，无需 Bash/WSL/Python；支持 WorkBuddy 内置 npm
 流程列表的列、标签、筛选和按钮来自内置固定原型模板；目录接口提供真实流程名称和关联表单，不读取真实流程实例/审批权限。宿主按 CLI 的 workflow-guide 生成右侧页面，固定 E10WorkflowStore 负责本地已读、批量提交、草稿续填、收藏/关注、实例评论以及关联记录联合保存。所有流程动作仅修改本地模拟数据。流程仍使用 kind=form 队列和 form/<菜单键>/ 交付路径，job.workflowType 区分流程类别。
 
 完整流程协议见 [PROTOCOL.md](docs/PROTOCOL.md)。
+
+## WorkBuddy 生成效率（0.5.4）
+
+首次 status 未就绪时仅提示“首次使用需要初始化工作环境，大概需要几分钟，完成后自动继续。”
+ensure 保留后台进度与耗时，成功后自动继续，后续正常使用不再提示初始化或依赖名称。不要给 CLI 命令附加 tail 或吞掉退出码。
+
+页面先看完整原图再写完整首版，不要求逐像素测量。html inspect 统一生成离线校对截图，
+相同源码与完整截图可复用；宿主实际看图并集中修正，最多两轮视觉微调。业务缺项或运行错误仍需处理。
+
+WorkBuddy 子任务显式使用主任务当前实际模型，保留可继承的思考配置，不写死某个模型。
+后台生成完成一个接收一个，accept/fail --refill --brief 同时返回新任务；promptPath 将页面细节
+留在对应子任务。连接失败确认旧写者已退出后恢复一次，已有草稿可继续；持续失败明确报告。
+并发额度不是实际活跃数，也不保证线性提速，结论以同输入同模型的实际验收计时为准。

package/dist/archive.d.ts

@@ -54,9 +54,9 @@ export declare function pack(store: Store, s: TaskState): Promise<{
             sha256: string | undefined;
             bytes: number | undefined;
             file: string | undefined;
-            status: "running" | "succeeded" | "failed";
+            status: "running" | "succeeded" | "failed" | "pending";
             sourceSha256: string;
-            promptVersion: 1 | 2 | 4 | 3 | 5;
+            promptVersion: 1 | 2 | 6 | 3 | 4 | 5 | 7 | 8 | 9;
             startedAt: string;
             finishedAt: string | undefined;
             error: {

package/dist/common.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.5.2";
+export declare const VERSION = "0.5.4";
 export declare class CaptureError extends Error {
     code: string;
     details?: unknown | undefined;

package/dist/common.js

@@ -3,7 +3,7 @@ import { renameWithRetry } from './runtime-support.mjs';
 import { createReadStream } from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
-export const VERSION = '0.5.2';
+export const VERSION = '0.5.4';
 export class CaptureError extends Error {
     code;
     details;

package/dist/form-context.d.ts

@@ -1,3 +1,3 @@
 import type { Store } from './store.js';
-/** Generated source views are disposable; regenerate from the verified canonical input on resume. */
+/** Bounded, lossless views. Fixed metadata is grouped, never reinterpreted or discarded. */
 export declare function formContext(store: Store, key: string): Promise<string>;

package/dist/form-context.js

@@ -1,10 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { fileDigest } from './common.js';
+import { digest, fileDigest, CaptureError } from './common.js';
+import { formOptionData } from './form-options.js';
 import { formInputPath } from './forms.js';
 import { navigationKey } from './menus.js';
+const limit = 18000;
+const lineLimit = 1800; // WorkBuddy Read truncates long individual lines, not only large files.
 function* parts(value, location) {
-    if (JSON.stringify(value).length <= 18000) {
+    if (JSON.stringify(location).length > lineLimit - 96)
+        throw new CaptureError('FORM_CONTEXT_LIMIT', '配置属性路径超过宿主可完整读取的单行长度');
+    const encoded = JSON.stringify({ entries: [{ location, value }] }, null, 2);
+    if (encoded.length <= limit && encoded.split('\n').every((line) => line.length <= lineLimit)) {
         yield { location, value };
         return;
     }
@@ -17,34 +23,76 @@ function* parts(value, location) {
             yield* parts(item, `${location}.${key}`);
     }
     else if (typeof value === 'string') {
-        for (let offset = 0; offset < value.length; offset += 6000)
+        for (let offset = 0; offset < value.length;) {
+            let low = offset + 1, high = Math.min(value.length, offset + lineLimit - 32);
+            while (low < high) {
+                const middle = Math.ceil((low + high) / 2);
+                if (JSON.stringify(value.slice(offset, middle)).length <= lineLimit - 32)
+                    low = middle;
+                else
+                    high = middle - 1;
+            }
+            let end = low;
+            if (end < value.length && /[\uD800-\uDBFF]/.test(value[end - 1]))
+                end--;
             yield {
-                location: `${location} (characters ${offset}:${Math.min(value.length, offset + 6000)})`,
-                value: value.slice(offset, offset + 6000),
+                location: `${location} (characters ${offset}:${end})`,
+                value: value.slice(offset, end),
             };
+            offset = end;
+        }
     }
     else
         yield { location, value };
 }
-/** Generated source views are disposable; regenerate from the verified canonical input on resume. */
+/** Bounded, lossless views. Fixed metadata is grouped, never reinterpreted or discarded. */
 export async function formContext(store, key) {
-    const source = formInputPath(store, key), input = JSON.parse(await fs.readFile(source, 'utf8'));
-    const folder = path.join(store.meta, 'form-context', navigationKey(key), await fileDigest(source));
+    const source = formInputPath(store, key), sourceSha256 = await fileDigest(source);
+    const folder = path.join(store.meta, 'form-context', navigationKey(key), sourceSha256);
+    const indexPath = path.join(folder, 'index.json');
+    const previous = await fs
+        .readFile(indexPath, 'utf8')
+        .then(JSON.parse)
+        .catch(() => null);
+    if (previous?.schema === 4 &&
+        previous.sourceSha256 === sourceSha256 &&
+        Array.isArray(previous.fragments)) {
+        const valid = await Promise.all(previous.fragments.map(async (part) => typeof part.path === 'string' &&
+            path.basename(part.path) === part.path &&
+            (await fileDigest(path.join(folder, part.path)).catch(() => '')) === part.sha256));
+        if (valid.length && valid.every(Boolean))
+            return indexPath;
+    }
+    const input = JSON.parse(await fs.readFile(source, 'utf8'));
+    const options = formOptionData(input);
     await fs.mkdir(folder, { recursive: true });
-    const index = [];
-    for (const [category, value] of Object.entries(input)) {
-        let i = 0;
+    const fragments = [];
+    let batch = [];
+    const flush = async () => {
+        if (!batch.length)
+            return;
+        const filename = `context-${fragments.length + 1}.json`;
+        const bytes = JSON.stringify({ entries: batch }, null, 2);
+        await fs.writeFile(path.join(folder, filename), bytes, { mode: 0o600 });
+        fragments.push({
+            path: filename,
+            locations: batch.map((part) => part.location),
+            sha256: digest(bytes),
+        });
+        batch = [];
+    };
+    for (const [category, value] of Object.entries(options.context)) {
         for (const part of parts(value, category)) {
-            const filename = `${category.replace(/[^a-zA-Z0-9_-]/g, '_')}-${++i}.json`;
-            await fs.writeFile(path.join(folder, filename), JSON.stringify(part, null, 2), {
-                mode: 0o600,
-            });
-            index.push({ path: filename, location: part.location });
+            if (batch.length && JSON.stringify({ entries: [...batch, part] }, null, 2).length > limit)
+                await flush();
+            batch.push(part);
         }
     }
-    const indexPath = path.join(folder, 'index.json');
+    await flush();
     await fs.writeFile(indexPath, JSON.stringify({
+        schema: 4,
         source,
+        sourceSha256,
         appId: input.appId,
         objId: input.objId,
         menu: input.page,
@@ -52,7 +100,9 @@ export async function formContext(store, key) {
         customFieldCount: input.fields?.filter((f) => !f.system).length,
         layoutSource: input.layout?.source,
         warnings: input.warnings,
-        fragments: index,
+        optionDatasets: options.descriptions,
+        format: 'Each fragment contains entries [{location,value}]; read each fragment once. Long strings use character ranges and concatenate in order. A {$e10Options:id,count,sample} replaces a large options array: call E10FormOptions.get(id) in the generated HTML to retrieve the complete original array. sample describes shape only; never use it as the full choices. CLI injects all dataset values during inspect/accept. Original input retains every property; host-readable lines are bounded.',
+        fragments,
     }, null, 2), { mode: 0o600 });
     return indexPath;
 }

package/dist/form-options.d.ts

@@ -0,0 +1,12 @@
+/** Large static choice catalogs travel as data, never as model-authored business code. */
+export declare function formOptionData(input: any): {
+    context: any;
+    datasets: Record<string, any[]>;
+    descriptions: {
+        id: string;
+        count: number;
+        locations: string[];
+    }[];
+};
+export declare function formOptionsRuntime(datasets: Record<string, any[]>): string;
+export declare function attachFormOptions(source: string, datasets: Record<string, any[]>): string;

package/dist/form-options.js

@@ -0,0 +1,54 @@
+import { digest } from './common.js';
+/** Large static choice catalogs travel as data, never as model-authored business code. */
+export function formOptionData(input) {
+    const datasets = Object.create(null);
+    const descriptions = new Map();
+    const sample = (value, depth = 0) => {
+        if (Array.isArray(value))
+            return depth >= 2
+                ? `[${value.length} items]`
+                : value.slice(0, 2).map((v) => sample(v, depth + 1));
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, sample(v, depth + 1)]));
+        return typeof value === 'string' && value.length > 160 ? value.slice(0, 160) + '…' : value;
+    };
+    const visit = (value, location, key = '') => {
+        if (key === 'options' && Array.isArray(value) && JSON.stringify(value).length > 8000) {
+            const id = digest(JSON.stringify(value));
+            datasets[id] = value;
+            if (!descriptions.has(id))
+                descriptions.set(id, { id, count: value.length, locations: [] });
+            descriptions.get(id).locations.push(location);
+            return { $e10Options: id, count: value.length, sample: sample(value) };
+        }
+        if (Array.isArray(value))
+            return value.map((v, i) => visit(v, `${location}[${i}]`));
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, visit(v, location ? `${location}.${k}` : k, k)]));
+        return value;
+    };
+    return { context: visit(input, ''), datasets, descriptions: [...descriptions.values()] };
+}
+function installOptions(datasets) {
+    Object.defineProperty(window, 'E10FormOptions', {
+        value: Object.freeze({
+            get: (id) => {
+                if (!Object.prototype.hasOwnProperty.call(datasets, id))
+                    throw new Error('本菜单没有对应的选项数据集');
+                return JSON.parse(JSON.stringify(datasets[id]));
+            },
+        }),
+        configurable: true,
+    });
+}
+export function formOptionsRuntime(datasets) {
+    const json = JSON.stringify(JSON.stringify(datasets))
+        .replaceAll('<', '\\u003c')
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+    return `<script id="e10-form-options">(${installOptions.toString()})(JSON.parse(${json}));</script>`;
+}
+export function attachFormOptions(source, datasets) {
+    const clean = source.replace(/<script\b[^>]*\bid\s*=\s*["']e10-form-options["'][^>]*>[\s\S]*?<\/script\s*>/gi, '');
+    return clean.replace(/<head(?:\s[^>]*)?>/i, (match) => match + formOptionsRuntime(datasets));
+}

package/dist/html-handoff.d.ts

@@ -0,0 +1,25 @@
+import type { TaskState } from './model.js';
+import type { Store } from './store.js';
+/** The worker attests its review; this is not an independent visual quality score. */
+export declare function readyHtml(store: Store, state: TaskState, pageId: string, token: string, kind: 'page' | 'form', summary: string): Promise<{
+    ok: boolean;
+    kind: "page" | "form";
+    pageId: string;
+    receiptPath: string;
+    next: string;
+    frozen: boolean;
+}>;
+/** Called only by the coordinator under the queue lock. Each acceptance is durable. */
+export declare function acceptReadyHtml(store: Store, state: TaskState): Promise<{
+    accepted: {
+        kind: "page" | "form";
+        pageId: string;
+        summary: any;
+    }[];
+    rejected: {
+        kind: "page" | "form";
+        pageId: string;
+        code: string;
+        message: string;
+    }[];
+}>;

package/dist/html-handoff.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { atomicJson, CaptureError, digest, fileDigest } from './common.js';
+import { prepareHtml, acceptHtml, draftPath } from './html.js';
+async function evidence(store, state, pageId, token, kind) {
+    const prepared = await prepareHtml(store, state, pageId, token, kind);
+    if (prepared.r.status !== 'running')
+        throw new CaptureError('HTML_JOB_NOT_RUNNING', '只可提交当前运行中的草稿');
+    const directory = path.join(path.dirname(prepared.draft), 'review');
+    const sourceSha256 = digest(prepared.bytes);
+    const widths = kind === 'form' ? [1440, 390] : [prepared.png.width];
+    const inspections = [];
+    for (const width of widths) {
+        const filename = path.join(directory, `inspection-${width}.json`);
+        const receipt = await fs
+            .readFile(filename, 'utf8')
+            .then(JSON.parse)
+            .catch(() => null);
+        if (!receipt?.ok ||
+            receipt.sourceSha256 !== sourceSha256 ||
+            receipt.viewport?.width !== width ||
+            !receipt.screenshots?.length)
+            throw new CaptureError('HTML_REVIEW_REQUIRED', `需要当前草稿 ${width}px 校对成功并实际看图`);
+        for (const image of receipt.screenshots) {
+            if (typeof image.path !== 'string' ||
+                path.dirname(image.path) !== directory ||
+                (await fileDigest(image.path).catch(() => '')) !== image.sha256)
+                throw new CaptureError('HTML_REVIEW_REQUIRED', '校对截图已变化，需要重新校对');
+        }
+        inspections.push({ width, sha256: await fileDigest(filename) });
+    }
+    return { directory, sourceSha256, inspections };
+}
+/** The worker attests its review; this is not an independent visual quality score. */
+export async function readyHtml(store, state, pageId, token, kind, summary) {
+    if (!summary?.trim() || summary.length > 4000)
+        throw new CaptureError('ARGUMENT_INVALID', 'summary 需为已实际检查和剩余差异的简短说明（1..4000字符）');
+    const proof = await evidence(store, state, pageId, token, kind);
+    const receiptPath = path.join(proof.directory, 'host-review.json');
+    await atomicJson(receiptPath, {
+        schema: 1,
+        kind,
+        pageId,
+        token,
+        sourceSha256: proof.sourceSha256,
+        inspections: proof.inspections,
+        summary: summary.trim(),
+        reviewedAt: new Date().toISOString(),
+    });
+    return { ok: true, kind, pageId, receiptPath, next: 'notify-coordinator', frozen: true };
+}
+/** Called only by the coordinator under the queue lock. Each acceptance is durable. */
+export async function acceptReadyHtml(store, state) {
+    const status = await store.status(state);
+    const accepted = [], rejected = [];
+    for (const result of [...status.htmlResults, ...status.formHtmlResults]) {
+        if (result?.status !== 'running')
+            continue;
+        const kind = result.kind || 'page';
+        const receiptPath = path.join(path.dirname(draftPath(store, result)), 'review', 'host-review.json');
+        const receipt = await fs
+            .readFile(receiptPath, 'utf8')
+            .then(JSON.parse)
+            .catch(() => null);
+        if (!receipt)
+            continue;
+        try {
+            const proof = await evidence(store, state, result.id, result.token, kind);
+            if (receipt.schema !== 1 ||
+                receipt.token !== result.token ||
+                receipt.pageId !== result.id ||
+                receipt.kind !== kind ||
+                receipt.sourceSha256 !== proof.sourceSha256 ||
+                JSON.stringify(receipt.inspections) !== JSON.stringify(proof.inspections) ||
+                typeof receipt.summary !== 'string' ||
+                !receipt.summary.trim() ||
+                receipt.summary.length > 4000)
+                throw new CaptureError('HTML_REVIEW_STALE', '完成回执与当前草稿/校对不一致');
+            await acceptHtml(store, state, result.id, result.token, kind, proof.sourceSha256);
+            accepted.push({ kind, pageId: result.id, summary: receipt.summary });
+        }
+        catch (error) {
+            if (!(error instanceof CaptureError))
+                throw error;
+            rejected.push({ kind, pageId: result.id, code: error.code, message: error.message });
+        }
+    }
+    return { accepted, rejected };
+}

package/dist/html-inspect.d.ts

@@ -0,0 +1,4 @@
+import type { Store } from './store.js';
+import type { TaskState } from './model.js';
+/** Deterministic local rendering, never a visual similarity assertion or model call. */
+export declare function inspectHtml(store: Store, state: TaskState, pageId: string, token: string, kind?: 'page' | 'form', width?: number): Promise<any>;

package/dist/html-inspect.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { bounded, CaptureError, digest, fileDigest, atomicJson } from './common.js';
+import { launchChrome } from './capture.js';
+import { prepareHtml } from './html.js';
+/** Deterministic local rendering, never a visual similarity assertion or model call. */
+export async function inspectHtml(store, state, pageId, token, kind = 'page', width) {
+    const prepared = await prepareHtml(store, state, pageId, token, kind);
+    const viewport = {
+        width: width ?? (kind === 'page' ? prepared.png.width : 1440),
+        height: 900,
+    };
+    if (!Number.isInteger(viewport.width) || viewport.width < 320 || viewport.width > 3840)
+        throw new CaptureError('ARGUMENT_INVALID', '校对宽度范围 320..3840');
+    const directory = path.join(path.dirname(prepared.draft), 'review');
+    await fs.mkdir(directory, { recursive: true });
+    const receiptPath = path.join(directory, `inspection-${viewport.width}.json`);
+    const sourceSha256 = digest(prepared.bytes);
+    const key = digest(JSON.stringify({ version: 3, sourceSha256, input: prepared.png.sha256, viewport }));
+    const old = await fs
+        .readFile(receiptPath, 'utf8')
+        .then(JSON.parse)
+        .catch(() => null);
+    if (old?.ok && old.key === key && Array.isArray(old.screenshots)) {
+        const valid = await Promise.all(old.screenshots.map(async (image) => path.dirname(image.path) === directory &&
+            (await fileDigest(image.path).catch(() => '')) === image.sha256));
+        if (valid.length && valid.every(Boolean))
+            return { ...old, reused: true, receiptPath };
+    }
+    const started = Date.now();
+    const errors = new Set();
+    const runtimeErrors = [];
+    const runtimeErrorDetails = [];
+    const screenshots = [];
+    const previewPath = path.join(directory, 'preview.html');
+    await fs.writeFile(previewPath, prepared.bytes, { mode: 0o600 });
+    const previewUrl = pathToFileURL(previewPath).href;
+    const sourceLines = prepared.bytes.toString('utf8').split(/\r?\n/);
+    const chrome = await launchChrome();
+    try {
+        const context = await chrome.browser.newContext({
+            viewport,
+            offline: true,
+            serviceWorkers: 'block',
+        });
+        try {
+            await context.route('**/*', async (route) => {
+                if (route.request().url() === previewUrl || /^(data:|about:)/.test(route.request().url()))
+                    await route.continue();
+                else {
+                    errors.add('页面尝试访问外部或旁路资源');
+                    await route.abort();
+                }
+            });
+            const page = await context.newPage();
+            try {
+                // Capture browser source locations, including parse errors without a JS stack.
+                await page.addInitScript(() => {
+                    ;
+                    window.__E10_INSPECTION_ERRORS__ = [];
+                    addEventListener('error', (event) => {
+                        const errors = window.__E10_INSPECTION_ERRORS__;
+                        if (errors.length < 10 && event.message)
+                            errors.push({
+                                message: event.message.slice(0, 500),
+                                url: event.filename,
+                                line: event.lineno,
+                                column: event.colno,
+                            });
+                    });
+                });
+                page.on('pageerror', (error) => {
+                    errors.add('页面存在 JavaScript 运行错误');
+                    if (runtimeErrors.length < 10)
+                        runtimeErrors.push(`${error.name}: ${error.message}`.slice(0, 500));
+                });
+                page.on('websocket', () => errors.add('页面尝试建立网络连接'));
+                await bounded((async () => {
+                    await page.goto(previewUrl, { waitUntil: 'load', timeout: 10000 });
+                    if (kind === 'form') {
+                        try {
+                            await page.waitForFunction(() => window.__E10_FORM_READY__ === true ||
+                                window.__E10_INSPECTION_ERRORS__?.length > 0, undefined, { timeout: 10000 });
+                        }
+                        catch (error) {
+                            if (!(error instanceof Error) || error.name !== 'TimeoutError')
+                                throw error;
+                        }
+                        if (!(await page.evaluate(() => window.__E10_FORM_READY__ === true)))
+                            errors.add('表单未完成初始化，检查脚本错误及 __E10_FORM_READY__ 设置');
+                    }
+                    await page.evaluate(() => document.fonts.ready);
+                    const layout = await page.evaluate(() => ({
+                        height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight),
+                        width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth),
+                        visible: [...document.body.querySelectorAll('*')].some((element) => element.getBoundingClientRect().width > 0 &&
+                            element.getBoundingClientRect().height > 0),
+                        broken: [...document.images].some((image) => !image.complete || !image.naturalWidth),
+                    }));
+                    if (!layout.visible)
+                        errors.add('页面没有可见业务内容');
+                    if (layout.broken)
+                        errors.add('页面包含未加载的图片');
+                    if (layout.height > 50000 || layout.width * layout.height > 60000000)
+                        throw new CaptureError('HTML_RENDER_SIZE', '页面尺寸超过校对限制');
+                    const save = async (name, clip) => {
+                        const filename = path.join(directory, `${viewport.width}-${name}.png`);
+                        const bytes = await page.screenshot({
+                            fullPage: true,
+                            ...(clip ? { clip } : {}),
+                            timeout: 10000,
+                            animations: 'disabled',
+                        });
+                        await fs.writeFile(filename, bytes, { mode: 0o600 });
+                        screenshots.push({ path: filename, sha256: digest(bytes) });
+                    };
+                    await save('full');
+                    if (layout.height > 1800) {
+                        for (const [i, y] of [
+                            ...new Set([0, Math.floor((layout.height - 900) / 2), layout.height - 900]),
+                        ].entries())
+                            await save(`section-${i + 1}`, { x: 0, y, width: viewport.width, height: 900 });
+                    }
+                    const browserErrors = await page.evaluate(() => window.__E10_INSPECTION_ERRORS__ || []);
+                    for (const error of browserErrors.slice(0, 10)) {
+                        if (error.url !== previewUrl || !Number.isInteger(error.line) || error.line < 1)
+                            continue;
+                        runtimeErrorDetails.push({
+                            message: String(error.message).slice(0, 500),
+                            file: previewPath,
+                            line: error.line,
+                            column: error.column,
+                            sourceLine: (sourceLines[error.line - 1] || '').slice(Math.max(0, error.column - 120), Math.max(0, error.column - 120) + 300),
+                        });
+                    }
+                })(), 30000, 'HTML_RENDER_TIMEOUT');
+            }
+            finally {
+                await bounded(page.close(), 8000, 'PAGE_CLOSE_TIMEOUT');
+            }
+        }
+        finally {
+            await bounded(context.close(), 8000, 'CONTEXT_CLOSE_TIMEOUT');
+        }
+    }
+    finally {
+        await chrome.close();
+    }
+    const current = await prepareHtml(store, state, pageId, token, kind);
+    if (digest(current.bytes) !== sourceSha256)
+        throw new CaptureError('HTML_REVIEW_STALE', '渲染期间草稿发生变化，请重新校对');
+    const receipt = {
+        ok: errors.size === 0,
+        key,
+        sourceSha256,
+        viewport,
+        screenshots,
+        errors: [...errors],
+        runtimeErrors,
+        runtimeErrorDetails,
+        elapsedMs: Date.now() - started,
+        reviewedAt: new Date().toISOString(),
+        visual: 'host-review-required',
+    };
+    await atomicJson(receiptPath, receipt);
+    return { ...receipt, reused: false, receiptPath };
+}

package/dist/html.d.ts

@@ -1,8 +1,16 @@
-import type { HtmlResult, TaskState } from './model.js';
+import type { HtmlResult, PageResult, TaskState, FormCollection } from './model.js';
 import { Store } from './store.js';
-export declare function nextHtml(store: Store, s: TaskState): Promise<{
+export declare function draftPath(store: Store, r: HtmlResult): string;
+export declare function nextHtml(store: Store, s: TaskState, options?: {
+    brief?: boolean;
+}): Promise<{
     state: string;
     concurrency: number;
+    host: {
+        modelPolicy: string;
+        scheduling: string;
+        maxVisualCorrections: number;
+    };
     jobs: any[];
     html: {
         required: boolean;
@@ -14,7 +22,18 @@ export declare function nextHtml(store: Store, s: TaskState): Promise<{
     next: string;
 }>;
 export declare function validateHtml(source: string, screenshotSha256: string): void;
-export declare function acceptHtml(store: Store, s: TaskState, pageId: string, token: string, kind?: 'page' | 'form'): Promise<HtmlResult>;
+export declare function activeHtml(store: Store, s: TaskState, pageId: string, token: string, kind: 'page' | 'form'): Promise<{
+    png: FormCollection | PageResult;
+    r: HtmlResult;
+}>;
+export declare function prepareHtml(store: Store, s: TaskState, pageId: string, token: string, kind: 'page' | 'form'): Promise<{
+    source: string;
+    bytes: Buffer<ArrayBufferLike>;
+    png: FormCollection | PageResult;
+    r: HtmlResult;
+    draft: string;
+}>;
+export declare function acceptHtml(store: Store, s: TaskState, pageId: string, token: string, kind?: 'page' | 'form', expectedSha256?: string): Promise<HtmlResult>;
 export declare function failHtml(store: Store, s: TaskState, pageId: string, token: string, reason: string, kind?: 'page' | 'form'): Promise<HtmlResult>;
 export declare function retryHtml(store: Store, s: TaskState, target?: {
     id: string;