e10-ebuilder-prototype 0.5.5 → 0.5.7

package/dist/form-behavior.d.ts

@@ -0,0 +1,11 @@
+/** No guesses from labels. This is the fixed execution domain, not a full EBuilder interpreter. */
+export declare function formBehaviorContract(raw: any): {
+    schema: number;
+    menuId: string;
+    objId: string;
+    fields: any;
+    buttons: any[];
+    scopes: any[];
+};
+export declare function formBehaviorRuntime(contract: any): string;
+export declare function attachFormBehavior(source: string, input: any): string;

package/dist/form-behavior.js

@@ -0,0 +1,169 @@
+import { formOptionData } from './form-options.js';
+import { installFormBehavior } from './form-behavior-runtime.mjs';
+const kinds = {
+    Text: 'text',
+    String: 'text',
+    TextArea: 'textarea',
+    Number: 'number',
+    NumberComponent: 'number',
+    Money: 'number',
+    Date: 'date',
+    DateComponent: 'date',
+    Select: 'select',
+    RadioBox: 'radio',
+    Checkbox: 'multi',
+    CheckBox: 'multi',
+    Cascader: 'cascader',
+    Employee: 'entity',
+    Department: 'entity',
+    Ebuilder: 'entity',
+    RelateBrowser: 'entity',
+    Phone: 'tel',
+    Mobile: 'tel',
+    Email: 'email',
+};
+const operations = {
+    tableAdd: 'add',
+    add: 'add',
+    view: 'view',
+    edit: 'edit',
+    tableEdit: 'edit',
+    save: 'save',
+    saveAndCreate: 'saveNew',
+    cancel: 'cancel',
+    tableDelete: 'delete',
+    delete: 'delete',
+};
+const bool = (v, fallback) => v === undefined
+    ? fallback
+    : [true, 1, '1', 'true'].includes(v)
+        ? true
+        : [false, 0, '0', 'false'].includes(v)
+            ? false
+            : undefined;
+const encode = (v) => JSON.stringify(v)
+    .replaceAll('<', '\\u003c')
+    .replaceAll('\u2028', '\\u2028')
+    .replaceAll('\u2029', '\\u2029');
+/** No guesses from labels. This is the fixed execution domain, not a full EBuilder interpreter. */
+export function formBehaviorContract(raw) {
+    const input = formOptionData(raw).context;
+    const fields = (input.fields || []).map((f, i) => {
+        const c = f.config || {}, component = c.componentKey || f.compType || f.type;
+        const issues = [];
+        const flag = (key, value, fallback = false) => {
+            const normalized = bool(value, fallback);
+            if (normalized === undefined)
+                issues.push(`unknown-${key}`);
+            return normalized ?? true; // uncertain constraints cannot silently enable editing
+        };
+        const number = (value, key) => {
+            if (value === undefined || value === null || value === '')
+                return undefined;
+            if (!Number.isFinite(Number(value))) {
+                issues.push(`unknown-${key}`);
+                return undefined;
+            }
+            return Number(value);
+        };
+        const kind = kinds[component] || 'unsupported';
+        if (kind === 'unsupported')
+            issues.push(`unsupported-control:${component}`);
+        if (c.richEditor === true || c.supportHtml === true)
+            issues.push('rich-text-as-plain-text');
+        if (c.isUnique === true || c.unique === true)
+            issues.push('uniqueness-source-service-unavailable');
+        if (c.formula || c.eventGroup || c.condition || c.displayCondition)
+            issues.push('dynamic-field-rule-requires-decision');
+        return {
+            key: String(f.id),
+            source: `/fields/${i}`,
+            id: String(f.id),
+            label: c.title || f.text || f.name || String(f.id),
+            kind,
+            component,
+            group: f.isDetail ? String(f.subFormId || f.groupId) : undefined,
+            readOnly: flag('readonly', c.readOnly ?? c.readonly, !!f.system || kind === 'unsupported'),
+            required: flag('required', c.required ?? c.isRequired),
+            hidden: flag('hidden', c.hidden),
+            multiple: flag('multiple', f.multiSelect ?? (c.isSingle === undefined ? undefined : !bool(c.isSingle, true))),
+            maxLength: number(c.maxLen ?? c.maxLength, 'length'),
+            precision: number(c.pointSize ?? c.precision, 'precision'),
+            min: number(c.min, 'min'),
+            max: number(c.max, 'max'),
+            format: c.format || f.format,
+            options: kind === 'cascader' ? c.options || f.options || [] : f.options || c.options || [],
+            refObjId: f.refObjId,
+            issues,
+        };
+    });
+    // Duplicate field IDs are possible across main/detail groups; keep separate identities.
+    for (const f of fields)
+        if (fields.filter((other) => other.id === f.id).length > 1)
+            f.key = `${f.group || 'main'}:${f.id}`;
+    const buttons = [], scopes = [];
+    for (const [mode, group, source] of [
+        ['list', input.buttons, '/buttons'],
+        ...['add', 'view', 'edit'].map((mode) => [
+            mode,
+            input.formButtons?.[mode],
+            `/formButtons/${mode}`,
+        ]),
+    ]) {
+        scopes.push({ mode, status: group?.status || 'unavailable', source });
+        for (const [i, b] of (group?.items || []).entries()) {
+            const c = b.config || {}, location = `${source}/items/${i}`;
+            const actions = (c.actions || []).map((a, j) => ({
+                source: `${location}/config/actions/${j}`,
+                order: Number(a.showOrder ?? j),
+                enabled: bool(a.deleteType, false) === true
+                    ? false
+                    : bool(a.deleteType, false) === false
+                        ? bool(a.enable, true)
+                        : undefined,
+                op: a.actionType === 'system' &&
+                    !a.url &&
+                    !a.params &&
+                    bool(a.thirdPartyFlag, false) === false &&
+                    bool(a.deleteType, false) === false
+                    ? operations[b.key]
+                    : undefined,
+                conditionRequired: !!(a.conditionId || a.datarule || a.conditionTxt),
+            }));
+            buttons.push({
+                key: location,
+                source: location,
+                id: String(b.id),
+                label: b.name,
+                mode,
+                positions: b.positions,
+                order: b.order,
+                enabled: group?.status === 'ready' &&
+                    bool(b.enabled, true) === true &&
+                    bool(b.hidden, false) === false,
+                conditionRequired: bool(c.conditionEnable, !!c.conditionId) !== false,
+                actions: actions.sort((a, b) => a.order - b.order),
+                issues: !actions.length
+                    ? ['no-configured-action']
+                    : actions.some((a) => !a.op && a.enabled !== false)
+                        ? ['action-requires-decision']
+                        : [],
+            });
+        }
+    }
+    return {
+        schema: 1,
+        menuId: String(input.page?.id || ''),
+        objId: String(input.objId || ''),
+        fields,
+        buttons,
+        scopes,
+    };
+}
+export function formBehaviorRuntime(contract) {
+    return `<script id="e10-form-behavior">(${installFormBehavior.toString()})(${encode(contract)});</script>`;
+}
+export function attachFormBehavior(source, input) {
+    const clean = source.replace(/<script\b[^>]*\bid\s*=\s*["']e10-form-behavior["'][^>]*>[\s\S]*?<\/script\s*>/gi, '');
+    return clean.replace(/<head(?:\s[^>]*)?>/i, (match) => match + formBehaviorRuntime(formBehaviorContract(input)));
+}

package/dist/form-context.d.ts

@@ -1,3 +1,7 @@
 import type { Store } from './store.js';
+export declare function contextParts(value: any, location: string, encode?: (value: any) => string): Generator<{
+    location: string;
+    value: any;
+}>;
 /** 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

@@ -6,21 +6,23 @@ 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) {
+export function* contextParts(value, location, encode = (value) => JSON.stringify(value, null, 2)) {
     if (JSON.stringify(location).length > lineLimit - 96)
         throw new CaptureError('FORM_CONTEXT_LIMIT', '配置属性路径超过宿主可完整读取的单行长度');
-    const encoded = JSON.stringify({ entries: [{ location, value }] }, null, 2);
+    const encoded = encode({ entries: [{ location, value }] });
     if (encoded.length <= limit && encoded.split('\n').every((line) => line.length <= lineLimit)) {
         yield { location, value };
         return;
     }
     if (Array.isArray(value)) {
         for (const [i, item] of value.entries())
-            yield* parts(item, `${location}[${i}]`);
+            yield* contextParts(item, location.startsWith('/') ? `${location}/${i}` : `${location}[${i}]`, encode);
     }
     else if (value && typeof value === 'object') {
         for (const [key, item] of Object.entries(value))
-            yield* parts(item, `${location}.${key}`);
+            yield* contextParts(item, location.startsWith('/')
+                ? `${location}/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`
+                : `${location}.${key}`, encode);
     }
     else if (typeof value === 'string') {
         for (let offset = 0; offset < value.length;) {
@@ -82,7 +84,7 @@ export async function formContext(store, key) {
         batch = [];
     };
     for (const [category, value] of Object.entries(options.context)) {
-        for (const part of parts(value, category)) {
+        for (const part of contextParts(value, category)) {
             if (batch.length && JSON.stringify({ entries: [...batch, part] }, null, 2).length > limit)
                 await flush();
             batch.push(part);

package/dist/form-generation.d.ts

@@ -0,0 +1,24 @@
+import type { Store } from './store.js';
+/** JSON Pointer references always address the decoded source, never encoded `set` paths. */
+export declare function compactConfiguration(input: any): any;
+/** Also used before writing views: a size optimization may never change configuration. */
+export declare function expandConfiguration(input: any): any;
+/** Compact lines are still readable by the host's line-limited Read tool. */
+export declare function generationJson(value: any, depth?: number): string;
+/** Extract structure, never value text, event handlers, scripts or remote resources. */
+export declare function layoutStructure(html: string, fields: any[], name?: string): any;
+export declare function generationView(input: any): {
+    configuration: any;
+    directory: any[];
+    layouts: {
+        location: string;
+        original: string;
+    }[];
+    optionDatasets: {
+        id: string;
+        count: number;
+        locations: string[];
+    }[];
+};
+/** Separate from immutable raw/context views, with digest-verified caching. */
+export declare function formGeneration(store: Store, key: string): Promise<string>;

package/dist/form-generation.js

@@ -0,0 +1,367 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { parse } from 'parse5';
+import { CaptureError, digest, fileDigest, atomicJson } from './common.js';
+import { contextParts, formContext } from './form-context.js';
+import { formInputPath } from './forms.js';
+import { formOptionData } from './form-options.js';
+const pointer = (parent, key) => `${parent}/${String(key).replace(/~/g, '~0').replace(/\//g, '~1')}`;
+const markers = ['$e10Ref', '$e10Base', '$e10Literal'];
+const object = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+/** JSON Pointer references always address the decoded source, never encoded `set` paths. */
+export function compactConfiguration(input) {
+    const exact = new Map();
+    const bases = [];
+    function visit(value, location) {
+        if (value === null || typeof value !== 'object')
+            return value;
+        const raw = JSON.stringify(value);
+        if (raw.length >= 240 && exact.has(raw))
+            return { $e10Ref: exact.get(raw) };
+        let base;
+        let saved = 0;
+        if (object(value) &&
+            !markers.some((k) => Object.hasOwn(value, k)) &&
+            Object.keys(value).length >= 8) {
+            for (const candidate of bases.slice(-120)) {
+                let gain = -120 -
+                    JSON.stringify(Object.keys(candidate.value).filter((k) => !Object.hasOwn(value, k)))
+                        .length;
+                for (const [key, item] of Object.entries(value))
+                    if (candidate.encoded[key] === JSON.stringify(item))
+                        gain += JSON.stringify([key, item]).length;
+                if (gain > saved && gain > raw.length * 0.2) {
+                    base = candidate;
+                    saved = gain;
+                }
+            }
+        }
+        let result;
+        if (base) {
+            result = {
+                $e10Base: base.location,
+                set: Object.fromEntries(Object.entries(value)
+                    .filter(([key, item]) => base.encoded[key] !== JSON.stringify(item))
+                    .map(([key, item]) => [key, visit(item, pointer(location, key))])),
+                remove: Object.keys(base.value).filter((key) => !Object.hasOwn(value, key)),
+            };
+        }
+        else if (Array.isArray(value))
+            result = value.map((item, i) => visit(item, pointer(location, i)));
+        else {
+            const entries = Object.entries(value).map(([key, item]) => [
+                key,
+                visit(item, pointer(location, key)),
+            ]);
+            result = markers.some((key) => Object.hasOwn(value, key))
+                ? { $e10Literal: entries }
+                : Object.fromEntries(entries);
+            if (Object.keys(value).length >= 8 && !markers.some((key) => Object.hasOwn(value, key)))
+                bases.push({
+                    value,
+                    location,
+                    encoded: Object.fromEntries(Object.entries(value).map(([k, v]) => [k, JSON.stringify(v)])),
+                });
+        }
+        // Only completed nodes are eligible: no forward references or base cycles.
+        if (raw.length >= 240)
+            exact.set(raw, location);
+        return result;
+    }
+    return visit(input, '');
+}
+/** Also used before writing views: a size optimization may never change configuration. */
+export function expandConfiguration(input) {
+    const decoded = new Map();
+    function register(value, location) {
+        decoded.set(location, value);
+        if (value && typeof value === 'object')
+            for (const [key, item] of Object.entries(value))
+                register(item, pointer(location, key));
+    }
+    function reference(location) {
+        if (!decoded.has(location))
+            throw new CaptureError('FORM_GENERATION_REFERENCE', '配置视图存在无效的重复引用');
+        return structuredClone(decoded.get(location));
+    }
+    function visit(value, location) {
+        let result = value;
+        if (Array.isArray(value))
+            result = value.map((item, i) => visit(item, pointer(location, i)));
+        else if (object(value)) {
+            if (Object.hasOwn(value, '$e10Ref'))
+                result = reference(value.$e10Ref);
+            else if (Object.hasOwn(value, '$e10Base')) {
+                result = reference(value.$e10Base);
+                for (const key of value.remove)
+                    delete result[key];
+                // Inherited descendants are valid reference targets for later changed values.
+                register(result, location);
+                for (const [key, item] of Object.entries(value.set))
+                    Object.defineProperty(result, key, {
+                        value: visit(item, pointer(location, key)),
+                        enumerable: true,
+                        writable: true,
+                        configurable: true,
+                    });
+            }
+            else
+                result = Object.fromEntries((value.$e10Literal ?? Object.entries(value)).map(([key, item]) => [
+                    key,
+                    visit(item, pointer(location, key)),
+                ]));
+        }
+        register(result, location);
+        return result;
+    }
+    return visit(input, '');
+}
+/** Compact lines are still readable by the host's line-limited Read tool. */
+export function generationJson(value, depth = 0) {
+    const compact = JSON.stringify(value);
+    if (compact.length + depth * 2 <= 1500)
+        return compact;
+    if (!value || typeof value !== 'object')
+        return compact;
+    const pad = '  '.repeat(depth), inner = `${pad}  `;
+    const entries = Array.isArray(value)
+        ? value.map((v) => generationJson(v, depth + 1))
+        : Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}: ${generationJson(v, depth + 1)}`);
+    return `${Array.isArray(value) ? '[' : '{'}\n${entries.map((v) => inner + v).join(',\n')}\n${pad}${Array.isArray(value) ? ']' : '}'}`;
+}
+/** Extract structure, never value text, event handlers, scripts or remote resources. */
+export function layoutStructure(html, fields, name) {
+    const nodes = [], issues = [], visibilityHints = [];
+    const byId = new Map();
+    const labels = new Set([name, ...fields.flatMap((f) => [f.groupName, f.name, f.config?.title])].filter(Boolean));
+    for (const field of fields)
+        byId.set(String(field.id), [...(byId.get(String(field.id)) || []), field]);
+    const text = (n) => n.nodeName === '#text' ? n.value : (n.childNodes || []).map(text).join('');
+    function walk(node, parent, inValue = false, inBoundField = false) {
+        const attrs = Object.fromEntries((node.attrs || []).map((a) => [a.name, a.value]));
+        const classes = attrs.class || '';
+        const span = node.sourceCodeLocation && {
+            start: node.sourceCodeLocation.startOffset,
+            end: node.sourceCodeLocation.endOffset,
+        };
+        if (node.tagName === 'style') {
+            // Hints, not a CSS evaluator. Keep only the specific visibility declarations
+            // and their selector/source range; never force a whole stylesheet fallback.
+            for (const child of node.childNodes || []) {
+                if (child.nodeName !== '#text')
+                    continue;
+                const css = child.value, offset = child.sourceCodeLocation?.startOffset;
+                const seen = new Set();
+                for (const match of css.matchAll(/(?:display\s*:\s*none|visibility\s*:\s*hidden)/gi)) {
+                    const open = css.lastIndexOf('{', match.index), end = css.indexOf('}', match.index);
+                    if (open < 0 || end < 0 || seen.has(open))
+                        continue;
+                    seen.add(open);
+                    const start = Math.max(css.lastIndexOf('}', open - 1), css.lastIndexOf('{', open - 1)) + 1;
+                    visibilityHints.push({
+                        selector: css.slice(start, open).trim(),
+                        declarations: [
+                            ...css.slice(open + 1, end).matchAll(/(?:display|visibility)\s*:[^;}]+/gi),
+                        ].map((m) => m[0]),
+                        ...(offset === undefined
+                            ? {}
+                            : { source: { start: offset + start, end: offset + end + 1 } }),
+                    });
+                }
+            }
+        }
+        if (['script', 'style', 'link', 'template'].includes(node.tagName))
+            return;
+        const fieldIds = [...classes.matchAll(/(?:^|\s)field_([^\s]+)/g)].map((m) => m[1]);
+        const field = fieldIds.length === 1 ? byId.get(fieldIds[0]) : undefined;
+        const heading = /^h[1-6]$/.test(node.tagName || '') ||
+            /(?:^|\s)weapp-form-(?:tab-title-item|widget-title)(?:\s|$)/.test(classes);
+        const structural = /(?:^|\s)weapp-form-(?:layout|column-content|tab-content)(?:\s|$)/.test(classes);
+        const widget = /(?:^|\s)weapp-form-widget(?:\s|$)/.test(classes);
+        const hidden = Object.hasOwn(attrs, 'hidden') ||
+            attrs['aria-hidden'] === 'true' ||
+            /(?:display\s*:\s*none|visibility\s*:\s*hidden)/i.test(attrs.style || '');
+        if (fieldIds.length ||
+            structural ||
+            widget ||
+            hidden ||
+            (heading && !inValue && !inBoundField)) {
+            const type = fieldIds.length
+                ? 'field'
+                : structural
+                    ? 'group'
+                    : widget
+                        ? 'widget'
+                        : hidden
+                            ? 'visibility'
+                            : 'heading';
+            const entry = {
+                order: nodes.length,
+                ...(parent === undefined ? {} : { parent }),
+                type,
+                source: span,
+            };
+            if (classes)
+                entry.classes = classes;
+            // Keep only layout declarations: arbitrary style URLs/text can contain private values.
+            if (attrs.style) {
+                const style = attrs.style
+                    .split(';')
+                    .filter((v) => /^\s*(display|visibility|grid-template-columns|grid-column|flex-direction|flex-wrap|width|height|col(?:umn)?-span)\s*:/i.test(v) && !/url\s*\(|[<>]/i.test(v))
+                    .join(';');
+                if (style)
+                    entry.style = style;
+            }
+            if (hidden)
+                entry.hidden = true;
+            if (fieldIds.length) {
+                entry.fieldIds = fieldIds;
+                entry.bindings = (field || []).map((f) => ({
+                    id: f.id,
+                    groupId: f.groupId,
+                    subFormId: f.subFormId,
+                    isDetail: f.isDetail,
+                    label: f.config?.title || f.name,
+                }));
+                if (fieldIds.length !== 1 || field?.length !== 1)
+                    issues.push({ reason: 'ambiguous-field-binding', source: span, fieldIds });
+            }
+            else if (heading && !inValue && !inBoundField) {
+                const label = text(node).trim();
+                if (labels.has(label))
+                    entry.label = label;
+                else if (label)
+                    issues.push({ reason: 'unverified-heading-text', source: span });
+            }
+            else if (widget && !structural)
+                issues.push({ reason: 'unbound-widget', source: span });
+            parent = nodes.length;
+            nodes.push(entry);
+        }
+        const childValue = inValue || /(?:^|\s)weapp-form-widget-content(?:\s|$)/.test(classes);
+        for (const child of node.childNodes || [])
+            walk(child, parent, childValue, inBoundField || (fieldIds.length === 1 && field?.length === 1));
+    }
+    walk(parse(html, { sourceCodeLocationInfo: true }));
+    if (!nodes.some((n) => n.type === 'field'))
+        issues.push({ reason: 'no-recognized-field-binding' });
+    return JSON.parse(JSON.stringify({
+        sourceSha256: digest(html),
+        nodes,
+        issues,
+        visibilityHints,
+        limits: '结构参考；visibilityHints 仅为静态线索，不推断脚本、CSS选择器或媒体条件计算结果，只对匹配当前结构的规则定向核对；配置显隐仍以字段/按钮条件为准。issues 给出需定向核对的原 HTML 字符范围；不读取整份脚本/CSS，不保留记录值。',
+    }));
+}
+export function generationView(input) {
+    const options = formOptionData(input);
+    const source = structuredClone(options.context);
+    const layouts = [];
+    const directory = [];
+    function describe(form, location) {
+        if (!form || typeof form !== 'object')
+            return;
+        const fields = Array.isArray(form.fields) ? form.fields : [];
+        const groups = new Map();
+        for (const [i, f] of fields.entries()) {
+            const identity = JSON.stringify([f.groupId, f.subFormId, f.isDetail]);
+            if (!groups.has(identity))
+                groups.set(identity, {
+                    groupId: f.groupId,
+                    groupName: f.groupName,
+                    subFormId: f.subFormId,
+                    isDetail: f.isDetail,
+                    fieldCount: 0,
+                    firstField: pointer(pointer(location, 'fields'), i),
+                });
+            groups.get(identity).fieldCount++;
+        }
+        directory.push({
+            location,
+            objId: form.objId,
+            fieldCount: fields.length,
+            fieldsLocation: pointer(location, 'fields'),
+            groups: [...groups.values()],
+            relations: fields.flatMap((f, i) => f.refObjId
+                ? [{ objId: f.refObjId, fieldLocation: pointer(pointer(location, 'fields'), i) }]
+                : []),
+            sections: Object.keys(form)
+                .filter((key) => key !== 'fields')
+                .map((key) => pointer(location, key)),
+        });
+        if (form.layout?.source === 'html-reference' && typeof form.layout.html === 'string') {
+            layouts.push({
+                location: pointer(pointer(location, 'layout'), 'html'),
+                original: form.layout.html,
+            });
+            form.layout.html = { $e10Layout: layoutStructure(form.layout.html, fields, form.name) };
+        }
+    }
+    describe(source, '');
+    if (Array.isArray(source.forms))
+        source.forms.forEach((form, i) => describe(form, `/forms/${i}`));
+    const configuration = compactConfiguration(source);
+    if (!isDeepStrictEqual(expandConfiguration(configuration), source))
+        throw new CaptureError('FORM_GENERATION_INTEGRITY', '配置视图无损校验失败，不能提供不完整输入');
+    return { configuration, directory, layouts, optionDatasets: options.descriptions };
+}
+/** Separate from immutable raw/context views, with digest-verified caching. */
+export async function formGeneration(store, key) {
+    const fallbackPath = await formContext(store, key);
+    const folder = path.join(path.dirname(fallbackPath), 'generation-v1'), indexPath = path.join(folder, 'index.json');
+    const source = formInputPath(store, key), sourceSha256 = await fileDigest(source);
+    const old = await fs
+        .readFile(indexPath, 'utf8')
+        .then(JSON.parse)
+        .catch(() => null);
+    if (old?.schema === 1 &&
+        old.sourceSha256 === sourceSha256 &&
+        Array.isArray(old.fragments) &&
+        old.fragments.length) {
+        const valid = await Promise.all(old.fragments.map(async (f) => typeof f.path === 'string' &&
+            path.basename(f.path) === f.path &&
+            (await fileDigest(path.join(folder, f.path)).catch(() => '')) === f.sha256));
+        if (valid.every(Boolean))
+            return indexPath;
+    }
+    const view = generationView(JSON.parse(await fs.readFile(source, 'utf8')));
+    await fs.mkdir(folder, { recursive: true });
+    const fragments = [], batch = [];
+    async function flush() {
+        if (!batch.length)
+            return;
+        const filename = `config-${fragments.length + 1}.json`, bytes = generationJson({ entries: batch });
+        await fs.writeFile(path.join(folder, filename), bytes, { mode: 0o600 });
+        fragments.push({
+            path: filename,
+            locations: batch.map((v) => v.location),
+            sha256: digest(bytes),
+        });
+        batch.length = 0;
+    }
+    for (const [key, value] of Object.entries(view.configuration)) {
+        for (const entry of contextParts(value, pointer('', key), generationJson)) {
+            if (batch.length && generationJson({ entries: [...batch, entry] }).length > 18000)
+                await flush();
+            batch.push(entry);
+        }
+    }
+    await flush();
+    await atomicJson(indexPath, {
+        schema: 1,
+        source,
+        sourceSha256,
+        fallbackPath,
+        format: '先读 directory，再各读 fragments 一次。entries.location 是编码文档位置；directory 和引用使用原配置 JSON Pointer（~1 为 /，~0 为 ~）。$e10Ref 完全等于目标；$e10Base 复制目标后逐键覆盖 set、删除 remove，不做深合并，遗漏与空值不同。这些是相同元数据的简写，不合并菜单/按钮身份，无需写解码脚本。$e10Literal 保存碰巧同名属性的键值对。所有未知属性、条件、动作和模式差异均保留。$e10Layout 是去除记录值的布局结构，只有 issues/绑定不明时按 source 字符范围定向查 fallbackPath 的原 HTML 分片。长字符串按字符区间拼接；$e10Options 用 E10FormOptions.get(id) 取全量。不要重复读取原始全部分片、runtime 或无关联对象。',
+        directory: view.directory,
+        optionDatasets: view.optionDatasets,
+        layoutSources: view.layouts.map(({ location, original }) => ({
+            location,
+            sha256: digest(original),
+            characters: original.length,
+        })),
+        fragments,
+    });
+    return indexPath;
+}

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', {