e10-ebuilder-prototype 0.5.0

package/dist/forms.js

@@ -0,0 +1,603 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { atomicJson, CaptureError, errorInfo, fileDigest, mapLimit } from './common.js';
+import { E10Client, parseApiJson } from './api.js';
+import { recoverTemporaryRecords, withTemporaryRecord, SeedUnavailable, temporarySummary, } from './temporary-records.js';
+import { navigationKey } from './menus.js';
+import { APPROVAL_PATH, normalizeWorkflows, workflowPreset, workflowType } from './workflows.js';
+export const formInputPath = (store, key) => path.join(store.meta, 'form-inputs', `${navigationKey(key)}.json`);
+const collectionPath = (store, key) => path.join(store.meta, 'form-results', `${navigationKey(key)}.json`);
+export async function formResult(store, key) {
+    try {
+        return JSON.parse(await fs.readFile(collectionPath(store, key), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+export async function verifiedForm(store, result) {
+    if (!result ||
+        result.status !== 'succeeded' ||
+        !result.sha256 ||
+        (!result.objId && result.kind !== 'workflow'))
+        return false;
+    try {
+        return (await fileDigest(formInputPath(store, result.id))) === result.sha256;
+    }
+    catch {
+        return false;
+    }
+}
+const flag = (value) => value === true || value === 1 || value === '1' || value === 'true';
+const decimal = (value, label) => {
+    if (!(typeof value === 'string' || (typeof value === 'number' && Number.isSafeInteger(value))) ||
+        !/^\d+$/.test(String(value)))
+        throw new CaptureError('FORM_ID_INVALID', `${label} 缺少有效 ID`);
+    return String(value);
+};
+export function configObject(value) {
+    if (value == null || value === '')
+        return {};
+    const result = typeof value === 'string' ? parseApiJson(value) : value;
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        throw new CaptureError('FORM_CONFIG_INVALID', '表单配置不是对象');
+    return result;
+}
+const systems = new Set([
+    '1:name',
+    '2:creator',
+    '3:create_time',
+    '4:update_time',
+    '5:id',
+    '6:updater',
+    '8:data_status',
+    '11:batchpubtags',
+    '12:batchmytags',
+    '9:flow_status',
+    '10:current_step',
+    '16:flow_system_number',
+]);
+export function normalizeFields(groups, objId) {
+    if (!Array.isArray(groups))
+        throw new CaptureError('FIELDS_INVALID', '字段接口不是数组');
+    const fields = [], seen = new Set();
+    const walk = (nodes, groupId, groupName, detail) => {
+        for (const node of nodes) {
+            if (!node || typeof node !== 'object')
+                throw new CaptureError('FIELDS_INVALID', '字段项无效');
+            if (Array.isArray(node.fields)) {
+                const childId = String(node.id || groupId);
+                walk(node.fields, childId, String(node.name || groupName), detail || childId !== objId);
+                continue;
+            }
+            const id = decimal(node.id, '字段'), config = configObject(node.config);
+            if (seen.has(id))
+                throw new CaptureError('FIELD_DUPLICATE', `重复字段 ${id}`);
+            seen.add(id);
+            const subFormId = String(node.subFormId || (detail ? groupId : ''));
+            fields.push({
+                ...node,
+                id,
+                config,
+                groupId,
+                groupName,
+                subFormId,
+                isDetail: !!subFormId || detail,
+                system: ['isSystem', 'systemField', 'isSystemField'].some((key) => flag(node[key])) ||
+                    systems.has(`${id}:${node.name}`),
+            });
+        }
+    };
+    walk(groups, objId, '', false);
+    return fields;
+}
+export function nlistPage(data) {
+    let current = data;
+    for (let i = 0; i < 5 && current && typeof current === 'object'; i++, current = current.data) {
+        if (current.page && typeof current.page === 'object') {
+            const page = current.page, component = page.comps?.[1];
+            if (!component || !component.config)
+                throw new CaptureError('NLIST_CONFIG_INVALID', '缺少已验证的 data.page.comps[1].config');
+            const config = configObject(component.config);
+            return {
+                page,
+                config,
+                objId: decimal(config.objId, 'NList 表单'),
+                listId: decimal(config.ebListId, 'NList 列表'),
+            };
+        }
+    }
+    throw new CaptureError('NLIST_CONFIG_INVALID', '响应缺少 data.page');
+}
+export function normalizeButtons(raw, scope, family) {
+    let sources;
+    if (family === 'layout')
+        sources = [['data', raw]];
+    else if (family === 'list') {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new CaptureError('BUTTON_INVALID', '传统列表按钮结构未知');
+        sources = [
+            ['buttons', raw?.buttons ?? []],
+            ['LineEndDropDownButtons', raw?.LineEndDropDownButtons ?? [], 'LineEndDropDown'],
+        ];
+    }
+    else {
+        const config = configObject(raw?.buttonConfig);
+        sources = [
+            ['buttonConfig.btns', config.btns ?? []],
+            ['topOperatBtns', raw?.topOperatBtns ?? [], 'topOperatBtns'],
+            ['bottomOperatBtns', raw?.bottomOperatBtns ?? [], 'bottomOperatBtns'],
+        ];
+    }
+    const boolean = (value, fallback) => {
+        if (value == null || value === '')
+            return fallback;
+        if ([true, false, 0, 1, '0', '1', 'true', 'false'].includes(value))
+            return flag(value);
+        throw new CaptureError('BUTTON_INVALID', '按钮开关格式未知');
+    };
+    const scopeKey = JSON.stringify(Object.fromEntries(Object.entries(scope).sort(([a], [b]) => a.localeCompare(b))));
+    const items = sources.flatMap(([source, value, position]) => {
+        const buttons = typeof value === 'string' ? parseApiJson(value) : value;
+        if (!Array.isArray(buttons))
+            throw new CaptureError('BUTTON_INVALID', '按钮集合不是数组');
+        return buttons.map((button, index) => {
+            if (!button || typeof button !== 'object')
+                throw new CaptureError('BUTTON_INVALID', '按钮配置无效');
+            let positions = button.showPosition ?? (position ? [position] : []);
+            if (typeof positions === 'string')
+                positions = [positions];
+            if (!Array.isArray(positions))
+                throw new CaptureError('BUTTON_INVALID', '按钮位置无效');
+            return {
+                id: String(button.id ?? `${source}[${index}]`),
+                key: button.buttonKey,
+                name: button.name,
+                positions,
+                enabled: boolean(button.enable, true),
+                hidden: boolean(button.hidden, false),
+                order: button.showOrder ?? index,
+                sourcePath: `${source}[${index}]`,
+                buttonRef: JSON.stringify([scopeKey, String(button.id ?? index), `${source}[${index}]`]),
+                config: button,
+            };
+        });
+    });
+    return { status: 'ready', scope, scopeKey, sourceFamily: family, items, raw };
+}
+export async function collectForms(store, state, auth, retryFailed = false) {
+    if (!state.menuRequired || !state.formPages)
+        return;
+    const client = new E10Client(auth), cache = new Map();
+    const cached = (key, fn) => {
+        if (!cache.has(key))
+            cache.set(key, fn());
+        return cache.get(key);
+    };
+    const jobs = [];
+    for (const item of state.formPages) {
+        const previous = await formResult(store, item.id);
+        if (await verifiedForm(store, previous)) {
+            item.objId = previous.objId;
+            continue;
+        }
+        if (previous?.status === 'failed' && !retryFailed)
+            continue;
+        jobs.push({ item, previous });
+    }
+    if (!jobs.length && !(await temporarySummary(store)).pending)
+        return;
+    const independent = await client.request('GET', `/api/ebuilder/form/app/isIndependentDeploy?appId=${state.appId}`);
+    if (typeof independent !== 'boolean')
+        throw new CaptureError('DEPLOYMENT_INVALID', '独立部署状态不是布尔值');
+    const prefix = '/api/ebuilder' + (independent ? state.appId : '');
+    await recoverTemporaryRecords(store, state, client, prefix);
+    if (!jobs.length)
+        return;
+    let temporaryQueue = Promise.resolve(), temporaryFailure;
+    const temporary = (fn) => {
+        const result = temporaryQueue.then(async () => {
+            if (temporaryFailure)
+                throw temporaryFailure;
+            try {
+                return await fn();
+            }
+            catch (error) {
+                if (!(error instanceof SeedUnavailable))
+                    temporaryFailure = error;
+                throw error;
+            }
+        });
+        temporaryQueue = result.then(() => undefined, () => undefined);
+        return result;
+    };
+    const get = (suffix) => client.request('GET', prefix + '/form' + suffix);
+    const post = (suffix, body) => client.request('POST', prefix + '/form' + suffix, body);
+    const sourceForms = new Map((state.forms || []).map((f) => [f.id, f]));
+    const safeAttempt = async (label, warnings, fn) => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (['E10_LOGIN_REQUIRED', 'TEMPORARY_RECORD_STOP'].includes(error.code))
+                throw error;
+            warnings.push(`${label}不可用，${client.clean(errorInfo(error).message)}`);
+            return undefined;
+        }
+    };
+    const collectObject = (formId, withButtons) => cached(`form:${formId}`, async () => {
+        const warnings = [];
+        const groups = await client.request('POST', '/api/ebuilder/common/ds/fields', {
+            groupId: state.appId,
+            sourceId: formId,
+            sourceType: 'FORM',
+            detailFieldsGroup: 'true',
+            enableMerge: 'true',
+            customParam: '{"terminal":""}',
+            params: '[]',
+        }, true);
+        const fields = normalizeFields(groups, formId);
+        for (const field of fields) {
+            const kind = String(field.compType || field.type).toLowerCase();
+            if (!field.system && ['select', 'radiobox', 'checkbox', 'cascader'].includes(kind)) {
+                field.options = await client.request('GET', `/api/ebuilder/common/ds/options?fieldName=${field.id}&objId=${formId}&sourceType=FORM&groupId=${state.appId}&optionLevel=1`);
+                if (kind === 'cascader')
+                    warnings.push(`字段 ${field.id} 的级联选项仅取得第一层`);
+            }
+        }
+        let record, referenceKnown = false;
+        await safeAttempt('参考记录查询', warnings, async () => {
+            const data = await post('/dataset/v2/getAllData', {
+                datajson: {
+                    header: { objId: formId },
+                    pageInfo: { pageNo: 1, pageSize: 1 },
+                    operationinfo: { isReturnDetail: false },
+                },
+            });
+            const rows = data?.datajson?.datas;
+            if (!Array.isArray(rows))
+                throw new CaptureError('REFERENCE_INVALID', '查询缺少 datas 数组');
+            referenceKnown = true;
+            if (rows.length) {
+                const value = rows[0]?.mainTable?.id;
+                if (value?.fieldId != null && String(value.fieldId) !== '5')
+                    throw new CaptureError('REFERENCE_INVALID', '记录 ID 字段无效');
+                record = decimal(value?.fieldValue, '参考记录');
+            }
+        });
+        const layout = {
+            source: 'fields',
+            reason: record ? 'export-unavailable' : 'no-accessible-record',
+        };
+        const contexts = {};
+        const buttonsFor = async (mode, layoutId, contextRecord) => {
+            if (!contextRecord && mode !== '1')
+                return { status: 'unavailable', reason: 'no-accessible-record', items: [] };
+            const dataId = mode === '1' ? '0' : contextRecord;
+            const data = await post('/data/getFormButtons', {
+                layoutType: 'formLayout',
+                objId: formId,
+                dataId,
+                formDataId: dataId,
+                type: mode,
+                fromRecycle: false,
+                otherOperator: '',
+                objectAppId: '',
+                browser: 'Chrome',
+                layoutId,
+                isTamper: '0',
+                paramWrapper: {
+                    id: dataId,
+                    fromRecycle: false,
+                    type: mode,
+                    objid: formId,
+                    dataid: dataId,
+                },
+            });
+            return normalizeButtons(data, {
+                appId: state.appId,
+                objId: formId,
+                kind: 'layout',
+                layoutId,
+                mode,
+                recordContext: mode === '1' ? 'new' : 'reference-snapshot',
+            }, 'layout');
+        };
+        const loadContexts = async (reference) => {
+            if (reference) {
+                const html = await safeAttempt('布局参考导出', warnings, async () => {
+                    const exported = await post('/single/exportDataDetailPDF', {
+                        objId: formId,
+                        fileName: 'prototype-layout-reference',
+                        exportWord: false,
+                        exportExcel: false,
+                        exportHtml: true,
+                        exportPdf: false,
+                        wordLayout: {},
+                        excelLayout: {},
+                        formDataId: reference,
+                    });
+                    if (exported?.success !== true)
+                        throw new CaptureError('REFERENCE_INVALID', '布局导出未成功');
+                    return client.reference(decimal(exported.pdfFileId, '导出文件'));
+                });
+                if (html) {
+                    layout.source = 'html-reference';
+                    layout.html = html;
+                    delete layout.reason;
+                }
+            }
+            // Collect default and explicitly requested layout/record contexts while a temporary reference still exists.
+            const requested = new Map();
+            if (withButtons)
+                requested.set('', { layoutId: '' });
+            for (const p of state.formPages || [])
+                if (withButtons && p.objId === formId && p.kind === 'layout')
+                    requested.set(p.id, {
+                        layoutId: p.layoutId || '',
+                        record: p.recordId && p.recordId !== '0' ? p.recordId : undefined,
+                    });
+            const snapshots = new Map();
+            for (const [key, context] of requested) {
+                const modes = {};
+                for (const [mode, name] of [
+                    ['1', 'add'],
+                    ['0', 'view'],
+                    ['2', 'edit'],
+                ]) {
+                    const recordId = context.record || reference, scopeKey = `${context.layoutId}:${mode}:${mode === '1' ? '0' : recordId || ''}`;
+                    if (!snapshots.has(scopeKey))
+                        snapshots.set(scopeKey, (await safeAttempt(`${name}布局按钮`, warnings, () => buttonsFor(mode, context.layoutId, recordId))) || { status: 'unavailable', reason: 'request-failed', items: [] });
+                    modes[name] = snapshots.get(scopeKey);
+                }
+                contexts[key] = modes;
+            }
+        };
+        await loadContexts(record);
+        if (layout.source === 'fields' && referenceKnown && state.allowTemporaryRecords) {
+            try {
+                await temporary(() => withTemporaryRecord(store, state, client, prefix, formId, fields, async (temporaryId) => {
+                    await loadContexts(temporaryId);
+                }));
+            }
+            catch (error) {
+                if (!(error instanceof SeedUnavailable))
+                    throw error;
+                warnings.push(error.message);
+            }
+        }
+        if (layout.source === 'fields')
+            warnings.push(state.allowTemporaryRecords
+                ? '未取得布局 HTML，使用全部自定义字段生成布局'
+                : '未取得布局 HTML，使用全部自定义字段生成布局；未启用临时参考记录');
+        return { fields, layout, warnings, contexts };
+    });
+    const loadWorkflowCatalog = () => cached('workflow-catalog', async () => {
+        try {
+            const data = await client.request('POST', `${APPROVAL_PATH}?apid=${state.appId}&cid=${state.appId}`, { appId: state.appId, viewType: '', sortParams: [], searchParamData: {} });
+            const value = normalizeWorkflows(data, state.appId, new Set(sourceForms.keys()));
+            await atomicJson(path.join(store.meta, 'workflow-catalog.json'), client.clean(value));
+            return value;
+        }
+        catch (error) {
+            await atomicJson(path.join(store.meta, 'workflow-catalog.json'), {
+                status: 'unavailable',
+                error: client.clean(errorInfo(error)),
+            });
+            throw error;
+        }
+    });
+    const collectMenu = async ({ item, previous }) => {
+        const receipt = {
+            id: item.id,
+            status: 'running',
+            attempt: (previous?.attempt || 0) + 1,
+            updatedAt: new Date().toISOString(),
+        };
+        await atomicJson(collectionPath(store, item.id), receipt);
+        try {
+            if (item.kind === 'workflow') {
+                const catalog = await loadWorkflowCatalog();
+                const objectIds = [
+                    ...new Set(catalog.templates.map((t) => t.objId)),
+                ].sort();
+                const forms = [];
+                for (const objId of objectIds) {
+                    // Ordinary menu collection runs first; reuse its verified snapshot on resume too.
+                    let shared;
+                    for (const page of state.formPages || []) {
+                        if (page.kind === 'workflow' || page.objId !== objId)
+                            continue;
+                        const result = await formResult(store, page.id);
+                        if (await verifiedForm(store, result)) {
+                            shared = JSON.parse(await fs.readFile(formInputPath(store, page.id), 'utf8'));
+                            break;
+                        }
+                    }
+                    shared ||= await collectObject(objId, false);
+                    forms.push({
+                        objId,
+                        name: sourceForms.get(objId).name,
+                        fields: shared.fields,
+                        layout: shared.layout,
+                        warnings: shared.warnings,
+                        workflowRefs: catalog.templates
+                            .filter((t) => t.objId === objId)
+                            .map((t) => t.workflowId),
+                    });
+                }
+                const preset = workflowPreset(workflowType(item.workflowType));
+                const scope = {
+                    appId: state.appId,
+                    kind: 'workflow',
+                    workflowType: item.workflowType,
+                    bindingPath: item.id,
+                };
+                const buttons = {
+                    ...normalizeButtons({ buttons: preset.buttons }, scope, 'list'),
+                    sourceFamily: 'workflow',
+                    source: preset.source,
+                    mockOnly: true,
+                };
+                for (const button of buttons.items)
+                    button.pageButtonRef = JSON.stringify([item.id, button.buttonRef]);
+                const warnings = [...new Set(forms.flatMap((f) => f.warnings))];
+                if (catalog.skipped.length)
+                    warnings.push(`流程目录跳过 ${catalog.skipped.length} 个非 EB 或归属/配置无效的流程；详见私有 workflowCatalog.skipped`);
+                if (!catalog.templates.length)
+                    warnings.push('没有可用的 EB 流程模板，保留已发布流程入口并显示空态');
+                await atomicJson(formInputPath(store, item.id), client.clean({
+                    schema: 1,
+                    appId: state.appId,
+                    name: item.name,
+                    page: item,
+                    workflowCatalog: catalog,
+                    workflowPreset: preset,
+                    forms,
+                    buttons,
+                    dataStatus: catalog.templates.length ? 'ready' : 'empty',
+                    warnings,
+                }));
+                Object.assign(receipt, {
+                    kind: 'workflow',
+                    objectIds,
+                    status: 'succeeded',
+                    warnings,
+                    sha256: await fileDigest(formInputPath(store, item.id)),
+                    updatedAt: new Date().toISOString(),
+                });
+                await atomicJson(collectionPath(store, item.id), receipt);
+                return undefined;
+            }
+            let list, listButtons, objId = item.objId;
+            if (item.kind === 'nlist') {
+                const data = await cached(`nlist:${item.viewId}`, () => get(`/viewdesigner/viewPageInfo?pageId=${item.viewId}&terminalType=PC`));
+                const parsed = nlistPage(data);
+                if (parsed.page.appId != null && String(parsed.page.appId) !== state.appId)
+                    throw new CaptureError('FORM_APP_MISMATCH', 'NList 所属应用不匹配');
+                if (objId && objId !== parsed.objId)
+                    throw new CaptureError('FORM_ID_MISMATCH', '菜单与 NList 表单不匹配');
+                objId = parsed.objId;
+                list = {
+                    kind: 'nlist',
+                    hostPageId: item.viewId,
+                    listId: parsed.listId,
+                    config: parsed.config,
+                };
+                listButtons = parsed.config;
+            }
+            else if (item.kind === 'list') {
+                const context = await cached(`list:${item.viewId}`, () => post('/list/listInit', { listId: item.viewId }));
+                if (String(context?.appId) !== state.appId ||
+                    (context.listId != null && String(context.listId) !== item.viewId))
+                    throw new CaptureError('FORM_APP_MISMATCH', '传统列表所属应用或列表 ID 不匹配');
+                const resolved = decimal(context.objId ?? context.objid, '传统列表表单');
+                if (objId && objId !== resolved)
+                    throw new CaptureError('FORM_ID_MISMATCH', '菜单与列表表单不匹配');
+                objId = resolved;
+                const query = `apid=${state.appId}&tpaid=${item.viewId}&objId=${objId}`;
+                const routes = {
+                    basicSettings: `/list/getBaseInfo/${item.viewId}?${query}`,
+                    displayColumns: `/list/getListFields/${item.viewId}?${query}&isVirtualForm=false&clientType=PC`,
+                    sorting: `/viewlist/getViewOrder?${query}&viewType=tableView&viewId=${item.viewId}&isVirtualForm=false`,
+                    search: `/listFilter/getSearchFilters/${item.viewId}?${query}&isVirtualForm=false&viewType=tableView`,
+                    statistics: `/listStatistics/getStatisticsList/${item.viewId}?${query}&isVirtualForm=false`,
+                    buttons: `/list/getListButtons/${item.viewId}?passid=${objId}`,
+                };
+                if (context.conditionId && String(context.conditionId) !== '0')
+                    routes.conditions = `/plugin/conditionEditor/getById?apid=${state.appId}&id=${decimal(context.conditionId, '条件')}&type=search&objId=${objId}`;
+                const responses = await Promise.allSettled(Object.entries(routes).map(async ([key, route]) => [
+                    key,
+                    await cached(route, () => get(route)),
+                ]));
+                for (const result of responses)
+                    if (result.status === 'rejected')
+                        throw result.reason;
+                const config = Object.fromEntries(responses.map((r) => r.value));
+                listButtons = config.buttons;
+                delete config.buttons;
+                list = { kind: 'list', listId: item.viewId, config };
+            }
+            if (!objId || !sourceForms.has(objId))
+                throw new CaptureError('FORM_MEMBERSHIP_INVALID', '菜单对应表单不属于当前应用');
+            item.objId = objId;
+            receipt.objId = objId;
+            const formId = objId;
+            const shared = await collectObject(formId, true);
+            const warnings = [...shared.warnings];
+            const formButtons = structuredClone(shared.contexts[item.kind === 'layout' ? item.id : ''] || shared.contexts['']);
+            if (formButtons.view.status !== 'ready' || formButtons.edit.status !== 'ready')
+                warnings.push('查看/编辑模式按钮缺少记录上下文，不能借用列表按钮');
+            if (item.layoutId && shared.layout.source === 'html-reference')
+                warnings.push('导出的 HTML 为表单默认参考，不能据此宣称指定布局已精确取得');
+            const publicPage = { ...item };
+            delete publicPage.recordId;
+            const input = {
+                schema: 1,
+                appId: state.appId,
+                objId: formId,
+                name: sourceForms.get(formId).name,
+                page: publicPage,
+                fields: shared.fields,
+                list,
+                layout: shared.layout,
+                formButtons,
+                warnings,
+                buttons: item.kind === 'layout'
+                    ? formButtons[item.mode || 'view']
+                    : normalizeButtons(listButtons, {
+                        appId: state.appId,
+                        objId: formId,
+                        kind: item.kind,
+                        listId: list.listId,
+                        hostPageId: list.hostPageId || '',
+                    }, item.kind),
+            };
+            for (const set of [input.buttons, ...Object.values(input.formButtons)])
+                for (const button of set?.items || [])
+                    button.pageButtonRef = JSON.stringify([item.id, button.buttonRef]);
+            const sanitized = client.clean(input);
+            await atomicJson(formInputPath(store, item.id), sanitized);
+            receipt.sha256 = await fileDigest(formInputPath(store, item.id));
+            receipt.warnings = warnings;
+            receipt.status = 'succeeded';
+        }
+        catch (error) {
+            if (['E10_LOGIN_REQUIRED', 'TEMPORARY_RECORD_STOP'].includes(error.code))
+                return error;
+            receipt.status = 'failed';
+            receipt.error = client.clean(errorInfo(error));
+        }
+        receipt.updatedAt = new Date().toISOString();
+        await atomicJson(collectionPath(store, item.id), receipt);
+        return undefined;
+    };
+    const outcomes = await mapLimit(jobs.filter((j) => j.item.kind !== 'workflow'), state.settings.concurrency, collectMenu);
+    if (!outcomes.some(Boolean) && jobs.some((j) => j.item.kind === 'workflow')) {
+        // A changed directory must invalidate every dependent workflow input, including accepted HTML.
+        try {
+            const catalog = await loadWorkflowCatalog();
+            for (const item of state.formPages) {
+                if (item.kind !== 'workflow' || jobs.some((j) => j.item.id === item.id))
+                    continue;
+                const previous = await formResult(store, item.id);
+                if (await verifiedForm(store, previous)) {
+                    const input = JSON.parse(await fs.readFile(formInputPath(store, item.id), 'utf8'));
+                    if (JSON.stringify(input.workflowCatalog) !== JSON.stringify(client.clean(catalog)))
+                        jobs.push({ item, previous });
+                }
+            }
+        }
+        catch {
+            /* Each workflow receipt records the shared failure below. */
+        }
+        outcomes.push(...(await mapLimit(jobs.filter((j) => j.item.kind === 'workflow'), state.settings.concurrency, collectMenu)));
+    }
+    delete state.archive;
+    await store.save(state);
+    const fatal = outcomes.find(Boolean);
+    if (fatal)
+        throw fatal;
+}

package/dist/html.d.ts

@@ -0,0 +1,22 @@
+import type { HtmlResult, TaskState } from './model.js';
+import { Store } from './store.js';
+export declare function nextHtml(store: Store, s: TaskState): Promise<{
+    state: string;
+    concurrency: number;
+    jobs: any[];
+    html: {
+        required: boolean;
+        succeeded: number;
+        failed: number;
+        running: number;
+        pending: number;
+    };
+    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 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;
+    kind: 'page' | 'form';
+}): Promise<void>;