weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/ebuilder-form-V5FG2EHC.js

@@ -0,0 +1,2276 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-DW6AUUKS.js";
+import {
+  getActiveProfile
+} from "./chunk-2GA5ZIQL.js";
+import {
+  CliError,
+  isCliError,
+  toErrorEnvelope
+} from "./chunk-LUSPKZKY.js";
+import "./chunk-BUSC6UAE.js";
+
+// src/shortcuts/ebuilder-form/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/shortcuts/ebuilder-form/continuation.ts
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+// src/shortcuts/ebuilder-form/errors.ts
+var EbuilderFormCliError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  stage;
+  details;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 5 /* InternalError */);
+    this.name = "EbuilderFormCliError";
+    this.type = type;
+    this.subtype = subtype;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.stage = options.stage;
+    this.details = options.details;
+  }
+};
+function ebuilderValidationError(subtype, message, details) {
+  return new EbuilderFormCliError("validation", subtype, message, {
+    details,
+    exitCode: 2 /* UsageError */
+  });
+}
+function ebuilderAuthError(subtype, message, details) {
+  return new EbuilderFormCliError("authentication", subtype, message, {
+    details,
+    exitCode: 3 /* AuthError */
+  });
+}
+function ebuilderBusinessError(subtype, message, options = {}) {
+  return new EbuilderFormCliError("api", subtype, message, {
+    code: options.code,
+    details: options.details,
+    retryable: options.retryable ?? false,
+    stage: options.stage,
+    exitCode: 1 /* GeneralError */
+  });
+}
+function ebuilderNetworkError(subtype, message, options = {}) {
+  return new EbuilderFormCliError("network", subtype, message, {
+    details: options.details,
+    retryable: options.retryable ?? true,
+    stage: options.stage,
+    exitCode: 4 /* NetworkError */
+  });
+}
+function ebuilderConfirmationError(action, details) {
+  return new EbuilderFormCliError("confirmation", "required", "\u8BE5 eBuilder \u8868\u5355\u5199\u64CD\u4F5C\u9700\u8981\u660E\u786E\u786E\u8BA4", {
+    details: { action, ...details },
+    exitCode: 10 /* ConfirmationRequired */
+  });
+}
+
+// src/shortcuts/ebuilder-form/continuation.ts
+function stateRoot(ctx) {
+  const configured = ctx?.config?.path();
+  if (configured) return resolve(configured, "..");
+  return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), ".weaver-work-cli");
+}
+async function loadKey(ctx) {
+  const keysDir = resolve(stateRoot(ctx), "keys");
+  const filename = resolve(keysDir, "ebuilder-form-continuation.key");
+  await mkdir(keysDir, { recursive: true, mode: 448 });
+  if (existsSync(filename)) return readFile(filename);
+  const key = randomBytes(32);
+  try {
+    await writeFile(filename, key, { flag: "wx", mode: 384 });
+    if (process.platform !== "win32") await chmod(filename, 384).catch(() => void 0);
+    return key;
+  } catch {
+    return readFile(filename);
+  }
+}
+function encode(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function signature(payload, key) {
+  return createHmac("sha256", key).update(payload).digest("base64url");
+}
+function createEbuilderFormContinuationSigner(ctx) {
+  return {
+    async issue(payload, ttlMs = 10 * 6e4) {
+      const issuedAt = Date.now();
+      const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+      const sig = signature(body, await loadKey(ctx));
+      return `${body}.${sig}`;
+    },
+    async verify(token, expectedOperation) {
+      if (typeof token !== "string" || !token.includes(".")) {
+        throw ebuilderValidationError("continuation_invalid", "continuation \u65E0\u6548");
+      }
+      const [body, provided] = token.split(".");
+      const expected = signature(body, await loadKey(ctx));
+      const valid = provided.length === expected.length && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+      if (!valid) throw ebuilderValidationError("continuation_invalid", "continuation \u7B7E\u540D\u6821\u9A8C\u5931\u8D25");
+      let value;
+      try {
+        value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+      } catch {
+        throw ebuilderValidationError("continuation_invalid", "continuation \u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+      }
+      if (value.operation !== expectedOperation) {
+        throw ebuilderValidationError("continuation_mismatch", "continuation \u4E0D\u5C5E\u4E8E\u5F53\u524D\u64CD\u4F5C");
+      }
+      if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+        throw ebuilderValidationError("continuation_expired", "continuation \u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+      }
+      return value;
+    }
+  };
+}
+
+// src/shortcuts/ebuilder-form/host.ts
+import { randomUUID } from "node:crypto";
+var PUBLIC_API_PREFIX = "/api/ebuilder";
+var API_PREFIX_PATTERN = /^\/api\/ebuilder(?:\d+)?$/u;
+var SUCCESS_CODES = /* @__PURE__ */ new Set(["0", "200", "true"]);
+var 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" }
+};
+var OPENAPI_READ_PATHS = {
+  detail: "/form/dataset/v2/getDataById",
+  query: "/form/dataset/v2/getAllData",
+  count: "/form/dataset/v2/getAllDataCount"
+};
+var OPENAPI_WRITE_PATHS = {
+  add: "/form/dataset/v2/saveFormData",
+  update: "/form/dataset/v2/updateFormData",
+  delete: "/form/dataset/v2/deleteData"
+};
+var CUSTOM_READ_PATHS = {
+  detail: "/form/formdata/v2/getFormDataByPk",
+  query: "/form/formdata/v2/getFormDataList",
+  count: "/form/formdata/v2/getFormDataCount"
+};
+var CUSTOM_WRITE_PATHS = {
+  add: "/form/formdata/v2/saveFormData",
+  update: "/form/formdata/v2/updateFormData",
+  delete: "/form/formdata/v2/deleteFormData"
+};
+function resolveApiPrefix(value) {
+  const raw = (value || PUBLIC_API_PREFIX).trim();
+  if (!API_PREFIX_PATTERN.test(raw)) {
+    throw ebuilderValidationError("api_prefix_invalid", "apiPrefix \u5FC5\u987B\u662F /api/ebuilder \u6216 /api/ebuilder{appId}");
+  }
+  return raw;
+}
+function routeEbuilderPath(apiPrefix, suffix) {
+  const prefix = resolveApiPrefix(apiPrefix);
+  if (!suffix.startsWith("/") || suffix.startsWith("/api/") || suffix.includes("/../")) {
+    throw ebuilderValidationError("path_invalid", "eBuilder API suffix \u5FC5\u987B\u662F\u4EE5 / \u5F00\u5934\u4E14\u4E0D\u542B /api \u524D\u7F00\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  const routedPrefix = suffix === "/form" || suffix.startsWith("/form/") ? prefix : PUBLIC_API_PREFIX;
+  return routedPrefix + suffix;
+}
+function parseDirectListUrl(value, expectedOrigin) {
+  const raw = String(value || "").trim();
+  if (!raw) throw ebuilderValidationError("url_required", "\u7F3A\u5C11\u9875\u9762 URL");
+  const confirmedOrigin = expectedOrigin ? originOnly(expectedOrigin) : originFromUrl(raw);
+  if (!confirmedOrigin) throw ebuilderValidationError("url_origin_required", "\u76F8\u5BF9\u9875\u9762 URL \u8FD8\u9700\u63D0\u4F9B\u5F53\u524D 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", "\u9875\u9762 URL \u4E0E\u5F53\u524D origin \u4E0D\u540C\u6E90");
+  }
+  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", "\u9875\u9762 URL \u8DEF\u5F84\u540C\u65F6\u5305\u542B\u8868\u683C\u548C\u6570\u636E\u5217\u8868\u7C7B\u578B");
+  }
+  let pathType = "";
+  let pathId = "";
+  let pathAppId = "";
+  let pathMenuId = "";
+  if (segments.length >= 2) {
+    const marker2 = segments[segments.length - 2].toLowerCase();
+    const candidate = segments[segments.length - 1];
+    if (DIRECT_LIST_TYPES[marker2]) {
+      if (/^\d+$/u.test(candidate)) {
+        pathType = marker2;
+        pathId = candidate;
+      } else {
+        const combined = /^(\d+)_(\d+)$/u.exec(candidate);
+        const menu = /^(\d+)-(\d+)$/u.exec(candidate);
+        if (combined) {
+          pathType = marker2;
+          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 = marker2;
+          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", "\u9875\u9762 URL \u7684\u5217\u8868\u7C7B\u578B\u53C2\u6570\u4E92\u76F8\u51B2\u7A81");
+    }
+    queryType = queryTypes[0];
+  }
+  if (pathType && queryType && DIRECT_LIST_TYPES[pathType].pageType !== DIRECT_LIST_TYPES[queryType].pageType) {
+    throw ebuilderValidationError("url_type_conflict", "\u9875\u9762 URL \u7684\u8DEF\u5F84\u4E0E pageType/listKind \u7C7B\u578B\u51B2\u7A81");
+  }
+  const marker = pathType || queryType;
+  if (!marker) throw ebuilderValidationError("url_type_missing", "\u65E0\u6CD5\u4ECE\u9875\u9762 URL \u8BC6\u522B\u5217\u8868\u7C7B\u578B\uFF1B\u9700\u8981 list/search \u6216 viewport/VIEWPORT");
+  const queryIds = ["pageid", "listid"].flatMap((key) => lowerParams.get(key) || []).filter(Boolean);
+  if (new Set(queryIds).size > 1) throw ebuilderValidationError("url_id_conflict", "\u9875\u9762 URL \u4E2D\u7684 pageId/listId \u4E92\u76F8\u51B2\u7A81");
+  const queryId = queryIds[0] || "";
+  if (pathId && queryId && pathId !== queryId) throw ebuilderValidationError("url_id_conflict", "\u9875\u9762 URL \u8DEF\u5F84 ID \u4E0E pageId/listId \u53C2\u6570\u4E0D\u4E00\u81F4");
+  const pageId = pathId || queryId;
+  if (!pageId) throw ebuilderValidationError("url_id_missing", "\u9875\u9762 URL \u7F3A\u5C11\u53EF\u8BC6\u522B\u7684 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", "\u9875\u9762 URL \u4E2D\u7684 appId \u4E92\u76F8\u51B2\u7A81");
+  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", "\u9875\u9762 URL \u4E2D\u7684 menuId/cusMenuId \u4E92\u76F8\u51B2\u7A81");
+  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) || ""
+  };
+}
+function encodeNlistCustomConfig(value) {
+  const source = JSON.stringify(value);
+  if (!source) return "";
+  const dictionary = /* @__PURE__ */ new Map();
+  const output = [];
+  let nextCode = 1 << 16;
+  let current = source[0];
+  function codeFor(token) {
+    const existing = dictionary.get(token);
+    if (existing !== void 0) return existing;
+    if (token.length !== 1) throw ebuilderValidationError("custom_config_invalid", `\u65E0\u6CD5\u7F16\u7801 customConfig \u7247\u6BB5: ${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(",");
+}
+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(options2) {
+    assertApiPath(options2.path);
+    const response = await (await runtime()).requestJson({
+      module: "ebuilder-form",
+      operation: options2.operation,
+      method: options2.method || "POST",
+      path: options2.path,
+      query: options2.query,
+      body: options2.body,
+      form: options2.form,
+      formData: options2.formData,
+      headers: options2.headers,
+      bigIntStrings: options2.bigIntStrings ?? true
+    });
+    if ([302, 401, 403].includes(response.status)) {
+      throw ebuilderAuthError("session_expired", "E10 \u767B\u5F55\u6001\u5DF2\u5931\u6548\u6216\u5F53\u524D\u8D26\u53F7\u65E0\u6743\u8BBF\u95EE\u8BE5 eBuilder \u6570\u636E", { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      throw ebuilderNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw ebuilderBusinessError("http_error", `eBuilder \u63A5\u53E3 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, "\u72EC\u7ACB\u90E8\u7F72\u68C0\u67E5");
+    if (typeof data !== "boolean") throw ebuilderBusinessError("deployment_response_invalid", "\u72EC\u7ACB\u90E8\u7F72\u68C0\u67E5 data \u4E0D\u662F\u5E03\u5C14\u503C");
+    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 \u81F3\u5C11\u5305\u542B\u4E00\u4E2A\u5173\u952E\u8BCD");
+    const payload = await requestJson({
+      operation: "ebuilder-form.menu.search",
+      path: "/api/ebuilder/form/viewlist/searchPermittedEbMenus",
+      body: normalized
+    });
+    const data = unwrapWeaData(payload, "\u83DC\u5355\u641C\u7D22");
+    if (!Array.isArray(data)) throw ebuilderBusinessError("menu_response_invalid", "\u83DC\u5355\u641C\u7D22 data \u4E0D\u662F\u6570\u7EC4");
+    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 \u4E0E\u9875\u9762 URL \u4E2D\u7684 appId \u4E0D\u4E00\u81F4");
+    }
+    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 \u4E0E\u9875\u9762 URL/\u8F93\u5165 appId \u4E0D\u4E00\u81F4");
+      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 \u4E2D\u7684 appId \u4E0E context.appId \u4E0D\u4E00\u81F4");
+    }
+    const objId = stringValue(raw.objId);
+    if (!objId) throw ebuilderValidationError("obj_id_required", "context.objId \u5FC5\u586B");
+    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", `\u4E0D\u652F\u6301\u7684 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, "\u8868\u683C\u4E0A\u4E0B\u6587");
+    const recordData = record(data);
+    const appId = stringValue(recordData.appId);
+    if (expectedAppId && appId && appId !== expectedAppId) throw ebuilderValidationError("app_conflict", "\u8868\u683C\u4E0A\u4E0B\u6587 appId \u4E0E\u5DF2\u786E\u8BA4 appId \u4E0D\u4E00\u81F4");
+    const objId = stringValue(recordData.objid || recordData.objId);
+    if (!objId) throw ebuilderBusinessError("list_context_invalid", "\u8868\u683C\u4E0A\u4E0B\u6587\u7F3A\u5C11 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, "\u6570\u636E\u5217\u8868\u4E0A\u4E0B\u6587");
+    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", "\u6570\u636E\u5217\u8868\u4E0A\u4E0B\u6587 appId \u4E0E\u5DF2\u786E\u8BA4 appId \u4E0D\u4E00\u81F4");
+    const listId = stringValue(config.ebListId);
+    const objId = stringValue(config.objId);
+    if (!listId || !objId) throw ebuilderBusinessError("nlist_context_invalid", "data.page.comps[1].config \u7F3A\u5C11 ebListId \u6216 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, "\u8868\u5355\u89C6\u56FE");
+    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 \u914D\u7F6E\u9700\u8981 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 \u914D\u7F6E\u9700\u8981 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 \u5206\u9875\u67E5\u8BE2\u9700\u8981 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", "\u9884\u8BA1\u9700\u8981 100 \u9875\u6216\u66F4\u591A\uFF0C\u8BF7\u589E\u52A0\u7B5B\u9009\u6761\u4EF6\u6216\u7F29\u5C0F\u8303\u56F4", { 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 \u5206\u9875\u67E5\u8BE2\u9700\u8981 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 \u7EC4\u4EF6\u7F3A\u5C11 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 === void 0 ? [baseNlistFilter(compId)] : input.filter;
+    const fieldFilter = input.fieldFilter === void 0 ? {} : input.fieldFilter;
+    const pageFilter = input.pageFilter === void 0 ? { 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", "\u9884\u8BA1\u9700\u8981 100 \u9875\u6216\u66F4\u591A\uFF0C\u8BF7\u589E\u52A0\u7B5B\u9009\u6761\u4EF6\u6216\u7F29\u5C0F\u8303\u56F4", { 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 \u5FC5\u586B");
+    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 \u5FC5\u586B");
+    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 \u5FC5\u586B");
+    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 \u5FC5\u987B\u662F\u5B8C\u6574 http/https \u5730\u5740\uFF0C\u4E14\u4E0D\u80FD\u5305\u542B\u7528\u6237\u4FE1\u606F");
+  }
+  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", "\u9875\u9762 URL \u683C\u5F0F\u4E0D\u5408\u6CD5");
+  }
+}
+function lowerSearchParams(url) {
+  const map = /* @__PURE__ */ 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 \u53EA\u80FD\u8C03\u7528 /api/ \u540C\u6E90\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  if (path.startsWith("/api/bs/")) {
+    throw ebuilderValidationError("path_forbidden", "eBuilder \u8868\u5355\u6A21\u5757\u7981\u6B62\u8C03\u7528 /api/bs/ \u63A5\u53E3");
+  }
+}
+function assertDecimalId(value, field) {
+  const text = stringValue(value);
+  if (!/^\d+$/u.test(text)) throw ebuilderValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u6570\u5B57 ID \u5B57\u7B26\u4E32`);
+  return text;
+}
+function optionalDecimalId(value, field) {
+  const text = stringValue(value);
+  if (!text) return void 0;
+  return assertDecimalId(text, field);
+}
+function stringValue(value) {
+  if (value === void 0 || 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 \u53EA\u80FD\u662F List \u6216 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 : void 0;
+}
+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 === void 0 || 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} \u4E1A\u52A1\u5931\u8D25\uFF1A${responseMessage(payload) || String(code)}`, { code: String(code), details: { result: payload } });
+  }
+  if (root.status === false || root.fail === true) {
+    throw ebuilderBusinessError("business_error", `${label} \u4E1A\u52A1\u5931\u8D25\uFF1A${responseMessage(payload) || "status=false"}`, { details: { result: payload } });
+  }
+  if (!("data" in root)) throw ebuilderBusinessError("response_invalid", `${label} \u54CD\u5E94\u7F3A\u5C11 data`, { details: { result: payload } });
+  return root.data;
+}
+function dataOrRaw(payload) {
+  try {
+    return unwrapWeaData(payload, "\u914D\u7F6E");
+  } 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} \u672A\u552F\u4E00\u547D\u4E2D eBuilder \u83DC\u5355`, { 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", "\u6CA1\u6709\u627E\u5230\u5408\u9002\u7684\u8868\u683C\u6216\u6570\u636E\u5217\u8868\u83DC\u5355", { 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", "\u83DC\u5355\u641C\u7D22\u7ED3\u679C\u4E0D\u552F\u4E00\uFF0C\u8BF7\u4F20 menuId \u6D88\u6B67", { 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, "\u9875\u9762\u914D\u7F6E");
+  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 \u54CD\u5E94\u7F3A\u5C11 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] \u7F3A\u5931");
+  let config = component.config;
+  if (typeof config === "string") {
+    try {
+      config = JSON.parse(config);
+    } catch {
+      throw ebuilderBusinessError("nlist_config_invalid", "data.page.comps[1].config \u4E0D\u662F\u5408\u6CD5 JSON");
+    }
+  }
+  const recordConfig = record(config);
+  if (!Object.keys(recordConfig).length) throw ebuilderBusinessError("nlist_config_missing", "data.page.comps[1].config \u7F3A\u5931");
+  return { component, config: recordConfig };
+}
+function positiveInt(value, field, fallback, max) {
+  const raw = value === void 0 || value === null || value === "" ? fallback : value;
+  const numeric = Number(raw);
+  if (!Number.isInteger(numeric) || numeric < 1) throw ebuilderValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+  if (max !== void 0 && 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 \u6700\u5927\u4E3A ${max}`);
+  return numeric;
+}
+function extractListTotal(payload) {
+  const data = record(unwrapWeaData(payload, "List \u603B\u6570"));
+  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 \u4E0D\u662F\u6574\u6570");
+  return total;
+}
+function listPageResult(pageNo, payload) {
+  const data = record(unwrapWeaData(payload, "List \u5206\u9875"));
+  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 \u603B\u6570"));
+  const total = Number(data.total);
+  if (!Number.isInteger(total) || total < 0) throw ebuilderBusinessError("count_invalid", "getCount.data.total \u4E0D\u662F\u6574\u6570");
+  return total;
+}
+function nlistPageResult(pageNo, payload) {
+  const data = record(unwrapWeaData(payload, "NList \u5206\u9875"));
+  if (!Array.isArray(data.list)) throw ebuilderBusinessError("rows_invalid", "getData.data.list \u4E0D\u662F\u6570\u7EC4");
+  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 === void 0 || 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, 1e3),
+        pageSize: pageSizeInt(input.pageSize, 10, 1e3)
+      },
+      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, 1e3))
+      },
+      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} \u5931\u8D25`, { 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} \u54CD\u5E94\u7F3A\u5C11 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", `\u81EA\u5B9A\u4E49\u63A5\u53E3 ${label} \u54CD\u5E94\u7F3A\u5C11 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 === void 0 || 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} \u4E0D\u662F\u5408\u6CD5\u63A5\u53E3\u8DEF\u5F84\u7247\u6BB5`);
+  }
+  return text;
+}
+
+// src/shortcuts/ebuilder-form/manifest.ts
+var contextProperties = {
+  context: { type: "object", description: "\u5DF2\u89E3\u6790\u7684 eBuilder \u4E0A\u4E0B\u6587\uFF0C\u53EF\u7531 ebuilder-form.context.resolve \u8FD4\u56DE" },
+  menuKeywords: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 5 },
+  menu: { type: "string" },
+  menuId: { type: "string", pattern: "^\\d+$" },
+  url: { type: "string", description: "E10 \u5217\u8868\u9875\u9762 URL\uFF1B\u652F\u6301 /sp/ebdfpage/list\u3001viewport \u548C /ebdapp/view" },
+  appId: { type: "string", pattern: "^\\d+$" },
+  apiPrefix: { type: "string", pattern: "^/api/ebuilder\\d*$" },
+  objId: { type: "string", pattern: "^\\d+$" },
+  listId: { type: "string", pattern: "^\\d+$" },
+  hostPageId: { type: "string", pattern: "^\\d+$" },
+  listKind: { type: "string", enum: ["List", "NList"] },
+  menuUrl: { type: "string" },
+  entryUrl: { type: "string" }
+};
+var preparedWriteProperties = {
+  confirm: { const: true },
+  continuation: { type: "string", minLength: 1 }
+};
+function schema(properties, options = {}) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    ...options.required?.length ? { required: options.required } : {},
+    ...options.anyOf ? { anyOf: options.anyOf } : {},
+    ...options.oneOf ? { oneOf: options.oneOf } : {},
+    ...options.description ? { description: options.description } : {}
+  };
+}
+var ebuilderFormOperations = [
+  {
+    name: "ebuilder-form.menu.search",
+    summary: "\u6309\u4E1A\u52A1\u5173\u952E\u8BCD\u67E5\u8BE2\u5F53\u524D\u8D26\u53F7\u6709\u6743\u9650\u8BBF\u95EE\u7684 eBuilder \u8868\u683C/\u6570\u636E\u5217\u8868\u83DC\u5355",
+    risk: "read",
+    inputSchema: schema({
+      menuKeywords: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 5 }
+    }, { required: ["menuKeywords"] })
+  },
+  {
+    name: "ebuilder-form.context.resolve",
+    summary: "\u4ECE\u83DC\u5355\u5173\u952E\u8BCD\u3001\u9875\u9762 URL\u3001objId \u6216\u73B0\u6709 context \u89E3\u6790 appId\u3001apiPrefix\u3001listId\u3001objId \u548C\u9875\u9762\u5730\u5740\u4E0A\u4E0B\u6587",
+    risk: "read",
+    inputSchema: schema(contextProperties, {
+      anyOf: [
+        { required: ["context"] },
+        { required: ["url"] },
+        { required: ["menuKeywords"] },
+        { required: ["menu"] },
+        { required: ["objId"] },
+        { required: ["listId", "appId", "listKind"] }
+      ]
+    })
+  },
+  {
+    name: "ebuilder-form.views.list",
+    summary: "\u679A\u4E3E\u67D0\u4E2A\u8868\u5355\u5BF9\u8C61\u4E0B\u7684 List/NList \u89C6\u56FE",
+    risk: "read",
+    inputSchema: schema(contextProperties, { required: ["objId"] })
+  },
+  {
+    name: "ebuilder-form.list.config",
+    summary: "\u8BFB\u53D6\u4F20\u7EDF\u8868\u683C List \u7684\u57FA\u7840\u8BBE\u7F6E\u3001\u663E\u793A\u5217\u3001\u6392\u5E8F\u3001\u641C\u7D22\u3001\u7EDF\u8BA1\u548C\u56FA\u5B9A\u6761\u4EF6\u914D\u7F6E",
+    risk: "read",
+    inputSchema: schema(contextProperties, {
+      anyOf: [{ required: ["context"] }, { required: ["listId", "appId"] }, { required: ["menuKeywords"] }, { required: ["url"] }]
+    })
+  },
+  {
+    name: "ebuilder-form.list.query",
+    summary: "\u6309 List \u8FD0\u884C\u65F6\u63A5\u53E3\u67E5\u8BE2\u5206\u9875\u6570\u636E\u548C\u771F\u5B9E\u603B\u6570\uFF0C\u4FDD\u7559\u660E\u7EC6\u5C55\u5F00\u91CD\u590D\u884C",
+    risk: "read",
+    inputSchema: schema({
+      ...contextProperties,
+      pageNo: { type: "integer", minimum: 1, default: 1 },
+      pageSize: { type: "integer", minimum: 1, maximum: 200 },
+      allPages: { type: "boolean", default: false },
+      tableuid: { type: "string" },
+      searchParamData: { type: "object" },
+      filterCondition: { type: "object" },
+      orderParams: { type: "array" },
+      passid: { type: "string" },
+      cid: { type: "string" }
+    })
+  },
+  {
+    name: "ebuilder-form.nlist.config",
+    summary: "\u8BFB\u53D6\u6570\u636E\u5217\u8868 NList \u7684\u9875\u9762\u3001\u7EC4\u4EF6\u4E0E comps[1].config \u8FD0\u884C\u65F6\u914D\u7F6E",
+    risk: "read",
+    inputSchema: schema(contextProperties, {
+      anyOf: [{ required: ["context"] }, { required: ["hostPageId", "appId"] }, { required: ["menuKeywords"] }, { required: ["url"] }]
+    })
+  },
+  {
+    name: "ebuilder-form.nlist.query",
+    summary: "\u6309 NList eblist \u8FD0\u884C\u65F6\u63A5\u53E3\u67E5\u8BE2\u5206\u9875\u6570\u636E\u548C\u771F\u5B9E\u603B\u6570\uFF0C\u4F7F\u7528 customConfig LZW \u6570\u5B57\u4E32\u7F16\u7801",
+    risk: "read",
+    inputSchema: schema({
+      ...contextProperties,
+      pageNo: { type: "integer", minimum: 1, default: 1 },
+      pageSize: { type: "integer", minimum: 1, maximum: 200 },
+      allPages: { type: "boolean", default: false },
+      compId: { type: "string" },
+      tableuid: { type: "string" },
+      filter: {},
+      fieldFilter: {},
+      pageFilter: {},
+      customConfig: { type: "object" },
+      refPluginPackageId: { type: "string" }
+    })
+  },
+  {
+    name: "ebuilder-form.fields.get",
+    summary: "\u8BFB\u53D6 eBuilder \u5B57\u6BB5\u5B9A\u4E49\uFF0C\u8FD4\u56DE\u4E3B\u8868\u4E0E\u660E\u7EC6\u8868\u5B57\u6BB5\u3001config.dataKey\u3001browserParams \u548C\u7EC4\u4EF6\u7C7B\u578B",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/common/ds/fields" },
+    inputSchema: schema({
+      ...contextProperties,
+      groupId: { type: "string" },
+      sourceId: { type: "string" },
+      sourceType: { type: "string", default: "FORM" },
+      detailFieldsGroup: { type: ["boolean", "string"], default: true },
+      enableMerge: { type: ["boolean", "string"], default: true },
+      customParam: {},
+      params: {}
+    })
+  },
+  {
+    name: "ebuilder-form.options.get",
+    summary: "\u6309\u5B57\u6BB5\u5143\u6570\u636E ID \u8BFB\u53D6\u9009\u62E9\u7C7B\u5B57\u6BB5\u9009\u9879",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/common/ds/options" },
+    inputSchema: schema({
+      ...contextProperties,
+      fieldName: { type: "string", pattern: "^\\d+$" },
+      fieldId: { type: "string", pattern: "^\\d+$" },
+      sourceType: { type: "string", default: "FORM" },
+      groupId: { type: "string" },
+      optionLevel: { type: ["integer", "string"], default: 1 }
+    }, {
+      anyOf: [{ required: ["fieldName"] }, { required: ["fieldId"] }]
+    })
+  },
+  {
+    name: "ebuilder-form.mapping.get",
+    summary: "\u8BFB\u53D6 objId \u7684 mainTable/detailN \u4E0E\u4E3B\u8868/\u660E\u7EC6\u8868\u6807\u8BC6\u6620\u5C04",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/dataset/v1/getTableMapping" },
+    inputSchema: schema({
+      ...contextProperties,
+      reverse: { type: "boolean", default: false }
+    }, { required: ["objId"] })
+  },
+  {
+    name: "ebuilder-form.browser.resolve",
+    summary: "\u8C03\u7528\u5B57\u6BB5\u914D\u7F6E\u6216\u5DF2\u77E5\u6A21\u5757\u5BF9\u5E94\u7684\u901A\u7528\u6D4F\u89C8 complete \u63A5\u53E3\uFF0C\u5C06\u540D\u79F0\u89E3\u6790\u4E3A\u53EF\u9009\u9879 ID",
+    risk: "read",
+    inputSchema: schema({
+      module: { type: "string", description: "\u6D4F\u89C8\u63A5\u53E3\u6A21\u5757\uFF0C\u4F8B\u5982 hrm\u3001workflow/core\u3001doc\u3001task" },
+      browserType: { type: "string", description: "\u6D4F\u89C8\u7C7B\u578B\uFF0C\u4F8B\u5982 resource\u3001department\u3001wfcRequest" },
+      query: { type: "string", minLength: 1 },
+      multiple: { type: "boolean", default: false },
+      limit: { type: "integer", minimum: 1, maximum: 50, default: 20 },
+      extra: { type: "object" }
+    }, { required: ["module", "browserType", "query"] })
+  },
+  {
+    name: "ebuilder-form.openapi.detail",
+    summary: "OpenAPI getDataById \u83B7\u53D6\u5355\u6761\u8868\u5355\u6570\u636E\u8BE6\u60C5",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/dataset/v2/getDataById" },
+    inputSchema: schema({
+      ...contextProperties,
+      dataId: { type: "string", pattern: "^\\d+$" },
+      isReturnDetail: { type: ["boolean", "string"], default: "y" },
+      fieldNoFindIgnore: { type: ["boolean", "string"], default: "false" }
+    }, { required: ["objId", "dataId"] })
+  },
+  {
+    name: "ebuilder-form.openapi.query",
+    summary: "OpenAPI getAllData \u8868\u5355\u7EA7\u5206\u9875\u67E5\u8BE2",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/dataset/v2/getAllData" },
+    inputSchema: schema({
+      ...contextProperties,
+      mainTable: { type: "object" },
+      pageNo: { type: "integer", minimum: 1, default: 1 },
+      pageSize: { type: "integer", minimum: 1, maximum: 1e3, default: 10 },
+      isReturnDetail: { type: ["boolean", "string"], default: "n" },
+      fieldNoFindIgnore: { type: ["boolean", "string"], default: "false" }
+    }, { required: ["objId"] })
+  },
+  {
+    name: "ebuilder-form.openapi.count",
+    summary: "OpenAPI getAllDataCount \u8868\u5355\u7EA7\u603B\u6570\u67E5\u8BE2",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/dataset/v2/getAllDataCount" },
+    inputSchema: schema({
+      ...contextProperties,
+      mainTable: { type: "object" },
+      fieldNoFindIgnore: { type: ["boolean", "string"], default: "false" }
+    }, { required: ["objId"] })
+  },
+  {
+    name: "ebuilder-form.openapi.add.prepare",
+    summary: "\u51C6\u5907 OpenAPI saveFormData \u65B0\u589E\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation\uFF0C\u4E0D\u5199\u5165",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      datas: { type: "array", minItems: 1 },
+      operationinfo: { type: "object" }
+    }, { required: ["objId", "datas"] })
+  },
+  {
+    name: "ebuilder-form.openapi.add.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C OpenAPI saveFormData \u65B0\u589E\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  },
+  {
+    name: "ebuilder-form.openapi.update.prepare",
+    summary: "\u51C6\u5907 OpenAPI updateFormData \u4FEE\u6539\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation\uFF0C\u4E0D\u5199\u5165",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      datas: { type: "array", minItems: 1 },
+      operationinfo: { type: "object" }
+    }, { required: ["objId", "datas"] })
+  },
+  {
+    name: "ebuilder-form.openapi.update.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C OpenAPI updateFormData \u4FEE\u6539\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  },
+  {
+    name: "ebuilder-form.openapi.delete.prepare",
+    summary: "\u51C6\u5907 OpenAPI deleteData \u5220\u9664\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation\uFF0C\u4E0D\u5199\u5165",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      mainTable: { type: "object", description: '\u5220\u9664\u6761\u4EF6\uFF1B\u6309\u6570\u636E ID \u5220\u9664\u65F6\u4F20 {"id":"..."}' },
+      dataId: { type: "string", pattern: "^\\d+$" },
+      operationinfo: { type: "object" }
+    }, {
+      required: ["objId"],
+      anyOf: [{ required: ["dataId"] }, { required: ["mainTable"] }]
+    })
+  },
+  {
+    name: "ebuilder-form.openapi.delete.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C OpenAPI deleteData \u5220\u9664\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  },
+  {
+    name: "ebuilder-form.custom.detail",
+    summary: "\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 getFormDataByPk \u6839\u636E\u4E3B\u952E\u67E5\u8BE2\u8BE6\u60C5",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/formdata/v2/getFormDataByPk/{interfacePk}" },
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      dataId: { type: "string", pattern: "^\\d+$" }
+    }, { required: ["interfacePk", "dataId"] })
+  },
+  {
+    name: "ebuilder-form.custom.query",
+    summary: "\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 getFormDataList \u5206\u9875\u67E5\u8BE2",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/formdata/v2/getFormDataList/{interfacePk}" },
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      mainTable: { type: "object" },
+      pageNo: { type: "integer", minimum: 1, default: 1 },
+      pageSize: { type: "integer", minimum: 1, maximum: 1e3, default: 10 }
+    }, { required: ["interfacePk"] })
+  },
+  {
+    name: "ebuilder-form.custom.count",
+    summary: "\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 getFormDataCount \u67E5\u8BE2\u603B\u6570",
+    risk: "read",
+    fixed: { path: "/api/ebuilder/form/formdata/v2/getFormDataCount/{interfacePk}" },
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      mainTable: { type: "object" }
+    }, { required: ["interfacePk"] })
+  },
+  {
+    name: "ebuilder-form.custom.add.prepare",
+    summary: "\u51C6\u5907\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 saveFormData \u65B0\u589E\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      datas: { type: "array", minItems: 1 },
+      operationinfo: { type: "object" }
+    }, { required: ["interfacePk", "datas"] })
+  },
+  {
+    name: "ebuilder-form.custom.add.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 saveFormData \u65B0\u589E\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  },
+  {
+    name: "ebuilder-form.custom.update.prepare",
+    summary: "\u51C6\u5907\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 updateFormData \u4FEE\u6539\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      datas: { type: "array", minItems: 1 },
+      operationinfo: { type: "object" }
+    }, { required: ["interfacePk", "datas"] })
+  },
+  {
+    name: "ebuilder-form.custom.update.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 updateFormData \u4FEE\u6539\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  },
+  {
+    name: "ebuilder-form.custom.delete.prepare",
+    summary: "\u51C6\u5907\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 deleteFormData \u5220\u9664\u8BF7\u6C42\uFF0C\u7B7E\u53D1 continuation",
+    risk: "read-before-write",
+    inputSchema: schema({
+      ...contextProperties,
+      interfacePk: { type: "string", minLength: 1 },
+      dataIds: { type: "array", items: { type: "string", pattern: "^\\d+$" }, minItems: 1 },
+      operationinfo: { type: "object" }
+    }, { required: ["interfacePk", "dataIds"] })
+  },
+  {
+    name: "ebuilder-form.custom.delete.apply",
+    summary: "\u786E\u8BA4\u540E\u6267\u884C\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u63A5\u53E3 deleteFormData \u5220\u9664\u8BF7\u6C42",
+    risk: "high-risk-write",
+    inputSchema: schema(preparedWriteProperties, { required: ["confirm", "continuation"] })
+  }
+];
+var ebuilderFormManifest = {
+  module: "ebuilder-form",
+  version: 1,
+  operations: ebuilderFormOperations
+};
+
+// src/shortcuts/ebuilder-form/operations/types.ts
+function ebuilderSuccess(action, data, meta, warnings = []) {
+  const payload = { ok: true, action, data };
+  if (meta && Object.keys(meta).length > 0) payload.meta = meta;
+  if (warnings.length > 0) payload.warnings = warnings;
+  return payload;
+}
+
+// src/shortcuts/ebuilder-form/operations/shared.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "access_token",
+  "app_key",
+  "app_secret",
+  "authorization",
+  "cookie",
+  "eteamsid",
+  "sedit",
+  "token"
+]);
+function asObject(value, field = "input") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw ebuilderValidationError("input_not_object", `${field} \u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+  }
+  return value;
+}
+function optionalObject(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  return asObject(value, field);
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) throw ebuilderValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u6570\u7EC4`);
+  return value;
+}
+function optionalArray(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  return requiredArray(value, field);
+}
+function requiredString(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    throw ebuilderValidationError("field_required", `${field} \u5FC5\u586B`);
+  }
+  if (typeof value === "object") throw ebuilderValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return String(value);
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "object") throw ebuilderValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return String(value);
+}
+function assertKnownKeys(input, allowed, operation) {
+  const unknown = Object.keys(input).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) {
+    throw ebuilderValidationError("unknown_field", `${operation} \u4E0D\u652F\u6301\u5B57\u6BB5\uFF1A${unknown.join("\u3001")}`, { unknown });
+  }
+}
+function assertNoForbiddenKeys(value, location = "input") {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoForbiddenKeys(item, `${location}[${index}]`));
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (FORBIDDEN_KEYS.has(key) || FORBIDDEN_KEYS.has(key.toLowerCase())) {
+      throw ebuilderValidationError("field_forbidden", `\u7981\u6B62\u4E1A\u52A1\u8F93\u5165\u5B57\u6BB5\uFF1A${location}.${key}`);
+    }
+    assertNoForbiddenKeys(child, `${location}.${key}`);
+  }
+}
+function compactJson(value) {
+  return JSON.stringify(value);
+}
+function sha256VisibleFingerprint(value) {
+  const json = compactJson(value);
+  let hash = 0;
+  for (let index = 0; index < json.length; index += 1) {
+    hash = (hash << 5) - hash + json.charCodeAt(index) | 0;
+  }
+  return `len:${json.length}:h:${(hash >>> 0).toString(16)}`;
+}
+
+// src/shortcuts/ebuilder-form/operations/read.ts
+var CONTEXT_KEYS = [
+  "context",
+  "menuKeywords",
+  "menu",
+  "menuId",
+  "url",
+  "appId",
+  "apiPrefix",
+  "objId",
+  "listId",
+  "hostPageId",
+  "listKind",
+  "menuUrl",
+  "entryUrl"
+];
+var EbuilderMenuSearchOperation = class {
+  name = "ebuilder-form.menu.search";
+  async execute(input, { host }) {
+    assertKnownKeys(input, ["menuKeywords"], this.name);
+    const keywords = requiredArray(input.menuKeywords, "menuKeywords").map((item) => String(item));
+    const menus = await host.searchMenus(keywords);
+    return ebuilderSuccess(this.name, { menus, count: menus.length }, { status: "COMPLETE" });
+  }
+};
+var EbuilderContextResolveOperation = class {
+  name = "ebuilder-form.context.resolve";
+  async execute(input, { host }) {
+    const context = await host.resolveContext(input);
+    return ebuilderSuccess(this.name, {
+      context,
+      listUrl: host.buildListUrl(context)
+    }, { status: "COMPLETE" });
+  }
+};
+var EbuilderViewsListOperation = class {
+  name = "ebuilder-form.views.list";
+  async execute(input, { host }) {
+    const result = await host.formViews(input);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderListConfigOperation = class {
+  name = "ebuilder-form.list.config";
+  async execute(input, { host }) {
+    const context = await host.resolveContext({ ...input, listKind: input.listKind || input.context?.listKind || "List" });
+    const result = await host.listConfig(context, this.name);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderListQueryOperation = class {
+  name = "ebuilder-form.list.query";
+  async execute(input, { host }) {
+    const result = await host.listQuery(input, this.name);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderNlistConfigOperation = class {
+  name = "ebuilder-form.nlist.config";
+  async execute(input, { host }) {
+    const context = await host.resolveContext({ ...input, listKind: input.listKind || input.context?.listKind || "NList" });
+    const result = await host.nlistConfig(context, this.name);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderNlistQueryOperation = class {
+  name = "ebuilder-form.nlist.query";
+  async execute(input, { host }) {
+    const result = await host.nlistQuery(input, this.name);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderFieldsGetOperation = class {
+  name = "ebuilder-form.fields.get";
+  async execute(input, { host }) {
+    const result = await host.fields(input, this.name);
+    return ebuilderSuccess(this.name, { result }, { status: "COMPLETE" });
+  }
+};
+var EbuilderOptionsGetOperation = class {
+  name = "ebuilder-form.options.get";
+  async execute(input, { host }) {
+    const result = await host.options(input, this.name);
+    return ebuilderSuccess(this.name, { result }, { status: "COMPLETE" });
+  }
+};
+var EbuilderMappingGetOperation = class {
+  name = "ebuilder-form.mapping.get";
+  async execute(input, { host }) {
+    const result = await host.mapping(input, this.name);
+    return ebuilderSuccess(this.name, { result }, { status: "COMPLETE" });
+  }
+};
+var EbuilderBrowserResolveOperation = class {
+  name = "ebuilder-form.browser.resolve";
+  async execute(input, { host }) {
+    assertKnownKeys(input, ["module", "browserType", "query", "multiple", "limit", "extra"], this.name);
+    const result = await host.browserResolve(input, this.name);
+    return ebuilderSuccess(this.name, result, { status: "COMPLETE" });
+  }
+};
+var EbuilderOpenapiReadOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.openapi.${endpoint}`;
+  }
+  endpoint;
+  name;
+  async execute(input, { host }) {
+    const allowed = [
+      ...CONTEXT_KEYS,
+      "dataId",
+      "mainTable",
+      "pageNo",
+      "pageSize",
+      "isReturnDetail",
+      "fieldNoFindIgnore"
+    ];
+    assertKnownKeys(input, allowed, this.name);
+    const result = await host.openapiRead(this.endpoint, input, this.name);
+    const data = addLinks(result, host, this.endpoint === "detail" ? optionalString(input.dataId, "dataId") : void 0);
+    return ebuilderSuccess(this.name, data, { status: "COMPLETE" });
+  }
+};
+var EbuilderCustomReadOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.custom.${endpoint}`;
+  }
+  endpoint;
+  name;
+  async execute(input, { host }) {
+    const allowed = [
+      ...CONTEXT_KEYS,
+      "interfacePk",
+      "dataId",
+      "mainTable",
+      "pageNo",
+      "pageSize"
+    ];
+    assertKnownKeys(input, allowed, this.name);
+    const result = await host.customRead(this.endpoint, input, this.name);
+    const data = addLinks(result, host, this.endpoint === "detail" ? optionalString(input.dataId, "dataId") : void 0);
+    return ebuilderSuccess(this.name, data, { status: "COMPLETE" });
+  }
+};
+function addLinks(result, host, dataId) {
+  const context = asObject(result.context || {}, "context");
+  const payload = asObject(result.result || {}, "result");
+  return {
+    context,
+    result: payload,
+    ...dataId ? { dataUrl: host.buildDataUrl(context, dataId) } : {},
+    listUrl: host.buildListUrl(context)
+  };
+}
+
+// src/shortcuts/ebuilder-form/operations/write.ts
+var CONTEXT_KEYS2 = [
+  "context",
+  "menuKeywords",
+  "menu",
+  "menuId",
+  "url",
+  "appId",
+  "apiPrefix",
+  "objId",
+  "listId",
+  "hostPageId",
+  "listKind",
+  "menuUrl",
+  "entryUrl"
+];
+var EbuilderOpenapiPrepareOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.openapi.${endpoint}.prepare`;
+    this.applyName = `ebuilder-form.openapi.${endpoint}.apply`;
+  }
+  endpoint;
+  name;
+  applyName;
+  async execute(input, env) {
+    const allowed = [
+      ...CONTEXT_KEYS2,
+      "dataId",
+      "mainTable",
+      "datas",
+      "operationinfo"
+    ];
+    assertKnownKeys(input, allowed, this.name);
+    assertNoForbiddenKeys(input);
+    const prepared = await prepareOpenapi(this.endpoint, input, env.host);
+    const session = await env.host.getSession();
+    const continuation = await env.continuation.issue({
+      operation: this.applyName,
+      actor: { userId: session.userId, baseUrl: session.baseUrl, profile: session.profile },
+      kind: "openapi",
+      endpoint: this.endpoint,
+      datajson: { ...prepared.datajson, __context: prepared.context },
+      target: prepared.target,
+      fingerprint: sha256VisibleFingerprint(prepared.datajson)
+    });
+    return ebuilderSuccess(this.name, {
+      context: prepared.context,
+      target: prepared.target,
+      requestPreview: { datajson: prepared.datajson },
+      continuation,
+      expiresInSeconds: 600
+    }, { status: "PREPARED" }, prepared.warnings);
+  }
+};
+var EbuilderOpenapiApplyOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.openapi.${endpoint}.apply`;
+  }
+  endpoint;
+  name;
+  async execute(input, env) {
+    assertKnownKeys(input, ["confirm", "continuation"], this.name);
+    if (input.confirm !== true) throw ebuilderConfirmationError(this.name);
+    const record2 = await env.continuation.verify(requiredString(input.continuation, "continuation"), this.name);
+    assertContinuation(record2, await env.host.getSession(), "openapi", this.endpoint);
+    const datajson = asObject(record2.datajson, "continuation.datajson");
+    const result = await env.host.openapiWrite(this.endpoint, datajson, this.name);
+    return ebuilderSuccess(this.name, summarizeWriteResult(result, env.host, this.endpoint === "delete"), { status: "COMPLETE" });
+  }
+};
+var EbuilderCustomPrepareOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.custom.${endpoint}.prepare`;
+    this.applyName = `ebuilder-form.custom.${endpoint}.apply`;
+  }
+  endpoint;
+  name;
+  applyName;
+  async execute(input, env) {
+    const allowed = [
+      ...CONTEXT_KEYS2,
+      "interfacePk",
+      "dataIds",
+      "datas",
+      "operationinfo"
+    ];
+    assertKnownKeys(input, allowed, this.name);
+    assertNoForbiddenKeys(input);
+    const prepared = await prepareCustom(this.endpoint, input, env.host);
+    const session = await env.host.getSession();
+    const continuation = await env.continuation.issue({
+      operation: this.applyName,
+      actor: { userId: session.userId, baseUrl: session.baseUrl, profile: session.profile },
+      kind: "custom",
+      endpoint: this.endpoint,
+      interfacePk: prepared.interfacePk,
+      datajson: { ...prepared.datajson, __context: prepared.context },
+      target: prepared.target,
+      fingerprint: sha256VisibleFingerprint(prepared.datajson)
+    });
+    return ebuilderSuccess(this.name, {
+      context: prepared.context,
+      interfacePk: prepared.interfacePk,
+      target: prepared.target,
+      requestPreview: { datajson: prepared.datajson },
+      continuation,
+      expiresInSeconds: 600
+    }, { status: "PREPARED" }, prepared.warnings);
+  }
+};
+var EbuilderCustomApplyOperation = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.name = `ebuilder-form.custom.${endpoint}.apply`;
+  }
+  endpoint;
+  name;
+  async execute(input, env) {
+    assertKnownKeys(input, ["confirm", "continuation"], this.name);
+    if (input.confirm !== true) throw ebuilderConfirmationError(this.name);
+    const record2 = await env.continuation.verify(requiredString(input.continuation, "continuation"), this.name);
+    assertContinuation(record2, await env.host.getSession(), "custom", this.endpoint);
+    const datajson = asObject(record2.datajson, "continuation.datajson");
+    const interfacePk = requiredString(record2.interfacePk, "continuation.interfacePk");
+    const result = await env.host.customWrite(this.endpoint, interfacePk, datajson, this.name);
+    return ebuilderSuccess(this.name, summarizeWriteResult(result, env.host, this.endpoint === "delete"), { status: "COMPLETE" });
+  }
+};
+async function prepareOpenapi(endpoint, input, host) {
+  const context = await host.resolveContext(input);
+  const operationinfo = optionalObject(input.operationinfo, "operationinfo") || {};
+  if (endpoint === "add") {
+    const datas = requiredArray(input.datas, "datas");
+    return {
+      context,
+      datajson: {
+        datas,
+        header: { objId: context.objId },
+        operationinfo: {
+          fieldNoFindIgnore: "false",
+          checkRight: "true",
+          doAction: "false",
+          printCost: "true",
+          ...operationinfo
+        }
+      },
+      target: { endpoint, objId: context.objId, count: datas.length },
+      warnings: fieldKeyWarnings(datas)
+    };
+  }
+  if (endpoint === "update") {
+    const datas = requiredArray(input.datas, "datas");
+    return {
+      context,
+      datajson: {
+        datas,
+        header: { objId: context.objId },
+        operationinfo: {
+          updateType: "ids",
+          needAdd: "false",
+          fieldNoFindIgnore: "false",
+          checkRight: "true",
+          doAction: "false",
+          printCost: "true",
+          ...operationinfo
+        }
+      },
+      target: { endpoint, objId: context.objId, dataIds: collectDataIds(datas) },
+      warnings: fieldKeyWarnings(datas)
+    };
+  }
+  const mainTable = {
+    ...optionalObject(input.mainTable, "mainTable") || {},
+    ...input.dataId ? { id: requiredString(input.dataId, "dataId") } : {}
+  };
+  if (Object.keys(mainTable).length === 0) {
+    throw ebuilderValidationError("delete_target_required", "\u5220\u9664\u5FC5\u987B\u63D0\u4F9B dataId \u6216 mainTable \u6761\u4EF6");
+  }
+  return {
+    context,
+    datajson: {
+      header: { objId: context.objId },
+      mainTable,
+      operationinfo: {
+        fieldNoFindIgnore: "false",
+        checkRight: "true",
+        doAction: "false",
+        printCost: "true",
+        ...operationinfo
+      }
+    },
+    target: { endpoint, objId: context.objId, mainTable },
+    warnings: ["\u5220\u9664\u4E0D\u53EF\u9006\uFF1Bapply \u524D\u5FC5\u987B\u786E\u8BA4 objId\u3001\u5220\u9664\u6761\u4EF6\u548C\u5F53\u524D\u64CD\u4F5C\u4EBA\u5747\u6B63\u786E"]
+  };
+}
+async function prepareCustom(endpoint, input, host) {
+  const context = await host.resolveContext(input);
+  const interfacePk = requiredString(input.interfacePk, "interfacePk");
+  const operationinfo = {
+    printCost: false,
+    asyncPostProcess: false,
+    asyncMark: false,
+    ...optionalObject(input.operationinfo, "operationinfo") || {}
+  };
+  const session = await host.getSession();
+  if (endpoint === "delete") {
+    const dataIds = requiredArray(input.dataIds, "dataIds").map((item) => requiredString(item, "dataIds[]"));
+    return {
+      context,
+      interfacePk,
+      datajson: {
+        datas: dataIds.map((id) => ({ mainTable: { id } })),
+        header: { operator: session.userId }
+      },
+      target: { endpoint, interfacePk, dataIds },
+      warnings: ["\u5220\u9664\u4E0D\u53EF\u9006\uFF1Bapply \u524D\u5FC5\u987B\u786E\u8BA4 interfacePk\u3001\u76EE\u6807 dataId \u548C\u5F53\u524D\u64CD\u4F5C\u4EBA\u5747\u6B63\u786E"]
+    };
+  }
+  const datas = requiredArray(input.datas, "datas");
+  return {
+    context,
+    interfacePk,
+    datajson: {
+      operationinfo,
+      datas,
+      header: { operator: session.userId }
+    },
+    target: { endpoint, interfacePk, count: datas.length, dataIds: collectDataIds(datas) },
+    warnings: fieldKeyWarnings(datas)
+  };
+}
+function assertContinuation(record2, session, kind, endpoint) {
+  if (record2.kind !== kind || record2.endpoint !== endpoint) {
+    throw ebuilderValidationError("continuation_mismatch", "continuation \u7684\u63A5\u53E3\u65CF\u6216 operation \u4E0E\u5F53\u524D apply \u4E0D\u4E00\u81F4");
+  }
+  const actor = asObject(record2.actor, "continuation.actor");
+  if (actor.userId !== session.userId || actor.baseUrl !== session.baseUrl) {
+    throw ebuilderValidationError("continuation_actor_changed", "continuation \u7B7E\u53D1\u65F6\u7684\u767B\u5F55\u73AF\u5883\u6216\u7528\u6237\u4E0E\u5F53\u524D\u4F1A\u8BDD\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+  }
+}
+function summarizeWriteResult(result, host, deleted) {
+  const context = asObject(result.context || {}, "context");
+  const payload = asObject(result.result || {}, "result");
+  const dataIds = Array.isArray(payload.dataIds) ? payload.dataIds : [];
+  return {
+    context,
+    result: payload,
+    records: dataIds.map((dataId) => ({
+      dataId,
+      url: host.buildDataUrl(context, dataId, deleted)
+    })),
+    listUrl: host.buildListUrl(context)
+  };
+}
+function collectDataIds(datas) {
+  return datas.map((item) => optionalString(asObject(item, "datas[]").mainTable?.id, "mainTable.id")).filter((item) => Boolean(item));
+}
+function fieldKeyWarnings(datas) {
+  const warnings = [];
+  const text = JSON.stringify(datas);
+  if (/"\d{16,}"/u.test(text)) {
+    warnings.push("\u68C0\u6D4B\u5230\u957F\u6570\u5B57\u5B57\u6BB5\u952E\uFF1B\u5982\u679C\u5B57\u6BB5\u5B9A\u4E49\u4E2D name \u7B49\u4E8E id\uFF0C\u8BF7\u786E\u8BA4\u5199\u5165\u952E\u5DF2\u6539\u7528 config.dataKey\uFF0C\u5426\u5219 eBuilder \u53EF\u80FD\u8FD4\u56DE\u6210\u529F\u4F46\u5B57\u6BB5\u503C\u4E3A\u7A7A");
+  }
+  if (optionalArray(datas, "datas")?.some((item) => JSON.stringify(item).includes('"fieldNoFindIgnore"'))) {
+    warnings.push("fieldNoFindIgnore \u5E94\u653E\u5728 operationinfo\uFF1B\u5B57\u6BB5\u540D\u9519\u8BEF\u4E0D\u80FD\u901A\u8FC7\u5FFD\u7565\u5B57\u6BB5\u7ED5\u8FC7");
+  }
+  return warnings;
+}
+
+// src/shortcuts/ebuilder-form/operations/registry.ts
+function buildRegistry() {
+  const handlers = [
+    new EbuilderMenuSearchOperation(),
+    new EbuilderContextResolveOperation(),
+    new EbuilderViewsListOperation(),
+    new EbuilderListConfigOperation(),
+    new EbuilderListQueryOperation(),
+    new EbuilderNlistConfigOperation(),
+    new EbuilderNlistQueryOperation(),
+    new EbuilderFieldsGetOperation(),
+    new EbuilderOptionsGetOperation(),
+    new EbuilderMappingGetOperation(),
+    new EbuilderBrowserResolveOperation(),
+    new EbuilderOpenapiReadOperation("detail"),
+    new EbuilderOpenapiReadOperation("query"),
+    new EbuilderOpenapiReadOperation("count"),
+    new EbuilderOpenapiPrepareOperation("add"),
+    new EbuilderOpenapiApplyOperation("add"),
+    new EbuilderOpenapiPrepareOperation("update"),
+    new EbuilderOpenapiApplyOperation("update"),
+    new EbuilderOpenapiPrepareOperation("delete"),
+    new EbuilderOpenapiApplyOperation("delete"),
+    new EbuilderCustomReadOperation("detail"),
+    new EbuilderCustomReadOperation("query"),
+    new EbuilderCustomReadOperation("count"),
+    new EbuilderCustomPrepareOperation("add"),
+    new EbuilderCustomApplyOperation("add"),
+    new EbuilderCustomPrepareOperation("update"),
+    new EbuilderCustomApplyOperation("update"),
+    new EbuilderCustomPrepareOperation("delete"),
+    new EbuilderCustomApplyOperation("delete")
+  ];
+  const registry2 = /* @__PURE__ */ new Map();
+  for (const handler of handlers) {
+    if (registry2.has(handler.name)) throw new Error(`duplicate ebuilder-form operation handler: ${handler.name}`);
+    registry2.set(handler.name, handler);
+  }
+  for (const contract of ebuilderFormOperations) {
+    if (!registry2.has(contract.name)) throw new Error(`missing ebuilder-form operation handler: ${contract.name}`);
+  }
+  return registry2;
+}
+var registry = buildRegistry();
+function getEbuilderFormOperation(operation) {
+  const handler = registry.get(operation);
+  if (!handler) {
+    throw ebuilderValidationError("operation_unknown", `eBuilder \u8868\u5355\u4E0D\u652F\u6301\u64CD\u4F5C\uFF1A${operation}`);
+  }
+  return handler;
+}
+
+// src/shortcuts/ebuilder-form/operations.ts
+async function executeEbuilderFormOperation(operation, rawInput, context) {
+  const handler = getEbuilderFormOperation(operation);
+  const input = asObject(rawInput);
+  assertNoForbiddenKeys(input);
+  return handler.execute(input, context);
+}
+
+// src/shortcuts/ebuilder-form/index.ts
+function asOptions(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function stripBom(value) {
+  return value.replace(/^\uFEFF+/u, "");
+}
+function parseJsonInput(raw, label) {
+  try {
+    const parsed = JSON.parse(stripBom(raw));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("input must be an object");
+    }
+    return parsed;
+  } catch {
+    throw ebuilderValidationError("input_invalid", `${label} \u4E0D\u662F\u5408\u6CD5 JSON \u5BF9\u8C61`);
+  }
+}
+async function inputFrom(options, extra = {}) {
+  const opts = asOptions(options);
+  let input = {};
+  if (opts.input && opts.inputJson) {
+    throw ebuilderValidationError("input_conflict", "\u4E0D\u80FD\u540C\u65F6\u4F20 --input \u548C --input-json");
+  }
+  if (opts.inputJson) {
+    input = parseJsonInput(String(opts.inputJson), "--input-json");
+  }
+  if (opts.input) {
+    let raw;
+    try {
+      raw = stripBom(opts.input === "-" ? await readStdin() : await readFile2(String(opts.input), "utf8"));
+    } catch {
+      throw ebuilderValidationError("input_unreadable", `\u65E0\u6CD5\u8BFB\u53D6 --input\uFF1A${String(opts.input)}`);
+    }
+    input = parseJsonInput(raw, "--input");
+  }
+  return {
+    ...input,
+    ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== void 0 && value !== ""))
+  };
+}
+function successEnvelope(operation, result) {
+  return {
+    schemaVersion: 1,
+    ok: true,
+    operation,
+    data: result.data === void 0 ? null : result.data,
+    ...result.meta ? { meta: result.meta } : {},
+    warnings: result.warnings ?? []
+  };
+}
+function failureEnvelope(error) {
+  return {
+    schemaVersion: 1,
+    ok: false,
+    error: toErrorEnvelope(error)
+  };
+}
+async function executeAndPrint(ctx, operation, input) {
+  try {
+    const result = await executeEbuilderFormOperation(operation, input, {
+      ctx,
+      host: createEbuilderFormHost(ctx),
+      continuation: createEbuilderFormContinuationSigner(ctx)
+    });
+    ctx.output.write(successEnvelope(operation, result), { json: true });
+  } catch (error) {
+    console.error(JSON.stringify(failureEnvelope(error), null, 2));
+    process.exitCode = isCliError(error) ? error.exitCode : 1 /* GeneralError */;
+  }
+}
+var ebuilderFormShortcut = {
+  name: "ebuilder-form",
+  description: "\u6CDB\u5FAEE10 eBuilder \u8868\u5355\u83DC\u5355\u3001\u5217\u8868\u548C\u8868\u5355\u6570\u636E CLI",
+  category: "shortcut",
+  register({ program, action }) {
+    const ebuilder = program.command("ebuilder-form").description("\u6CDB\u5FAEE10 eBuilder \u8868\u5355\u83DC\u5355\u3001List/NList\u3001OpenAPI \u4E0E\u81EA\u5B9A\u4E49\u63A5\u53E3\u80FD\u529B");
+    ebuilder.command("schema").description("Print ebuilder-form operation manifest for agents").action(action((ctx) => {
+      ctx.output.write(ebuilderFormManifest, { json: true });
+    }));
+    ebuilder.command("run").description("Run an ebuilder-form operation with JSON input").argument("<operation>", "operation name, e.g. ebuilder-form.context.resolve").option("--input <path>", "JSON input file, or - for stdin").option("--input-json <json>", "inline JSON input object").action(action(async (ctx, operation, options) => {
+      await executeAndPrint(ctx, String(operation), await inputFrom(options));
+    }));
+  }
+};
+export {
+  ebuilderFormShortcut,
+  inputFrom,
+  successEnvelope
+};