weaver-work-cli 0.1.5 → 0.1.7

package/dist/shortcuts/ebuilder-form/host.js

@@ -0,0 +1,1238 @@
+import { randomUUID } from 'node:crypto';
+import { requireE10Session } from '../../internal/e10/context.js';
+import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { ebuilderAuthError, ebuilderBusinessError, ebuilderNetworkError, ebuilderValidationError, } from './errors.js';
+const PUBLIC_API_PREFIX = '/api/ebuilder';
+const API_PREFIX_PATTERN = /^\/api\/ebuilder(?:\d+)?$/u;
+const SUCCESS_CODES = new Set(['0', '200', 'true']);
+const DIRECT_LIST_TYPES = {
+    list: { pageType: 'SEARCH', listKind: 'List' },
+    search: { pageType: 'SEARCH', listKind: 'List' },
+    searchlist: { pageType: 'SEARCH', listKind: 'List' },
+    viewport: { pageType: 'VIEWPORT', listKind: 'NList' },
+    nlist: { pageType: 'VIEWPORT', listKind: 'NList' },
+    view: { pageType: 'VIEWPORT', listKind: 'NList' },
+};
+const OPENAPI_READ_PATHS = {
+    detail: '/form/dataset/v2/getDataById',
+    query: '/form/dataset/v2/getAllData',
+    count: '/form/dataset/v2/getAllDataCount',
+};
+const OPENAPI_WRITE_PATHS = {
+    add: '/form/dataset/v2/saveFormData',
+    update: '/form/dataset/v2/updateFormData',
+    delete: '/form/dataset/v2/deleteData',
+};
+const CUSTOM_READ_PATHS = {
+    detail: '/form/formdata/v2/getFormDataByPk',
+    query: '/form/formdata/v2/getFormDataList',
+    count: '/form/formdata/v2/getFormDataCount',
+};
+const CUSTOM_WRITE_PATHS = {
+    add: '/form/formdata/v2/saveFormData',
+    update: '/form/formdata/v2/updateFormData',
+    delete: '/form/formdata/v2/deleteFormData',
+};
+export function resolveApiPrefix(value) {
+    const raw = (value || PUBLIC_API_PREFIX).trim();
+    if (!API_PREFIX_PATTERN.test(raw)) {
+        throw ebuilderValidationError('api_prefix_invalid', 'apiPrefix 必须是 /api/ebuilder 或 /api/ebuilder{appId}');
+    }
+    return raw;
+}
+export function routeEbuilderPath(apiPrefix, suffix) {
+    const prefix = resolveApiPrefix(apiPrefix);
+    if (!suffix.startsWith('/') || suffix.startsWith('/api/') || suffix.includes('/../')) {
+        throw ebuilderValidationError('path_invalid', 'eBuilder API suffix 必须是以 / 开头且不含 /api 前缀的相对路径');
+    }
+    const routedPrefix = suffix === '/form' || suffix.startsWith('/form/') ? prefix : PUBLIC_API_PREFIX;
+    return routedPrefix + suffix;
+}
+export function parseDirectListUrl(value, expectedOrigin) {
+    const raw = String(value || '').trim();
+    if (!raw)
+        throw ebuilderValidationError('url_required', '缺少页面 URL');
+    const confirmedOrigin = expectedOrigin ? originOnly(expectedOrigin) : originFromUrl(raw);
+    if (!confirmedOrigin)
+        throw ebuilderValidationError('url_origin_required', '相对页面 URL 还需提供当前 E10 origin');
+    const parsed = parseUrl(raw, confirmedOrigin);
+    const urlOrigin = parsed.origin === 'null' ? '' : parsed.origin;
+    if (/^https?:/iu.test(raw) && urlOrigin !== confirmedOrigin) {
+        throw ebuilderValidationError('url_cross_origin', '页面 URL 与当前 origin 不同源');
+    }
+    const entryUrl = /^https?:/iu.test(raw) ? raw : confirmedOrigin + raw;
+    const segments = parsed.pathname.split('/').filter(Boolean);
+    const pathMarkers = segments
+        .map((item) => item.toLowerCase())
+        .filter((item) => DIRECT_LIST_TYPES[item]);
+    if (new Set(pathMarkers.map((item) => DIRECT_LIST_TYPES[item].pageType)).size > 1) {
+        throw ebuilderValidationError('url_type_conflict', '页面 URL 路径同时包含表格和数据列表类型');
+    }
+    let pathType = '';
+    let pathId = '';
+    let pathAppId = '';
+    let pathMenuId = '';
+    if (segments.length >= 2) {
+        const marker = segments[segments.length - 2].toLowerCase();
+        const candidate = segments[segments.length - 1];
+        if (DIRECT_LIST_TYPES[marker]) {
+            if (/^\d+$/u.test(candidate)) {
+                pathType = marker;
+                pathId = candidate;
+            }
+            else {
+                const combined = /^(\d+)_(\d+)$/u.exec(candidate);
+                const menu = /^(\d+)-(\d+)$/u.exec(candidate);
+                if (combined) {
+                    pathType = marker;
+                    pathAppId = combined[1];
+                    pathId = combined[2];
+                }
+                else if (menu
+                    && segments.length >= 4
+                    && ['view', 'detail'].includes(segments[segments.length - 4].toLowerCase())
+                    && /^\d+$/u.test(segments[segments.length - 3])) {
+                    pathType = marker;
+                    pathAppId = segments[segments.length - 3];
+                    pathId = menu[1];
+                    pathMenuId = menu[2];
+                }
+            }
+        }
+    }
+    const lowerParams = lowerSearchParams(parsed);
+    const queryTypes = ['pagetype', 'listkind', 'viewtype']
+        .flatMap((key) => lowerParams.get(key) || [])
+        .map((item) => item.trim().toLowerCase())
+        .filter((item) => DIRECT_LIST_TYPES[item]);
+    let queryType = '';
+    if (queryTypes.length > 0) {
+        if (new Set(queryTypes.map((item) => DIRECT_LIST_TYPES[item].pageType)).size !== 1) {
+            throw ebuilderValidationError('url_type_conflict', '页面 URL 的列表类型参数互相冲突');
+        }
+        queryType = queryTypes[0];
+    }
+    if (pathType && queryType && DIRECT_LIST_TYPES[pathType].pageType !== DIRECT_LIST_TYPES[queryType].pageType) {
+        throw ebuilderValidationError('url_type_conflict', '页面 URL 的路径与 pageType/listKind 类型冲突');
+    }
+    const marker = pathType || queryType;
+    if (!marker)
+        throw ebuilderValidationError('url_type_missing', '无法从页面 URL 识别列表类型；需要 list/search 或 viewport/VIEWPORT');
+    const queryIds = ['pageid', 'listid'].flatMap((key) => lowerParams.get(key) || []).filter(Boolean);
+    if (new Set(queryIds).size > 1)
+        throw ebuilderValidationError('url_id_conflict', '页面 URL 中的 pageId/listId 互相冲突');
+    const queryId = queryIds[0] || '';
+    if (pathId && queryId && pathId !== queryId)
+        throw ebuilderValidationError('url_id_conflict', '页面 URL 路径 ID 与 pageId/listId 参数不一致');
+    const pageId = pathId || queryId;
+    if (!pageId)
+        throw ebuilderValidationError('url_id_missing', '页面 URL 缺少可识别的 pageId/listId');
+    assertDecimalId(pageId, 'URL pageId/listId');
+    const appIds = [];
+    if (pathAppId)
+        appIds.push(pathAppId);
+    appIds.push(...(lowerParams.get('appid') || []));
+    const appPath = /\/(?:sp\/)?ebdapp\/(?:view|detail)\/(\d+)(?:\/|$)/iu.exec(parsed.pathname);
+    if (appPath)
+        appIds.push(appPath[1]);
+    if (new Set(appIds.filter(Boolean)).size > 1)
+        throw ebuilderValidationError('url_app_conflict', '页面 URL 中的 appId 互相冲突');
+    const menuIds = [];
+    if (pathMenuId)
+        menuIds.push(pathMenuId);
+    menuIds.push(...['cusmenuid', 'menuid'].flatMap((key) => lowerParams.get(key) || []));
+    if (new Set(menuIds.filter(Boolean)).size > 1)
+        throw ebuilderValidationError('url_menu_conflict', '页面 URL 中的 menuId/cusMenuId 互相冲突');
+    const type = DIRECT_LIST_TYPES[marker];
+    return {
+        origin: confirmedOrigin,
+        entryUrl,
+        pageId,
+        pageType: type.pageType,
+        listKind: type.listKind,
+        appId: appIds.find(Boolean) || '',
+        menuId: menuIds.find(Boolean) || '',
+    };
+}
+export function encodeNlistCustomConfig(value) {
+    const source = JSON.stringify(value);
+    if (!source)
+        return '';
+    const dictionary = new Map();
+    const output = [];
+    let nextCode = 1 << 16;
+    let current = source[0];
+    function codeFor(token) {
+        const existing = dictionary.get(token);
+        if (existing !== undefined)
+            return existing;
+        if (token.length !== 1)
+            throw ebuilderValidationError('custom_config_invalid', `无法编码 customConfig 片段: ${token}`);
+        const code = token.codePointAt(0);
+        dictionary.set(token, code);
+        return code;
+    }
+    for (const char of Array.from(source.slice(1))) {
+        const combined = current + char;
+        if (dictionary.has(combined)) {
+            current = combined;
+            continue;
+        }
+        output.push(codeFor(current));
+        dictionary.set(combined, nextCode);
+        nextCode += 1;
+        current = char;
+    }
+    output.push(codeFor(current));
+    return output.join(',');
+}
+export function pickEbuilderDataKey(field) {
+    const config = record(field.config);
+    const name = stringValue(field.name);
+    const id = stringValue(field.id);
+    const dataKey = stringValue(config.dataKey);
+    if (name && name !== id)
+        return name;
+    return dataKey || name;
+}
+export function createEbuilderFormHost(ctx) {
+    let e10Session = null;
+    let sessionContext = null;
+    async function ensureSession() {
+        if (!e10Session) {
+            e10Session = await requireE10Session(ctx);
+            sessionContext = {
+                baseUrl: e10Session.getBaseUrl(),
+                profile: ctx.getGlobalOptions().profile || getActiveProfile(),
+                userId: e10Session.userId,
+            };
+        }
+        return e10Session;
+    }
+    async function getSession() {
+        await ensureSession();
+        return sessionContext;
+    }
+    async function runtime() {
+        return createE10RequestRuntime(ctx, await ensureSession(), {});
+    }
+    async function requestJson(options) {
+        assertApiPath(options.path);
+        const response = await (await runtime()).requestJson({
+            module: 'ebuilder-form',
+            operation: options.operation,
+            method: options.method || 'POST',
+            path: options.path,
+            query: options.query,
+            body: options.body,
+            form: options.form,
+            formData: options.formData,
+            headers: options.headers,
+            bigIntStrings: options.bigIntStrings ?? true,
+        });
+        if ([302, 401, 403].includes(response.status)) {
+            throw ebuilderAuthError('session_expired', 'E10 登录态已失效或当前账号无权访问该 eBuilder 数据', { httpStatus: response.status });
+        }
+        if (response.parseError) {
+            throw ebuilderNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw ebuilderBusinessError('http_error', `eBuilder 接口 HTTP ${response.status}`, { code: response.status, details: { message: responseMessage(response.value) } });
+        }
+        return response.value;
+    }
+    async function resolveDeployment(appId) {
+        const id = assertDecimalId(appId, 'appId');
+        const payload = await requestJson({
+            operation: 'ebuilder-form.context.resolve',
+            method: 'GET',
+            path: '/api/ebuilder/form/app/isIndependentDeploy',
+            query: { appId: id },
+        });
+        const data = unwrapWeaData(payload, '独立部署检查');
+        if (typeof data !== 'boolean')
+            throw ebuilderBusinessError('deployment_response_invalid', '独立部署检查 data 不是布尔值');
+        return data ? `/api/ebuilder${id}` : PUBLIC_API_PREFIX;
+    }
+    async function searchMenus(keywords) {
+        const normalized = keywords.map((item) => item.trim()).filter(Boolean).slice(0, 5);
+        if (normalized.length === 0)
+            throw ebuilderValidationError('keywords_required', 'menuKeywords 至少包含一个关键词');
+        const payload = await requestJson({
+            operation: 'ebuilder-form.menu.search',
+            path: '/api/ebuilder/form/viewlist/searchPermittedEbMenus',
+            body: normalized,
+        });
+        const data = unwrapWeaData(payload, '菜单搜索');
+        if (!Array.isArray(data))
+            throw ebuilderBusinessError('menu_response_invalid', '菜单搜索 data 不是数组');
+        return data
+            .filter((item) => Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+            .filter((item) => {
+            const type = stringValue(item.pageType).toUpperCase();
+            return ['SEARCH', 'VIEWPORT'].includes(type) && stringValue(item.pageId) && stringValue(item.appId);
+        });
+    }
+    async function resolveContext(input) {
+        if (input.context && typeof input.context === 'object' && !Array.isArray(input.context)) {
+            return validateContext(input.context);
+        }
+        if (input.url)
+            return resolveUrlContext(input);
+        if (input.menuKeywords || input.menu || input.menuId)
+            return resolveMenuContext(input);
+        return resolveDirectContext(input);
+    }
+    async function resolveMenuContext(input) {
+        const keywords = Array.isArray(input.menuKeywords)
+            ? input.menuKeywords.map((item) => String(item))
+            : Array.isArray(input.menu)
+                ? input.menu.map((item) => String(item))
+                : [String(input.menuKeywords || input.menu || '')];
+        const menuId = stringValue(input.menuId);
+        const menus = await searchMenus(keywords);
+        const menu = selectMenu(menus, keywords, menuId);
+        const appId = assertDecimalId(menu.appId, 'menu.appId');
+        const pageId = assertDecimalId(menu.pageId, 'menu.pageId');
+        const pageType = stringValue(menu.pageType).toUpperCase();
+        const apiPrefix = await resolveDeployment(appId);
+        const target = await resolveListTarget(apiPrefix, appId, pageId, pageType);
+        return validateContext({
+            origin: (await getSession()).baseUrl,
+            appId,
+            apiPrefix,
+            listId: target.listId,
+            hostPageId: pageType === 'VIEWPORT' ? pageId : '',
+            listKind: pageType === 'SEARCH' ? 'List' : 'NList',
+            menuId: stringValue(menu.menuId),
+            menuName: stringValue(menu.menuName || menu.refferName),
+            menuUrl: stringValue(menu.menuUrl),
+            objId: target.objId,
+        });
+    }
+    async function resolveUrlContext(input) {
+        const target = parseDirectListUrl(input.url, (await getSession()).baseUrl);
+        const requestedAppId = stringValue(input.appId);
+        if (requestedAppId && target.appId && requestedAppId !== target.appId) {
+            throw ebuilderValidationError('app_conflict', 'appId 与页面 URL 中的 appId 不一致');
+        }
+        let appId = requestedAppId || target.appId;
+        const requestedPrefix = input.apiPrefix ? resolveApiPrefix(String(input.apiPrefix)) : '';
+        if (requestedPrefix && requestedPrefix !== PUBLIC_API_PREFIX) {
+            const prefixAppId = requestedPrefix.replace(PUBLIC_API_PREFIX, '');
+            if (appId && appId !== prefixAppId)
+                throw ebuilderValidationError('api_prefix_conflict', 'apiPrefix 与页面 URL/输入 appId 不一致');
+            appId = prefixAppId;
+        }
+        let apiPrefix = requestedPrefix;
+        let listId = target.pageId;
+        let objId = '';
+        if (appId) {
+            apiPrefix = apiPrefix || await resolveDeployment(appId);
+            const resolved = await resolveListTarget(apiPrefix, appId, target.pageId, target.pageType);
+            listId = resolved.listId;
+            objId = resolved.objId;
+        }
+        else if (target.pageType === 'SEARCH') {
+            const list = await listInit(PUBLIC_API_PREFIX, target.pageId, '');
+            appId = list.appId;
+            objId = list.objId;
+            apiPrefix = apiPrefix || await resolveDeployment(appId);
+        }
+        else {
+            const page = await viewPageInfo(PUBLIC_API_PREFIX, target.pageId, 'ebuilder-form.context.resolve');
+            const parsed = parseNlistContext(page, '');
+            appId = parsed.appId;
+            listId = parsed.listId;
+            objId = parsed.objId;
+            apiPrefix = apiPrefix || await resolveDeployment(appId);
+        }
+        return validateContext({
+            origin: target.origin,
+            appId,
+            apiPrefix,
+            hostPageId: target.pageType === 'VIEWPORT' ? target.pageId : '',
+            listId,
+            listKind: target.listKind,
+            menuId: target.menuId,
+            entryUrl: target.entryUrl,
+            objId,
+        });
+    }
+    async function resolveDirectContext(input) {
+        const appId = stringValue(input.appId);
+        const apiPrefix = input.apiPrefix ? resolveApiPrefix(String(input.apiPrefix)) : (appId ? await resolveDeployment(appId) : PUBLIC_API_PREFIX);
+        const context = {
+            origin: (await getSession()).baseUrl,
+            appId,
+            apiPrefix,
+            objId: stringValue(input.objId),
+            listId: stringValue(input.listId),
+            hostPageId: stringValue(input.hostPageId),
+            listKind: stringValue(input.listKind),
+            menuUrl: stringValue(input.menuUrl),
+            entryUrl: stringValue(input.entryUrl),
+            menuId: stringValue(input.menuId),
+            menuName: stringValue(input.menuName),
+        };
+        if (!context.objId && context.listId && context.appId && context.listKind === 'List') {
+            const list = await listInit(context.apiPrefix, context.listId, context.appId);
+            context.objId = list.objId;
+        }
+        if ((!context.objId || !context.listId) && context.hostPageId && context.appId && context.listKind === 'NList') {
+            const page = await viewPageInfo(context.apiPrefix, context.hostPageId, 'ebuilder-form.context.resolve');
+            const parsed = parseNlistContext(page, context.appId);
+            context.listId = parsed.listId;
+            context.objId = parsed.objId;
+        }
+        return validateContext(context);
+    }
+    function validateContext(raw) {
+        const apiPrefix = resolveApiPrefix(stringValue(raw.apiPrefix) || PUBLIC_API_PREFIX);
+        const appId = stringValue(raw.appId);
+        if (apiPrefix !== PUBLIC_API_PREFIX) {
+            const prefixAppId = apiPrefix.replace(PUBLIC_API_PREFIX, '');
+            if (appId && prefixAppId !== appId)
+                throw ebuilderValidationError('context_conflict', 'apiPrefix 中的 appId 与 context.appId 不一致');
+        }
+        const objId = stringValue(raw.objId);
+        if (!objId)
+            throw ebuilderValidationError('obj_id_required', 'context.objId 必填');
+        return {
+            origin: stringValue(raw.origin) || sessionContext?.baseUrl || '',
+            appId,
+            apiPrefix,
+            objId: assertDecimalId(objId, 'objId'),
+            listId: optionalDecimalId(raw.listId, 'listId'),
+            hostPageId: optionalDecimalId(raw.hostPageId, 'hostPageId'),
+            listKind: normalizeListKind(raw.listKind),
+            menuId: optionalDecimalId(raw.menuId, 'menuId'),
+            menuName: stringValue(raw.menuName),
+            menuUrl: stringValue(raw.menuUrl),
+            entryUrl: stringValue(raw.entryUrl),
+        };
+    }
+    async function resolveListTarget(apiPrefix, appId, pageId, pageType) {
+        if (pageType === 'SEARCH') {
+            const list = await listInit(apiPrefix, pageId, appId);
+            return { listId: pageId, objId: list.objId };
+        }
+        if (pageType !== 'VIEWPORT')
+            throw ebuilderValidationError('page_type_invalid', `不支持的 pageType: ${pageType}`);
+        const page = await viewPageInfo(apiPrefix, pageId, 'ebuilder-form.context.resolve');
+        const parsed = parseNlistContext(page, appId);
+        return { listId: parsed.listId, objId: parsed.objId };
+    }
+    async function listInit(apiPrefix, listId, expectedAppId) {
+        const payload = await requestJson({
+            operation: 'ebuilder-form.context.resolve',
+            path: routeEbuilderPath(apiPrefix, '/form/list/listInit'),
+            body: { listId },
+        });
+        const data = unwrapWeaData(payload, '表格上下文');
+        const recordData = record(data);
+        const appId = stringValue(recordData.appId);
+        if (expectedAppId && appId && appId !== expectedAppId)
+            throw ebuilderValidationError('app_conflict', '表格上下文 appId 与已确认 appId 不一致');
+        const objId = stringValue(recordData.objid || recordData.objId);
+        if (!objId)
+            throw ebuilderBusinessError('list_context_invalid', '表格上下文缺少 objId');
+        return { appId: appId || expectedAppId, objId, data: recordData };
+    }
+    async function viewPageInfo(apiPrefix, pageId, operation) {
+        return requestJson({
+            operation,
+            method: 'GET',
+            path: routeEbuilderPath(apiPrefix, '/form/viewdesigner/viewPageInfo'),
+            query: { pageId, terminalType: 'PC', entranceType: 'RUN', runType: '' },
+        });
+    }
+    function parseNlistContext(payload, expectedAppId) {
+        unwrapWeaData(payload, '数据列表上下文');
+        const page = unwrapPage(payload);
+        const { component, config } = selectPrimaryNlistComponent(page);
+        const appId = stringValue(page.appId || page.appid);
+        if (expectedAppId && appId && appId !== expectedAppId)
+            throw ebuilderValidationError('app_conflict', '数据列表上下文 appId 与已确认 appId 不一致');
+        const listId = stringValue(config.ebListId);
+        const objId = stringValue(config.objId);
+        if (!listId || !objId)
+            throw ebuilderBusinessError('nlist_context_invalid', 'data.page.comps[1].config 缺少 ebListId 或 objId');
+        return { appId: appId || expectedAppId, listId, objId, page, component, config };
+    }
+    async function formViews(input) {
+        const context = await resolveContext(input);
+        const payload = await requestJson({
+            operation: 'ebuilder-form.views.list',
+            method: 'GET',
+            path: routeEbuilderPath(context.apiPrefix, `/form/viewlist/getViewlist/${context.objId}`),
+            query: { objId: context.objId },
+        });
+        const data = unwrapWeaData(payload, '表单视图');
+        const views = Array.isArray(data) ? data : [];
+        return {
+            context,
+            views: views.filter((item) => {
+                const type = stringValue(item?.viewType || item?.type || item?.pageType).toLowerCase();
+                return type === 'list' || type === 'nlist';
+            }),
+            raw: data,
+        };
+    }
+    async function listConfig(context, operation) {
+        if (!context.listId)
+            throw ebuilderValidationError('list_id_required', 'List 配置需要 listId');
+        const list = await listInit(context.apiPrefix, context.listId, context.appId);
+        const common = { apid: context.appId || list.appId, tpaid: context.listId, objId: context.objId };
+        const conditionId = stringValue(list.data.conditionId);
+        const [baseInfo, listFields, order, search, statistics, condition] = await Promise.all([
+            requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, `/form/list/getBaseInfo/${context.listId}`), query: common }),
+            requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, `/form/list/getListFields/${context.listId}`), query: { ...common, clientType: 'PC', isVirtualForm: 'false' } }),
+            requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, '/form/viewlist/getViewOrder'), query: { ...common, viewType: 'tableView', viewId: context.listId, isVirtualForm: 'false' } }),
+            requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, `/form/listFilter/getSearchFilters/${context.listId}`), query: { ...common, viewType: 'tableView', isVirtualForm: 'false' } }),
+            requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, `/form/listStatistics/getStatisticsList/${context.listId}`), query: { ...common, isVirtualForm: 'false' } }),
+            conditionId
+                ? requestJson({ operation, method: 'GET', path: routeEbuilderPath(context.apiPrefix, '/form/plugin/conditionEditor/getById'), query: { ...common, id: conditionId, type: 'search' } })
+                : Promise.resolve(null),
+        ]);
+        return {
+            context,
+            init: list.data,
+            config: {
+                basicSettings: dataOrRaw(baseInfo),
+                displayColumns: dataOrRaw(listFields),
+                sorting: dataOrRaw(order),
+                search: dataOrRaw(search),
+                statistics: dataOrRaw(statistics),
+                conditions: condition ? { configured: Boolean(dataOrRaw(condition)), rootData: dataOrRaw(condition) } : { configured: false },
+            },
+        };
+    }
+    async function nlistConfig(context, operation) {
+        if (!context.hostPageId)
+            throw ebuilderValidationError('host_page_id_required', 'NList 配置需要 hostPageId');
+        const payload = await viewPageInfo(context.apiPrefix, context.hostPageId, operation);
+        const parsed = parseNlistContext(payload, context.appId);
+        return {
+            context: { ...context, listId: parsed.listId, objId: parsed.objId },
+            page: parsed.page,
+            component: parsed.component,
+            config: parsed.config,
+        };
+    }
+    async function listQuery(input, operation) {
+        const context = await resolveContext({ ...input, listKind: input.listKind || input.context?.listKind || 'List' });
+        if (!context.listId)
+            throw ebuilderValidationError('list_id_required', 'List 分页查询需要 listId');
+        const list = await listInit(context.apiPrefix, context.listId, context.appId);
+        const pageNo = positiveInt(input.pageNo, 'pageNo', 1);
+        const configuredSize = positiveInt(list.data.pageSize, 'listInit.pageSize', 20, 200);
+        const pageSize = pageSizeInt(input.pageSize, configuredSize, 200);
+        const allPages = input.allPages === true;
+        const tableuid = stringValue(input.tableuid) || randomUUID().replace(/-/gu, '');
+        const searchParamData = nonEmptyRecord(input.searchParamData) || { searchType: '2', type: 'and', groupFields: {} };
+        const filterCondition = nonEmptyRecord(input.filterCondition) || {};
+        const passid = stringValue(input.passid) || context.objId;
+        const cid = stringValue(input.cid) || context.objId;
+        const body = {
+            current: pageNo,
+            pageSize,
+            requiredMatch: 1,
+            tableuid,
+            listId: context.listId,
+            searchParamData,
+            isFollow: 0,
+            isShareToMe: 0,
+            filterCondition,
+            terminal: 'PC',
+            ...(Array.isArray(input.orderParams) ? { orderParams: input.orderParams } : {}),
+        };
+        const query = { passid, cid };
+        const firstPage = await requestJson({ operation, path: routeEbuilderPath(context.apiPrefix, '/form/list/getListDatas'), query, body });
+        const totalPayload = await requestJson({ operation, path: routeEbuilderPath(context.apiPrefix, '/form/list/getListDataCount'), query, body });
+        const total = extractListTotal(totalPayload);
+        const pageCount = Math.ceil(total / pageSize);
+        if (allPages && pageCount >= 100) {
+            throw ebuilderValidationError('too_many_pages', '预计需要 100 页或更多，请增加筛选条件或缩小范围', { total, pageSize, pageCount });
+        }
+        const pages = [listPageResult(pageNo, firstPage)];
+        if (allPages) {
+            for (let next = 1; next <= pageCount; next += 1) {
+                if (next === pageNo)
+                    continue;
+                const page = await requestJson({
+                    operation,
+                    path: routeEbuilderPath(context.apiPrefix, '/form/list/getListDatas'),
+                    query,
+                    body: { ...body, current: next },
+                });
+                pages.push(listPageResult(next, page));
+            }
+            pages.sort((a, b) => a.pageNo - b.pageNo);
+        }
+        const rows = pages.flatMap((page) => page.rows);
+        return {
+            context,
+            listUrl: buildListUrl(context),
+            tableuid,
+            columns: pages[0]?.columns || [],
+            pages,
+            rows,
+            pagination: {
+                mainRecordTotal: total,
+                mainPageCount: pageCount,
+                returnedRowCount: rows.length,
+                distinctStableIdCount: new Set(rows.map(stableRowId).filter(Boolean)).size,
+            },
+        };
+    }
+    async function nlistQuery(input, operation) {
+        const context = await resolveContext({ ...input, listKind: input.listKind || input.context?.listKind || 'NList' });
+        if (!context.hostPageId)
+            throw ebuilderValidationError('host_page_id_required', 'NList 分页查询需要 hostPageId');
+        const configResult = await nlistConfig(context, operation);
+        const page = record(configResult.page);
+        const component = record(configResult.component);
+        const config = record(configResult.config);
+        const compId = stringValue(input.compId) || stringValue(component.id || component.compId);
+        if (!compId)
+            throw ebuilderBusinessError('nlist_context_invalid', 'NList 组件缺少 compId');
+        const pageSize = pageSizeInt(input.pageSize, Number(config.pageSize || config.detailPageSize || 10), 200);
+        const pageNo = positiveInt(input.pageNo, 'pageNo', 1);
+        const tableuid = stringValue(input.tableuid) || randomUUID().replace(/-/gu, '');
+        const filter = input.filter === undefined ? [baseNlistFilter(compId)] : input.filter;
+        const fieldFilter = input.fieldFilter === undefined ? {} : input.fieldFilter;
+        const pageFilter = input.pageFilter === undefined ? { filter: {}, filterIsNull: true, esbFilter: [] } : input.pageFilter;
+        const customConfig = nonEmptyRecord(input.customConfig) || { superiorField: { enable: false } };
+        const refPluginPackageId = stringValue(input.refPluginPackageId || config.refPluginPackageId || component.refPluginPackageId) || '933846626099339271';
+        const pageAppId = stringValue(page.appId || page.appid || context.appId);
+        const commonFields = {
+            pageAppId,
+            pageId: context.hostPageId,
+            compId,
+            pageSize,
+            tableuid,
+            filter: JSON.stringify(filter),
+            fieldFilter: JSON.stringify(fieldFilter),
+            pageFilter: JSON.stringify(pageFilter),
+            refPluginPackageId,
+            customConfig: encodeNlistCustomConfig(customConfig),
+        };
+        const firstPage = await requestJson({
+            operation,
+            path: routeEbuilderPath(context.apiPrefix, '/form/eblist/getData'),
+            form: new URLSearchParams({ ...stringifyForm(commonFields), pageNo: String(pageNo) }),
+        });
+        const totalPayload = await requestJson({
+            operation,
+            path: routeEbuilderPath(context.apiPrefix, '/form/eblist/getCount'),
+            query: { passid: context.objId },
+            form: new URLSearchParams({ tableuid, pageId: context.hostPageId, compId, refPluginPackageId }),
+        });
+        const total = extractNlistTotal(totalPayload);
+        const pageCount = Math.ceil(total / pageSize);
+        if (input.allPages === true && pageCount >= 100) {
+            throw ebuilderValidationError('too_many_pages', '预计需要 100 页或更多，请增加筛选条件或缩小范围', { total, pageSize, pageCount });
+        }
+        const pages = [nlistPageResult(pageNo, firstPage)];
+        if (input.allPages === true) {
+            for (let next = 1; next <= pageCount; next += 1) {
+                if (next === pageNo)
+                    continue;
+                const pagePayload = await requestJson({
+                    operation,
+                    path: routeEbuilderPath(context.apiPrefix, '/form/eblist/getData'),
+                    form: new URLSearchParams({ ...stringifyForm(commonFields), pageNo: String(next) }),
+                });
+                pages.push(nlistPageResult(next, pagePayload));
+            }
+            pages.sort((a, b) => a.pageNo - b.pageNo);
+        }
+        const rows = pages.flatMap((pageItem) => pageItem.rows);
+        return {
+            context: { ...context, listId: stringValue(config.ebListId), objId: stringValue(config.objId) },
+            listUrl: buildListUrl(context),
+            tableuid,
+            pages,
+            rows,
+            pagination: {
+                mainRecordTotal: total,
+                mainPageCount: pageCount,
+                returnedRowCount: rows.length,
+                distinctStableIdCount: new Set(rows.map(stableRowId).filter(Boolean)).size,
+            },
+        };
+    }
+    async function fields(input, operation) {
+        const context = await resolveContext(input);
+        const form = new FormData();
+        form.set('groupId', stringValue(input.groupId) || context.appId);
+        form.set('sourceId', stringValue(input.sourceId) || context.objId);
+        form.set('sourceType', stringValue(input.sourceType) || 'FORM');
+        form.set('detailFieldsGroup', String(input.detailFieldsGroup ?? 'true'));
+        form.set('enableMerge', String(input.enableMerge ?? 'true'));
+        form.set('customParam', typeof input.customParam === 'string' ? input.customParam : JSON.stringify(input.customParam ?? { terminal: '' }));
+        form.set('params', typeof input.params === 'string' ? input.params : JSON.stringify(input.params ?? []));
+        return requestJson({
+            operation,
+            path: routeEbuilderPath(context.apiPrefix, '/common/ds/fields'),
+            formData: form,
+            bigIntStrings: true,
+        });
+    }
+    async function options(input, operation) {
+        const context = await resolveContext(input);
+        return requestJson({
+            operation,
+            method: 'GET',
+            path: routeEbuilderPath(context.apiPrefix, '/common/ds/options'),
+            query: {
+                fieldName: assertDecimalId(input.fieldName || input.fieldId, 'fieldName'),
+                objId: stringValue(input.objId) || context.objId,
+                sourceType: stringValue(input.sourceType) || 'FORM',
+                groupId: stringValue(input.groupId) || context.appId,
+                optionLevel: input.optionLevel ?? '1',
+            },
+        });
+    }
+    async function mapping(input, operation) {
+        const context = await resolveContext(input);
+        return requestJson({
+            operation,
+            method: 'GET',
+            path: routeEbuilderPath(context.apiPrefix, '/form/dataset/v1/getTableMapping'),
+            query: { objId: context.objId, reverse: input.reverse === true ? 'true' : 'false' },
+        });
+    }
+    async function browserResolve(input, operation) {
+        const moduleName = cleanPathSegment(input.module, 'module');
+        const browserType = cleanPathSegment(input.browserType, 'browserType');
+        const query = stringValue(input.query);
+        if (!query)
+            throw ebuilderValidationError('query_required', 'query 必填');
+        const payload = {
+            browserMultiple: input.multiple === true,
+            keyword: query,
+            pageNo: 1,
+            pageSize: input.limit ? Math.min(Number(input.limit), 50) : 20,
+            ...(input.extra && typeof input.extra === 'object' && !Array.isArray(input.extra) ? input.extra : {}),
+        };
+        const result = await requestJson({
+            operation,
+            path: `/api/${moduleName}/common/browser/complete/${browserType}`,
+            body: payload,
+            headers: { langtype: 'zh_CN' },
+        });
+        const matches = normalizeBrowserMatches(result, Number(input.limit || 20));
+        const exact = matches.filter((item) => stringValue(item.name).toLowerCase() === query.toLowerCase());
+        const selected = exact.length > 0 ? exact : matches;
+        return {
+            query,
+            browser: { module: moduleName, type: browserType },
+            matchCount: selected.length,
+            unique: selected.length === 1,
+            ambiguous: selected.length > 1,
+            matches: selected,
+        };
+    }
+    async function openapiRead(endpoint, input, operation) {
+        const context = await resolveContext(input);
+        const datajson = openapiReadDatajson(endpoint, context.objId, input);
+        const payload = await requestJson({
+            operation,
+            path: routeEbuilderPath(context.apiPrefix, OPENAPI_READ_PATHS[endpoint]),
+            body: { datajson },
+        });
+        return { context, result: parseOpenapiPayload(payload, endpoint) };
+    }
+    async function openapiWrite(endpoint, datajson, operation) {
+        const context = await resolveContext(datajson.__context && typeof datajson.__context === 'object' ? { context: datajson.__context } : datajson);
+        const payload = stripInternalKeys(datajson);
+        const result = await requestJson({
+            operation,
+            path: routeEbuilderPath(context.apiPrefix, OPENAPI_WRITE_PATHS[endpoint]),
+            body: { datajson: payload },
+        });
+        return { context, result: parseOpenapiPayload(result, endpoint) };
+    }
+    async function customRead(endpoint, input, operation) {
+        const context = await resolveContext(input);
+        const interfacePk = stringValue(input.interfacePk);
+        if (!interfacePk)
+            throw ebuilderValidationError('interface_pk_required', 'interfacePk 必填');
+        const datajson = customReadDatajson(endpoint, input, (await getSession()).userId);
+        const payload = await requestJson({
+            operation,
+            path: `${routeEbuilderPath(context.apiPrefix, CUSTOM_READ_PATHS[endpoint])}/${encodeURIComponent(interfacePk)}`,
+            body: { datajson },
+        });
+        return { context, result: parseCustomPayload(payload, endpoint) };
+    }
+    async function customWrite(endpoint, interfacePk, datajson, operation) {
+        const context = await resolveContext(datajson.__context && typeof datajson.__context === 'object' ? { context: datajson.__context } : datajson);
+        const payload = stripInternalKeys(datajson);
+        const actualInterfacePk = stringValue(interfacePk || datajson.interfacePk);
+        if (!actualInterfacePk)
+            throw ebuilderValidationError('interface_pk_required', 'interfacePk 必填');
+        const result = await requestJson({
+            operation,
+            path: `${routeEbuilderPath(context.apiPrefix, CUSTOM_WRITE_PATHS[endpoint])}/${encodeURIComponent(actualInterfacePk)}`,
+            body: { datajson: payload },
+        });
+        return { context, result: parseCustomPayload(result, endpoint) };
+    }
+    function buildDataUrl(context, dataId, deleted = false) {
+        const base = `${(sessionContext?.baseUrl || context.origin).replace(/\/+$/u, '')}/sp/ebdfpage/card/0/${context.objId}/${dataId}`;
+        return deleted ? `${base}?fromRecycle=1` : base;
+    }
+    function buildListUrl(context) {
+        const origin = (sessionContext?.baseUrl || context.origin).replace(/\/+$/u, '');
+        if (context.entryUrl) {
+            try {
+                return parseDirectListUrl(context.entryUrl, origin).entryUrl;
+            }
+            catch {
+                return context.entryUrl;
+            }
+        }
+        if (context.menuUrl) {
+            try {
+                const parsed = new URL(context.menuUrl, origin);
+                if (parsed.origin === origin)
+                    return parsed.href;
+            }
+            catch {
+                if (context.menuUrl.startsWith('/') && !context.menuUrl.startsWith('//'))
+                    return origin + context.menuUrl;
+            }
+        }
+        if (!context.listId || !context.listKind)
+            return null;
+        return context.listKind === 'NList'
+            ? `${origin}/sp/ebdfpage/viewport/${context.listId}`
+            : `${origin}/sp/ebdfpage/list/${context.listId}`;
+    }
+    return {
+        getSession,
+        requestJson,
+        resolveDeployment,
+        searchMenus,
+        resolveContext,
+        formViews,
+        listConfig,
+        nlistConfig,
+        listQuery,
+        nlistQuery,
+        fields,
+        options,
+        mapping,
+        browserResolve,
+        openapiRead,
+        openapiWrite,
+        customRead,
+        customWrite,
+        buildDataUrl,
+        buildListUrl,
+    };
+}
+function originOnly(raw) {
+    const url = new URL(raw);
+    if (!['http:', 'https:'].includes(url.protocol) || !url.host || url.username || url.password) {
+        throw ebuilderValidationError('origin_invalid', 'E10 origin 必须是完整 http/https 地址，且不能包含用户信息');
+    }
+    return `${url.protocol}//${url.host}`;
+}
+function originFromUrl(raw) {
+    if (!/^https?:/iu.test(raw))
+        return '';
+    return originOnly(raw);
+}
+function parseUrl(raw, base) {
+    try {
+        return /^https?:/iu.test(raw) ? new URL(raw) : new URL(raw, base);
+    }
+    catch {
+        throw ebuilderValidationError('url_invalid', '页面 URL 格式不合法');
+    }
+}
+function lowerSearchParams(url) {
+    const map = new Map();
+    for (const [key, value] of url.searchParams.entries()) {
+        const lower = key.toLowerCase();
+        const list = map.get(lower) || [];
+        list.push(value);
+        map.set(lower, list);
+    }
+    return map;
+}
+function assertApiPath(path) {
+    if (!path.startsWith('/api/') || path.startsWith('//') || path.includes('/../') || /^https?:/iu.test(path)) {
+        throw ebuilderValidationError('path_invalid', 'E10 API 只能调用 /api/ 同源相对路径');
+    }
+    if (path.startsWith('/api/bs/')) {
+        throw ebuilderValidationError('path_forbidden', 'eBuilder 表单模块禁止调用 /api/bs/ 接口');
+    }
+}
+function assertDecimalId(value, field) {
+    const text = stringValue(value);
+    if (!/^\d+$/u.test(text))
+        throw ebuilderValidationError('field_invalid', `${field} 必须是数字 ID 字符串`);
+    return text;
+}
+function optionalDecimalId(value, field) {
+    const text = stringValue(value);
+    if (!text)
+        return undefined;
+    return assertDecimalId(text, field);
+}
+function stringValue(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'object')
+        return '';
+    return String(value).trim();
+}
+function normalizeListKind(value) {
+    const text = stringValue(value).toLowerCase();
+    if (!text)
+        return '';
+    if (text === 'list')
+        return 'List';
+    if (text === 'nlist')
+        return 'NList';
+    throw ebuilderValidationError('list_kind_invalid', 'listKind 只能是 List 或 NList');
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function nonEmptyRecord(value) {
+    const next = record(value);
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function responseMessage(payload) {
+    const root = record(payload);
+    const message = record(root.message);
+    const datajson = record(record(root.data).datajson);
+    for (const value of [root.msg, root.message, message.msg, message.message, datajson.message, datajson.msg]) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim().slice(0, 500);
+    }
+    return '';
+}
+function isSuccessCode(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (value === true || value === 0 || value === 200)
+        return true;
+    return SUCCESS_CODES.has(String(value).trim().toLowerCase());
+}
+function unwrapWeaData(payload, label) {
+    const root = record(payload);
+    const message = record(root.message);
+    const code = root.code ?? message.code;
+    if (!isSuccessCode(code)) {
+        throw ebuilderBusinessError('business_error', `${label} 业务失败：${responseMessage(payload) || String(code)}`, { code: String(code), details: { result: payload } });
+    }
+    if (root.status === false || root.fail === true) {
+        throw ebuilderBusinessError('business_error', `${label} 业务失败：${responseMessage(payload) || 'status=false'}`, { details: { result: payload } });
+    }
+    if (!('data' in root))
+        throw ebuilderBusinessError('response_invalid', `${label} 响应缺少 data`, { details: { result: payload } });
+    return root.data;
+}
+function dataOrRaw(payload) {
+    try {
+        return unwrapWeaData(payload, '配置');
+    }
+    catch {
+        return payload;
+    }
+}
+function selectMenu(menus, keywords, menuId) {
+    if (menuId) {
+        const matches = menus.filter((menu) => stringValue(menu.menuId) === menuId);
+        if (matches.length !== 1)
+            throw ebuilderValidationError('menu_not_unique', `menuId=${menuId} 未唯一命中 eBuilder 菜单`, { candidates: menus.slice(0, 20).map(menuSummary) });
+        return matches[0];
+    }
+    const scored = menus
+        .map((menu) => ({ menu, score: menuScore(menu, keywords) }))
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score);
+    if (scored.length === 0)
+        throw ebuilderValidationError('menu_not_found', '没有找到合适的表格或数据列表菜单', { candidates: menus.slice(0, 20).map(menuSummary) });
+    const best = scored[0].score;
+    const winners = scored.filter((item) => item.score === best);
+    if (winners.length !== 1) {
+        throw ebuilderValidationError('menu_ambiguous', '菜单搜索结果不唯一，请传 menuId 消歧', { candidates: winners.slice(0, 20).map((item) => menuSummary(item.menu)) });
+    }
+    return winners[0].menu;
+}
+function menuScore(menu, keywords) {
+    const labels = [menu.menuName, menu.refferName, menu.menuUrl, menu.pageType]
+        .map((item) => stringValue(item).toLowerCase())
+        .filter(Boolean);
+    return keywords.reduce((score, keyword) => {
+        const needle = keyword.toLowerCase();
+        if (!needle)
+            return score;
+        if (labels.some((label) => label === needle))
+            return score + 4;
+        if (labels.some((label) => label.includes(needle)))
+            return score + 2;
+        return score;
+    }, 0);
+}
+function menuSummary(menu) {
+    return {
+        menuId: stringValue(menu.menuId),
+        menuName: stringValue(menu.menuName),
+        refferName: stringValue(menu.refferName),
+        pageType: stringValue(menu.pageType),
+        pageId: stringValue(menu.pageId),
+        appId: stringValue(menu.appId),
+    };
+}
+function unwrapPage(payload) {
+    let current = unwrapWeaData(payload, '页面配置');
+    for (let index = 0; index < 4; index += 1) {
+        const rec = record(current);
+        if (rec.page && typeof rec.page === 'object')
+            return record(rec.page);
+        if (!rec.data || typeof rec.data !== 'object')
+            break;
+        current = rec.data;
+    }
+    throw ebuilderBusinessError('page_response_invalid', 'viewPageInfo 响应缺少 data.page');
+}
+function selectPrimaryNlistComponent(page) {
+    const comps = Array.isArray(page.comps) ? page.comps : [];
+    const component = record(comps[1]);
+    if (!Object.keys(component).length)
+        throw ebuilderBusinessError('nlist_component_missing', 'data.page.comps[1] 缺失');
+    let config = component.config;
+    if (typeof config === 'string') {
+        try {
+            config = JSON.parse(config);
+        }
+        catch {
+            throw ebuilderBusinessError('nlist_config_invalid', 'data.page.comps[1].config 不是合法 JSON');
+        }
+    }
+    const recordConfig = record(config);
+    if (!Object.keys(recordConfig).length)
+        throw ebuilderBusinessError('nlist_config_missing', 'data.page.comps[1].config 缺失');
+    return { component, config: recordConfig };
+}
+function positiveInt(value, field, fallback, max) {
+    const raw = value === undefined || value === null || value === '' ? fallback : value;
+    const numeric = Number(raw);
+    if (!Number.isInteger(numeric) || numeric < 1)
+        throw ebuilderValidationError('field_invalid', `${field} 必须是正整数`);
+    if (max !== undefined && numeric > max)
+        return max;
+    return numeric;
+}
+function pageSizeInt(value, fallback, max) {
+    const numeric = positiveInt(value, 'pageSize', fallback || 10);
+    if (numeric > max)
+        throw ebuilderValidationError('page_size_too_large', `pageSize 最大为 ${max}`);
+    return numeric;
+}
+function extractListTotal(payload) {
+    const data = record(unwrapWeaData(payload, 'List 总数'));
+    const value = data.total ?? record(data.data).total;
+    const total = Number(value);
+    if (!Number.isInteger(total) || total < 0)
+        throw ebuilderBusinessError('count_invalid', 'getListDataCount.data.total 不是整数');
+    return total;
+}
+function listPageResult(pageNo, payload) {
+    const data = record(unwrapWeaData(payload, 'List 分页'));
+    const displayData = data.displayData;
+    if (Array.isArray(displayData))
+        return { pageNo, rows: displayData, columns: Array.isArray(data.columns) ? data.columns : [] };
+    if (displayData && typeof displayData === 'object')
+        return { pageNo, rows: [], columns: Array.isArray(data.columns) ? data.columns : [], groupedDisplayData: displayData };
+    return { pageNo, rows: [], columns: Array.isArray(data.columns) ? data.columns : [] };
+}
+function extractNlistTotal(payload) {
+    const data = record(unwrapWeaData(payload, 'NList 总数'));
+    const total = Number(data.total);
+    if (!Number.isInteger(total) || total < 0)
+        throw ebuilderBusinessError('count_invalid', 'getCount.data.total 不是整数');
+    return total;
+}
+function nlistPageResult(pageNo, payload) {
+    const data = record(unwrapWeaData(payload, 'NList 分页'));
+    if (!Array.isArray(data.list))
+        throw ebuilderBusinessError('rows_invalid', 'getData.data.list 不是数组');
+    return { pageNo, rows: data.list };
+}
+function stableRowId(row) {
+    const rec = record(row);
+    return stringValue(rec.id || rec.form_data_id || rec.ebrecord_rowkey || rec.rowKey);
+}
+function baseNlistFilter(compId) {
+    return {
+        conditionComId: `${compId}_filter_EXCLUDECACHE`,
+        conditionType: 'and',
+        dataType: 'classification',
+        id: randomUUID().replace(/-/gu, ''),
+        useConfig: true,
+    };
+}
+function stringifyForm(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, item === undefined || item === null ? '' : String(item)]));
+}
+function normalizeBrowserMatches(payload, limit) {
+    const root = record(payload);
+    const candidates = [
+        root.data,
+        record(root.data).data,
+        record(root.data).list,
+        record(root.result).data,
+        root.result,
+    ];
+    const rows = candidates.find(Array.isArray);
+    if (!rows)
+        return [];
+    return rows
+        .filter((item) => Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+        .slice(0, limit)
+        .map((item) => {
+        const id = stringValue(item.id || item.optionId || item.key || item.value);
+        const name = stringValue(item.name || item.content || item.title || item.label);
+        return {
+            id,
+            name,
+            dataOption: { optionId: id, content: name },
+            details: {
+                no: stringValue(item.no || item.code || item.workCode),
+                department: stringValue(item.department || item.departmentName || item.orgName),
+                path: stringValue(item.path || item.fullName || item.fullPath),
+            },
+        };
+    })
+        .filter((item) => item.id || item.name);
+}
+function openapiReadDatajson(endpoint, objId, input) {
+    if (endpoint === 'detail') {
+        return {
+            header: { objId },
+            mainTable: { id: assertDecimalId(input.dataId || record(input.mainTable).id, 'dataId') },
+            operationinfo: {
+                isReturnDetail: input.isReturnDetail ?? 'y',
+                fieldNoFindIgnore: input.fieldNoFindIgnore ?? 'false',
+            },
+        };
+    }
+    if (endpoint === 'query') {
+        return {
+            header: { objId },
+            mainTable: record(input.mainTable),
+            pageInfo: {
+                pageNo: positiveInt(input.pageNo, 'pageNo', 1, 1_000),
+                pageSize: pageSizeInt(input.pageSize, 10, 1_000),
+            },
+            operationinfo: {
+                isReturnDetail: input.isReturnDetail ?? 'n',
+                fieldNoFindIgnore: input.fieldNoFindIgnore ?? 'false',
+            },
+        };
+    }
+    return {
+        header: { objId },
+        mainTable: record(input.mainTable),
+        operationinfo: { fieldNoFindIgnore: input.fieldNoFindIgnore ?? 'false' },
+    };
+}
+function customReadDatajson(endpoint, input, operator) {
+    if (endpoint === 'detail') {
+        return {
+            mainTable: { id: assertDecimalId(input.dataId || record(input.mainTable).id, 'dataId') },
+            header: { operator },
+        };
+    }
+    if (endpoint === 'query') {
+        return {
+            mainTable: record(input.mainTable),
+            pageInfo: {
+                pageNo: String(positiveInt(input.pageNo, 'pageNo', 1)),
+                pageSize: String(pageSizeInt(input.pageSize, 10, 1_000)),
+            },
+            header: { operator },
+        };
+    }
+    return { mainTable: record(input.mainTable), header: { operator } };
+}
+function parseOpenapiPayload(payload, label) {
+    const root = record(payload);
+    const message = record(root.message);
+    if (!isSuccessCode(message.code)) {
+        throw ebuilderBusinessError('business_error', responseMessage(payload) || `OpenAPI ${label} 失败`, { code: stringValue(message.code), details: { result: payload } });
+    }
+    const datajson = record(record(root.data).datajson);
+    if (!Object.keys(datajson).length)
+        throw ebuilderBusinessError('response_invalid', `OpenAPI ${label} 响应缺少 data.datajson`, { details: { result: payload } });
+    if (datajson.status === false) {
+        throw ebuilderBusinessError('business_error', responseMessage(payload) || `OpenAPI ${label} status=false`, { details: { result: payload } });
+    }
+    return {
+        status: datajson.status !== false,
+        message: responseMessage(payload) || 'success',
+        dataIds: normalizeDataIds(datajson.dataIds),
+        datas: datajson.datas,
+        raw: payload,
+    };
+}
+function parseCustomPayload(payload, label) {
+    const root = record(payload);
+    const datajson = record(root.datajson || record(root.data).datajson);
+    if (!Object.keys(datajson).length && !('datajson' in root)) {
+        throw ebuilderBusinessError('response_invalid', `自定义接口 ${label} 响应缺少 datajson`, { details: { result: payload } });
+    }
+    return {
+        status: true,
+        message: responseMessage(payload) || 'success',
+        dataIds: normalizeDataIds(datajson.dataIds),
+        datas: datajson.datas,
+        raw: payload,
+    };
+}
+function normalizeDataIds(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (Array.isArray(value))
+        return value.map((item) => stringValue(item)).filter(Boolean);
+    return String(value).split(',').map((item) => item.trim()).filter(Boolean);
+}
+function stripInternalKeys(value) {
+    const next = { ...value };
+    delete next.__context;
+    delete next.context;
+    delete next.apiPrefix;
+    delete next.appId;
+    delete next.objId;
+    delete next.listId;
+    delete next.hostPageId;
+    delete next.listKind;
+    delete next.menuId;
+    delete next.menuName;
+    delete next.menuUrl;
+    delete next.entryUrl;
+    delete next.url;
+    delete next.menu;
+    delete next.menuKeywords;
+    delete next.interfacePk;
+    delete next.dataId;
+    return next;
+}
+function cleanPathSegment(value, field) {
+    const text = stringValue(value).replace(/^\/+|\/+$/gu, '');
+    if (!/^[A-Za-z0-9_/-]+$/u.test(text) || text.includes('..') || text === '') {
+        throw ebuilderValidationError('field_invalid', `${field} 不是合法接口路径片段`);
+    }
+    return text;
+}