e10-ebuilder-prototype 0.5.4 → 0.5.7

package/dist/form-runtime.mjs

@@ -38,7 +38,10 @@ function installFormStore(scope, objectIds, createStorage) {
     const request = (targetScope, operation, value) => {
         if (!allowed.has(targetScope))
             return Promise.reject(new Error('表单不在当前应用的已发布范围'));
-        if (!valid(value) || JSON.stringify(value).length > 2_000_000)
+        if (!(operation === 'compareSave'
+            ? valid(value?.expected) && valid(value?.next)
+            : valid(value)) ||
+            JSON.stringify(value).length > 2_000_000)
             return Promise.reject(new Error('本地数据格式无效或超过容量'));
         if (parent === window)
             return Promise.resolve(local(targetScope, operation, value));
@@ -63,7 +66,12 @@ function installFormStore(scope, objectIds, createStorage) {
             };
             const timer = setTimeout(() => {
                 finish();
-                resolve(local(targetScope, operation, value));
+                // A timed-out write may already have committed in the shell. Never replay
+                // a compare/save locally and report a different outcome as success.
+                if (operation === 'compareSave')
+                    reject(new Error('FORM_COMMIT_UNKNOWN: 主框架未确认保存，请重新加载核对'));
+                else
+                    resolve(local(targetScope, operation, value));
             }, 1000);
             addEventListener('message', receive);
             parent.postMessage({ type: 'e10-form-store', requestId, operation, scope: targetScope, value }, '*');
@@ -114,6 +122,7 @@ function installFormStore(scope, objectIds, createStorage) {
     const objectStore = (targetScope) => Object.freeze({
         load: (initial) => request(targetScope, 'load', initial),
         save: (state) => request(targetScope, 'save', state),
+        compareSave: (expected, next) => request(targetScope, 'compareSave', { expected, next }),
         reset: (initial) => request(targetScope, 'reset', initial),
     });
     Object.defineProperty(window, 'E10FormStore', {

package/dist/host-ledger.d.ts

@@ -0,0 +1,23 @@
+import type { Store } from './store.js';
+import type { TaskState } from './model.js';
+type Worker = {
+    taskId: string;
+    token: string;
+    kind: 'page' | 'form';
+    pageId: string;
+    startedAt: string;
+    nativeName?: string;
+    outcome?: string;
+    endedAt?: string;
+};
+type Ledger = {
+    schema: 1;
+    workers: Worker[];
+};
+export declare function readHostLedger(store: Store): Promise<Ledger | undefined>;
+export declare function parseHostEvents(raw: string): any[];
+/** Called only under the existing coordinator lock. A missing event never means exit. */
+export declare function updateHostLedger(store: Store, state: TaskState, events: any[]): Promise<Ledger>;
+export declare function activeHostWorkers(store: Store): Promise<Worker[] | undefined>;
+export declare function parseHostActiveTokens(value: string): string[];
+export {};

package/dist/host-ledger.js

@@ -0,0 +1,183 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { atomicJson, CaptureError } from './common.js';
+const filename = (store) => path.join(store.meta, 'host-workers.json');
+const identity = (v) => typeof v === 'string' && /^[a-zA-Z0-9_-]{1,128}$/.test(v);
+const nativeName = (v) => typeof v === 'string' &&
+    v.length <= 256 &&
+    /^(?:e10-[a-f0-9-]{36}(?:-[0-9]+)?|(?:页面|表单)-[\p{L}\p{N}_-]+)$/u.test(v);
+export async function readHostLedger(store) {
+    let value;
+    try {
+        value = JSON.parse(await fs.readFile(filename(store), 'utf8'));
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return;
+        throw new CaptureError('HOST_LEDGER_INVALID', '后台任务登记文件损坏，不能按空列表释放名额');
+    }
+    if (value?.schema !== 1 ||
+        !Array.isArray(value.workers) ||
+        value.workers.some((w) => !identity(w.taskId) ||
+            !identity(w.token) ||
+            !['page', 'form'].includes(w.kind) ||
+            typeof w.pageId !== 'string' ||
+            !Number.isFinite(Date.parse(w.startedAt)) ||
+            (w.endedAt !== undefined &&
+                (!Number.isFinite(Date.parse(w.endedAt)) ||
+                    !['completed', 'failed', 'cancelled'].includes(w.outcome)))) ||
+        new Set(value.workers.map((w) => w.taskId)).size !== value.workers.length ||
+        new Set(value.workers.map((w) => w.token)).size !== value.workers.length)
+        throw new CaptureError('HOST_LEDGER_INVALID', '后台任务登记无效，不能释放名额');
+    return value;
+}
+export function parseHostEvents(raw) {
+    let events;
+    try {
+        events = JSON.parse(raw);
+    }
+    catch {
+        throw new CaptureError('ARGUMENT_INVALID', '--host-events 需要 JSON 数组');
+    }
+    if (Array.isArray(events))
+        events = events.map((event) => {
+            if (event?.event !== 'started' || event.receipt === undefined)
+                return event;
+            // Copy the native spawn response intact. Never pair parallel responses by order.
+            const receipt = event.receipt;
+            const names = typeof receipt === 'string' ? [...receipt.matchAll(/^name: ([^\r\n]+)\r?$/gm)] : [];
+            const ids = typeof receipt === 'string'
+                ? [...receipt.matchAll(/^task_id: ([a-zA-Z0-9_-]{1,128})\r?$/gm)]
+                : [];
+            if (typeof receipt !== 'string' ||
+                receipt.length > 16000 ||
+                !receipt.startsWith('Spawned successfully.') ||
+                names.length !== 1 ||
+                !nativeName(names[0][1]) ||
+                ids.length !== 1)
+                throw new CaptureError('HOST_START_RECEIPT_INVALID', '需要含唯一 name 和 task_id 的完整原生后台启动回执；同步结果不能登记');
+            const renames = [
+                ...receipt.matchAll(/^Note: requested name "([^"]+)" was already in use \(or reserved for the team leader\)\. Renamed to "([^"]+)"\. Use this name when addressing the teammate via SendMessage\.\r?$/gm),
+            ];
+            if (renames.length > 1 ||
+                [...receipt.matchAll(/^Note: requested name /gm)].length !== renames.length ||
+                (renames.length === 1 &&
+                    (!nativeName(renames[0][1]) ||
+                        renames[0][2] !== names[0][1] ||
+                        !/^-(?:[2-9]|[1-9][0-9]+)$/.test(names[0][1].slice(renames[0][1].length)) ||
+                        !names[0][1].startsWith(renames[0][1]))))
+                throw new CaptureError('HOST_START_RECEIPT_INVALID', '原生重名回执不一致，拒绝登记');
+            const requestedName = renames[0]?.[1] || names[0][1];
+            const legacyToken = /^e10-([a-f0-9-]{36})$/.exec(requestedName)?.[1];
+            if ((legacyToken && event.token !== undefined && event.token !== legacyToken) ||
+                (event.taskId !== undefined && event.taskId !== ids[0][1]))
+                throw new CaptureError('HOST_IDENTITY_MISMATCH', '手工身份与原生启动回执不一致，拒绝登记；不要改写回执');
+            return {
+                event: 'started',
+                taskId: ids[0][1],
+                token: legacyToken || event.token,
+                nativeName: names[0][1],
+                requestedName,
+            };
+        });
+    if (!Array.isArray(events) ||
+        events.length > 100 ||
+        events.some((e) => !e ||
+            !['started', 'terminal'].includes(e.event) ||
+            !identity(e.taskId) ||
+            (e.event === 'started'
+                ? (e.token === undefined ? !nativeName(e.requestedName) : !identity(e.token)) ||
+                    (e.nativeName !== undefined && !nativeName(e.nativeName)) ||
+                    (e.requestedName !== undefined && !nativeName(e.requestedName))
+                : e.token !== undefined && !identity(e.token)) ||
+            (e.event === 'terminal' &&
+                (e.executionEnded !== true || !['completed', 'failed', 'cancelled'].includes(e.outcome)))))
+        throw new CaptureError('ARGUMENT_INVALID', '启动需要原生 receipt（兼容 taskId/token）；终态需要 taskId、outcome 和 executionEnded:true 的宿主确认');
+    return events;
+}
+/** Called only under the existing coordinator lock. A missing event never means exit. */
+export async function updateHostLedger(store, state, events) {
+    events = parseHostEvents(JSON.stringify(events));
+    const ledger = (await readHostLedger(store)) || { schema: 1, workers: [] };
+    // Read each allocation once per transaction, even for a whole batch of starts.
+    const allocations = events.some((e) => e.event === 'started')
+        ? (await Promise.all([
+            ...(state.pages || []).map((p) => ({ kind: 'page', id: p.id })),
+            ...(state.formPages || []).map((p) => ({ kind: 'form', id: p.id })),
+        ].map(async (item) => {
+            const result = await store.htmlResult(item.id, item.kind);
+            return result && ['running', 'succeeded'].includes(result.status)
+                ? [{ ...item, result }]
+                : [];
+        }))).flat()
+        : [];
+    for (const event of events) {
+        const old = ledger.workers.find((w) => w.taskId === event.taskId);
+        if (event.event === 'started' && event.requestedName) {
+            const matches = [];
+            if (old &&
+                (old.nativeName === event.nativeName || event.requestedName === `e10-${old.token}`))
+                matches.push(old);
+            for (const { result: r } of allocations) {
+                if (!matches.some((m) => m.token === r.token) &&
+                    (event.requestedName === r.dispatchName || event.requestedName === `e10-${r.token}`))
+                    matches.push(r);
+            }
+            if (matches.length !== 1)
+                throw new CaptureError('HOST_TOKEN_STALE', '原生名称必须唯一对应当前已分配任务；不要按顺序猜 token');
+            if (event.token !== undefined && event.token !== matches[0].token)
+                throw new CaptureError('HOST_IDENTITY_MISMATCH', '手工 token 与原生名称不匹配，拒绝登记');
+            event.token = matches[0].token;
+        }
+        if (old && event.token !== undefined && old.token !== event.token)
+            throw new CaptureError('HOST_IDENTITY_MISMATCH', 'taskId 与 token 不匹配，拒绝更新');
+        if (event.event === 'terminal') {
+            if (!old)
+                throw new CaptureError('HOST_WORKER_UNKNOWN', '未登记的 taskId 不能释放名额');
+            if (old.endedAt && old.outcome !== event.outcome)
+                throw new CaptureError('HOST_TERMINAL_CONFLICT', '重复终态的 outcome 不一致');
+            old.endedAt ||= new Date().toISOString();
+            old.outcome = event.outcome;
+        }
+        else if (!old) {
+            if (ledger.workers.some((w) => w.token === event.token))
+                throw new CaptureError('HOST_DUPLICATE_WRITER', '同一 token 已登记其他原生任务');
+            const allocation = allocations.find(({ result }) => result.token === event.token);
+            const target = allocation
+                ? {
+                    taskId: event.taskId,
+                    token: event.token,
+                    kind: allocation.kind,
+                    pageId: allocation.id,
+                    startedAt: new Date().toISOString(),
+                    ...(event.nativeName ? { nativeName: event.nativeName } : {}),
+                }
+                : undefined;
+            if (!target)
+                throw new CaptureError('HOST_TOKEN_STALE', '只能登记当前已分配的 HTML token');
+            if (ledger.workers.filter((w) => !w.endedAt).length >= state.settings.concurrency)
+                throw new CaptureError('HOST_CAPACITY_EXCEEDED', '原生任务数已达到并发上限');
+            ledger.workers.push(target);
+        }
+    }
+    await atomicJson(filename(store), ledger);
+    return ledger;
+}
+export async function activeHostWorkers(store) {
+    return (await readHostLedger(store))?.workers.filter((w) => !w.endedAt);
+}
+export function parseHostActiveTokens(value) {
+    let tokens;
+    try {
+        tokens = JSON.parse(value);
+    }
+    catch {
+        throw new CaptureError('ARGUMENT_INVALID', '--host-active-tokens 需要 JSON 字符串数组');
+    }
+    if (!Array.isArray(tokens) ||
+        tokens.length > 100 ||
+        tokens.some((token) => typeof token !== 'string' || !/^[a-zA-Z0-9_-]{1,128}$/.test(token)) ||
+        new Set(tokens).size !== tokens.length)
+        throw new CaptureError('ARGUMENT_INVALID', '--host-active-tokens 需要不重复的有效令牌数组');
+    return tokens;
+}

package/dist/host-watch.d.ts

@@ -0,0 +1,102 @@
+import type { Store } from './store.js';
+import type { TaskState } from './model.js';
+/** Local evidence only. A quiet file, ready receipt or timeout never proves native exit. */
+export declare function observeHost(store: Store, state: TaskState, tokens: string[]): Promise<{
+    slots: ({
+        token: string;
+        htmlStatus: string;
+        checkReason: string;
+        reviewSubmitted: boolean;
+        kind?: undefined;
+        pageId?: undefined;
+        name?: undefined;
+        lastLocalActivityAt?: undefined;
+        localIdleMs?: undefined;
+    } | {
+        token: string;
+        kind: "page" | "form";
+        pageId: string;
+        name: string;
+        htmlStatus: "running" | "succeeded" | "failed" | "pending";
+        reviewSubmitted: boolean;
+        lastLocalActivityAt: string;
+        localIdleMs: number;
+        checkReason: string | undefined;
+    })[];
+    observationState: string;
+    reconcile: ({
+        token: string;
+        htmlStatus: string;
+        checkReason: string;
+        reviewSubmitted: boolean;
+        kind?: undefined;
+        pageId?: undefined;
+        name?: undefined;
+        lastLocalActivityAt?: undefined;
+        localIdleMs?: undefined;
+    } | {
+        token: string;
+        kind: "page" | "form";
+        pageId: string;
+        name: string;
+        htmlStatus: "running" | "succeeded" | "failed" | "pending";
+        reviewSubmitted: boolean;
+        lastLocalActivityAt: string;
+        localIdleMs: number;
+        checkReason: string | undefined;
+    })[];
+}>;
+/** One bounded background process. No auth, Chrome, queue lock or state mutations. */
+export declare function watchHost(store: Store, options: {
+    activeTokens: string[];
+    afterState?: string;
+    watchMs?: number;
+}): Promise<{
+    reason: string;
+    elapsedMs: number;
+    next: string;
+    releasesSlots: boolean;
+    slots: ({
+        token: string;
+        htmlStatus: string;
+        checkReason: string;
+        reviewSubmitted: boolean;
+        kind?: undefined;
+        pageId?: undefined;
+        name?: undefined;
+        lastLocalActivityAt?: undefined;
+        localIdleMs?: undefined;
+    } | {
+        token: string;
+        kind: "page" | "form";
+        pageId: string;
+        name: string;
+        htmlStatus: "running" | "succeeded" | "failed" | "pending";
+        reviewSubmitted: boolean;
+        lastLocalActivityAt: string;
+        localIdleMs: number;
+        checkReason: string | undefined;
+    })[];
+    observationState: string;
+    reconcile: ({
+        token: string;
+        htmlStatus: string;
+        checkReason: string;
+        reviewSubmitted: boolean;
+        kind?: undefined;
+        pageId?: undefined;
+        name?: undefined;
+        lastLocalActivityAt?: undefined;
+        localIdleMs?: undefined;
+    } | {
+        token: string;
+        kind: "page" | "form";
+        pageId: string;
+        name: string;
+        htmlStatus: "running" | "succeeded" | "failed" | "pending";
+        reviewSubmitted: boolean;
+        lastLocalActivityAt: string;
+        localIdleMs: number;
+        checkReason: string | undefined;
+    })[];
+}>;

package/dist/host-watch.js

@@ -0,0 +1,112 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { CaptureError, digest, mapLimit } from './common.js';
+import { navigationKey } from './menus.js';
+/** Local evidence only. A quiet file, ready receipt or timeout never proves native exit. */
+export async function observeHost(store, state, tokens) {
+    const targets = [
+        ...(state.pages || []).map((p) => ({ ...p, kind: 'page' })),
+        ...(state.menuRequired ? state.formPages || [] : []).map((p) => ({
+            ...p,
+            kind: 'form',
+        })),
+    ];
+    const receipts = await mapLimit(targets, 8, async (p) => ({
+        item: p,
+        receipt: await store.htmlResult(p.id, p.kind),
+    }));
+    const byToken = new Map(receipts.filter((p) => p.receipt).map((p) => [p.receipt.token, p]));
+    const now = Date.now();
+    const slots = await Promise.all(tokens.map(async (token) => {
+        const matched = byToken.get(token);
+        if (!matched?.receipt)
+            return {
+                token,
+                htmlStatus: 'unknown',
+                checkReason: 'unknown-reservation',
+                reviewSubmitted: false,
+            };
+        const { receipt: r, item } = matched;
+        const dir = path.join(store.meta, 'html-drafts', r.token);
+        const draft = path.join(dir, `${item.kind === 'form' ? navigationKey(r.id) : r.id}.html`);
+        const reviewPath = path.join(dir, 'review', 'host-review.json');
+        const [draftStat, reviewStat, review] = await Promise.all([
+            fs.stat(draft).catch(() => null),
+            fs.stat(reviewPath).catch(() => null),
+            fs
+                .readFile(reviewPath, 'utf8')
+                .then(JSON.parse)
+                .catch(() => null),
+        ]);
+        const reviewSubmitted = review?.schema === 1 &&
+            review.token === token &&
+            review.pageId === r.id &&
+            review.kind === item.kind;
+        const lastLocalActivityMs = Math.max(Date.parse(r.startedAt) || 0, Date.parse(r.finishedAt || '') || 0, draftStat?.mtimeMs || 0, reviewStat?.mtimeMs || 0);
+        const localIdleMs = Math.max(0, Math.floor(now - lastLocalActivityMs));
+        return {
+            token,
+            kind: item.kind,
+            pageId: r.id,
+            name: item.name,
+            htmlStatus: r.status,
+            reviewSubmitted,
+            lastLocalActivityAt: new Date(lastLocalActivityMs).toISOString(),
+            localIdleMs,
+            checkReason: r.status !== 'running'
+                ? 'html-terminal-native-unconfirmed'
+                : reviewSubmitted
+                    ? 'review-submitted-native-unconfirmed'
+                    : localIdleMs >= 300_000
+                        ? 'no-local-progress-five-minutes'
+                        : localIdleMs >= 180_000
+                            ? 'no-local-progress-three-minutes'
+                            : undefined,
+        };
+    }));
+    // Draft edits alone do not wake the model; handoffs, terminal receipts and stalled
+    // progress do. Sort tokens so changes in coordinator ordering are not new events.
+    const observationState = digest(JSON.stringify([...slots]
+        .sort((a, b) => a.token.localeCompare(b.token))
+        .map(({ token, htmlStatus, reviewSubmitted, checkReason }) => ({
+        token,
+        htmlStatus,
+        reviewSubmitted,
+        checkReason,
+    }))));
+    return { slots, observationState, reconcile: slots.filter((slot) => slot.checkReason) };
+}
+/** One bounded background process. No auth, Chrome, queue lock or state mutations. */
+export async function watchHost(store, options) {
+    const watchMs = options.watchMs ?? 60_000;
+    if (!Number.isInteger(watchMs) || watchMs < 1 || watchMs > 60_000)
+        throw new CaptureError('ARGUMENT_INVALID', '--watch-ms 范围 1..60000');
+    if (options.afterState !== undefined && !/^[a-f0-9]{64}$/.test(options.afterState))
+        throw new CaptureError('ARGUMENT_INVALID', '--after-state 需要 observationState 摘要');
+    const started = performance.now();
+    let baseline = options.afterState;
+    for (;;) {
+        const observation = await observeHost(store, await store.load(), options.activeTokens);
+        const elapsedMs = Math.round(performance.now() - started);
+        const reason = !options.activeTokens.length
+            ? 'no-active-workers'
+            : baseline !== undefined && observation.observationState !== baseline
+                ? 'local-state-changed'
+                : baseline === undefined && observation.reconcile.length
+                    ? 'native-check-required'
+                    : elapsedMs >= watchMs
+                        ? 'native-status-deadline'
+                        : undefined;
+        if (reason)
+            return {
+                ...observation,
+                reason,
+                elapsedMs,
+                next: options.activeTokens.length ? 'reconcile-native-host' : 'html next',
+                releasesSlots: false,
+            };
+        baseline = observation.observationState;
+        await delay(Math.min(1000, Math.max(1, watchMs - elapsedMs)));
+    }
+}

package/dist/html-handoff.d.ts

@@ -7,6 +7,7 @@ export declare function readyHtml(store: Store, state: TaskState, pageId: string
     pageId: string;
     receiptPath: string;
     next: string;
+    instruction: string;
     frozen: boolean;
 }>;
 /** Called only by the coordinator under the queue lock. Each acceptance is durable. */

package/dist/html-handoff.js

@@ -29,7 +29,25 @@ async function evidence(store, state, pageId, token, kind) {
         }
         inspections.push({ width, sha256: await fileDigest(filename) });
     }
-    return { directory, sourceSha256, inspections };
+    const interactionPath = path.join(directory, 'interaction.json');
+    const interaction = await fs
+        .readFile(interactionPath, 'utf8')
+        .then(JSON.parse)
+        .catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new CaptureError('HTML_INTERACTION_REQUIRED', '交互回执损坏，需要重跑');
+    });
+    if (interaction && (!interaction.ok || interaction.sourceSha256 !== sourceSha256))
+        throw new CaptureError('HTML_INTERACTION_REQUIRED', '已有交互检查失败或草稿已变化，需要对当前草稿重跑');
+    return {
+        directory,
+        sourceSha256,
+        inspections,
+        interaction: interaction
+            ? { sha256: await fileDigest(interactionPath), steps: interaction.results.length }
+            : undefined,
+    };
 }
 /** The worker attests its review; this is not an independent visual quality score. */
 export async function readyHtml(store, state, pageId, token, kind, summary) {
@@ -44,10 +62,19 @@ export async function readyHtml(store, state, pageId, token, kind, summary) {
         token,
         sourceSha256: proof.sourceSha256,
         inspections: proof.inspections,
+        interaction: proof.interaction,
         summary: summary.trim(),
         reviewedAt: new Date().toISOString(),
     });
-    return { ok: true, kind, pageId, receiptPath, next: 'notify-coordinator', frozen: true };
+    return {
+        ok: true,
+        kind,
+        pageId,
+        receiptPath,
+        next: 'finish-worker',
+        instruction: '回执已落盘；只作简短最终回复并结束，不再调用工具（包括 SendMessage、TaskList、TaskUpdate）或等待其它任务。协调者等待原生执行终态。',
+        frozen: true,
+    };
 }
 /** Called only by the coordinator under the queue lock. Each acceptance is durable. */
 export async function acceptReadyHtml(store, state) {
@@ -71,6 +98,7 @@ export async function acceptReadyHtml(store, state) {
                 receipt.pageId !== result.id ||
                 receipt.kind !== kind ||
                 receipt.sourceSha256 !== proof.sourceSha256 ||
+                JSON.stringify(receipt.interaction) !== JSON.stringify(proof.interaction) ||
                 JSON.stringify(receipt.inspections) !== JSON.stringify(proof.inspections) ||
                 typeof receipt.summary !== 'string' ||
                 !receipt.summary.trim() ||

package/dist/html-inspect.d.ts

@@ -1,4 +1,7 @@
+import { launchChrome } from './capture.js';
 import type { Store } from './store.js';
 import type { TaskState } from './model.js';
+/** One host call and at most one owned Chrome for the required form viewports. */
+export declare function inspectHtmlViewports(store: Store, state: TaskState, pageId: string, token: string, kind?: 'page' | 'form', width?: number, repairReason?: string): Promise<any>;
 /** 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>;
+export declare function inspectHtml(store: Store, state: TaskState, pageId: string, token: string, kind?: 'page' | 'form', width?: number, sharedChrome?: () => Promise<Awaited<ReturnType<typeof launchChrome>>>, repairReason?: string): Promise<any>;