openxiangda 1.0.152 → 1.0.154

package/packages/sdk/dist/runtime/react.mjs

@@ -2619,21 +2619,2588 @@ var usePageRoute = () => {
   return usePageContext().route;
 };
 
+// packages/sdk/src/runtime/react/filePreview.tsx
+import React6, { useMemo as useMemo6, useState as useState6 } from "react";
+import { Empty as Empty3 } from "antd";
+
+// packages/sdk/src/components/core/imageCompression.ts
+var DEFAULT_THUMB = {
+  maxWidth: 320,
+  maxHeight: 320,
+  quality: 0.72,
+  format: "source"
+};
+var DEFAULT_PREVIEW = {
+  maxWidth: 1280,
+  maxHeight: 1280,
+  quality: 0.82,
+  format: "source"
+};
+var COMPRESSIBLE_EXTENSIONS = /* @__PURE__ */ new Set(["jpg", "jpeg", "png", "webp", "bmp"]);
+function shouldCreateImageVariants(file, config) {
+  if (!config || config.enabled === false) return false;
+  if (!isCompressibleImageFile(file)) return false;
+  if (config.skipBelowBytes && file.size <= config.skipBelowBytes) return false;
+  return true;
+}
+async function createCompressedImageVariants(file, config) {
+  if (!shouldCreateImageVariants(file, config)) return [];
+  const variantConfigs = [];
+  if (config?.thumb !== false) {
+    variantConfigs.push(["thumb", { ...DEFAULT_THUMB, ...config?.thumb || {} }]);
+  }
+  if (config?.preview !== false) {
+    variantConfigs.push(["preview", { ...DEFAULT_PREVIEW, ...config?.preview || {} }]);
+  }
+  if (variantConfigs.length === 0) return [];
+  const source = await loadImageSource(file);
+  if (!source) return [];
+  try {
+    const sourceWidth = Math.max(1, source.naturalWidth || source.width || 0);
+    const sourceHeight = Math.max(1, source.naturalHeight || source.height || 0);
+    if (!sourceWidth || !sourceHeight) return [];
+    const results = [];
+    for (const [kind, variantConfig] of variantConfigs) {
+      const normalized = normalizeVariantConfig(kind, variantConfig);
+      const target = getTargetSize(sourceWidth, sourceHeight, normalized);
+      const mimeType = resolveOutputMimeType(file, normalized.format);
+      const blob = await drawCompressedBlob(
+        source,
+        target.width,
+        target.height,
+        mimeType,
+        normalized.quality
+      );
+      if (!blob || blob.size >= file.size) continue;
+      const outputFile = new File([blob], buildVariantFileName(file.name, kind, mimeType), {
+        type: blob.type || mimeType,
+        lastModified: Date.now()
+      });
+      results.push({
+        kind,
+        file: outputFile,
+        width: target.width,
+        height: target.height,
+        contentType: outputFile.type || mimeType,
+        quality: normalized.quality
+      });
+    }
+    return results;
+  } finally {
+    source.close?.();
+  }
+}
+function isCompressibleImageFile(file) {
+  const contentType = String(file.type || "").toLowerCase();
+  if (contentType === "image/svg+xml" || contentType === "image/gif") return false;
+  if (contentType.startsWith("image/")) {
+    return ["image/jpeg", "image/png", "image/webp", "image/bmp"].includes(contentType);
+  }
+  const extension = getExtension(file.name);
+  return COMPRESSIBLE_EXTENSIONS.has(extension);
+}
+async function loadImageSource(file) {
+  if (typeof createImageBitmap === "function") {
+    try {
+      return await createImageBitmap(file);
+    } catch {
+    }
+  }
+  if (typeof Image === "undefined" || typeof URL === "undefined") return null;
+  const objectUrl = URL.createObjectURL(file);
+  try {
+    const image = new Image();
+    image.decoding = "async";
+    image.src = objectUrl;
+    if (typeof image.decode === "function") {
+      await image.decode();
+    } else {
+      await new Promise((resolve, reject) => {
+        image.onload = () => resolve();
+        image.onerror = () => reject(new Error("\u56FE\u7247\u89E3\u7801\u5931\u8D25"));
+      });
+    }
+    return image;
+  } catch {
+    return null;
+  } finally {
+    URL.revokeObjectURL(objectUrl);
+  }
+}
+function normalizeVariantConfig(kind, config) {
+  const fallback = kind === "thumb" ? DEFAULT_THUMB : DEFAULT_PREVIEW;
+  const maxWidth = Number(config.maxWidth || fallback.maxWidth);
+  const maxHeight = Number(config.maxHeight || fallback.maxHeight);
+  const quality = Number(config.quality ?? fallback.quality);
+  return {
+    maxWidth: Number.isFinite(maxWidth) && maxWidth > 0 ? maxWidth : fallback.maxWidth,
+    maxHeight: Number.isFinite(maxHeight) && maxHeight > 0 ? maxHeight : fallback.maxHeight,
+    quality: Number.isFinite(quality) && quality > 0 && quality <= 1 ? quality : fallback.quality,
+    format: config.format || fallback.format
+  };
+}
+function getTargetSize(sourceWidth, sourceHeight, config) {
+  const scale = Math.min(1, config.maxWidth / sourceWidth, config.maxHeight / sourceHeight);
+  return {
+    width: Math.max(1, Math.round(sourceWidth * scale)),
+    height: Math.max(1, Math.round(sourceHeight * scale))
+  };
+}
+function drawCompressedBlob(source, width, height, mimeType, quality) {
+  if (typeof document === "undefined") return Promise.resolve(null);
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d");
+  if (!context || typeof canvas.toBlob !== "function") return Promise.resolve(null);
+  context.drawImage(source, 0, 0, width, height);
+  return new Promise((resolve) => {
+    canvas.toBlob(resolve, mimeType, mimeType === "image/png" ? void 0 : quality);
+  });
+}
+function resolveOutputMimeType(file, format) {
+  if (format && format !== "source") {
+    return format === "jpeg" ? "image/jpeg" : `image/${format}`;
+  }
+  const sourceType = String(file.type || "").toLowerCase();
+  if (["image/jpeg", "image/png", "image/webp"].includes(sourceType)) return sourceType;
+  const extension = getExtension(file.name);
+  if (extension === "png") return "image/png";
+  if (extension === "webp") return "image/webp";
+  return "image/jpeg";
+}
+function buildVariantFileName(fileName, kind, mimeType) {
+  const extension = extensionFromMimeType(mimeType);
+  const baseName = String(fileName || "image").replace(/\.[^.]*$/, "").replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "");
+  return `${baseName || "image"}.${kind}.${extension}`;
+}
+function extensionFromMimeType(mimeType) {
+  if (mimeType === "image/png") return "png";
+  if (mimeType === "image/webp") return "webp";
+  return "jpg";
+}
+function getExtension(fileName) {
+  return String(fileName || "").split(".").pop()?.toLowerCase() || "";
+}
+
+// packages/sdk/src/components/core/runtimeApi.ts
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+var CHUNK_UPLOAD_THRESHOLD = 10 * 1024 * 1024;
+var DEFAULT_PUBLIC_FILE_BUCKET = "public-assets";
+var trimTrailingSlash = (value) => String(value || "").replace(/\/$/, "");
+var getDefaultBaseUrl = () => {
+  const globalEnv = globalThis.process?.env;
+  const envBaseUrl = globalEnv?.FORM_API_BASE_URL || globalEnv?.BASE_API_URL;
+  if (envBaseUrl) return trimTrailingSlash(envBaseUrl);
+  const browserGlobal = typeof window !== "undefined" ? window : void 0;
+  const windowBaseUrl = browserGlobal?.FORM_API_BASE_URL || browserGlobal?.BASE_API_URL || browserGlobal?.__FORM_API_BASE_URL__ || browserGlobal?.__LOWCODE_API_BASE_URL__;
+  if (windowBaseUrl) return trimTrailingSlash(windowBaseUrl);
+  return typeof window !== "undefined" ? "/service" : "";
+};
+var appendQuery = (url, params) => {
+  if (!params) return url;
+  const search = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") return;
+    if (Array.isArray(value)) {
+      value.forEach((item) => search.append(key, String(item)));
+      return;
+    }
+    search.append(key, String(value));
+  });
+  const query = search.toString();
+  if (!query) return url;
+  return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+};
+var joinUrl = (baseUrl, url) => {
+  if (/^https?:\/\//i.test(url)) return url;
+  const normalizedBaseUrl = trimTrailingSlash(baseUrl);
+  if (normalizedBaseUrl && (url === normalizedBaseUrl || url.startsWith(`${normalizedBaseUrl}/`))) {
+    return url;
+  }
+  return `${normalizedBaseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+};
+var isSuccessCode2 = (value) => {
+  if (value === void 0 || value === null || value === "") return true;
+  const code = Number(value);
+  return Number.isFinite(code) ? code === 0 || code >= 200 && code < 300 : false;
+};
+var normalizeRuntimeFileUrl = (baseUrl, value) => {
+  if (typeof value !== "string" || !value) return value;
+  if (/^(https?:)?\/\//i.test(value) || /^(blob|data):/i.test(value)) return value;
+  if (!value.startsWith("/file/")) return value;
+  return joinUrl(baseUrl, value);
+};
+var normalizeFilePayloadUrls = (baseUrl, payload) => {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
+  return {
+    ...payload,
+    url: normalizeRuntimeFileUrl(baseUrl, payload.url),
+    downloadUrl: normalizeRuntimeFileUrl(baseUrl, payload.downloadUrl),
+    publicUrl: normalizeRuntimeFileUrl(baseUrl, payload.publicUrl),
+    relayUrl: normalizeRuntimeFileUrl(baseUrl, payload.relayUrl),
+    previewUrl: normalizeRuntimeFileUrl(baseUrl, payload.previewUrl),
+    metadataUrl: normalizeRuntimeFileUrl(baseUrl, payload.metadataUrl),
+    previewPageUrl: payload.previewPageUrl
+  };
+};
+var normalizeImageVariants = (baseUrl, variants) => {
+  if (!variants || typeof variants !== "object" || Array.isArray(variants)) return void 0;
+  const normalized = {};
+  ["thumb", "preview"].forEach((kind) => {
+    const item = variants[kind];
+    if (!item || typeof item !== "object") return;
+    normalized[kind] = {
+      ...item,
+      url: normalizeRuntimeFileUrl(baseUrl, item.url)
+    };
+  });
+  return normalized.thumb || normalized.preview ? normalized : void 0;
+};
+var normalizeFileTicketResult = (baseUrl, payload) => typeof payload === "string" ? normalizeRuntimeFileUrl(baseUrl, payload) : normalizeFilePayloadUrls(baseUrl, payload);
+var parseResponse = async (response) => {
+  const contentType = response.headers.get("content-type") || "";
+  const payload = contentType.includes("application/json") ? await response.json() : await response.text();
+  if (!response.ok) {
+    const message3 = typeof payload === "object" && payload ? payload.message || payload.error || response.statusText : response.statusText;
+    throw new Error(message3 || "\u8BF7\u6C42\u5931\u8D25");
+  }
+  if (typeof payload === "object" && payload) {
+    const hasCode = Object.prototype.hasOwnProperty.call(payload, "code");
+    if (payload.success === false || hasCode && !isSuccessCode2(payload.code)) {
+      throw new Error(payload.message || payload.error || "\u8BF7\u6C42\u5931\u8D25");
+    }
+  }
+  if (typeof payload === "object" && payload) {
+    return payload;
+  }
+  return {
+    code: response.status,
+    success: response.ok,
+    data: payload,
+    result: payload,
+    message: response.statusText
+  };
+};
+var applyAuthHeaders = (headers, getAuthHeaders) => {
+  const authHeaders = getAuthHeaders?.();
+  if (authHeaders) {
+    new Headers(authHeaders).forEach((value, key) => {
+      if (!headers.has(key)) headers.set(key, value);
+    });
+  }
+  const token = typeof window !== "undefined" ? window.localStorage?.getItem("token") : void 0;
+  if (token && !headers.has("authorization")) {
+    headers.set("authorization", token);
+  }
+};
+var applyXhrAuthHeaders = (xhr, getAuthHeaders) => {
+  let hasAuthorization = false;
+  const authHeaders = getAuthHeaders?.();
+  if (authHeaders) {
+    new Headers(authHeaders).forEach((value, key) => {
+      if (key.toLowerCase() === "authorization") hasAuthorization = true;
+      xhr.setRequestHeader(key, value);
+    });
+  }
+  const token = typeof window !== "undefined" ? window.localStorage?.getItem("token") : void 0;
+  if (token && !hasAuthorization) xhr.setRequestHeader("authorization", token);
+};
+var createDefaultRequest = (baseUrl, fetchImpl = fetch, getAuthHeaders) => async (config) => {
+  const method = config.method ?? "get";
+  const url = appendQuery(joinUrl(baseUrl, config.url), config.params);
+  const headers = new Headers(config.headers);
+  let body;
+  if (config.data !== void 0) {
+    if (config.data instanceof FormData) {
+      body = config.data;
+    } else {
+      headers.set("Content-Type", headers.get("Content-Type") || "application/json");
+      body = JSON.stringify(config.data);
+    }
+  }
+  applyAuthHeaders(headers, getAuthHeaders);
+  const response = await fetchImpl(url, {
+    method,
+    headers,
+    body,
+    credentials: "include"
+  });
+  if (config.responseType === "blob") {
+    if (!response.ok) throw new Error(response.statusText || "\u8BF7\u6C42\u5931\u8D25");
+    return response.blob();
+  }
+  return parseResponse(response);
+};
+var generateUid = () => `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+var normalizeFormInstancePayload = (payload) => {
+  const { formInstanceId, ...rest } = payload || {};
+  return {
+    ...rest,
+    formInstId: payload?.formInstId || formInstanceId
+  };
+};
+var unwrapBusinessResponse = (response) => {
+  const isFailureCode = (value) => {
+    if (value === void 0 || value === null || value === "") return false;
+    const code = Number(value);
+    return Number.isFinite(code) && code !== 0 && code !== 200;
+  };
+  if (response?.success === false || isFailureCode(response?.code)) {
+    throw new Error(response.message || response.error || "\u8BF7\u6C42\u5931\u8D25");
+  }
+  const result = response?.data ?? response?.result ?? response;
+  if (result?.success === false || isFailureCode(result?.code)) {
+    throw new Error(result.message || response?.message || "\u8BF7\u6C42\u5931\u8D25");
+  }
+  return result;
+};
+var normalizeUploadData = (data, file, bucketName, baseUrl = "") => {
+  const item = Array.isArray(data) ? data[0] : data;
+  const objectName = item?.objectName || item?.objectKey || item?.key;
+  const resolvedBucketName = item?.bucketName || bucketName;
+  const variants = normalizeImageVariants(baseUrl, item?.variants);
+  return {
+    id: item?.id || item?.uid || objectName || generateUid(),
+    uid: item?.uid || item?.id || objectName || generateUid(),
+    name: item?.originalName || item?.name || file.name,
+    originalName: item?.originalName || file.name,
+    url: normalizeRuntimeFileUrl(baseUrl, item?.url) || "",
+    downloadUrl: normalizeRuntimeFileUrl(baseUrl, item?.downloadUrl),
+    previewUrl: normalizeRuntimeFileUrl(baseUrl, item?.previewUrl),
+    publicUrl: normalizeRuntimeFileUrl(baseUrl, item?.publicUrl),
+    thumbUrl: normalizeRuntimeFileUrl(baseUrl, item?.thumbUrl) || variants?.thumb?.url,
+    visibility: item?.visibility,
+    provider: item?.provider,
+    uploadProvider: item?.uploadProvider,
+    storageScope: item?.storageScope,
+    storageCode: item?.storageCode,
+    appType: item?.appType,
+    status: "done",
+    size: item?.size ?? file.size,
+    objectName,
+    bucketName: resolvedBucketName,
+    contentType: item?.contentType || file.type,
+    mimeType: item?.contentType || file.type,
+    extension: item?.extension,
+    width: item?.width,
+    height: item?.height,
+    variants
+  };
+};
+var uploadWithXhr = (baseUrl, file, bucketName, onProgress, options = {}, getAuthHeaders) => new Promise((resolve, reject) => {
+  if (globalThis.process?.env?.VITEST) {
+    onProgress?.(100);
+    resolve({
+      id: generateUid(),
+      uid: generateUid(),
+      name: file.name,
+      url: typeof URL !== "undefined" && URL.createObjectURL ? URL.createObjectURL(file) : "",
+      status: "done",
+      size: file.size,
+      bucketName,
+      contentType: file.type,
+      visibility: options.visibility
+    });
+    return;
+  }
+  const xhr = new XMLHttpRequest();
+  const formData = new FormData();
+  formData.append("files", file);
+  xhr.open(
+    "POST",
+    joinUrl(
+      baseUrl,
+      appendQuery("/file/upload", {
+        bucketName,
+        visibility: options.visibility
+      })
+    )
+  );
+  xhr.withCredentials = true;
+  applyXhrAuthHeaders(xhr, getAuthHeaders);
+  xhr.upload.onprogress = (event) => {
+    if (event.lengthComputable) {
+      onProgress?.(Math.round(event.loaded / event.total * 100));
+    }
+  };
+  xhr.onload = () => {
+    try {
+      const payload = JSON.parse(xhr.responseText || "{}");
+      if (xhr.status >= 200 && xhr.status < 300 && payload.success !== false) {
+        resolve(normalizeUploadData(payload.data, file, bucketName, baseUrl));
+        return;
+      }
+      reject(new Error(payload.message || payload.error || "\u4E0A\u4F20\u5931\u8D25"));
+    } catch (error) {
+      reject(error);
+    }
+  };
+  xhr.onerror = () => reject(new Error("\u4E0A\u4F20\u5931\u8D25"));
+  xhr.send(formData);
+});
+var uploadWithSignedUrl = (file, uploadInfo, bucketName, onProgress) => new Promise((resolve, reject) => {
+  if (!uploadInfo?.uploadUrl) {
+    reject(new Error("OSS \u4E0A\u4F20\u7B7E\u540D\u7F3A\u5C11 uploadUrl"));
+    return;
+  }
+  const xhr = new XMLHttpRequest();
+  xhr.open(String(uploadInfo.uploadMethod || "PUT").toUpperCase(), uploadInfo.uploadUrl);
+  Object.entries(uploadInfo.headers || {}).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      xhr.setRequestHeader(key, String(value));
+    }
+  });
+  xhr.upload.onprogress = (event) => {
+    if (event.lengthComputable) {
+      onProgress?.(Math.round(event.loaded / event.total * 100));
+    }
+  };
+  xhr.onload = () => {
+    if (xhr.status >= 200 && xhr.status < 300) {
+      onProgress?.(100);
+      resolve(
+        normalizeUploadData(
+          {
+            ...uploadInfo,
+            provider: uploadInfo.provider || "oss",
+            uploadProvider: uploadInfo.uploadProvider,
+            storageScope: uploadInfo.storageScope,
+            storageCode: uploadInfo.storageCode
+          },
+          file,
+          uploadInfo.bucketName || bucketName
+        )
+      );
+      return;
+    }
+    reject(new Error(xhr.statusText || "OSS \u4E0A\u4F20\u5931\u8D25"));
+  };
+  xhr.onerror = () => reject(new Error("OSS \u4E0A\u4F20\u5931\u8D25"));
+  xhr.send(file);
+});
+async function uploadOssFile(request, file, bucketName, onProgress, options) {
+  if (!options.appType) throw new Error("OSS \u4E0A\u4F20\u7F3A\u5C11 appType");
+  if (!options.storageCode) throw new Error("OSS \u4E0A\u4F20\u7F3A\u5C11 storageCode");
+  const response = await request({
+    url: `/openxiangda-api/v1/apps/${encodeURIComponent(
+      options.appType
+    )}/storage-configs/${encodeURIComponent(options.storageCode)}/uploads/initiate`,
+    method: "post",
+    data: {
+      fileName: file.name,
+      fileSize: file.size,
+      contentType: file.type || void 0,
+      bucketName
+    }
+  });
+  return uploadWithSignedUrl(file, response.data || response.result, bucketName, onProgress);
+}
+async function uploadBuiltinOssFile(request, file, bucketName, onProgress, options) {
+  if (!options.appType) throw new Error("\u5E73\u53F0\u5185\u7F6E OSS \u4E0A\u4F20\u7F3A\u5C11 appType");
+  const response = await request({
+    url: `/openxiangda-api/v1/apps/${encodeURIComponent(
+      options.appType
+    )}/storage/builtin/uploads/initiate`,
+    method: "post",
+    data: {
+      fileName: file.name,
+      fileSize: file.size,
+      contentType: file.type || void 0,
+      bucketName,
+      purpose: options.uploadPurpose
+    }
+  });
+  return uploadWithSignedUrl(file, response.data || response.result, bucketName, onProgress);
+}
+async function uploadChunkedFile(request, file, bucketName, baseUrl, onProgress, options = {}) {
+  const initiate = await request({
+    url: "/file/multipart/initiate",
+    method: "post",
+    data: {
+      fileName: file.name,
+      fileSize: file.size,
+      chunkSize: DEFAULT_CHUNK_SIZE,
+      bucketName,
+      visibility: options.visibility,
+      contentType: file.type || void 0
+    }
+  });
+  const uploadInfo = initiate.data || initiate.result;
+  const totalParts = uploadInfo?.totalParts || Math.ceil(file.size / DEFAULT_CHUNK_SIZE);
+  const parts = [];
+  try {
+    for (let index = 0; index < totalParts; index += 1) {
+      const start = index * DEFAULT_CHUNK_SIZE;
+      const end = Math.min(start + DEFAULT_CHUNK_SIZE, file.size);
+      const formData = new FormData();
+      formData.append("file", file.slice(start, end));
+      formData.append("uploadId", uploadInfo.uploadId);
+      formData.append("partNumber", String(index + 1));
+      formData.append("bucketName", uploadInfo.bucketName);
+      formData.append("objectName", uploadInfo.objectName);
+      const part = await request({
+        url: "/file/multipart/upload",
+        method: "post",
+        data: formData
+      });
+      parts.push(part.data || part.result);
+      onProgress?.(Math.round((index + 1) / totalParts * 100));
+    }
+    const completed = await request({
+      url: "/file/multipart/complete",
+      method: "post",
+      data: {
+        uploadId: uploadInfo.uploadId,
+        bucketName: uploadInfo.bucketName,
+        objectName: uploadInfo.objectName,
+        originalName: file.name,
+        contentType: file.type || void 0,
+        parts: parts.sort((a, b) => a.partNumber - b.partNumber)
+      }
+    });
+    return normalizeUploadData(completed.data || completed.result, file, bucketName, baseUrl);
+  } catch (error) {
+    await request({
+      url: "/file/multipart/abort",
+      method: "post",
+      data: {
+        uploadId: uploadInfo?.uploadId,
+        bucketName: uploadInfo?.bucketName,
+        objectName: uploadInfo?.objectName
+      }
+    }).catch(() => void 0);
+    throw error;
+  }
+}
+var stripImageCompressionOptions = (options) => {
+  const { imageCompression, ...rest } = options;
+  return rest;
+};
+var createSegmentProgress = (onProgress, start, end) => (percent) => {
+  const next = start + (end - start) * Math.max(0, Math.min(100, percent)) / 100;
+  onProgress?.(Math.round(next));
+};
+var getAttachmentUrl = (item) => item.publicUrl || item.previewUrl || item.downloadUrl || item.url || "";
+async function uploadSingleRuntimeFile(request, baseUrl, file, bucketName, onProgress, options, getAuthHeaders) {
+  const singleOptions = stripImageCompressionOptions(options);
+  if (singleOptions.uploadProvider === "builtin-oss") {
+    return uploadBuiltinOssFile(request, file, bucketName, onProgress, singleOptions);
+  }
+  if (singleOptions.uploadProvider === "oss" || singleOptions.storageCode) {
+    return uploadOssFile(request, file, bucketName, onProgress, singleOptions);
+  }
+  if (file.size > CHUNK_UPLOAD_THRESHOLD) {
+    return uploadChunkedFile(request, file, bucketName, baseUrl, onProgress);
+  }
+  return uploadWithXhr(baseUrl, file, bucketName, onProgress, {}, getAuthHeaders);
+}
+function toImageVariantMetadata(uploaded, variant) {
+  return {
+    url: getAttachmentUrl(uploaded),
+    objectName: uploaded.objectName,
+    bucketName: uploaded.bucketName,
+    width: variant.width,
+    height: variant.height,
+    size: uploaded.size ?? variant.file.size,
+    contentType: uploaded.contentType || variant.contentType,
+    quality: variant.quality
+  };
+}
+async function uploadFileWithImageVariants(request, baseUrl, file, bucketName, onProgress, options, getAuthHeaders) {
+  let variants = [];
+  try {
+    variants = await createCompressedImageVariants(file, options.imageCompression);
+  } catch {
+    variants = [];
+  }
+  if (variants.length === 0) {
+    return uploadSingleRuntimeFile(
+      request,
+      baseUrl,
+      file,
+      bucketName,
+      onProgress,
+      options,
+      getAuthHeaders
+    );
+  }
+  const originalProgressEnd = 70;
+  const uploaded = await uploadSingleRuntimeFile(
+    request,
+    baseUrl,
+    file,
+    bucketName,
+    createSegmentProgress(onProgress, 0, originalProgressEnd),
+    options,
+    getAuthHeaders
+  );
+  const imageVariants = { ...uploaded.variants || {} };
+  const variantProgressStep = (100 - originalProgressEnd) / variants.length;
+  for (let index = 0; index < variants.length; index += 1) {
+    const variant = variants[index];
+    const start = originalProgressEnd + variantProgressStep * index;
+    const end = originalProgressEnd + variantProgressStep * (index + 1);
+    try {
+      const variantUpload = await uploadSingleRuntimeFile(
+        request,
+        baseUrl,
+        variant.file,
+        bucketName,
+        createSegmentProgress(onProgress, start, end),
+        options,
+        getAuthHeaders
+      );
+      imageVariants[variant.kind] = toImageVariantMetadata(variantUpload, variant);
+    } catch {
+      onProgress?.(Math.round(end));
+    }
+  }
+  onProgress?.(100);
+  return {
+    ...uploaded,
+    thumbUrl: imageVariants.thumb?.url || uploaded.thumbUrl,
+    previewUrl: imageVariants.preview?.url || uploaded.previewUrl || uploaded.url,
+    variants: imageVariants.thumb || imageVariants.preview ? imageVariants : uploaded.variants
+  };
+}
+function createFormRuntimeApi(config) {
+  const { baseUrl = getDefaultBaseUrl(), ...overrides } = config ?? {};
+  const { fetchImpl, getAuthHeaders } = overrides;
+  const request = overrides.request ?? createDefaultRequest(baseUrl, fetchImpl, getAuthHeaders);
+  const defaults = {
+    request,
+    uploadFile: async (file, bucketName = "files", onProgress, options = {}) => {
+      return uploadFileWithImageVariants(
+        request,
+        baseUrl,
+        file,
+        bucketName,
+        onProgress,
+        options,
+        getAuthHeaders
+      );
+    },
+    uploadPublicFile: async (file, bucketName = DEFAULT_PUBLIC_FILE_BUCKET, onProgress) => {
+      if (file.size > CHUNK_UPLOAD_THRESHOLD) {
+        return uploadChunkedFile(request, file, bucketName, baseUrl, onProgress, {
+          visibility: "public"
+        });
+      }
+      return uploadWithXhr(baseUrl, file, bucketName, onProgress, {
+        visibility: "public"
+      }, getAuthHeaders);
+    },
+    deleteFile: async (objectName, bucketName = "files", options = {}) => {
+      if (options.uploadProvider === "builtin-oss" || options.storageScope === "platform") {
+        if (!options.appType) throw new Error("\u5E73\u53F0\u5185\u7F6E OSS \u5220\u9664\u7F3A\u5C11 appType");
+        await request({
+          url: `/openxiangda-api/v1/apps/${encodeURIComponent(
+            options.appType
+          )}/storage/builtin/objects/delete`,
+          method: "post",
+          data: { bucketName, objectName }
+        });
+        return { success: true };
+      }
+      if (options.uploadProvider === "oss" || options.storageCode) {
+        if (!options.appType) throw new Error("OSS \u5220\u9664\u7F3A\u5C11 appType");
+        if (!options.storageCode) throw new Error("OSS \u5220\u9664\u7F3A\u5C11 storageCode");
+        await request({
+          url: `/openxiangda-api/v1/apps/${encodeURIComponent(
+            options.appType
+          )}/storage-configs/${encodeURIComponent(options.storageCode)}/objects/delete`,
+          method: "post",
+          data: { bucketName, objectName }
+        });
+        return { success: true };
+      }
+      await request({ url: "/file/delete", method: "post", data: { bucketName, objectName } });
+      return { success: true };
+    },
+    createDownloadTicket: async (bucketName, objectName, fileName) => {
+      const response = await request({
+        url: "/file/download-ticket",
+        method: "post",
+        data: { bucketName, objectName, fileName }
+      });
+      return normalizeFileTicketResult(baseUrl, response.data || response.result);
+    },
+    createFileAccessTicket: async (bucketName, objectName, fileName, purpose = "preview", options = {}) => {
+      const response = await request({
+        url: "/file/access-ticket",
+        method: "post",
+        data: { bucketName, objectName, fileName, purpose, appType: options.appType }
+      });
+      return normalizeFileTicketResult(baseUrl, response.data || response.result);
+    },
+    getUserById: async (id) => {
+      const response = await request({
+        url: `/user/${id}`,
+        method: "get"
+      });
+      return response.data || response.result;
+    },
+    getUserList: async (params) => {
+      const response = await request({
+        url: "/user/list",
+        method: "get",
+        params
+      });
+      const data = response.data || response.result;
+      return Array.isArray(data) ? data : data?.items || data?.list || [];
+    },
+    getDepartmentRoots: async () => {
+      const response = await request({
+        url: "/department/root",
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    getDepartmentChildren: async (parentId) => {
+      const response = await request({
+        url: `/department/${parentId}/children`,
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    searchDepartments: async (params) => {
+      const page = params?.page ?? 1;
+      const pageSize = params?.pageSize ?? 50;
+      const response = await request({
+        url: "/department/search",
+        method: "get",
+        params: {
+          keyword: params?.keyword,
+          page,
+          pageSize,
+          includePath: params?.includePath ?? true
+        }
+      });
+      const data = response.data || response.result;
+      if (Array.isArray(data)) {
+        return { items: data, total: data.length, page, pageSize };
+      }
+      return {
+        items: data?.items || data?.list || [],
+        total: Number(data?.total ?? data?.count ?? data?.items?.length ?? 0),
+        page: Number(data?.page ?? page),
+        pageSize: Number(data?.pageSize ?? pageSize)
+      };
+    },
+    getDepartmentParentDepartments: async (id) => {
+      const response = await request({
+        url: `/department/${id}/parentDepartments`,
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    getDepartmentMembers: async (id) => {
+      const response = await request({
+        url: `/department/${id}/members`,
+        method: "get"
+      });
+      const data = response.data || response.result;
+      return Array.isArray(data) ? data : data?.items || data?.list || [];
+    },
+    getDepartmentMembersPage: async (id, params) => {
+      const page = params?.page ?? 1;
+      const pageSize = params?.pageSize ?? 20;
+      const response = await request({
+        url: `/department/${id}/members`,
+        method: "get",
+        params: { page, pageSize }
+      });
+      const data = response.data || response.result;
+      const items = Array.isArray(data) ? data : data?.items || data?.list || [];
+      return {
+        items,
+        total: Number(data?.total ?? data?.count ?? items.length),
+        page: Number(data?.page ?? page),
+        pageSize: Number(data?.pageSize ?? pageSize)
+      };
+    },
+    getChinaDivisions: async (parentAdcode) => {
+      const response = await request({
+        url: "/china-divisions",
+        method: "get",
+        params: parentAdcode ? { parentAdcode } : void 0
+      });
+      return response.data || response.result || [];
+    },
+    advancedSearch: async (params) => {
+      const response = await request({
+        url: `/${params.appType}/v1/form/advancedSearch.json`,
+        method: "get",
+        params
+      });
+      return response.result || response.data || {};
+    },
+    getDingTalkSignature: async (url) => {
+      const response = await request({
+        url: "/dingtalk/signature",
+        method: "get",
+        params: { url }
+      });
+      return response.data || response.result;
+    },
+    submitFormData: async (payload) => {
+      const response = await request({
+        url: "/form/submitFormData",
+        method: "post",
+        data: payload
+      });
+      return unwrapBusinessResponse(response);
+    },
+    updateFormData: async (payload) => {
+      const data = normalizeFormInstancePayload(payload);
+      const response = await request({
+        url: `/${data.appType}/v1/form/updateFormData.json`,
+        method: "post",
+        data
+      });
+      return unwrapBusinessResponse(response);
+    },
+    startProcessFromExistingInstance: async (payload) => {
+      const data = normalizeFormInstancePayload(payload);
+      const response = await request({
+        url: `/${data.appType}/v1/form/startProcessFromExistingInstance.json`,
+        method: "post",
+        data
+      });
+      return unwrapBusinessResponse(response);
+    }
+  };
+  return { ...defaults, ...overrides, request };
+}
+
+// packages/sdk/src/components/fields/shared/fieldFormat.ts
+function getUserId(user) {
+  if (typeof user === "string" || typeof user === "number") return String(user).trim();
+  return String(user?.id || user?.userId || user?.userid || user?.value || user?.key || "").trim();
+}
+function getUserName(user) {
+  if (typeof user === "string" || typeof user === "number") return String(user).trim();
+  return String(
+    user?.name || user?.label || user?.title || user?.username || user?.nickname || getUserId(user)
+  );
+}
+function normalizeUser(user) {
+  const id = getUserId(user);
+  const source = typeof user === "object" && user !== null ? user : {};
+  return {
+    ...source,
+    id,
+    name: getUserName({ ...source, id })
+  };
+}
+function getDepartmentId(node) {
+  if (typeof node === "string" || typeof node === "number") return String(node).trim();
+  return String(
+    node?.id || node?.departmentId || node?.deptId || node?.value || node?.key || ""
+  ).trim();
+}
+function getDepartmentName(node) {
+  if (typeof node === "string" || typeof node === "number") return String(node).trim();
+  return String(
+    node?.name || node?.label || node?.title || node?.deptName || node?.departmentName || getDepartmentId(node)
+  );
+}
+function normalizeDepartmentNode(node) {
+  const id = getDepartmentId(node);
+  const source = typeof node === "object" && node !== null ? node : {};
+  const name = getDepartmentName({ ...source, id });
+  const hasChildren = typeof node?.hasChildren === "boolean" ? node.hasChildren : Array.isArray(node?.children) && node.children.length > 0;
+  const children = Array.isArray(node?.children) ? node.children.map((child) => normalizeDepartmentNode(child)) : void 0;
+  return {
+    ...source,
+    id,
+    name,
+    key: String(node?.key || id),
+    title: String(node?.title || name),
+    hasChildren,
+    isLeaf: typeof node?.isLeaf === "boolean" ? node.isLeaf : !hasChildren,
+    children
+  };
+}
+function flattenDepartments(nodes) {
+  const result = [];
+  const walk = (items) => {
+    for (const node of items) {
+      const id = getDepartmentId(node);
+      if (id) result.push({ id, name: getDepartmentName(node), node });
+      if (node.children?.length) walk(node.children);
+    }
+  };
+  walk(nodes);
+  return result;
+}
+function formatFileSize(bytes) {
+  if (!bytes) return "";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index += 1;
+  }
+  return `${Number(value.toFixed(value >= 10 || index === 0 ? 0 : 1))} ${units[index]}`;
+}
+function getFileExtension(fileName) {
+  return String(fileName || "").split(".").pop()?.toLowerCase() || "";
+}
+function isImageFile(fileName, contentType) {
+  return String(contentType || "").startsWith("image/") || [
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "bmp",
+    "svg",
+    "webp",
+    "avif",
+    "ico",
+    "heic",
+    "heif",
+    "tif",
+    "tiff"
+  ].includes(getFileExtension(fileName));
+}
+function getFileCategory(fileName, contentType) {
+  const ext = getFileExtension(fileName);
+  if (isImageFile(fileName, contentType)) return "image";
+  if (["mp4", "webm", "ogg", "mov", "m4v"].includes(ext)) return "video";
+  if (["mp3", "wav", "aac", "flac", "m4a", "ogg"].includes(ext)) return "audio";
+  if (ext === "pdf") return "pdf";
+  if (["xls", "xlsx", "csv"].includes(ext)) return "excel";
+  if (["doc", "docx"].includes(ext)) return "word";
+  if (["ppt", "pptx"].includes(ext)) return "ppt";
+  if (["zip", "rar", "7z", "tar", "gz"].includes(ext)) return "archive";
+  if (["txt", "json", "xml", "log", "md"].includes(ext)) return "text";
+  if (["js", "jsx", "ts", "tsx", "html", "css", "scss", "less", "java", "py"].includes(ext)) {
+    return "code";
+  }
+  return "file";
+}
+function getAttachmentItemIdentity(item) {
+  return String(item?.uid || item?.id || item?.objectName || item?.url || item?.name || "");
+}
+
+// packages/sdk/src/components/file-preview/capabilities.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "jpg",
+  "jpeg",
+  "png",
+  "gif",
+  "bmp",
+  "webp",
+  "svg",
+  "avif",
+  "ico",
+  "tif",
+  "tiff",
+  "heic",
+  "heif"
+]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "webm", "ogg", "ogv", "mov", "m4v"]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "oga", "m4a", "aac", "flac"]);
+var DIRECT_XLSX_MAX_BYTES = 10 * 1024 * 1024;
+var DIRECT_DOCX_MAX_BYTES = 20 * 1024 * 1024;
+var DIRECT_HEIC_MAX_BYTES = 30 * 1024 * 1024;
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "txt",
+  "csv",
+  "tsv",
+  "json",
+  "xml",
+  "log",
+  "md",
+  "markdown",
+  "yaml",
+  "yml",
+  "ini",
+  "conf",
+  "properties",
+  "sql",
+  "js",
+  "jsx",
+  "ts",
+  "tsx",
+  "css",
+  "scss",
+  "less",
+  "html",
+  "htm",
+  "java",
+  "py",
+  "go",
+  "rs",
+  "sh",
+  "bash",
+  "c",
+  "cc",
+  "cpp",
+  "h",
+  "hpp",
+  "cs",
+  "php",
+  "rb",
+  "vue"
+]);
+var unwrapFilePreviewPayload = (payload) => payload?.data ?? payload?.result ?? payload;
+var getBinaryResponseMessage = (response) => String(
+  response?.message || response?.error || response?.errorMessage || response?.data?.message || response?.data?.error || response?.result?.message || ""
+).trim();
+var normalizePreviewBlobResponse = (response) => {
+  const payload = response;
+  const candidates = [
+    response,
+    payload?.blob,
+    payload?.data,
+    payload?.data?.blob,
+    payload?.result,
+    payload?.result?.blob
+  ];
+  const blob = candidates.find(
+    (candidate) => typeof Blob !== "undefined" && candidate instanceof Blob
+  );
+  if (blob) return blob;
+  throw new Error(getBinaryResponseMessage(payload) || "\u6587\u4EF6\u5185\u5BB9\u54CD\u5E94\u4E0D\u662F\u4E8C\u8FDB\u5236\u6570\u636E");
+};
+var isZipBytes = (bytes) => bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && (bytes[2] === 3 && bytes[3] === 4 || bytes[2] === 5 && bytes[3] === 6 || bytes[2] === 7 && bytes[3] === 8);
+var decodeBase64ZipBlob = async (blob) => {
+  const prefix = (await blob.slice(0, 96).text()).replace(/^\uFEFF/, "").replace(/\s+/g, "");
+  if (!prefix.startsWith("UEsDB")) return blob;
+  if (blob.size > 32 * 1024 * 1024) {
+    throw new Error("Base64 \u6587\u4EF6\u8D85\u8FC7\u6D4F\u89C8\u5668\u517C\u5BB9\u89E3\u7801\u4E0A\u9650");
+  }
+  const base64 = (await blob.text()).replace(/^\uFEFF/, "").replace(/\s+/g, "");
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
+    throw new Error("\u6587\u4EF6\u5185\u5BB9\u662F\u65E0\u6548\u7684 Base64 \u4E8C\u8FDB\u5236\u6570\u636E");
+  }
+  let binary = "";
+  try {
+    binary = globalThis.atob(base64);
+  } catch {
+    throw new Error("\u6587\u4EF6\u5185\u5BB9\u662F\u65E0\u6548\u7684 Base64 \u4E8C\u8FDB\u5236\u6570\u636E");
+  }
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  if (!isZipBytes(bytes)) {
+    throw new Error("Base64 \u6587\u4EF6\u89E3\u7801\u540E\u4E0D\u662F\u6709\u6548\u7684 Office \u6587\u6863");
+  }
+  if (globalThis.btoa(binary).replace(/=+$/, "") !== base64.replace(/=+$/, "")) {
+    throw new Error("\u6587\u4EF6\u5185\u5BB9\u662F\u65E0\u6548\u7684 Base64 \u4E8C\u8FDB\u5236\u6570\u636E");
+  }
+  return new Blob([bytes], { type: blob.type || "application/zip" });
+};
+var normalizePreviewBlobContent = async (response) => {
+  const blob = normalizePreviewBlobResponse(response);
+  if (String(blob.type || "").toLowerCase().includes("application/json")) {
+    const payload = await blob.text().then((value) => JSON.parse(value)).catch(() => null);
+    if (payload) {
+      throw new Error(getBinaryResponseMessage(payload) || "\u6587\u4EF6\u5185\u5BB9\u8BF7\u6C42\u5931\u8D25");
+    }
+  }
+  return decodeBase64ZipBlob(blob);
+};
+var isDirectStorageItem = (item) => item.provider === "oss" || item.uploadProvider === "oss" || item.uploadProvider === "builtin-oss" || Boolean(item.storageCode);
+var getPreviewItemKey = (item, index = 0) => getAttachmentItemIdentity(item) || item.id || item.uid || `${item.name || "file"}-${index}`;
+var getPreviewSourceUrl = (item) => item.previewUrl || item.publicUrl || item.url || "";
+var inferExtensionFromContentType = (contentType) => {
+  if (contentType.includes("wordprocessingml")) return "docx";
+  if (contentType.includes("spreadsheetml")) return "xlsx";
+  if (contentType.includes("pdf")) return "pdf";
+  if (contentType.includes("heic")) return "heic";
+  if (contentType.includes("heif")) return "heif";
+  if (contentType.includes("tiff")) return "tiff";
+  if (contentType.includes("csv")) return "csv";
+  return "";
+};
+var downloadOnly = (extension, unsupportedReason) => ({
+  extension,
+  previewType: "download",
+  renderMode: "download",
+  previewSurface: "download",
+  previewProvider: "none",
+  canPreview: false,
+  canDownload: true,
+  unsupportedReason
+});
+var resolveLocalPreviewCapability = (item) => {
+  const contentType = String(item.contentType || item.mimeType || "").toLowerCase();
+  const extension = getFileExtension(item.name || item.originalName || item.objectName || "") || inferExtensionFromContentType(contentType);
+  const size = Number(item.size || 0);
+  if (IMAGE_EXTENSIONS.has(extension) || contentType.startsWith("image/")) {
+    if (["heic", "heif"].includes(extension) && size > 0 && size > DIRECT_HEIC_MAX_BYTES) {
+      return downloadOnly(extension, "HEIC \u56FE\u7247\u8D85\u8FC7 30MB \u6D4F\u89C8\u5668\u8F6C\u6362\u4E0A\u9650");
+    }
+    const platformTranscode = ["tif", "tiff"].includes(extension) && Boolean(item.objectName) && !isDirectStorageItem(item);
+    return {
+      extension,
+      previewType: "image",
+      renderMode: ["heic", "heif"].includes(extension) ? "image-heic" : platformTranscode ? "image-transcode" : ["tif", "tiff"].includes(extension) ? "download" : "inline",
+      previewSurface: "media",
+      previewProvider: platformTranscode ? "platform" : "browser",
+      canPreview: platformTranscode || !["tif", "tiff"].includes(extension),
+      canDownload: true,
+      unsupportedReason: ["tif", "tiff"].includes(extension) ? "\u76F4\u8FDE TIFF \u6587\u4EF6\u9700\u8981\u5E73\u53F0\u6587\u4EF6\u670D\u52A1\u8F6C\u6362\u540E\u624D\u80FD\u9884\u89C8" : void 0
+    };
+  }
+  if (VIDEO_EXTENSIONS.has(extension) || contentType.startsWith("video/")) {
+    return {
+      extension,
+      previewType: "video",
+      renderMode: "inline",
+      previewSurface: "media",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  if (AUDIO_EXTENSIONS.has(extension) || contentType.startsWith("audio/")) {
+    return {
+      extension,
+      previewType: "audio",
+      renderMode: "inline",
+      previewSurface: "media",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  if (extension === "pdf" || contentType.includes("pdf")) {
+    return {
+      extension: extension || "pdf",
+      previewType: "pdf",
+      renderMode: "pdfjs",
+      previewSurface: "document",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  if (extension === "docx") {
+    if (size > 0 && size > DIRECT_DOCX_MAX_BYTES) {
+      return downloadOnly(extension, "Word \u6587\u4EF6\u8D85\u8FC7 20MB \u6D4F\u89C8\u5668\u9884\u89C8\u4E0A\u9650");
+    }
+    return {
+      extension,
+      previewType: "office",
+      renderMode: "docx-html",
+      previewSurface: "document",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  if (extension === "xlsx") {
+    if (size > 0 && size > DIRECT_XLSX_MAX_BYTES) {
+      return downloadOnly(extension, "Excel \u6587\u4EF6\u8D85\u8FC7 10MB \u6D4F\u89C8\u5668\u9884\u89C8\u4E0A\u9650");
+    }
+    return {
+      extension,
+      previewType: "spreadsheet",
+      renderMode: "excel-client",
+      previewSurface: "document",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  if (TEXT_EXTENSIONS.has(extension) || contentType.startsWith("text/")) {
+    return {
+      extension,
+      previewType: "text",
+      renderMode: "text-client",
+      previewSurface: "document",
+      previewProvider: "browser",
+      canPreview: true,
+      canDownload: true
+    };
+  }
+  return downloadOnly(extension, "\u5F53\u524D\u6587\u4EF6\u7C7B\u578B\u6CA1\u6709\u53EF\u7528\u7684\u5728\u7EBF\u9884\u89C8\u5668");
+};
+var getTicketObject = (ticket) => typeof ticket === "string" ? { previewUrl: ticket } : ticket || {};
+var prepareFilePreview = async (options) => {
+  const { item, api, appType, bucketName } = options;
+  const direct = isDirectStorageItem(item) || !item.objectName;
+  if (direct) {
+    const capability = resolveLocalPreviewCapability(item);
+    return {
+      item,
+      direct: true,
+      metadata: {
+        ...capability,
+        fileName: item.name,
+        size: item.size,
+        contentType: item.contentType || item.mimeType,
+        previewUrl: getPreviewSourceUrl(item),
+        downloadUrl: item.downloadUrl || item.publicUrl || item.url
+      }
+    };
+  }
+  const ticketResult = getTicketObject(
+    await api.createFileAccessTicket(
+      item.bucketName || bucketName,
+      item.objectName,
+      item.name,
+      "preview",
+      { appType: item.appType || appType }
+    )
+  );
+  const localCapability = resolveLocalPreviewCapability(item);
+  const ticket = String(ticketResult.ticket || "").trim();
+  let metadata = {};
+  if (ticketResult.metadataUrl || ticket) {
+    const response = await api.request({
+      url: ticketResult.metadataUrl || `/file/access-ticket/${encodeURIComponent(ticket)}`,
+      method: "get"
+    });
+    metadata = unwrapFilePreviewPayload(response);
+  }
+  return {
+    item,
+    direct: false,
+    metadata: {
+      ...localCapability,
+      ...ticketResult,
+      ...metadata,
+      ticket: metadata.ticket || ticketResult.ticket,
+      fileName: metadata.fileName || ticketResult.fileName || item.name,
+      size: metadata.size ?? item.size,
+      contentType: metadata.contentType || ticketResult.contentType || item.contentType || item.mimeType,
+      previewUrl: ticketResult.previewUrl || metadata.previewUrl || getPreviewSourceUrl(item),
+      downloadUrl: ticketResult.downloadUrl || metadata.downloadUrl || item.downloadUrl || item.publicUrl || item.url
+    }
+  };
+};
+var loadPreviewBlob = async (request, url) => {
+  const response = await request({ url, method: "get", responseType: "blob" });
+  return normalizePreviewBlobContent(response);
+};
+var convertHeicPreview = async (request, url) => {
+  const source = await loadPreviewBlob(request, url);
+  const module = await import("heic2any");
+  const converted = await module.default({
+    blob: source,
+    toType: "image/jpeg",
+    quality: 0.92
+  });
+  const blob = Array.isArray(converted) ? converted[0] : converted;
+  if (!(blob instanceof Blob)) {
+    throw new Error("HEIC \u56FE\u7247\u8F6C\u6362\u5931\u8D25");
+  }
+  return URL.createObjectURL(blob);
+};
+
+// packages/sdk/src/components/file-preview/FilePreviewContent.tsx
+import { useEffect as useEffect3, useMemo as useMemo4, useRef as useRef2, useState as useState3 } from "react";
+import { Alert, Button, Empty, Image as Image2, Spin, Table, Tabs, Typography } from "antd";
+import { DownloadOutlined, FileOutlined, ReloadOutlined } from "@ant-design/icons";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var formatPreviewFileSize = (size) => {
+  const value = Number(size || 0);
+  if (!value) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const index = Math.min(
+    units.length - 1,
+    Math.floor(Math.log(value) / Math.log(1024))
+  );
+  return `${(value / Math.pow(1024, index)).toFixed(index === 0 ? 0 : 1)} ${units[index]}`;
+};
+var resolvePreviewServiceUrl = (url, servicePrefix = "/service") => {
+  const value = String(url || "").trim();
+  if (!value) return "";
+  if (/^(https?:)?\/\//i.test(value) || /^(blob|data):/i.test(value)) return value;
+  if (value === servicePrefix || value.startsWith(`${servicePrefix}/`)) return value;
+  if (value.startsWith("/file/")) {
+    return `${servicePrefix.replace(/\/+$/, "")}${value}`;
+  }
+  return value;
+};
+var toColumnName = (index) => {
+  let value = index + 1;
+  let name = "";
+  while (value > 0) {
+    const mod = (value - 1) % 26;
+    name = String.fromCharCode(65 + mod) + name;
+    value = Math.floor((value - mod) / 26);
+  }
+  return name;
+};
+var buildRowsTable = (rows = []) => {
+  const maxColumns = rows.reduce(
+    (count, row) => Math.max(count, Array.isArray(row) ? row.length : 0),
+    0
+  );
+  const columns = [
+    {
+      title: "#",
+      dataIndex: "__row",
+      key: "__row",
+      width: 58,
+      fixed: "left",
+      render: (value) => /* @__PURE__ */ jsx3(Typography.Text, { type: "secondary", children: value })
+    },
+    ...Array.from({ length: maxColumns }).map((_, index) => ({
+      title: toColumnName(index),
+      dataIndex: `col_${index}`,
+      key: `col_${index}`,
+      width: 168,
+      render: (value) => /* @__PURE__ */ jsx3(Typography.Text, { ellipsis: { tooltip: String(value ?? "") }, children: String(value ?? "") })
+    }))
+  ];
+  const dataSource = rows.map((row, rowIndex) => {
+    const record = { key: rowIndex, __row: rowIndex + 1 };
+    (Array.isArray(row) ? row : []).forEach((value, colIndex) => {
+      record[`col_${colIndex}`] = value;
+    });
+    return record;
+  });
+  return { columns, dataSource };
+};
+var CenteredState = ({ children }) => /* @__PURE__ */ jsx3(
+  "div",
+  {
+    style: {
+      minHeight: 280,
+      height: "100%",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      padding: 24
+    },
+    children
+  }
+);
+var PayloadPreview = ({
+  request,
+  url,
+  mode
+}) => {
+  const [payload, setPayload] = useState3(null);
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3("");
+  const [reloadKey, setReloadKey] = useState3(0);
+  useEffect3(() => {
+    let disposed = false;
+    setPayload(null);
+    setError("");
+    if (!url) return () => {
+      disposed = true;
+    };
+    setLoading(true);
+    request({ url, method: "get" }).then((response) => {
+      if (!disposed) setPayload(unwrapFilePreviewPayload(response));
+    }).catch((currentError) => {
+      if (!disposed) setError(currentError?.message || "\u6587\u4EF6\u9884\u89C8\u5185\u5BB9\u52A0\u8F7D\u5931\u8D25");
+    }).finally(() => {
+      if (!disposed) setLoading(false);
+    });
+    return () => {
+      disposed = true;
+    };
+  }, [reloadKey, request, url]);
+  if (loading) {
+    return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: mode === "excel" ? "\u6B63\u5728\u89E3\u6790\u5DE5\u4F5C\u7C3F..." : "\u6B63\u5728\u8BFB\u53D6\u6587\u672C..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(
+      Alert,
+      {
+        type: "error",
+        showIcon: true,
+        title: error,
+        action: /* @__PURE__ */ jsx3(Button, { icon: /* @__PURE__ */ jsx3(ReloadOutlined, {}), onClick: () => setReloadKey((value) => value + 1), children: "\u91CD\u8BD5" })
+      }
+    ) });
+  }
+  if (mode === "excel") {
+    const sheets = Array.isArray(payload?.sheets) ? payload.sheets : [];
+    if (!sheets.length) {
+      return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Empty, { description: "\u6682\u65E0\u53EF\u9884\u89C8\u7684\u5DE5\u4F5C\u8868" }) });
+    }
+    return /* @__PURE__ */ jsx3(
+      Tabs,
+      {
+        style: { height: "100%", padding: "0 16px" },
+        items: sheets.map((sheet) => {
+          const table = buildRowsTable(sheet.rows || []);
+          return {
+            key: String(sheet.id || sheet.name),
+            label: sheet.name || "Sheet",
+            children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [
+              sheet.truncatedRows || sheet.truncatedColumns ? /* @__PURE__ */ jsx3(
+                Alert,
+                {
+                  type: "info",
+                  showIcon: true,
+                  title: `\u5DE5\u4F5C\u8868\u8F83\u5927\uFF0C\u4EC5\u5C55\u793A\u524D ${payload.maxRows || 200} \u884C\u3001${payload.maxColumns || 60} \u5217\u3002`
+                }
+              ) : null,
+              /* @__PURE__ */ jsx3(
+                Table,
+                {
+                  bordered: true,
+                  size: "small",
+                  pagination: false,
+                  scroll: { x: "max-content", y: "min(66vh, 680px)" },
+                  columns: table.columns,
+                  dataSource: table.dataSource
+                }
+              )
+            ] })
+          };
+        })
+      }
+    );
+  }
+  const text = String(payload?.text || "");
+  return /* @__PURE__ */ jsxs("div", { style: { height: "100%", overflow: "auto", background: "#fff" }, children: [
+    payload?.truncated ? /* @__PURE__ */ jsx3(
+      Alert,
+      {
+        type: "info",
+        showIcon: true,
+        banner: true,
+        title: "\u6587\u4EF6\u8F83\u5927\uFF0C\u4EC5\u5C55\u793A\u524D\u90E8\u5185\u5BB9\uFF1B\u5B8C\u6574\u5185\u5BB9\u8BF7\u4E0B\u8F7D\u67E5\u770B\u3002"
+      }
+    ) : null,
+    /* @__PURE__ */ jsx3(
+      "pre",
+      {
+        style: {
+          minHeight: 280,
+          margin: 0,
+          padding: 20,
+          color: "#1f2328",
+          background: "#fff",
+          fontSize: 13,
+          lineHeight: 1.7,
+          whiteSpace: "pre-wrap",
+          wordBreak: "break-word",
+          fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace'
+        },
+        children: text || "\u6682\u65E0\u6587\u672C\u5185\u5BB9"
+      }
+    )
+  ] });
+};
+var ClientTextPreview = ({
+  request,
+  url
+}) => {
+  const [payload, setPayload] = useState3(null);
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    let disposed = false;
+    let textLimit = 1024 * 1024;
+    loadPreviewBlob(request, url).then(async (blob) => {
+      const slice = blob.size > textLimit ? blob.slice(0, textLimit) : blob;
+      const text = await slice.text();
+      if (!disposed) setPayload({ text, truncated: blob.size > textLimit });
+    }).catch((currentError) => {
+      if (!disposed) setError(currentError?.message || "\u6587\u672C\u8BFB\u53D6\u5931\u8D25");
+    });
+    return () => {
+      disposed = true;
+      textLimit = 0;
+    };
+  }, [request, url]);
+  if (error) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Alert, { type: "error", showIcon: true, title: error }) });
+  if (!payload) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: "\u6B63\u5728\u8BFB\u53D6\u6587\u672C..." }) });
+  return /* @__PURE__ */ jsxs("div", { style: { height: "100%", overflow: "auto", background: "#fff" }, children: [
+    payload.truncated ? /* @__PURE__ */ jsx3(Alert, { type: "info", showIcon: true, banner: true, title: "\u6587\u4EF6\u8F83\u5927\uFF0C\u4EC5\u5C55\u793A\u524D\u90E8\u5185\u5BB9\u3002" }) : null,
+    /* @__PURE__ */ jsx3(
+      "pre",
+      {
+        style: {
+          margin: 0,
+          padding: 20,
+          whiteSpace: "pre-wrap",
+          wordBreak: "break-word",
+          fontSize: 13,
+          lineHeight: 1.7
+        },
+        children: payload.text || "\u6682\u65E0\u6587\u672C\u5185\u5BB9"
+      }
+    )
+  ] });
+};
+var DocxPreview = ({ request, url }) => {
+  const containerRef = useRef2(null);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    let disposed = false;
+    const container = containerRef.current;
+    if (!container || !url) return () => {
+      disposed = true;
+    };
+    container.innerHTML = "";
+    setLoading(true);
+    setError("");
+    (async () => {
+      try {
+        const blob = await loadPreviewBlob(request, url);
+        const { renderAsync } = await import("docx-preview");
+        if (disposed || !containerRef.current) return;
+        await renderAsync(blob, containerRef.current, containerRef.current, {
+          className: "sy-docx-preview",
+          inWrapper: true,
+          breakPages: true,
+          ignoreLastRenderedPageBreak: false,
+          renderHeaders: true,
+          renderFooters: true,
+          renderFootnotes: true,
+          renderEndnotes: true,
+          useBase64URL: false
+        });
+      } catch (currentError) {
+        if (!disposed) setError(currentError?.message || "Word \u6587\u6863\u89E3\u6790\u5931\u8D25");
+      } finally {
+        if (!disposed) setLoading(false);
+      }
+    })();
+    return () => {
+      disposed = true;
+      if (container) container.innerHTML = "";
+    };
+  }, [request, url]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        minHeight: 360,
+        height: "100%",
+        overflow: "auto",
+        position: "relative",
+        background: "#e9edf2"
+      },
+      children: [
+        loading ? /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: "\u6B63\u5728\u8FD8\u539F Word \u7248\u5F0F..." }) }) : null,
+        error ? /* @__PURE__ */ jsx3("div", { style: { padding: 20 }, children: /* @__PURE__ */ jsx3(Alert, { type: "error", showIcon: true, title: error }) }) : null,
+        /* @__PURE__ */ jsx3("div", { ref: containerRef, style: { display: loading || error ? "none" : "block" } })
+      ]
+    }
+  );
+};
+var HeicImagePreview = ({
+  request,
+  url,
+  fileName
+}) => {
+  const [src, setSrc] = useState3("");
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    let disposed = false;
+    let objectUrl = "";
+    convertHeicPreview(request, url).then((result) => {
+      objectUrl = result;
+      if (!disposed) setSrc(result);
+    }).catch((currentError) => {
+      if (!disposed) setError(currentError?.message || "HEIC \u56FE\u7247\u8F6C\u6362\u5931\u8D25");
+    });
+    return () => {
+      disposed = true;
+      if (objectUrl) URL.revokeObjectURL?.(objectUrl);
+    };
+  }, [request, url]);
+  if (error) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Alert, { type: "error", showIcon: true, title: error }) });
+  if (!src) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: "\u6B63\u5728\u8F6C\u6362 HEIC \u56FE\u7247..." }) });
+  return /* @__PURE__ */ jsx3("div", { style: { minHeight: 320, textAlign: "center", padding: 20, background: "#f3f5f7" }, children: /* @__PURE__ */ jsx3(
+    Image2,
+    {
+      src,
+      alt: fileName || "HEIC \u56FE\u7247\u9884\u89C8",
+      style: { maxWidth: "100%", maxHeight: "72vh", objectFit: "contain" }
+    }
+  ) });
+};
+var ClientSpreadsheetPreview = ({
+  request,
+  url
+}) => {
+  const [payload, setPayload] = useState3(null);
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    let disposed = false;
+    (async () => {
+      try {
+        const blob = await loadPreviewBlob(request, url);
+        const XLSX = await import("xlsx");
+        const workbook = XLSX.read(await blob.arrayBuffer(), {
+          cellDates: true,
+          dense: true
+        });
+        const maxRows = 500;
+        const maxColumns = 100;
+        const sheets = workbook.SheetNames.map((name, index) => {
+          const allRows = XLSX.utils.sheet_to_json(workbook.Sheets[name], {
+            header: 1,
+            defval: "",
+            raw: false
+          });
+          const columnCount = allRows.reduce(
+            (count, row) => Math.max(count, Array.isArray(row) ? row.length : 0),
+            0
+          );
+          return {
+            id: index,
+            name,
+            rows: allRows.slice(0, maxRows).map(
+              (row) => (Array.isArray(row) ? row : []).slice(0, maxColumns)
+            ),
+            truncatedRows: allRows.length > maxRows,
+            truncatedColumns: columnCount > maxColumns
+          };
+        });
+        if (!disposed) setPayload({ sheets, maxRows, maxColumns });
+      } catch (currentError) {
+        if (!disposed) setError(currentError?.message || "Excel \u6587\u4EF6\u89E3\u6790\u5931\u8D25");
+      }
+    })();
+    return () => {
+      disposed = true;
+    };
+  }, [request, url]);
+  if (error) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Alert, { type: "error", showIcon: true, title: error }) });
+  if (!payload) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: "\u6B63\u5728\u89E3\u6790\u5DE5\u4F5C\u7C3F..." }) });
+  return /* @__PURE__ */ jsx3(PayloadPreviewFromValue, { payload });
+};
+var PayloadPreviewFromValue = ({ payload }) => {
+  const sheets = Array.isArray(payload?.sheets) ? payload.sheets : [];
+  if (!sheets.length) return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Empty, { description: "\u6682\u65E0\u53EF\u9884\u89C8\u7684\u5DE5\u4F5C\u8868" }) });
+  return /* @__PURE__ */ jsx3(
+    Tabs,
+    {
+      style: { height: "100%", padding: "0 16px" },
+      items: sheets.map((sheet) => {
+        const table = buildRowsTable(sheet.rows || []);
+        return {
+          key: String(sheet.id ?? sheet.name),
+          label: sheet.name || "Sheet",
+          children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [
+            sheet.truncatedRows || sheet.truncatedColumns ? /* @__PURE__ */ jsx3(
+              Alert,
+              {
+                type: "info",
+                showIcon: true,
+                title: `\u5DE5\u4F5C\u8868\u8F83\u5927\uFF0C\u4EC5\u5C55\u793A\u524D ${payload.maxRows} \u884C\u3001${payload.maxColumns} \u5217\u3002`
+              }
+            ) : null,
+            /* @__PURE__ */ jsx3(
+              Table,
+              {
+                bordered: true,
+                size: "small",
+                pagination: false,
+                scroll: { x: "max-content", y: "min(66vh, 680px)" },
+                columns: table.columns,
+                dataSource: table.dataSource
+              }
+            )
+          ] })
+        };
+      })
+    }
+  );
+};
+var scriptPromises = /* @__PURE__ */ new Map();
+var loadScriptOnce = (src) => {
+  const existingPromise = scriptPromises.get(src);
+  if (existingPromise) return existingPromise;
+  const promise = new Promise((resolve, reject) => {
+    if (!src || typeof document === "undefined") {
+      reject(new Error("ONLYOFFICE \u811A\u672C\u5730\u5740\u4E0D\u53EF\u7528"));
+      return;
+    }
+    const existed = document.querySelector(`script[src="${src}"]`);
+    if (existed?.dataset.loaded === "true") {
+      resolve();
+      return;
+    }
+    const script = existed || document.createElement("script");
+    script.src = src;
+    script.async = true;
+    script.onload = () => {
+      script.dataset.loaded = "true";
+      resolve();
+    };
+    script.onerror = () => reject(new Error("ONLYOFFICE \u811A\u672C\u52A0\u8F7D\u5931\u8D25"));
+    if (!existed) document.body.appendChild(script);
+  });
+  scriptPromises.set(src, promise);
+  promise.catch(() => scriptPromises.delete(src));
+  return promise;
+};
+var OnlyOfficePreview = ({
+  request,
+  configUrl,
+  ticket
+}) => {
+  const editorId = useMemo4(
+    () => `openxiangda-onlyoffice-${String(ticket || "editor").replace(/[^a-zA-Z0-9_-]/g, "")}`,
+    [ticket]
+  );
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    let disposed = false;
+    let editor;
+    setLoading(true);
+    setError("");
+    (async () => {
+      try {
+        const response = await request({ url: configUrl, method: "get" });
+        const payload = unwrapFilePreviewPayload(response);
+        const scriptUrl = `${String(payload?.documentServerUrl || "").replace(
+          /\/+$/,
+          ""
+        )}/web-apps/apps/api/documents/api.js`;
+        await loadScriptOnce(scriptUrl);
+        if (!disposed && window.DocsAPI?.DocEditor) {
+          editor = new window.DocsAPI.DocEditor(editorId, payload.config);
+        }
+      } catch (currentError) {
+        if (!disposed) setError(currentError?.message || "ONLYOFFICE \u9884\u89C8\u52A0\u8F7D\u5931\u8D25");
+      } finally {
+        if (!disposed) setLoading(false);
+      }
+    })();
+    return () => {
+      disposed = true;
+      editor?.destroyEditor?.();
+    };
+  }, [configUrl, editorId, request]);
+  return /* @__PURE__ */ jsxs("div", { style: { height: "100%", minHeight: 420, position: "relative", background: "#fff" }, children: [
+    loading ? /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(Spin, { description: "\u6B63\u5728\u52A0\u8F7D ONLYOFFICE..." }) }) : null,
+    error ? /* @__PURE__ */ jsx3("div", { style: { padding: 20 }, children: /* @__PURE__ */ jsx3(Alert, { type: "error", showIcon: true, title: error }) }) : null,
+    /* @__PURE__ */ jsx3("div", { id: editorId, style: { height: "100%", minHeight: 420, display: error ? "none" : "block" } })
+  ] });
+};
+var FilePreviewContent = ({
+  metadata,
+  request,
+  servicePrefix = "/service",
+  onDownload
+}) => {
+  const renderMode = metadata.renderMode || "download";
+  const previewUrl = resolvePreviewServiceUrl(metadata.previewUrl, servicePrefix);
+  const imageUrl = resolvePreviewServiceUrl(
+    renderMode === "image-transcode" ? metadata.imagePreviewUrl : metadata.previewUrl,
+    servicePrefix
+  );
+  if (renderMode === "inline" && metadata.previewType === "image") {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        style: {
+          height: "100%",
+          minHeight: 320,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          overflow: "auto",
+          padding: 20,
+          background: "#f3f5f7"
+        },
+        children: /* @__PURE__ */ jsx3(
+          Image2,
+          {
+            src: imageUrl,
+            alt: metadata.fileName || "\u56FE\u7247\u9884\u89C8",
+            style: { maxWidth: "100%", maxHeight: "72vh", objectFit: "contain" }
+          }
+        )
+      }
+    );
+  }
+  if (renderMode === "image-transcode") {
+    return /* @__PURE__ */ jsx3("div", { style: { minHeight: 320, textAlign: "center", padding: 20, background: "#f3f5f7" }, children: /* @__PURE__ */ jsx3(
+      Image2,
+      {
+        src: imageUrl,
+        alt: metadata.fileName || "\u56FE\u7247\u9884\u89C8",
+        style: { maxWidth: "100%", maxHeight: "72vh", objectFit: "contain" }
+      }
+    ) });
+  }
+  if (renderMode === "image-heic") {
+    return /* @__PURE__ */ jsx3(
+      HeicImagePreview,
+      {
+        request,
+        url: previewUrl,
+        fileName: metadata.fileName
+      }
+    );
+  }
+  if (renderMode === "inline" && metadata.previewType === "video") {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        style: {
+          height: "100%",
+          minHeight: 320,
+          display: "flex",
+          alignItems: "center",
+          background: "#080a0d"
+        },
+        children: /* @__PURE__ */ jsx3(
+          "video",
+          {
+            controls: true,
+            playsInline: true,
+            preload: "metadata",
+            src: previewUrl,
+            style: { width: "100%", maxHeight: "76vh" },
+            children: "\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u89C6\u9891\u64AD\u653E\u3002"
+          }
+        )
+      }
+    );
+  }
+  if (renderMode === "inline" && metadata.previewType === "audio") {
+    return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3("audio", { controls: true, preload: "metadata", src: previewUrl, style: { width: "min(680px, 100%)" }, children: "\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u97F3\u9891\u64AD\u653E\u3002" }) });
+  }
+  if (renderMode === "pdfjs") {
+    return /* @__PURE__ */ jsx3(
+      "iframe",
+      {
+        title: metadata.fileName || "PDF \u9884\u89C8",
+        src: previewUrl,
+        style: { width: "100%", height: "100%", minHeight: 520, border: 0, background: "#fff" }
+      }
+    );
+  }
+  if (renderMode === "docx-html") {
+    return /* @__PURE__ */ jsx3(DocxPreview, { request, url: previewUrl });
+  }
+  if (renderMode === "excel-client") {
+    return /* @__PURE__ */ jsx3(ClientSpreadsheetPreview, { request, url: previewUrl });
+  }
+  if (renderMode === "excel-basic") {
+    return /* @__PURE__ */ jsx3(
+      PayloadPreview,
+      {
+        request,
+        url: metadata.excelPreviewUrl || "",
+        mode: "excel"
+      }
+    );
+  }
+  if (renderMode === "text-client") {
+    return /* @__PURE__ */ jsx3(ClientTextPreview, { request, url: previewUrl });
+  }
+  if (renderMode === "text" || renderMode === "office-text") {
+    return /* @__PURE__ */ jsx3(
+      PayloadPreview,
+      {
+        request,
+        url: renderMode === "office-text" ? metadata.officeTextPreviewUrl || "" : metadata.textPreviewUrl || "",
+        mode: "text"
+      }
+    );
+  }
+  if (renderMode === "onlyoffice") {
+    return /* @__PURE__ */ jsx3(
+      OnlyOfficePreview,
+      {
+        request,
+        configUrl: metadata.onlyofficeConfigUrl || `/file/onlyoffice/config/${encodeURIComponent(metadata.ticket || "")}`,
+        ticket: metadata.ticket
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(CenteredState, { children: /* @__PURE__ */ jsx3(
+    Empty,
+    {
+      image: /* @__PURE__ */ jsx3(FileOutlined, { style: { fontSize: 52, color: "#8c8c8c" } }),
+      description: /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx3(Typography.Text, { strong: true, children: "\u5F53\u524D\u6587\u4EF6\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8" }),
+        /* @__PURE__ */ jsx3("br", {}),
+        /* @__PURE__ */ jsx3(Typography.Text, { type: "secondary", children: metadata.unsupportedReason || "\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528\u672C\u5730\u5E94\u7528\u6253\u5F00\u3002" })
+      ] }),
+      children: onDownload ? /* @__PURE__ */ jsx3(Button, { type: "primary", icon: /* @__PURE__ */ jsx3(DownloadOutlined, {}), onClick: onDownload, children: "\u4E0B\u8F7D\u6587\u4EF6" }) : null
+    }
+  ) });
+};
+
+// packages/sdk/src/components/file-preview/FilePreviewPage.tsx
+import { useCallback as useCallback3, useEffect as useEffect4, useState as useState4 } from "react";
+import { Alert as Alert2, Button as Button2, Empty as Empty2, Spin as Spin2, Tag, Tooltip, Typography as Typography2 } from "antd";
+import {
+  ArrowLeftOutlined,
+  DownloadOutlined as DownloadOutlined2,
+  FileOutlined as FileOutlined2,
+  ReloadOutlined as ReloadOutlined2
+} from "@ant-design/icons";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+
+// packages/sdk/src/components/file-preview/useFilePreview.tsx
+import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo5, useState as useState5 } from "react";
+import { Alert as Alert3, Button as Button3, Image as Image3, Modal, Spin as Spin3, Typography as Typography3 } from "antd";
+import { CloseOutlined, DownloadOutlined as DownloadOutlined3 } from "@ant-design/icons";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var canActOnItem = (item) => item.status !== "uploading" && item.status !== "error";
+var revokeImageItems = (items) => {
+  items.forEach((item) => {
+    if (item.revokeOnClose && item.src.startsWith("blob:")) {
+      URL.revokeObjectURL?.(item.src);
+    }
+  });
+};
+var buildCapabilityMap = (items, requireServerCapability) => {
+  const result = {};
+  items.forEach((item, index) => {
+    const key = getPreviewItemKey(item, index);
+    const local = resolveLocalPreviewCapability(item);
+    result[key] = requireServerCapability && item.objectName && !isDirectStorageItem(item) ? { ...local, canPreview: false } : local;
+  });
+  return result;
+};
+var useFilePreviewController = ({
+  items,
+  api,
+  appType,
+  bucketName,
+  enabled = true,
+  requireServerCapability = true
+}) => {
+  const itemSignature = useMemo5(
+    () => items.map(
+      (item, index) => [
+        getPreviewItemKey(item, index),
+        item.name,
+        item.objectName,
+        item.contentType,
+        item.size,
+        item.status
+      ].join(":")
+    ).join("|"),
+    [items]
+  );
+  const [capabilities, setCapabilities] = useState5(
+    () => buildCapabilityMap(items, requireServerCapability)
+  );
+  const [openingKey, setOpeningKey] = useState5("");
+  const [dialogPreview, setDialogPreview] = useState5(null);
+  const [imagePreview, setImagePreview] = useState5({
+    open: false,
+    current: 0,
+    items: []
+  });
+  useEffect5(() => {
+    let disposed = false;
+    const initial = buildCapabilityMap(items, requireServerCapability);
+    setCapabilities(initial);
+    if (!enabled || !requireServerCapability) return () => {
+      disposed = true;
+    };
+    const protectedItems = items.map((item, index) => ({ item, key: getPreviewItemKey(item, index) })).filter(
+      ({ item }) => canActOnItem(item) && Boolean(item.objectName) && !isDirectStorageItem(item)
+    );
+    if (!protectedItems.length) return () => {
+      disposed = true;
+    };
+    api.request({
+      url: "/file/preview-capabilities",
+      method: "post",
+      data: {
+        files: protectedItems.map(({ item, key }) => ({
+          key,
+          fileName: item.name,
+          objectName: item.objectName,
+          contentType: item.contentType || item.mimeType,
+          size: item.size
+        }))
+      }
+    }).then((response) => {
+      if (disposed) return;
+      const payload = unwrapFilePreviewPayload(response);
+      const next = { ...initial };
+      (payload?.items || []).forEach((capability) => {
+        if (capability.key) next[capability.key] = capability;
+      });
+      setCapabilities(next);
+    }).catch(() => {
+      if (disposed) return;
+      const fallback = { ...initial };
+      protectedItems.forEach(({ item, key }) => {
+        fallback[key] = resolveLocalPreviewCapability(item);
+      });
+      setCapabilities(fallback);
+    });
+    return () => {
+      disposed = true;
+    };
+  }, [api, enabled, itemSignature, requireServerCapability]);
+  const getCapability = useCallback4(
+    (item) => {
+      const index = items.indexOf(item);
+      return capabilities[getPreviewItemKey(item, Math.max(index, 0))];
+    },
+    [capabilities, items]
+  );
+  const canPreview = useCallback4(
+    (item) => enabled && canActOnItem(item) && getCapability(item)?.canPreview === true,
+    [enabled, getCapability]
+  );
+  const closeImagePreview = useCallback4(() => {
+    setImagePreview((current) => {
+      revokeImageItems(current.items);
+      return { open: false, current: 0, items: [] };
+    });
+  }, []);
+  useEffect5(
+    () => () => revokeImageItems(imagePreview.items),
+    [imagePreview.items]
+  );
+  const resolvePreparedImageItem = useCallback4(
+    async (prepared, index) => {
+      const item = prepared.item;
+      const metadata = prepared.metadata;
+      let src = resolvePreviewServiceUrl(
+        metadata.renderMode === "image-transcode" ? metadata.imagePreviewUrl : metadata.previewUrl
+      );
+      let revokeOnClose = false;
+      if (metadata.renderMode === "image-heic") {
+        src = await convertHeicPreview(api.request, src);
+        revokeOnClose = true;
+      }
+      if (!src) throw new Error(`${item.name || "\u56FE\u7247"}\u6CA1\u6709\u53EF\u7528\u7684\u9884\u89C8\u5730\u5740`);
+      return {
+        key: getPreviewItemKey(item, index),
+        src,
+        name: metadata.fileName || item.name,
+        revokeOnClose
+      };
+    },
+    [api]
+  );
+  const prepareImageItem = useCallback4(
+    async (item, index) => {
+      const prepared = await prepareFilePreview({ item, api, appType, bucketName });
+      return resolvePreparedImageItem(prepared, index);
+    },
+    [api, appType, bucketName, resolvePreparedImageItem]
+  );
+  const openPreview = useCallback4(
+    async (item) => {
+      const itemIndex = Math.max(items.indexOf(item), 0);
+      const key = getPreviewItemKey(item, itemIndex);
+      setOpeningKey(key);
+      try {
+        const prepared = await prepareFilePreview({ item, api, appType, bucketName });
+        if (prepared.metadata.canPreview === false || prepared.metadata.renderMode === "download") {
+          setDialogPreview(prepared);
+          return;
+        }
+        if (prepared.metadata.previewType === "image") {
+          const galleryCandidates = items.map((candidate, index) => ({ candidate, index })).filter(({ candidate }) => {
+            const capability = getCapability(candidate) || resolveLocalPreviewCapability(candidate);
+            return canActOnItem(candidate) && capability.canPreview && capability.previewType === "image";
+          });
+          const results = await Promise.allSettled(
+            galleryCandidates.map(
+              ({ candidate, index }) => candidate === item ? resolvePreparedImageItem(prepared, index) : prepareImageItem(candidate, index)
+            )
+          );
+          const gallery = results.flatMap(
+            (result) => result.status === "fulfilled" ? [result.value] : []
+          );
+          if (!gallery.length || !gallery.some((image) => image.key === key)) {
+            const fallback = await resolvePreparedImageItem(prepared, itemIndex);
+            gallery.push(fallback);
+          }
+          const current = Math.max(0, gallery.findIndex((image) => image.key === key));
+          closeImagePreview();
+          setImagePreview({ open: true, current, items: gallery });
+          return;
+        }
+        setDialogPreview(prepared);
+      } catch (error) {
+        setDialogPreview({
+          item,
+          direct: isDirectStorageItem(item),
+          metadata: {
+            ...resolveLocalPreviewCapability(item),
+            fileName: item.name,
+            size: item.size,
+            renderMode: "download",
+            canPreview: false,
+            unsupportedReason: error?.message || "\u6587\u4EF6\u9884\u89C8\u52A0\u8F7D\u5931\u8D25",
+            downloadUrl: item.downloadUrl || item.publicUrl || item.url
+          }
+        });
+      } finally {
+        setOpeningKey("");
+      }
+    },
+    [
+      api,
+      appType,
+      bucketName,
+      closeImagePreview,
+      getCapability,
+      items,
+      prepareImageItem,
+      resolvePreparedImageItem
+    ]
+  );
+  const downloadItem = useCallback4(
+    async (item, prepared) => {
+      let url = prepared?.metadata.downloadUrl || item.downloadUrl || item.publicUrl || item.url;
+      if (!isDirectStorageItem(item) && item.objectName && !prepared?.metadata.downloadUrl) {
+        const ticket = await api.createDownloadTicket(
+          item.bucketName || bucketName,
+          item.objectName,
+          item.name
+        );
+        url = typeof ticket === "string" ? ticket : ticket?.downloadUrl || ticket?.relayUrl || ticket?.url || url;
+      }
+      if (url && typeof window !== "undefined") window.location.assign(url);
+    },
+    [api, bucketName]
+  );
+  const previewHost = imagePreview.open || dialogPreview ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx5(
+      Image3.PreviewGroup,
+      {
+        items: imagePreview.items.map((item) => ({ src: item.src, alt: item.name })),
+        preview: {
+          open: imagePreview.open,
+          current: imagePreview.current,
+          onChange: (current) => setImagePreview((value) => ({ ...value, current })),
+          onOpenChange: (open) => {
+            if (!open) closeImagePreview();
+          },
+          countRender: (current, total) => `${current}/${total}`
+        },
+        children: /* @__PURE__ */ jsx5("span", { "aria-hidden": "true", style: { display: "none" } })
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      FilePreviewDialog,
+      {
+        preview: dialogPreview,
+        request: api.request,
+        onClose: () => setDialogPreview(null),
+        onDownload: () => {
+          if (dialogPreview) void downloadItem(dialogPreview.item, dialogPreview);
+        }
+      }
+    )
+  ] }) : null;
+  return {
+    canPreview,
+    getCapability,
+    openPreview,
+    openingKey,
+    isOpening: (item) => {
+      const index = Math.max(items.indexOf(item), 0);
+      return openingKey === getPreviewItemKey(item, index);
+    },
+    downloadItem,
+    previewHost
+  };
+};
+var FilePreviewDialog = ({
+  preview,
+  request,
+  onClose,
+  onDownload
+}) => {
+  const metadata = preview?.metadata;
+  const title = metadata?.fileName || preview?.item.name || "\u9644\u4EF6\u9884\u89C8";
+  return /* @__PURE__ */ jsx5(
+    Modal,
+    {
+      open: Boolean(preview),
+      title: /* @__PURE__ */ jsxs3("div", { style: { minWidth: 0, paddingRight: 16 }, children: [
+        /* @__PURE__ */ jsx5(Typography3.Text, { strong: true, ellipsis: true, style: { display: "block" }, children: title }),
+        metadata ? /* @__PURE__ */ jsxs3(Typography3.Text, { type: "secondary", style: { fontSize: 12 }, children: [
+          (metadata.extension || "FILE").toUpperCase(),
+          " \xB7 ",
+          formatPreviewFileSize(metadata.size)
+        ] }) : null
+      ] }),
+      width: "min(96vw, 1440px)",
+      centered: true,
+      destroyOnHidden: true,
+      mask: { closable: false },
+      closeIcon: /* @__PURE__ */ jsx5(CloseOutlined, {}),
+      onCancel: onClose,
+      styles: {
+        body: {
+          height: "min(78vh, 900px)",
+          minHeight: 360,
+          padding: 0,
+          overflow: "hidden",
+          border: "1px solid #e5e7eb"
+        }
+      },
+      footer: /* @__PURE__ */ jsxs3("div", { style: { display: "flex", justifyContent: "flex-end", gap: 8 }, children: [
+        /* @__PURE__ */ jsx5(Button3, { onClick: onClose, children: "\u5173\u95ED" }),
+        metadata?.canDownload !== false ? /* @__PURE__ */ jsx5(Button3, { type: "primary", icon: /* @__PURE__ */ jsx5(DownloadOutlined3, {}), onClick: onDownload, children: "\u4E0B\u8F7D" }) : null
+      ] }),
+      children: preview && metadata ? /* @__PURE__ */ jsx5(
+        FilePreviewContent,
+        {
+          metadata,
+          request,
+          onDownload
+        }
+      ) : /* @__PURE__ */ jsx5("div", { style: { height: "100%", display: "grid", placeItems: "center" }, children: /* @__PURE__ */ jsx5(Spin3, { description: "\u6B63\u5728\u51C6\u5907\u9884\u89C8..." }) })
+    }
+  );
+};
+
+// packages/sdk/src/components/fields/shared/FileDisplay.tsx
+import {
+  AudioOutlined,
+  CloseOutlined as CloseOutlined2,
+  DownloadOutlined as DownloadOutlined4,
+  EyeOutlined,
+  FileExcelOutlined,
+  FileImageOutlined,
+  FileOutlined as FileOutlined3,
+  FilePdfOutlined,
+  FilePptOutlined,
+  FileTextOutlined,
+  FileUnknownOutlined,
+  FileWordOutlined,
+  FileZipOutlined,
+  PaperClipOutlined,
+  PlusOutlined,
+  UploadOutlined,
+  VideoCameraOutlined
+} from "@ant-design/icons";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function FileTypeIcon({
+  item,
+  className
+}) {
+  const category = getFileCategory(item.name, item.contentType);
+  const extension = getFileExtension(item.name);
+  const icon = category === "image" ? /* @__PURE__ */ jsx6(FileImageOutlined, {}) : category === "video" ? /* @__PURE__ */ jsx6(VideoCameraOutlined, {}) : category === "audio" ? /* @__PURE__ */ jsx6(AudioOutlined, {}) : category === "pdf" ? /* @__PURE__ */ jsx6(FilePdfOutlined, {}) : category === "excel" ? /* @__PURE__ */ jsx6(FileExcelOutlined, {}) : category === "word" ? /* @__PURE__ */ jsx6(FileWordOutlined, {}) : category === "ppt" ? /* @__PURE__ */ jsx6(FilePptOutlined, {}) : category === "archive" ? /* @__PURE__ */ jsx6(FileZipOutlined, {}) : category === "text" || category === "code" ? /* @__PURE__ */ jsx6(FileTextOutlined, {}) : extension ? /* @__PURE__ */ jsx6(FileOutlined3, {}) : /* @__PURE__ */ jsx6(FileUnknownOutlined, {});
+  return /* @__PURE__ */ jsxs4("span", { className: `sy-file-icon sy-file-icon-${category} ${className || ""}`, "aria-hidden": "true", children: [
+    icon,
+    category !== "image" && extension ? /* @__PURE__ */ jsx6("span", { children: extension.toUpperCase() }) : null
+  ] });
+}
+function FileActionButton({
+  type,
+  disabled,
+  onClick,
+  testId
+}) {
+  const label = type === "preview" ? "\u9884\u89C8" : type === "download" ? "\u4E0B\u8F7D" : "\u5220\u9664";
+  const icon = type === "preview" ? /* @__PURE__ */ jsx6(EyeOutlined, {}) : type === "download" ? /* @__PURE__ */ jsx6(DownloadOutlined4, {}) : /* @__PURE__ */ jsx6(CloseOutlined2, {});
+  return /* @__PURE__ */ jsxs4(
+    "button",
+    {
+      type: "button",
+      className: `sy-file-action sy-file-action-${type}`,
+      disabled,
+      onClick,
+      "data-testid": testId,
+      "aria-label": label,
+      title: label,
+      children: [
+        icon,
+        /* @__PURE__ */ jsx6("span", { className: "sy-sr-only", children: label })
+      ]
+    }
+  );
+}
+function FileStatusText({
+  item,
+  showFileSize = true,
+  showFileTypeBadge = true
+}) {
+  const extension = getFileExtension(item.name);
+  const text = item.status === "uploading" ? `\u4E0A\u4F20\u4E2D ${Math.round(item.percent ?? 0)}%` : item.status === "error" ? item.error || "\u4E0A\u4F20\u5931\u8D25" : [
+    showFileTypeBadge && extension ? extension.toUpperCase() : "",
+    showFileSize ? formatFileSize(item.size) : ""
+  ].filter(Boolean).join(" \xB7 ") || "\u5DF2\u4E0A\u4F20";
+  return /* @__PURE__ */ jsx6("span", { className: "sy-file-sub", children: text });
+}
+
+// packages/sdk/src/runtime/react/filePreview.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var EMPTY_ITEMS = [];
+var normalizeMethod2 = (method) => {
+  const value = String(method || "get").toLowerCase();
+  return ["get", "post", "put", "delete", "patch"].includes(value) ? value : "get";
+};
+var normalizeHeaders = (headers) => {
+  if (!headers) return void 0;
+  return Object.fromEntries(new Headers(headers).entries());
+};
+var toPageRequest = (config) => ({
+  path: config.url,
+  method: normalizeMethod2(config.method),
+  query: config.params,
+  body: config.data,
+  headers: normalizeHeaders(config.headers)
+});
+var toRuntimeResponse = (response) => {
+  if (response.raw && typeof response.raw === "object") {
+    return response.raw;
+  }
+  return {
+    code: Number(response.code) || 200,
+    success: response.success,
+    message: response.message,
+    data: response.result,
+    result: response.result
+  };
+};
+var unwrapPageResult = (response) => response.result ?? response.data ?? null;
+var createPageFileRuntimeApi = (sdk) => {
+  const request = async (config) => {
+    const options = toPageRequest(config);
+    if (config.responseType === "blob") {
+      const response = await sdk.transport.download(options);
+      return response.blob;
+    }
+    return toRuntimeResponse(await sdk.transport.request(options));
+  };
+  return createFormRuntimeApi({
+    request,
+    createFileAccessTicket: async (bucketName, objectName, fileName, purpose = "preview", options = {}) => unwrapPageResult(
+      await sdk.createFileAccessTicket(
+        bucketName,
+        objectName,
+        fileName,
+        purpose,
+        options
+      )
+    ),
+    createDownloadTicket: async (bucketName, objectName, fileName) => unwrapPageResult(
+      await sdk.request({
+        path: "/file/download-ticket",
+        method: "post",
+        body: { bucketName, objectName, fileName }
+      })
+    )
+  });
+};
+var useFilePreview = ({
+  items = EMPTY_ITEMS,
+  appType,
+  bucketName = "attachments",
+  enabled = true,
+  requireServerCapability = true
+}) => {
+  const sdk = usePageSdk();
+  const api = useMemo6(() => createPageFileRuntimeApi(sdk), [sdk]);
+  const preview = useFilePreviewController({
+    items,
+    api,
+    appType: appType || sdk.context.app.appType,
+    bucketName,
+    enabled,
+    requireServerCapability
+  });
+  return {
+    canPreview: preview.canPreview,
+    getCapability: preview.getCapability,
+    open: preview.openPreview,
+    download: preview.downloadItem,
+    isOpening: preview.isOpening,
+    openingKey: preview.openingKey,
+    host: preview.previewHost
+  };
+};
+var AttachmentPreviewList = ({
+  items = EMPTY_ITEMS,
+  appType,
+  bucketName = "attachments",
+  showPreview = true,
+  showDownload = true,
+  showFileSize = true,
+  showFileTypeBadge = false,
+  emptyText = "\u6682\u65E0\u9644\u4EF6",
+  className
+}) => {
+  const preview = useFilePreview({
+    items,
+    appType,
+    bucketName,
+    enabled: showPreview,
+    requireServerCapability: true
+  });
+  if (!items.length) {
+    return /* @__PURE__ */ jsx7(Empty3, { description: emptyText, className });
+  }
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: ["sy-readonly-files", "sy-readonly-attachments", className].filter(Boolean).join(" "),
+      "data-testid": "openxiangda-attachment-preview-list",
+      children: [
+        /* @__PURE__ */ jsx7("div", { className: "sy-file-list", children: items.map((item, index) => {
+          const key = getPreviewItemKey(item, index);
+          const canAct = item.status !== "uploading" && item.status !== "error";
+          const canDownload = preview.getCapability(item)?.canDownload !== false;
+          return /* @__PURE__ */ jsxs5("div", { className: "sy-file-item", children: [
+            /* @__PURE__ */ jsx7(FileTypeIcon, { item }),
+            /* @__PURE__ */ jsxs5("div", { className: "sy-file-meta", children: [
+              /* @__PURE__ */ jsx7("span", { className: "sy-file-name", title: item.name, children: item.name || "\u672A\u547D\u540D\u9644\u4EF6" }),
+              /* @__PURE__ */ jsx7(
+                FileStatusText,
+                {
+                  item,
+                  showFileSize,
+                  showFileTypeBadge
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs5("div", { className: "sy-file-actions", children: [
+              showPreview && preview.canPreview(item) ? /* @__PURE__ */ jsx7(
+                FileActionButton,
+                {
+                  type: "preview",
+                  disabled: !canAct || preview.isOpening(item),
+                  onClick: () => void preview.open(item),
+                  testId: `attachment-preview-${key}`
+                }
+              ) : null,
+              showDownload && canDownload ? /* @__PURE__ */ jsx7(
+                FileActionButton,
+                {
+                  type: "download",
+                  disabled: !canAct,
+                  onClick: () => void preview.download(item),
+                  testId: `attachment-download-${key}`
+                }
+              ) : null
+            ] })
+          ] }, `${key}-${index}`);
+        }) }),
+        preview.host
+      ]
+    }
+  );
+};
+var PreviewImageThumb = ({ item }) => {
+  const src = item.thumbUrl || item.previewUrl || item.url;
+  const [failed, setFailed] = useState6(false);
+  React6.useEffect(() => setFailed(false), [src]);
+  return src && !failed ? /* @__PURE__ */ jsx7("img", { src, alt: item.name || "\u56FE\u7247", onError: () => setFailed(true) }) : /* @__PURE__ */ jsx7("span", { className: "sy-image-state", children: item.name || "\u56FE\u7247" });
+};
+var ImagePreviewGrid = ({
+  items = EMPTY_ITEMS,
+  appType,
+  bucketName = "images",
+  showPreview = true,
+  showDownload = true,
+  showFileName = true,
+  emptyText = "\u6682\u65E0\u56FE\u7247",
+  className
+}) => {
+  const preview = useFilePreview({
+    items,
+    appType,
+    bucketName,
+    enabled: showPreview,
+    requireServerCapability: true
+  });
+  if (!items.length) {
+    return /* @__PURE__ */ jsx7(Empty3, { description: emptyText, className });
+  }
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: ["sy-readonly-files", "sy-readonly-images", className].filter(Boolean).join(" "),
+      "data-testid": "openxiangda-image-preview-grid",
+      children: [
+        /* @__PURE__ */ jsx7(
+          "div",
+          {
+            className: "sy-mobile-image-grid",
+            style: { gridTemplateColumns: "repeat(auto-fill, minmax(112px, 160px))" },
+            children: items.map((item, index) => {
+              const key = getPreviewItemKey(item, index);
+              const canAct = item.status !== "uploading" && item.status !== "error";
+              const canOpen = showPreview && preview.canPreview(item);
+              const canDownload = preview.getCapability(item)?.canDownload !== false;
+              return /* @__PURE__ */ jsxs5("div", { className: "sy-mobile-image-card", children: [
+                /* @__PURE__ */ jsx7("div", { className: "sy-mobile-image-thumb", children: /* @__PURE__ */ jsx7(
+                  "button",
+                  {
+                    type: "button",
+                    className: "sy-image-preview",
+                    disabled: !canAct || !canOpen || preview.isOpening(item),
+                    onClick: () => void preview.open(item),
+                    "aria-label": `\u9884\u89C8 ${item.name || "\u56FE\u7247"}`,
+                    "data-testid": `image-preview-${key}`,
+                    children: /* @__PURE__ */ jsx7(PreviewImageThumb, { item })
+                  }
+                ) }),
+                /* @__PURE__ */ jsxs5(
+                  "div",
+                  {
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: 6,
+                      minWidth: 0
+                    },
+                    children: [
+                      showFileName ? /* @__PURE__ */ jsx7("div", { className: "sy-mobile-image-name", title: item.name, style: { flex: 1 }, children: item.name || "\u56FE\u7247" }) : /* @__PURE__ */ jsx7("span", { style: { flex: 1 } }),
+                      /* @__PURE__ */ jsxs5("div", { className: "sy-file-actions", children: [
+                        canOpen ? /* @__PURE__ */ jsx7(
+                          FileActionButton,
+                          {
+                            type: "preview",
+                            disabled: !canAct || preview.isOpening(item),
+                            onClick: () => void preview.open(item)
+                          }
+                        ) : null,
+                        showDownload && canDownload ? /* @__PURE__ */ jsx7(
+                          FileActionButton,
+                          {
+                            type: "download",
+                            disabled: !canAct,
+                            onClick: () => void preview.download(item)
+                          }
+                        ) : null
+                      ] })
+                    ]
+                  }
+                )
+              ] }, `${key}-${index}`);
+            })
+          }
+        ),
+        preview.host
+      ]
+    }
+  );
+};
+
 // packages/sdk/src/runtime/react/workflow.tsx
-import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef4, useState as useState7 } from "react";
-import { Form, Input as Input2, Modal as Modal4, Select as Select2 } from "antd";
+import { useCallback as useCallback8, useEffect as useEffect10, useMemo as useMemo12, useRef as useRef5, useState as useState11 } from "react";
+import { Form, Input as Input2, Modal as Modal5, Select as Select2 } from "antd";
 import {
   CheckOutlined,
-  CloseOutlined,
-  ReloadOutlined as ReloadOutlined2,
+  CloseOutlined as CloseOutlined3,
+  ReloadOutlined as ReloadOutlined4,
   RollbackOutlined as RollbackOutlined2,
   SaveOutlined,
   SwapOutlined
 } from "@ant-design/icons";
 
 // packages/sdk/src/components/modules/StickyActionBar.tsx
-import { useEffect as useEffect3, useMemo as useMemo4, useState as useState3 } from "react";
-import { Button, Dropdown, Tooltip } from "antd";
+import { useEffect as useEffect6, useMemo as useMemo7, useState as useState7 } from "react";
+import { Button as Button4, Dropdown, Tooltip as Tooltip2 } from "antd";
 import { MoreOutlined } from "@ant-design/icons";
 
 // packages/sdk/src/components/utils/confirmAction.ts
@@ -2650,7 +5217,7 @@ var confirmAction = (title, content) => {
 };
 
 // packages/sdk/src/components/modules/StickyActionBar.tsx
-import { Fragment as Fragment2, jsx as jsx3, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 var getActionPriority = (action) => {
   const maybePriority = action.priority;
   if (typeof maybePriority === "number") return maybePriority;
@@ -2668,14 +5235,14 @@ var StickyActionBar = ({
   position = "sticky",
   surface = "default"
 }) => {
-  const [isMobile, setIsMobile] = useState3(false);
-  useEffect3(() => {
+  const [isMobile, setIsMobile] = useState7(false);
+  useEffect6(() => {
     const update = () => setIsMobile(typeof window !== "undefined" && window.innerWidth <= 768);
     update();
     window.addEventListener("resize", update);
     return () => window.removeEventListener("resize", update);
   }, []);
-  const visibleActions = useMemo4(
+  const visibleActions = useMemo7(
     () => actions.filter((action) => action.visible !== false).sort((left, right) => getActionPriority(left) - getActionPriority(right)),
     [actions]
   );
@@ -2696,8 +5263,8 @@ var StickyActionBar = ({
     action.onClick();
   };
   const renderButton = (action, mobile = false) => {
-    const button = /* @__PURE__ */ jsx3(
-      Button,
+    const button = /* @__PURE__ */ jsx8(
+      Button4,
       {
         type: action.type === "danger" ? "primary" : action.type === "text" ? "text" : action.type || "default",
         danger: action.type === "danger",
@@ -2711,16 +5278,16 @@ var StickyActionBar = ({
       action.key
     );
     if (!action.disabled || !action.disabledReason) return button;
-    return /* @__PURE__ */ jsx3(Tooltip, { title: action.disabledReason, children: /* @__PURE__ */ jsx3("span", { className: mobile ? "flex min-w-0 flex-1" : "inline-flex", children: button }) }, action.key);
+    return /* @__PURE__ */ jsx8(Tooltip2, { title: action.disabledReason, children: /* @__PURE__ */ jsx8("span", { className: mobile ? "flex min-w-0 flex-1" : "inline-flex", children: button }) }, action.key);
   };
-  return /* @__PURE__ */ jsx3("div", { className: `${positionClass} z-20 ${spacingClass} ${surfaceClass} ${className}`, children: /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx8("div", { className: `${positionClass} z-20 ${spacingClass} ${surfaceClass} ${className}`, children: /* @__PURE__ */ jsx8(
     "div",
     {
       className: `mx-auto flex w-full items-center gap-3 ${!isMobile ? desktopJustifyClass : "justify-end"}`,
       style: { maxWidth: maxWidthStyle },
-      children: isMobile ? /* @__PURE__ */ jsxs(Fragment2, { children: [
-        /* @__PURE__ */ jsx3("div", { className: "flex flex-1 gap-2", children: primaryMobile.map((action) => renderButton(action, true)) }),
-        moreMobile.length > 0 && /* @__PURE__ */ jsx3(
+      children: isMobile ? /* @__PURE__ */ jsxs6(Fragment3, { children: [
+        /* @__PURE__ */ jsx8("div", { className: "flex flex-1 gap-2", children: primaryMobile.map((action) => renderButton(action, true)) }),
+        moreMobile.length > 0 && /* @__PURE__ */ jsx8(
           Dropdown,
           {
             trigger: ["click"],
@@ -2735,16 +5302,16 @@ var StickyActionBar = ({
                 onClick: () => runAction(action)
               }))
             },
-            children: /* @__PURE__ */ jsx3(Button, { icon: /* @__PURE__ */ jsx3(MoreOutlined, {}), className: "rounded-md", children: "\u66F4\u591A" })
+            children: /* @__PURE__ */ jsx8(Button4, { icon: /* @__PURE__ */ jsx8(MoreOutlined, {}), className: "rounded-md", children: "\u66F4\u591A" })
           }
         )
-      ] }) : layoutMode === "approval" ? /* @__PURE__ */ jsx3("div", { className: "flex flex-wrap items-center justify-center gap-3", children: visibleActions.map((action) => renderButton(action)) }) : /* @__PURE__ */ jsx3("div", { className: `flex flex-wrap items-center ${desktopJustifyClass} gap-3`, children: visibleActions.map((action) => renderButton(action)) })
+      ] }) : layoutMode === "approval" ? /* @__PURE__ */ jsx8("div", { className: "flex flex-wrap items-center justify-center gap-3", children: visibleActions.map((action) => renderButton(action)) }) : /* @__PURE__ */ jsx8("div", { className: `flex flex-wrap items-center ${desktopJustifyClass} gap-3`, children: visibleActions.map((action) => renderButton(action)) })
     }
   ) });
 };
 
 // packages/sdk/src/components/modules/ApprovalTimeline.tsx
-import { useMemo as useMemo5 } from "react";
+import { useMemo as useMemo8 } from "react";
 import {
   ApiOutlined,
   CheckCircleFilled,
@@ -2753,10 +5320,10 @@ import {
   CodeOutlined,
   CopyOutlined,
   EditOutlined,
-  FileTextOutlined,
+  FileTextOutlined as FileTextOutlined2,
   LoadingOutlined,
   NotificationOutlined,
-  ReloadOutlined,
+  ReloadOutlined as ReloadOutlined3,
   RollbackOutlined,
   UserOutlined
 } from "@ant-design/icons";
@@ -2775,7 +5342,7 @@ var TASK_STATUS_META = {
 };
 
 // packages/sdk/src/components/modules/ApprovalTimeline.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var systemNodeTypes = /* @__PURE__ */ new Set([
   "condition",
   "condition_branch",
@@ -2869,37 +5436,37 @@ function getStatusMeta(task, state, compact) {
 }
 function getIcon(task, state) {
   if (state === "current")
-    return task.nodeType === "callback_wait" ? /* @__PURE__ */ jsx4(ClockCircleOutlined, {}) : /* @__PURE__ */ jsx4(LoadingOutlined, {});
+    return task.nodeType === "callback_wait" ? /* @__PURE__ */ jsx9(ClockCircleOutlined, {}) : /* @__PURE__ */ jsx9(LoadingOutlined, {});
   if (state === "future" || state === "waiting")
-    return task.nodeType === "approval" ? /* @__PURE__ */ jsx4(UserOutlined, {}) : /* @__PURE__ */ jsx4(ClockCircleOutlined, {});
-  if (state === "rejected") return /* @__PURE__ */ jsx4(CloseCircleFilled, {});
-  if (state === "returned") return /* @__PURE__ */ jsx4(RollbackOutlined, {});
+    return task.nodeType === "approval" ? /* @__PURE__ */ jsx9(UserOutlined, {}) : /* @__PURE__ */ jsx9(ClockCircleOutlined, {});
+  if (state === "rejected") return /* @__PURE__ */ jsx9(CloseCircleFilled, {});
+  if (state === "returned") return /* @__PURE__ */ jsx9(RollbackOutlined, {});
   switch (task.nodeType) {
     case "start":
-      return /* @__PURE__ */ jsx4(FileTextOutlined, {});
+      return /* @__PURE__ */ jsx9(FileTextOutlined2, {});
     case "approval":
-      return /* @__PURE__ */ jsx4(CheckCircleFilled, {});
+      return /* @__PURE__ */ jsx9(CheckCircleFilled, {});
     case "originator_return":
-      return /* @__PURE__ */ jsx4(EditOutlined, {});
+      return /* @__PURE__ */ jsx9(EditOutlined, {});
     case "copy":
-      return /* @__PURE__ */ jsx4(CopyOutlined, {});
+      return /* @__PURE__ */ jsx9(CopyOutlined, {});
     case "callback_wait":
-      return /* @__PURE__ */ jsx4(ClockCircleOutlined, {});
+      return /* @__PURE__ */ jsx9(ClockCircleOutlined, {});
     case "js_code":
-      return /* @__PURE__ */ jsx4(CodeOutlined, {});
+      return /* @__PURE__ */ jsx9(CodeOutlined, {});
     case "connector_call":
-      return /* @__PURE__ */ jsx4(ApiOutlined, {});
+      return /* @__PURE__ */ jsx9(ApiOutlined, {});
     case "work_notification":
     case "dingtalk_card":
-      return /* @__PURE__ */ jsx4(NotificationOutlined, {});
+      return /* @__PURE__ */ jsx9(NotificationOutlined, {});
     case "data_retrieve_single":
     case "data_retrieve_batch":
     case "data_create":
     case "data_update":
     case "loop_container":
-      return /* @__PURE__ */ jsx4(ReloadOutlined, {});
+      return /* @__PURE__ */ jsx9(ReloadOutlined3, {});
     default:
-      return /* @__PURE__ */ jsx4(CheckCircleFilled, {});
+      return /* @__PURE__ */ jsx9(CheckCircleFilled, {});
   }
 }
 function getDotClass(state) {
@@ -2922,21 +5489,21 @@ var ApprovalTimeline = ({
   compactMode = false,
   showApproverInfo = true
 }) => {
-  const taskList = useMemo5(() => Array.isArray(tasks) ? tasks : [], [tasks]);
-  const groups = useMemo5(() => groupTasks(taskList), [taskList]);
+  const taskList = useMemo8(() => Array.isArray(tasks) ? tasks : [], [tasks]);
+  const groups = useMemo8(() => groupTasks(taskList), [taskList]);
   if (taskList.length === 0) {
-    return /* @__PURE__ */ jsx4(
+    return /* @__PURE__ */ jsx9(
       "div",
       {
         className: `rounded-lg border border-ant-border-secondary bg-ant-bg-container p-6 ${className}`,
-        children: /* @__PURE__ */ jsx4("p", { className: "m-0 text-center text-sm text-ant-text-tertiary", children: "\u6682\u65E0\u5BA1\u6279\u8BB0\u5F55" })
+        children: /* @__PURE__ */ jsx9("p", { className: "m-0 text-center text-sm text-ant-text-tertiary", children: "\u6682\u65E0\u5BA1\u6279\u8BB0\u5F55" })
       }
     );
   }
   if (renderNode) {
-    return /* @__PURE__ */ jsx4("div", { className, children: taskList.map((task, index) => /* @__PURE__ */ jsx4("div", { children: renderNode(task, index) }, task.taskId || task.id || index)) });
+    return /* @__PURE__ */ jsx9("div", { className, children: taskList.map((task, index) => /* @__PURE__ */ jsx9("div", { children: renderNode(task, index) }, task.taskId || task.id || index)) });
   }
-  return /* @__PURE__ */ jsx4("div", { className: `approval-timeline ${className}`, children: groups.map((group, index) => {
+  return /* @__PURE__ */ jsx9("div", { className: `approval-timeline ${className}`, children: groups.map((group, index) => {
     const node = group[0];
     const isLast = index === groups.length - 1;
     const isFutureGroup = group.some((task) => task.isSimulated || task.status === "simulated");
@@ -2945,62 +5512,62 @@ var ApprovalTimeline = ({
     const statusMeta = getStatusMeta(node, state, compact);
     const title = getNodeTitle(node);
     const time = node.actionAt || node.createdAt;
-    return /* @__PURE__ */ jsxs2(
+    return /* @__PURE__ */ jsxs7(
       "div",
       {
         className: `relative flex gap-4 pb-5 ${isLast ? "pb-0" : ""}`,
         children: [
-          !isLast && /* @__PURE__ */ jsx4(
+          !isLast && /* @__PURE__ */ jsx9(
             "div",
             {
               className: `absolute bottom-0 left-[21px] top-11 w-px ${state === "future" ? "border-l border-dashed border-gray-300" : "bg-ant-border-secondary"}`
             }
           ),
-          /* @__PURE__ */ jsx4(
+          /* @__PURE__ */ jsx9(
             "div",
             {
               className: `relative z-10 flex h-11 w-11 shrink-0 items-center justify-center rounded-full border-2 shadow-[0_0_0_4px_var(--ant-color-bg-layout,#f5f5f5)] ${getDotClass(state)}`,
               children: getIcon(node, state)
             }
           ),
-          /* @__PURE__ */ jsx4("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ jsxs2(
+          /* @__PURE__ */ jsx9("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ jsxs7(
             "div",
             {
               className: `rounded-lg border p-4 ${state === "current" ? "border-blue-300 bg-blue-50/60" : state === "future" ? "border-dashed border-gray-200 bg-gray-50/70" : "border-ant-border-secondary bg-ant-bg-container"}`,
               children: [
-                /* @__PURE__ */ jsxs2("div", { className: "flex flex-wrap items-start justify-between gap-2", children: [
-                  /* @__PURE__ */ jsxs2("div", { className: "flex min-w-0 flex-wrap items-center gap-2", children: [
-                    /* @__PURE__ */ jsx4("span", { className: "font-medium text-ant-text", children: title }),
-                    /* @__PURE__ */ jsx4(
+                /* @__PURE__ */ jsxs7("div", { className: "flex flex-wrap items-start justify-between gap-2", children: [
+                  /* @__PURE__ */ jsxs7("div", { className: "flex min-w-0 flex-wrap items-center gap-2", children: [
+                    /* @__PURE__ */ jsx9("span", { className: "font-medium text-ant-text", children: title }),
+                    /* @__PURE__ */ jsx9(
                       "span",
                       {
                         className: `inline-flex min-h-6 items-center rounded-md border px-2 text-xs font-medium ${state === "future" ? toneClasses.future : toneClasses[statusMeta.tone]}`,
                         children: statusMeta.label
                       }
                     ),
-                    node.nodeType === "originator_return" && /* @__PURE__ */ jsx4("span", { className: "rounded-md bg-amber-50 px-2 py-1 text-xs text-amber-700", children: "\u53D1\u8D77\u4EBA\u64CD\u4F5C" })
+                    node.nodeType === "originator_return" && /* @__PURE__ */ jsx9("span", { className: "rounded-md bg-amber-50 px-2 py-1 text-xs text-amber-700", children: "\u53D1\u8D77\u4EBA\u64CD\u4F5C" })
                   ] }),
-                  !isFutureGroup && time && /* @__PURE__ */ jsx4("span", { className: "text-xs text-ant-text-tertiary", children: time })
+                  !isFutureGroup && time && /* @__PURE__ */ jsx9("span", { className: "text-xs text-ant-text-tertiary", children: time })
                 ] }),
-                showApproverInfo && !compact && group.length > 0 && /* @__PURE__ */ jsxs2("div", { className: "mt-3 flex flex-wrap gap-3", children: [
-                  /* @__PURE__ */ jsx4("span", { className: "w-full text-xs font-medium text-ant-text-tertiary", children: state === "current" || state === "waiting" ? "\u5F53\u524D\u5BA1\u6279\u4EBA" : "\u5904\u7406\u4EBA" }),
-                  group.map((assignee) => /* @__PURE__ */ jsxs2(
+                showApproverInfo && !compact && group.length > 0 && /* @__PURE__ */ jsxs7("div", { className: "mt-3 flex flex-wrap gap-3", children: [
+                  /* @__PURE__ */ jsx9("span", { className: "w-full text-xs font-medium text-ant-text-tertiary", children: state === "current" || state === "waiting" ? "\u5F53\u524D\u5BA1\u6279\u4EBA" : "\u5904\u7406\u4EBA" }),
+                  group.map((assignee) => /* @__PURE__ */ jsxs7(
                     "span",
                     {
                       className: "inline-flex min-w-0 items-center gap-2",
                       children: [
-                        /* @__PURE__ */ jsx4("span", { className: "inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-blue-50 text-xs font-semibold text-blue-700", children: assignee.assigneeName?.slice(0, 1) || "?" }),
-                        /* @__PURE__ */ jsxs2("span", { className: "min-w-0", children: [
-                          /* @__PURE__ */ jsx4("span", { className: "block text-sm font-medium text-ant-text", children: assignee.assigneeName || "\u7CFB\u7EDF" }),
-                          /* @__PURE__ */ jsx4("span", { className: "block text-xs text-ant-text-tertiary", children: assignee.departmentName || assignee.actionAt || assignee.createdAt || "" })
+                        /* @__PURE__ */ jsx9("span", { className: "inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-blue-50 text-xs font-semibold text-blue-700", children: assignee.assigneeName?.slice(0, 1) || "?" }),
+                        /* @__PURE__ */ jsxs7("span", { className: "min-w-0", children: [
+                          /* @__PURE__ */ jsx9("span", { className: "block text-sm font-medium text-ant-text", children: assignee.assigneeName || "\u7CFB\u7EDF" }),
+                          /* @__PURE__ */ jsx9("span", { className: "block text-xs text-ant-text-tertiary", children: assignee.departmentName || assignee.actionAt || assignee.createdAt || "" })
                         ] })
                       ]
                     },
                     assignee.taskId || assignee.id
                   ))
                 ] }),
-                showApproverInfo && compact && /* @__PURE__ */ jsx4("div", { className: "mt-2 text-sm text-ant-text-secondary", children: group.map((item) => item.assigneeName).filter(Boolean).join("\u3001") || (node.nodeType === "start" ? "\u63D0\u4EA4\u7533\u8BF7" : systemNodeTypes.has(node.nodeType) ? node.comments || "\u7CFB\u7EDF\u81EA\u52A8\u5904\u7406" : "") }),
-                showRemarks && node.comments && /* @__PURE__ */ jsx4(
+                showApproverInfo && compact && /* @__PURE__ */ jsx9("div", { className: "mt-2 text-sm text-ant-text-secondary", children: group.map((item) => item.assigneeName).filter(Boolean).join("\u3001") || (node.nodeType === "start" ? "\u63D0\u4EA4\u7533\u8BF7" : systemNodeTypes.has(node.nodeType) ? node.comments || "\u7CFB\u7EDF\u81EA\u52A8\u5904\u7406" : "") }),
+                showRemarks && node.comments && /* @__PURE__ */ jsx9(
                   "div",
                   {
                     className: `mt-3 border-l-2 pl-3 text-sm leading-6 ${state === "rejected" ? "border-red-300 text-red-700" : state === "returned" ? "border-amber-300 text-amber-700" : "border-ant-border-secondary text-ant-text-secondary"}`,
@@ -3018,9 +5585,9 @@ var ApprovalTimeline = ({
 };
 
 // packages/sdk/src/components/modules/ProcessPreview.tsx
-import { Modal, Skeleton, Button as Button2 } from "antd";
+import { Modal as Modal2, Skeleton, Button as Button5 } from "antd";
 import { CheckCircleOutlined, UserOutlined as UserOutlined2 } from "@ant-design/icons";
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 var ProcessPreview = ({
   open,
   onClose,
@@ -3029,30 +5596,30 @@ var ProcessPreview = ({
   loading = false
 }) => {
   const routeList = Array.isArray(routes) ? routes : [];
-  return /* @__PURE__ */ jsx5(
-    Modal,
+  return /* @__PURE__ */ jsx10(
+    Modal2,
     {
       getContainer: false,
       title: "\u6D41\u7A0B\u9884\u89C8",
       open,
       onCancel: onClose,
       width: 520,
-      footer: /* @__PURE__ */ jsxs3("div", { className: "flex justify-end gap-3", children: [
-        /* @__PURE__ */ jsx5(Button2, { onClick: onClose, children: "\u53D6\u6D88" }),
-        /* @__PURE__ */ jsx5(Button2, { type: "primary", onClick: onConfirm, loading, children: "\u786E\u8BA4\u63D0\u4EA4" })
+      footer: /* @__PURE__ */ jsxs8("div", { className: "flex justify-end gap-3", children: [
+        /* @__PURE__ */ jsx10(Button5, { onClick: onClose, children: "\u53D6\u6D88" }),
+        /* @__PURE__ */ jsx10(Button5, { type: "primary", onClick: onConfirm, loading, children: "\u786E\u8BA4\u63D0\u4EA4" })
       ] }),
-      children: loading && routeList.length === 0 ? /* @__PURE__ */ jsx5(Skeleton, { active: true, paragraph: { rows: 4 } }) : routeList.length === 0 ? /* @__PURE__ */ jsx5("p", { className: "text-sm text-gray-400 text-center py-8", children: "\u6682\u65E0\u6D41\u7A0B\u8282\u70B9" }) : /* @__PURE__ */ jsx5("div", { className: "py-2", children: routeList.map((route, index) => {
+      children: loading && routeList.length === 0 ? /* @__PURE__ */ jsx10(Skeleton, { active: true, paragraph: { rows: 4 } }) : routeList.length === 0 ? /* @__PURE__ */ jsx10("p", { className: "text-sm text-gray-400 text-center py-8", children: "\u6682\u65E0\u6D41\u7A0B\u8282\u70B9" }) : /* @__PURE__ */ jsx10("div", { className: "py-2", children: routeList.map((route, index) => {
         const isLast = index === routeList.length - 1;
-        return /* @__PURE__ */ jsxs3("div", { className: "flex gap-3", children: [
-          /* @__PURE__ */ jsxs3("div", { className: "flex flex-col items-center", children: [
-            /* @__PURE__ */ jsx5("div", { className: "w-6 h-6 rounded-full bg-blue-50 border-2 border-blue-400 flex items-center justify-center flex-shrink-0", children: /* @__PURE__ */ jsx5(CheckCircleOutlined, { className: "text-blue-500 text-xs" }) }),
-            !isLast && /* @__PURE__ */ jsx5("div", { className: "w-0.5 flex-1 bg-blue-200 mt-1" })
+        return /* @__PURE__ */ jsxs8("div", { className: "flex gap-3", children: [
+          /* @__PURE__ */ jsxs8("div", { className: "flex flex-col items-center", children: [
+            /* @__PURE__ */ jsx10("div", { className: "w-6 h-6 rounded-full bg-blue-50 border-2 border-blue-400 flex items-center justify-center flex-shrink-0", children: /* @__PURE__ */ jsx10(CheckCircleOutlined, { className: "text-blue-500 text-xs" }) }),
+            !isLast && /* @__PURE__ */ jsx10("div", { className: "w-0.5 flex-1 bg-blue-200 mt-1" })
           ] }),
-          /* @__PURE__ */ jsxs3("div", { className: `flex-1 ${isLast ? "pb-0" : "pb-5"}`, children: [
-            /* @__PURE__ */ jsx5("div", { className: "text-sm font-medium text-gray-900", children: route.nodeName }),
-            route.assignees && route.assignees.length > 0 && /* @__PURE__ */ jsxs3("div", { className: "mt-1 flex items-center gap-1.5 flex-wrap", children: [
-              /* @__PURE__ */ jsx5(UserOutlined2, { className: "text-gray-400 text-xs" }),
-              route.assignees.map((assignee) => /* @__PURE__ */ jsx5(
+          /* @__PURE__ */ jsxs8("div", { className: `flex-1 ${isLast ? "pb-0" : "pb-5"}`, children: [
+            /* @__PURE__ */ jsx10("div", { className: "text-sm font-medium text-gray-900", children: route.nodeName }),
+            route.assignees && route.assignees.length > 0 && /* @__PURE__ */ jsxs8("div", { className: "mt-1 flex items-center gap-1.5 flex-wrap", children: [
+              /* @__PURE__ */ jsx10(UserOutlined2, { className: "text-gray-400 text-xs" }),
+              route.assignees.map((assignee) => /* @__PURE__ */ jsx10(
                 "span",
                 {
                   className: "text-xs text-gray-500 bg-gray-100 px-1.5 py-0.5 rounded",
@@ -3069,20 +5636,20 @@ var ProcessPreview = ({
 };
 
 // packages/sdk/src/components/modules/InitiatorApproverSelector.tsx
-import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo8, useRef as useRef3, useState as useState6 } from "react";
-import { Button as Button4, Empty as Empty2, Modal as Modal3, Select, Space as Space2, Tag as Tag2, Typography, message as message2 } from "antd";
+import { useCallback as useCallback7, useEffect as useEffect9, useMemo as useMemo11, useRef as useRef4, useState as useState10 } from "react";
+import { Button as Button7, Empty as Empty5, Modal as Modal4, Select, Space as Space2, Tag as Tag3, Typography as Typography4, message as message2 } from "antd";
 
 // packages/sdk/src/components/core/processApi.ts
 var hasOwn2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 var isRuntimeEnvelope = (value) => !!value && typeof value === "object" && !Array.isArray(value) && (hasOwn2(value, "code") || hasOwn2(value, "success") || hasOwn2(value, "data") || hasOwn2(value, "result") || hasOwn2(value, "message") || hasOwn2(value, "error"));
-var isSuccessCode2 = (code) => {
+var isSuccessCode3 = (code) => {
   if (code === void 0 || code === null || code === "") return true;
   const normalized = Number(code);
   return Number.isFinite(normalized) ? normalized === 0 || normalized === 200 : false;
 };
 var unwrapRuntimeResponse = (response) => {
   if (!isRuntimeEnvelope(response)) return response;
-  if (response.success === false || !isSuccessCode2(response.code)) {
+  if (response.success === false || !isSuccessCode3(response.code)) {
     throw new Error(response.message || response.error || "\u8BF7\u6C42\u5931\u8D25");
   }
   if (hasOwn2(response, "data")) return response.data;
@@ -3114,88 +5681,26 @@ async function getInitiatorSelectCandidates(request, params) {
 }
 
 // packages/sdk/src/components/fields/shared/UserPicker.tsx
-import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo7, useState as useState5 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect8, useMemo as useMemo10, useState as useState9 } from "react";
 import {
   Avatar,
-  Button as Button3,
+  Button as Button6,
   Checkbox,
-  Empty,
+  Empty as Empty4,
   Input,
   List,
-  Modal as Modal2,
+  Modal as Modal3,
   Pagination,
   Space,
-  Spin,
-  Tag,
+  Spin as Spin4,
+  Tag as Tag2,
   Tree
 } from "antd";
 import { SearchOutlined, TeamOutlined, UserOutlined as UserOutlined3 } from "@ant-design/icons";
 import * as MobileAntd from "antd-mobile";
 
-// packages/sdk/src/components/fields/shared/fieldFormat.ts
-function getUserId(user) {
-  if (typeof user === "string" || typeof user === "number") return String(user).trim();
-  return String(user?.id || user?.userId || user?.userid || user?.value || user?.key || "").trim();
-}
-function getUserName(user) {
-  if (typeof user === "string" || typeof user === "number") return String(user).trim();
-  return String(
-    user?.name || user?.label || user?.title || user?.username || user?.nickname || getUserId(user)
-  );
-}
-function normalizeUser(user) {
-  const id = getUserId(user);
-  const source = typeof user === "object" && user !== null ? user : {};
-  return {
-    ...source,
-    id,
-    name: getUserName({ ...source, id })
-  };
-}
-function getDepartmentId(node) {
-  if (typeof node === "string" || typeof node === "number") return String(node).trim();
-  return String(
-    node?.id || node?.departmentId || node?.deptId || node?.value || node?.key || ""
-  ).trim();
-}
-function getDepartmentName(node) {
-  if (typeof node === "string" || typeof node === "number") return String(node).trim();
-  return String(
-    node?.name || node?.label || node?.title || node?.deptName || node?.departmentName || getDepartmentId(node)
-  );
-}
-function normalizeDepartmentNode(node) {
-  const id = getDepartmentId(node);
-  const source = typeof node === "object" && node !== null ? node : {};
-  const name = getDepartmentName({ ...source, id });
-  const hasChildren = typeof node?.hasChildren === "boolean" ? node.hasChildren : Array.isArray(node?.children) && node.children.length > 0;
-  const children = Array.isArray(node?.children) ? node.children.map((child) => normalizeDepartmentNode(child)) : void 0;
-  return {
-    ...source,
-    id,
-    name,
-    key: String(node?.key || id),
-    title: String(node?.title || name),
-    hasChildren,
-    isLeaf: typeof node?.isLeaf === "boolean" ? node.isLeaf : !hasChildren,
-    children
-  };
-}
-function flattenDepartments(nodes) {
-  const result = [];
-  const walk = (items) => {
-    for (const node of items) {
-      const id = getDepartmentId(node);
-      if (id) result.push({ id, name: getDepartmentName(node), node });
-      if (node.children?.length) walk(node.children);
-    }
-  };
-  walk(nodes);
-  return result;
-}
-
 // packages/sdk/src/components/fields/shared/useLazyDepartmentTree.ts
-import { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo6, useRef as useRef2, useState as useState4 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef3, useState as useState8 } from "react";
 var toLazyNode = (node) => {
   const normalized = normalizeDepartmentNode(node);
   const id = getDepartmentId(normalized);
@@ -3245,15 +5750,15 @@ function buildIndexes(nodes) {
   return { nodeMap, parentMap, flatNodes };
 }
 function useLazyDepartmentTree(api, configuredTreeData) {
-  const [treeData, setTreeDataState] = useState4(
+  const [treeData, setTreeDataState] = useState8(
     () => (configuredTreeData || []).map(toLazyNode)
   );
-  const [treeLoading, setTreeLoading] = useState4(false);
-  const treeDataRef = useRef2(treeData);
-  const rootsLoadedRef = useRef2(Boolean(configuredTreeData?.length));
-  const rootPromiseRef = useRef2(null);
-  const childPromiseRef = useRef2({});
-  const setTreeData = useCallback3(
+  const [treeLoading, setTreeLoading] = useState8(false);
+  const treeDataRef = useRef3(treeData);
+  const rootsLoadedRef = useRef3(Boolean(configuredTreeData?.length));
+  const rootPromiseRef = useRef3(null);
+  const childPromiseRef = useRef3({});
+  const setTreeData = useCallback5(
     (next) => {
       const resolved = typeof next === "function" ? next(treeDataRef.current) : next;
       treeDataRef.current = resolved;
@@ -3262,13 +5767,13 @@ function useLazyDepartmentTree(api, configuredTreeData) {
     },
     []
   );
-  useEffect4(() => {
+  useEffect7(() => {
     if (!configuredTreeData) return;
     const next = configuredTreeData.map(toLazyNode);
     rootsLoadedRef.current = next.length > 0;
     setTreeData(next);
   }, [configuredTreeData, setTreeData]);
-  const loadRootDepartments = useCallback3(async () => {
+  const loadRootDepartments = useCallback5(async () => {
     if (rootsLoadedRef.current) return treeDataRef.current;
     if (rootPromiseRef.current) return rootPromiseRef.current;
     setTreeLoading(true);
@@ -3284,7 +5789,7 @@ function useLazyDepartmentTree(api, configuredTreeData) {
     rootPromiseRef.current = promise;
     return promise;
   }, [api, setTreeData]);
-  const loadChildren = useCallback3(
+  const loadChildren = useCallback5(
     async (parentId) => {
       const id = String(parentId || "");
       if (!id) return [];
@@ -3305,8 +5810,8 @@ function useLazyDepartmentTree(api, configuredTreeData) {
     },
     [api, setTreeData]
   );
-  const indexes = useMemo6(() => buildIndexes(treeData), [treeData]);
-  useEffect4(() => {
+  const indexes = useMemo9(() => buildIndexes(treeData), [treeData]);
+  useEffect7(() => {
     void loadRootDepartments();
   }, [loadRootDepartments]);
   return {
@@ -3319,7 +5824,7 @@ function useLazyDepartmentTree(api, configuredTreeData) {
 }
 
 // packages/sdk/src/components/fields/shared/UserPicker.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 var DEFAULT_MEMBER_PAGE_SIZE = 10;
 var getMobileComponent = (name) => {
   try {
@@ -3351,24 +5856,24 @@ function UserPickerPanel({
     flatNodes,
     loadChildren
   } = useLazyDepartmentTree(api, treeData);
-  const [departmentKeyword, setDepartmentKeyword] = useState5("");
-  const [memberKeyword, setMemberKeyword] = useState5("");
-  const [mobileKeyword, setMobileKeyword] = useState5("");
-  const [currentDeptId, setCurrentDeptId] = useState5("");
-  const [expandedKeys, setExpandedKeys] = useState5([]);
-  const [members, setMembers] = useState5(() => normalizeUsers(dataSource));
-  const [memberPage, setMemberPage] = useState5(1);
-  const [memberPageSize, setMemberPageSize] = useState5(DEFAULT_MEMBER_PAGE_SIZE);
-  const [memberTotal, setMemberTotal] = useState5(() => normalizeUsers(dataSource).length);
-  const [memberReloadKey, setMemberReloadKey] = useState5(0);
-  const [loading, setLoading] = useState5(false);
-  const [selected, setSelected] = useState5(() => normalizeUsers(value));
+  const [departmentKeyword, setDepartmentKeyword] = useState9("");
+  const [memberKeyword, setMemberKeyword] = useState9("");
+  const [mobileKeyword, setMobileKeyword] = useState9("");
+  const [currentDeptId, setCurrentDeptId] = useState9("");
+  const [expandedKeys, setExpandedKeys] = useState9([]);
+  const [members, setMembers] = useState9(() => normalizeUsers(dataSource));
+  const [memberPage, setMemberPage] = useState9(1);
+  const [memberPageSize, setMemberPageSize] = useState9(DEFAULT_MEMBER_PAGE_SIZE);
+  const [memberTotal, setMemberTotal] = useState9(() => normalizeUsers(dataSource).length);
+  const [memberReloadKey, setMemberReloadKey] = useState9(0);
+  const [loading, setLoading] = useState9(false);
+  const [selected, setSelected] = useState9(() => normalizeUsers(value));
   const selectedIds = selected.map(getUserId);
   const MobileSearchBar = getMobileComponent("SearchBar");
   const activeMemberKeyword = (mobile ? mobileKeyword : memberKeyword).trim();
-  const staticUsers = useMemo7(() => normalizeUsers(dataSource), [dataSource]);
+  const staticUsers = useMemo10(() => normalizeUsers(dataSource), [dataSource]);
   const hasStaticUserSource = staticUsers.length > 0;
-  useEffect5(() => {
+  useEffect8(() => {
     if (mobile) return;
     if (currentDeptId || deptTreeData.length === 0) return;
     setExpandedKeys(deptTreeData.map((node) => getDepartmentId(node)));
@@ -3376,17 +5881,17 @@ function UserPickerPanel({
       setCurrentDeptId(getDepartmentId(deptTreeData[0]));
     }
   }, [currentDeptId, deptTreeData, loadAllWhenNoDepartment, mobile]);
-  useEffect5(() => {
+  useEffect8(() => {
     setMemberPage(1);
   }, [activeMemberKeyword, currentDeptId, dataSource, mobile]);
-  const handleDepartmentSelect = useCallback4((deptId) => {
+  const handleDepartmentSelect = useCallback6((deptId) => {
     const nextDeptId = String(deptId || "");
     setCurrentDeptId(nextDeptId);
     setMemberKeyword("");
     setMemberPage(1);
     setMemberReloadKey((current) => current + 1);
   }, []);
-  useEffect5(() => {
+  useEffect8(() => {
     let active = true;
     const keyword = activeMemberKeyword;
     if (hasStaticUserSource) {
@@ -3459,7 +5964,7 @@ function UserPickerPanel({
     memberReloadKey,
     staticUsers
   ]);
-  const currentPath = useMemo7(() => {
+  const currentPath = useMemo10(() => {
     if (!currentDeptId) return [];
     const path = [];
     let cursor = currentDeptId;
@@ -3471,7 +5976,7 @@ function UserPickerPanel({
     }
     return path;
   }, [currentDeptId, nodeMap, parentMap]);
-  const mobileDepartments = useMemo7(() => {
+  const mobileDepartments = useMemo10(() => {
     const keyword = mobileKeyword.trim().toLowerCase();
     if (keyword) {
       return flatNodes.filter((item) => item.name.toLowerCase().includes(keyword)).map((item) => item.node);
@@ -3493,19 +5998,19 @@ function UserPickerPanel({
     }
     setSelected(checked ? [normalized] : []);
   };
-  const renderSelected = () => /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker-selected", children: [
-    /* @__PURE__ */ jsxs4("div", { className: "sy-org-picker-selected-head", children: [
-      /* @__PURE__ */ jsxs4("span", { children: [
+  const renderSelected = () => /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker-selected", children: [
+    /* @__PURE__ */ jsxs9("div", { className: "sy-org-picker-selected-head", children: [
+      /* @__PURE__ */ jsxs9("span", { children: [
         "\u5DF2\u9009 ",
         selected.length,
         " \u4EBA"
       ] }),
-      /* @__PURE__ */ jsx6("button", { type: "button", onClick: () => setSelected([]), disabled: !selected.length, children: "\u6E05\u7A7A" })
+      /* @__PURE__ */ jsx11("button", { type: "button", onClick: () => setSelected([]), disabled: !selected.length, children: "\u6E05\u7A7A" })
     ] }),
-    selected.length ? /* @__PURE__ */ jsx6("div", { className: "sy-org-picker-tags", children: selected.map((item) => /* @__PURE__ */ jsx6(Tag, { closable: true, onClose: () => toggleUser(item, false), children: getUserName(item) }, getUserId(item))) }) : /* @__PURE__ */ jsx6(Empty, { image: Empty.PRESENTED_IMAGE_SIMPLE, description: "\u6682\u65E0\u9009\u62E9" })
+    selected.length ? /* @__PURE__ */ jsx11("div", { className: "sy-org-picker-tags", children: selected.map((item) => /* @__PURE__ */ jsx11(Tag2, { closable: true, onClose: () => toggleUser(item, false), children: getUserName(item) }, getUserId(item))) }) : /* @__PURE__ */ jsx11(Empty4, { image: Empty4.PRESENTED_IMAGE_SIMPLE, description: "\u6682\u65E0\u9009\u62E9" })
   ] });
-  const renderMemberList = () => /* @__PURE__ */ jsx6("div", { className: "sy-user-picker-member-panel", children: /* @__PURE__ */ jsxs4(Spin, { spinning: loading, wrapperClassName: "sy-user-picker-member-spin", children: [
-    /* @__PURE__ */ jsx6("div", { className: "sy-user-picker-list", children: /* @__PURE__ */ jsx6(
+  const renderMemberList = () => /* @__PURE__ */ jsx11("div", { className: "sy-user-picker-member-panel", children: /* @__PURE__ */ jsxs9(Spin4, { spinning: loading, wrapperClassName: "sy-user-picker-member-spin", children: [
+    /* @__PURE__ */ jsx11("div", { className: "sy-user-picker-list", children: /* @__PURE__ */ jsx11(
       List,
       {
         dataSource: members,
@@ -3513,27 +6018,27 @@ function UserPickerPanel({
         renderItem: (user) => {
           const id = getUserId(user);
           const checked = selectedIds.includes(id);
-          return /* @__PURE__ */ jsx6(List.Item, { children: /* @__PURE__ */ jsxs4("label", { className: "sy-user-picker-row", children: [
-            /* @__PURE__ */ jsx6(
+          return /* @__PURE__ */ jsx11(List.Item, { children: /* @__PURE__ */ jsxs9("label", { className: "sy-user-picker-row", children: [
+            /* @__PURE__ */ jsx11(
               Checkbox,
               {
                 checked,
                 onChange: (event) => toggleUser(user, event.target.checked)
               }
             ),
-            /* @__PURE__ */ jsx6(Avatar, { size: 36, src: user.avatar, icon: !user.avatar && /* @__PURE__ */ jsx6(UserOutlined3, {}) }),
-            /* @__PURE__ */ jsx6("span", { children: getUserName(user) })
+            /* @__PURE__ */ jsx11(Avatar, { size: 36, src: user.avatar, icon: !user.avatar && /* @__PURE__ */ jsx11(UserOutlined3, {}) }),
+            /* @__PURE__ */ jsx11("span", { children: getUserName(user) })
           ] }) }, id);
         }
       }
     ) }),
-    /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker-pagination", children: [
-      /* @__PURE__ */ jsxs4("span", { children: [
+    /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker-pagination", children: [
+      /* @__PURE__ */ jsxs9("span", { children: [
         "\u5171 ",
         memberTotal,
         " \u4EBA"
       ] }),
-      /* @__PURE__ */ jsx6(
+      /* @__PURE__ */ jsx11(
         Pagination,
         {
           size: "small",
@@ -3551,35 +6056,35 @@ function UserPickerPanel({
     ] })
   ] }) });
   if (mobile) {
-    return /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker sy-user-picker-mobile", children: [
-      /* @__PURE__ */ jsxs4("div", { className: "sy-org-picker-mobile-head", children: [
-        /* @__PURE__ */ jsx6("button", { type: "button", onClick: onCancel, children: "\u53D6\u6D88" }),
-        /* @__PURE__ */ jsx6("strong", { children: "\u9009\u62E9\u6210\u5458" }),
-        /* @__PURE__ */ jsx6("button", { type: "button", onClick: () => onConfirm(selected), children: "\u786E\u5B9A" })
+    return /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker sy-user-picker-mobile", children: [
+      /* @__PURE__ */ jsxs9("div", { className: "sy-org-picker-mobile-head", children: [
+        /* @__PURE__ */ jsx11("button", { type: "button", onClick: onCancel, children: "\u53D6\u6D88" }),
+        /* @__PURE__ */ jsx11("strong", { children: "\u9009\u62E9\u6210\u5458" }),
+        /* @__PURE__ */ jsx11("button", { type: "button", onClick: () => onConfirm(selected), children: "\u786E\u5B9A" })
       ] }),
-      MobileSearchBar ? /* @__PURE__ */ jsx6(
+      MobileSearchBar ? /* @__PURE__ */ jsx11(
         MobileSearchBar,
         {
           placeholder: "\u641C\u7D22\u90E8\u95E8\u6216\u6210\u5458",
           value: mobileKeyword,
           onChange: setMobileKeyword
         }
-      ) : /* @__PURE__ */ jsx6("input", { value: mobileKeyword, onChange: (event) => setMobileKeyword(event.target.value) }),
-      /* @__PURE__ */ jsxs4("div", { className: "sy-org-picker-breadcrumb", children: [
-        /* @__PURE__ */ jsx6("button", { type: "button", onClick: () => handleDepartmentSelect(""), children: "\u901A\u8BAF\u5F55" }),
-        currentPath.map((item) => /* @__PURE__ */ jsxs4("button", { type: "button", onClick: () => handleDepartmentSelect(item.id), children: [
+      ) : /* @__PURE__ */ jsx11("input", { value: mobileKeyword, onChange: (event) => setMobileKeyword(event.target.value) }),
+      /* @__PURE__ */ jsxs9("div", { className: "sy-org-picker-breadcrumb", children: [
+        /* @__PURE__ */ jsx11("button", { type: "button", onClick: () => handleDepartmentSelect(""), children: "\u901A\u8BAF\u5F55" }),
+        currentPath.map((item) => /* @__PURE__ */ jsxs9("button", { type: "button", onClick: () => handleDepartmentSelect(item.id), children: [
           "/ ",
           item.name
         ] }, item.id))
       ] }),
-      /* @__PURE__ */ jsx6(Spin, { spinning: treeLoading, children: /* @__PURE__ */ jsx6(
+      /* @__PURE__ */ jsx11(Spin4, { spinning: treeLoading, children: /* @__PURE__ */ jsx11(
         List,
         {
           dataSource: mobileDepartments,
           locale: { emptyText: null },
           renderItem: (node) => {
             const id = getDepartmentId(node);
-            return /* @__PURE__ */ jsx6(
+            return /* @__PURE__ */ jsx11(
               List.Item,
               {
                 onClick: async () => {
@@ -3587,7 +6092,7 @@ function UserPickerPanel({
                   handleDepartmentSelect(id);
                   setMobileKeyword("");
                 },
-                children: /* @__PURE__ */ jsx6(List.Item.Meta, { avatar: /* @__PURE__ */ jsx6(TeamOutlined, {}), title: getDepartmentName(node) })
+                children: /* @__PURE__ */ jsx11(List.Item.Meta, { avatar: /* @__PURE__ */ jsx11(TeamOutlined, {}), title: getDepartmentName(node) })
               },
               id
             );
@@ -3602,20 +6107,20 @@ function UserPickerPanel({
   const filteredTreeData = lowerDepartmentKeyword ? deptTreeData.filter(
     (node) => getDepartmentName(node).toLowerCase().includes(lowerDepartmentKeyword)
   ) : deptTreeData;
-  return /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker", children: [
-    /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker-main", children: [
-      /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker-depts", children: [
-        /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker", children: [
+    /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker-main", children: [
+      /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker-depts", children: [
+        /* @__PURE__ */ jsx11(
           Input,
           {
             allowClear: true,
-            prefix: /* @__PURE__ */ jsx6(SearchOutlined, {}),
+            prefix: /* @__PURE__ */ jsx11(SearchOutlined, {}),
             placeholder: "\u641C\u7D22\u90E8\u95E8",
             value: departmentKeyword,
             onChange: (event) => setDepartmentKeyword(event.target.value)
           }
         ),
-        /* @__PURE__ */ jsx6(Spin, { spinning: treeLoading, children: /* @__PURE__ */ jsx6(
+        /* @__PURE__ */ jsx11(Spin4, { spinning: treeLoading, children: /* @__PURE__ */ jsx11(
           Tree,
           {
             selectedKeys: currentDeptId ? [currentDeptId] : [],
@@ -3628,12 +6133,12 @@ function UserPickerPanel({
           }
         ) })
       ] }),
-      /* @__PURE__ */ jsxs4("div", { className: "sy-user-picker-members", children: [
-        displaySearch && /* @__PURE__ */ jsx6(
+      /* @__PURE__ */ jsxs9("div", { className: "sy-user-picker-members", children: [
+        displaySearch && /* @__PURE__ */ jsx11(
           Input,
           {
             allowClear: true,
-            prefix: /* @__PURE__ */ jsx6(SearchOutlined, {}),
+            prefix: /* @__PURE__ */ jsx11(SearchOutlined, {}),
             placeholder: "\u641C\u7D22\u6210\u5458",
             value: memberKeyword,
             onChange: (event) => setMemberKeyword(event.target.value)
@@ -3643,9 +6148,9 @@ function UserPickerPanel({
       ] }),
       renderSelected()
     ] }),
-    /* @__PURE__ */ jsx6("div", { className: "sy-org-picker-footer", children: /* @__PURE__ */ jsxs4(Space, { children: [
-      /* @__PURE__ */ jsx6(Button3, { onClick: onCancel, children: "\u53D6\u6D88" }),
-      /* @__PURE__ */ jsx6(Button3, { type: "primary", onClick: () => onConfirm(selected), children: "\u786E\u5B9A" })
+    /* @__PURE__ */ jsx11("div", { className: "sy-org-picker-footer", children: /* @__PURE__ */ jsxs9(Space, { children: [
+      /* @__PURE__ */ jsx11(Button6, { onClick: onCancel, children: "\u53D6\u6D88" }),
+      /* @__PURE__ */ jsx11(Button6, { type: "primary", onClick: () => onConfirm(selected), children: "\u786E\u5B9A" })
     ] }) })
   ] });
 }
@@ -3660,7 +6165,7 @@ function UserPicker({
     onOpenChange(false);
     onCancel();
   };
-  const panel = /* @__PURE__ */ jsx6(
+  const panel = /* @__PURE__ */ jsx11(
     UserPickerPanel,
     {
       ...panelProps,
@@ -3675,7 +6180,7 @@ function UserPicker({
   if (mobile) {
     const MobilePopup = getMobileComponent("Popup");
     if (!MobilePopup) return open ? panel : null;
-    return /* @__PURE__ */ jsx6(
+    return /* @__PURE__ */ jsx11(
       MobilePopup,
       {
         visible: open,
@@ -3686,8 +6191,8 @@ function UserPicker({
       }
     );
   }
-  return /* @__PURE__ */ jsx6(
-    Modal2,
+  return /* @__PURE__ */ jsx11(
+    Modal3,
     {
       title: "\u9009\u62E9\u6210\u5458",
       open,
@@ -3701,7 +6206,7 @@ function UserPicker({
 }
 
 // packages/sdk/src/components/modules/InitiatorApproverSelector.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var scopeText = {
   all: "\u5168\u90E8\u6210\u5458",
   members: "\u6307\u5B9A\u6210\u5458",
@@ -3735,19 +6240,19 @@ var RequirementSelect = ({
   selectedUsers,
   onChange
 }) => {
-  const [pickerOpen, setPickerOpen] = useState6(false);
-  const initialCandidates = useMemo8(
+  const [pickerOpen, setPickerOpen] = useState10(false);
+  const initialCandidates = useMemo11(
     () => (requirement.candidateUsers || []).map(normalizeCandidate).filter(Boolean),
     [requirement.candidateUsers]
   );
-  const [optionsSource, setOptionsSource] = useState6(initialCandidates);
-  const [loading, setLoading] = useState6(false);
-  useEffect6(() => {
+  const [optionsSource, setOptionsSource] = useState10(initialCandidates);
+  const [loading, setLoading] = useState10(false);
+  useEffect9(() => {
     setOptionsSource(
       (current) => mergeUsers(initialCandidates, mergeUsers(current, selectedUsers))
     );
   }, [initialCandidates, selectedUsers]);
-  const loadCandidates = useCallback5(
+  const loadCandidates = useCallback7(
     async (keyword) => {
       setLoading(true);
       try {
@@ -3785,12 +6290,12 @@ var RequirementSelect = ({
     },
     [api, appType, formUuid, initialCandidates.length, requirement.nodeId, requirement.scope]
   );
-  useEffect6(() => {
+  useEffect9(() => {
     if (requirement.scope !== "all" && open && formUuid && appType && requirement.nodeId) {
       void loadCandidates();
     }
   }, [appType, formUuid, loadCandidates, open, requirement.nodeId, requirement.scope]);
-  const options = useMemo8(
+  const options = useMemo11(
     () => optionsSource.map((user) => ({
       value: user.id,
       label: getUserLabel(user)
@@ -3798,19 +6303,19 @@ var RequirementSelect = ({
     [optionsSource]
   );
   if (requirement.scope === "all") {
-    return /* @__PURE__ */ jsxs5("div", { className: "rounded-lg border border-ant-border-secondary bg-ant-bg-container p-3", children: [
-      /* @__PURE__ */ jsxs5("div", { className: "mb-2 flex items-start justify-between gap-3", children: [
-        /* @__PURE__ */ jsxs5("div", { children: [
-          /* @__PURE__ */ jsx7(Typography.Text, { strong: true, children: requirement.nodeName }),
-          /* @__PURE__ */ jsxs5("div", { className: "mt-1 text-xs text-ant-color-text-tertiary", children: [
+    return /* @__PURE__ */ jsxs10("div", { className: "rounded-lg border border-ant-border-secondary bg-ant-bg-container p-3", children: [
+      /* @__PURE__ */ jsxs10("div", { className: "mb-2 flex items-start justify-between gap-3", children: [
+        /* @__PURE__ */ jsxs10("div", { children: [
+          /* @__PURE__ */ jsx12(Typography4.Text, { strong: true, children: requirement.nodeName }),
+          /* @__PURE__ */ jsxs10("div", { className: "mt-1 text-xs text-ant-color-text-tertiary", children: [
             "\u9009\u62E9\u8303\u56F4\uFF1A",
             scopeText[requirement.scope] || "\u5168\u90E8\u6210\u5458"
           ] })
         ] }),
-        /* @__PURE__ */ jsx7(Button4, { onClick: () => setPickerOpen(true), children: selectedUsers.length > 0 ? "\u91CD\u65B0\u9009\u62E9\u6210\u5458" : "\u9009\u62E9\u6210\u5458" })
+        /* @__PURE__ */ jsx12(Button7, { onClick: () => setPickerOpen(true), children: selectedUsers.length > 0 ? "\u91CD\u65B0\u9009\u62E9\u6210\u5458" : "\u9009\u62E9\u6210\u5458" })
       ] }),
-      selectedUsers.length > 0 ? /* @__PURE__ */ jsx7(Space2, { size: [4, 4], wrap: true, className: "mt-2", children: selectedUsers.map((user) => /* @__PURE__ */ jsx7(Tag2, { children: getUserLabel(user) }, user.id)) }) : /* @__PURE__ */ jsx7(Empty2, { image: Empty2.PRESENTED_IMAGE_SIMPLE, description: "\u8BF7\u4ECE\u7EC4\u7EC7\u67B6\u6784\u9009\u62E9\u6210\u5458" }),
-      /* @__PURE__ */ jsx7(
+      selectedUsers.length > 0 ? /* @__PURE__ */ jsx12(Space2, { size: [4, 4], wrap: true, className: "mt-2", children: selectedUsers.map((user) => /* @__PURE__ */ jsx12(Tag3, { children: getUserLabel(user) }, user.id)) }) : /* @__PURE__ */ jsx12(Empty5, { image: Empty5.PRESENTED_IMAGE_SIMPLE, description: "\u8BF7\u4ECE\u7EC4\u7EC7\u67B6\u6784\u9009\u62E9\u6210\u5458" }),
+      /* @__PURE__ */ jsx12(
         UserPicker,
         {
           api,
@@ -3830,15 +6335,15 @@ var RequirementSelect = ({
       )
     ] });
   }
-  return /* @__PURE__ */ jsxs5("div", { className: "rounded-lg border border-ant-border-secondary bg-ant-bg-container p-3", children: [
-    /* @__PURE__ */ jsxs5("div", { className: "mb-2", children: [
-      /* @__PURE__ */ jsx7(Typography.Text, { strong: true, children: requirement.nodeName }),
-      /* @__PURE__ */ jsxs5("div", { className: "mt-1 text-xs text-ant-color-text-tertiary", children: [
+  return /* @__PURE__ */ jsxs10("div", { className: "rounded-lg border border-ant-border-secondary bg-ant-bg-container p-3", children: [
+    /* @__PURE__ */ jsxs10("div", { className: "mb-2", children: [
+      /* @__PURE__ */ jsx12(Typography4.Text, { strong: true, children: requirement.nodeName }),
+      /* @__PURE__ */ jsxs10("div", { className: "mt-1 text-xs text-ant-color-text-tertiary", children: [
         "\u9009\u62E9\u8303\u56F4\uFF1A",
         scopeText[requirement.scope] || "\u5168\u90E8\u6210\u5458"
       ] })
     ] }),
-    /* @__PURE__ */ jsx7(
+    /* @__PURE__ */ jsx12(
       Select,
       {
         mode: "multiple",
@@ -3850,7 +6355,7 @@ var RequirementSelect = ({
         loading,
         value: selectedUsers.map((user) => user.id),
         options,
-        notFoundContent: loading ? "\u52A0\u8F7D\u4E2D..." : /* @__PURE__ */ jsx7(Empty2, { image: Empty2.PRESENTED_IMAGE_SIMPLE }),
+        notFoundContent: loading ? "\u52A0\u8F7D\u4E2D..." : /* @__PURE__ */ jsx12(Empty5, { image: Empty5.PRESENTED_IMAGE_SIMPLE }),
         onSearch: (keyword) => {
           void loadCandidates(keyword);
         },
@@ -3862,7 +6367,7 @@ var RequirementSelect = ({
         }
       }
     ),
-    selectedUsers.length > 0 ? /* @__PURE__ */ jsx7(Space2, { size: [4, 4], wrap: true, className: "mt-2", children: selectedUsers.map((user) => /* @__PURE__ */ jsx7(Tag2, { children: getUserLabel(user) }, user.id)) }) : null
+    selectedUsers.length > 0 ? /* @__PURE__ */ jsx12(Space2, { size: [4, 4], wrap: true, className: "mt-2", children: selectedUsers.map((user) => /* @__PURE__ */ jsx12(Tag3, { children: getUserLabel(user) }, user.id)) }) : null
   ] });
 };
 var InitiatorApproverSelector = ({
@@ -3875,9 +6380,9 @@ var InitiatorApproverSelector = ({
   onOk,
   onCancel
 }) => {
-  const [selected, setSelected] = useState6({});
-  const wasOpenRef = useRef3(false);
-  useEffect6(() => {
+  const [selected, setSelected] = useState10({});
+  const wasOpenRef = useRef4(false);
+  useEffect9(() => {
     if (open && !wasOpenRef.current) {
       setSelected(value || EMPTY_SELECTED_MAP);
     }
@@ -3886,8 +6391,8 @@ var InitiatorApproverSelector = ({
   const missingNodes = requirements.filter(
     (requirement) => !(selected[requirement.nodeId] || []).length
   );
-  return /* @__PURE__ */ jsx7(
-    Modal3,
+  return /* @__PURE__ */ jsx12(
+    Modal4,
     {
       getContainer: false,
       title: "\u9009\u62E9\u5BA1\u6279\u4EBA",
@@ -3904,7 +6409,7 @@ var InitiatorApproverSelector = ({
         onOk(selected);
       },
       destroyOnHidden: true,
-      children: /* @__PURE__ */ jsx7(Space2, { direction: "vertical", size: 12, className: "w-full", children: requirements.map((requirement) => /* @__PURE__ */ jsx7(
+      children: /* @__PURE__ */ jsx12(Space2, { direction: "vertical", size: 12, className: "w-full", children: requirements.map((requirement) => /* @__PURE__ */ jsx12(
         RequirementSelect,
         {
           open,
@@ -3922,7 +6427,7 @@ var InitiatorApproverSelector = ({
 };
 
 // packages/sdk/src/runtime/react/workflow.tsx
-import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 var getError = (error) => error instanceof Error ? error : new Error(String(error || "\u6D41\u7A0B\u80FD\u529B\u89E3\u6790\u5931\u8D25"));
 var normalizeCapabilities = (value) => {
   const raw = value || {};
@@ -3935,20 +6440,20 @@ var normalizeCapabilities = (value) => {
 function useProcessCapabilities(options) {
   const { enabled = true, refreshKey, onError, ...params } = options;
   const sdk = usePageSdk();
-  const [capabilities, setCapabilities] = useState7(
+  const [capabilities, setCapabilities] = useState11(
     null
   );
-  const [loading, setLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const mountedRef = useRef4(true);
+  const [loading, setLoading] = useState11(false);
+  const [error, setError] = useState11(null);
+  const mountedRef = useRef5(true);
   const paramsKey = JSON.stringify({ ...params, refreshKey });
-  useEffect7(() => {
+  useEffect10(() => {
     mountedRef.current = true;
     return () => {
       mountedRef.current = false;
     };
   }, []);
-  const refresh = useCallback6(async () => {
+  const refresh = useCallback8(async () => {
     if (!enabled) return capabilities;
     setLoading(true);
     setError(null);
@@ -3974,7 +6479,7 @@ function useProcessCapabilities(options) {
       }
     }
   }, [capabilities, enabled, onError, paramsKey, sdk]);
-  useEffect7(() => {
+  useEffect10(() => {
     if (!enabled) return;
     void refresh();
   }, [enabled, paramsKey, refresh]);
@@ -3999,8 +6504,8 @@ var requireValue = (value, message3) => {
 function useProcessActions(options) {
   const { capabilities, formUuid, appType, getFormValues, onActionComplete } = options;
   const sdk = usePageSdk();
-  const [loadingAction, setLoadingAction] = useState7(null);
-  const buildUpdateFormDataJson = useCallback6(
+  const [loadingAction, setLoadingAction] = useState11(null);
+  const buildUpdateFormDataJson = useCallback8(
     (input) => {
       if (input?.updateFormDataJson !== void 0) return input.updateFormDataJson;
       const values = getFormValues?.();
@@ -4008,7 +6513,7 @@ function useProcessActions(options) {
     },
     [getFormValues]
   );
-  const executeOperation = useCallback6(
+  const executeOperation = useCallback8(
     async (operation, input = {}) => {
       if (!operation.enabled) return false;
       setLoadingAction(operation.key);
@@ -4118,7 +6623,7 @@ function useProcessActions(options) {
       sdk
     ]
   );
-  const execute = useCallback6(
+  const execute = useCallback8(
     async (action, input) => {
       const operation = (capabilities?.operations || []).find(
         (item) => item.key === action
@@ -4161,12 +6666,12 @@ var actionTone = (key) => {
   return "default";
 };
 var actionIcon = (key) => {
-  if (key === "startProcess" || key === "approve") return /* @__PURE__ */ jsx8(CheckOutlined, {});
-  if (key === "reject") return /* @__PURE__ */ jsx8(CloseOutlined, {});
-  if (key === "transfer" || key === "adminTransfer") return /* @__PURE__ */ jsx8(SwapOutlined, {});
-  if (key === "return" || key === "withdraw") return /* @__PURE__ */ jsx8(RollbackOutlined2, {});
-  if (key === "save") return /* @__PURE__ */ jsx8(SaveOutlined, {});
-  if (key === "retryException" || key === "callback") return /* @__PURE__ */ jsx8(ReloadOutlined2, {});
+  if (key === "startProcess" || key === "approve") return /* @__PURE__ */ jsx13(CheckOutlined, {});
+  if (key === "reject") return /* @__PURE__ */ jsx13(CloseOutlined3, {});
+  if (key === "transfer" || key === "adminTransfer") return /* @__PURE__ */ jsx13(SwapOutlined, {});
+  if (key === "return" || key === "withdraw") return /* @__PURE__ */ jsx13(RollbackOutlined2, {});
+  if (key === "save") return /* @__PURE__ */ jsx13(SaveOutlined, {});
+  if (key === "retryException" || key === "callback") return /* @__PURE__ */ jsx13(ReloadOutlined4, {});
   return void 0;
 };
 var getModalTitle = (key) => {
@@ -4193,7 +6698,7 @@ var ProcessActionBar = ({
   position = "sticky"
 }) => {
   const [form] = Form.useForm();
-  const [activeOperation, setActiveOperation] = useState7(null);
+  const [activeOperation, setActiveOperation] = useState11(null);
   const autoCapabilities = useProcessCapabilities({
     ...capabilityParams || {},
     enabled: Boolean(capabilityParams) && capabilityParams?.enabled !== false
@@ -4228,7 +6733,7 @@ var ProcessActionBar = ({
     }
     void actions.executeOperation(operation);
   };
-  const actionConfigs = useMemo9(
+  const actionConfigs = useMemo12(
     () => operations.map((operation) => ({
       key: operation.key,
       label: operation.label || operation.key,
@@ -4260,8 +6765,8 @@ var ProcessActionBar = ({
       label: String(node.nodeName || node.name || node.label || value)
     };
   });
-  return /* @__PURE__ */ jsxs6(Fragment3, { children: [
-    /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsxs11(Fragment4, { children: [
+    /* @__PURE__ */ jsx13(
       StickyActionBar,
       {
         actions: actionConfigs,
@@ -4273,8 +6778,8 @@ var ProcessActionBar = ({
         position
       }
     ),
-    /* @__PURE__ */ jsx8(
-      Modal4,
+    /* @__PURE__ */ jsx13(
+      Modal5,
       {
         getContainer: false,
         title: modalKey ? getModalTitle(modalKey) : "\u6D41\u7A0B\u64CD\u4F5C",
@@ -4290,26 +6795,26 @@ var ProcessActionBar = ({
           form.resetFields();
         },
         destroyOnHidden: true,
-        children: /* @__PURE__ */ jsxs6(Form, { form, layout: "vertical", children: [
-          (modalKey === "transfer" || modalKey === "adminTransfer") && /* @__PURE__ */ jsx8(
+        children: /* @__PURE__ */ jsxs11(Form, { form, layout: "vertical", children: [
+          (modalKey === "transfer" || modalKey === "adminTransfer") && /* @__PURE__ */ jsx13(
             Form.Item,
             {
               name: "newAssignee",
               label: "\u63A5\u6536\u4EBA",
               rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u63A5\u6536\u4EBA\u7528\u6237ID" }],
-              children: /* @__PURE__ */ jsx8(Input2, { placeholder: "\u8BF7\u8F93\u5165\u7528\u6237ID" })
+              children: /* @__PURE__ */ jsx13(Input2, { placeholder: "\u8BF7\u8F93\u5165\u7528\u6237ID" })
             }
           ),
-          modalKey === "return" && /* @__PURE__ */ jsx8(
+          modalKey === "return" && /* @__PURE__ */ jsx13(
             Form.Item,
             {
               name: "targetNodeId",
               label: "\u9000\u56DE\u8282\u70B9",
               rules: [{ required: true, message: "\u8BF7\u9009\u62E9\u9000\u56DE\u8282\u70B9" }],
-              children: /* @__PURE__ */ jsx8(Select2, { placeholder: "\u8BF7\u9009\u62E9\u9000\u56DE\u8282\u70B9", options: returnOptions })
+              children: /* @__PURE__ */ jsx13(Select2, { placeholder: "\u8BF7\u9009\u62E9\u9000\u56DE\u8282\u70B9", options: returnOptions })
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx13(
             Form.Item,
             {
               name: modalKey === "reject" || modalKey === "resubmit" ? "comments" : "reason",
@@ -4320,7 +6825,7 @@ var ProcessActionBar = ({
                   message: "\u8BF7\u586B\u5199\u8BF4\u660E"
                 }
               ],
-              children: /* @__PURE__ */ jsx8(Input2.TextArea, { rows: 4, maxLength: 500, showCount: true })
+              children: /* @__PURE__ */ jsx13(Input2.TextArea, { rows: 4, maxLength: 500, showCount: true })
             }
           )
         ] })
@@ -4332,7 +6837,7 @@ var ProcessTimeline = ({
   capabilities,
   tasks,
   ...props
-}) => /* @__PURE__ */ jsx8(
+}) => /* @__PURE__ */ jsx13(
   ApprovalTimeline,
   {
     ...props,
@@ -4344,12 +6849,12 @@ var ProcessPreviewPanel = ProcessPreview;
 // packages/sdk/src/runtime/react/openxiangdaProvider.tsx
 import {
   createContext as createContext2,
-  useCallback as useCallback8,
+  useCallback as useCallback10,
   useContext as useContext2,
-  useEffect as useEffect9,
-  useMemo as useMemo11,
-  useRef as useRef5,
-  useState as useState9
+  useEffect as useEffect12,
+  useMemo as useMemo14,
+  useRef as useRef6,
+  useState as useState13
 } from "react";
 
 // packages/sdk/src/runtime/core/fetch.ts
@@ -4386,24 +6891,24 @@ var createBoundFetch = (fetchImpl) => {
 };
 
 // packages/sdk/src/runtime/host/browserHost.ts
-var trimTrailingSlash = (value) => value.replace(/\/+$/, "");
-var getDefaultServicePrefix = () => typeof window !== "undefined" ? trimTrailingSlash(window.__OPENXIANGDA_SERVICE_PREFIX__ || "/service") : "/service";
+var trimTrailingSlash2 = (value) => value.replace(/\/+$/, "");
+var getDefaultServicePrefix = () => typeof window !== "undefined" ? trimTrailingSlash2(window.__OPENXIANGDA_SERVICE_PREFIX__ || "/service") : "/service";
 var joinServicePath = (servicePrefix, path) => {
   if (/^https?:\/\//i.test(path)) return path;
-  const normalizedPrefix = trimTrailingSlash(servicePrefix || "/service");
+  const normalizedPrefix = trimTrailingSlash2(servicePrefix || "/service");
   if (path.startsWith(normalizedPrefix)) return path;
   return `${normalizedPrefix}${path.startsWith("/") ? path : `/${path}`}`;
 };
-var appendQuery = (url, query) => {
+var appendQuery2 = (url, query) => {
   if (!query) return url;
   return `${url}${url.includes("?") ? "&" : "?"}${query}`;
 };
-var normalizeMethod2 = (method) => {
+var normalizeMethod3 = (method) => {
   const value = String(method || "get").toUpperCase();
   return ["GET", "POST", "PUT", "DELETE", "PATCH"].includes(value) ? value : "GET";
 };
 var shouldRetryTransportRequest = (payload) => {
-  const method = normalizeMethod2(payload?.method);
+  const method = normalizeMethod3(payload?.method);
   if (method === "GET") return true;
   const path = String(payload?.path || "").split("?")[0];
   return method === "POST" && path === "/workflow/capabilities/resolve";
@@ -4413,7 +6918,7 @@ var normalizeEnvelopeCode2 = (value, fallback) => {
   const normalized = Number(value);
   return Number.isFinite(normalized) ? normalized : String(value);
 };
-var isSuccessCode3 = (value) => {
+var isSuccessCode4 = (value) => {
   if (value === void 0 || value === null || value === "") return true;
   const normalized = Number(value);
   return Number.isFinite(normalized) ? normalized === 0 || normalized >= 200 && normalized < 300 : false;
@@ -4428,7 +6933,7 @@ var parseJsonResponse = async (response) => {
     const code = normalizeEnvelopeCode2(payload.code, response.status);
     return {
       code,
-      success: payload.success !== false && isSuccessCode3(code),
+      success: payload.success !== false && isSuccessCode4(code),
       message: payload.message,
       result: payload.result ?? payload.data ?? null,
       data: payload.data,
@@ -4451,7 +6956,7 @@ var createBrowserPageBridge = (options = {}) => {
     if (!payload?.path) {
       throw new Error("transport.request \u9700\u8981 path");
     }
-    const url = appendQuery(joinServicePath(servicePrefix, payload.path), payload.query);
+    const url = appendQuery2(joinServicePath(servicePrefix, payload.path), payload.query);
     const headers = new Headers(payload.headers);
     let body;
     if (payload.body !== void 0) {
@@ -4463,7 +6968,7 @@ var createBrowserPageBridge = (options = {}) => {
       }
     }
     const response = await fetchWithTransientRetry(fetchImpl, url, {
-      method: normalizeMethod2(payload.method),
+      method: normalizeMethod3(payload.method),
       headers,
       body,
       credentials: "include"
@@ -4476,7 +6981,7 @@ var createBrowserPageBridge = (options = {}) => {
     if (!payload?.path) {
       throw new Error("transport.download \u9700\u8981 path");
     }
-    const url = appendQuery(joinServicePath(servicePrefix, payload.path), payload.query);
+    const url = appendQuery2(joinServicePath(servicePrefix, payload.path), payload.query);
     const headers = new Headers(payload.headers);
     let body;
     if (payload.body !== void 0) {
@@ -4488,7 +6993,7 @@ var createBrowserPageBridge = (options = {}) => {
       }
     }
     const response = await fetchImpl(url, {
-      method: normalizeMethod2(payload.method),
+      method: normalizeMethod3(payload.method),
       headers,
       body,
       credentials: "include"
@@ -4576,21 +7081,21 @@ var createBrowserPageContext = (bootstrap, options = {}) => {
 
 // packages/sdk/src/runtime/react/auth.tsx
 import {
-  useCallback as useCallback7,
-  useEffect as useEffect8,
-  useMemo as useMemo10,
-  useState as useState8
+  useCallback as useCallback9,
+  useEffect as useEffect11,
+  useMemo as useMemo13,
+  useState as useState12
 } from "react";
 import {
-  Alert,
-  Button as Button5,
+  Alert as Alert4,
+  Button as Button8,
   Card,
-  Empty as Empty3,
+  Empty as Empty6,
   Form as Form2,
   Input as Input3,
   Space as Space3,
-  Tabs,
-  Typography as Typography2
+  Tabs as Tabs2,
+  Typography as Typography5
 } from "antd";
 import {
   LoginOutlined,
@@ -4668,7 +7173,7 @@ var createAuthClient = ({
     const payload = await readPayload(response);
     const code = getRecordValue(payload, "code");
     const success = getRecordValue(payload, "success");
-    if (!response.ok || success === false || !isSuccessCode4(code)) {
+    if (!response.ok || success === false || !isSuccessCode5(code)) {
       throw new AuthClientError(
         String(getRecordValue(payload, "message") || `Auth request failed: ${response.status}`),
         {
@@ -4747,7 +7252,7 @@ var readNumber = (value) => {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : void 0;
 };
-var isSuccessCode4 = (code) => {
+var isSuccessCode5 = (code) => {
   if (code === void 0 || code === null || code === "") return true;
   const normalized = Number(code);
   return Number.isFinite(normalized) ? normalized === 0 || normalized >= 200 && normalized < 300 : false;
@@ -4777,10 +7282,10 @@ var resolveLoginUrl = (appType, {
 var getCurrentHref2 = () => typeof window === "undefined" ? "" : window.location.href;
 
 // packages/sdk/src/runtime/react/auth.tsx
-import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
 var useAuth = (options = {}) => {
   const runtime = useOpenXiangda();
-  const client = useMemo10(
+  const client = useMemo13(
     () => createAuthClient({
       appType: options.appType || runtime.appType,
       servicePrefix: options.servicePrefix || runtime.servicePrefix,
@@ -4795,7 +7300,7 @@ var useAuth = (options = {}) => {
       runtime.servicePrefix
     ]
   );
-  return useMemo10(
+  return useMemo13(
     () => ({
       client,
       getMethods: client.getMethods,
@@ -4815,12 +7320,12 @@ var useAuth = (options = {}) => {
 };
 var useLoginMethods = (options = {}) => {
   const auth = useAuth(options);
-  const [state, setState] = useState8({
+  const [state, setState] = useState12({
     data: null,
     loading: true,
     error: null
   });
-  const reload = useCallback7(async () => {
+  const reload = useCallback9(async () => {
     setState((prev) => ({ ...prev, loading: true, error: null }));
     try {
       const data = await auth.getMethods();
@@ -4833,7 +7338,7 @@ var useLoginMethods = (options = {}) => {
       });
     }
   }, [auth]);
-  useEffect8(() => {
+  useEffect11(() => {
     let disposed = false;
     const run = async () => {
       setState((prev) => ({ ...prev, loading: true, error: null }));
@@ -4877,17 +7382,17 @@ var LoginPage = ({
   const methodsState = useLoginMethods(authOptions);
   const [passwordForm] = Form2.useForm();
   const [phoneForm] = Form2.useForm();
-  const [activeMethod, setActiveMethod] = useState8(
+  const [activeMethod, setActiveMethod] = useState12(
     defaultMethod || "password"
   );
-  const [phonePurpose, setPhonePurpose] = useState8(
+  const [phonePurpose, setPhonePurpose] = useState12(
     "login"
   );
-  const [phoneChallengeId, setPhoneChallengeId] = useState8("");
-  const [passwordChallenge, setPasswordChallenge] = useState8(null);
-  const [submitting, setSubmitting] = useState8(false);
-  const [sendingCode, setSendingCode] = useState8(false);
-  const [error, setError] = useState8(null);
+  const [phoneChallengeId, setPhoneChallengeId] = useState12("");
+  const [passwordChallenge, setPasswordChallenge] = useState12(null);
+  const [submitting, setSubmitting] = useState12(false);
+  const [sendingCode, setSendingCode] = useState12(false);
+  const [error, setError] = useState12(null);
   const methods = methodsState.methods.filter((method) => method.enabled !== false);
   const passwordMethod = findMethod(methods, "password");
   const phoneMethod = findMethod(methods, "phone_code");
@@ -4895,16 +7400,16 @@ var LoginPage = ({
   const ssoMethod = findMethod(methods, "sso");
   const guestMethod = findMethod(methods, "guest");
   const allowRegister = methodsState.data?.registration?.mode !== "reject";
-  const tabItems = useMemo10(() => {
+  const tabItems = useMemo13(() => {
     const items = [];
     if (passwordMethod) {
       items.push({
         key: "password",
-        label: /* @__PURE__ */ jsxs7(Space3, { size: 6, children: [
-          /* @__PURE__ */ jsx9(UserOutlined4, {}),
-          /* @__PURE__ */ jsx9("span", { children: passwordMethod.label || "\u8D26\u53F7\u5BC6\u7801" })
+        label: /* @__PURE__ */ jsxs12(Space3, { size: 6, children: [
+          /* @__PURE__ */ jsx14(UserOutlined4, {}),
+          /* @__PURE__ */ jsx14("span", { children: passwordMethod.label || "\u8D26\u53F7\u5BC6\u7801" })
         ] }),
-        children: /* @__PURE__ */ jsx9(
+        children: /* @__PURE__ */ jsx14(
           PasswordLoginForm,
           {
             challenge: passwordChallenge,
@@ -4946,11 +7451,11 @@ var LoginPage = ({
     if (phoneMethod) {
       items.push({
         key: "phone_code",
-        label: /* @__PURE__ */ jsxs7(Space3, { size: 6, children: [
-          /* @__PURE__ */ jsx9(MobileOutlined, {}),
-          /* @__PURE__ */ jsx9("span", { children: phoneMethod.label || "\u624B\u673A\u53F7" })
+        label: /* @__PURE__ */ jsxs12(Space3, { size: 6, children: [
+          /* @__PURE__ */ jsx14(MobileOutlined, {}),
+          /* @__PURE__ */ jsx14("span", { children: phoneMethod.label || "\u624B\u673A\u53F7" })
         ] }),
-        children: /* @__PURE__ */ jsx9(
+        children: /* @__PURE__ */ jsx14(
           PhoneCodeLoginForm,
           {
             allowRegister,
@@ -5014,7 +7519,7 @@ var LoginPage = ({
     sendingCode,
     submitting
   ]);
-  useEffect8(() => {
+  useEffect11(() => {
     const firstKey = tabItems[0]?.key;
     if (firstKey && !tabItems.some((item) => item.key === activeMethod)) {
       setActiveMethod(firstKey);
@@ -5089,7 +7594,7 @@ var LoginPage = ({
       );
     }
   }
-  return /* @__PURE__ */ jsx9(
+  return /* @__PURE__ */ jsx14(
     "div",
     {
       className,
@@ -5101,7 +7606,7 @@ var LoginPage = ({
         background: "#f6f8fb",
         ...style
       },
-      children: /* @__PURE__ */ jsx9(
+      children: /* @__PURE__ */ jsx14(
         Card,
         {
           style: {
@@ -5110,54 +7615,54 @@ var LoginPage = ({
             boxShadow: "0 16px 48px rgba(15, 23, 42, 0.10)"
           },
           styles: { body: { padding: 28 } },
-          children: /* @__PURE__ */ jsxs7(Space3, { direction: "vertical", size: 20, style: { width: "100%" }, children: [
-            /* @__PURE__ */ jsxs7("div", { children: [
-              /* @__PURE__ */ jsx9(Typography2.Title, { level: 3, style: { margin: 0 }, children: title || "\u5E94\u7528\u767B\u5F55" }),
-              subtitle ? /* @__PURE__ */ jsx9(Typography2.Text, { type: "secondary", children: subtitle }) : null
+          children: /* @__PURE__ */ jsxs12(Space3, { direction: "vertical", size: 20, style: { width: "100%" }, children: [
+            /* @__PURE__ */ jsxs12("div", { children: [
+              /* @__PURE__ */ jsx14(Typography5.Title, { level: 3, style: { margin: 0 }, children: title || "\u5E94\u7528\u767B\u5F55" }),
+              subtitle ? /* @__PURE__ */ jsx14(Typography5.Text, { type: "secondary", children: subtitle }) : null
             ] }),
-            methodsState.error ? /* @__PURE__ */ jsx9(
-              Alert,
+            methodsState.error ? /* @__PURE__ */ jsx14(
+              Alert4,
               {
                 showIcon: true,
                 type: "error",
                 message: methodsState.error.message
               }
             ) : null,
-            error ? /* @__PURE__ */ jsx9(Alert, { showIcon: true, type: "error", message: error }) : null,
-            methodsState.loading ? /* @__PURE__ */ jsx9(Button5, { block: true, loading: true, children: "\u52A0\u8F7D\u4E2D" }) : tabItems.length > 0 ? /* @__PURE__ */ jsx9(
-              Tabs,
+            error ? /* @__PURE__ */ jsx14(Alert4, { showIcon: true, type: "error", message: error }) : null,
+            methodsState.loading ? /* @__PURE__ */ jsx14(Button8, { block: true, loading: true, children: "\u52A0\u8F7D\u4E2D" }) : tabItems.length > 0 ? /* @__PURE__ */ jsx14(
+              Tabs2,
               {
                 activeKey: activeMethod,
                 items: tabItems,
                 onChange: setActiveMethod
               }
-            ) : /* @__PURE__ */ jsx9(Empty3, { description: "\u672A\u542F\u7528\u767B\u5F55\u65B9\u5F0F" }),
-            /* @__PURE__ */ jsxs7(Space3, { direction: "vertical", size: 10, style: { width: "100%" }, children: [
-              dingtalkMethod ? /* @__PURE__ */ jsx9(
-                Button5,
+            ) : /* @__PURE__ */ jsx14(Empty6, { description: "\u672A\u542F\u7528\u767B\u5F55\u65B9\u5F0F" }),
+            /* @__PURE__ */ jsxs12(Space3, { direction: "vertical", size: 10, style: { width: "100%" }, children: [
+              dingtalkMethod ? /* @__PURE__ */ jsx14(
+                Button8,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx9(QrcodeOutlined, {}),
+                  icon: /* @__PURE__ */ jsx14(QrcodeOutlined, {}),
                   loading: submitting,
                   onClick: handleDingTalkLogin,
                   children: dingtalkMethod.label || "\u9489\u9489\u514D\u767B"
                 }
               ) : null,
-              ssoMethod ? /* @__PURE__ */ jsx9(
-                Button5,
+              ssoMethod ? /* @__PURE__ */ jsx14(
+                Button8,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx9(SafetyCertificateOutlined, {}),
+                  icon: /* @__PURE__ */ jsx14(SafetyCertificateOutlined, {}),
                   loading: submitting,
                   onClick: handleSsoLogin,
                   children: ssoMethod.label || "SSO \u767B\u5F55"
                 }
               ) : null,
-              guestMethod ? /* @__PURE__ */ jsx9(
-                Button5,
+              guestMethod ? /* @__PURE__ */ jsx14(
+                Button8,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx9(LoginOutlined, {}),
+                  icon: /* @__PURE__ */ jsx14(LoginOutlined, {}),
                   loading: submitting,
                   onClick: handleGuestLogin,
                   children: guestMethod.label || "\u8BBF\u5BA2\u8BBF\u95EE"
@@ -5170,28 +7675,28 @@ var LoginPage = ({
     }
   );
 };
-var PasswordLoginForm = ({ challenge, form, loading, onFinish }) => /* @__PURE__ */ jsxs7(Form2, { form, layout: "vertical", requiredMark: false, onFinish, children: [
-  /* @__PURE__ */ jsx9(
+var PasswordLoginForm = ({ challenge, form, loading, onFinish }) => /* @__PURE__ */ jsxs12(Form2, { form, layout: "vertical", requiredMark: false, onFinish, children: [
+  /* @__PURE__ */ jsx14(
     Form2.Item,
     {
       label: "\u8D26\u53F7",
       name: "username",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u8D26\u53F7" }],
-      children: /* @__PURE__ */ jsx9(Input3, { autoComplete: "username" })
+      children: /* @__PURE__ */ jsx14(Input3, { autoComplete: "username" })
     }
   ),
-  /* @__PURE__ */ jsx9(
+  /* @__PURE__ */ jsx14(
     Form2.Item,
     {
       label: "\u5BC6\u7801",
       name: "password",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u5BC6\u7801" }],
-      children: /* @__PURE__ */ jsx9(Input3.Password, { autoComplete: "current-password" })
+      children: /* @__PURE__ */ jsx14(Input3.Password, { autoComplete: "current-password" })
     }
   ),
-  challenge ? /* @__PURE__ */ jsxs7(Fragment4, { children: [
-    /* @__PURE__ */ jsx9(
-      Alert,
+  challenge ? /* @__PURE__ */ jsxs12(Fragment5, { children: [
+    /* @__PURE__ */ jsx14(
+      Alert4,
       {
         showIcon: true,
         type: "warning",
@@ -5199,17 +7704,17 @@ var PasswordLoginForm = ({ challenge, form, loading, onFinish }) => /* @__PURE__
         description: readChallengeQuestion(challenge) || "\u8BF7\u8F93\u5165\u9A8C\u8BC1\u7801\u540E\u7EE7\u7EED\u767B\u5F55\u3002"
       }
     ),
-    /* @__PURE__ */ jsx9(
+    /* @__PURE__ */ jsx14(
       Form2.Item,
       {
         label: "\u9A8C\u8BC1\u7B54\u6848",
         name: "challengeAnswer",
         rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u9A8C\u8BC1\u7B54\u6848" }],
-        children: /* @__PURE__ */ jsx9(Input3, { autoComplete: "one-time-code" })
+        children: /* @__PURE__ */ jsx14(Input3, { autoComplete: "one-time-code" })
       }
     )
   ] }) : null,
-  /* @__PURE__ */ jsx9(Button5, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx9(LoginOutlined, {}), loading, type: "primary", children: "\u767B\u5F55" })
+  /* @__PURE__ */ jsx14(Button8, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx14(LoginOutlined, {}), loading, type: "primary", children: "\u767B\u5F55" })
 ] });
 var PhoneCodeLoginForm = ({
   allowRegister,
@@ -5220,9 +7725,9 @@ var PhoneCodeLoginForm = ({
   onPurposeChange,
   onSendCode,
   onFinish
-}) => /* @__PURE__ */ jsxs7(Form2, { form, layout: "vertical", requiredMark: false, onFinish, children: [
-  allowRegister ? /* @__PURE__ */ jsx9(Form2.Item, { style: { marginBottom: 12 }, children: /* @__PURE__ */ jsx9(
-    Tabs,
+}) => /* @__PURE__ */ jsxs12(Form2, { form, layout: "vertical", requiredMark: false, onFinish, children: [
+  allowRegister ? /* @__PURE__ */ jsx14(Form2.Item, { style: { marginBottom: 12 }, children: /* @__PURE__ */ jsx14(
+    Tabs2,
     {
       activeKey: phonePurpose,
       items: [
@@ -5233,26 +7738,26 @@ var PhoneCodeLoginForm = ({
       size: "small"
     }
   ) }) : null,
-  /* @__PURE__ */ jsx9(
+  /* @__PURE__ */ jsx14(
     Form2.Item,
     {
       label: "\u624B\u673A\u53F7",
       name: "phone",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u624B\u673A\u53F7" }],
-      children: /* @__PURE__ */ jsx9(Input3, { autoComplete: "tel" })
+      children: /* @__PURE__ */ jsx14(Input3, { autoComplete: "tel" })
     }
   ),
-  /* @__PURE__ */ jsx9(
+  /* @__PURE__ */ jsx14(
     Form2.Item,
     {
       label: "\u9A8C\u8BC1\u7801",
       name: "code",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u9A8C\u8BC1\u7801" }],
-      children: /* @__PURE__ */ jsx9(
+      children: /* @__PURE__ */ jsx14(
         Input3,
         {
-          addonAfter: /* @__PURE__ */ jsx9(
-            Button5,
+          addonAfter: /* @__PURE__ */ jsx14(
+            Button8,
             {
               loading: sendingCode,
               onClick: onSendCode,
@@ -5266,7 +7771,7 @@ var PhoneCodeLoginForm = ({
       )
     }
   ),
-  /* @__PURE__ */ jsx9(Button5, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx9(MobileOutlined, {}), loading, type: "primary", children: phonePurpose === "register" ? "\u6CE8\u518C" : "\u767B\u5F55" })
+  /* @__PURE__ */ jsx14(Button8, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx14(MobileOutlined, {}), loading, type: "primary", children: phonePurpose === "register" ? "\u6CE8\u518C" : "\u767B\u5F55" })
 ] });
 var findMethod = (methods, type) => methods.find((method) => method.type === type);
 var normalizeError = (error) => error instanceof Error ? error : new Error(String(error || "\u8BF7\u6C42\u5931\u8D25"));
@@ -5343,7 +7848,7 @@ var getCallbackUrl = () => {
 };
 
 // packages/sdk/src/runtime/react/openxiangdaProvider.tsx
-import { Fragment as Fragment5, jsx as jsx10 } from "react/jsx-runtime";
+import { Fragment as Fragment6, jsx as jsx15 } from "react/jsx-runtime";
 var RuntimeHttpError = class extends Error {
   constructor(snapshot) {
     super(snapshot.message);
@@ -5361,19 +7866,19 @@ var OpenXiangdaProvider = ({
   fetchImpl,
   children
 }) => {
-  const resolvedFetch = useMemo11(() => createBoundFetch(fetchImpl), [fetchImpl]);
-  const resolvedAppType = useMemo11(
+  const resolvedFetch = useMemo14(() => createBoundFetch(fetchImpl), [fetchImpl]);
+  const resolvedAppType = useMemo14(
     () => appType || resolveAppTypeFromLocation(),
     [appType]
   );
-  const [, setAccessTokenState] = useState9(null);
-  const [authState, setAuthState] = useState9({
+  const [, setAccessTokenState] = useState13(null);
+  const [authState, setAuthState] = useState13({
     status: "unknown",
     error: null
   });
-  const accessTokenRef = useRef5(null);
-  const refreshRequestRef = useRef5(null);
-  const applyAccessToken = useCallback8(
+  const accessTokenRef = useRef6(null);
+  const refreshRequestRef = useRef6(null);
+  const applyAccessToken = useCallback10(
     (nextAccessToken, options = {}) => {
       if (!nextAccessToken && options.clearIfToken && accessTokenRef.current?.token !== options.clearIfToken) {
         return accessTokenRef.current;
@@ -5391,7 +7896,7 @@ var OpenXiangdaProvider = ({
     },
     []
   );
-  const setAccessToken = useCallback8(
+  const setAccessToken = useCallback10(
     (nextAccessToken, options = {}) => {
       const previousState = accessTokenRef.current;
       const nextState = applyAccessToken(nextAccessToken, options);
@@ -5407,7 +7912,7 @@ var OpenXiangdaProvider = ({
     },
     [applyAccessToken]
   );
-  const markUnauthenticated = useCallback8(
+  const markUnauthenticated = useCallback10(
     (error) => {
       const runtimeError = normalizeRuntimeError(error);
       applyAccessToken(null);
@@ -5415,7 +7920,7 @@ var OpenXiangdaProvider = ({
     },
     [applyAccessToken]
   );
-  const refreshAccessToken = useCallback8(async () => {
+  const refreshAccessToken = useCallback10(async () => {
     if (!resolvedAppType) return null;
     if (!refreshRequestRef.current) {
       setAuthState((prev) => ({ ...prev, status: "refreshing", error: null }));
@@ -5476,7 +7981,7 @@ var OpenXiangdaProvider = ({
     }
     return refreshRequestRef.current;
   }, [applyAccessToken, resolvedAppType, resolvedFetch, servicePrefix]);
-  const authorizedFetch = useMemo11(
+  const authorizedFetch = useMemo14(
     () => createAuthorizedFetch({
       appType: resolvedAppType,
       baseFetch: resolvedFetch,
@@ -5486,18 +7991,18 @@ var OpenXiangdaProvider = ({
     }),
     [markUnauthenticated, refreshAccessToken, resolvedAppType, resolvedFetch]
   );
-  const getAuthHeaders = useCallback8(() => {
+  const getAuthHeaders = useCallback10(() => {
     const state2 = accessTokenRef.current;
     if (!state2) return {};
     const token = resolveAccessTokenForCurrentRoute(state2);
     return token ? { authorization: `Bearer ${token}` } : {};
   }, []);
-  const [state, setState] = useState9({
+  const [state, setState] = useState13({
     data: null,
     loading: true,
     error: null
   });
-  const reload = useCallback8(async (options = {}) => {
+  const reload = useCallback10(async (options = {}) => {
     if (!resolvedAppType) {
       setState({
         data: null,
@@ -5561,10 +8066,10 @@ var OpenXiangdaProvider = ({
       }
     }
   }, [authorizedFetch, resolvedAppType, resolvedFetch, servicePrefix]);
-  useEffect9(() => {
+  useEffect12(() => {
     void reload();
   }, [reload]);
-  const value = useMemo11(
+  const value = useMemo14(
     () => ({
       ...state,
       appType: resolvedAppType,
@@ -5587,7 +8092,7 @@ var OpenXiangdaProvider = ({
       authState
     ]
   );
-  return /* @__PURE__ */ jsx10(OpenXiangdaRuntimeContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx15(OpenXiangdaRuntimeContext.Provider, { value, children });
 };
 var useOpenXiangda = () => {
   const context = useContext2(OpenXiangdaRuntimeContext);
@@ -5607,7 +8112,7 @@ var OpenXiangdaPageProvider = ({
   navigation
 }) => {
   const runtime = useOpenXiangda();
-  const context = useMemo11(() => {
+  const context = useMemo14(() => {
     const bootstrap = runtime.data;
     const app = toRuntimeRecord(bootstrap?.app);
     const user = toRuntimeRecord(bootstrap?.user);
@@ -5687,7 +8192,7 @@ var OpenXiangdaPageProvider = ({
     runtime.fetchImpl,
     runtime.servicePrefix
   ]);
-  return /* @__PURE__ */ jsx10(PageProvider, { context, children });
+  return /* @__PURE__ */ jsx15(PageProvider, { context, children });
 };
 var useAppMenus = () => {
   const runtime = useOpenXiangda();
@@ -5705,12 +8210,12 @@ var usePermission = () => {
 };
 var useCanAccessRoute = (input) => {
   const runtime = useOpenXiangda();
-  const [state, setState] = useState9({
+  const [state, setState] = useState13({
     data: null,
     loading: true,
     error: null
   });
-  useEffect9(() => {
+  useEffect12(() => {
     let disposed = false;
     const check = async () => {
       const permissions = runtime.data?.permissions;
@@ -5832,16 +8337,16 @@ var PermissionBoundary = ({
   const access = useCanAccessRoute({ routeCode, menuCode, path });
   const fallbackState = createPermissionFallbackState(access, runtime);
   if (access.loading) {
-    return /* @__PURE__ */ jsx10(Fragment5, { children: renderBoundaryFallback(loadingFallback, fallbackState) });
+    return /* @__PURE__ */ jsx15(Fragment6, { children: renderBoundaryFallback(loadingFallback, fallbackState) });
   }
   if (!access.canAccess) {
-    return /* @__PURE__ */ jsx10(Fragment5, { children: renderBoundaryFallback(fallback, fallbackState) });
+    return /* @__PURE__ */ jsx15(Fragment6, { children: renderBoundaryFallback(fallback, fallbackState) });
   }
-  return /* @__PURE__ */ jsx10(Fragment5, { children });
+  return /* @__PURE__ */ jsx15(Fragment6, { children });
 };
 var useRuntimeAuth = () => {
   const runtime = useOpenXiangda();
-  const resolveLoginUrl2 = useCallback8(
+  const resolveLoginUrl2 = useCallback10(
     async (options = {}) => {
       const redirectUri = options.redirectUri || getCurrentHref4();
       const domain = options.domain || getCurrentHostname2();
@@ -5888,7 +8393,7 @@ var useRuntimeAuth = () => {
     },
     [runtime.baseFetchImpl, runtime.data?.app, runtime.servicePrefix]
   );
-  const redirectToLogin = useCallback8(
+  const redirectToLogin = useCallback10(
     async (options = {}) => {
       const loginUrl = await resolveLoginUrl2(options);
       if (typeof window !== "undefined") {
@@ -5902,7 +8407,7 @@ var useRuntimeAuth = () => {
     },
     [resolveLoginUrl2]
   );
-  const logout = useCallback8(async () => {
+  const logout = useCallback10(async () => {
     const response = await runtime.baseFetchImpl(
       buildServiceUrl2(runtime.servicePrefix, "/api/auth/logout"),
       {
@@ -5922,7 +8427,7 @@ var useRuntimeAuth = () => {
     runtime.setAccessToken(null);
     return payload;
   }, [runtime.baseFetchImpl, runtime.servicePrefix, runtime.setAccessToken]);
-  const logoutAndRedirect = useCallback8(
+  const logoutAndRedirect = useCallback10(
     async (options = {}) => {
       try {
         await logout();
@@ -5933,7 +8438,7 @@ var useRuntimeAuth = () => {
     },
     [logout, redirectToLogin]
   );
-  return useMemo11(
+  return useMemo14(
     () => ({
       logout,
       logoutAndRedirect,
@@ -5952,7 +8457,7 @@ var RuntimeAuthGuard = ({
 }) => {
   const runtime = useOpenXiangda();
   const auth = useRuntimeAuth();
-  const redirectedRef = useRef5(false);
+  const redirectedRef = useRef6(false);
   const currentPath = getCurrentPathname();
   const excluded = isRuntimeAuthGuardExcluded(
     currentPath,
@@ -5960,7 +8465,7 @@ var RuntimeAuthGuard = ({
     excludedPaths
   );
   const shouldRedirect = !disabled && !excluded && !runtime.loading && (runtime.authState.status === "unauthenticated" || runtime.error?.type === "unauthenticated");
-  useEffect9(() => {
+  useEffect12(() => {
     if (!shouldRedirect || redirectedRef.current) return;
     redirectedRef.current = true;
     void auth.redirectToLogin({
@@ -5977,9 +8482,9 @@ var RuntimeAuthGuard = ({
     redirectOptions.replace,
     shouldRedirect
   ]);
-  if (excluded) return /* @__PURE__ */ jsx10(Fragment5, { children });
-  if (shouldRedirect) return /* @__PURE__ */ jsx10(Fragment5, { children: fallback });
-  return /* @__PURE__ */ jsx10(Fragment5, { children });
+  if (excluded) return /* @__PURE__ */ jsx15(Fragment6, { children });
+  if (shouldRedirect) return /* @__PURE__ */ jsx15(Fragment6, { children: fallback });
+  return /* @__PURE__ */ jsx15(Fragment6, { children });
 };
 var buildServiceUrl2 = (servicePrefix, path) => {
   const prefix = servicePrefix.endsWith("/") ? servicePrefix.slice(0, -1) : servicePrefix;
@@ -6250,7 +8755,7 @@ var buildBrowserRouteInfo = (route) => {
     hash
   };
 };
-var isSuccessCode5 = (code) => {
+var isSuccessCode6 = (code) => {
   if (code === void 0 || code === null || code === "") return true;
   const normalized = Number(code);
   return Number.isFinite(normalized) ? normalized === 0 || normalized >= 200 && normalized < 300 : false;
@@ -6258,7 +8763,7 @@ var isSuccessCode5 = (code) => {
 var isRuntimeEnvelopeFailure = (response, payload) => {
   const code = getRecordValue2(payload, "code");
   const success = getRecordValue2(payload, "success");
-  return !response.ok || success === false || !isSuccessCode5(code);
+  return !response.ok || success === false || !isSuccessCode6(code);
 };
 var isServerErrorCode = (code) => {
   const normalized = Number(code);
@@ -6303,7 +8808,7 @@ var resolveAppTypeFromLocation = () => {
 };
 
 // packages/sdk/src/runtime/react/publicAccess.tsx
-import { useCallback as useCallback9, useEffect as useEffect10, useMemo as useMemo12, useRef as useRef6, useState as useState10 } from "react";
+import { useCallback as useCallback11, useEffect as useEffect13, useMemo as useMemo15, useRef as useRef7, useState as useState14 } from "react";
 
 // packages/sdk/src/runtime/core/publicAccess.ts
 var PublicAccessClientError = class extends Error {
@@ -6353,7 +8858,7 @@ var createPublicAccessClient = ({
     const payload = await readPayload2(response);
     const code = getRecordValue3(payload, "code");
     const success = getRecordValue3(payload, "success");
-    if (!response.ok || success === false || !isSuccessCode6(code)) {
+    if (!response.ok || success === false || !isSuccessCode7(code)) {
       throw new PublicAccessClientError(
         String(
           getRecordValue3(payload, "message") || `Public access session failed: ${response.status}`
@@ -6391,7 +8896,7 @@ var getRecordValue3 = (value, key) => {
   if (!value || typeof value !== "object") return void 0;
   return value[key];
 };
-var isSuccessCode6 = (code) => {
+var isSuccessCode7 = (code) => {
   if (code === void 0 || code === null || code === "") return true;
   const normalized = Number(code);
   return Number.isFinite(normalized) ? normalized === 0 || normalized >= 200 && normalized < 300 : false;
@@ -6419,7 +8924,7 @@ var createRandomIdentifier = (appType) => {
 };
 
 // packages/sdk/src/runtime/react/publicAccess.tsx
-import { Fragment as Fragment6, jsx as jsx11 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx16 } from "react/jsx-runtime";
 var usePublicAccess = (options = {}) => {
   const runtime = useOpenXiangda();
   const {
@@ -6436,14 +8941,14 @@ var usePublicAccess = (options = {}) => {
     autoStart = true,
     ...sessionInput
   } = options;
-  const [session, setSession] = useState10(null);
-  const [error, setError] = useState10(null);
-  const [loading, setLoading] = useState10(Boolean(autoStart));
-  const activeSessionRef = useRef6(null);
-  const mountedRef = useRef6(true);
+  const [session, setSession] = useState14(null);
+  const [error, setError] = useState14(null);
+  const [loading, setLoading] = useState14(Boolean(autoStart));
+  const activeSessionRef = useRef7(null);
+  const mountedRef = useRef7(true);
   const sessionInputKey = JSON.stringify(sessionInput);
-  const stableSessionInput = useMemo12(() => sessionInput, [sessionInputKey]);
-  const client = useMemo12(
+  const stableSessionInput = useMemo15(() => sessionInput, [sessionInputKey]);
+  const client = useMemo15(
     () => createPublicAccessClient({
       appType,
       servicePrefix,
@@ -6451,7 +8956,7 @@ var usePublicAccess = (options = {}) => {
     }),
     [appType, fetchImpl, servicePrefix]
   );
-  const startSession = useCallback9(
+  const startSession = useCallback11(
     async (input = {}) => {
       setLoading(true);
       setError(null);
@@ -6497,11 +9002,11 @@ var usePublicAccess = (options = {}) => {
     },
     [client, reloadRuntime, setAccessToken, stableSessionInput]
   );
-  useEffect10(() => {
+  useEffect13(() => {
     if (!autoStart) return;
     void startSession().catch(() => void 0);
   }, [autoStart, startSession]);
-  useEffect10(
+  useEffect13(
     () => {
       mountedRef.current = true;
       return () => {
@@ -6530,11 +9035,11 @@ var PublicAccessGate = ({
   ...options
 }) => {
   const state = usePublicAccess(options);
-  if (state.loading) return /* @__PURE__ */ jsx11(Fragment6, { children: fallback });
+  if (state.loading) return /* @__PURE__ */ jsx16(Fragment7, { children: fallback });
   if (state.error) {
-    return /* @__PURE__ */ jsx11(Fragment6, { children: typeof errorFallback === "function" ? errorFallback(state.error) : errorFallback });
+    return /* @__PURE__ */ jsx16(Fragment7, { children: typeof errorFallback === "function" ? errorFallback(state.error) : errorFallback });
   }
-  return /* @__PURE__ */ jsx11(Fragment6, { children });
+  return /* @__PURE__ */ jsx16(Fragment7, { children });
 };
 var readTicketFromLocation = () => {
   if (typeof window === "undefined") return void 0;
@@ -6542,7 +9047,9 @@ var readTicketFromLocation = () => {
 };
 var readPathFromLocation = () => typeof window === "undefined" ? void 0 : window.location.pathname;
 export {
+  AttachmentPreviewList,
   AuthClientError,
+  ImagePreviewGrid,
   InitiatorApproverSelector,
   LoginPage,
   OpenXiangdaPageProvider,
@@ -6568,6 +9075,7 @@ export {
   useCanAccessRoute,
   useCurrentUser,
   useDataSource,
+  useFilePreview,
   useFormViewPermissions,
   useLoginMethods,
   useMessage,